2N/A
2N/A#pragma ident "%Z%%M% %I% %E% SMI"
2N/A
2N/A/*
2N/A** 2003 December 18
2N/A**
2N/A** The author disclaims copyright to this source code. In place of
2N/A** a legal notice, here is a blessing:
2N/A**
2N/A** May you do good and not evil.
2N/A** May you find forgiveness for yourself and forgive others.
2N/A** May you share freely, never taking more than you give.
2N/A**
2N/A*************************************************************************
2N/A** Code for testing the the SQLite library in a multithreaded environment.
2N/A**
2N/A** $Id: test4.c,v 1.3 2004/04/23 17:04:45 drh Exp $
2N/A*/
2N/A#include "sqliteInt.h"
2N/A#include "tcl.h"
2N/A#if defined(OS_UNIX) && OS_UNIX==1 && defined(THREADSAFE) && THREADSAFE==1
2N/A#include <stdlib.h>
2N/A#include <string.h>
2N/A#include <pthread.h>
2N/A#include <sched.h>
2N/A#include <ctype.h>
2N/A
2N/A/*
2N/A** Each thread is controlled by an instance of the following
2N/A** structure.
2N/A*/
2N/Atypedef struct Thread Thread;
2N/Astruct Thread {
2N/A /* The first group of fields are writable by the master and read-only
2N/A ** to the thread. */
2N/A char *zFilename; /* Name of database file */
2N/A void (*xOp)(Thread*); /* next operation to do */
2N/A char *zArg; /* argument usable by xOp */
2N/A int opnum; /* Operation number */
2N/A int busy; /* True if this thread is in use */
2N/A
2N/A /* The next group of fields are writable by the thread but read-only to the
2N/A ** master. */
2N/A int completed; /* Number of operations completed */
2N/A sqlite *db; /* Open database */
2N/A sqlite_vm *vm; /* Pending operation */
2N/A char *zErr; /* operation error */
2N/A char *zStaticErr; /* Static error message */
2N/A int rc; /* operation return code */
2N/A int argc; /* number of columns in result */
2N/A const char **argv; /* result columns */
2N/A const char **colv; /* result column names */
2N/A};
2N/A
2N/A/*
2N/A** There can be as many as 26 threads running at once. Each is named
2N/A** by a capital letter: A, B, C, ..., Y, Z.
2N/A*/
2N/A#define N_THREAD 26
2N/Astatic Thread threadset[N_THREAD];
2N/A
2N/A
2N/A/*
2N/A** The main loop for a thread. Threads use busy waiting.
2N/A*/
2N/Astatic void *thread_main(void *pArg){
2N/A Thread *p = (Thread*)pArg;
2N/A if( p->db ){
2N/A sqlite_close(p->db);
2N/A }
2N/A p->db = sqlite_open(p->zFilename, 0, &p->zErr);
2N/A p->vm = 0;
2N/A p->completed = 1;
2N/A while( p->opnum<=p->completed ) sched_yield();
2N/A while( p->xOp ){
2N/A if( p->zErr && p->zErr!=p->zStaticErr ){
2N/A sqlite_freemem(p->zErr);
2N/A p->zErr = 0;
2N/A }
2N/A (*p->xOp)(p);
2N/A p->completed++;
2N/A while( p->opnum<=p->completed ) sched_yield();
2N/A }
2N/A if( p->vm ){
2N/A sqlite_finalize(p->vm, 0);
2N/A p->vm = 0;
2N/A }
2N/A if( p->db ){
2N/A sqlite_close(p->db);
2N/A p->db = 0;
2N/A }
2N/A if( p->zErr && p->zErr!=p->zStaticErr ){
2N/A sqlite_freemem(p->zErr);
2N/A p->zErr = 0;
2N/A }
2N/A p->completed++;
2N/A return 0;
2N/A}
2N/A
2N/A/*
2N/A** Get a thread ID which is an upper case letter. Return the index.
2N/A** If the argument is not a valid thread ID put an error message in
2N/A** the interpreter and return -1.
2N/A*/
2N/Astatic int parse_thread_id(Tcl_Interp *interp, const char *zArg){
2N/A if( zArg==0 || zArg[0]==0 || zArg[1]!=0 || !isupper(zArg[0]) ){
2N/A Tcl_AppendResult(interp, "thread ID must be an upper case letter", 0);
2N/A return -1;
2N/A }
2N/A return zArg[0] - 'A';
2N/A}
2N/A
2N/A/*
2N/A** Usage: thread_create NAME FILENAME
2N/A**
2N/A** NAME should be an upper case letter. Start the thread running with
2N/A** an open connection to the given database.
2N/A*/
2N/Astatic int tcl_thread_create(
2N/A void *NotUsed,
2N/A Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
2N/A int argc, /* Number of arguments */
2N/A const char **argv /* Text of each argument */
2N/A){
2N/A int i;
2N/A pthread_t x;
2N/A int rc;
2N/A
2N/A if( argc!=3 ){
2N/A Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
2N/A " ID FILENAME", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A i = parse_thread_id(interp, argv[1]);
2N/A if( i<0 ) return TCL_ERROR;
2N/A if( threadset[i].busy ){
2N/A Tcl_AppendResult(interp, "thread ", argv[1], " is already running", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A threadset[i].busy = 1;
2N/A sqliteFree(threadset[i].zFilename);
2N/A threadset[i].zFilename = sqliteStrDup(argv[2]);
2N/A threadset[i].opnum = 1;
2N/A threadset[i].completed = 0;
2N/A rc = pthread_create(&x, 0, thread_main, &threadset[i]);
2N/A if( rc ){
2N/A Tcl_AppendResult(interp, "failed to create the thread", 0);
2N/A sqliteFree(threadset[i].zFilename);
2N/A threadset[i].busy = 0;
2N/A return TCL_ERROR;
2N/A }
2N/A pthread_detach(x);
2N/A return TCL_OK;
2N/A}
2N/A
2N/A/*
2N/A** Wait for a thread to reach its idle state.
2N/A*/
2N/Astatic void thread_wait(Thread *p){
2N/A while( p->opnum>p->completed ) sched_yield();
2N/A}
2N/A
2N/A/*
2N/A** Usage: thread_wait ID
2N/A**
2N/A** Wait on thread ID to reach its idle state.
2N/A*/
2N/Astatic int tcl_thread_wait(
2N/A void *NotUsed,
2N/A Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
2N/A int argc, /* Number of arguments */
2N/A const char **argv /* Text of each argument */
2N/A){
2N/A int i;
2N/A
2N/A if( argc!=2 ){
2N/A Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
2N/A " ID", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A i = parse_thread_id(interp, argv[1]);
2N/A if( i<0 ) return TCL_ERROR;
2N/A if( !threadset[i].busy ){
2N/A Tcl_AppendResult(interp, "no such thread", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A thread_wait(&threadset[i]);
2N/A return TCL_OK;
2N/A}
2N/A
2N/A/*
2N/A** Stop a thread.
2N/A*/
2N/Astatic void stop_thread(Thread *p){
2N/A thread_wait(p);
2N/A p->xOp = 0;
2N/A p->opnum++;
2N/A thread_wait(p);
2N/A sqliteFree(p->zArg);
2N/A p->zArg = 0;
2N/A sqliteFree(p->zFilename);
2N/A p->zFilename = 0;
2N/A p->busy = 0;
2N/A}
2N/A
2N/A/*
2N/A** Usage: thread_halt ID
2N/A**
2N/A** Cause a thread to shut itself down. Wait for the shutdown to be
2N/A** completed. If ID is "*" then stop all threads.
2N/A*/
2N/Astatic int tcl_thread_halt(
2N/A void *NotUsed,
2N/A Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
2N/A int argc, /* Number of arguments */
2N/A const char **argv /* Text of each argument */
2N/A){
2N/A int i;
2N/A
2N/A if( argc!=2 ){
2N/A Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
2N/A " ID", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A if( argv[1][0]=='*' && argv[1][1]==0 ){
2N/A for(i=0; i<N_THREAD; i++){
2N/A if( threadset[i].busy ) stop_thread(&threadset[i]);
2N/A }
2N/A }else{
2N/A i = parse_thread_id(interp, argv[1]);
2N/A if( i<0 ) return TCL_ERROR;
2N/A if( !threadset[i].busy ){
2N/A Tcl_AppendResult(interp, "no such thread", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A stop_thread(&threadset[i]);
2N/A }
2N/A return TCL_OK;
2N/A}
2N/A
2N/A/*
2N/A** Usage: thread_argc ID
2N/A**
2N/A** Wait on the most recent thread_step to complete, then return the
2N/A** number of columns in the result set.
2N/A*/
2N/Astatic int tcl_thread_argc(
2N/A void *NotUsed,
2N/A Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
2N/A int argc, /* Number of arguments */
2N/A const char **argv /* Text of each argument */
2N/A){
2N/A int i;
2N/A char zBuf[100];
2N/A
2N/A if( argc!=2 ){
2N/A Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
2N/A " ID", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A i = parse_thread_id(interp, argv[1]);
2N/A if( i<0 ) return TCL_ERROR;
2N/A if( !threadset[i].busy ){
2N/A Tcl_AppendResult(interp, "no such thread", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A thread_wait(&threadset[i]);
2N/A sprintf(zBuf, "%d", threadset[i].argc);
2N/A Tcl_AppendResult(interp, zBuf, 0);
2N/A return TCL_OK;
2N/A}
2N/A
2N/A/*
2N/A** Usage: thread_argv ID N
2N/A**
2N/A** Wait on the most recent thread_step to complete, then return the
2N/A** value of the N-th columns in the result set.
2N/A*/
2N/Astatic int tcl_thread_argv(
2N/A void *NotUsed,
2N/A Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
2N/A int argc, /* Number of arguments */
2N/A const char **argv /* Text of each argument */
2N/A){
2N/A int i;
2N/A int n;
2N/A
2N/A if( argc!=3 ){
2N/A Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
2N/A " ID N", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A i = parse_thread_id(interp, argv[1]);
2N/A if( i<0 ) return TCL_ERROR;
2N/A if( !threadset[i].busy ){
2N/A Tcl_AppendResult(interp, "no such thread", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A if( Tcl_GetInt(interp, argv[2], &n) ) return TCL_ERROR;
2N/A thread_wait(&threadset[i]);
2N/A if( n<0 || n>=threadset[i].argc ){
2N/A Tcl_AppendResult(interp, "column number out of range", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A Tcl_AppendResult(interp, threadset[i].argv[n], 0);
2N/A return TCL_OK;
2N/A}
2N/A
2N/A/*
2N/A** Usage: thread_colname ID N
2N/A**
2N/A** Wait on the most recent thread_step to complete, then return the
2N/A** name of the N-th columns in the result set.
2N/A*/
2N/Astatic int tcl_thread_colname(
2N/A void *NotUsed,
2N/A Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
2N/A int argc, /* Number of arguments */
2N/A const char **argv /* Text of each argument */
2N/A){
2N/A int i;
2N/A int n;
2N/A
2N/A if( argc!=3 ){
2N/A Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
2N/A " ID N", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A i = parse_thread_id(interp, argv[1]);
2N/A if( i<0 ) return TCL_ERROR;
2N/A if( !threadset[i].busy ){
2N/A Tcl_AppendResult(interp, "no such thread", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A if( Tcl_GetInt(interp, argv[2], &n) ) return TCL_ERROR;
2N/A thread_wait(&threadset[i]);
2N/A if( n<0 || n>=threadset[i].argc ){
2N/A Tcl_AppendResult(interp, "column number out of range", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A Tcl_AppendResult(interp, threadset[i].colv[n], 0);
2N/A return TCL_OK;
2N/A}
2N/A
2N/A/*
2N/A** Usage: thread_result ID
2N/A**
2N/A** Wait on the most recent operation to complete, then return the
2N/A** result code from that operation.
2N/A*/
2N/Astatic int tcl_thread_result(
2N/A void *NotUsed,
2N/A Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
2N/A int argc, /* Number of arguments */
2N/A const char **argv /* Text of each argument */
2N/A){
2N/A int i;
2N/A const char *zName;
2N/A
2N/A if( argc!=2 ){
2N/A Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
2N/A " ID", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A i = parse_thread_id(interp, argv[1]);
2N/A if( i<0 ) return TCL_ERROR;
2N/A if( !threadset[i].busy ){
2N/A Tcl_AppendResult(interp, "no such thread", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A thread_wait(&threadset[i]);
2N/A switch( threadset[i].rc ){
2N/A case SQLITE_OK: zName = "SQLITE_OK"; break;
2N/A case SQLITE_ERROR: zName = "SQLITE_ERROR"; break;
2N/A case SQLITE_INTERNAL: zName = "SQLITE_INTERNAL"; break;
2N/A case SQLITE_PERM: zName = "SQLITE_PERM"; break;
2N/A case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
2N/A case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
2N/A case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
2N/A case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
2N/A case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
2N/A case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break;
2N/A case SQLITE_IOERR: zName = "SQLITE_IOERR"; break;
2N/A case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break;
2N/A case SQLITE_NOTFOUND: zName = "SQLITE_NOTFOUND"; break;
2N/A case SQLITE_FULL: zName = "SQLITE_FULL"; break;
2N/A case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break;
2N/A case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break;
2N/A case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break;
2N/A case SQLITE_SCHEMA: zName = "SQLITE_SCHEMA"; break;
2N/A case SQLITE_TOOBIG: zName = "SQLITE_TOOBIG"; break;
2N/A case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break;
2N/A case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break;
2N/A case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break;
2N/A case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break;
2N/A case SQLITE_AUTH: zName = "SQLITE_AUTH"; break;
2N/A case SQLITE_FORMAT: zName = "SQLITE_FORMAT"; break;
2N/A case SQLITE_RANGE: zName = "SQLITE_RANGE"; break;
2N/A case SQLITE_ROW: zName = "SQLITE_ROW"; break;
2N/A case SQLITE_DONE: zName = "SQLITE_DONE"; break;
2N/A default: zName = "SQLITE_Unknown"; break;
2N/A }
2N/A Tcl_AppendResult(interp, zName, 0);
2N/A return TCL_OK;
2N/A}
2N/A
2N/A/*
2N/A** Usage: thread_error ID
2N/A**
2N/A** Wait on the most recent operation to complete, then return the
2N/A** error string.
2N/A*/
2N/Astatic int tcl_thread_error(
2N/A void *NotUsed,
2N/A Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
2N/A int argc, /* Number of arguments */
2N/A const char **argv /* Text of each argument */
2N/A){
2N/A int i;
2N/A
2N/A if( argc!=2 ){
2N/A Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
2N/A " ID", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A i = parse_thread_id(interp, argv[1]);
2N/A if( i<0 ) return TCL_ERROR;
2N/A if( !threadset[i].busy ){
2N/A Tcl_AppendResult(interp, "no such thread", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A thread_wait(&threadset[i]);
2N/A Tcl_AppendResult(interp, threadset[i].zErr, 0);
2N/A return TCL_OK;
2N/A}
2N/A
2N/A/*
2N/A** This procedure runs in the thread to compile an SQL statement.
2N/A*/
2N/Astatic void do_compile(Thread *p){
2N/A if( p->db==0 ){
2N/A p->zErr = p->zStaticErr = "no database is open";
2N/A p->rc = SQLITE_ERROR;
2N/A return;
2N/A }
2N/A if( p->vm ){
2N/A sqlite_finalize(p->vm, 0);
2N/A p->vm = 0;
2N/A }
2N/A p->rc = sqlite_compile(p->db, p->zArg, 0, &p->vm, &p->zErr);
2N/A}
2N/A
2N/A/*
2N/A** Usage: thread_compile ID SQL
2N/A**
2N/A** Compile a new virtual machine.
2N/A*/
2N/Astatic int tcl_thread_compile(
2N/A void *NotUsed,
2N/A Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
2N/A int argc, /* Number of arguments */
2N/A const char **argv /* Text of each argument */
2N/A){
2N/A int i;
2N/A if( argc!=3 ){
2N/A Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
2N/A " ID SQL", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A i = parse_thread_id(interp, argv[1]);
2N/A if( i<0 ) return TCL_ERROR;
2N/A if( !threadset[i].busy ){
2N/A Tcl_AppendResult(interp, "no such thread", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A thread_wait(&threadset[i]);
2N/A threadset[i].xOp = do_compile;
2N/A sqliteFree(threadset[i].zArg);
2N/A threadset[i].zArg = sqliteStrDup(argv[2]);
2N/A threadset[i].opnum++;
2N/A return TCL_OK;
2N/A}
2N/A
2N/A/*
2N/A** This procedure runs in the thread to step the virtual machine.
2N/A*/
2N/Astatic void do_step(Thread *p){
2N/A if( p->vm==0 ){
2N/A p->zErr = p->zStaticErr = "no virtual machine available";
2N/A p->rc = SQLITE_ERROR;
2N/A return;
2N/A }
2N/A p->rc = sqlite_step(p->vm, &p->argc, &p->argv, &p->colv);
2N/A}
2N/A
2N/A/*
2N/A** Usage: thread_step ID
2N/A**
2N/A** Advance the virtual machine by one step
2N/A*/
2N/Astatic int tcl_thread_step(
2N/A void *NotUsed,
2N/A Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
2N/A int argc, /* Number of arguments */
2N/A const char **argv /* Text of each argument */
2N/A){
2N/A int i;
2N/A if( argc!=2 ){
2N/A Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
2N/A " IDL", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A i = parse_thread_id(interp, argv[1]);
2N/A if( i<0 ) return TCL_ERROR;
2N/A if( !threadset[i].busy ){
2N/A Tcl_AppendResult(interp, "no such thread", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A thread_wait(&threadset[i]);
2N/A threadset[i].xOp = do_step;
2N/A threadset[i].opnum++;
2N/A return TCL_OK;
2N/A}
2N/A
2N/A/*
2N/A** This procedure runs in the thread to finalize a virtual machine.
2N/A*/
2N/Astatic void do_finalize(Thread *p){
2N/A if( p->vm==0 ){
2N/A p->zErr = p->zStaticErr = "no virtual machine available";
2N/A p->rc = SQLITE_ERROR;
2N/A return;
2N/A }
2N/A p->rc = sqlite_finalize(p->vm, &p->zErr);
2N/A p->vm = 0;
2N/A}
2N/A
2N/A/*
2N/A** Usage: thread_finalize ID
2N/A**
2N/A** Finalize the virtual machine.
2N/A*/
2N/Astatic int tcl_thread_finalize(
2N/A void *NotUsed,
2N/A Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
2N/A int argc, /* Number of arguments */
2N/A const char **argv /* Text of each argument */
2N/A){
2N/A int i;
2N/A if( argc!=2 ){
2N/A Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
2N/A " IDL", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A i = parse_thread_id(interp, argv[1]);
2N/A if( i<0 ) return TCL_ERROR;
2N/A if( !threadset[i].busy ){
2N/A Tcl_AppendResult(interp, "no such thread", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A thread_wait(&threadset[i]);
2N/A threadset[i].xOp = do_finalize;
2N/A sqliteFree(threadset[i].zArg);
2N/A threadset[i].zArg = 0;
2N/A threadset[i].opnum++;
2N/A return TCL_OK;
2N/A}
2N/A
2N/A/*
2N/A** Usage: thread_swap ID ID
2N/A**
2N/A** Interchange the sqlite* pointer between two threads.
2N/A*/
2N/Astatic int tcl_thread_swap(
2N/A void *NotUsed,
2N/A Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
2N/A int argc, /* Number of arguments */
2N/A const char **argv /* Text of each argument */
2N/A){
2N/A int i, j;
2N/A sqlite *temp;
2N/A if( argc!=3 ){
2N/A Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
2N/A " ID1 ID2", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A i = parse_thread_id(interp, argv[1]);
2N/A if( i<0 ) return TCL_ERROR;
2N/A if( !threadset[i].busy ){
2N/A Tcl_AppendResult(interp, "no such thread", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A thread_wait(&threadset[i]);
2N/A j = parse_thread_id(interp, argv[2]);
2N/A if( j<0 ) return TCL_ERROR;
2N/A if( !threadset[j].busy ){
2N/A Tcl_AppendResult(interp, "no such thread", 0);
2N/A return TCL_ERROR;
2N/A }
2N/A thread_wait(&threadset[j]);
2N/A temp = threadset[i].db;
2N/A threadset[i].db = threadset[j].db;
2N/A threadset[j].db = temp;
2N/A return TCL_OK;
2N/A}
2N/A
2N/A/*
2N/A** Register commands with the TCL interpreter.
2N/A*/
2N/Aint Sqlitetest4_Init(Tcl_Interp *interp){
2N/A static struct {
2N/A char *zName;
2N/A Tcl_CmdProc *xProc;
2N/A } aCmd[] = {
2N/A { "thread_create", (Tcl_CmdProc*)tcl_thread_create },
2N/A { "thread_wait", (Tcl_CmdProc*)tcl_thread_wait },
2N/A { "thread_halt", (Tcl_CmdProc*)tcl_thread_halt },
2N/A { "thread_argc", (Tcl_CmdProc*)tcl_thread_argc },
2N/A { "thread_argv", (Tcl_CmdProc*)tcl_thread_argv },
2N/A { "thread_colname", (Tcl_CmdProc*)tcl_thread_colname },
2N/A { "thread_result", (Tcl_CmdProc*)tcl_thread_result },
2N/A { "thread_error", (Tcl_CmdProc*)tcl_thread_error },
2N/A { "thread_compile", (Tcl_CmdProc*)tcl_thread_compile },
2N/A { "thread_step", (Tcl_CmdProc*)tcl_thread_step },
2N/A { "thread_finalize", (Tcl_CmdProc*)tcl_thread_finalize },
2N/A { "thread_swap", (Tcl_CmdProc*)tcl_thread_swap },
2N/A };
2N/A int i;
2N/A
2N/A for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
2N/A Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
2N/A }
2N/A return TCL_OK;
2N/A}
2N/A#else
2N/Aint Sqlitetest4_Init(Tcl_Interp *interp){ return TCL_OK; }
2N/A#endif /* OS_UNIX */