jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

makes the -d:nimIncremental compiler mode compile again

Browse source
This commit is contained in:
Andreas Rumpf 2019-07-21 16:41:46 +02:00
commit 25e6c53bb5
5 changed files with 75 additions and 83 deletions
Download patch file Download diff file Expand all files Collapse all files

36
compiler/rodimpl.nim
View file

@ -225,18 +225,13 @@ proc encodeType(g: ModuleGraph, t: PType, result: var string) =
add(result, '\15') add(result, '\15')
encodeVInt(t.destructor.id, result) encodeVInt(t.destructor.id, result)
pushSym(w, t.destructor) pushSym(w, t.destructor)
if t.deepCopy != nil: for a in t.attachedOps:
add(result, '\16') add(result, '\16')
encodeVInt(t.deepcopy.id, result) if a == nil:
pushSym(w, t.deepcopy) encodeVInt(-1, result)
if t.assignment != nil: else:
add(result, '\17') encodeVInt(a.id, result)
encodeVInt(t.assignment.id, result) pushSym(w, a)
pushSym(w, t.assignment)
if t.sink != nil:
add(result, '\18')
encodeVInt(t.sink.id, result)
pushSym(w, t.sink)
for i, s in items(t.methods): for i, s in items(t.methods):
add(result, '\19') add(result, '\19')
encodeVInt(i, result) encodeVInt(i, result)
@ -427,8 +422,10 @@ proc storeRemaining*(g: ModuleGraph; module: PSym) =
stillForwarded.add s stillForwarded.add s
swap w.forwardedSyms, stillForwarded swap w.forwardedSyms, stillForwarded
transitiveClosure(g) transitiveClosure(g)
var nimid = 0
for x in items(g.config.m.fileInfos): for x in items(g.config.m.fileInfos):
storeFilename(g, x.fullPath, FileIndex(nimid)) storeFilename(g, x.fullPath, FileIndex(nimid))
inc nimid
# ---------------- decoder ----------------------------------- # ---------------- decoder -----------------------------------
@ -636,18 +633,13 @@ proc loadType(g; id: int; info: TLineInfo): PType =
else: else:
result.lockLevel = UnspecifiedLockLevel result.lockLevel = UnspecifiedLockLevel
if b.s[b.pos] == '\15': for a in low(result.attachedOps)..high(result.attachedOps):
inc(b.pos)
result.destructor = loadSym(g, decodeVInt(b.s, b.pos), info)
if b.s[b.pos] == '\16': if b.s[b.pos] == '\16':
inc(b.pos) inc(b.pos)
result.deepCopy = loadSym(g, decodeVInt(b.s, b.pos), info) let id = decodeVInt(b.s, b.pos)
if b.s[b.pos] == '\17': if id >= 0:
inc(b.pos) result.attachedOps[a] = loadSym(g, id, info)
result.assignment = loadSym(g, decodeVInt(b.s, b.pos), info)
if b.s[b.pos] == '\18':
inc(b.pos)
result.sink = loadSym(g, decodeVInt(b.s, b.pos), info)
while b.s[b.pos] == '\19': while b.s[b.pos] == '\19':
inc(b.pos) inc(b.pos)
let x = decodeVInt(b.s, b.pos) let x = decodeVInt(b.s, b.pos)
@ -842,7 +834,7 @@ proc replay(g: ModuleGraph; module: PSym; n: PNode) =
of "error": localError(g.config, n.info, errUser, n[1].strVal) of "error": localError(g.config, n.info, errUser, n[1].strVal)
of "compile": of "compile":
internalAssert g.config, n.len == 3 and n[2].kind == nkStrLit internalAssert g.config, n.len == 3 and n[2].kind == nkStrLit
let cname = AbsoluteFile n[1].strVal, let cname = AbsoluteFile n[1].strVal
var cf = Cfile(nimname: splitFile(cname).name, cname: cname, var cf = Cfile(nimname: splitFile(cname).name, cname: cname,
obj: AbsoluteFile n[2].strVal, obj: AbsoluteFile n[2].strVal,
flags: {CfileFlag.External}) flags: {CfileFlag.External})

2
compiler/semdata.nim
View file

@ -11,7 +11,7 @@
import import
intsets, options, ast, astalgo, msgs, idents, renderer, intsets, options, ast, astalgo, msgs, idents, renderer,
magicsys, passes, vmdef, modulegraphs, lineinfos magicsys, vmdef, modulegraphs, lineinfos
type type
TOptionEntry* = object # entries to put on a stack for pragma parsing TOptionEntry* = object # entries to put on a stack for pragma parsing

2
compiler/vmdef.nim
View file

@ -10,7 +10,7 @@
## This module contains the type definitions for the new evaluation engine. ## This module contains the type definitions for the new evaluation engine.
## An instruction is 1-3 int32s in memory, it is a register based VM. ## An instruction is 1-3 int32s in memory, it is a register based VM.
import ast, passes, idents, intsets, options, modulegraphs, lineinfos import ast, idents, intsets, options, modulegraphs, lineinfos
const const
byteExcess* = 128 # we use excess-K for immediates byteExcess* = 128 # we use excess-K for immediates

10
lib/impure/db_sqlite.nim
View file

@ -112,7 +112,7 @@ type
DbConn* = PSqlite3 ## Encapsulates a database connection. DbConn* = PSqlite3 ## Encapsulates a database connection.
Row* = seq[string] ## A row of a dataset. `NULL` database values will be Row* = seq[string] ## A row of a dataset. `NULL` database values will be
## converted to an empty string. ## converted to an empty string.
InstantRow* = Pstmt ## A handle that can be used to get a row's column InstantRow* = PStmt ## A handle that can be used to get a row's column
## text on demand. ## text on demand.
proc dbError*(db: DbConn) {.noreturn.} = proc dbError*(db: DbConn) {.noreturn.} =
@ -169,7 +169,7 @@ proc tryExec*(db: DbConn, query: SqlQuery,
## db.close() ## db.close()
assert(not db.isNil, "Database not connected.") assert(not db.isNil, "Database not connected.")
var q = dbFormat(query, args) var q = dbFormat(query, args)
var stmt: sqlite3.Pstmt var stmt: sqlite3.PStmt
if prepare_v2(db, q, q.len.cint, stmt, nil) == SQLITE_OK: if prepare_v2(db, q, q.len.cint, stmt, nil) == SQLITE_OK:
let x = step(stmt) let x = step(stmt)
if x in {SQLITE_DONE, SQLITE_ROW}: if x in {SQLITE_DONE, SQLITE_ROW}:
@ -198,12 +198,12 @@ proc newRow(L: int): Row =
for i in 0..L-1: result[i] = "" for i in 0..L-1: result[i] = ""
proc setupQuery(db: DbConn, query: SqlQuery, proc setupQuery(db: DbConn, query: SqlQuery,
args: varargs[string]): Pstmt = args: varargs[string]): PStmt =
assert(not db.isNil, "Database not connected.") assert(not db.isNil, "Database not connected.")
var q = dbFormat(query, args) var q = dbFormat(query, args)
if prepare_v2(db, q, q.len.cint, result, nil) != SQLITE_OK: dbError(db) if prepare_v2(db, q, q.len.cint, result, nil) != SQLITE_OK: dbError(db)
proc setRow(stmt: Pstmt, r: var Row, cols: cint) = proc setRow(stmt: PStmt, r: var Row, cols: cint) =
for col in 0'i32..cols-1: for col in 0'i32..cols-1:
setLen(r[col], column_bytes(stmt, col)) # set capacity setLen(r[col], column_bytes(stmt, col)) # set capacity
setLen(r[col], 0) setLen(r[col], 0)
@ -514,7 +514,7 @@ proc tryInsertID*(db: DbConn, query: SqlQuery,
## db.close() ## db.close()
assert(not db.isNil, "Database not connected.") assert(not db.isNil, "Database not connected.")
var q = dbFormat(query, args) var q = dbFormat(query, args)
var stmt: sqlite3.Pstmt var stmt: sqlite3.PStmt
result = -1 result = -1
if prepare_v2(db, q, q.len.cint, stmt, nil) == SQLITE_OK: if prepare_v2(db, q, q.len.cint, stmt, nil) == SQLITE_OK:
if step(stmt) == SQLITE_DONE: if step(stmt) == SQLITE_DONE:

104
lib/wrappers/sqlite3.nim
View file

@ -106,11 +106,11 @@ type
PPSqlite3* = ptr PSqlite3 PPSqlite3* = ptr PSqlite3
Context{.pure, final.} = object Context{.pure, final.} = object
Pcontext* = ptr Context Pcontext* = ptr Context
Tstmt{.pure, final.} = object TStmt{.pure, final.} = object
Pstmt* = ptr Tstmt PStmt* = ptr TStmt
Value{.pure, final.} = object Value{.pure, final.} = object
Pvalue* = ptr Value PValue* = ptr Value
PValueArg* = array[0..127, Pvalue] PValueArg* = array[0..127, PValue]
Callback* = proc (para1: pointer, para2: int32, para3, Callback* = proc (para1: pointer, para2: int32, para3,
para4: cstringArray): int32{.cdecl.} para4: cstringArray): int32{.cdecl.}
@ -186,90 +186,90 @@ proc errcode*(db: PSqlite3): int32{.cdecl, dynlib: Lib, importc: "sqlite3_errcod
proc errmsg*(para1: PSqlite3): cstring{.cdecl, dynlib: Lib, importc: "sqlite3_errmsg".} proc errmsg*(para1: PSqlite3): cstring{.cdecl, dynlib: Lib, importc: "sqlite3_errmsg".}
proc errmsg16*(para1: PSqlite3): pointer{.cdecl, dynlib: Lib, proc errmsg16*(para1: PSqlite3): pointer{.cdecl, dynlib: Lib,
importc: "sqlite3_errmsg16".} importc: "sqlite3_errmsg16".}
proc prepare*(db: PSqlite3, zSql: cstring, nBytes: int32, ppStmt: var Pstmt, proc prepare*(db: PSqlite3, zSql: cstring, nBytes: int32, ppStmt: var PStmt,
pzTail: ptr cstring): int32{.cdecl, dynlib: Lib, pzTail: ptr cstring): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_prepare".} importc: "sqlite3_prepare".}
proc prepare_v2*(db: PSqlite3, zSql: cstring, nByte: cint, ppStmt: var Pstmt, proc prepare_v2*(db: PSqlite3, zSql: cstring, nByte: cint, ppStmt: var PStmt,
pzTail: ptr cstring): cint {. pzTail: ptr cstring): cint {.
importc: "sqlite3_prepare_v2", cdecl, dynlib: Lib.} importc: "sqlite3_prepare_v2", cdecl, dynlib: Lib.}
proc prepare16*(db: PSqlite3, zSql: pointer, nBytes: int32, ppStmt: var Pstmt, proc prepare16*(db: PSqlite3, zSql: pointer, nBytes: int32, ppStmt: var PStmt,
pzTail: var pointer): int32{.cdecl, dynlib: Lib, pzTail: var pointer): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_prepare16".} importc: "sqlite3_prepare16".}
proc bind_blob*(para1: Pstmt, para2: int32, para3: pointer, n: int32, proc bind_blob*(para1: PStmt, para2: int32, para3: pointer, n: int32,
para5: Tbind_destructor_func): int32{.cdecl, dynlib: Lib, para5: Tbind_destructor_func): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_bind_blob".} importc: "sqlite3_bind_blob".}
proc bind_double*(para1: Pstmt, para2: int32, para3: float64): int32{.cdecl, proc bind_double*(para1: PStmt, para2: int32, para3: float64): int32{.cdecl,
dynlib: Lib, importc: "sqlite3_bind_double".} dynlib: Lib, importc: "sqlite3_bind_double".}
proc bind_int*(para1: Pstmt, para2: int32, para3: int32): int32{.cdecl, proc bind_int*(para1: PStmt, para2: int32, para3: int32): int32{.cdecl,
dynlib: Lib, importc: "sqlite3_bind_int".} dynlib: Lib, importc: "sqlite3_bind_int".}
proc bind_int64*(para1: Pstmt, para2: int32, para3: int64): int32{.cdecl, proc bind_int64*(para1: PStmt, para2: int32, para3: int64): int32{.cdecl,
dynlib: Lib, importc: "sqlite3_bind_int64".} dynlib: Lib, importc: "sqlite3_bind_int64".}
proc bind_null*(para1: Pstmt, para2: int32): int32{.cdecl, dynlib: Lib, proc bind_null*(para1: PStmt, para2: int32): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_bind_null".} importc: "sqlite3_bind_null".}
proc bind_text*(para1: Pstmt, para2: int32, para3: cstring, n: int32, proc bind_text*(para1: PStmt, para2: int32, para3: cstring, n: int32,
para5: Tbind_destructor_func): int32{.cdecl, dynlib: Lib, para5: Tbind_destructor_func): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_bind_text".} importc: "sqlite3_bind_text".}
proc bind_text16*(para1: Pstmt, para2: int32, para3: pointer, para4: int32, proc bind_text16*(para1: PStmt, para2: int32, para3: pointer, para4: int32,
para5: Tbind_destructor_func): int32{.cdecl, dynlib: Lib, para5: Tbind_destructor_func): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_bind_text16".} importc: "sqlite3_bind_text16".}
#function sqlite3_bind_value(_para1:Psqlite3_stmt; _para2:longint; _para3:Psqlite3_value):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_value'; #function sqlite3_bind_value(_para1:Psqlite3_stmt; _para2:longint; _para3:Psqlite3_value):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_value';
#These overloaded functions were introduced to allow the use of SQLITE_STATIC and SQLITE_TRANSIENT #These overloaded functions were introduced to allow the use of SQLITE_STATIC and SQLITE_TRANSIENT
#It's the c world man ;-) #It's the c world man ;-)
proc bind_blob*(para1: Pstmt, para2: int32, para3: pointer, n: int32, proc bind_blob*(para1: PStmt, para2: int32, para3: pointer, n: int32,
para5: int32): int32{.cdecl, dynlib: Lib, para5: int32): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_bind_blob".} importc: "sqlite3_bind_blob".}
proc bind_text*(para1: Pstmt, para2: int32, para3: cstring, n: int32, proc bind_text*(para1: PStmt, para2: int32, para3: cstring, n: int32,
para5: int32): int32{.cdecl, dynlib: Lib, para5: int32): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_bind_text".} importc: "sqlite3_bind_text".}
proc bind_text16*(para1: Pstmt, para2: int32, para3: pointer, para4: int32, proc bind_text16*(para1: PStmt, para2: int32, para3: pointer, para4: int32,
para5: int32): int32{.cdecl, dynlib: Lib, para5: int32): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_bind_text16".} importc: "sqlite3_bind_text16".}
proc bind_parameter_count*(para1: Pstmt): int32{.cdecl, dynlib: Lib, proc bind_parameter_count*(para1: PStmt): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_bind_parameter_count".} importc: "sqlite3_bind_parameter_count".}
proc bind_parameter_name*(para1: Pstmt, para2: int32): cstring{.cdecl, proc bind_parameter_name*(para1: PStmt, para2: int32): cstring{.cdecl,
dynlib: Lib, importc: "sqlite3_bind_parameter_name".} dynlib: Lib, importc: "sqlite3_bind_parameter_name".}
proc bind_parameter_index*(para1: Pstmt, zName: cstring): int32{.cdecl, proc bind_parameter_index*(para1: PStmt, zName: cstring): int32{.cdecl,
dynlib: Lib, importc: "sqlite3_bind_parameter_index".} dynlib: Lib, importc: "sqlite3_bind_parameter_index".}
proc clear_bindings*(para1: Pstmt): int32 {.cdecl, proc clear_bindings*(para1: PStmt): int32 {.cdecl,
dynlib: Lib, importc: "sqlite3_clear_bindings".} dynlib: Lib, importc: "sqlite3_clear_bindings".}
proc column_count*(pStmt: Pstmt): int32{.cdecl, dynlib: Lib, proc column_count*(PStmt: PStmt): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_column_count".} importc: "sqlite3_column_count".}
proc column_name*(para1: Pstmt, para2: int32): cstring{.cdecl, dynlib: Lib, proc column_name*(para1: PStmt, para2: int32): cstring{.cdecl, dynlib: Lib,
importc: "sqlite3_column_name".} importc: "sqlite3_column_name".}
proc column_table_name*(para1: Pstmt; para2: int32): cstring{.cdecl, dynlib: Lib, proc column_table_name*(para1: PStmt; para2: int32): cstring{.cdecl, dynlib: Lib,
importc: "sqlite3_column_table_name".} importc: "sqlite3_column_table_name".}
proc column_name16*(para1: Pstmt, para2: int32): pointer{.cdecl, dynlib: Lib, proc column_name16*(para1: PStmt, para2: int32): pointer{.cdecl, dynlib: Lib,
importc: "sqlite3_column_name16".} importc: "sqlite3_column_name16".}
proc column_decltype*(para1: Pstmt, i: int32): cstring{.cdecl, dynlib: Lib, proc column_decltype*(para1: PStmt, i: int32): cstring{.cdecl, dynlib: Lib,
importc: "sqlite3_column_decltype".} importc: "sqlite3_column_decltype".}
proc column_decltype16*(para1: Pstmt, para2: int32): pointer{.cdecl, proc column_decltype16*(para1: PStmt, para2: int32): pointer{.cdecl,
dynlib: Lib, importc: "sqlite3_column_decltype16".} dynlib: Lib, importc: "sqlite3_column_decltype16".}
proc step*(para1: Pstmt): int32{.cdecl, dynlib: Lib, importc: "sqlite3_step".} proc step*(para1: PStmt): int32{.cdecl, dynlib: Lib, importc: "sqlite3_step".}
proc data_count*(pStmt: Pstmt): int32{.cdecl, dynlib: Lib, proc data_count*(PStmt: PStmt): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_data_count".} importc: "sqlite3_data_count".}
proc column_blob*(para1: Pstmt, iCol: int32): pointer{.cdecl, dynlib: Lib, proc column_blob*(para1: PStmt, iCol: int32): pointer{.cdecl, dynlib: Lib,
importc: "sqlite3_column_blob".} importc: "sqlite3_column_blob".}
proc column_bytes*(para1: Pstmt, iCol: int32): int32{.cdecl, dynlib: Lib, proc column_bytes*(para1: PStmt, iCol: int32): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_column_bytes".} importc: "sqlite3_column_bytes".}
proc column_bytes16*(para1: Pstmt, iCol: int32): int32{.cdecl, dynlib: Lib, proc column_bytes16*(para1: PStmt, iCol: int32): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_column_bytes16".} importc: "sqlite3_column_bytes16".}
proc column_double*(para1: Pstmt, iCol: int32): float64{.cdecl, dynlib: Lib, proc column_double*(para1: PStmt, iCol: int32): float64{.cdecl, dynlib: Lib,
importc: "sqlite3_column_double".} importc: "sqlite3_column_double".}
proc column_int*(para1: Pstmt, iCol: int32): int32{.cdecl, dynlib: Lib, proc column_int*(para1: PStmt, iCol: int32): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_column_int".} importc: "sqlite3_column_int".}
proc column_int64*(para1: Pstmt, iCol: int32): int64{.cdecl, dynlib: Lib, proc column_int64*(para1: PStmt, iCol: int32): int64{.cdecl, dynlib: Lib,
importc: "sqlite3_column_int64".} importc: "sqlite3_column_int64".}
proc column_text*(para1: Pstmt, iCol: int32): cstring{.cdecl, dynlib: Lib, proc column_text*(para1: PStmt, iCol: int32): cstring{.cdecl, dynlib: Lib,
importc: "sqlite3_column_text".} importc: "sqlite3_column_text".}
proc column_text16*(para1: Pstmt, iCol: int32): pointer{.cdecl, dynlib: Lib, proc column_text16*(para1: PStmt, iCol: int32): pointer{.cdecl, dynlib: Lib,
importc: "sqlite3_column_text16".} importc: "sqlite3_column_text16".}
proc column_type*(para1: Pstmt, iCol: int32): int32{.cdecl, dynlib: Lib, proc column_type*(para1: PStmt, iCol: int32): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_column_type".} importc: "sqlite3_column_type".}
proc finalize*(pStmt: Pstmt): int32{.cdecl, dynlib: Lib, proc finalize*(PStmt: PStmt): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_finalize".} importc: "sqlite3_finalize".}
proc reset*(pStmt: Pstmt): int32{.cdecl, dynlib: Lib, importc: "sqlite3_reset".} proc reset*(PStmt: PStmt): int32{.cdecl, dynlib: Lib, importc: "sqlite3_reset".}
proc create_function*(para1: PSqlite3, zFunctionName: cstring, nArg: int32, proc create_function*(para1: PSqlite3, zFunctionName: cstring, nArg: int32,
eTextRep: int32, para5: pointer, eTextRep: int32, para5: pointer,
xFunc: Create_function_func_func, xFunc: Create_function_func_func,
@ -284,27 +284,27 @@ proc create_function16*(para1: PSqlite3, zFunctionName: pointer, nArg: int32,
dynlib: Lib, importc: "sqlite3_create_function16".} dynlib: Lib, importc: "sqlite3_create_function16".}
proc aggregate_count*(para1: Pcontext): int32{.cdecl, dynlib: Lib, proc aggregate_count*(para1: Pcontext): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_aggregate_count".} importc: "sqlite3_aggregate_count".}
proc value_blob*(para1: Pvalue): pointer{.cdecl, dynlib: Lib, proc value_blob*(para1: PValue): pointer{.cdecl, dynlib: Lib,
importc: "sqlite3_value_blob".} importc: "sqlite3_value_blob".}
proc value_bytes*(para1: Pvalue): int32{.cdecl, dynlib: Lib, proc value_bytes*(para1: PValue): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_value_bytes".} importc: "sqlite3_value_bytes".}
proc value_bytes16*(para1: Pvalue): int32{.cdecl, dynlib: Lib, proc value_bytes16*(para1: PValue): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_value_bytes16".} importc: "sqlite3_value_bytes16".}
proc value_double*(para1: Pvalue): float64{.cdecl, dynlib: Lib, proc value_double*(para1: PValue): float64{.cdecl, dynlib: Lib,
importc: "sqlite3_value_double".} importc: "sqlite3_value_double".}
proc value_int*(para1: Pvalue): int32{.cdecl, dynlib: Lib, proc value_int*(para1: PValue): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_value_int".} importc: "sqlite3_value_int".}
proc value_int64*(para1: Pvalue): int64{.cdecl, dynlib: Lib, proc value_int64*(para1: PValue): int64{.cdecl, dynlib: Lib,
importc: "sqlite3_value_int64".} importc: "sqlite3_value_int64".}
proc value_text*(para1: Pvalue): cstring{.cdecl, dynlib: Lib, proc value_text*(para1: PValue): cstring{.cdecl, dynlib: Lib,
importc: "sqlite3_value_text".} importc: "sqlite3_value_text".}
proc value_text16*(para1: Pvalue): pointer{.cdecl, dynlib: Lib, proc value_text16*(para1: PValue): pointer{.cdecl, dynlib: Lib,
importc: "sqlite3_value_text16".} importc: "sqlite3_value_text16".}
proc value_text16le*(para1: Pvalue): pointer{.cdecl, dynlib: Lib, proc value_text16le*(para1: PValue): pointer{.cdecl, dynlib: Lib,
importc: "sqlite3_value_text16le".} importc: "sqlite3_value_text16le".}
proc value_text16be*(para1: Pvalue): pointer{.cdecl, dynlib: Lib, proc value_text16be*(para1: PValue): pointer{.cdecl, dynlib: Lib,
importc: "sqlite3_value_text16be".} importc: "sqlite3_value_text16be".}
proc value_type*(para1: Pvalue): int32{.cdecl, dynlib: Lib, proc value_type*(para1: PValue): int32{.cdecl, dynlib: Lib,
importc: "sqlite3_value_type".} importc: "sqlite3_value_type".}
proc aggregate_context*(para1: Pcontext, nBytes: int32): pointer{.cdecl, proc aggregate_context*(para1: Pcontext, nBytes: int32): pointer{.cdecl,
dynlib: Lib, importc: "sqlite3_aggregate_context".} dynlib: Lib, importc: "sqlite3_aggregate_context".}
@ -342,7 +342,7 @@ proc result_text16le*(para1: Pcontext, para2: pointer, para3: int32,
proc result_text16be*(para1: Pcontext, para2: pointer, para3: int32, proc result_text16be*(para1: Pcontext, para2: pointer, para3: int32,
para4: Result_func){.cdecl, dynlib: Lib, para4: Result_func){.cdecl, dynlib: Lib,
importc: "sqlite3_result_text16be".} importc: "sqlite3_result_text16be".}
proc result_value*(para1: Pcontext, para2: Pvalue){.cdecl, dynlib: Lib, proc result_value*(para1: Pcontext, para2: PValue){.cdecl, dynlib: Lib,
importc: "sqlite3_result_value".} importc: "sqlite3_result_value".}
proc create_collation*(para1: PSqlite3, zName: cstring, eTextRep: int32, proc create_collation*(para1: PSqlite3, zName: cstring, eTextRep: int32,
para4: pointer, xCompare: Create_collation_func): int32{. para4: pointer, xCompare: Create_collation_func): int32{.