Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Use the SQLITE_UTF* symbols instead of the old internal TEXT_Utf* symbols. (CVS 1572) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
9b84f2f488e1d37ba1a4c4cf31490bcb |
User & Date: | danielk1977 2004-06-12 00:42:35.000 |
Context
2004-06-12
| ||
01:43 | Change prototype for busy callbacks to "int xBusy(void *, int);" (CVS 1573) (check-in: 4f1cfca5ca user: danielk1977 tags: trunk) | |
00:42 | Use the SQLITE_UTF* symbols instead of the old internal TEXT_Utf* symbols. (CVS 1572) (check-in: 9b84f2f488 user: danielk1977 tags: trunk) | |
2004-06-11
| ||
22:04 | Fix typos in the new locking document. (CVS 1571) (check-in: 022075517c user: drh tags: trunk) | |
Changes
Changes to src/build.c.
︙ | ︙ | |||
19 20 21 22 23 24 25 | ** DROP INDEX ** creating ID lists ** BEGIN TRANSACTION ** COMMIT ** ROLLBACK ** PRAGMA ** | | | 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | ** DROP INDEX ** creating ID lists ** BEGIN TRANSACTION ** COMMIT ** ROLLBACK ** PRAGMA ** ** $Id: build.c,v 1.217 2004/06/12 00:42:35 danielk1977 Exp $ */ #include "sqliteInt.h" #include <ctype.h> /* ** This routine is called when a new SQL statement is beginning to ** be parsed. Check to see if the schema for the database needs |
︙ | ︙ | |||
875 876 877 878 879 880 881 | if( nName<0 ) nName = strlen(zName); pColl = sqlite3HashFind(&db->aCollSeq, zName, nName); if( 0==pColl && create ){ pColl = sqliteMalloc( 3*sizeof(*pColl) + nName + 1 ); if( pColl ){ pColl[0].zName = (char*)&pColl[3]; | | | | | 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 | if( nName<0 ) nName = strlen(zName); pColl = sqlite3HashFind(&db->aCollSeq, zName, nName); if( 0==pColl && create ){ pColl = sqliteMalloc( 3*sizeof(*pColl) + nName + 1 ); if( pColl ){ pColl[0].zName = (char*)&pColl[3]; pColl[0].enc = SQLITE_UTF8; pColl[1].zName = (char*)&pColl[3]; pColl[1].enc = SQLITE_UTF16LE; pColl[2].zName = (char*)&pColl[3]; pColl[2].enc = SQLITE_UTF16BE; memcpy(pColl[0].zName, zName, nName); pColl[0].zName[nName] = 0; sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, nName, pColl); } } return pColl; } |
︙ | ︙ | |||
905 906 907 908 909 910 911 | u8 enc, const char *zName, int nName, int create ){ CollSeq *pColl = findCollSeqEntry(db, zName, nName, create); if( pColl ) switch( enc ){ | | | | | 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 | u8 enc, const char *zName, int nName, int create ){ CollSeq *pColl = findCollSeqEntry(db, zName, nName, create); if( pColl ) switch( enc ){ case SQLITE_UTF8: break; case SQLITE_UTF16LE: pColl = &pColl[1]; break; case SQLITE_UTF16BE: pColl = &pColl[2]; break; default: assert(!"Cannot happen"); } return pColl; } |
︙ | ︙ | |||
953 954 955 956 957 958 959 | ** available. Use one of these instead. Avoid a UTF-8 <-> UTF-16 ** conversion if possible. */ CollSeq *pColl2 = 0; char *z = pColl->zName; int n = strlen(z); switch( pParse->db->enc ){ | | | | | | | | | | | 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 | ** available. Use one of these instead. Avoid a UTF-8 <-> UTF-16 ** conversion if possible. */ CollSeq *pColl2 = 0; char *z = pColl->zName; int n = strlen(z); switch( pParse->db->enc ){ case SQLITE_UTF16LE: pColl2 = sqlite3FindCollSeq(pParse->db, SQLITE_UTF16BE, z, n, 0); assert( pColl2 ); if( pColl2->xCmp ) break; pColl2 = sqlite3FindCollSeq(pParse->db, SQLITE_UTF8, z, n, 0); assert( pColl2 ); break; case SQLITE_UTF16BE: pColl2 = sqlite3FindCollSeq(pParse->db,SQLITE_UTF16LE, z, n, 0); assert( pColl2 ); if( pColl2->xCmp ) break; pColl2 = sqlite3FindCollSeq(pParse->db,SQLITE_UTF8, z, n, 0); assert( pColl2 ); break; case SQLITE_UTF8: pColl2 = sqlite3FindCollSeq(pParse->db,SQLITE_UTF16BE, z, n, 0); assert( pColl2 ); if( pColl2->xCmp ) break; pColl2 = sqlite3FindCollSeq(pParse->db,SQLITE_UTF16LE, z, n, 0); assert( pColl2 ); break; } if( pColl2->xCmp ){ memcpy(pColl, pColl2, sizeof(CollSeq)); }else{ if( pParse->nErr==0 ){ |
︙ | ︙ |
Changes to src/date.c.
︙ | ︙ | |||
12 13 14 15 16 17 18 | ** This file contains the C functions that implement date and time ** functions for SQLite. ** ** There is only one exported symbol in this file - the function ** sqlite3RegisterDateTimeFunctions() found at the bottom of the file. ** All other code has file scope. ** | | | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | ** This file contains the C functions that implement date and time ** functions for SQLite. ** ** There is only one exported symbol in this file - the function ** sqlite3RegisterDateTimeFunctions() found at the bottom of the file. ** All other code has file scope. ** ** $Id: date.c,v 1.28 2004/06/12 00:42:35 danielk1977 Exp $ ** ** NOTES: ** ** SQLite processes all times and dates as Julian Day numbers. The ** dates and times are stored as the number of days since noon ** in Greenwich on November 24, 4714 B.C. according to the Gregorian ** calendar system. |
︙ | ︙ | |||
317 318 319 320 321 322 323 | double r; if( sqlite3OsCurrentTime(&r)==0 ){ p->rJD = r; p->validJD = 1; return 0; } return 1; | | | 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 | double r; if( sqlite3OsCurrentTime(&r)==0 ){ p->rJD = r; p->validJD = 1; return 0; } return 1; }else if( sqlite3IsNumber(zDate, 0, SQLITE_UTF8) ){ p->rJD = sqlite3AtoF(zDate, 0); p->validJD = 1; return 0; } return 1; } |
︙ | ︙ |
Changes to src/expr.c.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains routines used for analyzing expressions and ** for generating VDBE code that evaluates expressions in SQLite. ** | | | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains routines used for analyzing expressions and ** for generating VDBE code that evaluates expressions in SQLite. ** ** $Id: expr.c,v 1.140 2004/06/12 00:42:35 danielk1977 Exp $ */ #include "sqliteInt.h" #include <ctype.h> char const *sqlite3AffinityString(char affinity){ switch( affinity ){ case SQLITE_AFF_INTEGER: return "i"; |
︙ | ︙ | |||
1008 1009 1010 1011 1012 1013 1014 | int no_such_func = 0; /* True if no such function exists */ int wrong_num_args = 0; /* True if wrong number of arguments */ int is_agg = 0; /* True if is an aggregate function */ int i; int nId; /* Number of characters in function name */ const char *zId; /* The function name. */ FuncDef *pDef; | | | 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 | int no_such_func = 0; /* True if no such function exists */ int wrong_num_args = 0; /* True if wrong number of arguments */ int is_agg = 0; /* True if is an aggregate function */ int i; int nId; /* Number of characters in function name */ const char *zId; /* The function name. */ FuncDef *pDef; int iPrefEnc = (pParse->db->enc==SQLITE_UTF8)?0:1; getFunctionName(pExpr, &zId, &nId); pDef = sqlite3FindFunction(pParse->db, zId, nId, n, iPrefEnc, 0); if( pDef==0 ){ pDef = sqlite3FindFunction(pParse->db, zId, nId, -1, iPrefEnc, 0); if( pDef==0 ){ no_such_func = 1; |
︙ | ︙ | |||
1276 1277 1278 1279 1280 1281 1282 | ExprList *pList = pExpr->pList; int nExpr = pList ? pList->nExpr : 0; FuncDef *pDef; int nId; const char *zId; int p2 = 0; int i; | | | 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 | ExprList *pList = pExpr->pList; int nExpr = pList ? pList->nExpr : 0; FuncDef *pDef; int nId; const char *zId; int p2 = 0; int i; int iPrefEnc = (pParse->db->enc==SQLITE_UTF8)?0:1; CollSeq *pColl = 0; getFunctionName(pExpr, &zId, &nId); pDef = sqlite3FindFunction(pParse->db, zId, nId, nExpr, iPrefEnc, 0); assert( pDef!=0 ); nExpr = sqlite3ExprCodeExprList(pParse, pList); for(i=0; i<nExpr && i<32; i++){ if( sqlite3ExprIsConstant(pList->a[i].pExpr) ){ |
︙ | ︙ | |||
1720 1721 1722 1723 1724 1725 1726 | for(i=0; i<pParse->nAgg; i++){ if( !aAgg[i].isAgg ) continue; if( sqlite3ExprCompare(aAgg[i].pExpr, pExpr) ){ break; } } if( i>=pParse->nAgg ){ | | | 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 | for(i=0; i<pParse->nAgg; i++){ if( !aAgg[i].isAgg ) continue; if( sqlite3ExprCompare(aAgg[i].pExpr, pExpr) ){ break; } } if( i>=pParse->nAgg ){ int iPrefEnc = (pParse->db->enc==SQLITE_UTF8)?0:1; i = appendAggInfo(pParse); if( i<0 ) return 1; pParse->aAgg[i].isAgg = 1; pParse->aAgg[i].pExpr = pExpr; pParse->aAgg[i].pFunc = sqlite3FindFunction(pParse->db, pExpr->token.z, pExpr->token.n, pExpr->pList ? pExpr->pList->nExpr : 0, iPrefEnc, 0); |
︙ | ︙ |
Changes to src/func.c.
︙ | ︙ | |||
12 13 14 15 16 17 18 | ** This file contains the C functions that implement various SQL ** functions of SQLite. ** ** There is only one exported symbol in this file - the function ** sqliteRegisterBuildinFunctions() found at the bottom of the file. ** All other code has file scope. ** | | | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | ** This file contains the C functions that implement various SQL ** functions of SQLite. ** ** There is only one exported symbol in this file - the function ** sqliteRegisterBuildinFunctions() found at the bottom of the file. ** All other code has file scope. ** ** $Id: func.c,v 1.67 2004/06/12 00:42:35 danielk1977 Exp $ */ #include <ctype.h> #include <math.h> #include <stdlib.h> #include <assert.h> #include "sqliteInt.h" #include "vdbeInt.h" |
︙ | ︙ | |||
393 394 395 396 397 398 399 | int pc_state = -1; /* State number of previous '%' wild card */ int n = 0; int c; int offset = 0; const char *zLike; | | | 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 | int pc_state = -1; /* State number of previous '%' wild card */ int n = 0; int c; int offset = 0; const char *zLike; if( enc==SQLITE_UTF8 ){ zLike = sqlite3_value_text(pPattern); n = sqlite3_value_bytes(pPattern) + 1; }else{ zLike = sqlite3_value_text16(pPattern); n = sqlite3_value_bytes16(pPattern)/2 + 1; } |
︙ | ︙ | |||
484 485 486 487 488 489 490 | if( sqlite3_value_type(argv[1])==SQLITE_NULL || sqlite3_value_type(argv[0])==SQLITE_NULL ){ return; } /* If the user-data pointer is NULL, use UTF-8. Otherwise UTF-16. */ if( sqlite3_user_data(context) ){ | | | | | 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 | if( sqlite3_value_type(argv[1])==SQLITE_NULL || sqlite3_value_type(argv[0])==SQLITE_NULL ){ return; } /* If the user-data pointer is NULL, use UTF-8. Otherwise UTF-16. */ if( sqlite3_user_data(context) ){ enc = SQLITE_UTF16NATIVE; zString = (const unsigned char *)sqlite3_value_text16(argv[1]); assert(0); }else{ enc = SQLITE_UTF8; zString = sqlite3_value_text(argv[1]); } /* If the LIKE pattern has not been compiled, compile it now. */ if( !pLike ){ pLike = compileLike(argv[0], enc); if( !pLike ){ sqlite3_result_error(context, "out of memory", -1); return; } sqlite3_set_auxdata(context, 0, pLike, deleteLike); } aState = pLike->aState; pState = aState; do { if( enc==SQLITE_UTF8 ){ c = zString[offset++]; if( c&0x80 ){ offset--; c = sqlite3ReadUniChar(zString, &offset, &enc, 1); } }else{ c = sqlite3ReadUniChar(zString, &offset, &enc, 1); |
︙ | ︙ |
Changes to src/main.c.
︙ | ︙ | |||
10 11 12 13 14 15 16 | ** ************************************************************************* ** Main file for the SQLite library. The routines in this file ** implement the programmer interface to the library. Routines in ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** | | | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** ************************************************************************* ** Main file for the SQLite library. The routines in this file ** implement the programmer interface to the library. Routines in ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** ** $Id: main.c,v 1.216 2004/06/12 00:42:35 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" #include <ctype.h> /* ** A pointer to this structure is used to communicate information |
︙ | ︙ | |||
219 220 221 222 223 224 225 | /* Get the database meta information. ** ** Meta values are as follows: ** meta[0] Schema cookie. Changes with each schema change. ** meta[1] File format of schema layer. ** meta[2] Size of the page cache. ** meta[3] Synchronous setting. 1:off, 2:normal, 3:full | | | | 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 | /* Get the database meta information. ** ** Meta values are as follows: ** meta[0] Schema cookie. Changes with each schema change. ** meta[1] File format of schema layer. ** meta[2] Size of the page cache. ** meta[3] Synchronous setting. 1:off, 2:normal, 3:full ** meta[4] Db text encoding. 1:UTF-8 3:UTF-16 LE 4:UTF-16 BE ** meta[5] Pragma temp_store value. See comments on BtreeFactory ** meta[6] ** meta[7] ** meta[8] ** meta[9] ** ** Note: The hash defined SQLITE_UTF* symbols in sqliteInt.h correspond to ** the possible values of meta[4]. */ if( rc==SQLITE_OK ){ int i; for(i=0; rc==SQLITE_OK && i<sizeof(meta)/sizeof(meta[0]); i++){ rc = sqlite3BtreeGetMeta(db->aDb[iDb].pBt, i+1, &meta[i]); } |
︙ | ︙ | |||
1050 1051 1052 1053 1054 1055 1056 | /* Allocate the sqlite data structure */ db = sqliteMalloc( sizeof(sqlite) ); if( db==0 ) goto opendb_out; db->priorNewRowid = 0; db->magic = SQLITE_MAGIC_BUSY; db->nDb = 2; db->aDb = db->aDbStatic; | | | 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 | /* Allocate the sqlite data structure */ db = sqliteMalloc( sizeof(sqlite) ); if( db==0 ) goto opendb_out; db->priorNewRowid = 0; db->magic = SQLITE_MAGIC_BUSY; db->nDb = 2; db->aDb = db->aDbStatic; db->enc = SQLITE_UTF8; db->autoCommit = 1; /* db->flags |= SQLITE_ShortColNames; */ sqlite3HashInit(&db->aFunc, SQLITE_HASH_STRING, 0); sqlite3HashInit(&db->aCollSeq, SQLITE_HASH_STRING, 0); for(i=0; i<db->nDb; i++){ sqlite3HashInit(&db->aDb[i].tblHash, SQLITE_HASH_STRING, 0); sqlite3HashInit(&db->aDb[i].idxHash, SQLITE_HASH_STRING, 0); |
︙ | ︙ |
Changes to src/pragma.c.
1 2 3 4 5 6 7 8 9 10 11 12 13 | /* ** 2003 April 6 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: ** ** May you do good and not evil. ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains code used to implement the PRAGMA command. ** | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | /* ** 2003 April 6 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: ** ** May you do good and not evil. ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains code used to implement the PRAGMA command. ** ** $Id: pragma.c,v 1.43 2004/06/12 00:42:35 danielk1977 Exp $ */ #include "sqliteInt.h" #include <ctype.h> #ifdef SQLITE_DEBUG # include "pager.h" # include "btree.h" |
︙ | ︙ | |||
765 766 767 768 769 770 771 | ** useful if invoked immediately after the main database i */ if( sqlite3StrICmp(zLeft, "encoding")==0 ){ struct EncName { char *zName; u8 enc; } encnames[] = { | | | | | | | | | | 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 | ** useful if invoked immediately after the main database i */ if( sqlite3StrICmp(zLeft, "encoding")==0 ){ struct EncName { char *zName; u8 enc; } encnames[] = { { "UTF-8", SQLITE_UTF8 }, { "UTF-16le", SQLITE_UTF16LE }, { "UTF-16be", SQLITE_UTF16BE }, { "UTF-16", SQLITE_UTF16NATIVE }, { "UTF8", SQLITE_UTF8 }, { "UTF16le", SQLITE_UTF16LE }, { "UTF16be", SQLITE_UTF16BE }, { "UTF16", SQLITE_UTF16NATIVE }, { 0, 0 } }; struct EncName *pEnc; if( pRight->z==pLeft->z ){ /* "PRAGMA encoding" */ if( SQLITE_OK!=sqlite3ReadSchema(pParse->db, &pParse->zErrMsg) ){ pParse->nErr++; return; |
︙ | ︙ |
Changes to src/sqlite.h.in.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This header file defines the interface that the SQLite library ** presents to client programs. ** | | | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This header file defines the interface that the SQLite library ** presents to client programs. ** ** @(#) $Id: sqlite.h.in,v 1.99 2004/06/12 00:42:35 danielk1977 Exp $ */ #ifndef _SQLITE_H_ #define _SQLITE_H_ #include <stdarg.h> /* Needed for the definition of va_list */ /* ** Make sure we can call this stuff from C++. |
︙ | ︙ | |||
964 965 966 967 968 969 970 | void sqlite3_result_value(sqlite3_context*, sqlite3_value*); /* ** These are the allowed values for the eTextRep argument to ** sqlite3_create_collation and sqlite3_create_function. */ #define SQLITE_UTF8 1 | | | | | 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 | void sqlite3_result_value(sqlite3_context*, sqlite3_value*); /* ** These are the allowed values for the eTextRep argument to ** sqlite3_create_collation and sqlite3_create_function. */ #define SQLITE_UTF8 1 #define SQLITE_UTF16LE 2 #define SQLITE_UTF16BE 3 #define SQLITE_UTF16 4 /* Use native byte order */ #define SQLITE_ANY 5 /* sqlite3_create_function only */ /* ** These two functions are used to add new collation sequences to the ** sqlite3 handle specified as the first argument. ** ** The name of the new collation sequence is specified as a UTF-8 string |
︙ | ︙ |
Changes to src/sqliteInt.h.
1 2 3 4 5 6 7 8 9 10 11 12 13 | /* ** 2001 September 15 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: ** ** May you do good and not evil. ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** Internal interface definitions for SQLite. ** | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | /* ** 2001 September 15 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: ** ** May you do good and not evil. ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** Internal interface definitions for SQLite. ** ** @(#) $Id: sqliteInt.h,v 1.283 2004/06/12 00:42:35 danielk1977 Exp $ */ #include "config.h" #include "sqlite3.h" #include "hash.h" #include "parse.h" #include <stdio.h> #include <stdlib.h> |
︙ | ︙ | |||
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 | ** changes and so the view will need to be reset. */ #define DB_Locked 0x0001 /* OP_Transaction opcode has been emitted */ #define DB_Cookie 0x0002 /* OP_VerifyCookie opcode has been emiited */ #define DB_SchemaLoaded 0x0004 /* The schema has been loaded */ #define DB_UnresetViews 0x0008 /* Some views have defined column names */ /* ** Possible values for the Db.textEnc field. */ #define TEXT_Utf8 1 #define TEXT_Utf16le 2 #define TEXT_Utf16be 3 #define TEXT_Utf16 (SQLITE_BIGENDIAN?TEXT_Utf16be:TEXT_Utf16le) /* ** An instance of the following structure is used to store the busy-handler ** callback for a given sqlite handle. ** ** The sqlite.busyHandler member of the sqlite struct contains the busy ** callback for the database handle. Each pager opened via the sqlite | > > > > | 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 | ** changes and so the view will need to be reset. */ #define DB_Locked 0x0001 /* OP_Transaction opcode has been emitted */ #define DB_Cookie 0x0002 /* OP_VerifyCookie opcode has been emiited */ #define DB_SchemaLoaded 0x0004 /* The schema has been loaded */ #define DB_UnresetViews 0x0008 /* Some views have defined column names */ #if 0 /* ** Possible values for the Db.textEnc field. */ #define TEXT_Utf8 1 #define TEXT_Utf16le 2 #define TEXT_Utf16be 3 #define TEXT_Utf16 (SQLITE_BIGENDIAN?TEXT_Utf16be:TEXT_Utf16le) #endif #define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE) /* ** An instance of the following structure is used to store the busy-handler ** callback for a given sqlite handle. ** ** The sqlite.busyHandler member of the sqlite struct contains the busy ** callback for the database handle. Each pager opened via the sqlite |
︙ | ︙ |
Changes to src/test5.c.
︙ | ︙ | |||
11 12 13 14 15 16 17 | ************************************************************************* ** Code for testing the utf.c module in SQLite. This code ** is not included in the SQLite library. It is used for automated ** testing of the SQLite library. Specifically, the code in this file ** is used for testing the SQLite routines for converting between ** the various supported unicode encodings. ** | | | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | ************************************************************************* ** Code for testing the utf.c module in SQLite. This code ** is not included in the SQLite library. It is used for automated ** testing of the SQLite library. Specifically, the code in this file ** is used for testing the SQLite routines for converting between ** the various supported unicode encodings. ** ** $Id: test5.c,v 1.10 2004/06/12 00:42:35 danielk1977 Exp $ */ #include "sqliteInt.h" #include "vdbeInt.h" #include "os.h" /* to get SQLITE_BIGENDIAN */ #include "tcl.h" #include <stdlib.h> #include <string.h> |
︙ | ︙ | |||
266 267 268 269 270 271 272 | if( Tcl_GetIntFromObj(interp, objv[1], &repeat_count) ) return TCL_ERROR; if( Tcl_GetIntFromObj(interp, objv[2], &do_calls) ) return TCL_ERROR; val.flags = MEM_Str|MEM_Term|MEM_Static; val.z = "hello world"; val.type = SQLITE_TEXT; | | | 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 | if( Tcl_GetIntFromObj(interp, objv[1], &repeat_count) ) return TCL_ERROR; if( Tcl_GetIntFromObj(interp, objv[2], &do_calls) ) return TCL_ERROR; val.flags = MEM_Str|MEM_Term|MEM_Static; val.z = "hello world"; val.type = SQLITE_TEXT; val.enc = SQLITE_UTF8; for(i=0; i<repeat_count; i++){ if( do_calls ){ zVal = sqlite3_value_text(&val); } } |
︙ | ︙ |
Changes to src/utf.c.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains routines used to translate between UTF-8, ** UTF-16, UTF-16BE, and UTF-16LE. ** | | | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains routines used to translate between UTF-8, ** UTF-16, UTF-16BE, and UTF-16LE. ** ** $Id: utf.c,v 1.19 2004/06/12 00:42:35 danielk1977 Exp $ ** ** Notes on UTF-8: ** ** Byte-0 Byte-1 Byte-2 Byte-3 Value ** 0xxxxxxx 00000000 00000000 0xxxxxxx ** 110yyyyy 10xxxxxx 00000000 00000yyy yyxxxxxx ** 1110zzzz 10yyyyyy 10xxxxxx 00000000 zzzzyyyy yyxxxxxx |
︙ | ︙ | |||
96 97 98 99 100 101 102 | }; /* ** The first parameter, zStr, points at a unicode string. This routine ** reads a single character from the string and returns the codepoint value ** of the character read. ** | | | | | 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 | }; /* ** The first parameter, zStr, points at a unicode string. This routine ** reads a single character from the string and returns the codepoint value ** of the character read. ** ** The value of *pEnc is the string encoding. If *pEnc is SQLITE_UTF16LE or ** SQLITE_UTF16BE, and the first character read is a byte-order-mark, then ** the value of *pEnc is modified if necessary. In this case the next ** character is read and it's code-point value returned. ** ** The value of *pOffset is the byte-offset in zStr from which to begin ** reading. It is incremented by the number of bytes read by this function. ** ** If the fourth parameter, fold, is non-zero, then codepoint values are ** folded to lower-case before being returned. See comments for macro ** LOWERCASE(x) for details. */ int sqlite3ReadUniChar(const char *zStr, int *pOffset, u8 *pEnc, int fold){ int ret = 0; switch( *pEnc ){ case SQLITE_UTF8: { #if 0 static const int initVal[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, |
︙ | ︙ | |||
180 181 182 183 184 185 186 | return (int)0xFFFD; } ret = (ret<<6) + (u32)(b&0x3F); } break; } | | | | | 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 | return (int)0xFFFD; } ret = (ret<<6) + (u32)(b&0x3F); } break; } case SQLITE_UTF16LE: case SQLITE_UTF16BE: { u32 code_point; /* the first code-point in the character */ u32 code_point2; /* the second code-point in the character, if any */ code_point = READ_16(&zStr[*pOffset], (*pEnc==SQLITE_UTF16BE)); *pOffset += 2; /* If this is a non-surrogate code-point, just cast it to an int and ** this is the code-point value. */ if( code_point<0xD800 || code_point>0xE000 ){ ret = code_point; |
︙ | ︙ | |||
207 208 209 210 211 212 213 | return (int)0xFFFD; } /* The code-point just read is a leading surrogate code-point. If their ** is not enough data left or the next code-point is not a trailing ** surrogate, return the replacement character. */ | | | 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 | return (int)0xFFFD; } /* The code-point just read is a leading surrogate code-point. If their ** is not enough data left or the next code-point is not a trailing ** surrogate, return the replacement character. */ code_point2 = READ_16(&zStr[*pOffset], (*pEnc==SQLITE_UTF16BE)); *pOffset += 2; if( code_point2<0xDC00 || code_point>0xDFFF ){ return (int)0xFFFD; } ret = ( (((code_point&0x03C0)+0x0040)<<16) + /* uuuuu */ |
︙ | ︙ | |||
253 254 255 256 257 258 259 | ** Otherwise, check the first 2 bytes of the string to see if a BOM is ** present. */ if( pStr->n>1 ){ u8 bom = sqlite3UtfReadBom(pStr->pZ, 2); if( bom ){ pStr->c += 2; | | | | | | | | 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 | ** Otherwise, check the first 2 bytes of the string to see if a BOM is ** present. */ if( pStr->n>1 ){ u8 bom = sqlite3UtfReadBom(pStr->pZ, 2); if( bom ){ pStr->c += 2; return (bom==SQLITE_UTF16LE)?0:1; } } return big_endian; } /* ** zData is a UTF-16 encoded string, nData bytes in length. This routine ** checks if there is a byte-order mark at the start of zData. If no ** byte order mark is found 0 is returned. Otherwise SQLITE_UTF16BE or ** SQLITE_UTF16LE is returned, depending on whether The BOM indicates that ** the text is big-endian or little-endian. */ u8 sqlite3UtfReadBom(const void *zData, int nData){ if( nData<0 || nData>1 ){ u8 b1 = *(u8 *)zData; u8 b2 = *(((u8 *)zData) + 1); if( b1==0xFE && b2==0xFF ){ return SQLITE_UTF16BE; } if( b1==0xFF && b2==0xFE ){ return SQLITE_UTF16LE; } } return 0; } /* ** Read a single unicode character from the UTF-8 encoded string *pStr. The ** value returned is a unicode scalar value. In the case of malformed ** strings, the unicode replacement character U+FFFD may be returned. */ static u32 readUtf8(UtfString *pStr){ u8 enc = SQLITE_UTF8; return sqlite3ReadUniChar(pStr->pZ, &pStr->c, &enc, 0); } /* ** Write the unicode character 'code' to the string pStr using UTF-8 ** encoding. SQLITE_NOMEM may be returned if sqlite3Malloc() fails. */ |
︙ | ︙ | |||
683 684 685 686 687 688 689 | */ int sqlite3utfTranslate( const void *zData, int nData, /* Input string */ u8 enc1, /* Encoding of zData */ void **zOut, int *nOut, /* Output string */ u8 enc2 /* Desired encoding of output */ ){ | | | | | | | | | 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 | */ int sqlite3utfTranslate( const void *zData, int nData, /* Input string */ u8 enc1, /* Encoding of zData */ void **zOut, int *nOut, /* Output string */ u8 enc2 /* Desired encoding of output */ ){ assert( enc1==SQLITE_UTF8 || enc1==SQLITE_UTF16LE || enc1==SQLITE_UTF16BE ); assert( enc2==SQLITE_UTF8 || enc2==SQLITE_UTF16LE || enc2==SQLITE_UTF16BE ); assert( (enc1==SQLITE_UTF8 && (enc2==SQLITE_UTF16LE || enc2==SQLITE_UTF16BE)) || (enc2==SQLITE_UTF8 && (enc1==SQLITE_UTF16LE || enc1==SQLITE_UTF16BE)) ); if( enc1==SQLITE_UTF8 ){ if( enc2==SQLITE_UTF16LE ){ *zOut = sqlite3utf8to16le(zData, nData); }else{ *zOut = sqlite3utf8to16be(zData, nData); } if( !(*zOut) ) return SQLITE_NOMEM; *nOut = sqlite3utf16ByteLen(*zOut, -1); }else{ *zOut = sqlite3utf16to8(zData, nData, enc1==SQLITE_UTF16BE); if( !(*zOut) ) return SQLITE_NOMEM; *nOut = strlen(*zOut); } return SQLITE_OK; } |
Changes to src/util.c.
︙ | ︙ | |||
10 11 12 13 14 15 16 | ** ************************************************************************* ** Utility functions used throughout sqlite. ** ** This file contains functions for allocating memory, comparing ** strings, and stuff like that. ** | | | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** ************************************************************************* ** Utility functions used throughout sqlite. ** ** This file contains functions for allocating memory, comparing ** strings, and stuff like that. ** ** $Id: util.c,v 1.101 2004/06/12 00:42:35 danielk1977 Exp $ */ #include "sqliteInt.h" #include <stdarg.h> #include <ctype.h> /* ** If malloc() ever fails, this global variable gets set to 1. |
︙ | ︙ | |||
561 562 563 564 565 566 567 | ** string contains any character which is not part of a number. If ** the string is numeric and contains the '.' character, set *realnum ** to TRUE (otherwise FALSE). ** ** Am empty string is considered non-numeric. */ int sqlite3IsNumber(const char *z, int *realnum, u8 enc){ | | | | 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 | ** string contains any character which is not part of a number. If ** the string is numeric and contains the '.' character, set *realnum ** to TRUE (otherwise FALSE). ** ** Am empty string is considered non-numeric. */ int sqlite3IsNumber(const char *z, int *realnum, u8 enc){ int incr = (enc==SQLITE_UTF8?1:2); if( enc==SQLITE_UTF16LE ) z++; if( *z=='-' || *z=='+' ) z += incr; if( !isdigit(*z) ){ return 0; } z += incr; if( realnum ) *realnum = 0; while( isdigit(*z) ){ z += incr; } |
︙ | ︙ | |||
763 764 765 766 767 768 769 | int result; int isNumA, isNumB; if( atext==0 ){ return -1; }else if( btext==0 ){ return 1; } | | | | 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 | int result; int isNumA, isNumB; if( atext==0 ){ return -1; }else if( btext==0 ){ return 1; } isNumA = sqlite3IsNumber(atext, 0, SQLITE_UTF8); isNumB = sqlite3IsNumber(btext, 0, SQLITE_UTF8); if( isNumA ){ if( !isNumB ){ result = -1; }else{ double rA, rB; rA = sqlite3AtoF(atext, 0); rB = sqlite3AtoF(btext, 0); |
︙ | ︙ | |||
855 856 857 858 859 860 861 | break; } assert( a[0]==b[0] ); if( (dir=a[0])=='A' || a[0]=='D' ){ res = strcmp(&a[1],&b[1]); if( res ) break; }else{ | | | | 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 | break; } assert( a[0]==b[0] ); if( (dir=a[0])=='A' || a[0]=='D' ){ res = strcmp(&a[1],&b[1]); if( res ) break; }else{ isNumA = sqlite3IsNumber(&a[1], 0, SQLITE_UTF8); isNumB = sqlite3IsNumber(&b[1], 0, SQLITE_UTF8); if( isNumA ){ double rA, rB; if( !isNumB ){ res = -1; break; } rA = sqlite3AtoF(&a[1], 0); |
︙ | ︙ |
Changes to src/vdbe.c.
︙ | ︙ | |||
39 40 41 42 43 44 45 | ** ** Various scripts scan this source file in order to generate HTML ** documentation, headers files, or other derived files. The formatting ** of the code in this file is, therefore, important. See other comments ** in this file for details. If in doubt, do not deviate from existing ** commenting and indentation practices when changing or adding code. ** | | | 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 | ** ** Various scripts scan this source file in order to generate HTML ** documentation, headers files, or other derived files. The formatting ** of the code in this file is, therefore, important. See other comments ** in this file for details. If in doubt, do not deviate from existing ** commenting and indentation practices when changing or adding code. ** ** $Id: vdbe.c,v 1.366 2004/06/12 00:42:35 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" #include <ctype.h> #include "vdbeInt.h" /* |
︙ | ︙ | |||
698 699 700 701 702 703 704 | if( pOp->p3==0 ){ pTos->flags = MEM_Int; pTos->i = pOp->p1; }else{ pTos->flags = MEM_Str|MEM_Static|MEM_Term; pTos->z = pOp->p3; pTos->n = strlen(pTos->z); | | | | | | 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 | if( pOp->p3==0 ){ pTos->flags = MEM_Int; pTos->i = pOp->p1; }else{ pTos->flags = MEM_Str|MEM_Static|MEM_Term; pTos->z = pOp->p3; pTos->n = strlen(pTos->z); pTos->enc = SQLITE_UTF8; Integerify(pTos, 0); } break; } /* Opcode: Real * * P3 ** ** The string value P3 is converted to a real and pushed on to the stack. */ case OP_Real: { pTos++; pTos->flags = MEM_Str|MEM_Static|MEM_Term; pTos->z = pOp->p3; pTos->n = strlen(pTos->z); pTos->enc = SQLITE_UTF8; Realify(pTos, 0); break; } /* Opcode: String8 * * P3 ** ** P3 points to a nul terminated UTF-8 string. This opcode is transformed ** into an OP_String before it is executed for the first time. */ case OP_String8: { pOp->opcode = OP_String; if( db->enc!=SQLITE_UTF8 && pOp->p3 ){ if( db->enc==SQLITE_UTF16LE ){ pOp->p3 = sqlite3utf8to16le(pOp->p3, -1); }else{ pOp->p3 = sqlite3utf8to16be(pOp->p3, -1); } if( !pOp->p3 ) goto no_mem; } |
︙ | ︙ | |||
749 750 751 752 753 754 755 | ** string encoded with the database native encoding. */ case OP_String: { pTos++; if( pOp->p3 ){ pTos->flags = MEM_Str|MEM_Static|MEM_Term; pTos->z = pOp->p3; | | | 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 | ** string encoded with the database native encoding. */ case OP_String: { pTos++; if( pOp->p3 ){ pTos->flags = MEM_Str|MEM_Static|MEM_Term; pTos->z = pOp->p3; if( db->enc==SQLITE_UTF8 ){ pTos->n = strlen(pTos->z); }else{ pTos->n = sqlite3utf16ByteLen(pTos->z, -1); } pTos->enc = db->enc; }else{ pTos->flags = MEM_Null; |
︙ | ︙ | |||
1057 1058 1059 1060 1061 1062 1063 | ** now it is always UTF-8. So set up zSep to hold the native encoding of ** P3. */ if( pOp->p3 ){ mSep.z = pOp->p3; mSep.n = strlen(mSep.z); mSep.flags = MEM_Str|MEM_Static|MEM_Term; | | | 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 | ** now it is always UTF-8. So set up zSep to hold the native encoding of ** P3. */ if( pOp->p3 ){ mSep.z = pOp->p3; mSep.n = strlen(mSep.z); mSep.flags = MEM_Str|MEM_Static|MEM_Term; mSep.enc = SQLITE_UTF8; sqlite3VdbeChangeEncoding(&mSep, db->enc); }else{ mSep.flags = MEM_Null; mSep.n = 0; } /* Loop through the stack elements to see how long the result will be. */ |
︙ | ︙ | |||
1488 1489 1490 1491 1492 1493 1494 | double r = (double)i; if( r!=pTos->r ){ goto mismatch; } pTos->i = i; }else if( pTos->flags & MEM_Str ){ i64 v; | | | | | 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 | double r = (double)i; if( r!=pTos->r ){ goto mismatch; } pTos->i = i; }else if( pTos->flags & MEM_Str ){ i64 v; if( sqlite3VdbeChangeEncoding(pTos, SQLITE_UTF8) || sqlite3VdbeMemNulTerminate(pTos) ){ goto no_mem; } if( !sqlite3atoi64(pTos->z, &v) ){ double r; if( !sqlite3IsNumber(pTos->z, 0, db->enc) ){ goto mismatch; } Realify(pTos, db->enc); v = (int)pTos->r; r = (double)v; if( r!=pTos->r ){ goto mismatch; } } pTos->i = v; |
︙ | ︙ | |||
3925 3926 3927 3928 3929 3930 3931 | pTos->n = 2; pTos->flags = MEM_Str | MEM_Static | MEM_Term; }else{ pTos->z = z; pTos->n = strlen(z); pTos->flags = MEM_Str | MEM_Dyn | MEM_Term; } | | | 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 | pTos->n = 2; pTos->flags = MEM_Str | MEM_Static | MEM_Term; }else{ pTos->z = z; pTos->n = strlen(z); pTos->flags = MEM_Str | MEM_Dyn | MEM_Term; } pTos->enc = SQLITE_UTF8; sqlite3VdbeChangeEncoding(pTos, db->enc); sqliteFree(aRoot); break; } /* Opcode: ListWrite * * * ** |
︙ | ︙ |
Changes to src/vdbeapi.c.
︙ | ︙ | |||
54 55 56 57 58 59 60 | } long long int sqlite3_value_int64(sqlite3_value *pVal){ Mem *pMem = (Mem *)pVal; sqlite3VdbeMemIntegerify(pMem); return pVal->i; } const unsigned char *sqlite3_value_text(sqlite3_value *pVal){ | | | | 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 | } long long int sqlite3_value_int64(sqlite3_value *pVal){ Mem *pMem = (Mem *)pVal; sqlite3VdbeMemIntegerify(pMem); return pVal->i; } const unsigned char *sqlite3_value_text(sqlite3_value *pVal){ return (const char *)sqlite3ValueText(pVal, SQLITE_UTF8); } const void *sqlite3_value_text16(sqlite3_value* pVal){ return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE); } int sqlite3_value_type(sqlite3_value* pVal){ return pVal->type; } /**************************** sqlite3_result_ ******************************* ** The following routines are used by user-defined functions to specify |
︙ | ︙ | |||
81 82 83 84 85 86 87 | sqlite3VdbeMemSetStr(&pCtx->s, z, n, 0, eCopy); } void sqlite3_result_double(sqlite3_context *pCtx, double rVal){ sqlite3VdbeMemSetDouble(&pCtx->s, rVal); } void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){ pCtx->isError = 1; | | | | | | 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 | sqlite3VdbeMemSetStr(&pCtx->s, z, n, 0, eCopy); } void sqlite3_result_double(sqlite3_context *pCtx, double rVal){ sqlite3VdbeMemSetDouble(&pCtx->s, rVal); } void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){ pCtx->isError = 1; sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, 1); } void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){ pCtx->isError = 1; sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, 1); } void sqlite3_result_int(sqlite3_context *pCtx, int iVal){ sqlite3VdbeMemSetInt64(&pCtx->s, (i64)iVal); } void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){ sqlite3VdbeMemSetInt64(&pCtx->s, iVal); } void sqlite3_result_null(sqlite3_context *pCtx){ sqlite3VdbeMemSetNull(&pCtx->s); } void sqlite3_result_text( sqlite3_context *pCtx, const char *z, int n, int eCopy ){ sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, eCopy); } void sqlite3_result_text16( sqlite3_context *pCtx, const void *z, int n, int eCopy ){ sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, eCopy); } void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){ sqlite3VdbeMemCopy(&pCtx->s, pValue); } /* |
︙ | ︙ | |||
470 471 472 473 474 475 476 | int rc; rc = vdbeUnbind(p, i); if( rc ){ return rc; } pVar = &p->apVar[i-1]; | | | 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 | int rc; rc = vdbeUnbind(p, i); if( rc ){ return rc; } pVar = &p->apVar[i-1]; rc = sqlite3VdbeMemSetStr(pVar, zData, nData, SQLITE_UTF8, eCopy); if( rc ){ return rc; } rc = sqlite3VdbeChangeEncoding(pVar, p->db->enc); return rc; } int sqlite3_bind_text16( |
︙ | ︙ | |||
495 496 497 498 499 500 501 | rc = vdbeUnbind(p, i); if( rc ){ return rc; } pVar = &p->apVar[i-1]; /* There may or may not be a byte order mark at the start of the UTF-16. | | | | 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 | rc = vdbeUnbind(p, i); if( rc ){ return rc; } pVar = &p->apVar[i-1]; /* There may or may not be a byte order mark at the start of the UTF-16. ** Either way set 'txt_enc' to the SQLITE_UTF16* value indicating the ** actual byte order used by this string. If the string does happen ** to contain a BOM, then move zData so that it points to the first ** byte after the BOM. */ txt_enc = sqlite3UtfReadBom(zData, nData); if( txt_enc ){ zData = (void *)(((u8 *)zData) + 2); nData -= 2; }else{ txt_enc = SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE; } rc = sqlite3VdbeMemSetStr(pVar, zData, nData, txt_enc, eCopy); if( rc ){ return rc; } rc = sqlite3VdbeChangeEncoding(pVar, p->db->enc); return rc; } |
Changes to src/vdbeaux.c.
︙ | ︙ | |||
575 576 577 578 579 580 581 | pMem->i = i; /* Program counter */ pMem++; pMem->flags = MEM_Static|MEM_Str|MEM_Term; pMem->z = sqlite3OpcodeNames[pOp->opcode]; /* Opcode */ pMem->n = strlen(pMem->z); pMem->type = SQLITE_TEXT; | | | | 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 | pMem->i = i; /* Program counter */ pMem++; pMem->flags = MEM_Static|MEM_Str|MEM_Term; pMem->z = sqlite3OpcodeNames[pOp->opcode]; /* Opcode */ pMem->n = strlen(pMem->z); pMem->type = SQLITE_TEXT; pMem->enc = SQLITE_UTF8; pMem++; pMem->flags = MEM_Int; pMem->i = pOp->p1; /* P1 */ pMem->type = SQLITE_INTEGER; pMem++; pMem->flags = MEM_Int; pMem->i = pOp->p2; /* P2 */ pMem->type = SQLITE_INTEGER; pMem++; pMem->flags = MEM_Short|MEM_Str|MEM_Term; /* P3 */ pMem->z = displayP3(pOp, pMem->zShort, sizeof(pMem->zShort)); pMem->type = SQLITE_TEXT; pMem->enc = SQLITE_UTF8; p->nResColumn = 5; p->pTos = pMem; p->rc = SQLITE_OK; p->resOnStack = 1; rc = SQLITE_ROW; } |
︙ | ︙ | |||
1004 1005 1006 1007 1008 1009 1010 | for(i=0; i<(2*p->nResColumn); i++){ p->aColName[i].flags = MEM_Null; } } pColName = &(p->aColName[idx]); if( N==0 ){ | | | | 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 | for(i=0; i<(2*p->nResColumn); i++){ p->aColName[i].flags = MEM_Null; } } pColName = &(p->aColName[idx]); if( N==0 ){ rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, 1); }else{ rc = sqlite3VdbeMemSetStr(pColName, zName, N, SQLITE_UTF8, N>0); } if( rc==SQLITE_OK && N==P3_DYNAMIC ){ pColName->flags = (pColName->flags&(~MEM_Static))|MEM_Dyn; } return rc; } |
︙ | ︙ |
Changes to src/vdbemem.c.
︙ | ︙ | |||
37 38 39 40 41 42 43 | int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){ /* If this is not a string, or if it is a string but the encoding is ** already correct, do nothing. */ if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){ return SQLITE_OK; } | | | 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 | int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){ /* If this is not a string, or if it is a string but the encoding is ** already correct, do nothing. */ if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){ return SQLITE_OK; } if( pMem->enc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF8 ){ /* If the current encoding does not match the desired encoding, then ** we will need to do some translation between encodings. */ char *z; int n; int rc; |
︙ | ︙ | |||
187 188 189 190 191 192 193 | sqlite3_snprintf(NBFS, z, "%.15g", pMem->r); }else{ assert( fg & MEM_Int ); sqlite3_snprintf(NBFS, z, "%lld", pMem->i); } pMem->n = strlen(z); pMem->z = z; | | | 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 | sqlite3_snprintf(NBFS, z, "%.15g", pMem->r); }else{ assert( fg & MEM_Int ); sqlite3_snprintf(NBFS, z, "%lld", pMem->i); } pMem->n = strlen(z); pMem->z = z; pMem->enc = SQLITE_UTF8; pMem->flags |= MEM_Str | MEM_Short | MEM_Term; sqlite3VdbeChangeEncoding(pMem, enc); } return rc; } /* |
︙ | ︙ | |||
215 216 217 218 219 220 221 | int sqlite3VdbeMemIntegerify(Mem *pMem){ int flags = pMem->flags; if( flags & MEM_Int ){ /* Do nothing */ }else if( flags & MEM_Real ){ pMem->i = (i64)pMem->r; }else if( flags & (MEM_Str|MEM_Blob) ){ | | | 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 | int sqlite3VdbeMemIntegerify(Mem *pMem){ int flags = pMem->flags; if( flags & MEM_Int ){ /* Do nothing */ }else if( flags & MEM_Real ){ pMem->i = (i64)pMem->r; }else if( flags & (MEM_Str|MEM_Blob) ){ if( sqlite3VdbeChangeEncoding(pMem, SQLITE_UTF8) || sqlite3VdbeMemNulTerminate(pMem) ){ return SQLITE_NOMEM; } assert( pMem->z ); sqlite3atoi64(pMem->z, &pMem->i); }else{ pMem->i = 0; |
︙ | ︙ | |||
239 240 241 242 243 244 245 | */ int sqlite3VdbeMemRealify(Mem *pMem){ if( pMem->flags & MEM_Real ){ /* Do nothing */ }else if( (pMem->flags & MEM_Int) && pMem->type!=SQLITE_TEXT ){ pMem->r = pMem->i; }else if( pMem->flags & (MEM_Str|MEM_Blob) ){ | | | 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 | */ int sqlite3VdbeMemRealify(Mem *pMem){ if( pMem->flags & MEM_Real ){ /* Do nothing */ }else if( (pMem->flags & MEM_Int) && pMem->type!=SQLITE_TEXT ){ pMem->r = pMem->i; }else if( pMem->flags & (MEM_Str|MEM_Blob) ){ if( sqlite3VdbeChangeEncoding(pMem, SQLITE_UTF8) || sqlite3VdbeMemNulTerminate(pMem) ){ return SQLITE_NOMEM; } assert( pMem->z ); pMem->r = sqlite3AtoF(pMem->z, 0); }else{ pMem->r = 0.0; |
︙ | ︙ | |||
328 329 330 331 332 333 334 | pMem->type = enc==0 ? SQLITE_BLOB : SQLITE_TEXT; pMem->n = n; switch( enc ){ case 0: pMem->flags |= MEM_Blob; break; | | | | | 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 | pMem->type = enc==0 ? SQLITE_BLOB : SQLITE_TEXT; pMem->n = n; switch( enc ){ case 0: pMem->flags |= MEM_Blob; break; case SQLITE_UTF8: pMem->flags |= MEM_Str; if( n<0 ){ pMem->n = strlen(z); pMem->flags |= MEM_Term; } break; case SQLITE_UTF16LE: case SQLITE_UTF16BE: pMem->flags |= MEM_Str; if( n<0 ){ pMem->n = sqlite3utf16ByteLen(z,-1); pMem->flags |= MEM_Term; } break; |
︙ | ︙ | |||
429 430 431 432 433 434 435 | return 1; } if( (f2 & MEM_Str)==0 ){ return -1; } assert( pMem1->enc==pMem2->enc ); | | | | 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 | return 1; } if( (f2 & MEM_Str)==0 ){ return -1; } assert( pMem1->enc==pMem2->enc ); assert( pMem1->enc==SQLITE_UTF8 || pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE ); /* FIX ME: This may fail if the collation sequence is deleted after ** this vdbe program is compiled. We cannot just use BINARY in this ** case as this may lead to a segfault caused by traversing an index ** table incorrectly. We need to return an error to the user in this ** case. */ |
︙ | ︙ | |||
550 551 552 553 554 555 556 | assert( (x & (x-1))==0 ); /* Only one string subtype can be defined */ assert( pMem->z!=0 ); /* Strings must have a value */ /* Mem.z points to Mem.zShort iff the subtype is MEM_Short */ assert( (pMem->flags & MEM_Short)==0 || pMem->z==pMem->zShort ); assert( (pMem->flags & MEM_Short)!=0 || pMem->z!=pMem->zShort ); if( (flags & MEM_Str) ){ | | | | | | 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 | assert( (x & (x-1))==0 ); /* Only one string subtype can be defined */ assert( pMem->z!=0 ); /* Strings must have a value */ /* Mem.z points to Mem.zShort iff the subtype is MEM_Short */ assert( (pMem->flags & MEM_Short)==0 || pMem->z==pMem->zShort ); assert( (pMem->flags & MEM_Short)!=0 || pMem->z!=pMem->zShort ); if( (flags & MEM_Str) ){ assert( pMem->enc==SQLITE_UTF8 || pMem->enc==SQLITE_UTF16BE || pMem->enc==SQLITE_UTF16LE ); /* If the string is UTF-8 encoded and nul terminated, then pMem->n ** must be the length of the string. */ if( pMem->enc==SQLITE_UTF8 && (flags & MEM_Term) ){ assert( strlen(pMem->z)==pMem->n ); } } }else{ /* Cannot define a string subtype for non-string objects */ assert( (pMem->flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short))==0 ); } |
︙ | ︙ |
Changes to www/capi3ref.tcl.
|
| | | 1 2 3 4 5 6 7 8 | set rcsid {$Id: capi3ref.tcl,v 1.3 2004/06/12 00:42:36 danielk1977 Exp $} source common.tcl header {C/C++ Interface For SQLite Version 3} puts { <h2>C/C++ Interface For SQLite Version 3</h2> } proc api {name prototype desc {notused x}} { |
︙ | ︙ | |||
326 327 328 329 330 331 332 | sqlite3*, const char *zName, int pref16, void*, int(*xCompare)(void*,int,const void*,int,const void*) ); #define SQLITE_UTF8 1 | | | | | 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 | sqlite3*, const char *zName, int pref16, void*, int(*xCompare)(void*,int,const void*,int,const void*) ); #define SQLITE_UTF8 1 #define SQLITE_UTF16BE 2 #define SQLITE_UTF16LE 3 #define SQLITE_UTF16 4 } { These two functions are used to add new collation sequences to the sqlite3 handle specified as the first argument. The name of the new collation sequence is specified as a UTF-8 string for sqlite3_create_collation() and a UTF-16 string for sqlite3_create_collation16(). In both cases the name is passed as the |
︙ | ︙ |