SQLite

**
*************************************************************************
** Main file for the SQLite library.  The routines in this file
** implement the programmer interface to the library.  Routines in
** other files are for internal use by SQLite and should not be
** accessed by users of the library.
**
** $Id: main.c,v 1.195 2004/05/27 23:56:16 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "os.h"
#include <ctype.h>

/*
** A pointer to this structure is used to communicate information

  }else{
    rc = openDatabase(zFilename8, ppDb, options, TEXT_Utf16le);
  }

  sqliteFree(zFilename8);
  return rc;
}

/*
** Open a new database handle.
*/
int sqlite3_open_vararg(
  const char *filename,   /* Database filename (UTF-8) */
  sqlite3 **ppDb,         /* OUT: SQLite db handle */
  ...                     /* Option strings */
){
  va_list ap;
  const char **aOpts = 0;
  int nOpts = 0;
  int rc;

  /* Count the arguments */
  va_start(ap, ppDb);
  while( va_arg(ap, const char *) ) nOpts++;
  va_end(ap);

  /* If there are more than zero arguments, construct an array */
  if( nOpts ){
    aOpts = (const char **)sqliteMalloc(sizeof(const char *)*nOpts+1);
    if( !aOpts ){
      *ppDb = 0;
      return SQLITE_NOMEM;
    }
    va_start(ap, ppDb);
    nOpts = 0;
    while( va_arg(ap, const char *) ){
      aOpts[nOpts] = va_arg(ap, const char *);
      nOpts++;
    }
    aOpts[nOpts] = 0;
    va_end(ap);
  }
  
  /* Call the regular sqlite3_open() */
  rc = sqlite3_open(filename, ppDb, aOpts);
  if( aOpts ) sqliteFree(aOpts);
  return rc;
}

/*
** Open a new database handle.
*/
int sqlite3_open16_vararg(
  const void *filename,   /* Database filename (UTF-16) */
  sqlite3 **ppDb,         /* OUT: SQLite db handle */
  ...                     /* Option strings */
){
  va_list ap;
  const char **aOpts = 0;
  int nOpts = 0;
  int rc;

  /* Count the arguments */
  va_start(ap, ppDb);
  while( va_arg(ap, const char *) ) nOpts++;
  va_end(ap);

  /* If there are more than zero arguments, construct an array */
  if( nOpts ){
    aOpts = (const char **)sqliteMalloc(sizeof(const char *)*nOpts+1);
    if( !aOpts ){
      *ppDb = 0;
      return SQLITE_NOMEM;
    }
    va_start(ap, ppDb);
    nOpts = 0;
    while( va_arg(ap, const char *) ){
      aOpts[nOpts] = va_arg(ap, const char *);
      nOpts++;
    }
    aOpts[nOpts] = 0;
    va_end(ap);
  }
  
  /* Call the regular sqlite3_open16() */
  rc = sqlite3_open16(filename, ppDb, aOpts);
  if( aOpts ) sqliteFree(aOpts);
  return rc;
}

/*
** The following routine destroys a virtual machine that is created by
** the sqlite3_compile() routine. The integer returned is an SQLITE_
** success/failure code that describes the result of executing the virtual
** machine.
**

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains C code routines that are called by the parser
** to handle SELECT statements in SQLite.
**
** $Id: select.c,v 1.180 2004/05/27 23:56:16 danielk1977 Exp $
*/
#include "sqliteInt.h"


/*
** Allocate a new Select structure and return a pointer to that
** structure.

  Vdbe *v = pParse->pVdbe;
  int i, j;
  sqlite *db = pParse->db;
  int fullNames, shortNames;

  /* If this is an EXPLAIN, skip this step */
  if( pParse->explain ){
    return;
  }

  assert( v!=0 );
  if( pParse->colNamesSet || v==0 || sqlite3_malloc_failed ) return;
  pParse->colNamesSet = 1;
  fullNames = (db->flags & SQLITE_FullColNames)!=0;
  shortNames = (db->flags & SQLITE_ShortColNames)!=0;
  sqlite3VdbeSetNumCols(v, pEList->nExpr);
  for(i=0; i<pEList->nExpr; i++){
    Expr *p;

    p = pEList->a[i].pExpr;
    if( p==0 ) continue;
    if( pEList->a[i].zName ){
      char *zName = pEList->a[i].zName;
      sqlite3VdbeSetColName(v, i, zName, 0);
      continue;
    }

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This header file defines the interface that the SQLite library
** presents to client programs.
**
** @(#) $Id: sqlite.h.in,v 1.85 2004/05/27 23:56:16 danielk1977 Exp $
*/
#ifndef _SQLITE_H_
#define _SQLITE_H_
#include <stdarg.h>     /* Needed for the definition of va_list */

/*
** Make sure we can call this stuff from C++.

** called in response to a user action such as pressing "Cancel"
** or Ctrl-C where the user wants a long query operation to halt
** immediately.
*/
void sqlite3_interrupt(sqlite*);


/* These functions return true if the given input string comprises
** one or more complete SQL statements. For the sqlite3_complete() call,
** the parameter must be a nul-terminated UTF-8 string. For
** sqlite3_complete16(), a nul-terminated machine byte order UTF-16 string
** is required.
**
** The algorithm is simple.  If the last token other than spaces
** and comments is a semicolon, then return true.  otherwise return
** false.
*/
int sqlite3_complete(const char *sql);
int sqlite3_complete16(const void *sql);

/*
** This routine identifies a callback function that is invoked
** whenever an attempt is made to open a database table that is
** currently locked by another process or thread.  If the busy callback
** is NULL, then sqlite3_exec() returns SQLITE_BUSY immediately if
** it finds a locked table.  If the busy callback is not NULL, then

  const char **args       /* Null terminated array of option strings */
);
int sqlite3_open16(
  const void *filename,   /* Database filename (UTF-16) */
  sqlite3 **ppDb,         /* OUT: SQLite db handle */
  const char **args       /* Null terminated array of option strings */
);

/*
** The following two functions are identical to sqlite3_open() and
** sqlite3_open16(), except that any option strings are specified as the
** third and subsequent arguments, instead of as an array.  The final
** argument to either of the following two functions must be a NULL.
*/
int sqlite3_open_vararg(
  const char *filename,   /* Database filename (UTF-8) */
  sqlite3 **ppDb,         /* OUT: SQLite db handle */
  ...                     /* Option strings */
);
int sqlite3_open16_vararg(
  const void *filename,   /* Database filename (UTF-16) */
  sqlite3 **ppDb,         /* OUT: SQLite db handle */
  ...                     /* Option strings */
);

/*
** Return the error code for the most recent sqlite3_* API call associated
** with sqlite3 handle 'db'. SQLITE_OK is returned if the most recent 
** API call was successful.
**
** Calls to many sqlite3_* functions set the error code and string returned

*************************************************************************
** An tokenizer for SQL
**
** This file contains C code that splits an SQL input string up into
** individual tokens and sends those tokens one-by-one over to the
** parser for analysis.
**
** $Id: tokenize.c,v 1.74 2004/05/27 23:56:16 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "os.h"
#include <ctype.h>
#include <stdlib.h>

/*

      }
    }
    state = trans[state][token];
    zSql++;
  }
  return state==0;
}

/*
** This routine is the same as the sqlite3_complete() routine described
** above, except that the parameter is required to be UTF-16 encoded, not
** UTF-8.
*/
int sqlite3_complete16(const void *zSql){
  int rc;
  char *zSql8 = sqlite3utf16to8(zSql, -1, SQLITE3_BIGENDIAN);
  if( !zSql8 ) return 0;
  rc = sqlite3_complete(zSql8);
  sqliteFree(zSql8);
  return rc;
}

    }
    return len;
  }

  /* String or blob */
  assert( serial_type>=12 );
  len = sqlite3VdbeSerialTypeLen(serial_type);
  pMem->z = (char *)buf;
  pMem->n = len;
  if( serial_type&0x01 ){
    pMem->flags = MEM_Str | MEM_Ephem;
    pMem->enc = enc;
  }else{
    pMem->flags = MEM_Blob | MEM_Ephem;
  }