diff options
| -rwxr-xr-x | lib/wrappers/mysql.nim | 1073 | ||||
| -rwxr-xr-x | lib/wrappers/sqlite3.nim | 356 | ||||
| -rwxr-xr-x | lib/wrappers/tcl.nim | 866 |
3 files changed, 2295 insertions, 0 deletions
diff --git a/lib/wrappers/mysql.nim b/lib/wrappers/mysql.nim new file mode 100755 index 000000000..2a7a10c58 --- /dev/null +++ b/lib/wrappers/mysql.nim @@ -0,0 +1,1073 @@ +# +# +# Nimrod's Runtime Library +# (c) Copyright 2010 Andreas Rumpf +# +# See the file "copying.txt", included in this +# distribution, for details about the copyright. +# + +{.deadCodeElim: on.} +when defined(Unix): + const + lib = "libmysqlclient.so.15" +when defined(Windows): + const + lib = "libmysql.dll" +type + my_bool* = bool + Pmy_bool* = ptr my_bool + PVIO* = Pointer + Pgptr* = ptr gptr + gptr* = cstring + Pmy_socket* = ptr my_socket + my_socket* = cint + PPByte* = pointer + cuint* = cint + +# ------------ Start of declaration in "mysql_com.h" --------------------- +# +# ** Common definition between mysql server & client +# +# Field/table name length + +const + NAME_LEN* = 64 + HOSTNAME_LENGTH* = 60 + USERNAME_LENGTH* = 16 + SERVER_VERSION_LENGTH* = 60 + SQLSTATE_LENGTH* = 5 + LOCAL_HOST* = "localhost" + LOCAL_HOST_NAMEDPIPE* = '.' + +const + NAMEDPIPE* = "MySQL" + SERVICENAME* = "MySQL" + +type + Tenum_server_command* = enum + COM_SLEEP, COM_QUIT, COM_INIT_DB, COM_QUERY, COM_FIELD_LIST, COM_CREATE_DB, + COM_DROP_DB, COM_REFRESH, COM_SHUTDOWN, COM_STATISTICS, COM_PROCESS_INFO, + COM_CONNECT, COM_PROCESS_KILL, COM_DEBUG, COM_PING, COM_TIME, + COM_DELAYED_INSERT, COM_CHANGE_USER, COM_BINLOG_DUMP, COM_TABLE_DUMP, + COM_CONNECT_OUT, COM_REGISTER_SLAVE, COM_STMT_PREPARE, COM_STMT_EXECUTE, + COM_STMT_SEND_LONG_DATA, COM_STMT_CLOSE, COM_STMT_RESET, COM_SET_OPTION, + COM_STMT_FETCH, COM_END + +const + SCRAMBLE_LENGTH* = 20 # Length of random string sent by server on handshake; + # this is also length of obfuscated password, + # recieved from client + SCRAMBLE_LENGTH_323* = 8 # length of password stored in the db: + # new passwords are preceeded with '*' + SCRAMBLED_PASSWORD_CHAR_LENGTH* = SCRAMBLE_LENGTH * 2 + 1 + SCRAMBLED_PASSWORD_CHAR_LENGTH_323* = SCRAMBLE_LENGTH_323 * 2 + NOT_NULL_FLAG* = 1 # Field can't be NULL + PRI_KEY_FLAG* = 2 # Field is part of a primary key + UNIQUE_KEY_FLAG* = 4 # Field is part of a unique key + MULTIPLE_KEY_FLAG* = 8 # Field is part of a key + BLOB_FLAG* = 16 # Field is a blob + UNSIGNED_FLAG* = 32 # Field is unsigned + ZEROFILL_FLAG* = 64 # Field is zerofill + BINARY_FLAG* = 128 # Field is binary + # The following are only sent to new clients + ENUM_FLAG* = 256 # field is an enum + AUTO_INCREMENT_FLAG* = 512 # field is a autoincrement field + TIMESTAMP_FLAG* = 1024 # Field is a timestamp + SET_FLAG* = 2048 # field is a set + NO_DEFAULT_VALUE_FLAG* = 4096 # Field doesn't have default value + NUM_FLAG* = 32768 # Field is num (for clients) + PART_KEY_FLAG* = 16384 # Intern; Part of some key + GROUP_FLAG* = 32768 # Intern: Group field + UNIQUE_FLAG* = 65536 # Intern: Used by sql_yacc + BINCMP_FLAG* = 131072 # Intern: Used by sql_yacc + REFRESH_GRANT* = 1 # Refresh grant tables + REFRESH_LOG* = 2 # Start on new log file + REFRESH_TABLES* = 4 # close all tables + REFRESH_HOSTS* = 8 # Flush host cache + REFRESH_STATUS* = 16 # Flush status variables + REFRESH_THREADS* = 32 # Flush thread cache + REFRESH_SLAVE* = 64 # Reset master info and restart slave thread + REFRESH_MASTER* = 128 # Remove all bin logs in the index and truncate the index + # The following can't be set with mysql_refresh() + REFRESH_READ_LOCK* = 16384 # Lock tables for read + REFRESH_FAST* = 32768 # Intern flag + REFRESH_QUERY_CACHE* = 65536 # RESET (remove all queries) from query cache + REFRESH_QUERY_CACHE_FREE* = 0x00020000 # pack query cache + REFRESH_DES_KEY_FILE* = 0x00040000 + REFRESH_USER_RESOURCES* = 0x00080000 + CLIENT_LONG_PASSWORD* = 1 # new more secure passwords + CLIENT_FOUND_ROWS* = 2 # Found instead of affected rows + CLIENT_LONG_FLAG* = 4 # Get all column flags + CLIENT_CONNECT_WITH_DB* = 8 # One can specify db on connect + CLIENT_NO_SCHEMA* = 16 # Don't allow database.table.column + CLIENT_COMPRESS* = 32 # Can use compression protocol + CLIENT_ODBC* = 64 # Odbc client + CLIENT_LOCAL_FILES* = 128 # Can use LOAD DATA LOCAL + CLIENT_IGNORE_SPACE* = 256 # Ignore spaces before '(' + CLIENT_PROTOCOL_41* = 512 # New 4.1 protocol + CLIENT_INTERACTIVE* = 1024 # This is an interactive client + CLIENT_SSL* = 2048 # Switch to SSL after handshake + CLIENT_IGNORE_SIGPIPE* = 4096 # IGNORE sigpipes + CLIENT_TRANSACTIONS* = 8192 # Client knows about transactions + CLIENT_RESERVED* = 16384 # Old flag for 4.1 protocol + CLIENT_SECURE_CONNECTION* = 32768 # New 4.1 authentication + CLIENT_MULTI_STATEMENTS* = 65536 # Enable/disable multi-stmt support + CLIENT_MULTI_RESULTS* = 131072 # Enable/disable multi-results + CLIENT_REMEMBER_OPTIONS*: int = 1 shl 31 + SERVER_STATUS_IN_TRANS* = 1 # Transaction has started + SERVER_STATUS_AUTOCOMMIT* = 2 # Server in auto_commit mode + SERVER_STATUS_MORE_RESULTS* = 4 # More results on server + SERVER_MORE_RESULTS_EXISTS* = 8 # Multi query - next query exists + SERVER_QUERY_NO_GOOD_INDEX_USED* = 16 + SERVER_QUERY_NO_INDEX_USED* = 32 # The server was able to fulfill the clients request and opened a + # read-only non-scrollable cursor for a query. This flag comes + # in reply to COM_STMT_EXECUTE and COM_STMT_FETCH commands. + SERVER_STATUS_CURSOR_EXISTS* = 64 # This flag is sent when a read-only cursor is exhausted, in reply to + # COM_STMT_FETCH command. + SERVER_STATUS_LAST_ROW_SENT* = 128 + SERVER_STATUS_DB_DROPPED* = 256 # A database was dropped + SERVER_STATUS_NO_BACKSLASH_ESCAPES* = 512 + ERRMSG_SIZE* = 200 + NET_READ_TIMEOUT* = 30 # Timeout on read + NET_WRITE_TIMEOUT* = 60 # Timeout on write + NET_WAIT_TIMEOUT* = 8 * 60 * 60 # Wait for new query + ONLY_KILL_QUERY* = 1 + +const + MAX_TINYINT_WIDTH* = 3 # Max width for a TINY w.o. sign + MAX_SMALLINT_WIDTH* = 5 # Max width for a SHORT w.o. sign + MAX_MEDIUMINT_WIDTH* = 8 # Max width for a INT24 w.o. sign + MAX_INT_WIDTH* = 10 # Max width for a LONG w.o. sign + MAX_BIGINT_WIDTH* = 20 # Max width for a LONGLONG + MAX_CHAR_WIDTH* = 255 # Max length for a CHAR colum + MAX_BLOB_WIDTH* = 8192 # Default width for blob + +type + Pst_net* = ptr Tst_net + Tst_net*{.final.} = object + vio*: PVio + buff*: cstring + buff_end*: cstring + write_pos*: cstring + read_pos*: cstring + fd*: my_socket # For Perl DBI/dbd + max_packet*: int + max_packet_size*: int + pkt_nr*: cuint + compress_pkt_nr*: cuint + write_timeout*: cuint + read_timeout*: cuint + retry_count*: cuint + fcntl*: cint + compress*: my_bool # The following variable is set if we are doing several queries in one + # command ( as in LOAD TABLE ... FROM MASTER ), + # and do not want to confuse the client with OK at the wrong time + remain_in_buf*: int + len*: int + buf_length*: int + where_b*: int + return_status*: ptr cint + reading_or_writing*: char + save_char*: cchar + no_send_ok*: my_bool # For SPs and other things that do multiple stmts + no_send_eof*: my_bool # For SPs' first version read-only cursors + no_send_error*: my_bool # Set if OK packet is already sent, and + # we do not need to send error messages + # Pointer to query object in query cache, do not equal NULL (0) for + # queries in cache that have not stored its results yet + # $endif + last_error*: array[0..(ERRMSG_SIZE) - 1, char] + sqlstate*: array[0..(SQLSTATE_LENGTH + 1) - 1, char] + last_errno*: cuint + error*: char + query_cache_query*: gptr + report_error*: my_bool # We should report error (we have unreported error) + return_errno*: my_bool + + TNET* = Tst_net + PNET* = ptr TNET + +const + packet_error* = - 1 + +type + Tenum_field_types* = enum # For backward compatibility + TYPE_DECIMAL, TYPE_TINY, TYPE_SHORT, TYPE_LONG, TYPE_FLOAT, TYPE_DOUBLE, + TYPE_NULL, TYPE_TIMESTAMP, TYPE_LONGLONG, TYPE_INT24, TYPE_DATE, TYPE_TIME, + TYPE_DATETIME, TYPE_YEAR, TYPE_NEWDATE, TYPE_VARCHAR, TYPE_BIT, + TYPE_NEWDECIMAL = 246, TYPE_ENUM = 247, TYPE_SET = 248, + TYPE_TINY_BLOB = 249, TYPE_MEDIUM_BLOB = 250, TYPE_LONG_BLOB = 251, + TYPE_BLOB = 252, TYPE_VAR_STRING = 253, TYPE_STRING = 254, + TYPE_GEOMETRY = 255 + +const + CLIENT_MULTI_QUERIES* = CLIENT_MULTI_STATEMENTS + FIELD_TYPE_DECIMAL* = TYPE_DECIMAL + FIELD_TYPE_NEWDECIMAL* = TYPE_NEWDECIMAL + FIELD_TYPE_TINY* = TYPE_TINY + FIELD_TYPE_SHORT* = TYPE_SHORT + FIELD_TYPE_LONG* = TYPE_LONG + FIELD_TYPE_FLOAT* = TYPE_FLOAT + FIELD_TYPE_DOUBLE* = TYPE_DOUBLE + FIELD_TYPE_NULL* = TYPE_NULL + FIELD_TYPE_TIMESTAMP* = TYPE_TIMESTAMP + FIELD_TYPE_LONGLONG* = TYPE_LONGLONG + FIELD_TYPE_INT24* = TYPE_INT24 + FIELD_TYPE_DATE* = TYPE_DATE + FIELD_TYPE_TIME* = TYPE_TIME + FIELD_TYPE_DATETIME* = TYPE_DATETIME + FIELD_TYPE_YEAR* = TYPE_YEAR + FIELD_TYPE_NEWDATE* = TYPE_NEWDATE + FIELD_TYPE_ENUM* = TYPE_ENUM + FIELD_TYPE_SET* = TYPE_SET + FIELD_TYPE_TINY_BLOB* = TYPE_TINY_BLOB + FIELD_TYPE_MEDIUM_BLOB* = TYPE_MEDIUM_BLOB + FIELD_TYPE_LONG_BLOB* = TYPE_LONG_BLOB + FIELD_TYPE_BLOB* = TYPE_BLOB + FIELD_TYPE_VAR_STRING* = TYPE_VAR_STRING + FIELD_TYPE_STRING* = TYPE_STRING + FIELD_TYPE_CHAR* = TYPE_TINY + FIELD_TYPE_INTERVAL* = TYPE_ENUM + FIELD_TYPE_GEOMETRY* = TYPE_GEOMETRY + FIELD_TYPE_BIT* = TYPE_BIT # Shutdown/kill enums and constants + # Bits for THD::killable. + SHUTDOWN_KILLABLE_CONNECT* = chr(1 shl 0) + SHUTDOWN_KILLABLE_TRANS* = chr(1 shl 1) + SHUTDOWN_KILLABLE_LOCK_TABLE* = chr(1 shl 2) + SHUTDOWN_KILLABLE_UPDATE* = chr(1 shl 3) + +type + Tenum_shutdown_level* = enum + SHUTDOWN_DEFAULT = 0, SHUTDOWN_WAIT_CONNECTIONS = 1, + SHUTDOWN_WAIT_TRANSACTIONS = 2, SHUTDOWN_WAIT_UPDATES = 8, + SHUTDOWN_WAIT_ALL_BUFFERS = 16, SHUTDOWN_WAIT_CRITICAL_BUFFERS = 17, + KILL_QUERY = 254, KILL_CONNECTION = 255 + Tenum_cursor_type* = enum # options for mysql_set_option + CURSOR_TYPE_NO_CURSOR = 0, CURSOR_TYPE_READ_ONLY = 1, + CURSOR_TYPE_FOR_UPDATE = 2, CURSOR_TYPE_SCROLLABLE = 4 + Tenum_mysql_set_option* = enum + OPTION_MULTI_STATEMENTS_ON, OPTION_MULTI_STATEMENTS_OFF + +proc my_net_init*(net: PNET, vio: PVio): my_bool{.cdecl, dynlib: lib, + importc: "my_net_init".} +proc my_net_local_init*(net: PNET){.cdecl, dynlib: lib, + importc: "my_net_local_init".} +proc net_end*(net: PNET){.cdecl, dynlib: lib, importc: "net_end".} +proc net_clear*(net: PNET){.cdecl, dynlib: lib, importc: "net_clear".} +proc net_realloc*(net: PNET, len: int): my_bool{.cdecl, dynlib: lib, + importc: "net_realloc".} +proc net_flush*(net: PNET): my_bool{.cdecl, dynlib: lib, importc: "net_flush".} +proc my_net_write*(net: PNET, packet: cstring, length: int): my_bool{.cdecl, + dynlib: lib, importc: "my_net_write".} +proc net_write_command*(net: PNET, command: char, header: cstring, + head_len: int, packet: cstring, length: int): my_bool{. + cdecl, dynlib: lib, importc: "net_write_command".} +proc net_real_write*(net: PNET, packet: cstring, length: int): cint{.cdecl, + dynlib: lib, importc: "net_real_write".} +proc my_net_read*(net: PNET): int{.cdecl, dynlib: lib, importc: "my_net_read".} + # The following function is not meant for normal usage + # Currently it's used internally by manager.c +type + Psockaddr* = ptr Tsockaddr + Tsockaddr*{.final.} = object # undefined structure + +proc my_connect*(s: my_socket, name: Psockaddr, namelen: cuint, timeout: cuint): cint{. + cdecl, dynlib: lib, importc: "my_connect".} +type + Prand_struct* = ptr Trand_struct + Trand_struct*{.final.} = object # The following is for user defined functions + seed1*: int + seed2*: int + max_value*: int + max_value_dbl*: cdouble + + TItem_result* = enum + STRING_RESULT, REAL_RESULT, INT_RESULT, ROW_RESULT, DECIMAL_RESULT + PItem_result* = ptr TItem_result + Pst_udf_args* = ptr Tst_udf_args + Tst_udf_args*{.final.} = object + arg_count*: cuint # Number of arguments + arg_type*: PItem_result # Pointer to item_results + args*: cstringArray # Pointer to item_results + lengths*: ptr int # Length of string arguments + maybe_null*: cstring # Length of string arguments + attributes*: cstringArray # Pointer to attribute name + attribute_lengths*: ptr int # Length of attribute arguments + + TUDF_ARGS* = Tst_udf_args + PUDF_ARGS* = ptr TUDF_ARGS # This holds information about the result + Pst_udf_init* = ptr Tst_udf_init + Tst_udf_init*{.final.} = object + maybe_null*: my_bool # 1 if function can return NULL + decimals*: cuint # for real functions + max_length*: int # For string functions + theptr*: cstring # free pointer for function data + const_item*: my_bool # free pointer for function data + + TUDF_INIT* = Tst_udf_init + PUDF_INIT* = ptr TUDF_INIT # Constants when using compression + +const + NET_HEADER_SIZE* = 4 # standard header size + COMP_HEADER_SIZE* = 3 # compression header extra size + # Prototypes to password functions + # These functions are used for authentication by client and server and + # implemented in sql/password.c + +proc randominit*(para1: Prand_struct, seed1: int, seed2: int){.cdecl, + dynlib: lib, importc: "randominit".} +proc my_rnd*(para1: Prand_struct): cdouble{.cdecl, dynlib: lib, + importc: "my_rnd".} +proc create_random_string*(fto: cstring, len: cuint, rand_st: Prand_struct){. + cdecl, dynlib: lib, importc: "create_random_string".} +proc hash_password*(fto: int, password: cstring, password_len: cuint){.cdecl, + dynlib: lib, importc: "hash_password".} +proc make_scrambled_password_323*(fto: cstring, password: cstring){.cdecl, + dynlib: lib, importc: "make_scrambled_password_323".} +proc scramble_323*(fto: cstring, message: cstring, password: cstring){.cdecl, + dynlib: lib, importc: "scramble_323".} +proc check_scramble_323*(para1: cstring, message: cstring, salt: int): my_bool{. + cdecl, dynlib: lib, importc: "check_scramble_323".} +proc get_salt_from_password_323*(res: ptr int, password: cstring){.cdecl, + dynlib: lib, importc: "get_salt_from_password_323".} +proc make_password_from_salt_323*(fto: cstring, salt: ptr int){.cdecl, + dynlib: lib, importc: "make_password_from_salt_323".} +proc octet2hex*(fto: cstring, str: cstring, length: cuint): cstring{.cdecl, + dynlib: lib, importc: "octet2hex".} +proc make_scrambled_password*(fto: cstring, password: cstring){.cdecl, + dynlib: lib, importc: "make_scrambled_password".} +proc scramble*(fto: cstring, message: cstring, password: cstring){.cdecl, + dynlib: lib, importc: "scramble".} +proc check_scramble*(reply: cstring, message: cstring, hash_stage2: pointer): my_bool{. + cdecl, dynlib: lib, importc: "check_scramble".} +proc get_salt_from_password*(res: pointer, password: cstring){.cdecl, + dynlib: lib, importc: "get_salt_from_password".} +proc make_password_from_salt*(fto: cstring, hash_stage2: pointer){.cdecl, + dynlib: lib, importc: "make_password_from_salt".} + # end of password.c +proc get_tty_password*(opt_message: cstring): cstring{.cdecl, dynlib: lib, + importc: "get_tty_password".} +proc errno_to_sqlstate*(errno: cuint): cstring{.cdecl, dynlib: lib, + importc: "mysql_errno_to_sqlstate".} + # Some other useful functions +proc modify_defaults_file*(file_location: cstring, option: cstring, + option_value: cstring, section_name: cstring, + remove_option: cint): cint{.cdecl, dynlib: lib, + importc: "load_defaults".} +proc load_defaults*(conf_file: cstring, groups: cstringArray, argc: ptr cint, + argv: ptr cstringArray): cint{.cdecl, dynlib: lib, + importc: "load_defaults".} +proc my_init*(): my_bool{.cdecl, dynlib: lib, importc: "my_init".} +proc my_thread_init*(): my_bool{.cdecl, dynlib: lib, importc: "my_thread_init".} +proc my_thread_end*(){.cdecl, dynlib: lib, importc: "my_thread_end".} +const + NULL_LENGTH*: int = int(not (0)) # For net_store_length + +const + STMT_HEADER* = 4 + LONG_DATA_HEADER* = 6 # ------------ Stop of declaration in "mysql_com.h" ----------------------- + # $include "mysql_time.h" + # $include "mysql_version.h" + # $include "typelib.h" + # $include "my_list.h" /* for LISTs used in 'MYSQL' and 'MYSQL_STMT' */ + # var + # mysql_port : cuint;cvar;external; + # mysql_unix_port : Pchar;cvar;external; + +const + CLIENT_NET_READ_TIMEOUT* = 365 * 24 * 3600 # Timeout on read + CLIENT_NET_WRITE_TIMEOUT* = 365 * 24 * 3600 # Timeout on write + +type + Pst_mysql_field* = ptr Tst_mysql_field + Tst_mysql_field*{.final.} = object + name*: cstring # Name of column + org_name*: cstring # Original column name, if an alias + table*: cstring # Table of column if column was a field + org_table*: cstring # Org table name, if table was an alias + db*: cstring # Database for table + catalog*: cstring # Catalog for table + def*: cstring # Default value (set by mysql_list_fields) + len*: int # Width of column (create length) + max_length*: int # Max width for selected set + name_length*: cuint + org_name_length*: cuint + table_length*: cuint + org_table_length*: cuint + db_length*: cuint + catalog_length*: cuint + def_length*: cuint + flags*: cuint # Div flags + decimals*: cuint # Number of decimals in field + charsetnr*: cuint # Character set + ftype*: Tenum_field_types # Type of field. See mysql_com.h for types + + TFIELD* = Tst_mysql_field + PFIELD* = ptr TFIELD + PROW* = ptr TROW # return data as array of strings + TROW* = cstringArray + PFIELD_OFFSET* = ptr TFIELD_OFFSET # offset to current field + TFIELD_OFFSET* = cuint + +proc IS_PRI_KEY*(n: int32): bool +proc IS_NOT_NULL*(n: int32): bool +proc IS_BLOB*(n: int32): bool +proc IS_NUM*(t: Tenum_field_types): bool +proc INTERNAL_NUM_FIELD*(f: Pst_mysql_field): bool +proc IS_NUM_FIELD*(f: Pst_mysql_field): bool +type + my_ulonglong* = int64 + Pmy_ulonglong* = ptr my_ulonglong + +const + COUNT_ERROR* = not (my_ulonglong(0)) + +type + Pst_mysql_rows* = ptr Tst_mysql_rows + Tst_mysql_rows*{.final.} = object + next*: Pst_mysql_rows # list of rows + data*: TROW + len*: int + + TROWS* = Tst_mysql_rows + PROWS* = ptr TROWS + PROW_OFFSET* = ptr TROW_OFFSET # offset to current row + TROW_OFFSET* = TROWS + +const + ALLOC_MAX_BLOCK_TO_DROP* = 4096 + ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP* = 10 # struct for once_alloc (block) + +type + Pst_used_mem* = ptr Tst_used_mem + Tst_used_mem*{.final.} = object + next*: Pst_used_mem # Next block in use + left*: cuint # memory left in block + size*: cuint # size of block + + TUSED_MEM* = Tst_used_mem + PUSED_MEM* = ptr TUSED_MEM + Pst_mem_root* = ptr Tst_mem_root + Tst_mem_root*{.final.} = object + free*: PUSED_MEM # blocks with free memory in it + used*: PUSED_MEM # blocks almost without free memory + pre_alloc*: PUSED_MEM # preallocated block + min_malloc*: cuint # if block have less memory it will be put in 'used' list + block_size*: cuint # initial block size + block_num*: cuint # allocated blocks counter + # first free block in queue test counter (if it exceed + # MAX_BLOCK_USAGE_BEFORE_DROP block will be dropped in 'used' list) + first_block_usage*: cuint + error_handler*: proc (){.cdecl.} + + TMEM_ROOT* = Tst_mem_root + PMEM_ROOT* = ptr TMEM_ROOT # ------------ Stop of declaration in "my_alloc.h" ---------------------- + +type + Pst_mysql_data* = ptr Tst_mysql_data + Tst_mysql_data*{.final.} = object + rows*: my_ulonglong + fields*: cuint + data*: PROWS + alloc*: TMEM_ROOT + prev_ptr*: ptr PROWS + + TDATA* = Tst_mysql_data + PDATA* = ptr TDATA + Toption* = enum + OPT_CONNECT_TIMEOUT, OPT_COMPRESS, OPT_NAMED_PIPE, INIT_COMMAND, + READ_DEFAULT_FILE, READ_DEFAULT_GROUP, SET_CHARSET_DIR, SET_CHARSET_NAME, + OPT_LOCAL_INFILE, OPT_PROTOCOL, SHARED_MEMORY_BASE_NAME, OPT_READ_TIMEOUT, + OPT_WRITE_TIMEOUT, OPT_USE_RESULT, OPT_USE_REMOTE_CONNECTION, + OPT_USE_EMBEDDED_CONNECTION, OPT_GUESS_CONNECTION, SET_CLIENT_IP, + SECURE_AUTH, REPORT_DATA_TRUNCATION, OPT_RECONNECT + +const + MAX_MYSQL_MANAGER_ERR* = 256 + MAX_MYSQL_MANAGER_MSG* = 256 + MANAGER_OK* = 200 + MANAGER_INFO* = 250 + MANAGER_ACCESS* = 401 + MANAGER_CLIENT_ERR* = 450 + MANAGER_INTERNAL_ERR* = 500 + +type + Tst_dynamic_array*{.final.} = object + buffer*: cstring + elements*: cuint + max_element*: cuint + alloc_increment*: cuint + size_of_element*: cuint + + TDYNAMIC_ARRAY* = Tst_dynamic_array + Pst_dynamic_array* = ptr Tst_dynamic_array + Pst_mysql_options* = ptr Tst_mysql_options + Tst_mysql_options*{.final.} = object + connect_timeout*: cuint + read_timeout*: cuint + write_timeout*: cuint + port*: cuint + protocol*: cuint + client_flag*: int + host*: cstring + user*: cstring + password*: cstring + unix_socket*: cstring + db*: cstring + init_commands*: Pst_dynamic_array + my_cnf_file*: cstring + my_cnf_group*: cstring + charset_dir*: cstring + charset_name*: cstring + ssl_key*: cstring # PEM key file + ssl_cert*: cstring # PEM cert file + ssl_ca*: cstring # PEM CA file + ssl_capath*: cstring # PEM directory of CA-s? + ssl_cipher*: cstring # cipher to use + shared_memory_base_name*: cstring + max_allowed_packet*: int + use_ssl*: my_bool # if to use SSL or not + compress*: my_bool + named_pipe*: my_bool # On connect, find out the replication role of the server, and + # establish connections to all the peers + rpl_probe*: my_bool # Each call to mysql_real_query() will parse it to tell if it is a read + # or a write, and direct it to the slave or the master + rpl_parse*: my_bool # If set, never read from a master, only from slave, when doing + # a read that is replication-aware + no_master_reads*: my_bool + separate_thread*: my_bool + methods_to_use*: Toption + client_ip*: cstring + secure_auth*: my_bool # Refuse client connecting to server if it uses old (pre-4.1.1) protocol + report_data_truncation*: my_bool # 0 - never report, 1 - always report (default) + # function pointers for local infile support + local_infile_init*: proc (para1: var pointer, para2: cstring, para3: pointer): cint{. + cdecl.} + local_infile_read*: proc (para1: pointer, para2: cstring, para3: cuint): cint + local_infile_end*: proc (para1: pointer) + local_infile_error*: proc (para1: pointer, para2: cstring, para3: cuint): cint + local_infile_userdata*: pointer + + Tstatus* = enum + STATUS_READY, STATUS_GET_RESULT, STATUS_USE_RESULT + Tprotocol_type* = enum # There are three types of queries - the ones that have to go to + # the master, the ones that go to a slave, and the adminstrative + # type which must happen on the pivot connectioin + PROTOCOL_DEFAULT, PROTOCOL_TCP, PROTOCOL_SOCKET, PROTOCOL_PIPE, + PROTOCOL_MEMORY + Trpl_type* = enum + RPL_MASTER, RPL_SLAVE, RPL_ADMIN + Tcharset_info_st*{.final.} = object + number*: cuint + primary_number*: cuint + binary_number*: cuint + state*: cuint + csname*: cstring + name*: cstring + comment*: cstring + tailoring*: cstring + ftype*: cstring + to_lower*: cstring + to_upper*: cstring + sort_order*: cstring + contractions*: ptr int16 + sort_order_big*: ptr ptr int16 + tab_to_uni*: ptr int16 + tab_from_uni*: pointer # was ^MY_UNI_IDX + state_map*: cstring + ident_map*: cstring + strxfrm_multiply*: cuint + mbminlen*: cuint + mbmaxlen*: cuint + min_sort_char*: int16 + max_sort_char*: int16 + escape_with_backslash_is_dangerous*: my_bool + cset*: pointer # was ^MY_CHARSET_HANDLER + coll*: pointer # was ^MY_COLLATION_HANDLER; + + TCHARSET_INFO* = Tcharset_info_st + Pcharset_info_st* = ptr Tcharset_info_st + Pcharacter_set* = ptr Tcharacter_set + Tcharacter_set*{.final.} = object + number*: cuint + state*: cuint + csname*: cstring + name*: cstring + comment*: cstring + dir*: cstring + mbminlen*: cuint + mbmaxlen*: cuint + + TMY_CHARSET_INFO* = Tcharacter_set + PMY_CHARSET_INFO* = ptr TMY_CHARSET_INFO + Pst_mysql_methods* = ptr Tst_mysql_methods + Pst_mysql* = ptr Tst_mysql + Tst_mysql*{.final.} = object + net*: TNET # Communication parameters + connector_fd*: gptr # ConnectorFd for SSL + host*: cstring + user*: cstring + passwd*: cstring + unix_socket*: cstring + server_version*: cstring + host_info*: cstring + info*: cstring + db*: cstring + charset*: Pcharset_info_st + fields*: PFIELD + field_alloc*: TMEM_ROOT + affected_rows*: my_ulonglong + insert_id*: my_ulonglong # id if insert on table with NEXTNR + extra_info*: my_ulonglong # Used by mysqlshow, not used by mysql 5.0 and up + thread_id*: int # Id for connection in server + packet_length*: int + port*: cuint + client_flag*: int + server_capabilities*: int + protocol_version*: cuint + field_count*: cuint + server_status*: cuint + server_language*: cuint + warning_count*: cuint + options*: Tst_mysql_options + status*: Tstatus + free_me*: my_bool # If free in mysql_close + reconnect*: my_bool # set to 1 if automatic reconnect + scramble*: array[0..(SCRAMBLE_LENGTH + 1) - 1, char] # session-wide random string + # Set if this is the original connection, not a master or a slave we have + # added though mysql_rpl_probe() or mysql_set_master()/ mysql_add_slave() + rpl_pivot*: my_bool # Pointers to the master, and the next slave connections, points to + # itself if lone connection. + master*: Pst_mysql + next_slave*: Pst_mysql + last_used_slave*: Pst_mysql # needed for round-robin slave pick + last_used_con*: Pst_mysql # needed for send/read/store/use result to work correctly with replication + stmts*: Pointer # was PList, list of all statements + methods*: Pst_mysql_methods + thd*: pointer # Points to boolean flag in MYSQL_RES or MYSQL_STMT. We set this flag + # from mysql_stmt_close if close had to cancel result set of this object. + unbuffered_fetch_owner*: Pmy_bool + + TMySQL* = Tst_mysql + PMySQL* = ptr TMySQL + Pst_mysql_res* = ptr Tst_mysql_res + Tst_mysql_res*{.final.} = object + row_count*: my_ulonglong + fields*: PFIELD + data*: PDATA + data_cursor*: PROWS + lengths*: ptr int # column lengths of current row + handle*: PMySQL # for unbuffered reads + field_alloc*: TMEM_ROOT + field_count*: cuint + current_field*: cuint + row*: TROW # If unbuffered read + current_row*: TROW # buffer to current row + eof*: my_bool # Used by mysql_fetch_row + unbuffered_fetch_cancelled*: my_bool # mysql_stmt_close() had to cancel this result + methods*: Pst_mysql_methods + + TRES* = Tst_mysql_res + PRES* = ptr TRES + Pst_mysql_stmt* = ptr Tst_mysql_stmt + PSTMT* = ptr TSTMT + Tst_mysql_methods*{.final.} = object + read_query_result*: proc (MySQL: PMySQL): my_bool{.cdecl.} + advanced_command*: proc (MySQL: PMySQL, command: Tenum_server_command, header: cstring, + header_length: int, arg: cstring, arg_length: int, + skip_check: my_bool): my_bool + read_rows*: proc (MySQL: PMySQL, fields: PFIELD, fields_count: cuint): PDATA + use_result*: proc (MySQL: PMySQL): PRES + fetch_lengths*: proc (fto: ptr int, column: TROW, field_count: cuint) + flush_use_result*: proc (MySQL: PMySQL) + list_fields*: proc (MySQL: PMySQL): PFIELD + read_prepare_result*: proc (MySQL: PMySQL, stmt: PSTMT): my_bool + stmt_execute*: proc (stmt: PSTMT): cint + read_binary_rows*: proc (stmt: PSTMT): cint + unbuffered_fetch*: proc (MySQL: PMySQL, row: cstringArray): cint + free_embedded_thd*: proc (MySQL: PMySQL) + read_statistics*: proc (MySQL: PMySQL): cstring + next_result*: proc (MySQL: PMySQL): my_bool + read_change_user_result*: proc (MySQL: PMySQL, buff: cstring, passwd: cstring): cint + read_rowsfrom_cursor*: proc (stmt: PSTMT): cint + + TMETHODS* = Tst_mysql_methods + PMETHODS* = ptr TMETHODS + Pst_mysql_manager* = ptr Tst_mysql_manager + Tst_mysql_manager*{.final.} = object + net*: TNET + host*: cstring + user*: cstring + passwd*: cstring + port*: cuint + free_me*: my_bool + eof*: my_bool + cmd_status*: cint + last_errno*: cint + net_buf*: cstring + net_buf_pos*: cstring + net_data_end*: cstring + net_buf_size*: cint + last_error*: array[0..(MAX_MYSQL_MANAGER_ERR) - 1, char] + + TMANAGER* = Tst_mysql_manager + PMANAGER* = ptr TMANAGER + Pst_mysql_parameters* = ptr Tst_mysql_parameters + Tst_mysql_parameters*{.final.} = object + p_max_allowed_packet*: ptr int + p_net_buffer_length*: ptr int + + TPARAMETERS* = Tst_mysql_parameters + PPARAMETERS* = ptr TPARAMETERS + Tenum_mysql_stmt_state* = enum + STMT_INIT_DONE = 1, STMT_PREPARE_DONE, STMT_EXECUTE_DONE, STMT_FETCH_DONE + Pst_mysql_bind* = ptr Tst_mysql_bind + Tst_mysql_bind*{.final.} = object + len*: int # output length pointer + is_null*: Pmy_bool # Pointer to null indicator + buffer*: pointer # buffer to get/put data + error*: pmy_bool # set this if you want to track data truncations happened during fetch + buffer_type*: Tenum_field_types # buffer type + buffer_length*: int # buffer length, must be set for str/binary + # Following are for internal use. Set by mysql_stmt_bind_param + row_ptr*: ptr byte # for the current data position + offset*: int # offset position for char/binary fetch + length_value*: int # Used if length is 0 + param_number*: cuint # For null count and error messages + pack_length*: cuint # Internal length for packed data + error_value*: my_bool # used if error is 0 + is_unsigned*: my_bool # set if integer type is unsigned + long_data_used*: my_bool # If used with mysql_send_long_data + is_null_value*: my_bool # Used if is_null is 0 + store_param_func*: proc (net: PNET, param: Pst_mysql_bind){.cdecl.} + fetch_result*: proc (para1: Pst_mysql_bind, para2: PFIELD, row: PPbyte) + skip_result*: proc (para1: Pst_mysql_bind, para2: PFIELD, row: PPbyte) + + TBIND* = Tst_mysql_bind + PBIND* = ptr TBIND # statement handler + Tst_mysql_stmt*{.final.} = object + mem_root*: TMEM_ROOT # root allocations + mysql*: PMySQL # connection handle + params*: PBIND # input parameters + `bind`*: PBIND # input parameters + fields*: PFIELD # result set metadata + result*: TDATA # cached result set + data_cursor*: PROWS # current row in cached result + affected_rows*: my_ulonglong # copy of mysql->affected_rows after statement execution + insert_id*: my_ulonglong + read_row_func*: proc (stmt: Pst_mysql_stmt, row: PPbyte): cint{.cdecl.} + stmt_id*: int # Id for prepared statement + flags*: int # i.e. type of cursor to open + prefetch_rows*: int # number of rows per one COM_FETCH + server_status*: cuint # Copied from mysql->server_status after execute/fetch to know + # server-side cursor status for this statement. + last_errno*: cuint # error code + param_count*: cuint # input parameter count + field_count*: cuint # number of columns in result set + state*: Tenum_mysql_stmt_state # statement state + last_error*: array[0..(ERRMSG_SIZE) - 1, char] # error message + sqlstate*: array[0..(SQLSTATE_LENGTH + 1) - 1, char] + send_types_to_server*: my_bool # Types of input parameters should be sent to server + bind_param_done*: my_bool # input buffers were supplied + bind_result_done*: char # output buffers were supplied + unbuffered_fetch_cancelled*: my_bool + update_max_length*: my_bool + + TSTMT* = Tst_mysql_stmt + + Tenum_stmt_attr_type* = enum + STMT_ATTR_UPDATE_MAX_LENGTH, STMT_ATTR_CURSOR_TYPE, STMT_ATTR_PREFETCH_ROWS + +proc server_init*(argc: cint, argv: cstringArray, groups: cstringArray): cint{. + cdecl, dynlib: lib, importc: "mysql_server_init".} +proc server_end*(){.cdecl, dynlib: lib, importc: "mysql_server_end".} + # mysql_server_init/end need to be called when using libmysqld or + # libmysqlclient (exactly, mysql_server_init() is called by mysql_init() so + # you don't need to call it explicitely; but you need to call + # mysql_server_end() to free memory). The names are a bit misleading + # (mysql_SERVER* to be used when using libmysqlCLIENT). So we add more general + # names which suit well whether you're using libmysqld or libmysqlclient. We + # intend to promote these aliases over the mysql_server* ones. +proc library_init*(argc: cint, argv: cstringArray, groups: cstringArray): cint{. + cdecl, dynlib: lib, importc: "mysql_server_init".} +proc library_end*(){.cdecl, dynlib: lib, importc: "mysql_server_end".} +proc get_parameters*(): PPARAMETERS{.stdcall, dynlib: lib, + importc: "mysql_get_parameters".} + # Set up and bring down a thread; these function should be called + # for each thread in an application which opens at least one MySQL + # connection. All uses of the connection(s) should be between these + # function calls. +proc thread_init*(): my_bool{.stdcall, dynlib: lib, importc: "mysql_thread_init".} +proc thread_end*(){.stdcall, dynlib: lib, importc: "mysql_thread_end".} + # Functions to get information from the MYSQL and MYSQL_RES structures + # Should definitely be used if one uses shared libraries. +proc num_rows*(res: PRES): my_ulonglong{.stdcall, dynlib: lib, + importc: "mysql_num_rows".} +proc num_fields*(res: PRES): cuint{.stdcall, dynlib: lib, + importc: "mysql_num_fields".} +proc eof*(res: PRES): my_bool{.stdcall, dynlib: lib, importc: "mysql_eof".} +proc fetch_field_direct*(res: PRES, fieldnr: cuint): PFIELD{.stdcall, + dynlib: lib, importc: "mysql_fetch_field_direct".} +proc fetch_fields*(res: PRES): PFIELD{.stdcall, dynlib: lib, + importc: "mysql_fetch_fields".} +proc row_tell*(res: PRES): TROW_OFFSET{.stdcall, dynlib: lib, + importc: "mysql_row_tell".} +proc field_tell*(res: PRES): TFIELD_OFFSET{.stdcall, dynlib: lib, + importc: "mysql_field_tell".} +proc field_count*(MySQL: PMySQL): cuint{.stdcall, dynlib: lib, + importc: "mysql_field_count".} +proc affected_rows*(MySQL: PMySQL): my_ulonglong{.stdcall, dynlib: lib, + importc: "mysql_affected_rows".} +proc insert_id*(MySQL: PMySQL): my_ulonglong{.stdcall, dynlib: lib, + importc: "mysql_insert_id".} +proc errno*(MySQL: PMySQL): cuint{.stdcall, dynlib: lib, importc: "mysql_errno".} +proc error*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_error".} +proc sqlstate*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_sqlstate".} +proc warning_count*(MySQL: PMySQL): cuint{.stdcall, dynlib: lib, + importc: "mysql_warning_count".} +proc info*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_info".} +proc thread_id*(MySQL: PMySQL): int{.stdcall, dynlib: lib, importc: "mysql_thread_id".} +proc character_set_name*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, + importc: "mysql_character_set_name".} +proc set_character_set*(MySQL: PMySQL, csname: cstring): int32{.stdcall, dynlib: lib, + importc: "mysql_set_character_set".} +proc init*(MySQL: PMySQL): PMySQL{.stdcall, dynlib: lib, importc: "mysql_init".} +proc ssl_set*(MySQL: PMySQL, key: cstring, cert: cstring, ca: cstring, capath: cstring, + cipher: cstring): my_bool{.stdcall, dynlib: lib, + importc: "mysql_ssl_set".} +proc change_user*(MySQL: PMySQL, user: cstring, passwd: cstring, db: cstring): my_bool{. + stdcall, dynlib: lib, importc: "mysql_change_user".} +proc real_connect*(MySQL: PMySQL, host: cstring, user: cstring, passwd: cstring, + db: cstring, port: cuint, unix_socket: cstring, + clientflag: int): PMySQL{.stdcall, dynlib: lib, + importc: "mysql_real_connect".} +proc select_db*(MySQL: PMySQL, db: cstring): cint{.stdcall, dynlib: lib, + importc: "mysql_select_db".} +proc query*(MySQL: PMySQL, q: cstring): cint{.stdcall, dynlib: lib, importc: "mysql_query".} +proc send_query*(MySQL: PMySQL, q: cstring, len: int): cint{.stdcall, dynlib: lib, + importc: "mysql_send_query".} +proc real_query*(MySQL: PMySQL, q: cstring, len: int): cint{.stdcall, dynlib: lib, + importc: "mysql_real_query".} +proc store_result*(MySQL: PMySQL): PRES{.stdcall, dynlib: lib, + importc: "mysql_store_result".} +proc use_result*(MySQL: PMySQL): PRES{.stdcall, dynlib: lib, importc: "mysql_use_result".} + # perform query on master +proc master_query*(MySQL: PMySQL, q: cstring, len: int): my_bool{.stdcall, dynlib: lib, + importc: "mysql_master_query".} +proc master_send_query*(MySQL: PMySQL, q: cstring, len: int): my_bool{.stdcall, + dynlib: lib, importc: "mysql_master_send_query".} + # perform query on slave +proc slave_query*(MySQL: PMySQL, q: cstring, len: int): my_bool{.stdcall, dynlib: lib, + importc: "mysql_slave_query".} +proc slave_send_query*(MySQL: PMySQL, q: cstring, len: int): my_bool{.stdcall, + dynlib: lib, importc: "mysql_slave_send_query".} +proc get_character_set_info*(MySQL: PMySQL, charset: PMY_CHARSET_INFO){.stdcall, + dynlib: lib, importc: "mysql_get_character_set_info".} + # local infile support +const + LOCAL_INFILE_ERROR_LEN* = 512 + +# procedure mysql_set_local_infile_handler(mysql:PMYSQL; local_infile_init:function (para1:Ppointer; para2:Pchar; para3:pointer):longint; local_infile_read:function (para1:pointer; para2:Pchar; para3:dword):longint; local_infile_end:procedure (_pa +# para6:pointer);cdecl;external mysqllib name 'mysql_set_local_infile_handler'; + +proc set_local_infile_default*(MySQL: PMySQL){.cdecl, dynlib: lib, + importc: "mysql_set_local_infile_default".} + # enable/disable parsing of all queries to decide if they go on master or + # slave +proc enable_rpl_parse*(MySQL: PMySQL){.stdcall, dynlib: lib, + importc: "mysql_enable_rpl_parse".} +proc disable_rpl_parse*(MySQL: PMySQL){.stdcall, dynlib: lib, + importc: "mysql_disable_rpl_parse".} + # get the value of the parse flag +proc rpl_parse_enabled*(MySQL: PMySQL): cint{.stdcall, dynlib: lib, + importc: "mysql_rpl_parse_enabled".} + # enable/disable reads from master +proc enable_reads_from_master*(MySQL: PMySQL){.stdcall, dynlib: lib, + importc: "mysql_enable_reads_from_master".} +proc disable_reads_from_master*(MySQL: PMySQL){.stdcall, dynlib: lib, importc: "mysql_disable_reads_from_master".} + # get the value of the master read flag +proc reads_from_master_enabled*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, + importc: "mysql_reads_from_master_enabled".} +proc rpl_query_type*(q: cstring, length: cint): Trpl_type{.stdcall, dynlib: lib, + importc: "mysql_rpl_query_type".} + # discover the master and its slaves +proc rpl_probe*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, importc: "mysql_rpl_probe".} + # set the master, close/free the old one, if it is not a pivot +proc set_master*(MySQL: PMySQL, host: cstring, port: cuint, user: cstring, passwd: cstring): cint{. + stdcall, dynlib: lib, importc: "mysql_set_master".} +proc add_slave*(MySQL: PMySQL, host: cstring, port: cuint, user: cstring, passwd: cstring): cint{. + stdcall, dynlib: lib, importc: "mysql_add_slave".} +proc shutdown*(MySQL: PMySQL, shutdown_level: Tenum_shutdown_level): cint{.stdcall, + dynlib: lib, importc: "mysql_shutdown".} +proc dump_debug_info*(MySQL: PMySQL): cint{.stdcall, dynlib: lib, + importc: "mysql_dump_debug_info".} +proc refresh*(MySQL: PMySQL, refresh_options: cuint): cint{.stdcall, dynlib: lib, + importc: "mysql_refresh".} +proc kill*(MySQL: PMySQL, pid: int): cint{.stdcall, dynlib: lib, importc: "mysql_kill".} +proc set_server_option*(MySQL: PMySQL, option: Tenum_mysql_set_option): cint{.stdcall, + dynlib: lib, importc: "mysql_set_server_option".} +proc ping*(MySQL: PMySQL): cint{.stdcall, dynlib: lib, importc: "mysql_ping".} +proc stat*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_stat".} +proc get_server_info*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, + importc: "mysql_get_server_info".} +proc get_client_info*(): cstring{.stdcall, dynlib: lib, + importc: "mysql_get_client_info".} +proc get_client_version*(): int{.stdcall, dynlib: lib, + importc: "mysql_get_client_version".} +proc get_host_info*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, + importc: "mysql_get_host_info".} +proc get_server_version*(MySQL: PMySQL): int{.stdcall, dynlib: lib, + importc: "mysql_get_server_version".} +proc get_proto_info*(MySQL: PMySQL): cuint{.stdcall, dynlib: lib, + importc: "mysql_get_proto_info".} +proc list_dbs*(MySQL: PMySQL, wild: cstring): PRES{.stdcall, dynlib: lib, + importc: "mysql_list_dbs".} +proc list_tables*(MySQL: PMySQL, wild: cstring): PRES{.stdcall, dynlib: lib, + importc: "mysql_list_tables".} +proc list_processes*(MySQL: PMySQL): PRES{.stdcall, dynlib: lib, + importc: "mysql_list_processes".} +proc options*(MySQL: PMySQL, option: Toption, arg: cstring): cint{.stdcall, dynlib: lib, + importc: "mysql_options".} +proc free_result*(result: PRES){.stdcall, dynlib: lib, + importc: "mysql_free_result".} +proc data_seek*(result: PRES, offset: my_ulonglong){.stdcall, dynlib: lib, + importc: "mysql_data_seek".} +proc row_seek*(result: PRES, offset: TROW_OFFSET): TROW_OFFSET{.stdcall, + dynlib: lib, importc: "mysql_row_seek".} +proc field_seek*(result: PRES, offset: TFIELD_OFFSET): TFIELD_OFFSET{.stdcall, + dynlib: lib, importc: "mysql_field_seek".} +proc fetch_row*(result: PRES): TROW{.stdcall, dynlib: lib, + importc: "mysql_fetch_row".} +proc fetch_lengths*(result: PRES): ptr int{.stdcall, dynlib: lib, + importc: "mysql_fetch_lengths".} +proc fetch_field*(result: PRES): PFIELD{.stdcall, dynlib: lib, + importc: "mysql_fetch_field".} +proc list_fields*(MySQL: PMySQL, table: cstring, wild: cstring): PRES{.stdcall, + dynlib: lib, importc: "mysql_list_fields".} +proc escape_string*(fto: cstring, `from`: cstring, from_length: int): int{. + stdcall, dynlib: lib, importc: "mysql_escape_string".} +proc hex_string*(fto: cstring, `from`: cstring, from_length: int): int{.stdcall, + dynlib: lib, importc: "mysql_hex_string".} +proc real_escape_string*(MySQL: PMySQL, fto: cstring, `from`: cstring, len: int): int{. + stdcall, dynlib: lib, importc: "mysql_real_escape_string".} +proc debug*(debug: cstring){.stdcall, dynlib: lib, importc: "mysql_debug".} + # function mysql_odbc_escape_string(mysql:PMYSQL; fto:Pchar; to_length:dword; from:Pchar; from_length:dword; + # param:pointer; extend_buffer:function (para1:pointer; to:Pchar; length:Pdword):Pchar):Pchar;stdcall;external mysqllib name 'mysql_odbc_escape_string'; +proc myodbc_remove_escape*(MySQL: PMySQL, name: cstring){.stdcall, dynlib: lib, + importc: "myodbc_remove_escape".} +proc thread_safe*(): cuint{.stdcall, dynlib: lib, importc: "mysql_thread_safe".} +proc embedded*(): my_bool{.stdcall, dynlib: lib, importc: "mysql_embedded".} +proc manager_init*(con: PMANAGER): PMANAGER{.stdcall, dynlib: lib, + importc: "mysql_manager_init".} +proc manager_connect*(con: PMANAGER, host: cstring, user: cstring, + passwd: cstring, port: cuint): PMANAGER{.stdcall, + dynlib: lib, importc: "mysql_manager_connect".} +proc manager_close*(con: PMANAGER){.stdcall, dynlib: lib, + importc: "mysql_manager_close".} +proc manager_command*(con: PMANAGER, cmd: cstring, cmd_len: cint): cint{. + stdcall, dynlib: lib, importc: "mysql_manager_command".} +proc manager_fetch_line*(con: PMANAGER, res_buf: cstring, res_buf_size: cint): cint{. + stdcall, dynlib: lib, importc: "mysql_manager_fetch_line".} +proc read_query_result*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, + importc: "mysql_read_query_result".} +proc stmt_init*(MySQL: PMySQL): PSTMT{.stdcall, dynlib: lib, importc: "mysql_stmt_init".} +proc stmt_prepare*(stmt: PSTMT, query: cstring, len: int): cint{.stdcall, + dynlib: lib, importc: "mysql_stmt_prepare".} +proc stmt_execute*(stmt: PSTMT): cint{.stdcall, dynlib: lib, + importc: "mysql_stmt_execute".} +proc stmt_fetch*(stmt: PSTMT): cint{.stdcall, dynlib: lib, + importc: "mysql_stmt_fetch".} +proc stmt_fetch_column*(stmt: PSTMT, `bind`: PBIND, column: cuint, offset: int): cint{. + stdcall, dynlib: lib, importc: "mysql_stmt_fetch_column".} +proc stmt_store_result*(stmt: PSTMT): cint{.stdcall, dynlib: lib, + importc: "mysql_stmt_store_result".} +proc stmt_param_count*(stmt: PSTMT): int{.stdcall, dynlib: lib, + importc: "mysql_stmt_param_count".} +proc stmt_attr_set*(stmt: PSTMT, attr_type: Tenum_stmt_attr_type, attr: pointer): my_bool{. + stdcall, dynlib: lib, importc: "mysql_stmt_attr_set".} +proc stmt_attr_get*(stmt: PSTMT, attr_type: Tenum_stmt_attr_type, attr: pointer): my_bool{. + stdcall, dynlib: lib, importc: "mysql_stmt_attr_get".} +proc stmt_bind_param*(stmt: PSTMT, bnd: PBIND): my_bool{.stdcall, dynlib: lib, + importc: "mysql_stmt_bind_param".} +proc stmt_bind_result*(stmt: PSTMT, bnd: PBIND): my_bool{.stdcall, dynlib: lib, + importc: "mysql_stmt_bind_result".} +proc stmt_close*(stmt: PSTMT): my_bool{.stdcall, dynlib: lib, + importc: "mysql_stmt_close".} +proc stmt_reset*(stmt: PSTMT): my_bool{.stdcall, dynlib: lib, + importc: "mysql_stmt_reset".} +proc stmt_free_result*(stmt: PSTMT): my_bool{.stdcall, dynlib: lib, + importc: "mysql_stmt_free_result".} +proc stmt_send_long_data*(stmt: PSTMT, param_number: cuint, data: cstring, + len: int): my_bool{.stdcall, dynlib: lib, + importc: "mysql_stmt_send_long_data".} +proc stmt_result_metadata*(stmt: PSTMT): PRES{.stdcall, dynlib: lib, + importc: "mysql_stmt_result_metadata".} +proc stmt_param_metadata*(stmt: PSTMT): PRES{.stdcall, dynlib: lib, + importc: "mysql_stmt_param_metadata".} +proc stmt_errno*(stmt: PSTMT): cuint{.stdcall, dynlib: lib, + importc: "mysql_stmt_errno".} +proc stmt_error*(stmt: PSTMT): cstring{.stdcall, dynlib: lib, + importc: "mysql_stmt_error".} +proc stmt_sqlstate*(stmt: PSTMT): cstring{.stdcall, dynlib: lib, + importc: "mysql_stmt_sqlstate".} +proc stmt_row_seek*(stmt: PSTMT, offset: TROW_OFFSET): TROW_OFFSET{.stdcall, + dynlib: lib, importc: "mysql_stmt_row_seek".} +proc stmt_row_tell*(stmt: PSTMT): TROW_OFFSET{.stdcall, dynlib: lib, + importc: "mysql_stmt_row_tell".} +proc stmt_data_seek*(stmt: PSTMT, offset: my_ulonglong){.stdcall, dynlib: lib, + importc: "mysql_stmt_data_seek".} +proc stmt_num_rows*(stmt: PSTMT): my_ulonglong{.stdcall, dynlib: lib, + importc: "mysql_stmt_num_rows".} +proc stmt_affected_rows*(stmt: PSTMT): my_ulonglong{.stdcall, dynlib: lib, + importc: "mysql_stmt_affected_rows".} +proc stmt_insert_id*(stmt: PSTMT): my_ulonglong{.stdcall, dynlib: lib, + importc: "mysql_stmt_insert_id".} +proc stmt_field_count*(stmt: PSTMT): cuint{.stdcall, dynlib: lib, + importc: "mysql_stmt_field_count".} +proc commit*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, importc: "mysql_commit".} +proc rollback*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, importc: "mysql_rollback".} +proc autocommit*(MySQL: PMySQL, auto_mode: my_bool): my_bool{.stdcall, dynlib: lib, + importc: "mysql_autocommit".} +proc more_results*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, + importc: "mysql_more_results".} +proc next_result*(MySQL: PMySQL): cint{.stdcall, dynlib: lib, importc: "mysql_next_result".} +proc close*(sock: PMySQL){.stdcall, dynlib: lib, importc: "mysql_close".} + # status return codes +const + NO_DATA* = 100 + DATA_TRUNCATED* = 101 + +proc reload*(MySQL: PMySQL): cint +when defined(USE_OLD_FUNCTIONS): + proc connect*(MySQL: PMySQL, host: cstring, user: cstring, passwd: cstring): PMySQL{.stdcall, + dynlib: lib, importc: "mysql_connect".} + proc create_db*(MySQL: PMySQL, DB: cstring): cint{.stdcall, dynlib: lib, + importc: "mysql_create_db".} + proc drop_db*(MySQL: PMySQL, DB: cstring): cint{.stdcall, dynlib: lib, + importc: "mysql_drop_db".} +proc net_safe_read*(MySQL: PMySQL): cuint{.cdecl, dynlib: lib, importc: "net_safe_read".} + +proc IS_PRI_KEY(n: int32): bool = + result = (n and PRI_KEY_FLAG) != 0 + +proc IS_NOT_NULL(n: int32): bool = + result = (n and NOT_NULL_FLAG) != 0 + +proc IS_BLOB(n: int32): bool = + result = (n and BLOB_FLAG) != 0 + +proc IS_NUM_FIELD(f: pst_mysql_field): bool = + result = (f.flags and NUM_FLAG) != 0 + +proc IS_NUM(t: Tenum_field_types): bool = + result = (t <= FIELD_TYPE_INT24) or (t == FIELD_TYPE_YEAR) or + (t == FIELD_TYPE_NEWDECIMAL) + +proc INTERNAL_NUM_FIELD(f: Pst_mysql_field): bool = + result = (f.ftype <= FIELD_TYPE_INT24) and + ((f.ftype != FIELD_TYPE_TIMESTAMP) or (f.len == 14) or (f.len == 8)) or + (f.ftype == FIELD_TYPE_YEAR) + +proc reload(mysql: PMySQL): cint = + result = refresh(mysql, REFRESH_GRANT) diff --git a/lib/wrappers/sqlite3.nim b/lib/wrappers/sqlite3.nim new file mode 100755 index 000000000..a5d2189a2 --- /dev/null +++ b/lib/wrappers/sqlite3.nim @@ -0,0 +1,356 @@ +# +# +# Nimrod's Runtime Library +# (c) Copyright 2010 Andreas Rumpf +# +# See the file "copying.txt", included in this +# distribution, for details about the copyright. +# + +{.deadCodeElim: on.} +when defined(windows): + const + Lib = "sqlite3.dll" +elif defined(macosx): + const + Lib = "sqlite-3.6.13.dylib" +else: + const + Lib = "libsqlite3.so" + +const + SQLITE_INTEGER* = 1 + SQLITE_FLOAT* = 2 + SQLITE_BLOB* = 4 + SQLITE_NULL* = 5 + SQLITE_TEXT* = 3 + SQLITE_UTF8* = 1 + SQLITE_UTF16LE* = 2 + SQLITE_UTF16BE* = 3 # Use native byte order + SQLITE_UTF16* = 4 # sqlite3_create_function only + SQLITE_ANY* = 5 #sqlite_exec return values + SQLITE_OK* = 0 + SQLITE_ERROR* = 1 # SQL error or missing database + SQLITE_INTERNAL* = 2 # An internal logic error in SQLite + SQLITE_PERM* = 3 # Access permission denied + SQLITE_ABORT* = 4 # Callback routine requested an abort + SQLITE_BUSY* = 5 # The database file is locked + SQLITE_LOCKED* = 6 # A table in the database is locked + SQLITE_NOMEM* = 7 # A malloc() failed + SQLITE_READONLY* = 8 # Attempt to write a readonly database + SQLITE_INTERRUPT* = 9 # Operation terminated by sqlite3_interrupt() + SQLITE_IOERR* = 10 # Some kind of disk I/O error occurred + SQLITE_CORRUPT* = 11 # The database disk image is malformed + SQLITE_NOTFOUND* = 12 # (Internal Only) Table or record not found + SQLITE_FULL* = 13 # Insertion failed because database is full + SQLITE_CANTOPEN* = 14 # Unable to open the database file + SQLITE_PROTOCOL* = 15 # Database lock protocol error + SQLITE_EMPTY* = 16 # Database is empty + SQLITE_SCHEMA* = 17 # The database schema changed + SQLITE_TOOBIG* = 18 # Too much data for one row of a table + SQLITE_CONSTRAINT* = 19 # Abort due to contraint violation + SQLITE_MISMATCH* = 20 # Data type mismatch + SQLITE_MISUSE* = 21 # Library used incorrectly + SQLITE_NOLFS* = 22 # Uses OS features not supported on host + SQLITE_AUTH* = 23 # Authorization denied + SQLITE_FORMAT* = 24 # Auxiliary database format error + SQLITE_RANGE* = 25 # 2nd parameter to sqlite3_bind out of range + SQLITE_NOTADB* = 26 # File opened that is not a database file + SQLITE_ROW* = 100 # sqlite3_step() has another row ready + SQLITE_DONE* = 101 # sqlite3_step() has finished executing + SQLITE_COPY* = 0 + SQLITE_CREATE_INDEX* = 1 + SQLITE_CREATE_TABLE* = 2 + SQLITE_CREATE_TEMP_INDEX* = 3 + SQLITE_CREATE_TEMP_TABLE* = 4 + SQLITE_CREATE_TEMP_TRIGGER* = 5 + SQLITE_CREATE_TEMP_VIEW* = 6 + SQLITE_CREATE_TRIGGER* = 7 + SQLITE_CREATE_VIEW* = 8 + SQLITE_DELETE* = 9 + SQLITE_DROP_INDEX* = 10 + SQLITE_DROP_TABLE* = 11 + SQLITE_DROP_TEMP_INDEX* = 12 + SQLITE_DROP_TEMP_TABLE* = 13 + SQLITE_DROP_TEMP_TRIGGER* = 14 + SQLITE_DROP_TEMP_VIEW* = 15 + SQLITE_DROP_TRIGGER* = 16 + SQLITE_DROP_VIEW* = 17 + SQLITE_INSERT* = 18 + SQLITE_PRAGMA* = 19 + SQLITE_READ* = 20 + SQLITE_SELECT* = 21 + SQLITE_TRANSACTION* = 22 + SQLITE_UPDATE* = 23 + SQLITE_ATTACH* = 24 + SQLITE_DETACH* = 25 + SQLITE_ALTER_TABLE* = 26 + SQLITE_REINDEX* = 27 + SQLITE_DENY* = 1 + SQLITE_IGNORE* = 2 # Original from sqlite3.h: + ##define SQLITE_STATIC ((void(*)(void *))0) + ##define SQLITE_TRANSIENT ((void(*)(void *))-1) + +const + SQLITE_STATIC* = nil + SQLITE_TRANSIENT* = cast[pointer](- 1) + +type + TSqlite3 {.pure, final.} = object + PSqlite3* = ptr TSqlite3 + PPSqlite3* = ptr PSqlite3 + TContext{.pure, final.} = object + Pcontext* = ptr TContext + Tstmt{.pure, final.} = object + Pstmt* = ptr Tstmt + Tvalue{.pure, final.} = object + Pvalue* = ptr Tvalue + PPValue* = ptr Pvalue + + Tcallback* = proc (para1: pointer, para2: int32, para3, + para4: cstringArray): int32{.cdecl.} + Tbind_destructor_func* = proc (para1: pointer){.cdecl.} + Tcreate_function_step_func* = proc (para1: Pcontext, para2: int32, + para3: PPValue){.cdecl.} + Tcreate_function_func_func* = proc (para1: Pcontext, para2: int32, + para3: PPValue){.cdecl.} + Tcreate_function_final_func* = proc (para1: Pcontext){.cdecl.} + Tresult_func* = proc (para1: pointer){.cdecl.} + Tcreate_collation_func* = proc (para1: pointer, para2: int32, para3: pointer, + para4: int32, para5: pointer): int32{.cdecl.} + Tcollation_needed_func* = proc (para1: pointer, para2: PSqlite3, eTextRep: int32, + para4: cstring){.cdecl.} + +proc close*(para1: PSqlite3): int32{.cdecl, dynlib: Lib, importc: "sqlite3_close".} +proc exec*(para1: PSqlite3, sql: cstring, para3: Tcallback, para4: pointer, + errmsg: var cstring): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_exec".} +proc last_insert_rowid*(para1: PSqlite3): int64{.cdecl, dynlib: Lib, + importc: "sqlite3_last_insert_rowid".} +proc changes*(para1: PSqlite3): int32{.cdecl, dynlib: Lib, importc: "sqlite3_changes".} +proc total_changes*(para1: PSqlite3): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_total_changes".} +proc interrupt*(para1: PSqlite3){.cdecl, dynlib: Lib, importc: "sqlite3_interrupt".} +proc complete*(sql: cstring): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_complete".} +proc complete16*(sql: pointer): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_complete16".} +proc busy_handler*(para1: PSqlite3, + para2: proc (para1: pointer, para2: int32): int32{.cdecl.}, + para3: pointer): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_busy_handler".} +proc busy_timeout*(para1: PSqlite3, ms: int32): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_busy_timeout".} +proc get_table*(para1: PSqlite3, sql: cstring, resultp: var cstringArray, + nrow, ncolumn: var cint, errmsg: ptr cstring): int32{.cdecl, + dynlib: Lib, importc: "sqlite3_get_table".} +proc free_table*(result: cstringArray){.cdecl, dynlib: Lib, + importc: "sqlite3_free_table".} + # Todo: see how translate sqlite3_mprintf, sqlite3_vmprintf, sqlite3_snprintf + # function sqlite3_mprintf(_para1:Pchar; args:array of const):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_mprintf'; +proc mprintf*(para1: cstring): cstring{.cdecl, varargs, dynlib: Lib, + importc: "sqlite3_mprintf".} + #function sqlite3_vmprintf(_para1:Pchar; _para2:va_list):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_vmprintf'; +proc free*(z: cstring){.cdecl, dynlib: Lib, importc: "sqlite3_free".} + #function sqlite3_snprintf(_para1:longint; _para2:Pchar; _para3:Pchar; args:array of const):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_snprintf'; +proc snprintf*(para1: int32, para2: cstring, para3: cstring): cstring{.cdecl, + dynlib: Lib, varargs, importc: "sqlite3_snprintf".} +proc set_authorizer*(para1: PSqlite3, xAuth: proc (para1: pointer, para2: int32, + para3: cstring, para4: cstring, para5: cstring, para6: cstring): int32{. + cdecl.}, pUserData: pointer): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_set_authorizer".} +proc trace*(para1: PSqlite3, xTrace: proc (para1: pointer, para2: cstring){.cdecl.}, + para3: pointer): pointer{.cdecl, dynlib: Lib, + importc: "sqlite3_trace".} +proc progress_handler*(para1: PSqlite3, para2: int32, + para3: proc (para1: pointer): int32{.cdecl.}, + para4: pointer){.cdecl, dynlib: Lib, + importc: "sqlite3_progress_handler".} +proc commit_hook*(para1: PSqlite3, para2: proc (para1: pointer): int32{.cdecl.}, + para3: pointer): pointer{.cdecl, dynlib: Lib, + importc: "sqlite3_commit_hook".} +proc open*(filename: cstring, ppDb: var PSqlite3): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_open".} +proc open16*(filename: pointer, ppDb: var PSqlite3): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_open16".} +proc errcode*(db: PSqlite3): int32{.cdecl, dynlib: Lib, importc: "sqlite3_errcode".} +proc errmsg*(para1: PSqlite3): cstring{.cdecl, dynlib: Lib, importc: "sqlite3_errmsg".} +proc errmsg16*(para1: PSqlite3): pointer{.cdecl, dynlib: Lib, + importc: "sqlite3_errmsg16".} +proc prepare*(db: PSqlite3, zSql: cstring, nBytes: int32, ppStmt: var PStmt, + pzTail: ptr cstring): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_prepare".} + +proc prepare_v2*(db: PSqlite3, zSql: cstring, nByte: cint, ppStmt: var PStmt, + pzTail: ptr cstring): cint {. + importc: "sqlite3_prepare_v2", cdecl, dynlib: Lib.} + +proc prepare16*(db: PSqlite3, zSql: pointer, nBytes: int32, ppStmt: var PStmt, + pzTail: var pointer): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_prepare16".} +proc bind_blob*(para1: Pstmt, para2: int32, para3: pointer, n: int32, + para5: Tbind_destructor_func): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_bind_blob".} +proc bind_double*(para1: Pstmt, para2: int32, para3: float64): int32{.cdecl, + dynlib: Lib, importc: "sqlite3_bind_double".} +proc bind_int*(para1: Pstmt, para2: int32, para3: int32): int32{.cdecl, + dynlib: Lib, importc: "sqlite3_bind_int".} +proc bind_int64*(para1: Pstmt, para2: int32, para3: int64): int32{.cdecl, + dynlib: Lib, importc: "sqlite3_bind_int64".} +proc bind_null*(para1: Pstmt, para2: int32): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_bind_null".} +proc bind_text*(para1: Pstmt, para2: int32, para3: cstring, n: int32, + para5: Tbind_destructor_func): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_bind_text".} +proc bind_text16*(para1: Pstmt, para2: int32, para3: pointer, para4: int32, + para5: Tbind_destructor_func): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_bind_text16".} + #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 + #It's the c world man ;-) +proc bind_blob*(para1: Pstmt, para2: int32, para3: pointer, n: int32, + para5: int32): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_bind_blob".} +proc bind_text*(para1: Pstmt, para2: int32, para3: cstring, n: int32, + para5: int32): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_bind_text".} +proc bind_text16*(para1: Pstmt, para2: int32, para3: pointer, para4: int32, + para5: int32): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_bind_text16".} +proc bind_parameter_count*(para1: Pstmt): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_bind_parameter_count".} +proc bind_parameter_name*(para1: Pstmt, para2: int32): cstring{.cdecl, + dynlib: Lib, importc: "sqlite3_bind_parameter_name".} +proc bind_parameter_index*(para1: Pstmt, zName: cstring): int32{.cdecl, + dynlib: Lib, importc: "sqlite3_bind_parameter_index".} + #function sqlite3_clear_bindings(_para1:Psqlite3_stmt):longint;cdecl; external Sqlite3Lib name 'sqlite3_clear_bindings'; +proc column_count*(pStmt: Pstmt): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_column_count".} +proc column_name*(para1: Pstmt, para2: int32): cstring{.cdecl, dynlib: Lib, + importc: "sqlite3_column_name".} +proc column_name16*(para1: Pstmt, para2: int32): pointer{.cdecl, dynlib: Lib, + importc: "sqlite3_column_name16".} +proc column_decltype*(para1: Pstmt, i: int32): cstring{.cdecl, dynlib: Lib, + importc: "sqlite3_column_decltype".} +proc column_decltype16*(para1: Pstmt, para2: int32): pointer{.cdecl, + dynlib: Lib, importc: "sqlite3_column_decltype16".} +proc step*(para1: Pstmt): int32{.cdecl, dynlib: Lib, importc: "sqlite3_step".} +proc data_count*(pStmt: Pstmt): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_data_count".} +proc column_blob*(para1: Pstmt, iCol: int32): pointer{.cdecl, dynlib: Lib, + importc: "sqlite3_column_blob".} +proc column_bytes*(para1: Pstmt, iCol: int32): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_column_bytes".} +proc column_bytes16*(para1: Pstmt, iCol: int32): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_column_bytes16".} +proc column_double*(para1: Pstmt, iCol: int32): float64{.cdecl, dynlib: Lib, + importc: "sqlite3_column_double".} +proc column_int*(para1: Pstmt, iCol: int32): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_column_int".} +proc column_int64*(para1: Pstmt, iCol: int32): int64{.cdecl, dynlib: Lib, + importc: "sqlite3_column_int64".} +proc column_text*(para1: Pstmt, iCol: int32): cstring{.cdecl, dynlib: Lib, + importc: "sqlite3_column_text".} +proc column_text16*(para1: Pstmt, iCol: int32): pointer{.cdecl, dynlib: Lib, + importc: "sqlite3_column_text16".} +proc column_type*(para1: Pstmt, iCol: int32): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_column_type".} +proc finalize*(pStmt: Pstmt): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_finalize".} +proc reset*(pStmt: Pstmt): int32{.cdecl, dynlib: Lib, importc: "sqlite3_reset".} +proc create_function*(para1: PSqlite3, zFunctionName: cstring, nArg: int32, + eTextRep: int32, para5: pointer, + xFunc: Tcreate_function_func_func, + xStep: Tcreate_function_step_func, + xFinal: Tcreate_function_final_func): int32{.cdecl, + dynlib: Lib, importc: "sqlite3_create_function".} +proc create_function16*(para1: PSqlite3, zFunctionName: pointer, nArg: int32, + eTextRep: int32, para5: pointer, + xFunc: Tcreate_function_func_func, + xStep: Tcreate_function_step_func, + xFinal: Tcreate_function_final_func): int32{.cdecl, + dynlib: Lib, importc: "sqlite3_create_function16".} +proc aggregate_count*(para1: Pcontext): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_aggregate_count".} +proc value_blob*(para1: Pvalue): pointer{.cdecl, dynlib: Lib, + importc: "sqlite3_value_blob".} +proc value_bytes*(para1: Pvalue): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_value_bytes".} +proc value_bytes16*(para1: Pvalue): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_value_bytes16".} +proc value_double*(para1: Pvalue): float64{.cdecl, dynlib: Lib, + importc: "sqlite3_value_double".} +proc value_int*(para1: Pvalue): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_value_int".} +proc value_int64*(para1: Pvalue): int64{.cdecl, dynlib: Lib, + importc: "sqlite3_value_int64".} +proc value_text*(para1: Pvalue): cstring{.cdecl, dynlib: Lib, + importc: "sqlite3_value_text".} +proc value_text16*(para1: Pvalue): pointer{.cdecl, dynlib: Lib, + importc: "sqlite3_value_text16".} +proc value_text16le*(para1: Pvalue): pointer{.cdecl, dynlib: Lib, + importc: "sqlite3_value_text16le".} +proc value_text16be*(para1: Pvalue): pointer{.cdecl, dynlib: Lib, + importc: "sqlite3_value_text16be".} +proc value_type*(para1: Pvalue): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_value_type".} +proc aggregate_context*(para1: Pcontext, nBytes: int32): pointer{.cdecl, + dynlib: Lib, importc: "sqlite3_aggregate_context".} +proc user_data*(para1: Pcontext): pointer{.cdecl, dynlib: Lib, + importc: "sqlite3_user_data".} +proc get_auxdata*(para1: Pcontext, para2: int32): pointer{.cdecl, dynlib: Lib, + importc: "sqlite3_get_auxdata".} +proc set_auxdata*(para1: Pcontext, para2: int32, para3: pointer, + para4: proc (para1: pointer){.cdecl.}){.cdecl, dynlib: Lib, + importc: "sqlite3_set_auxdata".} +proc result_blob*(para1: Pcontext, para2: pointer, para3: int32, + para4: Tresult_func){.cdecl, dynlib: Lib, + importc: "sqlite3_result_blob".} +proc result_double*(para1: Pcontext, para2: float64){.cdecl, dynlib: Lib, + importc: "sqlite3_result_double".} +proc result_error*(para1: Pcontext, para2: cstring, para3: int32){.cdecl, + dynlib: Lib, importc: "sqlite3_result_error".} +proc result_error16*(para1: Pcontext, para2: pointer, para3: int32){.cdecl, + dynlib: Lib, importc: "sqlite3_result_error16".} +proc result_int*(para1: Pcontext, para2: int32){.cdecl, dynlib: Lib, + importc: "sqlite3_result_int".} +proc result_int64*(para1: Pcontext, para2: int64){.cdecl, dynlib: Lib, + importc: "sqlite3_result_int64".} +proc result_null*(para1: Pcontext){.cdecl, dynlib: Lib, + importc: "sqlite3_result_null".} +proc result_text*(para1: Pcontext, para2: cstring, para3: int32, + para4: Tresult_func){.cdecl, dynlib: Lib, + importc: "sqlite3_result_text".} +proc result_text16*(para1: Pcontext, para2: pointer, para3: int32, + para4: Tresult_func){.cdecl, dynlib: Lib, + importc: "sqlite3_result_text16".} +proc result_text16le*(para1: Pcontext, para2: pointer, para3: int32, + para4: Tresult_func){.cdecl, dynlib: Lib, + importc: "sqlite3_result_text16le".} +proc result_text16be*(para1: Pcontext, para2: pointer, para3: int32, + para4: Tresult_func){.cdecl, dynlib: Lib, + importc: "sqlite3_result_text16be".} +proc result_value*(para1: Pcontext, para2: Pvalue){.cdecl, dynlib: Lib, + importc: "sqlite3_result_value".} +proc create_collation*(para1: PSqlite3, zName: cstring, eTextRep: int32, + para4: pointer, xCompare: Tcreate_collation_func): int32{. + cdecl, dynlib: Lib, importc: "sqlite3_create_collation".} +proc create_collation16*(para1: PSqlite3, zName: cstring, eTextRep: int32, + para4: pointer, xCompare: Tcreate_collation_func): int32{. + cdecl, dynlib: Lib, importc: "sqlite3_create_collation16".} +proc collation_needed*(para1: PSqlite3, para2: pointer, para3: Tcollation_needed_func): int32{. + cdecl, dynlib: Lib, importc: "sqlite3_collation_needed".} +proc collation_needed16*(para1: PSqlite3, para2: pointer, para3: Tcollation_needed_func): int32{. + cdecl, dynlib: Lib, importc: "sqlite3_collation_needed16".} +proc libversion*(): cstring{.cdecl, dynlib: Lib, importc: "sqlite3_libversion".} + #Alias for allowing better code portability (win32 is not working with external variables) +proc version*(): cstring{.cdecl, dynlib: Lib, importc: "sqlite3_libversion".} + # Not published functions +proc libversion_number*(): int32{.cdecl, dynlib: Lib, + importc: "sqlite3_libversion_number".} + #function sqlite3_key(db:Psqlite3; pKey:pointer; nKey:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_key'; + #function sqlite3_rekey(db:Psqlite3; pKey:pointer; nKey:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_rekey'; + #function sqlite3_sleep(_para1:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_sleep'; + #function sqlite3_expired(_para1:Psqlite3_stmt):longint;cdecl; external Sqlite3Lib name 'sqlite3_expired'; + #function sqlite3_global_recover:longint;cdecl; external Sqlite3Lib name 'sqlite3_global_recover'; +# implementation diff --git a/lib/wrappers/tcl.nim b/lib/wrappers/tcl.nim new file mode 100755 index 000000000..f2ecf558d --- /dev/null +++ b/lib/wrappers/tcl.nim @@ -0,0 +1,866 @@ +# +# +# Nimrod's Runtime Library +# (c) Copyright 2010 Andreas Rumpf +# +# See the file "copying.txt", included in this +# distribution, for details about the copyright. +# + +## This module is a wrapper for the TCL programming language. + +# +# tcl.h -- +# +# This header file describes the externally-visible facilities of the Tcl +# interpreter. +# +# Translated to Pascal Copyright (c) 2002 by Max Artemev +# aka Bert Raccoon (bert@furry.ru, bert_raccoon@freemail.ru) +# +# +# Copyright (c) 1998-2000 by Scriptics Corporation. +# Copyright (c) 1994-1998 Sun Microsystems, Inc. +# Copyright (c) 1993-1996 Lucent Technologies. +# Copyright (c) 1987-1994 John Ousterhout, The Regents of the +# University of California, Berkeley. +# +# *********************************************************************** +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# *********************************************************************** +# + +{.deadCodeElim: on.} + +when defined(WIN32): + const + dllName = "tcl(85|84|83|82|81|80).dll" +elif defined(macosx): + const + dllName = "libtcl(8.5|8.4|8.3|8.2|8.1).dynlib" +else: + const + dllName = "libtcl(8.5|8.4|8.3|8.2|8.1).so.(1|0)" +const + TCL_DESTROYED* = 0xDEADDEAD + TCL_OK* = 0 + TCL_ERROR* = 1 + TCL_RETURN* = 2 + TCL_BREAK* = 3 + TCL_CONTINUE* = 4 + RESULT_SIZE* = 200 + MAX_ARGV* = 0x00007FFF + VERSION_MAJOR* = 0 + VERSION_MINOR* = 0 + NO_EVAL* = 0x00010000 + EVAL_GLOBAL* = 0x00020000 # Flag values passed to variable-related proc + GLOBAL_ONLY* = 1 + NAMESPACE_ONLY* = 2 + APPEND_VALUE* = 4 + LIST_ELEMENT* = 8 + TRACE_READS* = 0x00000010 + TRACE_WRITES* = 0x00000020 + TRACE_UNSETS* = 0x00000040 + TRACE_DESTROYED* = 0x00000080 + INTERP_DESTROYED* = 0x00000100 + LEAVE_ERR_MSG* = 0x00000200 + PARSE_PART1* = 0x00000400 # Types for linked variables: * + LINK_INT* = 1 + LINK_DOUBLE* = 2 + LINK_BOOLEAN* = 3 + LINK_STRING* = 4 + LINK_READ_ONLY* = 0x00000080 + SMALL_HASH_TABLE* = 4 # Hash Table * + STRING_KEYS* = 0 + ONE_WORD_KEYS* = 1 # Const/enums Tcl_QueuePosition * + + QUEUE_TAIL* = 0 + QUEUE_HEAD* = 1 + QUEUE_MARK* = 2 # Tcl_QueuePosition; + # Event Flags + DONT_WAIT* = 1 shl 1 + WINDOW_EVENTS* = 1 shl 2 + FILE_EVENTS* = 1 shl 3 + TIMER_EVENTS* = 1 shl 4 + IDLE_EVENTS* = 1 shl 5 # WAS 0x10 ???? * + ALL_EVENTS* = not DONT_WAIT + VOLATILE* = 1 + STATIC* = 0 + DYNAMIC* = 3 # Channel + TCL_STDIN* = 1 shl 1 + TCL_STDOUT* = 1 shl 2 + TCL_STDERR* = 1 shl 3 + ENFORCE_MODE* = 1 shl 4 + READABLE* = 1 shl 1 + WRITABLE* = 1 shl 2 + EXCEPTION* = 1 shl 3 # POSIX * + EPERM* = 1 # Operation not permitted; only the owner of the file (or other + # resource) or processes with special privileges can perform the + # operation. + # + ENOENT* = 2 # No such file or directory. This is a "file doesn't exist" error + # for ordinary files that are referenced in contexts where they are + # expected to already exist. + # + ESRCH* = 3 # No process matches the specified process ID. * + EINTR* = 4 # Interrupted function call; an asynchronous signal occurred and + # prevented completion of the call. When this happens, you should + # try the call again. + # + EIO* = 5 # Input/output error; usually used for physical read or write errors. * + ENXIO* = 6 # No such device or address. The system tried to use the device + # represented by a file you specified, and it couldn't find the + # device. This can mean that the device file was installed + # incorrectly, or that the physical device is missing or not + # correctly attached to the computer. + # + E2BIG* = 7 # Argument list too long; used when the arguments passed to a new + # program being executed with one of the `exec' functions (*note + # Executing a File::.) occupy too much memory space. This condition + # never arises in the GNU system. + # + ENOEXEC* = 8 # Invalid executable file format. This condition is detected by the + # `exec' functions; see *Note Executing a File::. + # + EBADF* = 9 # Bad file descriptor; for example, I/O on a descriptor that has been + # closed or reading from a descriptor open only for writing (or vice + # versa). + # + ECHILD* = 10 # There are no child processes. This error happens on operations + # that are supposed to manipulate child processes, when there aren't + # any processes to manipulate. + # + EDEADLK* = 11 # Deadlock avoided; allocating a system resource would have resulted + # in a deadlock situation. The system does not guarantee that it + # will notice all such situations. This error means you got lucky + # and the system noticed; it might just hang. *Note File Locks::, + # for an example. + # + ENOMEM* = 12 # No memory available. The system cannot allocate more virtual + # memory because its capacity is full. + # + EACCES* = 13 # Permission denied; the file permissions do not allow the attempted + # operation. + # + EFAULT* = 14 # Bad address; an invalid pointer was detected. In the GNU system, + # this error never happens; you get a signal instead. + # + ENOTBLK* = 15 # A file that isn't a block special file was given in a situation + # that requires one. For example, trying to mount an ordinary file + # as a file system in Unix gives this error. + # + EBUSY* = 16 # Resource busy; a system resource that can't be shared is already + # in use. For example, if you try to delete a file that is the root + # of a currently mounted filesystem, you get this error. + # + EEXIST* = 17 # File exists; an existing file was specified in a context where it + # only makes sense to specify a new file. + # + EXDEV* = 18 # An attempt to make an improper link across file systems was + # detected. This happens not only when you use `link' (*note Hard + # Links::.) but also when you rename a file with `rename' (*note + # Renaming Files::.). + # + ENODEV* = 19 # The wrong type of device was given to a function that expects a + # particular sort of device. + # + ENOTDIR* = 20 # A file that isn't a directory was specified when a directory is + # required. + # + EISDIR* = 21 # File is a directory; you cannot open a directory for writing, or + # create or remove hard links to it. + # + EINVAL* = 22 # Invalid argument. This is used to indicate various kinds of + # problems with passing the wrong argument to a library function. + # + EMFILE* = 24 # The current process has too many files open and can't open any + # more. Duplicate descriptors do count toward this limit. + # + # In BSD and GNU, the number of open files is controlled by a + # resource limit that can usually be increased. If you get this + # error, you might want to increase the `RLIMIT_NOFILE' limit or + # make it unlimited; *note Limits on Resources::.. + # + ENFILE* = 23 # There are too many distinct file openings in the entire system. + # Note that any number of linked channels count as just one file + # opening; see *Note Linked Channels::. This error never occurs in + # the GNU system. + # + ENOTTY* = 25 # Inappropriate I/O control operation, such as trying to set terminal + # modes on an ordinary file. + # + ETXTBSY* = 26 # An attempt to execute a file that is currently open for writing, or + # write to a file that is currently being executed. Often using a + # debugger to run a program is considered having it open for writing + # and will cause this error. (The name stands for "text file + # busy".) This is not an error in the GNU system; the text is + # copied as necessary. + # + EFBIG* = 27 # File too big; the size of a file would be larger than allowed by + # the system. + # + ENOSPC* = 28 # No space left on device; write operation on a file failed because + # the disk is full. + # + ESPIPE* = 29 # Invalid seek operation (such as on a pipe). * + EROFS* = 30 # An attempt was made to modify something on a read-only file system. * + EMLINK* = 31 # Too many links; the link count of a single file would become too + # large. `rename' can cause this error if the file being renamed + # already has as many links as it can take (*note Renaming Files::.). + # + EPIPE* = 32 # Broken pipe; there is no process reading from the other end of a + # pipe. Every library function that returns this error code also + # generates a `SIGPIPE' signal; this signal terminates the program + # if not handled or blocked. Thus, your program will never actually + # see `EPIPE' unless it has handled or blocked `SIGPIPE'. + # + EDOM* = 33 # Domain error; used by mathematical functions when an argument + # value does not fall into the domain over which the function is + # defined. + # + ERANGE* = 34 # Range error; used by mathematical functions when the result value + # is not representable because of overflow or underflow. + # + EAGAIN* = 35 # Resource temporarily unavailable; the call might work if you try + # again later. The macro `EWOULDBLOCK' is another name for `EAGAIN'; + # they are always the same in the GNU C library. + # + EWOULDBLOCK* = EAGAIN # In the GNU C library, this is another name for `EAGAIN' (above). + # The values are always the same, on every operating system. + # C libraries in many older Unix systems have `EWOULDBLOCK' as a + # separate error code. + # + EINPROGRESS* = 36 # An operation that cannot complete immediately was initiated on an + # object that has non-blocking mode selected. Some functions that + # must always block (such as `connect'; *note Connecting::.) never + # return `EAGAIN'. Instead, they return `EINPROGRESS' to indicate + # that the operation has begun and will take some time. Attempts to + # manipulate the object before the call completes return `EALREADY'. + # You can use the `select' function to find out when the pending + # operation has completed; *note Waiting for I/O::.. + # + EALREADY* = 37 # An operation is already in progress on an object that has + # non-blocking mode selected. + # + ENOTSOCK* = 38 # A file that isn't a socket was specified when a socket is required. * + EDESTADDRREQ* = 39 # No default destination address was set for the socket. You get + # this error when you try to transmit data over a connectionless + # socket, without first specifying a destination for the data with + # `connect'. + # + EMSGSIZE* = 40 # The size of a message sent on a socket was larger than the + # supported maximum size. + # + EPROTOTYPE* = 41 # The socket type does not support the requested communications + # protocol. + # + ENOPROTOOPT* = 42 # You specified a socket option that doesn't make sense for the + # particular protocol being used by the socket. *Note Socket + # Options::. + # + EPROTONOSUPPORT* = 43 # The socket domain does not support the requested communications + # protocol (perhaps because the requested protocol is completely + # invalid.) *Note Creating a Socket::. + # + ESOCKTNOSUPPORT* = 44 # The socket type is not supported. * + EOPNOTSUPP* = 45 # The operation you requested is not supported. Some socket + # functions don't make sense for all types of sockets, and others + # may not be implemented for all communications protocols. In the + # GNU system, this error can happen for many calls when the object + # does not support the particular operation; it is a generic + # indication that the server knows nothing to do for that call. + # + EPFNOSUPPORT* = 46 # The socket communications protocol family you requested is not + # supported. + # + EAFNOSUPPORT* = 47 # The address family specified for a socket is not supported; it is + # inconsistent with the protocol being used on the socket. *Note + # Sockets::. + # + EADDRINUSE* = 48 # The requested socket address is already in use. *Note Socket + # Addresses::. + # + EADDRNOTAVAIL* = 49 # The requested socket address is not available; for example, you + # tried to give a socket a name that doesn't match the local host + # name. *Note Socket Addresses::. + # + ENETDOWN* = 50 # A socket operation failed because the network was down. * + ENETUNREACH* = 51 # A socket operation failed because the subnet containing the remote + # host was unreachable. + # + ENETRESET* = 52 # A network connection was reset because the remote host crashed. * + ECONNABORTED* = 53 # A network connection was aborted locally. * + ECONNRESET* = 54 # A network connection was closed for reasons outside the control of + # the local host, such as by the remote machine rebooting or an + # unrecoverable protocol violation. + # + ENOBUFS* = 55 # The kernel's buffers for I/O operations are all in use. In GNU, + # this error is always synonymous with `ENOMEM'; you may get one or + # the other from network operations. + # + EISCONN* = 56 # You tried to connect a socket that is already connected. *Note + # Connecting::. + # + ENOTCONN* = 57 # The socket is not connected to anything. You get this error when + # you try to transmit data over a socket, without first specifying a + # destination for the data. For a connectionless socket (for + # datagram protocols, such as UDP), you get `EDESTADDRREQ' instead. + # + ESHUTDOWN* = 58 # The socket has already been shut down. * + ETOOMANYREFS* = 59 # ??? * + ETIMEDOUT* = 60 # A socket operation with a specified timeout received no response + # during the timeout period. + # + ECONNREFUSED* = 61 # A remote host refused to allow the network connection (typically + # because it is not running the requested service). + # + ELOOP* = 62 # Too many levels of symbolic links were encountered in looking up a + # file name. This often indicates a cycle of symbolic links. + # + ENAMETOOLONG* = 63 # Filename too long (longer than `PATH_MAX'; *note Limits for + # Files::.) or host name too long (in `gethostname' or + # `sethostname'; *note Host Identification::.). + # + EHOSTDOWN* = 64 # The remote host for a requested network connection is down. * + EHOSTUNREACH* = 65 # The remote host for a requested network connection is not + # reachable. + # + ENOTEMPTY* = 66 # Directory not empty, where an empty directory was expected. + # Typically, this error occurs when you are trying to delete a + # directory. + # + EPROCLIM* = 67 # This means that the per-user limit on new process would be + # exceeded by an attempted `fork'. *Note Limits on Resources::, for + # details on the `RLIMIT_NPROC' limit. + # + EUSERS* = 68 # The file quota system is confused because there are too many users. * + EDQUOT* = 69 # The user's disk quota was exceeded. * + ESTALE* = 70 # Stale NFS file handle. This indicates an internal confusion in + # the NFS system which is due to file system rearrangements on the + # server host. Repairing this condition usually requires unmounting + # and remounting the NFS file system on the local host. + # + EREMOTE* = 71 # An attempt was made to NFS-mount a remote file system with a file + # name that already specifies an NFS-mounted file. (This is an + # error on some operating systems, but we expect it to work properly + # on the GNU system, making this error code impossible.) + # + EBADRPC* = 72 # ??? * + ERPCMISMATCH* = 73 # ??? * + EPROGUNAVAIL* = 74 # ??? * + EPROGMISMATCH* = 75 # ??? * + EPROCUNAVAIL* = 76 # ??? * + ENOLCK* = 77 # No locks available. This is used by the file locking facilities; + # see *Note File Locks::. This error is never generated by the GNU + # system, but it can result from an operation to an NFS server + # running another operating system. + # + ENOSYS* = 78 # Function not implemented. Some functions have commands or options + # defined that might not be supported in all implementations, and + # this is the kind of error you get if you request them and they are + # not supported. + # + EFTYPE* = 79 # Inappropriate file type or format. The file was the wrong type + # for the operation, or a data file had the wrong format. + # On some systems `chmod' returns this error if you try to set the + # sticky bit on a non-directory file; *note Setting Permissions::.. + # + +type + TArgv* = cstringArray + TClientData* = pointer + TFreeProc* = proc (theBlock: pointer){.cdecl.} + PInterp* = ptr TInterp + TInterp*{.final.} = object # Event Definitions + result*: cstring # Do not access this directly. Use + # Tcl_GetStringResult since result + # may be pointing to an object + # + freeProc*: TFreeProc + errorLine*: int + + TEventSetupProc* = proc (clientData: TClientData, flags: int){.cdecl.} + TEventCheckProc* = TEventSetupProc + PEvent* = ptr TEvent + TEventProc* = proc (evPtr: PEvent, flags: int): int{.cdecl.} + TEvent*{.final.} = object + prc*: TEventProc + nextPtr*: PEvent + ClientData*: TObject # ClientData is just pointer.* + + PTime* = ptr TTime + TTime*{.final.} = object + sec*: int32 # Seconds. * + usec*: int32 # Microseconds. * + + TTimerToken* = pointer + PInteger* = ptr int + PHashTable* = ptr THashTable + PHashEntry* = ptr THashEntry + PPHashEntry* = ptr PHashEntry + THashEntry*{.final.} = object + nextPtr*: PHashEntry + tablePtr*: PHashTable + bucketPtr*: PPHashEntry + clientData*: TClientData + key*: cstring + + THashFindProc* = proc (tablePtr: PHashTable, key: cstring): PHashEntry{. + cdecl.} + THashCreateProc* = proc (tablePtr: PHashTable, key: cstring, + newPtr: PInteger): PHashEntry{.cdecl.} + THashTable*{.final.} = object + buckets*: ppHashEntry + staticBuckets*: array[0..SMALL_HASH_TABLE - 1, PHashEntry] + numBuckets*: int + numEntries*: int + rebuildSize*: int + downShift*: int + mask*: int + keyType*: int + findProc*: THashFindProc + createProc*: THashCreateProc + + PHashSearch* = ptr THashSearch + THashSearch*{.final.} = object + tablePtr*: PHashTable + nextIndex*: int + nextEntryPtr*: PHashEntry + + TAppInitProc* = proc (interp: pInterp): int{.cdecl.} + TPackageInitProc* = proc (interp: pInterp): int{.cdecl.} + TCmdProc* = proc (clientData: TClientData, interp: pInterp, argc: int, + argv: TArgv): int{.cdecl.} + TVarTraceProc* = proc (clientData: TClientData, interp: pInterp, + varName: cstring, elemName: cstring, flags: int): cstring{. + cdecl.} + TInterpDeleteProc* = proc (clientData: TClientData, interp: pInterp){.cdecl.} + TCmdDeleteProc* = proc (clientData: TClientData){.cdecl.} + TNamespaceDeleteProc* = proc (clientData: TClientData){.cdecl.} + +const + DSTRING_STATIC_SIZE* = 200 + +type + PDString* = ptr TDString + TDString*{.final.} = object + str*: cstring + len*: int + spaceAvl*: int + staticSpace*: array[0..DSTRING_STATIC_SIZE - 1, char] + + PChannel* = ptr TChannel + TChannel*{.final.} = object + TDriverBlockModeProc* = proc (instanceData: TClientData, mode: int): int{. + cdecl.} + TDriverCloseProc* = proc (instanceData: TClientData, interp: PInterp): int{. + cdecl.} + TDriverInputProc* = proc (instanceData: TClientData, buf: cstring, + toRead: int, errorCodePtr: PInteger): int{.cdecl.} + TDriverOutputProc* = proc (instanceData: TClientData, buf: cstring, + toWrite: int, errorCodePtr: PInteger): int{.cdecl.} + TDriverSeekProc* = proc (instanceData: TClientData, offset: int32, + mode: int, errorCodePtr: PInteger): int{.cdecl.} + TDriverSetOptionProc* = proc (instanceData: TClientData, interp: PInterp, + optionName: cstring, value: cstring): int{.cdecl.} + TDriverGetOptionProc* = proc (instanceData: TClientData, interp: pInterp, + optionName: cstring, dsPtr: PDString): int{. + cdecl.} + TDriverWatchProc* = proc (instanceData: TClientData, mask: int){.cdecl.} + TDriverGetHandleProc* = proc (instanceData: TClientData, direction: int, + handlePtr: var TClientData): int{.cdecl.} + PChannelType* = ptr TChannelType + TChannelType*{.final.} = object + typeName*: cstring + blockModeProc*: TDriverBlockModeProc + closeProc*: TDriverCloseProc + inputProc*: TDriverInputProc + ouputProc*: TDriverOutputProc + seekProc*: TDriverSeekProc + setOptionProc*: TDriverSetOptionProc + getOptionProc*: TDriverGetOptionProc + watchProc*: TDriverWatchProc + getHandleProc*: TDriverGetHandleProc + + TChannelProc* = proc (clientData: TClientData, mask: int){.cdecl.} + PObj* = ptr TObj + PPObj* = ptr PObj + TObj*{.final.} = object + refCount*: int # ... + + TObjCmdProc* = proc (clientData: TClientData, interp: PInterp, objc: int, + PPObj: PPObj): int{.cdecl.} + PNamespace* = ptr TNamespace + TNamespace*{.final.} = object + name*: cstring + fullName*: cstring + clientData*: TClientData + deleteProc*: TNamespaceDeleteProc + parentPtr*: PNamespace + + PCallFrame* = ptr TCallFrame + TCallFrame*{.final.} = object + nsPtr*: PNamespace + dummy1*: int + dummy2*: int + dummy3*: cstring + dummy4*: cstring + dummy5*: cstring + dummy6*: int + dummy7*: cstring + dummy8*: cstring + dummy9*: int + dummy10*: cstring + + PCmdInfo* = ptr TCmdInfo + TCmdInfo*{.final.} = object + isNativeObjectProc*: int + objProc*: TObjCmdProc + objClientData*: TClientData + prc*: TCmdProc + clientData*: TClientData + deleteProc*: TCmdDeleteProc + deleteData*: TClientData + namespacePtr*: pNamespace + + pCommand* = ptr TCommand + TCommand*{.final.} = object # hPtr : pTcl_HashEntry; + # nsPtr : pTcl_Namespace; + # refCount : integer; + # isCmdEpoch : integer; + # compileProc : pointer; + # objProc : pointer; + # objClientData : Tcl_ClientData; + # proc : pointer; + # clientData : Tcl_ClientData; + # deleteProc : TTclCmdDeleteProc; + # deleteData : Tcl_ClientData; + # deleted : integer; + # importRefPtr : pointer; + # + +type + TPanicProc* = proc (fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8: cstring){. + cdecl.} # 1/15/97 orig. Tcl style + TClientDataProc* = proc (clientData: TClientData){.cdecl.} + TIdleProc* = proc (clientData: TClientData){.cdecl.} + TTimerProc* = TIdleProc + TCreateCloseHandler* = proc (channel: pChannel, prc: TClientDataProc, + clientData: TClientData){.cdecl.} + TDeleteCloseHandler* = TCreateCloseHandler + TEventDeleteProc* = proc (evPtr: pEvent, clientData: TClientData): int{. + cdecl.} + +proc Alloc*(size: int): cstring{.cdecl, dynlib: dllName, + importc: "Tcl_Alloc".} +proc CreateInterp*(): pInterp{.cdecl, dynlib: dllName, + importc: "Tcl_CreateInterp".} +proc DeleteInterp*(interp: pInterp){.cdecl, dynlib: dllName, + importc: "Tcl_DeleteInterp".} +proc ResetResult*(interp: pInterp){.cdecl, dynlib: dllName, + importc: "Tcl_ResetResult".} +proc Eval*(interp: pInterp, script: cstring): int{.cdecl, dynlib: dllName, + importc: "Tcl_Eval".} +proc EvalFile*(interp: pInterp, filename: cstring): int{.cdecl, + dynlib: dllName, importc: "Tcl_EvalFile".} +proc AddErrorInfo*(interp: pInterp, message: cstring){.cdecl, + dynlib: dllName, importc: "Tcl_AddErrorInfo".} +proc BackgroundError*(interp: pInterp){.cdecl, dynlib: dllName, + importc: "Tcl_BackgroundError".} +proc CreateCommand*(interp: pInterp, name: cstring, cmdProc: TCmdProc, + clientData: TClientData, deleteProc: TCmdDeleteProc): pCommand{. + cdecl, dynlib: dllName, importc: "Tcl_CreateCommand".} +proc DeleteCommand*(interp: pInterp, name: cstring): int{.cdecl, + dynlib: dllName, importc: "Tcl_DeleteCommand".} +proc CallWhenDeleted*(interp: pInterp, prc: TInterpDeleteProc, + clientData: TClientData){.cdecl, dynlib: dllName, + importc: "Tcl_CallWhenDeleted".} +proc DontCallWhenDeleted*(interp: pInterp, prc: TInterpDeleteProc, + clientData: TClientData){.cdecl, + dynlib: dllName, importc: "Tcl_DontCallWhenDeleted".} +proc CommandComplete*(cmd: cstring): int{.cdecl, dynlib: dllName, + importc: "Tcl_CommandComplete".} +proc LinkVar*(interp: pInterp, varName: cstring, varAddr: pointer, typ: int): int{. + cdecl, dynlib: dllName, importc: "Tcl_LinkVar".} +proc UnlinkVar*(interp: pInterp, varName: cstring){.cdecl, dynlib: dllName, + importc: "Tcl_UnlinkVar".} +proc TraceVar*(interp: pInterp, varName: cstring, flags: int, + prc: TVarTraceProc, clientData: TClientData): int{.cdecl, + dynlib: dllName, importc: "Tcl_TraceVar".} +proc TraceVar2*(interp: pInterp, varName: cstring, elemName: cstring, + flags: int, prc: TVarTraceProc, clientData: TClientData): int{. + cdecl, dynlib: dllName, importc: "Tcl_TraceVar2".} +proc UntraceVar*(interp: pInterp, varName: cstring, flags: int, + prc: TVarTraceProc, clientData: TClientData){.cdecl, + dynlib: dllName, importc: "Tcl_UntraceVar".} +proc UntraceVar2*(interp: pInterp, varName: cstring, elemName: cstring, + flags: int, prc: TVarTraceProc, clientData: TClientData){. + cdecl, dynlib: dllName, importc: "Tcl_UntraceVar2".} +proc GetVar*(interp: pInterp, varName: cstring, flags: int): cstring{.cdecl, + dynlib: dllName, importc: "Tcl_GetVar".} +proc GetVar2*(interp: pInterp, varName: cstring, elemName: cstring, + flags: int): cstring{.cdecl, dynlib: dllName, + importc: "Tcl_GetVar2".} +proc SetVar*(interp: pInterp, varName: cstring, newValue: cstring, + flags: int): cstring{.cdecl, dynlib: dllName, + importc: "Tcl_SetVar".} +proc SetVar2*(interp: pInterp, varName: cstring, elemName: cstring, + newValue: cstring, flags: int): cstring{.cdecl, + dynlib: dllName, importc: "Tcl_SetVar2".} +proc UnsetVar*(interp: pInterp, varName: cstring, flags: int): int{.cdecl, + dynlib: dllName, importc: "Tcl_UnsetVar".} +proc UnsetVar2*(interp: pInterp, varName: cstring, elemName: cstring, + flags: int): int{.cdecl, dynlib: dllName, + importc: "Tcl_UnsetVar2".} +proc SetResult*(interp: pInterp, newValue: cstring, freeProc: TFreeProc){. + cdecl, dynlib: dllName, importc: "Tcl_SetResult".} +proc FirstHashEntry*(hashTbl: pHashTable, searchInfo: var THashSearch): pHashEntry{. + cdecl, dynlib: dllName, importc: "Tcl_FirstHashEntry".} +proc NextHashEntry*(searchInfo: var THashSearch): pHashEntry{.cdecl, + dynlib: dllName, importc: "Tcl_NextHashEntry".} +proc InitHashTable*(hashTbl: pHashTable, keyType: int){.cdecl, + dynlib: dllName, importc: "Tcl_InitHashTable".} +proc StringMatch*(str: cstring, pattern: cstring): int{.cdecl, + dynlib: dllName, importc: "Tcl_StringMatch".} +proc GetErrno*(): int{.cdecl, dynlib: dllName, importc: "Tcl_GetErrno".} +proc SetErrno*(val: int){.cdecl, dynlib: dllName, importc: "Tcl_SetErrno".} +proc SetPanicProc*(prc: TPanicProc){.cdecl, dynlib: dllName, + importc: "Tcl_SetPanicProc".} +proc PkgProvide*(interp: pInterp, name: cstring, version: cstring): int{. + cdecl, dynlib: dllName, importc: "Tcl_PkgProvide".} +proc StaticPackage*(interp: pInterp, pkgName: cstring, + initProc: TPackageInitProc, + safeInitProc: TPackageInitProc){.cdecl, dynlib: dllName, + importc: "Tcl_StaticPackage".} +proc CreateEventSource*(setupProc: TEventSetupProc, + checkProc: TEventCheckProc, + clientData: TClientData){.cdecl, dynlib: dllName, + importc: "Tcl_CreateEventSource".} +proc DeleteEventSource*(setupProc: TEventSetupProc, + checkProc: TEventCheckProc, + clientData: TClientData){.cdecl, dynlib: dllName, + importc: "Tcl_DeleteEventSource".} +proc QueueEvent*(evPtr: pEvent, pos: int){.cdecl, dynlib: dllName, + importc: "Tcl_QueueEvent".} +proc SetMaxBlockTime*(timePtr: pTime){.cdecl, dynlib: dllName, + importc: "Tcl_SetMaxBlockTime".} +proc DeleteEvents*(prc: TEventDeleteProc, clientData: TClientData){. + cdecl, dynlib: dllName, importc: "Tcl_DeleteEvents".} +proc DoOneEvent*(flags: int): int{.cdecl, dynlib: dllName, + importc: "Tcl_DoOneEvent".} +proc DoWhenIdle*(prc: TIdleProc, clientData: TClientData){.cdecl, + dynlib: dllName, importc: "Tcl_DoWhenIdle".} +proc CancelIdleCall*(prc: TIdleProc, clientData: TClientData){.cdecl, + dynlib: dllName, importc: "Tcl_CancelIdleCall".} +proc CreateTimerHandler*(milliseconds: int, prc: TTimerProc, + clientData: TClientData): TTimerToken{.cdecl, + dynlib: dllName, importc: "Tcl_CreateTimerHandler".} +proc DeleteTimerHandler*(token: TTimerToken){.cdecl, dynlib: dllName, + importc: "Tcl_DeleteTimerHandler".} + # procedure Tcl_CreateModalTimeout(milliseconds: integer; prc: TTclTimerProc; clientData: Tcl_ClientData); cdecl; external dllName; + # procedure Tcl_DeleteModalTimeout(prc: TTclTimerProc; clientData: Tcl_ClientData); cdecl; external dllName; +proc SplitList*(interp: pInterp, list: cstring, argcPtr: var int, + argvPtr: var TArgv): int{.cdecl, dynlib: dllName, + importc: "Tcl_SplitList".} +proc Merge*(argc: int, argv: TArgv): cstring{.cdecl, dynlib: dllName, + importc: "Tcl_Merge".} +proc Free*(p: cstring){.cdecl, dynlib: dllName, importc: "Tcl_Free".} +proc Init*(interp: pInterp): int{.cdecl, dynlib: dllName, + importc: "Tcl_Init".} + # procedure Tcl_InterpDeleteProc(clientData: Tcl_ClientData; interp: pTcl_Interp); cdecl; external dllName; +proc GetAssocData*(interp: pInterp, key: cstring, prc: var TInterpDeleteProc): TClientData{. + cdecl, dynlib: dllName, importc: "Tcl_GetAssocData".} +proc DeleteAssocData*(interp: pInterp, key: cstring){.cdecl, + dynlib: dllName, importc: "Tcl_DeleteAssocData".} +proc SetAssocData*(interp: pInterp, key: cstring, prc: TInterpDeleteProc, + clientData: TClientData){.cdecl, dynlib: dllName, + importc: "Tcl_SetAssocData".} +proc IsSafe*(interp: pInterp): int{.cdecl, dynlib: dllName, + importc: "Tcl_IsSafe".} +proc MakeSafe*(interp: pInterp): int{.cdecl, dynlib: dllName, + importc: "Tcl_MakeSafe".} +proc CreateSlave*(interp: pInterp, slaveName: cstring, isSafe: int): pInterp{. + cdecl, dynlib: dllName, importc: "Tcl_CreateSlave".} +proc GetSlave*(interp: pInterp, slaveName: cstring): pInterp{.cdecl, + dynlib: dllName, importc: "Tcl_GetSlave".} +proc GetMaster*(interp: pInterp): pInterp{.cdecl, dynlib: dllName, + importc: "Tcl_GetMaster".} +proc GetInterpPath*(askingInterp: pInterp, slaveInterp: pInterp): int{. + cdecl, dynlib: dllName, importc: "Tcl_GetInterpPath".} +proc CreateAlias*(slaveInterp: pInterp, srcCmd: cstring, + targetInterp: pInterp, targetCmd: cstring, argc: int, + argv: TArgv): int{.cdecl, dynlib: dllName, + importc: "Tcl_CreateAlias".} +proc GetAlias*(interp: pInterp, srcCmd: cstring, targetInterp: var pInterp, + targetCmd: var cstring, argc: var int, argv: var TArgv): int{. + cdecl, dynlib: dllName, importc: "Tcl_GetAlias".} +proc ExposeCommand*(interp: pInterp, hiddenCmdName: cstring, + cmdName: cstring): int{.cdecl, dynlib: dllName, + importc: "Tcl_ExposeCommand".} +proc HideCommand*(interp: pInterp, cmdName: cstring, hiddenCmdName: cstring): int{. + cdecl, dynlib: dllName, importc: "Tcl_HideCommand".} +proc EventuallyFree*(clientData: TClientData, freeProc: TFreeProc){. + cdecl, dynlib: dllName, importc: "Tcl_EventuallyFree".} +proc Preserve*(clientData: TClientData){.cdecl, dynlib: dllName, + importc: "Tcl_Preserve".} +proc Release*(clientData: TClientData){.cdecl, dynlib: dllName, + importc: "Tcl_Release".} +proc InterpDeleted*(interp: pInterp): int{.cdecl, dynlib: dllName, + importc: "Tcl_InterpDeleted".} +proc GetCommandInfo*(interp: pInterp, cmdName: cstring, + info: var TCmdInfo): int{.cdecl, dynlib: dllName, + importc: "Tcl_GetCommandInfo".} +proc SetCommandInfo*(interp: pInterp, cmdName: cstring, + info: var TCmdInfo): int{.cdecl, dynlib: dllName, + importc: "Tcl_SetCommandInfo".} +proc FindExecutable*(path: cstring){.cdecl, dynlib: dllName, + importc: "Tcl_FindExecutable".} +proc GetStringResult*(interp: pInterp): cstring{.cdecl, dynlib: dllName, + importc: "Tcl_GetStringResult".} + #v1.0 +proc FindCommand*(interp: pInterp, cmdName: cstring, + contextNsPtr: pNamespace, flags: int): TCommand{.cdecl, + dynlib: dllName, importc: "Tcl_FindCommand".} + #v1.0 +proc DeleteCommandFromToken*(interp: pInterp, cmd: pCommand): int{.cdecl, + dynlib: dllName, importc: "Tcl_DeleteCommandFromToken".} +proc CreateNamespace*(interp: pInterp, name: cstring, + clientData: TClientData, + deleteProc: TNamespaceDeleteProc): pNamespace{.cdecl, + dynlib: dllName, importc: "Tcl_CreateNamespace".} + #v1.0 +proc DeleteNamespace*(namespacePtr: pNamespace){.cdecl, dynlib: dllName, + importc: "Tcl_DeleteNamespace".} +proc FindNamespace*(interp: pInterp, name: cstring, + contextNsPtr: pNamespace, flags: int): pNamespace{. + cdecl, dynlib: dllName, importc: "Tcl_FindNamespace".} +proc Tcl_Export*(interp: pInterp, namespacePtr: pNamespace, pattern: cstring, + resetListFirst: int): int{.cdecl, dynlib: dllName, + importc: "Tcl_Export".} +proc Tcl_Import*(interp: pInterp, namespacePtr: pNamespace, pattern: cstring, + allowOverwrite: int): int{.cdecl, dynlib: dllName, + importc: "Tcl_Import".} +proc GetCurrentNamespace*(interp: pInterp): pNamespace{.cdecl, + dynlib: dllName, importc: "Tcl_GetCurrentNamespace".} +proc GetGlobalNamespace*(interp: pInterp): pNamespace{.cdecl, + dynlib: dllName, importc: "Tcl_GetGlobalNamespace".} +proc PushCallFrame*(interp: pInterp, callFramePtr: var TCallFrame, + namespacePtr: pNamespace, isProcCallFrame: int): int{. + cdecl, dynlib: dllName, importc: "Tcl_PushCallFrame".} +proc PopCallFrame*(interp: pInterp){.cdecl, dynlib: dllName, + importc: "Tcl_PopCallFrame".} +proc VarEval*(interp: pInterp): int{.cdecl, varargs, dynlib: dllName, + importc: "Tcl_VarEval".} + # For TkConsole.c * +proc RecordAndEval*(interp: pInterp, cmd: cstring, flags: int): int{.cdecl, + dynlib: dllName, importc: "Tcl_RecordAndEval".} +proc GlobalEval*(interp: pInterp, command: cstring): int{.cdecl, + dynlib: dllName, importc: "Tcl_GlobalEval".} +proc DStringFree*(dsPtr: pDString){.cdecl, dynlib: dllName, + importc: "Tcl_DStringFree".} +proc DStringAppend*(dsPtr: pDString, str: cstring, length: int): cstring{. + cdecl, dynlib: dllName, importc: "Tcl_DStringAppend".} +proc DStringAppendElement*(dsPtr: pDString, str: cstring): cstring{.cdecl, + dynlib: dllName, importc: "Tcl_DStringAppendElement".} +proc DStringInit*(dsPtr: pDString){.cdecl, dynlib: dllName, + importc: "Tcl_DStringInit".} +proc AppendResult*(interp: pInterp){.cdecl, varargs, dynlib: dllName, + importc: "Tcl_AppendResult".} + # actually a "C" var array +proc SetStdChannel*(channel: pChannel, typ: int){.cdecl, dynlib: dllName, + importc: "Tcl_SetStdChannel".} +proc SetChannelOption*(interp: pInterp, chan: pChannel, optionName: cstring, + newValue: cstring): int{.cdecl, dynlib: dllName, + importc: "Tcl_SetChannelOption".} +proc GetChannelOption*(interp: pInterp, chan: pChannel, optionName: cstring, + dsPtr: pDString): int{.cdecl, dynlib: dllName, + importc: "Tcl_GetChannelOption".} +proc CreateChannel*(typePtr: pChannelType, chanName: cstring, + instanceData: TClientData, mask: int): pChannel{. + cdecl, dynlib: dllName, importc: "Tcl_CreateChannel".} +proc RegisterChannel*(interp: pInterp, channel: pChannel){.cdecl, + dynlib: dllName, importc: "Tcl_RegisterChannel".} +proc UnregisterChannel*(interp: pInterp, channel: pChannel): int{.cdecl, + dynlib: dllName, importc: "Tcl_UnregisterChannel".} +proc CreateChannelHandler*(chan: pChannel, mask: int, prc: TChannelProc, + clientData: TClientData){.cdecl, + dynlib: dllName, importc: "Tcl_CreateChannelHandler".} +proc GetChannel*(interp: pInterp, chanName: cstring, modePtr: pInteger): pChannel{. + cdecl, dynlib: dllName, importc: "Tcl_GetChannel".} +proc GetStdChannel*(typ: int): pChannel{.cdecl, dynlib: dllName, + importc: "Tcl_GetStdChannel".} +proc Gets*(chan: pChannel, dsPtr: pDString): int{.cdecl, dynlib: dllName, + importc: "Tcl_Gets".} +proc Write*(chan: pChannel, s: cstring, slen: int): int{.cdecl, + dynlib: dllName, importc: "Tcl_Write".} +proc Flush*(chan: pChannel): int{.cdecl, dynlib: dllName, + importc: "Tcl_Flush".} + # TclWinLoadLibrary = function(name: PChar): HMODULE; cdecl; external dllName; +proc CreateExitHandler*(prc: TClientDataProc, clientData: TClientData){. + cdecl, dynlib: dllName, importc: "Tcl_CreateExitHandler".} +proc DeleteExitHandler*(prc: TClientDataProc, clientData: TClientData){. + cdecl, dynlib: dllName, importc: "Tcl_DeleteExitHandler".} +proc GetStringFromObj*(pObj: pObj, pLen: pInteger): cstring{.cdecl, + dynlib: dllName, importc: "Tcl_GetStringFromObj".} +proc CreateObjCommand*(interp: pInterp, name: cstring, cmdProc: TObjCmdProc, + clientData: TClientData, + deleteProc: TCmdDeleteProc): pCommand{.cdecl, + dynlib: dllName, importc: "Tcl_CreateObjCommand".} +proc NewStringObj*(bytes: cstring, length: int): pObj{.cdecl, + dynlib: dllName, importc: "Tcl_NewStringObj".} + # procedure TclFreeObj(pObj: pTcl_Obj); cdecl; external dllName; +proc EvalObj*(interp: pInterp, pObj: pObj): int{.cdecl, dynlib: dllName, + importc: "Tcl_EvalObj".} +proc GlobalEvalObj*(interp: pInterp, pObj: pObj): int{.cdecl, + dynlib: dllName, importc: "Tcl_GlobalEvalObj".} +proc RegComp*(exp: cstring): pointer{.cdecl, dynlib: dllName, + importc: "TclRegComp".} + +proc RegExec*(prog: pointer, str: cstring, start: cstring): int{.cdecl, + dynlib: dllName, importc: "TclRegExec".} + +proc RegError*(msg: cstring){.cdecl, dynlib: dllName, importc: "TclRegError".} + +proc GetRegError*(): cstring{.cdecl, dynlib: dllName, + importc: "TclGetRegError".} + +proc RegExpRange*(prog: pointer, index: int, head: var cstring, + tail: var cstring){.cdecl, dynlib: dllName, + importc: "Tcl_RegExpRange".} + +proc GetCommandTable*(interp: pInterp): pHashTable = + if interp != nil: + result = cast[pHashTable](cast[int](interp) + sizeof(Interp) + + sizeof(pointer)) + +proc CreateHashEntry*(tablePtr: pHashTable, key: cstring, + newPtr: pInteger): pHashEntry = + result = cast[pHashTable](tablePtr).createProc(tablePtr, key, newPtr) + +proc FindHashEntry*(tablePtr: pHashTable, key: cstring): pHashEntry = + result = cast[pHashTable](tablePtr).findProc(tablePtr, key) + +proc SetHashValue*(h: pHashEntry, clientData: TClientData) = + h.clientData = clientData + +proc GetHashValue*(h: pHashEntry): TClientData = + result = h.clientData + +proc IncrRefCount*(pObj: pObj) = + inc(pObj.refCount) + +proc DecrRefCount*(pObj: pObj) = + dec(pObj.refCount) + if pObj.refCount <= 0: + dealloc(pObj) + +proc IsShared*(pObj: pObj): bool = + return pObj.refCount > 1 + +proc GetHashKey*(hashTbl: pHashTable, hashEntry: pHashEntry): cstring = + if hashTbl == nil or hashEntry == nil: + result = nil + else: + result = hashEntry.key |