System.Data.SQLite
Check-in [d9c4970b26]
Not logged in

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:3.3.0 alpha
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | sourceforge
Files: files | file ages | folders
SHA1: d9c4970b26eeb6b742e74ad046803e32e5fda6c9
User & Date: rmsimpson 2006-01-11 03:22:29
Context
2006-01-11
05:00
1.0.24.3 refresh check-in: 944e15b0fa user: rmsimpson tags: sourceforge
03:22
3.3.0 alpha check-in: d9c4970b26 user: rmsimpson tags: sourceforge
2006-01-10
23:32
Fix a rollback bug check-in: e9bd66e344 user: rmsimpson tags: sourceforge
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to SQLite.Interop/src/alter.c.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This file contains C code routines that used to generate VDBE code
    13     13   ** that implements the ALTER TABLE command.
    14     14   **
    15         -** $Id: alter.c,v 1.12 2006/01/10 21:09:54 rmsimpson Exp $
           15  +** $Id: alter.c,v 1.13 2006/01/11 03:22:29 rmsimpson Exp $
    16     16   */
    17     17   #include "sqliteInt.h"
    18     18   #include <ctype.h>
    19     19   
    20     20   /*
    21     21   ** The code in this file only exists if we are not omitting the
    22     22   ** ALTER TABLE logic from the build.

Changes to SQLite.Interop/src/analyze.c.

     7      7   **    May you do good and not evil.
     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This file contains code associated with the ANALYZE command.
    13     13   **
    14         -** @(#) $Id: analyze.c,v 1.6 2006/01/10 21:09:54 rmsimpson Exp $
           14  +** @(#) $Id: analyze.c,v 1.7 2006/01/11 03:22:29 rmsimpson Exp $
    15     15   */
    16     16   #ifndef SQLITE_OMIT_ANALYZE
    17     17   #include "sqliteInt.h"
    18     18   
    19     19   /*
    20     20   ** This routine generates code that opens the sqlite_stat1 table on cursor
    21     21   ** iStatCur.

Changes to SQLite.Interop/src/attach.c.

     7      7   **    May you do good and not evil.
     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This file contains code used to implement the ATTACH and DETACH commands.
    13     13   **
    14         -** $Id: attach.c,v 1.12 2006/01/10 21:09:54 rmsimpson Exp $
           14  +** $Id: attach.c,v 1.13 2006/01/11 03:22:29 rmsimpson Exp $
    15     15   */
    16     16   #include "sqliteInt.h"
    17     17   
    18     18   /*
    19     19   ** Resolve an expression that was part of an ATTACH or DETACH statement. This
    20     20   ** is slightly different from resolving a normal SQL expression, because simple
    21     21   ** identifiers are treated as strings, not possible column names or aliases.

Changes to SQLite.Interop/src/auth.c.

    10     10   **
    11     11   *************************************************************************
    12     12   ** This file contains code used to implement the sqlite3_set_authorizer()
    13     13   ** API.  This facility is an optional feature of the library.  Embedded
    14     14   ** systems that do not need this facility may omit it by recompiling
    15     15   ** the library with -DSQLITE_OMIT_AUTHORIZATION=1
    16     16   **
    17         -** $Id: auth.c,v 1.12 2006/01/10 21:09:54 rmsimpson Exp $
           17  +** $Id: auth.c,v 1.13 2006/01/11 03:22:29 rmsimpson Exp $
    18     18   */
    19     19   #include "sqliteInt.h"
    20     20   
    21     21   /*
    22     22   ** All of the code in this file may be omitted by defining a single
    23     23   ** macro.
    24     24   */

Changes to SQLite.Interop/src/btree.c.

     5      5   ** a legal notice, here is a blessing:
     6      6   **
     7      7   **    May you do good and not evil.
     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12         -** $Id: btree.c,v 1.14 2006/01/10 21:09:54 rmsimpson Exp $
           12  +** $Id: btree.c,v 1.15 2006/01/11 03:22:29 rmsimpson Exp $
    13     13   **
    14     14   ** This file implements a external (disk-based) database using BTrees.
    15     15   ** For a detailed discussion of BTrees, refer to
    16     16   **
    17     17   **     Donald E. Knuth, THE ART OF COMPUTER PROGRAMMING, Volume 3:
    18     18   **     "Sorting And Searching", pages 473-480. Addison-Wesley
    19     19   **     Publishing Company, Reading, Massachusetts.

Changes to SQLite.Interop/src/btree.h.

     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This header file defines the interface that the sqlite B-Tree file
    13     13   ** subsystem.  See comments in the source code for a detailed description
    14     14   ** of what each interface routine does.
    15     15   **
    16         -** @(#) $Id: btree.h,v 1.13 2006/01/10 21:09:54 rmsimpson Exp $
           16  +** @(#) $Id: btree.h,v 1.14 2006/01/11 03:22:29 rmsimpson Exp $
    17     17   */
    18     18   #ifndef _BTREE_H_
    19     19   #define _BTREE_H_
    20     20   
    21     21   /* TODO: This definition is just included so other modules compile. It
    22     22   ** needs to be revisited.
    23     23   */

Changes to SQLite.Interop/src/build.c.

    18     18   **     CREATE INDEX
    19     19   **     DROP INDEX
    20     20   **     creating ID lists
    21     21   **     BEGIN TRANSACTION
    22     22   **     COMMIT
    23     23   **     ROLLBACK
    24     24   **
    25         -** $Id: build.c,v 1.12 2006/01/10 21:09:54 rmsimpson Exp $
           25  +** $Id: build.c,v 1.13 2006/01/11 03:22:29 rmsimpson Exp $
    26     26   */
    27     27   #include "sqliteInt.h"
    28     28   #include <ctype.h>
    29     29   
    30     30   /*
    31     31   ** This routine is called when a new SQL statement is beginning to
    32     32   ** be parsed.  Initialize the pParse structure as needed.

Changes to SQLite.Interop/src/callback.c.

     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   **
    13     13   ** This file contains functions used to access the internal hash tables
    14     14   ** of user defined functions and collation sequences.
    15     15   **
    16         -** $Id: callback.c,v 1.8 2006/01/10 21:09:55 rmsimpson Exp $
           16  +** $Id: callback.c,v 1.9 2006/01/11 03:22:29 rmsimpson Exp $
    17     17   */
    18     18   
    19     19   #include "sqliteInt.h"
    20     20   
    21     21   /*
    22     22   ** Invoke the 'collation needed' callback to request a collation sequence
    23     23   ** in the database text encoding of name zName, length nName.

Changes to SQLite.Interop/src/complete.c.

    12     12   ** An tokenizer for SQL
    13     13   **
    14     14   ** This file contains C code that implements the sqlite3_complete() API.
    15     15   ** This code used to be part of the tokenizer.c source file.  But by
    16     16   ** separating it out, the code will be automatically omitted from
    17     17   ** static links that do not use it.
    18     18   **
    19         -** $Id: complete.c,v 1.6 2006/01/10 21:09:55 rmsimpson Exp $
           19  +** $Id: complete.c,v 1.7 2006/01/11 03:22:29 rmsimpson Exp $
    20     20   */
    21     21   #include "sqliteInt.h"
    22     22   #ifndef SQLITE_OMIT_COMPLETE
    23     23   
    24     24   /*
    25     25   ** This is defined in tokenize.c.  We just have to import the definition.
    26     26   */

Changes to SQLite.Interop/src/date.c.

    12     12   ** This file contains the C functions that implement date and time
    13     13   ** functions for SQLite.  
    14     14   **
    15     15   ** There is only one exported symbol in this file - the function
    16     16   ** sqlite3RegisterDateTimeFunctions() found at the bottom of the file.
    17     17   ** All other code has file scope.
    18     18   **
    19         -** $Id: date.c,v 1.12 2006/01/10 21:09:55 rmsimpson Exp $
           19  +** $Id: date.c,v 1.13 2006/01/11 03:22:29 rmsimpson Exp $
    20     20   **
    21     21   ** NOTES:
    22     22   **
    23     23   ** SQLite processes all times and dates as Julian Day numbers.  The
    24     24   ** dates and times are stored as the number of days since noon
    25     25   ** in Greenwich on November 24, 4714 B.C. according to the Gregorian
    26     26   ** calendar system.

Changes to SQLite.Interop/src/delete.c.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This file contains C code routines that are called by the parser
    13     13   ** in order to generate code for DELETE FROM statements.
    14     14   **
    15         -** $Id: delete.c,v 1.12 2006/01/10 21:09:55 rmsimpson Exp $
           15  +** $Id: delete.c,v 1.13 2006/01/11 03:22:29 rmsimpson Exp $
    16     16   */
    17     17   #include "sqliteInt.h"
    18     18   
    19     19   /*
    20     20   ** Look up every table that is named in pSrc.  If any table is not found,
    21     21   ** add an error message to pParse->zErrMsg and return NULL.  If all tables
    22     22   ** are found, return a pointer to the last table.

Changes to SQLite.Interop/src/experimental.c.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This file contains C code routines that are not a part of the official
    13     13   ** SQLite API.  These routines are unsupported.
    14     14   **
    15         -** $Id: experimental.c,v 1.2 2006/01/10 21:09:55 rmsimpson Exp $
           15  +** $Id: experimental.c,v 1.3 2006/01/11 03:22:30 rmsimpson Exp $
    16     16   */
    17     17   #include "sqliteInt.h"
    18     18   
    19     19   /*
    20     20   ** Set all the parameters in the compiled SQL statement to NULL.
    21     21   */
    22     22   int sqlite3_clear_bindings(sqlite3_stmt *pStmt){

Changes to SQLite.Interop/src/expr.c.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This file contains routines used for analyzing expressions and
    13     13   ** for generating VDBE code that evaluates expressions in SQLite.
    14     14   **
    15         -** $Id: expr.c,v 1.19 2006/01/10 21:09:55 rmsimpson Exp $
           15  +** $Id: expr.c,v 1.20 2006/01/11 03:22:29 rmsimpson Exp $
    16     16   */
    17     17   #include "sqliteInt.h"
    18     18   #include <ctype.h>
    19     19   
    20     20   /*
    21     21   ** Return the 'affinity' of the expression pExpr if any.
    22     22   **

Changes to SQLite.Interop/src/func.c.

    12     12   ** This file contains the C functions that implement various SQL
    13     13   ** functions of SQLite.  
    14     14   **
    15     15   ** There is only one exported symbol in this file - the function
    16     16   ** sqliteRegisterBuildinFunctions() found at the bottom of the file.
    17     17   ** All other code has file scope.
    18     18   **
    19         -** $Id: func.c,v 1.13 2006/01/10 21:09:55 rmsimpson Exp $
           19  +** $Id: func.c,v 1.14 2006/01/11 03:22:29 rmsimpson Exp $
    20     20   */
    21     21   #include "sqliteInt.h"
    22     22   #include <ctype.h>
    23     23   /* #include <math.h> */
    24     24   #include <stdlib.h>
    25     25   #include <assert.h>
    26     26   #include "vdbeInt.h"

Changes to SQLite.Interop/src/hash.c.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This is the implementation of generic hash-tables
    13     13   ** used in SQLite.
    14     14   **
    15         -** $Id: hash.c,v 1.12 2006/01/10 21:09:55 rmsimpson Exp $
           15  +** $Id: hash.c,v 1.13 2006/01/11 03:22:29 rmsimpson Exp $
    16     16   */
    17     17   #include "sqliteInt.h"
    18     18   #include <assert.h>
    19     19   
    20     20   /* Turn bulk memory into a hash table object by initializing the
    21     21   ** fields of the Hash structure.
    22     22   **

Changes to SQLite.Interop/src/hash.h.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This is the header file for the generic hash-table implemenation
    13     13   ** used in SQLite.
    14     14   **
    15         -** $Id: hash.h,v 1.12 2006/01/10 21:09:55 rmsimpson Exp $
           15  +** $Id: hash.h,v 1.13 2006/01/11 03:22:29 rmsimpson Exp $
    16     16   */
    17     17   #ifndef _SQLITE_HASH_H_
    18     18   #define _SQLITE_HASH_H_
    19     19   
    20     20   /* Forward declarations of structures. */
    21     21   typedef struct Hash Hash;
    22     22   typedef struct HashElem HashElem;

Changes to SQLite.Interop/src/insert.c.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This file contains C code routines that are called by the parser
    13     13   ** to handle INSERT statements in SQLite.
    14     14   **
    15         -** $Id: insert.c,v 1.12 2006/01/10 21:09:55 rmsimpson Exp $
           15  +** $Id: insert.c,v 1.13 2006/01/11 03:22:29 rmsimpson Exp $
    16     16   */
    17     17   #include "sqliteInt.h"
    18     18   
    19     19   /*
    20     20   ** Set P3 of the most recently inserted opcode to a column affinity
    21     21   ** string for index pIdx. A column affinity string has one character
    22     22   ** for each column in the table, according to the affinity of the column:

Changes to SQLite.Interop/src/keywordhash.h.

     8      8       "CASECASTCOLLATECOLUMNCOMMITCONFLICTCONSTRAINTERSECTCREATECROSS"
     9      9       "CURRENT_DATECURRENT_TIMESTAMPLANDESCDETACHDISTINCTDROPRAGMATCH"
    10     10       "FAILIMITFROMFULLGROUPDATEIFIMMEDIATEINSERTINSTEADINTOFFSETISNULL"
    11     11       "JOINORDEREPLACEOUTERESTRICTPRIMARYQUERYRIGHTROLLBACKROWHENUNION"
    12     12       "UNIQUEUSINGVACUUMVALUESVIEWHERE";
    13     13     static const unsigned char aHash[127] = {
    14     14         92,  80, 107,  91,   0,   4,   0,   0, 114,   0,  83,   0,   0,
    15         -      96,  44,  76,  93,   0, 106, 109,  97,  90,   0,  10,   0,   0,
           15  +      95,  44,  76,  93,   0, 106, 109,  97,  90,   0,  10,   0,   0,
    16     16        113,   0, 110, 103,   0,  28,  48,   0,  41,   0,   0,  65,  71,
    17         -       0,  63,  19,   0, 105,  36, 104,   0, 108,  75,   0,   0,  33,
           17  +       0,  63,  19,   0, 105,  36, 104,   0, 108,  74,   0,   0,  33,
    18     18          0,  61,  37,   0,   8,   0, 115,  38,  12,   0,  77,  40,  25,
    19     19         66,   0,   0,  31,  81,  53,  30,  50,  20,  88,   0,  34,   0,
    20         -      74,  26,   0,  72,   0,   0,   0,  64,  47,  67,  22,  87,  29,
           20  +      75,  26,   0,  72,   0,   0,   0,  64,  47,  67,  22,  87,  29,
    21     21         69,  86,   0,   1,   0,   9, 101,  58,  18,   0, 112,  82,  99,
    22         -      55,   6,  85,   0,   0,  49,  94,   0, 102,   0,  70,   0,   0,
    23         -      15,   0, 116,  51,  56,   0,   2,  54,   0, 111,
           22  +      54,   6,  85,   0,   0,  49,  94,   0, 102,   0,  70,   0,   0,
           23  +      15,   0, 116,  51,  56,   0,   2,  55,   0, 111,
    24     24     };
    25     25     static const unsigned char aNext[116] = {
    26     26          0,   0,   0,   0,   0,   3,   0,   0,   0,   0,   0,   0,   0,
    27     27          0,   0,   0,   0,   0,   0,   0,   0,  17,   0,   0,   0,   0,
    28     28          0,  11,   0,   0,   0,   0,   5,  13,   0,   7,   0,   0,   0,
    29         -       0,   0,   0,   0,   0,   0,   0,  42,   0,   0,   0,   0,   0,
    30         -       0,  16,   0,   0,  23,  52,   0,   0,   0,   0,  45,   0,  59,
    31         -       0,   0,   0,   0,   0,   0,   0,   0,  43,  73,   0,  24,  60,
           29  +       0,   0,   0,   0,   0,   0,   0,  43,   0,   0,   0,   0,   0,
           30  +       0,   0,  16,   0,  23,  52,   0,   0,   0,   0,  45,   0,  59,
           31  +       0,   0,   0,   0,   0,   0,   0,   0,  73,  42,   0,  24,  60,
    32     32         21,   0,  79,   0,   0,  68,   0,   0,  84,  46,   0,   0,   0,
    33         -       0,   0,   0,   0,   0,  39,  95,  98,   0,   0, 100,   0,  32,
           33  +       0,   0,   0,   0,   0,  39,  96,  98,   0,   0, 100,   0,  32,
    34     34          0,  14,  27,  78,   0,  57,  89,   0,  35,   0,  62,   0,
    35     35     };
    36     36     static const unsigned char aLen[116] = {
    37     37          5,   5,   4,   4,   9,   2,   3,   8,   2,   6,   4,   3,   7,
    38     38         11,   2,   7,   5,   5,   4,   5,   3,   5,  10,   6,   4,   6,
    39     39          7,   6,   7,   9,   3,   7,   9,   6,   9,   3,  10,   6,   6,
    40         -       4,   6,   7,   3,   6,   7,   5,  13,   2,   2,   5,   5,   6,
    41         -       7,   7,   3,   4,   4,   2,   7,   3,   8,   6,   4,   4,   7,
    42         -       6,   6,   8,  10,   9,   6,   5,  12,  17,  12,   4,   4,   6,
           40  +       4,   6,   3,   7,   6,   7,   5,  13,   2,   2,   5,   5,   6,
           41  +       7,   3,   7,   4,   4,   2,   7,   3,   8,   6,   4,   4,   7,
           42  +       6,   6,   8,  10,   9,   6,   5,  12,  12,  17,   4,   4,   6,
    43     43          8,   2,   4,   6,   5,   4,   5,   4,   4,   5,   6,   2,   9,
    44         -       6,   7,   4,   6,   2,   3,   6,   4,   5,   7,   5,   8,   7,
           44  +       6,   7,   4,   2,   6,   3,   6,   4,   5,   7,   5,   8,   7,
    45     45          5,   5,   8,   3,   4,   5,   6,   5,   6,   6,   4,   5,
    46     46     };
    47     47     static const unsigned short int aOffset[116] = {
    48     48          0,   4,   7,  10,  10,  14,  19,  21,  26,  27,  32,  34,  36,
    49     49         42,  51,  52,  57,  61,  65,  67,  71,  74,  78,  86,  91,  94,
    50     50         99, 105, 108, 113, 118, 122, 128, 136, 141, 150, 152, 162, 167,
    51     51        172, 175, 177, 177, 181, 185, 187, 192, 194, 196, 205, 208, 212,
................................................................................
    60     60       TK_OR,         TK_ADD,        TK_DATABASE,   TK_AS,         TK_SELECT,     
    61     61       TK_THEN,       TK_END,        TK_DEFAULT,    TK_TRANSACTION,TK_ON,         
    62     62       TK_JOIN_KW,    TK_ALTER,      TK_RAISE,      TK_EACH,       TK_CHECK,      
    63     63       TK_KEY,        TK_AFTER,      TK_REFERENCES, TK_ESCAPE,     TK_ELSE,       
    64     64       TK_EXCEPT,     TK_TRIGGER,    TK_LIKE_KW,    TK_EXPLAIN,    TK_INITIALLY,  
    65     65       TK_ALL,        TK_ANALYZE,    TK_EXCLUSIVE,  TK_EXISTS,     TK_STATEMENT,  
    66     66       TK_AND,        TK_DEFERRABLE, TK_ATTACH,     TK_HAVING,     TK_LIKE_KW,    
    67         -    TK_BEFORE,     TK_FOREIGN,    TK_FOR,        TK_IGNORE,     TK_REINDEX,    
           67  +    TK_BEFORE,     TK_FOR,        TK_FOREIGN,    TK_IGNORE,     TK_REINDEX,    
    68     68       TK_INDEX,      TK_AUTOINCR,   TK_TO,         TK_IN,         TK_BEGIN,      
    69         -    TK_JOIN_KW,    TK_RENAME,     TK_BETWEEN,    TK_NOTNULL,    TK_NOT,        
           69  +    TK_JOIN_KW,    TK_RENAME,     TK_BETWEEN,    TK_NOT,        TK_NOTNULL,    
    70     70       TK_NULL,       TK_LIKE_KW,    TK_BY,         TK_CASCADE,    TK_ASC,        
    71     71       TK_DEFERRED,   TK_DELETE,     TK_CASE,       TK_CAST,       TK_COLLATE,    
    72     72       TK_COLUMNKW,   TK_COMMIT,     TK_CONFLICT,   TK_CONSTRAINT, TK_INTERSECT,  
    73     73       TK_CREATE,     TK_JOIN_KW,    TK_CTIME_KW,   TK_CTIME_KW,   TK_CTIME_KW,   
    74     74       TK_PLAN,       TK_DESC,       TK_DETACH,     TK_DISTINCT,   TK_IS,         
    75     75       TK_DROP,       TK_PRAGMA,     TK_MATCH,      TK_FAIL,       TK_LIMIT,      
    76     76       TK_FROM,       TK_JOIN_KW,    TK_GROUP,      TK_UPDATE,     TK_IF,         
    77         -    TK_IMMEDIATE,  TK_INSERT,     TK_INSTEAD,    TK_INTO,       TK_OFFSET,     
    78         -    TK_OF,         TK_SET,        TK_ISNULL,     TK_JOIN,       TK_ORDER,      
           77  +    TK_IMMEDIATE,  TK_INSERT,     TK_INSTEAD,    TK_INTO,       TK_OF,         
           78  +    TK_OFFSET,     TK_SET,        TK_ISNULL,     TK_JOIN,       TK_ORDER,      
    79     79       TK_REPLACE,    TK_JOIN_KW,    TK_RESTRICT,   TK_PRIMARY,    TK_QUERY,      
    80     80       TK_JOIN_KW,    TK_ROLLBACK,   TK_ROW,        TK_WHEN,       TK_UNION,      
    81     81       TK_UNIQUE,     TK_USING,      TK_VACUUM,     TK_VALUES,     TK_VIEW,       
    82     82       TK_WHERE,      
    83     83     };
    84     84     int h, i;
    85     85     if( n<2 ) return TK_ID;

Changes to SQLite.Interop/src/legacy.c.

    10     10   **
    11     11   *************************************************************************
    12     12   ** Main file for the SQLite library.  The routines in this file
    13     13   ** implement the programmer interface to the library.  Routines in
    14     14   ** other files are for internal use by SQLite and should not be
    15     15   ** accessed by users of the library.
    16     16   **
    17         -** $Id: legacy.c,v 1.12 2006/01/10 21:10:18 rmsimpson Exp $
           17  +** $Id: legacy.c,v 1.13 2006/01/11 03:22:29 rmsimpson Exp $
    18     18   */
    19     19   
    20     20   #include "sqliteInt.h"
    21     21   #include "os.h"
    22     22   #include <ctype.h>
    23     23   
    24     24   /*

Changes to SQLite.Interop/src/main.c.

    10     10   **
    11     11   *************************************************************************
    12     12   ** Main file for the SQLite library.  The routines in this file
    13     13   ** implement the programmer interface to the library.  Routines in
    14     14   ** other files are for internal use by SQLite and should not be
    15     15   ** accessed by users of the library.
    16     16   **
    17         -** $Id: main.c,v 1.12 2006/01/10 21:10:18 rmsimpson Exp $
           17  +** $Id: main.c,v 1.13 2006/01/11 03:22:29 rmsimpson Exp $
    18     18   */
    19     19   #include "sqliteInt.h"
    20     20   #include "os.h"
    21     21   #include <ctype.h>
    22     22   
    23     23   /*
    24     24   ** The following constant value is used by the SQLITE_BIGENDIAN and

Changes to SQLite.Interop/src/opcodes.c.

     1      1   /* Automatically generated.  Do not edit */
     2      2   /* See the mkopcodec.awk script for details. */
     3      3   #if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
     4      4   const char *const sqlite3OpcodeNames[] = { "?",
     5      5    /*   1 */ "MemLoad",
     6         - /* 125 */ "HexBlob",
     7      6    /*   2 */ "Column",
     8      7    /*   3 */ "SetCookie",
     9      8    /*   4 */ "IfMemPos",
    10         - /* 124 */ "Real",
    11      9    /*   5 */ "Sequence",
    12     10    /*   6 */ "MoveGt",
    13         - /*  71 */ "Ge",
    14     11    /*   7 */ "RowKey",
    15         - /*  67 */ "Eq",
    16     12    /*   8 */ "OpenWrite",
    17         - /*  65 */ "NotNull",
    18     13    /*   9 */ "If",
    19         - /* 140 */ "ToInt",
    20         - /*  86 */ "String8",
    21     14    /*  10 */ "Pop",
    22     15    /*  11 */ "CollSeq",
    23     16    /*  12 */ "OpenRead",
    24     17    /*  13 */ "Expire",
    25     18    /*  14 */ "AutoCommit",
    26         - /*  68 */ "Gt",
    27     19    /*  15 */ "IntegrityCk",
           20  + /*  16 */ "Not",
    28     21    /*  17 */ "Sort",
    29     22    /*  18 */ "Function",
    30         - /*  60 */ "And",
    31         - /*  78 */ "Subtract",
    32     23    /*  19 */ "Noop",
    33     24    /*  20 */ "Return",
    34         - /*  81 */ "Remainder",
    35     25    /*  21 */ "NewRowid",
    36         - /*  79 */ "Multiply",
    37     26    /*  22 */ "IfMemNeg",
    38     27    /*  23 */ "Variable",
    39     28    /*  24 */ "String",
    40     29    /*  25 */ "RealAffinity",
    41     30    /*  26 */ "ParseSchema",
    42     31    /*  27 */ "Close",
    43     32    /*  28 */ "CreateIndex",
................................................................................
    50     39    /*  35 */ "Rowid",
    51     40    /*  36 */ "IdxLT",
    52     41    /*  37 */ "AddImm",
    53     42    /*  38 */ "Statement",
    54     43    /*  39 */ "RowData",
    55     44    /*  40 */ "MemMax",
    56     45    /*  41 */ "Push",
    57         - /*  59 */ "Or",
    58     46    /*  42 */ "NotExists",
    59     47    /*  43 */ "MemIncr",
    60     48    /*  44 */ "Gosub",
    61         - /*  80 */ "Divide",
    62     49    /*  45 */ "Integer",
    63         - /* 139 */ "ToNumeric",
    64     50    /*  46 */ "MemInt",
    65     51    /*  47 */ "Prev",
    66         - /*  82 */ "Concat",
    67         - /*  73 */ "BitAnd",
    68     52    /*  48 */ "CreateTable",
    69     53    /*  49 */ "Last",
    70         - /*  64 */ "IsNull",
    71     54    /*  50 */ "IdxRowid",
    72     55    /*  51 */ "MakeIdxRec",
    73         - /*  76 */ "ShiftRight",
    74     56    /*  52 */ "ResetCount",
    75     57    /*  53 */ "FifoWrite",
    76     58    /*  54 */ "Callback",
    77     59    /*  55 */ "ContextPush",
    78     60    /*  56 */ "DropTrigger",
    79     61    /*  57 */ "DropIndex",
    80     62    /*  58 */ "IdxGE",
           63  + /*  59 */ "Or",
           64  + /*  60 */ "And",
    81     65    /*  61 */ "IdxDelete",
    82     66    /*  62 */ "Vacuum",
    83     67    /*  63 */ "MoveLe",
           68  + /*  64 */ "IsNull",
           69  + /*  65 */ "NotNull",
           70  + /*  66 */ "Ne",
           71  + /*  67 */ "Eq",
           72  + /*  68 */ "Gt",
           73  + /*  69 */ "Le",
           74  + /*  70 */ "Lt",
           75  + /*  71 */ "Ge",
    84     76    /*  72 */ "IfNot",
           77  + /*  73 */ "BitAnd",
           78  + /*  74 */ "BitOr",
           79  + /*  75 */ "ShiftLeft",
           80  + /*  76 */ "ShiftRight",
           81  + /*  77 */ "Add",
           82  + /*  78 */ "Subtract",
           83  + /*  79 */ "Multiply",
           84  + /*  80 */ "Divide",
           85  + /*  81 */ "Remainder",
           86  + /*  82 */ "Concat",
           87  + /*  83 */ "Negative",
    85     88    /*  84 */ "DropTable",
           89  + /*  85 */ "BitNot",
           90  + /*  86 */ "String8",
    86     91    /*  87 */ "MakeRecord",
    87         - /* 138 */ "ToBlob",
    88     92    /*  88 */ "Delete",
    89     93    /*  89 */ "AggFinal",
    90         - /*  75 */ "ShiftLeft",
    91     94    /*  90 */ "Dup",
    92     95    /*  91 */ "Goto",
    93     96    /*  92 */ "TableLock",
    94     97    /*  93 */ "FifoRead",
    95     98    /*  94 */ "Clear",
    96     99    /*  95 */ "IdxGT",
    97    100    /*  96 */ "MoveLt",
    98         - /*  69 */ "Le",
    99    101    /*  97 */ "VerifyCookie",
   100    102    /*  98 */ "AggStep",
   101    103    /*  99 */ "Pull",
   102         - /* 137 */ "ToText",
   103         - /*  16 */ "Not",
   104         - /* 141 */ "ToReal",
   105    104    /* 100 */ "SetNumColumns",
   106    105    /* 101 */ "AbsValue",
   107    106    /* 102 */ "Transaction",
   108         - /*  83 */ "Negative",
   109         - /*  66 */ "Ne",
   110    107    /* 103 */ "ContextPop",
   111         - /*  74 */ "BitOr",
   112    108    /* 104 */ "Next",
   113    109    /* 105 */ "IdxInsert",
   114    110    /* 106 */ "Distinct",
   115         - /*  70 */ "Lt",
   116    111    /* 107 */ "Insert",
   117    112    /* 108 */ "Destroy",
   118    113    /* 109 */ "ReadCookie",
   119    114    /* 110 */ "ForceInt",
   120    115    /* 111 */ "LoadAnalysis",
   121    116    /* 112 */ "OpenVirtual",
   122    117    /* 113 */ "Explain",
   123    118    /* 114 */ "IfMemZero",
   124    119    /* 115 */ "OpenPseudo",
   125    120    /* 116 */ "Null",
   126    121    /* 117 */ "Blob",
   127         - /*  77 */ "Add",
   128    122    /* 118 */ "MemStore",
   129    123    /* 119 */ "Rewind",
   130    124    /* 120 */ "MoveGe",
   131         - /*  85 */ "BitNot",
   132    125    /* 121 */ "MemMove",
   133    126    /* 122 */ "MemNull",
   134    127    /* 123 */ "Found",
          128  + /* 124 */ "Real",
          129  + /* 125 */ "HexBlob",
   135    130    /* 126 */ "NullRow",
   136    131    /* 127 */ "NotUsed_127",
   137    132    /* 128 */ "NotUsed_128",
   138    133    /* 129 */ "NotUsed_129",
   139    134    /* 130 */ "NotUsed_130",
   140    135    /* 131 */ "NotUsed_131",
   141    136    /* 132 */ "NotUsed_132",
   142    137    /* 133 */ "NotUsed_133",
   143    138    /* 134 */ "NotUsed_134",
   144    139    /* 135 */ "NotUsed_135",
   145    140    /* 136 */ "NotUsed_136",
          141  + /* 137 */ "ToText",
          142  + /* 138 */ "ToBlob",
          143  + /* 139 */ "ToNumeric",
          144  + /* 140 */ "ToInt",
          145  + /* 141 */ "ToReal",
   146    146   };
   147    147   #endif

Changes to SQLite.Interop/src/os_win.c.

   240    240     WCHAR *pszName = utf8ToUnicode(pszFilename);
   241    241     BOOL bInit = TRUE;
   242    242   
   243    243     /* Initialize the local lockdata */
   244    244     ZeroMemory(&pLocks->local, sizeof(LOCKDATA));
   245    245   
   246    246     /* Create a unique global name for the mutex and subsequently the shared memory */
   247         -  _wcslwr(pszName);
          247  +  CharLowerW(pszName);
   248    248     while (pszTok = wcschr(pszName, '\\'))
   249    249     {
   250    250       *pszTok = '_';
   251    251     }
   252    252   
   253    253     /* Create/open the named mutex */
   254    254     pLocks->hMutex = CreateMutexW(NULL, FALSE, pszName);
................................................................................
   258    258       return FALSE;
   259    259     }
   260    260   
   261    261     /* Acquire the mutex before continuing */
   262    262     MUTEX_ACQUIRE(pLocks->hMutex);
   263    263     
   264    264     /* Create/open the shared memory */
   265         -  _wcsupr(pszName);
          265  +  CharUpperW(pszName);
   266    266     pLocks->hShared = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, sizeof(LOCKDATA), pszName);  
   267    267   
   268    268     /* Set a flag that indicates we're the first to create the memory so it must be zero-initialized */
   269    269     if (GetLastError() == ERROR_ALREADY_EXISTS)
   270    270     {
   271    271       bInit = FALSE;
   272    272     }

Changes to SQLite.Interop/src/pager.c.

    14     14   ** The pager is used to access a database disk file.  It implements
    15     15   ** atomic commit and rollback through the use of a journal file that
    16     16   ** is separate from the database file.  The pager also implements file
    17     17   ** locking to prevent two processes from writing the same database
    18     18   ** file simultaneously, or one process from reading the database while
    19     19   ** another is writing.
    20     20   **
    21         -** @(#) $Id: pager.c,v 1.13 2006/01/10 21:10:18 rmsimpson Exp $
           21  +** @(#) $Id: pager.c,v 1.14 2006/01/11 03:22:29 rmsimpson Exp $
    22     22   */
    23     23   #ifndef SQLITE_OMIT_DISKIO
    24     24   #include "sqliteInt.h"
    25     25   #include "os.h"
    26     26   #include "pager.h"
    27     27   #include <assert.h>
    28     28   #include <string.h>
................................................................................
   438    438       unsigned char ac[4];
   439    439       memcpy(ac, &res, 4);
   440    440       res = (ac[0]<<24) | (ac[1]<<16) | (ac[2]<<8) | ac[3];
   441    441     }
   442    442     *pRes = res;
   443    443     return rc;
   444    444   }
          445  +
          446  +/*
          447  +** Write a 32-bit integer into a string buffer in big-endian byte order.
          448  +*/
          449  +static void put32bits(char *ac, u32 val){
          450  +  ac[0] = (val>>24) & 0xff;
          451  +  ac[1] = (val>>16) & 0xff;
          452  +  ac[2] = (val>>8) & 0xff;
          453  +  ac[3] = val & 0xff;
          454  +}
   445    455   
   446    456   /*
   447    457   ** Write a 32-bit integer into the given file descriptor.  Return SQLITE_OK
   448    458   ** on success or an error code is something goes wrong.
   449    459   */
   450    460   static int write32bits(OsFile *fd, u32 val){
   451    461     unsigned char ac[4];
   452         -  ac[0] = (val>>24) & 0xff;
   453         -  ac[1] = (val>>16) & 0xff;
   454         -  ac[2] = (val>>8) & 0xff;
   455         -  ac[3] = val & 0xff;
          462  +  put32bits(ac, val);
   456    463     return sqlite3OsWrite(fd, ac, 4);
   457    464   }
   458    465   
   459    466   /*
   460    467   ** Write the 32-bit integer 'val' into the page identified by page header
   461    468   ** 'p' at offset 'offset'.
   462    469   */
   463    470   static void store32bits(u32 val, PgHdr *p, int offset){
   464    471     unsigned char *ac;
   465    472     ac = &((unsigned char*)PGHDR_TO_DATA(p))[offset];
   466         -  ac[0] = (val>>24) & 0xff;
   467         -  ac[1] = (val>>16) & 0xff;
   468         -  ac[2] = (val>>8) & 0xff;
   469         -  ac[3] = val & 0xff;
          473  +  put32bits(ac, val);
   470    474   }
   471    475   
   472    476   /*
   473    477   ** Read a 32-bit integer at offset 'offset' from the page identified by
   474    478   ** page header 'p'.
   475    479   */
   476    480   static u32 retrieve32bits(PgHdr *p, int offset){
................................................................................
   652    656   ** - 4 bytes: Random number used for page hash.
   653    657   ** - 4 bytes: Initial database page count.
   654    658   ** - 4 bytes: Sector size used by the process that wrote this journal.
   655    659   ** 
   656    660   ** Followed by (JOURNAL_HDR_SZ - 24) bytes of unused space.
   657    661   */
   658    662   static int writeJournalHdr(Pager *pPager){
          663  +  char zHeader[sizeof(aJournalMagic)+16];
   659    664   
   660    665     int rc = seekJournalHdr(pPager);
   661    666     if( rc ) return rc;
   662    667   
   663    668     pPager->journalHdr = pPager->journalOff;
   664    669     if( pPager->stmtHdrOff==0 ){
   665    670       pPager->stmtHdrOff = pPager->journalHdr;
................................................................................
   670    675     **
   671    676     ** Possibly for a pager not in no-sync mode, the journal magic should not
   672    677     ** be written until nRec is filled in as part of next syncJournal(). 
   673    678     **
   674    679     ** Actually maybe the whole journal header should be delayed until that
   675    680     ** point. Think about this.
   676    681     */
   677         -  rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, sizeof(aJournalMagic));
   678         -
   679         -  if( rc==SQLITE_OK ){
   680         -    /* The nRec Field. 0xFFFFFFFF for no-sync journals. */
   681         -    rc = write32bits(pPager->jfd, pPager->noSync ? 0xffffffff : 0);
   682         -  }
   683         -  if( rc==SQLITE_OK ){
   684         -    /* The random check-hash initialiser */ 
   685         -    sqlite3Randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
   686         -    rc = write32bits(pPager->jfd, pPager->cksumInit);
   687         -  }
   688         -  if( rc==SQLITE_OK ){
   689         -    /* The initial database size */
   690         -    rc = write32bits(pPager->jfd, pPager->dbSize);
   691         -  }
   692         -  if( rc==SQLITE_OK ){
   693         -    /* The assumed sector size for this process */
   694         -    rc = write32bits(pPager->jfd, pPager->sectorSize);
   695         -  }
          682  +  memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
          683  +  /* The nRec Field. 0xFFFFFFFF for no-sync journals. */
          684  +  put32bits(&zHeader[sizeof(aJournalMagic)], pPager->noSync ? 0xffffffff : 0);
          685  +  /* The random check-hash initialiser */ 
          686  +  sqlite3Randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
          687  +  put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
          688  +  /* The initial database size */
          689  +  put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbSize);
          690  +  /* The assumed sector size for this process */
          691  +  put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
          692  +  rc = sqlite3OsWrite(pPager->jfd, zHeader, sizeof(zHeader));
   696    693   
   697    694     /* The journal header has been written successfully. Seek the journal
   698    695     ** file descriptor to the end of the journal header sector.
   699    696     */
   700    697     if( rc==SQLITE_OK ){
   701    698       rc = sqlite3OsSeek(pPager->jfd, pPager->journalOff-1);
   702    699       if( rc==SQLITE_OK ){
................................................................................
   788    785   ** If zMaster is a NULL pointer (occurs for a single database transaction), 
   789    786   ** this call is a no-op.
   790    787   */
   791    788   static int writeMasterJournal(Pager *pPager, const char *zMaster){
   792    789     int rc;
   793    790     int len; 
   794    791     int i; 
   795         -  u32 cksum = 0; 
          792  +  u32 cksum = 0;
          793  +  char zBuf[sizeof(aJournalMagic)+2*4];
   796    794   
   797    795     if( !zMaster || pPager->setMaster) return SQLITE_OK;
   798    796     pPager->setMaster = 1;
   799    797   
   800    798     len = strlen(zMaster);
   801    799     for(i=0; i<len; i++){
   802    800       cksum += zMaster[i];
................................................................................
   814    812   
   815    813     rc = write32bits(pPager->jfd, PAGER_MJ_PGNO(pPager));
   816    814     if( rc!=SQLITE_OK ) return rc;
   817    815   
   818    816     rc = sqlite3OsWrite(pPager->jfd, zMaster, len);
   819    817     if( rc!=SQLITE_OK ) return rc;
   820    818   
   821         -  rc = write32bits(pPager->jfd, len);
   822         -  if( rc!=SQLITE_OK ) return rc;
   823         -
   824         -  rc = write32bits(pPager->jfd, cksum);
   825         -  if( rc!=SQLITE_OK ) return rc;
   826         -
   827         -  rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, sizeof(aJournalMagic));
          819  +  put32bits(zBuf, len);
          820  +  put32bits(&zBuf[4], cksum);
          821  +  memcpy(&zBuf[8], aJournalMagic, sizeof(aJournalMagic));
          822  +  rc = sqlite3OsWrite(pPager->jfd, zBuf, 8+sizeof(aJournalMagic));
   828    823     pPager->needSync = !pPager->noSync;
   829    824     return rc;
   830    825   }
   831    826   
   832    827   /*
   833    828   ** Add or remove a page from the list of all pages that are in the
   834    829   ** statement journal.

Changes to SQLite.Interop/src/pager.h.

     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This header file defines the interface that the sqlite page cache
    13     13   ** subsystem.  The page cache subsystem reads and writes a file a page
    14     14   ** at a time and provides a journal for rollback.
    15     15   **
    16         -** @(#) $Id: pager.h,v 1.13 2006/01/10 21:10:18 rmsimpson Exp $
           16  +** @(#) $Id: pager.h,v 1.14 2006/01/11 03:22:29 rmsimpson Exp $
    17     17   */
    18     18   
    19     19   #ifndef _PAGER_H_
    20     20   #define _PAGER_H_
    21     21   
    22     22   /*
    23     23   ** The default size of a database page.

Changes to SQLite.Interop/src/parse.c.

   171    171   **  yy_shift_ofst[]    For each state, the offset into yy_action for
   172    172   **                     shifting terminals.
   173    173   **  yy_reduce_ofst[]   For each state, the offset into yy_action for
   174    174   **                     shifting non-terminals after a reduce.
   175    175   **  yy_default[]       Default action for each state.
   176    176   */
   177    177   static const YYACTIONTYPE yy_action[] = {
   178         - /*     0 */   281,   67,  344,   80,  150,  157,  225,  517,   92,   92,
   179         - /*    10 */    92,   92,  288,   59,   59,   59,   59,   58,   58,   57,
   180         - /*    20 */    57,   57,   65,  346,  478,   48,  544,   86,   59,   59,
   181         - /*    30 */    59,   59,   58,   58,   57,   57,   57,   65,   67,  481,
   182         - /*    40 */    80,  150,  231,   64,   88,  295,  525,  518,  530,  530,
   183         - /*    50 */    72,   72,   92,   92,   92,   92,  219,   59,   59,   59,
   184         - /*    60 */    59,   58,   58,   57,   57,   57,   65,  281,  252,  189,
   185         - /*    70 */   517,  296,  344,   81,   59,   59,   59,   59,   58,   58,
   186         - /*    80 */    57,   57,   57,   65,  166,  115,  246,  303,  264,  323,
   187         - /*    90 */   196,  236,  158,  544,  478,   49,  387,   69,  228,  857,
   188         - /*   100 */   128,  560,  247,   56,    2,  381,   22,  476,  456,  363,
   189         - /*   110 */    64,   88,  295,  525,  518,  530,  530,   72,   72,   92,
   190         - /*   120 */    92,   92,   92,  283,   59,   59,   59,   59,   58,   58,
   191         - /*   130 */    57,   57,   57,   65,  281,  344,  279,  386,  395,  553,
   192         - /*   140 */   388,  165,  386,  276,  361,  288,  223,  439,  520,  451,
   193         - /*   150 */   344,   58,   58,   57,   57,   57,   65,  478,   38,  365,
   194         - /*   160 */   544,  145,  143,  282,   67,  393,   80,  150,  451,  500,
   195         - /*   170 */   393,  189,  478,   36,  500,  424,  425,   64,   88,  295,
   196         - /*   180 */   525,  518,  530,  530,   72,   72,   92,   92,   92,   92,
   197         - /*   190 */    71,   59,   59,   59,   59,   58,   58,   57,   57,   57,
   198         - /*   200 */    65,  281,  508,  508,  508,  429,  146,  508,  508,  508,
   199         - /*   210 */   294,  512,  507,  198,  344,  520,  350,  357,  362,  246,
   200         - /*   220 */   303,  264,  323,  196,  236,  283,  221,  544,  367,  310,
   201         - /*   230 */   228,  228,   57,   57,   57,   65,  478,   48,  308,  299,
   202         - /*   240 */   534,  537,  306,  417,   64,   88,  295,  525,  518,  530,
   203         - /*   250 */   530,   72,   72,   92,   92,   92,   92,  551,   59,   59,
   204         - /*   260 */    59,   59,   58,   58,   57,   57,   57,   65,  281,  550,
   205         - /*   270 */   202,  416,  198,  375,  520,  350,  357,  362,  512,  507,
   206         - /*   280 */   413,  414,  344,  293,  344,  372,   21,  367,  198,  522,
   207         - /*   290 */   517,  350,  357,  362,  544,  359,  539,  371,  374,  126,
   208         - /*   300 */   403,  209,  200,  367,  478,   18,  478,   43,  194,  169,
   209         - /*   310 */   384,   64,   88,  295,  525,  518,  530,  530,   72,   72,
   210         - /*   320 */    92,   92,   92,   92,  232,   59,   59,   59,   59,   58,
   211         - /*   330 */    58,   57,   57,   57,   65,  511,  344,  512,  507,  427,
   212         - /*   340 */   281,  420,  479,  479,  148,  419,  331,  233,  344,   67,
   213         - /*   350 */   344,   80,  150,  517,  344,  176,  155,  309,  478,   32,
   214         - /*   360 */   315,  436,  149,  184,  464,  195,  544,  348,   78,  533,
   215         - /*   370 */   478,   51,  478,   51,  378,  428,  478,   51,  479,  443,
   216         - /*   380 */   158,  377,   85,   64,   88,  295,  525,  518,  530,  530,
   217         - /*   390 */    72,   72,   92,   92,   92,   92,  479,   59,   59,   59,
   218         - /*   400 */    59,   58,   58,   57,   57,   57,   65,  281,  387,  467,
   219         - /*   410 */   504,  162,   77,  324,  344,  290,  521,  457,   22,  300,
   220         - /*   420 */   353,  520,  513,  513,  432,  487,   14,  487,  329,  271,
   221         - /*   430 */   257,  487,  426,  544,  523,  524,  478,   51,  217,  208,
   222         - /*   440 */   206,  144,  380,  355,  534,  537,  353,   55,  513,  513,
   223         - /*   450 */    64,   88,  295,  525,  518,  530,  530,   72,   72,   92,
   224         - /*   460 */    92,   92,   92,  375,   59,   59,   59,   59,   58,   58,
   225         - /*   470 */    57,   57,   57,   65,  281,  372,   11,  127,   71,  218,
   226         - /*   480 */   520,  241,  182,  126,  512,  507,  164,  155,  374,  520,
   227         - /*   490 */   338,  488,  452,  398,  543,  353,  200,  513,  513,    1,
   228         - /*   500 */   544,  401,  353,  520,  513,  513,  200,  553,  366,  165,
   229         - /*   510 */   157,  463,  517,  358,  540,  538,  479,   64,   88,  295,
   230         - /*   520 */   525,  518,  530,  530,   72,   72,   92,   92,   92,   92,
   231         - /*   530 */   468,   59,   59,   59,   59,   58,   58,   57,   57,   57,
   232         - /*   540 */    65,  370,  541,  512,  507,  437,  281,  344,  172,  506,
   233         - /*   550 */   239,  344,  512,  507,  344,  387,  224,  448,   93,  344,
   234         - /*   560 */    89,  344,  313,  344,  555,   22,  512,  507,  182,  478,
   235         - /*   570 */    27,  520,  544,  478,   43,  517,  478,   50,  561,  547,
   236         - /*   580 */   369,  478,   47,  478,  114,  478,   95,  528,   91,   64,
   237         - /*   590 */    88,  295,  525,  518,  530,  530,   72,   72,   92,   92,
   238         - /*   600 */    92,   92,  479,   59,   59,   59,   59,   58,   58,   57,
   239         - /*   610 */    57,   57,   65,  281,  226,  344,  251,  174,  110,  344,
   240         - /*   620 */   141,  147,  344,  465,  344,  449,  325,  370,  270,  344,
   241         - /*   630 */   421,  344,  450,  554,  512,  507,    2,  478,   52,  544,
   242         - /*   640 */   595,  478,   44,  311,  478,   30,  478,   45,  313,  173,
   243         - /*   650 */   418,  478,   53,  478,   25,  479,   64,   88,  295,  525,
   244         - /*   660 */   518,  530,  530,   72,   72,   92,   92,   92,   92,  344,
   245         - /*   670 */    59,   59,   59,   59,   58,   58,   57,   57,   57,   65,
   246         - /*   680 */   281,  344,  404,  479,  433,  344,  470,  344,  152,  344,
   247         - /*   690 */   469,  478,  112,  344,  415,  314,  415,  344,  411,  344,
   248         - /*   700 */   126,  287,  161,  478,   94,  440,  544,  478,  113,  478,
   249         - /*   710 */    12,  478,   99,  401,  465,  478,   41,  292,  456,  478,
   250         - /*   720 */   100,  478,   46,   64,   88,  295,  525,  518,  530,  530,
   251         - /*   730 */    72,   72,   92,   92,   92,   92,  344,   59,   59,   59,
   252         - /*   740 */    59,   58,   58,   57,   57,   57,   65,  281,  344,  485,
   253         - /*   750 */    19,  404,  344,  514,  344,   79,  307,  260,  478,  111,
   254         - /*   760 */   344,  242,  344,  548,  548,  344,  503,  501,  497,  466,
   255         - /*   770 */   478,   42,  404,  544,  478,   26,  478,   39,  478,    3,
   256         - /*   780 */   304,  423,  478,   31,  478,   40,  291,  478,   37,  305,
   257         - /*   790 */    64,   88,  295,  525,  518,  530,  530,   72,   72,   92,
   258         - /*   800 */    92,   92,   92,  344,   59,   59,   59,   59,   58,   58,
   259         - /*   810 */    57,   57,   57,   65,  281,  344,  470,  404,  126,  344,
   260         - /*   820 */   469,  344,   20,  344,  139,  478,   97,  344,  320,    7,
   261         - /*   830 */   242,  344,  190,  181,  180,  208,  451,  478,   28,  258,
   262         - /*   840 */   544,  478,   54,  478,   35,  478,   33,  222,  327,  478,
   263         - /*   850 */    34,  262,  204,  478,   29,  435,  191,   64,   76,  295,
   264         - /*   860 */   525,  518,  530,  530,   72,   72,   92,   92,   92,   92,
   265         - /*   870 */   404,   59,   59,   59,   59,   58,   58,   57,   57,   57,
   266         - /*   880 */    65,  281,  404,  454,  177,  162,  344,  208,  344,  175,
   267         - /*   890 */   479,  320,  447,  235,  211,  794,  242,  286,  456,  516,
   268         - /*   900 */   352,  441,  409,  410,  409,  298,  385,  544,  478,   24,
   269         - /*   910 */   478,   98,  252,  252,  252,  252,  275,  284,  479,  252,
   270         - /*   920 */   334,  252,  252,  479,  281,   88,  295,  525,  518,  530,
   271         - /*   930 */   530,   72,   72,   92,   92,   92,   92,  274,   59,   59,
   272         - /*   940 */    59,   59,   58,   58,   57,   57,   57,   65,  517,  242,
   273         - /*   950 */   544,  244,  252,  237,  340,  215,  494,  214,  390,  546,
   274         - /*   960 */   492,  242,  256,  489,  475,  406,   79,  397,  273,  295,
   275         - /*   970 */   525,  518,  530,  530,   72,   72,   92,   92,   92,   92,
   276         - /*   980 */   116,   59,   59,   59,   59,   58,   58,   57,   57,   57,
   277         - /*   990 */    65,   62,  345,  484,    4,  407,  412,  269,  289,  126,
   278         - /*  1000 */   519,  259,   23,  550,  202,  552,  349,   62,  345,  549,
   279         - /*  1010 */     4,  517,  354,  493,  289,   14,  547,  369,  402,  316,
   280         - /*  1020 */   240,  453,  349,  339,  472,  356,  142,  266,  471,  477,
   281         - /*  1030 */   249,  319,  505,  386,  459,  343,  529,  428,  255,  339,
   282         - /*  1040 */    71,  458,  499,  118,  333,  130,  121,  192,  389,  386,
   283         - /*  1050 */   123,  156,   60,   61,  483,  103,   87,  125,  212,  480,
   284         - /*  1060 */    62,  328,  330,  178,  277,  500,  229,  210,   60,   61,
   285         - /*  1070 */   438,  297,  399,  491,  476,  473,   62,  328,  330,   62,
   286         - /*  1080 */   345,  500,    4,  474,  208,  302,  289,  342,  207,  186,
   287         - /*  1090 */   498,   68,  278,  120,  349,  136,  400,  556,  508,  508,
   288         - /*  1100 */   508,  509,  510,   17,  312,  106,  243,  326,  205,  245,
   289         - /*  1110 */   373,  339,  434,  285,  508,  508,  508,  509,  510,   17,
   290         - /*  1120 */    74,  386,  160,  431,  248,    8,  321,  227,  220,  230,
   291         - /*  1130 */   102,  332,  137,  382,  383,  536,  405,  234,   75,  183,
   292         - /*  1140 */    60,   61,  317,  170,  265,  254,  135,  336,   62,  328,
   293         - /*  1150 */   330,  442,  267,  500,  263,   66,  318,  261,  201,  455,
   294         - /*  1160 */   447,   73,  461,  408,  168,  531,  443,   83,  482,  446,
   295         - /*  1170 */   376,  171,  396,  167,  444,  542,  545,  208,  238,  272,
   296         - /*  1180 */   213,  163,  188,  101,  364,   96,  508,  508,  508,  509,
   297         - /*  1190 */   510,   17,  490,   63,  270,  322,  153,  105,  335,  535,
   298         - /*  1200 */   526,  108,  558,  394,  527,  532,  250,  515,  379,  391,
   299         - /*  1210 */    13,  368,  557,  107,  351,  337,  216,  257,   82,  132,
   300         - /*  1220 */   559,  280,  109,  179,  347,  140,  208,  159,   65,  185,
   301         - /*  1230 */   502,  341,  268,  193,  392,  131,  129,  203,  496,  151,
   302         - /*  1240 */    10,  104,  154,  430,  486,  138,  253,  199,  495,  422,
   303         - /*  1250 */   360,  162,  445,    5,   15,  597,    9,  187,  117,  122,
   304         - /*  1260 */   596,  119,  133,   16,    6,  124,  301,  134,   14,   90,
   305         - /*  1270 */    70,  462,   84,  460,  197,
          178  + /*     0 */   280,   68,  284,   70,  148,  166,  547,  420,   62,   62,
          179  + /*    10 */    62,   62,  202,   64,   64,   64,   64,   65,   65,   66,
          180  + /*    20 */    66,   66,   67,   67,  549,  550,  433,   69,   64,   64,
          181  + /*    30 */    64,   64,   65,   65,   66,   66,   66,   67,   68,  455,
          182  + /*    40 */    70,  148,  500,   61,   59,  288,  441,  442,  438,  438,
          183  + /*    50 */    63,   63,   62,   62,   62,   62,  502,   64,   64,   64,
          184  + /*    60 */    64,   65,   65,   66,   66,   66,   67,  280,  372,  284,
          185  + /*    70 */   420,    2,  378,   80,  158,  115,  220,  305,  225,  306,
          186  + /*    80 */   170,  245,  857,  119,  560,  505,  204,    2,  246,  390,
          187  + /*    90 */   497,  219,   22,  433,  515,   21,  420,   58,  494,  171,
          188  + /*   100 */    64,   64,   64,   64,   65,   65,   66,   66,   66,   67,
          189  + /*   110 */    61,   59,  288,  441,  442,  438,  438,   63,   63,   62,
          190  + /*   120 */    62,   62,   62,  513,   64,   64,   64,   64,   65,   65,
          191  + /*   130 */    66,   66,   66,   67,  280,  379,  380,  175,  202,  378,
          192  + /*   140 */   331,  334,  335,  220,  305,  225,  306,  170,  245,  203,
          193  + /*   150 */   146,  358,  336,  282,  378,  246,   55,  302,  374,  420,
          194  + /*   160 */   433,  506,   92,  200,  531,   66,   66,   66,   67,  526,
          195  + /*   170 */   192,   65,   65,   66,   66,   66,   67,   61,   59,  288,
          196  + /*   180 */   441,  442,  438,  438,   63,   63,   62,   62,   62,   62,
          197  + /*   190 */   434,   64,   64,   64,   64,   65,   65,   66,   66,   66,
          198  + /*   200 */    67,  280,  379,  380,  412,  432,  110,  226,  428,  205,
          199  + /*   210 */   436,  437,  309,  359,  262,  261,  175,  379,  380,  331,
          200  + /*   220 */   334,  335,  373,  370,  202,  512,  481,  433,  548,  363,
          201  + /*   230 */   467,  336,  511,  501,  411,   41,  277,  415,  435,  430,
          202  + /*   240 */   504,  162,  233,  528,   61,   59,  288,  441,  442,  438,
          203  + /*   250 */   438,   63,   63,   62,   62,   62,   62,  320,   64,   64,
          204  + /*   260 */    64,   64,   65,   65,   66,   66,   66,   67,  280,  473,
          205  + /*   270 */   417,  417,  417,  309,  323,  236,  309,   68,  309,   70,
          206  + /*   280 */   148,    1,  309,  794,  309,  378,   68,  153,   70,  148,
          207  + /*   290 */   149,  378,  326,  283,  433,  411,   35,  552,  411,   35,
          208  + /*   300 */   411,   36,  428,  205,  411,   35,  411,   35,  287,  423,
          209  + /*   310 */   424,   61,   59,  288,  441,  442,  438,  438,   63,   63,
          210  + /*   320 */    62,   62,   62,   62,  412,   64,   64,   64,   64,   65,
          211  + /*   330 */    65,   66,   66,   66,   67,  309,  505,  467,  291,  255,
          212  + /*   340 */   280,  325,  486,  147,  237,  389,   21,  289,  379,  380,
          213  + /*   350 */   452,  420,  232,  452,  379,  380,  309,  411,   28,  452,
          214  + /*   360 */   175,  451,  487,  331,  334,  335,  433,  215,  348,  145,
          215  + /*   370 */   514,  204,  351,  186,  168,  336,  238,  412,  411,   41,
          216  + /*   380 */   256,  463,   76,   61,   59,  288,  441,  442,  438,  438,
          217  + /*   390 */    63,   63,   62,   62,   62,   62,  310,   64,   64,   64,
          218  + /*   400 */    64,   65,   65,   66,   66,   66,   67,  412,  412,  186,
          219  + /*   410 */   397,  309,  280,  292,  420,  339,  477,  309,  391,  234,
          220  + /*   420 */   169,  154,  398,  476,  397,  328,  494,  312,  423,  424,
          221  + /*   430 */   445,  378,  357,  411,   49,  399,  398,  395,  433,  411,
          222  + /*   440 */    49,  503,  171,  412,  430,  313,  162,  396,  352,  399,
          223  + /*   450 */   498,  319,  471,  353,   79,   61,   59,  288,  441,  442,
          224  + /*   460 */   438,  438,   63,   63,   62,   62,   62,   62,  357,   64,
          225  + /*   470 */    64,   64,   64,   65,   65,   66,   66,   66,   67,  280,
          226  + /*   480 */   299,  446,  377,  480,  533,  406,  300,   11,  505,  353,
          227  + /*   490 */   204,  378,  407,  378,  379,  380,  282,  557,   21,  492,
          228  + /*   500 */   492,  246,  561,  373,  370,  433,  393,  394,  315,  123,
          229  + /*   510 */   444,  444,  166,  290,  420,  315,  116,  444,  444,  251,
          230  + /*   520 */   265,  464,   61,   59,  288,  441,  442,  438,  438,   63,
          231  + /*   530 */    63,   62,   62,   62,   62,  293,   64,   64,   64,   64,
          232  + /*   540 */    65,   65,   66,   66,   66,   67,  280,  460,  329,  475,
          233  + /*   550 */   499,  309,  202,  309,  379,  380,  379,  380,  181,  131,
          234  + /*   560 */   179,  266,  309,    5,  309,  364,  315,  356,  444,  444,
          235  + /*   570 */   411,    3,  433,  411,   29,  411,   24,  420,  243,  244,
          236  + /*   580 */   381,  382,  383,  405,  411,   33,  411,   54,  467,   61,
          237  + /*   590 */    59,  288,  441,  442,  438,  438,   63,   63,   62,   62,
          238  + /*   600 */    62,   62,  309,   64,   64,   64,   64,   65,   65,   66,
          239  + /*   610 */    66,   66,   67,  280,  522,  345,  522,  249,  309,  492,
          240  + /*   620 */   309,  471,  309,  471,  411,   25,  309,  240,  309,  315,
          241  + /*   630 */   309,  444,  444,  213,  172,  173,  174,  142,  267,  433,
          242  + /*   640 */   411,   52,  411,   97,  411,   94,  529,  394,  411,   99,
          243  + /*   650 */   411,  100,  411,  111,  212,  255,   61,   59,  288,  441,
          244  + /*   660 */   442,  438,  438,   63,   63,   62,   62,   62,   62,  309,
          245  + /*   670 */    64,   64,   64,   64,   65,   65,   66,   66,   66,   67,
          246  + /*   680 */   280,  309,  346,  188,  298,   91,  309,  492,  309,  416,
          247  + /*   690 */   309,  411,  112,  309,  429,  309,  538,  309,  244,  165,
          248  + /*   700 */   154,  410,  356,  411,   18,  409,  433,  321,  411,   98,
          249  + /*   710 */   411,   34,  411,   95,  314,  411,   53,  411,  113,  411,
          250  + /*   720 */   114,  255,  294,   61,   59,  288,  441,  442,  438,  438,
          251  + /*   730 */    63,   63,   62,   62,   62,   62,  309,   64,   64,   64,
          252  + /*   740 */    64,   65,   65,   66,   66,   66,   67,  280,  309,  492,
          253  + /*   750 */   492,  524,  309,  453,  309,  523,  309,  462,  411,   26,
          254  + /*   760 */   309,   75,  540,   77,  309,  461,  244,  347,  214,  466,
          255  + /*   770 */   411,   37,  470,  433,  411,   38,  411,   27,  411,   39,
          256  + /*   780 */   242,   82,  411,   40,  295,  297,  411,   42,  439,  330,
          257  + /*   790 */    61,   59,  288,  441,  442,  438,  438,   63,   63,   62,
          258  + /*   800 */    62,   62,   62,  309,   64,   64,   64,   64,   65,   65,
          259  + /*   810 */    66,   66,   66,   67,  280,  309,  410,  190,  221,  309,
          260  + /*   820 */   409,  309,  152,  309,  159,  411,   43,  309,  244,  244,
          261  + /*   830 */   222,   20,  309,  139,  426,  426,  482,  411,   44,  483,
          262  + /*   840 */   433,  411,   30,  411,   31,  411,   45,  488,  462,  411,
          263  + /*   850 */    46,  412,  507,  255,  411,   47,  489,   61,   71,  288,
          264  + /*   860 */   441,  442,  438,  438,   63,   63,   62,   62,   62,   62,
          265  + /*   870 */   309,   64,   64,   64,   64,   65,   65,   66,   66,   66,
          266  + /*   880 */    67,  280,  309,  402,  403,  250,  309,  193,  309,  421,
          267  + /*   890 */   309,   23,  411,   48,  541,  450,  255,   14,  469,  478,
          268  + /*   900 */   167,   14,  485,  484,  411,   32,  252,  433,  411,   12,
          269  + /*   910 */   411,   50,  411,   51,  255,  255,  595,  255,  255,  150,
          270  + /*   920 */   490,  412,  123,  253,  280,   59,  288,  441,  442,  438,
          271  + /*   930 */   438,   63,   63,   62,   62,   62,   62,  542,   64,   64,
          272  + /*   940 */    64,   64,   65,   65,   66,   66,   66,   67,  254,  248,
          273  + /*   950 */   433,  123,  338,  412,  123,  268,  270,  196,  362,  367,
          274  + /*   960 */   183,  177,  180,  520,  521,  260,  535,  123,  167,  288,
          275  + /*   970 */   441,  442,  438,  438,   63,   63,   62,   62,   62,   62,
          276  + /*   980 */   343,   64,   64,   64,   64,   65,   65,   66,   66,   66,
          277  + /*   990 */    67,   72,  316,  259,    4,  412,  412,  536,  286,   89,
          278  + /*  1000 */   545,  350,   89,  354,  355,   19,  311,   72,  316,  369,
          279  + /*  1010 */     4,  387,  263,  264,  286,  223,  546,  271,  365,  274,
          280  + /*  1020 */   275,  141,  311,  318,  227,  317,  556,  425,  427,  481,
          281  + /*  1030 */   456,  459,  491,  432,  333,  493,  534,  157,  544,  318,
          282  + /*  1040 */   376,  384,  385,  386,    8,  303,  304,  392,  285,  432,
          283  + /*  1050 */   405,  400,   74,   73,  224,  404,  408,   82,  324,  322,
          284  + /*  1060 */    72,  307,  308,  401,  231,  415,   81,  206,   74,   73,
          285  + /*  1070 */   474,   57,   78,  164,  454,  413,   72,  307,  308,   72,
          286  + /*  1080 */   316,  415,    4,  228,  202,  229,  286,  235,  230,  457,
          287  + /*  1090 */   458,  414,  207,  120,  311,   83,  327,  102,  417,  417,
          288  + /*  1100 */   417,  418,  419,   13,  239,  496,  468,  241,  278,  208,
          289  + /*  1110 */   472,  318,  495,  210,  417,  417,  417,  418,  419,   13,
          290  + /*  1120 */   211,  432,  156,  279,  340,  508,  509,  216,  217,  218,
          291  + /*  1130 */   106,  510,  516,  178,  344,   84,  342,  182,  518,  457,
          292  + /*  1140 */    74,   73,   86,  198,  519,  272,  257,  184,   72,  307,
          293  + /*  1150 */   308,  349,  273,  415,  527,  530,  118,  187,  127,  537,
          294  + /*  1160 */   360,  136,  128,  543,  195,  129,  531,  301,  553,   90,
          295  + /*  1170 */   554,  194,  137,  197,  432,  130,  133,  555,  558,   96,
          296  + /*  1180 */   209,  101,  375,  388,  117,  201,  417,  417,  417,  418,
          297  + /*  1190 */   419,   13,   93,  143,  144,   56,  596,  109,  597,  160,
          298  + /*  1200 */   161,   60,  501,  422,  431,  440,  415,  443,  138,  447,
          299  + /*  1210 */   151,    6,  448,  449,    7,  361,  269,  261,  163,   15,
          300  + /*  1220 */   465,  281,   14,  121,  155,  122,  202,  479,  103,  332,
          301  + /*  1230 */   247,  104,   85,  105,  337,  222,  176,  341,  140,  417,
          302  + /*  1240 */   417,  417,  517,  124,  296,  167,  125,  525,  185,  107,
          303  + /*  1250 */   366,  258,    9,  532,   10,  126,   16,  189,  539,  191,
          304  + /*  1260 */   132,   87,   88,  134,  135,   17,  108,  276,  551,  371,
          305  + /*  1270 */   536,  199,  368,  559,
   306    306   };
   307    307   static const YYCODETYPE yy_lookahead[] = {
   308         - /*     0 */    16,  216,  146,  218,  219,   21,  146,   23,   68,   69,
   309         - /*    10 */    70,   71,   16,   73,   74,   75,   76,   77,   78,   79,
   310         - /*    20 */    80,   81,   82,  146,  168,  169,   42,   72,   73,   74,
          308  + /*     0 */    16,  216,   16,  218,  219,   21,  146,   23,   68,   69,
          309  + /*    10 */    70,   71,  109,   73,   74,   75,   76,   77,   78,   79,
          310  + /*    20 */    80,   81,   82,   82,  164,  165,   42,   72,   73,   74,
   311    311    /*    30 */    75,   76,   77,   78,   79,   80,   81,   82,  216,  217,
   312         - /*    40 */   218,  219,  146,   59,   60,   61,   62,   63,   64,   65,
   313         - /*    50 */    66,   67,   68,   69,   70,   71,  146,   73,   74,   75,
   314         - /*    60 */    76,   77,   78,   79,   80,   81,   82,   16,  146,   43,
   315         - /*    70 */    86,  215,  146,   22,   73,   74,   75,   76,   77,   78,
   316         - /*    80 */    79,   80,   81,   82,   88,   89,   90,   91,   92,   93,
   317         - /*    90 */    94,   95,   22,   42,  168,  169,  146,   46,  102,  138,
   318         - /*   100 */   139,  140,  152,   19,  143,  155,  156,   23,  160,  187,
          312  + /*    40 */   218,  219,  168,   59,   60,   61,   62,   63,   64,   65,
          313  + /*    50 */    66,   67,   68,   69,   70,   71,  168,   73,   74,   75,
          314  + /*    60 */    76,   77,   78,   79,   80,   81,   82,   16,  140,   16,
          315  + /*    70 */    86,  143,   23,   22,   88,   89,   90,   91,   92,   93,
          316  + /*    80 */    94,   95,  138,  139,  140,  146,  226,  143,  102,  166,
          317  + /*    90 */   167,  152,   19,   42,  155,  156,   23,   46,  175,   43,
          318  + /*   100 */    73,   74,   75,   76,   77,   78,   79,   80,   81,   82,
   319    319    /*   110 */    59,   60,   61,   62,   63,   64,   65,   66,   67,   68,
   320         - /*   120 */    69,   70,   71,   97,   73,   74,   75,   76,   77,   78,
   321         - /*   130 */    79,   80,   81,   82,   16,  146,  157,   58,   20,  160,
   322         - /*   140 */   161,  162,   58,  189,   16,   16,  220,  199,   23,  146,
   323         - /*   150 */   146,   77,   78,   79,   80,   81,   82,  168,  169,  237,
   324         - /*   160 */    42,   77,   78,  149,  216,   86,  218,  219,  146,   90,
   325         - /*   170 */    86,   43,  168,  169,   90,   89,   90,   59,   60,   61,
          320  + /*   120 */    69,   70,   71,  180,   73,   74,   75,   76,   77,   78,
          321  + /*   130 */    79,   80,   81,   82,   16,   86,   87,   88,  109,   23,
          322  + /*   140 */    91,   92,   93,   90,   91,   92,   93,   94,   95,  191,
          323  + /*   150 */    22,  122,  103,   97,   23,  102,  198,  141,  142,   86,
          324  + /*   160 */    42,  180,   44,  147,   49,   79,   80,   81,   82,   18,
          325  + /*   170 */   154,   77,   78,   79,   80,   81,   82,   59,   60,   61,
   326    326    /*   180 */    62,   63,   64,   65,   66,   67,   68,   69,   70,   71,
   327         - /*   190 */   120,   73,   74,   75,   76,   77,   78,   79,   80,   81,
   328         - /*   200 */    82,   16,  123,  124,  125,   20,   22,  123,  124,  125,
   329         - /*   210 */   207,   86,   87,   88,  146,   23,   91,   92,   93,   90,
   330         - /*   220 */    91,   92,   93,   94,   95,   97,  146,   42,  103,  207,
   331         - /*   230 */   102,  102,   79,   80,   81,   82,  168,  169,  224,  163,
   332         - /*   240 */   164,  165,  228,  177,   59,   60,   61,   62,   63,   64,
   333         - /*   250 */    65,   66,   67,   68,   69,   70,   71,  146,   73,   74,
   334         - /*   260 */    75,   76,   77,   78,   79,   80,   81,   82,   16,   77,
   335         - /*   270 */    78,  177,   88,   12,   23,   91,   92,   93,   86,   87,
   336         - /*   280 */    51,   52,  146,  215,  146,   24,   19,  103,   88,   97,
   337         - /*   290 */    23,   91,   92,   93,   42,  141,  142,   20,   37,   22,
   338         - /*   300 */    39,  147,  226,  103,  168,  169,  168,  169,  154,  154,
   339         - /*   310 */    49,   59,   60,   61,   62,   63,   64,   65,   66,   67,
   340         - /*   320 */    68,   69,   70,   71,   14,   73,   74,   75,   76,   77,
   341         - /*   330 */    78,   79,   80,   81,   82,   20,  146,   86,   87,  146,
   342         - /*   340 */    16,   25,  188,  188,  154,   29,  208,  209,  146,  216,
   343         - /*   350 */   146,  218,  219,   86,  146,  200,  201,   41,  168,  169,
   344         - /*   360 */   205,   20,  154,   53,  113,   55,   42,  213,   44,  236,
   345         - /*   370 */   168,  169,  168,  169,  175,  176,  168,  169,  188,   49,
   346         - /*   380 */    22,  182,  130,   59,   60,   61,   62,   63,   64,   65,
   347         - /*   390 */    66,   67,   68,   69,   70,   71,  188,   73,   74,   75,
   348         - /*   400 */    76,   77,   78,   79,   80,   81,   82,   16,  146,   20,
   349         - /*   410 */    20,   22,   21,  211,  146,  211,  146,  155,  156,  211,
   350         - /*   420 */   105,   23,  107,  108,   20,  223,   22,  223,   98,   99,
   351         - /*   430 */   100,  223,  177,   42,  164,  165,  168,  169,   14,  109,
   352         - /*   440 */   191,  179,  180,  163,  164,  165,  105,  198,  107,  108,
   353         - /*   450 */    59,   60,   61,   62,   63,   64,   65,   66,   67,   68,
   354         - /*   460 */    69,   70,   71,   12,   73,   74,   75,   76,   77,   78,
   355         - /*   470 */    79,   80,   81,   82,   16,   24,   19,   53,  120,   55,
   356         - /*   480 */    23,   20,  154,   22,   86,   87,  200,  201,   37,   23,
   357         - /*   490 */    39,  223,  166,  167,   42,  105,  226,  107,  108,   19,
   358         - /*   500 */    42,  175,  105,   23,  107,  108,  226,  160,  161,  162,
   359         - /*   510 */    21,  113,   23,   16,   62,   63,  188,   59,   60,   61,
   360         - /*   520 */    62,   63,   64,   65,   66,   67,   68,   69,   70,   71,
   361         - /*   530 */    22,   73,   74,   75,   76,   77,   78,   79,   80,   81,
   362         - /*   540 */    82,  213,   90,   86,   87,   79,   16,  146,   19,  146,
   363         - /*   550 */    20,  146,   86,   87,  146,  146,  132,  229,  129,  146,
   364         - /*   560 */   131,  146,  234,  146,  155,  156,   86,   87,  154,  168,
   365         - /*   570 */   169,   23,   42,  168,  169,   86,  168,  169,    0,    1,
   366         - /*   580 */     2,  168,  169,  168,  169,  168,  169,   90,  130,   59,
          327  + /*   190 */    42,   73,   74,   75,   76,   77,   78,   79,   80,   81,
          328  + /*   200 */    82,   16,   86,   87,  188,   58,   21,  189,   77,   78,
          329  + /*   210 */    62,   63,  146,   98,   99,  100,   88,   86,   87,   91,
          330  + /*   220 */    92,   93,    1,    2,  109,  175,  176,   42,   97,  213,
          331  + /*   230 */   160,  103,  182,   86,  168,  169,  157,   90,   90,  160,
          332  + /*   240 */   161,  162,  146,   92,   59,   60,   61,   62,   63,   64,
          333  + /*   250 */    65,   66,   67,   68,   69,   70,   71,  185,   73,   74,
          334  + /*   260 */    75,   76,   77,   78,   79,   80,   81,   82,   16,  199,
          335  + /*   270 */   123,  124,  125,  146,  208,  209,  146,  216,  146,  218,
          336  + /*   280 */   219,   19,  146,  132,  146,   23,  216,  146,  218,  219,
          337  + /*   290 */   154,   23,  146,  149,   42,  168,  169,  236,  168,  169,
          338  + /*   300 */   168,  169,   77,   78,  168,  169,  168,  169,  163,  164,
          339  + /*   310 */   165,   59,   60,   61,   62,   63,   64,   65,   66,   67,
          340  + /*   320 */    68,   69,   70,   71,  188,   73,   74,   75,   76,   77,
          341  + /*   330 */    78,   79,   80,   81,   82,  146,  146,  160,  211,  146,
          342  + /*   340 */    16,  211,   30,  154,  146,  155,  156,  211,   86,   87,
          343  + /*   350 */   223,   23,  220,  223,   86,   87,  146,  168,  169,  223,
          344  + /*   360 */    88,  223,   50,   91,   92,   93,   42,  144,  224,  179,
          345  + /*   370 */   180,  226,  228,  154,  154,  103,  199,  188,  168,  169,
          346  + /*   380 */   187,  113,  130,   59,   60,   61,   62,   63,   64,   65,
          347  + /*   390 */    66,   67,   68,   69,   70,   71,  146,   73,   74,   75,
          348  + /*   400 */    76,   77,   78,   79,   80,   81,   82,  188,  188,  154,
          349  + /*   410 */    12,  146,   16,  101,   86,   16,   20,  146,  167,  209,
          350  + /*   420 */   200,  201,   24,   20,   12,  205,  175,  163,  164,  165,
          351  + /*   430 */    20,   23,  213,  168,  169,   37,   24,   39,   42,  168,
          352  + /*   440 */   169,  159,   43,  188,  160,  161,  162,   49,  229,   37,
          353  + /*   450 */   168,   39,  146,  234,  130,   59,   60,   61,   62,   63,
          354  + /*   460 */    64,   65,   66,   67,   68,   69,   70,   71,  213,   73,
          355  + /*   470 */    74,   75,   76,   77,   78,   79,   80,   81,   82,   16,
          356  + /*   480 */   215,   20,  146,   20,  229,   27,  215,   19,  146,  234,
          357  + /*   490 */   226,   23,   34,   23,   86,   87,   97,  155,  156,  146,
          358  + /*   500 */   146,  102,    0,    1,    2,   42,  184,  185,  105,   22,
          359  + /*   510 */   107,  108,   21,  207,   23,  105,  146,  107,  108,   14,
          360  + /*   520 */    14,  113,   59,   60,   61,   62,   63,   64,   65,   66,
          361  + /*   530 */    67,   68,   69,   70,   71,  181,   73,   74,   75,   76,
          362  + /*   540 */    77,   78,   79,   80,   81,   82,   16,   22,  146,   79,
          363  + /*   550 */    20,  146,  109,  146,   86,   87,   86,   87,   53,   53,
          364  + /*   560 */    55,   55,  146,  190,  146,  122,  105,  146,  107,  108,
          365  + /*   570 */   168,  169,   42,  168,  169,  168,  169,   86,  225,  225,
          366  + /*   580 */     7,    8,    9,   96,  168,  169,  168,  169,  160,   59,
   367    367    /*   590 */    60,   61,   62,   63,   64,   65,   66,   67,   68,   69,
   368         - /*   600 */    70,   71,  188,   73,   74,   75,   76,   77,   78,   79,
   369         - /*   610 */    80,   81,   82,   16,  209,  146,   90,  230,   21,  146,
   370         - /*   620 */   112,  154,  146,   22,  146,   27,  231,  213,  102,  146,
   371         - /*   630 */    30,  146,   34,  140,   86,   87,  143,  168,  169,   42,
   372         - /*   640 */   111,  168,  169,  229,  168,  169,  168,  169,  234,  154,
   373         - /*   650 */    50,  168,  169,  168,  169,  188,   59,   60,   61,   62,
          368  + /*   600 */    70,   71,  146,   73,   74,   75,   76,   77,   78,   79,
          369  + /*   610 */    80,   81,   82,   16,   98,   99,  100,   20,  146,  146,
          370  + /*   620 */   146,  146,  146,  146,  168,  169,  146,  199,  146,  105,
          371  + /*   630 */   146,  107,  108,  212,   98,   99,  100,  112,  132,   42,
          372  + /*   640 */   168,  169,  168,  169,  168,  169,  184,  185,  168,  169,
          373  + /*   650 */   168,  169,  168,  169,  181,  146,   59,   60,   61,   62,
   374    374    /*   660 */    63,   64,   65,   66,   67,   68,   69,   70,   71,  146,
   375    375    /*   670 */    73,   74,   75,   76,   77,   78,   79,   80,   81,   82,
   376         - /*   680 */    16,  146,  146,  188,   20,  146,  106,  146,   87,  146,
   377         - /*   690 */   110,  168,  169,  146,   98,   99,  100,  146,   20,  146,
   378         - /*   700 */    22,  101,   19,  168,  169,  167,   42,  168,  169,  168,
   379         - /*   710 */   169,  168,  169,  175,  113,  168,  169,  181,  160,  168,
   380         - /*   720 */   169,  168,  169,   59,   60,   61,   62,   63,   64,   65,
          376  + /*   680 */    16,  146,  207,   22,  207,   21,  146,  146,  146,  146,
          377  + /*   690 */   146,  168,  169,  146,  160,  146,  187,  146,  225,  200,
          378  + /*   700 */   201,  106,  146,  168,  169,  110,   42,  146,  168,  169,
          379  + /*   710 */   168,  169,  168,  169,   16,  168,  169,  168,  169,  168,
          380  + /*   720 */   169,  146,  181,   59,   60,   61,   62,   63,   64,   65,
   381    381    /*   730 */    66,   67,   68,   69,   70,   71,  146,   73,   74,   75,
   382    382    /*   740 */    76,   77,   78,   79,   80,   81,   82,   16,  146,  146,
   383         - /*   750 */    67,  146,  146,   20,  146,   22,  146,  199,  168,  169,
   384         - /*   760 */   146,  225,  146,  123,  124,  146,    7,    8,    9,  202,
          383  + /*   750 */   146,   25,  146,  146,  146,   29,  146,   22,  168,  169,
          384  + /*   760 */   146,  129,  187,  131,  146,  202,  225,   41,  212,  146,
   385    385    /*   770 */   168,  169,  146,   42,  168,  169,  168,  169,  168,  169,
   386         - /*   780 */   146,   18,  168,  169,  168,  169,  181,  168,  169,   79,
          386  + /*   780 */   146,  120,  168,  169,  181,  181,  168,  169,   90,   79,
   387    387    /*   790 */    59,   60,   61,   62,   63,   64,   65,   66,   67,   68,
   388    388    /*   800 */    69,   70,   71,  146,   73,   74,   75,   76,   77,   78,
   389         - /*   810 */    79,   80,   81,   82,   16,  146,  106,  146,   22,  146,
   390         - /*   820 */   110,  146,   19,  146,   21,  168,  169,  146,  146,  190,
   391         - /*   830 */   225,  146,   98,   99,  100,  109,  146,  168,  169,  146,
   392         - /*   840 */    42,  168,  169,  168,  169,  168,  169,  146,  122,  168,
   393         - /*   850 */   169,  225,  181,  168,  169,   92,  154,   59,   60,   61,
          389  + /*   810 */    79,   80,   81,   82,   16,  146,  106,  154,   90,  146,
          390  + /*   820 */   110,  146,   87,  146,   19,  168,  169,  146,  225,  225,
          391  + /*   830 */   102,   19,  146,   21,  123,  124,  146,  168,  169,  177,
          392  + /*   840 */    42,  168,  169,  168,  169,  168,  169,  177,  113,  168,
          393  + /*   850 */   169,  188,  146,  146,  168,  169,  177,   59,   60,   61,
   394    394    /*   860 */    62,   63,   64,   65,   66,   67,   68,   69,   70,   71,
   395    395    /*   870 */   146,   73,   74,   75,   76,   77,   78,   79,   80,   81,
   396         - /*   880 */    82,   16,  146,   20,  154,   22,  146,  109,  146,  154,
   397         - /*   890 */   188,  146,   96,  146,  212,  132,  225,  207,  160,  146,
   398         - /*   900 */   122,  184,  185,  184,  185,  181,  146,   42,  168,  169,
   399         - /*   910 */   168,  169,  146,  146,  146,  146,  146,  181,  188,  146,
   400         - /*   920 */   146,  146,  146,  188,   16,   60,   61,   62,   63,   64,
   401         - /*   930 */    65,   66,   67,   68,   69,   70,   71,  199,   73,   74,
   402         - /*   940 */    75,   76,   77,   78,   79,   80,   81,   82,   23,  225,
   403         - /*   950 */    42,  146,  146,  187,  187,  187,  187,  212,  159,  227,
   404         - /*   960 */   187,  225,  187,  187,   20,  171,   22,  168,  146,   61,
          396  + /*   880 */    82,   16,  146,    7,    8,  146,  146,  154,  146,   20,
          397  + /*   890 */   146,   22,  168,  169,  187,   20,  146,   22,   20,   20,
          398  + /*   900 */    22,   22,   89,   90,  168,  169,  146,   42,  168,  169,
          399  + /*   910 */   168,  169,  168,  169,  146,  146,  111,  146,  146,  154,
          400  + /*   920 */    20,  188,   22,  146,   16,   60,   61,   62,   63,   64,
          401  + /*   930 */    65,   66,   67,   68,   69,   70,   71,  187,   73,   74,
          402  + /*   940 */    75,   76,   77,   78,   79,   80,   81,   82,  146,   20,
          403  + /*   950 */    42,   22,   20,  188,   22,  187,  187,   19,  187,  187,
          404  + /*   960 */   230,  154,  154,   51,   52,   20,   20,   22,   22,   61,
   405    405    /*   970 */    62,   63,   64,   65,   66,   67,   68,   69,   70,   71,
   406         - /*   980 */   146,   73,   74,   75,   76,   77,   78,   79,   80,   81,
   407         - /*   990 */    82,   16,   17,  187,   19,    7,    8,   20,   23,   22,
   408         - /*  1000 */    20,  171,   22,   77,   78,  160,   31,   16,   17,  227,
   409         - /*  1010 */    19,   86,  172,   20,   23,   22,    1,    2,  171,  146,
   410         - /*  1020 */   192,  146,   31,   48,  171,  146,  190,  144,  148,  171,
   411         - /*  1030 */   146,  146,  193,   58,  146,  222,  146,  176,  146,   48,
   412         - /*  1040 */   120,  193,  193,   59,   15,  183,  186,  111,  151,   58,
   413         - /*  1050 */   186,    6,   77,   78,  145,   19,  129,  186,  221,  193,
   414         - /*  1060 */    85,   86,   87,  151,  173,   90,   95,  210,   77,   78,
   415         - /*  1070 */    79,   40,  178,  145,   23,  159,   85,   86,   87,   16,
   416         - /*  1080 */    17,   90,   19,  145,  109,  151,   23,   15,  210,  150,
   417         - /*  1090 */   197,  119,  173,   19,   31,  214,  159,  136,  123,  124,
   418         - /*  1100 */   125,  126,  127,  128,   97,  238,  193,  117,  210,  194,
   419         - /*  1110 */   170,   48,  170,  151,  123,  124,  125,  126,  127,  128,
   420         - /*  1120 */   118,   58,    5,  170,  195,   22,  153,   10,   11,   12,
   421         - /*  1130 */    13,  115,  214,  170,  170,   33,  151,  196,  235,  150,
   422         - /*  1140 */    77,   78,   38,   26,  170,   28,  151,  151,   85,   86,
   423         - /*  1150 */    87,  183,   35,   90,  232,   97,  114,  203,  210,  204,
   424         - /*  1160 */    96,  129,  170,  233,   47,  145,   49,  235,  151,  172,
   425         - /*  1170 */   170,   54,  178,   56,  204,  151,  151,  109,  135,  203,
   426         - /*  1180 */   174,  183,  134,  174,   57,  158,  123,  124,  125,  126,
   427         - /*  1190 */   127,  128,  188,   19,  102,  146,  146,   14,  185,    1,
   428         - /*  1200 */    90,   19,  180,  168,   20,   20,   20,  106,  180,  168,
   429         - /*  1210 */    19,   44,   20,   19,   44,   98,   99,  100,   19,  121,
   430         - /*  1220 */     4,  104,   19,  111,    3,   19,  109,  121,   82,  111,
   431         - /*  1230 */    11,   16,  146,   97,   17,  101,  112,   44,   20,   19,
   432         - /*  1240 */     5,   19,  111,   20,   17,   21,  132,   22,   20,   45,
   433         - /*  1250 */   133,   22,   11,  116,   22,  111,    1,  112,   32,   45,
   434         - /*  1260 */   111,  101,   20,   19,  116,   97,   36,   19,   22,   67,
   435         - /*  1270 */    19,  113,   67,   20,   94,
          406  + /*   980 */   231,   73,   74,   75,   76,   77,   78,   79,   80,   81,
          407  + /*   990 */    82,   16,   17,  146,   19,  188,  188,   20,   23,   22,
          408  + /*  1000 */    20,  146,   22,  146,  146,   67,   31,   16,   17,  237,
          409  + /*  1010 */    19,  148,  146,  146,   23,  171,  146,  146,  146,  146,
          410  + /*  1020 */   146,  190,   31,   48,  192,  222,  146,  227,  227,  176,
          411  + /*  1030 */   171,  171,  171,   58,  172,  171,  193,    6,  193,   48,
          412  + /*  1040 */   145,  145,  145,  145,   22,  153,   97,  170,   40,   58,
          413  + /*  1050 */    96,  170,   77,   78,  170,  172,  170,  120,  117,  115,
          414  + /*  1060 */    85,   86,   87,  178,  196,   90,  118,  221,   77,   78,
          415  + /*  1070 */    79,  119,  129,  111,  151,  188,   85,   86,   87,   16,
          416  + /*  1080 */    17,   90,   19,  193,  109,  194,   23,   95,  195,   23,
          417  + /*  1090 */   159,  197,  210,  151,   31,   97,  114,   19,  123,  124,
          418  + /*  1100 */   125,  126,  127,  128,  203,  178,  204,  203,  173,  210,
          419  + /*  1110 */   204,   48,  159,  210,  123,  124,  125,  126,  127,  128,
          420  + /*  1120 */   210,   58,    5,  173,   15,  170,  170,   10,   11,   12,
          421  + /*  1130 */    13,  170,  151,  150,   38,   19,  151,  151,  151,   23,
          422  + /*  1140 */    77,   78,  129,   26,  233,   28,  232,  150,   85,   86,
          423  + /*  1150 */    87,  151,   35,   90,  170,  183,   59,  183,   19,  193,
          424  + /*  1160 */    15,  214,  186,  193,   47,  186,   49,  151,   33,  235,
          425  + /*  1170 */   151,   54,  214,   56,   58,  186,  183,  151,  136,  158,
          426  + /*  1180 */   174,  174,    1,   20,   32,   44,  123,  124,  125,  126,
          427  + /*  1190 */   127,  128,  235,   77,   78,   19,  111,  238,  111,  111,
          428  + /*  1200 */   111,   19,   86,   20,   20,   90,   90,  106,   19,   11,
          429  + /*  1210 */    19,  116,   20,   20,  116,   98,   99,  100,   22,   22,
          430  + /*  1220 */   113,  104,   22,   19,  111,   20,  109,   20,   19,   44,
          431  + /*  1230 */    20,   19,   19,   19,   44,  102,   94,   16,   21,  123,
          432  + /*  1240 */   124,  125,   17,   97,   36,   22,   45,   45,   97,   19,
          433  + /*  1250 */   133,  132,    5,   11,    1,  101,   19,  121,   17,  112,
          434  + /*  1260 */   112,   67,   67,  101,  121,   19,   14,  135,   20,    3,
          435  + /*  1270 */   239,  134,   57,    4,
   436    436   };
   437         -#define YY_SHIFT_USE_DFLT (-61)
          437  +#define YY_SHIFT_USE_DFLT (-98)
   438    438   #define YY_SHIFT_MAX 371
   439    439   static const short yy_shift_ofst[] = {
   440         - /*     0 */  1015,  975, 1117,  -16,  975, 1063, 1063, 1063,  125,  330,
   441         - /*    10 */   330, 1068,  324, 1063, 1063, 1063, 1063, 1063,  -45,  192,
   442         - /*    20 */   548,  926,  925,  926,   51,  391,  118,  185,  252,  458,
   443         - /*    30 */   530,  597,  664,  731,  731,  731,  731,  731,  731,  731,
   444         - /*    40 */   731,  731,  798,  731,  731,  731,  731,  731,  731,  731,
          440  + /*     0 */   221,  975, 1117,  -16,  975, 1063, 1063, 1063,   49,  115,
          441  + /*    10 */   115,  -97,  118, 1063, 1063, 1063, 1063, 1063,  -45,  131,
          442  + /*    20 */   116,  328,  225,  225,   51,  185,  252,  324,  396,  463,
          443  + /*    30 */   530,  597,  664,  731,  798,  731,  731,  731,  731,  731,
          444  + /*    40 */   731,  731,  731,  731,  731,  731,  731,  731,  731,  731,
   445    445    /*    50 */   731,  731,  865,  908,  908,  991, 1063, 1063, 1063, 1063,
   446    446    /*    60 */  1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063,
   447    447    /*    70 */  1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063,
   448    448    /*    80 */  1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063,
   449         - /*    90 */  1063, 1063, 1063, 1063,  -60,  -60,   -4,    1,    1,   74,
   450         - /*   100 */   153,  128,  763,  548,  548,  548,  548,  548,  548,  548,
   451         - /*   110 */   925, 1146,  -61,  -61,  -61,   84,  129,  261,  261,  548,
   452         - /*   120 */   548,  548,  548,  548,  548,  548,  548,  548,  578,  548,
   453         - /*   130 */   548,  548,  548,  489,  548,  489,  778,  726, 1068, 1068,
   454         - /*   140 */  1068,  -61,  -61,   79,  184,   79,  200,  390,  341,  315,
   455         - /*   150 */   480,  451,  251,  398,  466,  457,  548,  548,  548,  548,
   456         - /*   160 */   759,  548,  548,  548,  601,  267,  548,  548,  548,  397,
   457         - /*   170 */   548,  548,  710,  397,  596,  397,  601,  397,  316,  548,
   458         - /*   180 */   600,  600,  397,  548,  548,  548,  548,  548,  548,  548,
   459         - /*   190 */   600,  397,  548,  548,  397,  548,  548,  548,  548,  548,
   460         - /*   200 */   640,  598,  640,  598,  796,  598,  508,  598,  580,  803,
   461         - /*   210 */   598,   70,  429,   26,  358,  920,  984, 1029, 1029,  936,
   462         - /*   220 */  1045,  920, 1036,  927, 1029,  936,  971, 1045, 1031, 1051,
   463         - /*   230 */  1045,  936, 1072,  971,  972, 1036, 1051, 1074,  961, 1007,
   464         - /*   240 */   920, 1007,  971,  990,  936, 1002, 1007, 1103, 1016, 1074,
   465         - /*   250 */  1007, 1007,  936, 1072, 1102,  936, 1104,  984,  936, 1007,
   466         - /*   260 */  1058, 1042,  971, 1032, 1007, 1064, 1045, 1102,  936, 1007,
   467         - /*   270 */  1031,  984, 1042,  936, 1058,  936, 1068,  -61,  -61,  -61,
   468         - /*   280 */   424,  452,  310,  734,  277,  683,  389,   86,  526,  529,
   469         - /*   290 */   404,  461,  678,  733,  863,  497,  944,  988,  977,  980,
   470         - /*   300 */   993,  229, 1136, 1193, 1222, 1223, 1235, 1131, 1114, 1204,
   471         - /*   310 */  1229, 1241, 1226, 1255, 1214, 1242, 1160, 1230, 1248, 1202,
   472         - /*   320 */  1205, 1253, 1158, 1251, 1246, 1168, 1148, 1244, 1149, 1145,
   473         - /*   330 */  1144, 1232, 1137, 1227, 1228, 1225, 1224, 1124, 1218, 1220,
   474         - /*   340 */  1134, 1217, 1215, 1219, 1118, 1206, 1112, 1216, 1098, 1199,
   475         - /*   350 */  1170, 1194, 1191, 1101, 1186, 1185, 1184, 1182, 1110, 1198,
   476         - /*   360 */  1183, 1092, 1174, 1127, 1048, 1043, 1192, 1167, 1203, 1221,
   477         - /*   370 */  1106, 1180,
          449  + /*    90 */  1063, 1063, 1063, 1063,  -60,  -60,  -14,   27,   27,   94,
          450  + /*   100 */    86,  399,  116,  116,  116,  116,  151,  116,  116,  116,
          451  + /*   110 */   328,  -59,  -98,  -98,  -98, 1116,   53,  398,  398,  502,
          452  + /*   120 */   491,  116,  491,  116,  116,  116,  116,  116,  116,  116,
          453  + /*   130 */   116,  116,  116,  116,  116,  116,   29,  443,  -97,  -97,
          454  + /*   140 */   -97,  -98,  -98,  147,  147,  128,  272,  403,  262,  410,
          455  + /*   150 */   461,  412,  268,  408,  468,  470,  573,  116,  116,  710,
          456  + /*   160 */   116,  116,   73,  116,  116,  735,  116,  116,  524,  735,
          457  + /*   170 */   116,  116,  312,  312,  312,  116,  116,  524,  116,  116,
          458  + /*   180 */   524,  116,  726,  516,  116,  116,  524,  116,  116,  116,
          459  + /*   190 */   524,  116,  524,  524,  116,  116,  116,  116,  116,  116,
          460  + /*   200 */   812,  458,  595,  525,  711,  711,  632,  458,  458,   56,
          461  + /*   210 */   458,  458,  487,  661,  661, 1031, 1031, 1031, 1031, 1022,
          462  + /*   220 */   949,  949, 1008,  949,  954,  949,  -97,  937,  941,  948,
          463  + /*   230 */   944,  952,  943,  962,  992, 1066,  992,  962,  998,  982,
          464  + /*   240 */   998,  982, 1078,  992,  992, 1066, 1008,  949,  949,  949,
          465  + /*   250 */  1078, 1109,  962,  962,  962,  962, 1096, 1013, 1109,  962,
          466  + /*   260 */   949, 1097, 1097, 1139,  937, 1145, 1145, 1145,  937, 1097,
          467  + /*   270 */  1139,  962, 1135, 1135,  962,  962, 1042,  -98,  -98,  -98,
          468  + /*   280 */   148,  506,  536,  505,  728,  876,  805,  869,  698,  875,
          469  + /*   290 */   878,  879,  813,  900,  929,  932,  912,  945,  946,  977,
          470  + /*   300 */   980,  938, 1181, 1163, 1152, 1141, 1176, 1085, 1087, 1088,
          471  + /*   310 */  1089, 1182, 1183, 1184, 1115, 1101, 1189, 1198, 1191, 1192,
          472  + /*   320 */  1196, 1193, 1095, 1197, 1098, 1200, 1107, 1204, 1205, 1113,
          473  + /*   330 */  1207, 1185, 1209, 1210, 1212, 1213, 1190, 1214, 1142, 1133,
          474  + /*   340 */  1221, 1225, 1217, 1146, 1208, 1201, 1223, 1202, 1119, 1151,
          475  + /*   350 */  1230, 1247, 1242, 1253, 1154, 1194, 1195, 1136, 1237, 1147,
          476  + /*   360 */  1241, 1148, 1162, 1143, 1246, 1248, 1252, 1215, 1137, 1132,
          477  + /*   370 */  1266, 1269,
   478    478   };
   479    479   #define YY_REDUCE_USE_DFLT (-216)
   480    480   #define YY_REDUCE_MAX 279
   481    481   static const short yy_reduce_ofst[] = {
   482         - /*     0 */   -39,  208,  154,  -52,  190,  138,  202,  204,  262,  328,
   483         - /*    10 */   414,  155,  133,   68,  268,  405, -144,  -74, -178,  270,
   484         - /*    20 */   -50,   76,  -21,  280, -215, -215, -215, -215, -215, -215,
          482  + /*     0 */   -56,  136,   16,   70,  189,  127,   66,  130,  190,  219,
          483  + /*    10 */   255,  220,   61,  132,  138,  210,  265,  271, -178, -140,
          484  + /*    20 */   -61,   79,  145,  264, -215, -215, -215, -215, -215, -215,
   485    485    /*    30 */  -215, -215, -215, -215, -215, -215, -215, -215, -215, -215,
   486    486    /*    40 */  -215, -215, -215, -215, -215, -215, -215, -215, -215, -215,
   487         - /*    50 */  -215, -215, -215, -215, -215,  610,  606,  590,  551,  543,
   488         - /*    60 */   539,  523,  483,  476,  469,  415,  408,  136,  740,  -11,
   489         - /*    70 */   401,  413,  417,  473,  478,  485,  535,  541,  547,  553,
   490         - /*    80 */   602,  608,  614,    4,  616,  619,  657,  669,  673,  675,
   491         - /*    90 */   677,  681,  742,  685, -215, -215,  326, -215, -215, -215,
   492         - /*   100 */  -215,  199,   14,  536,  605,  -78,  409,  671,  724,  736,
   493         - /*   110 */   347, -215, -215, -215, -215,  799,  538,  719,  717,  745,
   494         - /*   120 */   690,  806,   22,  776,  775,  773,  626,  769,  493,  768,
   495         - /*   130 */   767,  682,  766,  738,    3,  558,  735,  730,  702,  495,
   496         - /*   140 */   467,  286,  249, 1041, 1028, 1035, 1022,  -46,  -46,  -46,
   497         - /*   150 */  1086, 1013, 1050, 1049, -123,  892,  890,  888,  885,  884,
   498         - /*   160 */   883,  879,  875,  873,  567,  845,  834,  822,  805,  -46,
   499         - /*   170 */   770,  753,  639,  -46,  395,  -46,  567,  -46,  387,  403,
   500         - /*   180 */    94,   66,  -46, -104, -140, -123,  -90,   80,  111,  193,
   501         - /*   190 */   255,  -46,  603,  634,  -46,  693,  701,  747,  760,  774,
   502         - /*   200 */   732,  794,  782,  830,  840,  847,  828,  853,  836,  880,
   503         - /*   210 */   858,  839,  813,  861,  848,  849,  862,  860,  864,  897,
   504         - /*   220 */   909,  866,  891,  837,  871,  912,  857,  928,  894,  916,
   505         - /*   230 */   938,  934,  939,  878,  893,  919,  937,  881,  867,  940,
   506         - /*   240 */   913,  942,  898,  915,  962,  929,  953,  973,  941,  918,
   507         - /*   250 */   963,  964,  985,  989,  903,  995,  922,  968,  996,  974,
   508         - /*   260 */   954,  955,  948,  930,  992,  997, 1020,  932, 1017, 1000,
   509         - /*   270 */   994,  998,  970, 1024,  976, 1025, 1004, 1006, 1009, 1027,
          487  + /*    50 */  -215, -215, -215, -215, -215,  402,  405,  407,  416,  418,
          488  + /*    60 */   456,  472,  474,  476,  480,  482,  484,  523,  535,  540,
          489  + /*    70 */   542,  544,  547,  549,  551,  590,  602,  606,  608,  610,
          490  + /*    80 */   614,  618,  657,  669,  673,  675,  677,  681,  686,  724,
          491  + /*    90 */   736,  740,  742,  744, -215, -215,  -77, -215, -215, -215,
          492  + /*   100 */  -215,   50,  354,  473,  541,  603,  144,  604,  772,  342,
          493  + /*   110 */   284, -215, -215, -215, -215,  282,  251,  322,  462,  -72,
          494  + /*   120 */   177,  306,  428,  353,  193,  475,  421,  477,  509,  575,
          495  + /*   130 */   707,  750,  768,  771,  556,  769,  663,  733,  765,  807,
          496  + /*   140 */   808,  -42,  499, -126, -112,  -57,  -19,   18,   96,   18,
          497  + /*   150 */    18,   72,  141,  146,  198,  250,  223,  336,  370,  373,
          498  + /*   160 */   250,  543,  534,  561,  607,  563,  623,  626,   18,  563,
          499  + /*   170 */   634,  690,  662,  670,  679,  706,  739,   18,  760,  777,
          500  + /*   180 */    18,  802,  730,  749,  847,  855,   18,  857,  858,  866,
          501  + /*   190 */    18,  867,   18,   18,  870,  871,  872,  873,  874,  880,
          502  + /*   200 */   863,  844,  831,  832,  800,  801,  803,  859,  860,  853,
          503  + /*   210 */   861,  864,  862,  843,  845,  895,  896,  897,  898,  892,
          504  + /*   220 */   877,  881,  885,  884,  883,  886,  887,  890,  891,  893,
          505  + /*   230 */   868,  894,  846,  923,  882,  931,  899,  942,  901,  902,
          506  + /*   240 */   904,  906,  935,  903,  910,  953,  927,  955,  956,  961,
          507  + /*   250 */   950,  983,  981,  985,  986,  987,  914,  911,  997, 1000,
          508  + /*   260 */   984,  972,  974,  947,  966,  976,  979,  989,  970,  993,
          509  + /*   270 */   958, 1016,  934,  957, 1019, 1026,  959, 1021, 1006, 1007,
   510    510   };
   511    511   static const YYACTIONTYPE yy_default[] = {
   512         - /*     0 */   567,  791,  856,  682,  856,  856,  791,  791,  856,  829,
   513         - /*    10 */   829,  686,  842,  856,  791,  856,  856,  787,  762,  813,
   514         - /*    20 */   856,  813,  598,  813,  717,  856,  856,  856,  856,  856,
   515         - /*    30 */   856,  856,  856,  724,  782,  784,  846,  783,  718,  719,
   516         - /*    40 */   725,  843,  856,  706,  827,  715,  730,  722,  731,  786,
   517         - /*    50 */   698,  790,  752,  768,  751,  856,  856,  856,  856,  856,
          512  + /*     0 */   567,  791,  856,  682,  856,  791,  856,  791,  856,  829,
          513  + /*    10 */   829,  686,  842,  787,  791,  856,  856,  856,  762,  813,
          514  + /*    20 */   856,  598,  813,  813,  717,  856,  856,  856,  856,  856,
          515  + /*    30 */   856,  856,  856,  718,  856,  790,  786,  782,  784,  783,
          516  + /*    40 */   719,  706,  715,  722,  698,  827,  724,  725,  730,  731,
          517  + /*    50 */   843,  846,  752,  768,  751,  856,  856,  856,  856,  856,
   518    518    /*    60 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
   519    519    /*    70 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
   520    520    /*    80 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
   521         - /*    90 */   856,  856,  856,  856,  773,  754,  591,  761,  753,  755,
   522         - /*   100 */   756,  651,  586,  856,  856,  856,  856,  856,  856,  856,
   523         - /*   110 */   856,  757,  769,  770,  758,  856,  856,  856,  856,  856,
   524         - /*   120 */   856,  856,  856,  856,  856,  856,  856,  856,  567,  856,
   525         - /*   130 */   856,  856,  856,  682,  856,  682,  856,  856,  856,  856,
   526         - /*   140 */   856,  686,  676,  856,  642,  856,  856,  856,  856,  856,
   527         - /*   150 */   856,  856,  856,  856,  856,  856,  572,  856,  856,  856,
   528         - /*   160 */   574,  856,  856,  856,  684,  600,  856,  847,  856,  689,
   529         - /*   170 */   849,  801,  674,  588,  856,  727,  690,  832,  819,  856,
   530         - /*   180 */   856,  856,  834,  856,  856,  856,  856,  856,  856,  856,
   531         - /*   190 */   856,  663,  856,  856,  665,  856,  856,  856,  856,  856,
   532         - /*   200 */   856,  709,  856,  709,  624,  709,  683,  709,  674,  856,
   533         - /*   210 */   709,  721,  785,  621,  721,  721,  655,  662,  662,  691,
   534         - /*   220 */   571,  721,  795,  856,  662,  691,  710,  571,  638,  856,
   535         - /*   230 */   571,  691,  583,  710,  716,  795,  856,  732,  854,  653,
   536         - /*   240 */   721,  653,  710,  712,  691,  714,  653,  641,  702,  732,
   537         - /*   250 */   653,  653,  691,  583,  845,  691,  823,  655,  691,  653,
   538         - /*   260 */   699,  701,  710,  826,  653,  624,  571,  845,  691,  653,
   539         - /*   270 */   638,  655,  701,  691,  699,  691,  856,  626,  626,  608,
   540         - /*   280 */   856,  856,  856,  856,  856,  808,  856,  856,  856,  739,
          521  + /*    90 */   856,  856,  856,  856,  754,  773,  591,  753,  761,  755,
          522  + /*   100 */   756,  651,  856,  856,  856,  856,  586,  856,  856,  856,
          523  + /*   110 */   856,  757,  758,  769,  770,  856,  856,  856,  856,  567,
          524  + /*   120 */   682,  856,  682,  856,  856,  856,  856,  856,  856,  856,
          525  + /*   130 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
          526  + /*   140 */   856,  676,  686,  856,  856,  642,  856,  856,  856,  856,
          527  + /*   150 */   856,  856,  856,  856,  856,  856,  574,  572,  856,  674,
          528  + /*   160 */   856,  856,  600,  856,  856,  684,  856,  856,  689,  690,
          529  + /*   170 */   856,  856,  856,  856,  856,  856,  856,  588,  856,  856,
          530  + /*   180 */   663,  856,  819,  856,  856,  856,  834,  856,  856,  856,
          531  + /*   190 */   832,  856,  665,  727,  801,  856,  856,  847,  849,  856,
          532  + /*   200 */   856,  709,  674,  683,  856,  856,  785,  709,  709,  621,
          533  + /*   210 */   709,  709,  624,  721,  721,  571,  571,  571,  571,  641,
          534  + /*   220 */   653,  653,  638,  653,  624,  653,  856,  721,  712,  714,
          535  + /*   230 */   702,  716,  856,  691,  710,  856,  710,  691,  699,  701,
          536  + /*   240 */   699,  701,  795,  710,  710,  856,  638,  653,  653,  653,
          537  + /*   250 */   795,  583,  691,  691,  691,  691,  823,  826,  583,  691,
          538  + /*   260 */   653,  655,  655,  732,  721,  662,  662,  662,  721,  655,
          539  + /*   270 */   732,  691,  845,  845,  691,  691,  854,  608,  626,  626,
          540  + /*   280 */   856,  856,  856,  856,  856,  856,  739,  856,  856,  856,
   541    541    /*   290 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
   542         - /*   300 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
   543         - /*   310 */   822,  856,  856,  856,  821,  856,  856,  856,  856,  856,
   544         - /*   320 */   856,  856,  856,  856,  713,  856,  856,  856,  744,  856,
   545         - /*   330 */   740,  703,  856,  856,  856,  856,  856,  856,  856,  856,
   546         - /*   340 */   856,  856,  856,  856,  856,  856,  741,  856,  856,  856,
   547         - /*   350 */   856,  856,  856,  668,  856,  856,  856,  856,  856,  856,
   548         - /*   360 */   856,  856,  856,  853,  856,  856,  856,  856,  856,  568,
   549         - /*   370 */   856,  856,  838,  649,  839,  837,  648,  650,  652,  644,
   550         - /*   380 */   645,  590,  647,  617,  659,  646,  750,  592,  599,  582,
   551         - /*   390 */   615,  614,  584,  744,  613,  612,  636,  611,  610,  637,
   552         - /*   400 */   623,  622,  798,  658,  799,  693,  797,  639,  815,  657,
   553         - /*   410 */   654,  796,  640,  824,  825,  820,  631,  630,  635,  816,
   554         - /*   420 */   817,  634,  818,  585,  633,  632,  629,  628,  627,  620,
   555         - /*   430 */   749,  616,  748,  737,  792,  793,  777,  679,  678,  677,
   556         - /*   440 */   609,  656,  728,  729,  688,  814,  618,  625,  828,  707,
   557         - /*   450 */   708,  735,  607,  734,  700,  687,  681,  589,  830,  680,
   558         - /*   460 */   587,  619,  697,  696,  695,  694,  685,  733,  675,  672,
   559         - /*   470 */   673,  581,  705,  711,  580,  831,  593,  704,  736,  666,
   560         - /*   480 */   833,  763,  779,  579,  660,  692,  661,  789,  788,  664,
   561         - /*   490 */   667,  578,  800,  776,  840,  836,  835,  577,  671,  720,
   562         - /*   500 */   738,  576,  781,  575,  780,  723,  742,  597,  743,  745,
   563         - /*   510 */   746,  778,  596,  670,  726,  669,  802,  594,  774,  601,
   564         - /*   520 */   595,  803,  804,  805,  806,  771,  767,  807,  765,  573,
   565         - /*   530 */   764,  570,  602,  841,  605,  566,  844,  606,  775,  564,
   566         - /*   540 */   772,  766,  848,  760,  759,  850,  809,  565,  811,  810,
   567         - /*   550 */   812,  851,  604,  603,  562,  852,  855,  747,  643,  569,
          542  + /*   300 */   856,  808,  856,  856,  856,  856,  856,  744,  740,  856,
          543  + /*   310 */   741,  856,  856,  856,  856,  668,  856,  856,  856,  856,
          544  + /*   320 */   856,  856,  856,  703,  856,  713,  856,  856,  856,  856,
          545  + /*   330 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
          546  + /*   340 */   856,  856,  856,  856,  856,  821,  822,  856,  856,  856,
          547  + /*   350 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
          548  + /*   360 */   856,  856,  856,  856,  856,  856,  856,  853,  856,  856,
          549  + /*   370 */   568,  856,  562,  565,  564,  566,  570,  573,  595,  596,
          550  + /*   380 */   597,  575,  576,  577,  578,  579,  580,  581,  587,  589,
          551  + /*   390 */   607,  609,  616,  654,  657,  658,  659,  837,  838,  839,
          552  + /*   400 */   617,  636,  639,  640,  618,  625,  707,  708,  619,  672,
          553  + /*   410 */   673,  736,  666,  667,  671,  738,  742,  743,  745,  746,
          554  + /*   420 */   594,  601,  602,  605,  606,  809,  811,  810,  812,  604,
          555  + /*   430 */   603,  747,  750,  759,  760,  766,  772,  775,  764,  765,
          556  + /*   440 */   767,  771,  774,  669,  670,  778,  780,  781,  835,  836,
          557  + /*   450 */   776,  788,  789,  692,  779,  763,  704,  593,  711,  705,
          558  + /*   460 */   675,  685,  694,  695,  696,  697,  680,  681,  687,  700,
          559  + /*   470 */   734,  735,  688,  677,  678,  679,  777,  737,  748,  749,
          560  + /*   480 */   620,  627,  628,  629,  632,  633,  634,  635,  630,  631,
          561  + /*   490 */   796,  797,  799,  798,  622,  623,  637,  610,  611,  612,
          562  + /*   500 */   613,  744,  614,  615,  599,  592,  643,  646,  647,  648,
          563  + /*   510 */   649,  650,  652,  644,  645,  590,  582,  584,  693,  815,
          564  + /*   520 */   824,  825,  820,  816,  817,  818,  585,  792,  793,  656,
          565  + /*   530 */   728,  729,  814,  828,  830,  733,  831,  833,  660,  661,
          566  + /*   540 */   664,  800,  840,  720,  723,  726,  802,  803,  804,  805,
          567  + /*   550 */   806,  807,  841,  844,  848,  850,  851,  852,  855,  569,
   568    568    /*   560 */   563,
   569    569   };
   570    570   #define YY_SZ_ACTTAB (sizeof(yy_action)/sizeof(yy_action[0]))
   571    571   
   572    572   /* The next table maps tokens into fallback tokens.  If a construct
   573    573   ** like the following:
   574    574   ** 

Changes to SQLite.Interop/src/pragma.c.

     7      7   **    May you do good and not evil.
     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This file contains code used to implement the PRAGMA command.
    13     13   **
    14         -** $Id: pragma.c,v 1.12 2006/01/10 21:10:18 rmsimpson Exp $
           14  +** $Id: pragma.c,v 1.13 2006/01/11 03:22:29 rmsimpson Exp $
    15     15   */
    16     16   #include "sqliteInt.h"
    17     17   #include "os.h"
    18     18   #include <ctype.h>
    19     19   
    20     20   /* Ignore this whole file if pragmas are disabled
    21     21   */

Changes to SQLite.Interop/src/prepare.c.

     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This file contains the implementation of the sqlite3_prepare()
    13     13   ** interface, and routines that contribute to loading the database schema
    14     14   ** from disk.
    15     15   **
    16         -** $Id: prepare.c,v 1.8 2006/01/10 21:10:18 rmsimpson Exp $
           16  +** $Id: prepare.c,v 1.9 2006/01/11 03:22:29 rmsimpson Exp $
    17     17   */
    18     18   #include "sqliteInt.h"
    19     19   #include "os.h"
    20     20   #include <ctype.h>
    21     21   
    22     22   /*
    23     23   ** Fill the InitData structure with an error message that indicates

Changes to SQLite.Interop/src/random.c.

    11     11   *************************************************************************
    12     12   ** This file contains code to implement a pseudo-random number
    13     13   ** generator (PRNG) for SQLite.
    14     14   **
    15     15   ** Random numbers are used by some of the database backends in order
    16     16   ** to generate random integer keys for tables or random filenames.
    17     17   **
    18         -** $Id: random.c,v 1.12 2006/01/10 21:10:18 rmsimpson Exp $
           18  +** $Id: random.c,v 1.13 2006/01/11 03:22:29 rmsimpson Exp $
    19     19   */
    20     20   #include "sqliteInt.h"
    21     21   #include "os.h"
    22     22   
    23     23   
    24     24   /*
    25     25   ** Get a single 8-bit random value from the RC4 PRNG.  The Mutex

Changes to SQLite.Interop/src/select.c.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This file contains C code routines that are called by the parser
    13     13   ** to handle SELECT statements in SQLite.
    14     14   **
    15         -** $Id: select.c,v 1.12 2006/01/10 21:10:18 rmsimpson Exp $
           15  +** $Id: select.c,v 1.13 2006/01/11 03:22:30 rmsimpson Exp $
    16     16   */
    17     17   #include "sqliteInt.h"
    18     18   
    19     19   
    20     20   /*
    21     21   ** Allocate a new Select structure and return a pointer to that
    22     22   ** structure.

Changes to SQLite.Interop/src/server.c.

   327    327   ** This routine implements the server.  To start the server, first
   328    328   ** make sure g.serverHalt is false, then create a new detached thread
   329    329   ** on this procedure.  See the sqlite3_server_start() routine below
   330    330   ** for an example.  This procedure loops until g.serverHalt becomes
   331    331   ** true.
   332    332   */
   333    333   void *sqlite3_server(void *NotUsed){
   334         -  sqlite3_enable_shared_cache(1);
   335    334     if( pthread_mutex_trylock(&g.serverMutex) ){
   336    335       return 0;  /* Another server is already running */
   337    336     }
   338    337     while( !g.serverHalt ){
   339    338       SqlMessage *pMsg;
   340    339   
   341    340       /* Remove the last message from the message queue.

Changes to SQLite.Interop/src/shell.c.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This file contains code to implement the "sqlite" command line
    13     13   ** utility for accessing SQLite databases.
    14     14   **
    15         -** $Id: shell.c,v 1.12 2006/01/10 21:10:18 rmsimpson Exp $
           15  +** $Id: shell.c,v 1.13 2006/01/11 03:22:29 rmsimpson Exp $
    16     16   */
    17     17   #include <stdlib.h>
    18     18   #include <string.h>
    19     19   #include <stdio.h>
    20     20   #include <assert.h>
    21     21   #include "sqlite3.h"
    22     22   #include <ctype.h>

Changes to SQLite.Interop/src/sqlite3.def.

    36     36   sqlite3_complete16
    37     37   sqlite3_create_collation
    38     38   sqlite3_create_collation16
    39     39   sqlite3_create_function
    40     40   sqlite3_create_function16
    41     41   sqlite3_data_count
    42     42   sqlite3_db_handle
           43  +sqlite3_enable_memory_management
           44  +sqlite3_enable_shared_cache
    43     45   sqlite3_errcode
    44     46   sqlite3_errmsg
    45     47   sqlite3_errmsg16
    46     48   sqlite3_exec
    47     49   sqlite3_expired
    48     50   sqlite3_finalize
    49     51   sqlite3_free
................................................................................
    58     60   sqlite3_libversion_number
    59     61   sqlite3_mprintf
    60     62   sqlite3_open
    61     63   sqlite3_open16
    62     64   sqlite3_prepare
    63     65   sqlite3_prepare16
    64     66   sqlite3_progress_handler
           67  +sqlite3_release_memory
    65     68   sqlite3_reset
    66     69   sqlite3_result_blob
    67     70   sqlite3_result_double
    68     71   sqlite3_result_error
    69     72   sqlite3_result_error16
    70     73   sqlite3_result_int
    71     74   sqlite3_result_int64
    72     75   sqlite3_result_null
    73     76   sqlite3_result_text
    74     77   sqlite3_result_text16
    75     78   sqlite3_result_text16be
    76     79   sqlite3_result_text16le
    77     80   sqlite3_result_value
           81  +sqlite3_rollback_hook
    78     82   sqlite3_set_authorizer
    79     83   sqlite3_set_auxdata
    80     84   sqlite3_snprintf
           85  +sqlite3_soft_heap_limit
    81     86   sqlite3_step
    82     87   sqlite3_total_changes
    83     88   sqlite3_trace
    84     89   sqlite3_transfer_bindings
           90  +sqlite3_update_hook
    85     91   sqlite3_user_data
    86     92   sqlite3_value_blob
    87     93   sqlite3_value_bytes
    88     94   sqlite3_value_bytes16
    89     95   sqlite3_value_double
    90     96   sqlite3_value_int
    91     97   sqlite3_value_int64
    92     98   sqlite3_value_text
    93     99   sqlite3_value_text16
    94    100   sqlite3_value_text16be
    95    101   sqlite3_value_text16le
    96    102   sqlite3_value_type
    97    103   sqlite3_vmprintf

Changes to SQLite.Interop/src/sqlite3.h.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This header file defines the interface that the SQLite library
    13     13   ** presents to client programs.
    14     14   **
    15         -** @(#) $Id: sqlite3.h,v 1.13 2006/01/10 21:10:18 rmsimpson Exp $
           15  +** @(#) $Id: sqlite3.h,v 1.14 2006/01/11 03:22:30 rmsimpson Exp $
    16     16   */
    17     17   #ifndef _SQLITE3_H_
    18     18   #define _SQLITE3_H_
    19     19   #include <stdarg.h>     /* Needed for the definition of va_list */
    20     20   
    21     21   /*
    22     22   ** Make sure we can call this stuff from C++.
................................................................................
    27     27   
    28     28   /*
    29     29   ** The version of the SQLite library.
    30     30   */
    31     31   #ifdef SQLITE_VERSION
    32     32   # undef SQLITE_VERSION
    33     33   #endif
    34         -#define SQLITE_VERSION         "3.2.8beta"
           34  +#define SQLITE_VERSION         "3.3.0"
    35     35   
    36     36   /*
    37     37   ** The format of the version string is "X.Y.Z<trailing string>", where
    38     38   ** X is the major version number, Y is the minor version number and Z
    39     39   ** is the release number. The trailing string is often "alpha" or "beta".
    40     40   ** For example "3.1.1beta".
    41     41   **
................................................................................
    44     44   ** SQLITE_VERSION_NUMBER is set to 3001001. To detect if they are using 
    45     45   ** version 3.1.1 or greater at compile time, programs may use the test 
    46     46   ** (SQLITE_VERSION_NUMBER>=3001001).
    47     47   */
    48     48   #ifdef SQLITE_VERSION_NUMBER
    49     49   # undef SQLITE_VERSION_NUMBER
    50     50   #endif
    51         -#define SQLITE_VERSION_NUMBER 3002008
           51  +#define SQLITE_VERSION_NUMBER 3003000
    52     52   
    53     53   /*
    54     54   ** The version string is also compiled into the library so that a program
    55     55   ** can check to make sure that the lib*.a file and the *.h file are from
    56     56   ** the same version.  The sqlite3_libversion() function returns a pointer
    57     57   ** to the sqlite3_version variable - useful in DLLs which cannot access
    58     58   ** global variables.

Changes to SQLite.Interop/src/sqliteInt.h.

     7      7   **    May you do good and not evil.
     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** Internal interface definitions for SQLite.
    13     13   **
    14         -** @(#) $Id: sqliteInt.h,v 1.12 2006/01/10 21:10:18 rmsimpson Exp $
           14  +** @(#) $Id: sqliteInt.h,v 1.13 2006/01/11 03:22:30 rmsimpson Exp $
    15     15   */
    16     16   #ifndef _SQLITEINT_H_
    17     17   #define _SQLITEINT_H_
    18     18   
    19     19   /*
    20     20   ** Extra interface definitions for those who need them
    21     21   */

Changes to SQLite.Interop/src/tclsqlite.c.

     7      7   **    May you do good and not evil.
     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** A TCL Interface to SQLite
    13     13   **
    14         -** $Id: tclsqlite.c,v 1.12 2006/01/10 21:10:18 rmsimpson Exp $
           14  +** $Id: tclsqlite.c,v 1.13 2006/01/11 03:22:30 rmsimpson Exp $
    15     15   */
    16     16   #ifndef NO_TCL     /* Omit this whole file if TCL is unavailable */
    17     17   
    18     18   #include "sqliteInt.h"
    19     19   #include "hash.h"
    20     20   #include "tcl.h"
    21     21   #include <stdlib.h>

Changes to SQLite.Interop/src/tokenize.c.

    11     11   *************************************************************************
    12     12   ** An tokenizer for SQL
    13     13   **
    14     14   ** This file contains C code that splits an SQL input string up into
    15     15   ** individual tokens and sends those tokens one-by-one over to the
    16     16   ** parser for analysis.
    17     17   **
    18         -** $Id: tokenize.c,v 1.15 2006/01/10 21:10:18 rmsimpson Exp $
           18  +** $Id: tokenize.c,v 1.16 2006/01/11 03:22:30 rmsimpson Exp $
    19     19   */
    20     20   #include "sqliteInt.h"
    21     21   #include "os.h"
    22     22   #include <ctype.h>
    23     23   #include <stdlib.h>
    24     24   
    25     25   /*

Changes to SQLite.Interop/src/update.c.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This file contains C code routines that are called by the parser
    13     13   ** to handle UPDATE statements.
    14     14   **
    15         -** $Id: update.c,v 1.12 2006/01/10 21:10:18 rmsimpson Exp $
           15  +** $Id: update.c,v 1.13 2006/01/11 03:22:30 rmsimpson Exp $
    16     16   */
    17     17   #include "sqliteInt.h"
    18     18   
    19     19   /*
    20     20   ** The most recently coded instruction was an OP_Column to retrieve the
    21     21   ** i-th column of table pTab. This routine sets the P3 parameter of the 
    22     22   ** OP_Column to the default value, if any.

Changes to SQLite.Interop/src/utf.c.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This file contains routines used to translate between UTF-8, 
    13     13   ** UTF-16, UTF-16BE, and UTF-16LE.
    14     14   **
    15         -** $Id: utf.c,v 1.12 2006/01/10 21:10:18 rmsimpson Exp $
           15  +** $Id: utf.c,v 1.13 2006/01/11 03:22:30 rmsimpson Exp $
    16     16   **
    17     17   ** Notes on UTF-8:
    18     18   **
    19     19   **   Byte-0    Byte-1    Byte-2    Byte-3    Value
    20     20   **  0xxxxxxx                                 00000000 00000000 0xxxxxxx
    21     21   **  110yyyyy  10xxxxxx                       00000000 00000yyy yyxxxxxx
    22     22   **  1110zzzz  10yyyyyy  10xxxxxx             00000000 zzzzyyyy yyxxxxxx

Changes to SQLite.Interop/src/util.c.

    10     10   **
    11     11   *************************************************************************
    12     12   ** Utility functions used throughout sqlite.
    13     13   **
    14     14   ** This file contains functions for allocating memory, comparing
    15     15   ** strings, and stuff like that.
    16     16   **
    17         -** $Id: util.c,v 1.13 2006/01/10 21:10:18 rmsimpson Exp $
           17  +** $Id: util.c,v 1.14 2006/01/11 03:22:30 rmsimpson Exp $
    18     18   */
    19     19   #include "sqliteInt.h"
    20     20   #include "os.h"
    21     21   #include <stdarg.h>
    22     22   #include <ctype.h>
    23     23   
    24     24   /*

Changes to SQLite.Interop/src/vacuum.c.

    10     10   **
    11     11   *************************************************************************
    12     12   ** This file contains code used to implement the VACUUM command.
    13     13   **
    14     14   ** Most of the code in this file may be omitted by defining the
    15     15   ** SQLITE_OMIT_VACUUM macro.
    16     16   **
    17         -** $Id: vacuum.c,v 1.12 2006/01/10 21:10:18 rmsimpson Exp $
           17  +** $Id: vacuum.c,v 1.13 2006/01/11 03:22:30 rmsimpson Exp $
    18     18   */
    19     19   #include "sqliteInt.h"
    20     20   #include "vdbeInt.h"
    21     21   #include "os.h"
    22     22   
    23     23   #ifndef SQLITE_OMIT_VACUUM
    24     24   /*

Changes to SQLite.Interop/src/vdbe.c.

    39     39   **
    40     40   ** Various scripts scan this source file in order to generate HTML
    41     41   ** documentation, headers files, or other derived files.  The formatting
    42     42   ** of the code in this file is, therefore, important.  See other comments
    43     43   ** in this file for details.  If in doubt, do not deviate from existing
    44     44   ** commenting and indentation practices when changing or adding code.
    45     45   **
    46         -** $Id: vdbe.c,v 1.12 2006/01/10 21:10:18 rmsimpson Exp $
           46  +** $Id: vdbe.c,v 1.13 2006/01/11 03:22:30 rmsimpson Exp $
    47     47   */
    48     48   #include "sqliteInt.h"
    49     49   #include "os.h"
    50     50   #include <ctype.h>
    51     51   #include "vdbeInt.h"
    52     52   
    53     53   /*
................................................................................
  3649   3649     }
  3650   3650     pC->rowidIsValid = 0;
  3651   3651     break;
  3652   3652   }
  3653   3653   
  3654   3654   /* Opcode: IdxInsert P1 * *
  3655   3655   **
  3656         -** The top of the stack holds a SQL index key made using the
  3657         -** MakeIdxRec instruction.  This opcode writes that key into the
  3658         -** index P1.  Data for the entry is nil.
         3656  +** The top of the stack holds a SQL index key made using either the
         3657  +** MakeIdxRec or MakeRecord instructions.  This opcode writes that key
         3658  +** into the index P1.  Data for the entry is nil.
  3659   3659   **
  3660   3660   ** This instruction only works for indices.  The equivalent instruction
  3661   3661   ** for tables is OP_Insert.
  3662   3662   */
  3663   3663   case OP_IdxInsert: {        /* no-push */
  3664   3664     int i = pOp->p1;
  3665   3665     Cursor *pC;
................................................................................
  3680   3680     Release(pTos);
  3681   3681     pTos--;
  3682   3682     break;
  3683   3683   }
  3684   3684   
  3685   3685   /* Opcode: IdxDelete P1 * *
  3686   3686   **
  3687         -** The top of the stack is an index key built using the MakeIdxRec opcode.
         3687  +** The top of the stack is an index key built using the either the
         3688  +** MakeIdxRec or MakeRecord opcodes.
  3688   3689   ** This opcode removes that entry from the index.
  3689   3690   */
  3690   3691   case OP_IdxDelete: {        /* no-push */
  3691   3692     int i = pOp->p1;
  3692   3693     Cursor *pC;
  3693   3694     BtCursor *pCrsr;
  3694   3695     assert( pTos>=p->aStack );

Changes to SQLite.Interop/src/vdbe.h.

    11     11   *************************************************************************
    12     12   ** Header file for the Virtual DataBase Engine (VDBE)
    13     13   **
    14     14   ** This header defines the interface to the virtual database engine
    15     15   ** or VDBE.  The VDBE implements an abstract machine that runs a
    16     16   ** simple program to access and modify the underlying database.
    17     17   **
    18         -** $Id: vdbe.h,v 1.12 2006/01/10 21:10:18 rmsimpson Exp $
           18  +** $Id: vdbe.h,v 1.13 2006/01/11 03:22:30 rmsimpson Exp $
    19     19   */
    20     20   #ifndef _SQLITE_VDBE_H_
    21     21   #define _SQLITE_VDBE_H_
    22     22   #include <stdio.h>
    23     23   
    24     24   /*
    25     25   ** A single VDBE is an opaque structure named "Vdbe".  Only routines

Changes to SQLite.Interop/src/where.c.

    12     12   ** This module contains C code that generates VDBE code used to process
    13     13   ** the WHERE clause of SQL statements.  This module is reponsible for
    14     14   ** generating the code that loops through a table looking for applicable
    15     15   ** rows.  Indices are selected and used to speed the search when doing
    16     16   ** so is applicable.  Because this module is responsible for selecting
    17     17   ** indices, you might also think of this module as the "query optimizer".
    18     18   **
    19         -** $Id: where.c,v 1.14 2006/01/10 21:10:18 rmsimpson Exp $
           19  +** $Id: where.c,v 1.15 2006/01/11 03:22:30 rmsimpson Exp $
    20     20   */
    21     21   #include "sqliteInt.h"
    22     22   
    23     23   /*
    24     24   ** The number of bits in a Bitmask.  "BMS" means "BitMask Size".
    25     25   */
    26     26   #define BMS  (sizeof(Bitmask)*8)