Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Fix warning messages in VC++. Patches from nicolas352001. (CVS 347) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
f3038d218c91b44b70b75a7b881ea24c |
User & Date: | drh 2002-01-14 09:28:20.000 |
Context
2002-01-15
| ||
18:39 | Added implementations for sqliteOsEnterMutex() and sqliteOsLeaveMutex(). (CVS 348) (check-in: f8a026a3ca user: drh tags: trunk) | |
2002-01-14
| ||
09:28 | Fix warning messages in VC++. Patches from nicolas352001. (CVS 347) (check-in: f3038d218c user: drh tags: trunk) | |
03:00 | Version 2.2.2 (CVS 451) (check-in: 7da00a33fe user: drh tags: trunk) | |
Changes
Changes to src/hash.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 is the implementation of generic hash-tables ** used 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 is the implementation of generic hash-tables ** used in SQLite. ** ** $Id: hash.c,v 1.6 2002/01/14 09:28:20 drh Exp $ */ #include "sqliteInt.h" #include <assert.h> /* Turn bulk memory into a hash table object by initializing the ** fields of the Hash structure. ** |
︙ | ︙ | |||
126 127 128 129 130 131 132 | ** single parameter "keyClass". The return value of hashFunction() ** is a pointer to another function. Specifically, the return value ** of hashFunction() is a pointer to a function that takes two parameters ** with types "const void*" and "int" and returns an "int". */ static int (*hashFunction(int keyClass))(const void*,int){ switch( keyClass ){ | | | | | | | | | | 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 | ** single parameter "keyClass". The return value of hashFunction() ** is a pointer to another function. Specifically, the return value ** of hashFunction() is a pointer to a function that takes two parameters ** with types "const void*" and "int" and returns an "int". */ static int (*hashFunction(int keyClass))(const void*,int){ switch( keyClass ){ case SQLITE_HASH_INT: return &intHash; case SQLITE_HASH_POINTER: return &ptrHash; case SQLITE_HASH_STRING: return &strHash; case SQLITE_HASH_BINARY: return &binHash;; default: break; } return 0; } /* ** Return a pointer to the appropriate hash function given the key class. ** ** For help in interpreted the obscure C code in the function definition, ** see the header comment on the previous function. */ static int (*compareFunction(int keyClass))(const void*,int,const void*,int){ switch( keyClass ){ case SQLITE_HASH_INT: return &intCompare; case SQLITE_HASH_POINTER: return &ptrCompare; case SQLITE_HASH_STRING: return &strCompare; case SQLITE_HASH_BINARY: return &binCompare; default: break; } return 0; } /* Resize the hash table so that it cantains "new_size" buckets. |
︙ | ︙ |
Changes to src/os.c.
︙ | ︙ | |||
495 496 497 498 499 500 501 | wrote = write(id->fd, pBuf, amt); if( wrote<amt ) return SQLITE_FULL; return SQLITE_OK; #endif #if OS_WIN DWORD wrote; SimulateIOError(SQLITE_IOERR); | | | 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 | wrote = write(id->fd, pBuf, amt); if( wrote<amt ) return SQLITE_FULL; return SQLITE_OK; #endif #if OS_WIN DWORD wrote; SimulateIOError(SQLITE_IOERR); if( !WriteFile(id->h, pBuf, amt, &wrote, 0) || (int)wrote<amt ){ return SQLITE_FULL; } return SQLITE_OK; #endif } /* |
︙ | ︙ |
Changes to src/os.h.
︙ | ︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | ** ** This header file (together with is companion C source-code file ** "os.c") attempt to abstract the underlying operating system so that ** the SQLite library will work on both POSIX and windows systems. */ #ifndef _SQLITE_OS_H_ #define _SQLITE_OS_H_ /* ** A handle for an open file is stored in an OsFile object. */ #if OS_UNIX typedef struct OsFile OsFile; struct OsFile { | > > > > > > > > | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | ** ** This header file (together with is companion C source-code file ** "os.c") attempt to abstract the underlying operating system so that ** the SQLite library will work on both POSIX and windows systems. */ #ifndef _SQLITE_OS_H_ #define _SQLITE_OS_H_ #ifdef WIN32 # define OS_WIN 1 # undef OS_UNIX #else # define OS_UNIX 1 # undef OS_WIN #endif /* ** A handle for an open file is stored in an OsFile object. */ #if OS_UNIX typedef struct OsFile OsFile; struct OsFile { |
︙ | ︙ |
Changes to src/pager.c.
︙ | ︙ | |||
14 15 16 17 18 19 20 | ** The pager is used to access a database disk file. It implements ** atomic commit and rollback through the use of a journal file that ** is separate from the database file. The pager also implements file ** locking to prevent two processes from writing the same database ** file simultaneously, or one process from reading the database while ** another is writing. ** | | | 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | ** The pager is used to access a database disk file. It implements ** atomic commit and rollback through the use of a journal file that ** is separate from the database file. The pager also implements file ** locking to prevent two processes from writing the same database ** file simultaneously, or one process from reading the database while ** another is writing. ** ** @(#) $Id: pager.c,v 1.36 2002/01/14 09:28:20 drh Exp $ */ #include "sqliteInt.h" #include "pager.h" #include "os.h" #include <assert.h> #include <string.h> |
︙ | ︙ | |||
765 766 767 768 769 770 771 | assert( pPager->aHash[h]==pPg ); pPager->aHash[h] = pPg->pNextHash; } pPg->pNextHash = pPg->pPrevHash = 0; pPager->nOvfl++; } pPg->pgno = pgno; | | | | 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 | assert( pPager->aHash[h]==pPg ); pPager->aHash[h] = pPg->pNextHash; } pPg->pNextHash = pPg->pPrevHash = 0; pPager->nOvfl++; } pPg->pgno = pgno; if( pPager->aInJournal && (int)pgno<=pPager->origDbSize ){ pPg->inJournal = (pPager->aInJournal[pgno/8] & (1<<(pgno&7)))!=0; }else{ pPg->inJournal = 0; } pPg->dirty = 0; pPg->nRef = 1; REFINFO(pPg); pPager->nRef++; h = pager_hash(pgno); pPg->pNextHash = pPager->aHash[h]; pPager->aHash[h] = pPg; if( pPg->pNextHash ){ assert( pPg->pNextHash->pPrevHash==0 ); pPg->pNextHash->pPrevHash = pPg; } if( pPager->dbSize<0 ) sqlitepager_pagecount(pPager); if( pPager->dbSize<(int)pgno ){ memset(PGHDR_TO_DATA(pPg), 0, SQLITE_PAGE_SIZE); }else{ int rc; sqliteOsSeek(&pPager->fd, (pgno-1)*SQLITE_PAGE_SIZE); rc = sqliteOsRead(&pPager->fd, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE); if( rc!=SQLITE_OK ){ return rc; |
︙ | ︙ | |||
964 965 966 967 968 969 970 | } assert( pPager->state==SQLITE_WRITELOCK ); assert( pPager->journalOpen ); /* The journal now exists and we have a write lock on the ** main database file. Write the current page to the journal. */ | | | | 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 | } assert( pPager->state==SQLITE_WRITELOCK ); assert( pPager->journalOpen ); /* The journal now exists and we have a write lock on the ** main database file. Write the current page to the journal. */ if( (int)pPg->pgno <= pPager->origDbSize ){ rc = sqliteOsWrite(&pPager->jfd, &pPg->pgno, sizeof(Pgno)); if( rc==SQLITE_OK ){ rc = sqliteOsWrite(&pPager->jfd, pData, SQLITE_PAGE_SIZE); } if( rc!=SQLITE_OK ){ sqlitepager_rollback(pPager); pPager->errMask |= PAGER_ERR_FULL; return rc; } assert( pPager->aInJournal!=0 ); pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7); pPager->needSync = 1; } /* Mark the current page as being in the journal and return. */ pPg->inJournal = 1; if( pPager->dbSize<(int)pPg->pgno ){ pPager->dbSize = pPg->pgno; } return rc; } /* ** Return TRUE if the page given in the argument was previously passed |
︙ | ︙ |
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.35 2002/01/14 09:28:20 drh Exp $ */ #include "sqliteInt.h" #include <stdarg.h> #include <ctype.h> /* ** If malloc() ever fails, this global variable gets set to 1. |
︙ | ︙ | |||
815 816 817 818 819 820 821 | return; } *z++ = zDigit[(exp>>6)&0x3f]; *z++ = zDigit[exp & 0x3f]; while( r>0.0 && cnt<10 ){ int digit; r *= 64.0; | | | 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 | return; } *z++ = zDigit[(exp>>6)&0x3f]; *z++ = zDigit[exp & 0x3f]; while( r>0.0 && cnt<10 ){ int digit; r *= 64.0; digit = (int)r; assert( digit>=0 && digit<64 ); *z++ = zDigit[digit & 0x3f]; r -= digit; cnt++; } *z = 0; } |
︙ | ︙ |
Changes to src/vdbe.c.
︙ | ︙ | |||
26 27 28 29 30 31 32 | ** type to the other occurs as necessary. ** ** Most of the code in this file is taken up by the sqliteVdbeExec() ** function which does the work of interpreting a VDBE program. ** But other routines are also provided to help in building up ** a program instruction by instruction. ** | | | 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | ** type to the other occurs as necessary. ** ** Most of the code in this file is taken up by the sqliteVdbeExec() ** function which does the work of interpreting a VDBE program. ** But other routines are also provided to help in building up ** a program instruction by instruction. ** ** $Id: vdbe.c,v 1.106 2002/01/14 09:28:20 drh Exp $ */ #include "sqliteInt.h" #include <ctype.h> /* ** The following global variable is incremented every time a cursor ** moves, either by the OP_MoveTo or the OP_Next opcode. The test |
︙ | ︙ | |||
582 583 584 585 586 587 588 | ** Any prior string or real representation is invalidated. ** NULLs are converted into 0. */ #define Integerify(P,I) \ if(((P)->aStack[(I)].flags&STK_Int)==0){ hardIntegerify(P,I); } static void hardIntegerify(Vdbe *p, int i){ if( p->aStack[i].flags & STK_Real ){ | | | 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 | ** Any prior string or real representation is invalidated. ** NULLs are converted into 0. */ #define Integerify(P,I) \ if(((P)->aStack[(I)].flags&STK_Int)==0){ hardIntegerify(P,I); } static void hardIntegerify(Vdbe *p, int i){ if( p->aStack[i].flags & STK_Real ){ p->aStack[i].i = (int)p->aStack[i].r; Release(p, i); }else if( p->aStack[i].flags & STK_Str ){ p->aStack[i].i = atoi(p->zStack[i]); Release(p, i); }else{ p->aStack[i].i = 0; } |
︙ | ︙ | |||
1507 1508 1509 1510 1511 1512 1513 | case OP_Multiply: b *= a; break; case OP_Divide: { if( a==0.0 ) goto divide_by_zero; b /= a; break; } default: { | | | | 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 | case OP_Multiply: b *= a; break; case OP_Divide: { if( a==0.0 ) goto divide_by_zero; b /= a; break; } default: { int ia = (int)a; int ib = (int)b; if( ia==0.0 ) goto divide_by_zero; b = ib % ia; break; } } POPSTACK; Release(p, nos); |
︙ | ︙ | |||
3876 3877 3878 3879 3880 3881 3882 | if( pFocus==0 ) goto no_mem; if( i>=0 && i<p->agg.nMem ){ Mem *pMem = &pFocus->aMem[i]; if( pMem->s.flags!=STK_Int ){ if( pMem->s.flags & STK_Int ){ /* Do nothing */ }else if( pMem->s.flags & STK_Real ){ | | | 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 | if( pFocus==0 ) goto no_mem; if( i>=0 && i<p->agg.nMem ){ Mem *pMem = &pFocus->aMem[i]; if( pMem->s.flags!=STK_Int ){ if( pMem->s.flags & STK_Int ){ /* Do nothing */ }else if( pMem->s.flags & STK_Real ){ pMem->s.i = (int)pMem->s.r; }else if( pMem->s.flags & STK_Str ){ pMem->s.i = atoi(pMem->z); }else{ pMem->s.i = 0; } if( pMem->s.flags & STK_Dyn ) sqliteFree(pMem->z); pMem->z = 0; |
︙ | ︙ | |||
4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 | sprintf(zBuf,"%d",pc); sqliteSetString(pzErrMsg, "too few operands on stack at ", zBuf, 0); rc = SQLITE_INTERNAL; goto cleanup; /* Jump here if an illegal or illformed instruction is executed. */ bad_instruction: sprintf(zBuf,"%d",pc); sqliteSetString(pzErrMsg, "illegal operation at ", zBuf, 0); rc = SQLITE_INTERNAL; goto cleanup; } | > > | 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 | sprintf(zBuf,"%d",pc); sqliteSetString(pzErrMsg, "too few operands on stack at ", zBuf, 0); rc = SQLITE_INTERNAL; goto cleanup; /* Jump here if an illegal or illformed instruction is executed. */ VERIFY( bad_instruction: sprintf(zBuf,"%d",pc); sqliteSetString(pzErrMsg, "illegal operation at ", zBuf, 0); rc = SQLITE_INTERNAL; goto cleanup; ) } |