More strict aliasing fixes. The single source file library now runs
successfully with -fstrict-alias. (CVS 3725)
FossilOrigin-Name: c8a8a189a82500aab501e9949f5b197c0b80b3a9
diff --git a/src/build.c b/src/build.c
index 0e14d73..de3629b 100644
--- a/src/build.c
+++ b/src/build.c
@@ -22,7 +22,7 @@
** COMMIT
** ROLLBACK
**
-** $Id: build.c,v 1.416 2007/03/26 22:05:01 drh Exp $
+** $Id: build.c,v 1.417 2007/03/27 13:36:37 drh Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
@@ -82,7 +82,7 @@
}
nBytes = sizeof(TableLock) * (pParse->nTableLock+1);
- sqliteReallocOrFree(&pParse->aTableLock, nBytes);
+ pParse->aTableLock = sqliteReallocOrFree(pParse->aTableLock, nBytes);
if( pParse->aTableLock ){
p = &pParse->aTableLock[pParse->nTableLock++];
p->iDb = iDb;
@@ -2783,45 +2783,46 @@
}
/*
-** ppArray points into a structure where there is an array pointer
-** followed by two integers. The first integer is the
-** number of elements in the structure array. The second integer
-** is the number of allocated slots in the array.
+** pArray is a pointer to an array of objects. Each object in the
+** array is szEntry bytes in size. This routine allocates a new
+** object on the end of the array.
**
-** In other words, the structure looks something like this:
+** *pnEntry is the number of entries already in use. *pnAlloc is
+** the previously allocated size of the array. initSize is the
+** suggested initial array size allocation.
**
-** struct Example1 {
-** struct subElem *aEntry;
-** int nEntry;
-** int nAlloc;
-** }
+** The index of the new entry is returned in *pIdx.
**
-** The pnEntry parameter points to the equivalent of Example1.nEntry.
-**
-** This routine allocates a new slot in the array, zeros it out,
-** and returns its index. If malloc fails a negative number is returned.
-**
-** szEntry is the sizeof of a single array entry. initSize is the
-** number of array entries allocated on the initial allocation.
+** This routine returns a pointer to the array of objects. This
+** might be the same as the pArray parameter or it might be a different
+** pointer if the array was resized.
*/
-int sqlite3ArrayAllocate(void *ppArray, int szEntry, int initSize){
- char *p;
- void **pp = (void**)ppArray;
- int *an = (int*)&pp[1];
- if( an[0]>=an[1] ){
+void *sqlite3ArrayAllocate(
+ void *pArray, /* Array of objects. Might be reallocated */
+ int szEntry, /* Size of each object in the array */
+ int initSize, /* Suggested initial allocation, in elements */
+ int *pnEntry, /* Number of objects currently in use */
+ int *pnAlloc, /* Current size of the allocation, in elements */
+ int *pIdx /* Write the index of a new slot here */
+){
+ char *z;
+ if( *pnEntry >= *pnAlloc ){
void *pNew;
int newSize;
- newSize = an[1]*2 + initSize;
- pNew = sqliteRealloc(*pp, newSize*szEntry);
+ newSize = (*pnAlloc)*2 + initSize;
+ pNew = sqliteRealloc(pArray, newSize*szEntry);
if( pNew==0 ){
- return -1;
+ *pIdx = -1;
+ return pArray;
}
- an[1] = newSize;
- *pp = pNew;
+ *pnAlloc = newSize;
+ pArray = pNew;
}
- p = *pp;
- memset(&p[an[0]*szEntry], 0, szEntry);
- return an[0]++;
+ z = (char*)pArray;
+ memset(&z[*pnEntry * szEntry], 0, szEntry);
+ *pIdx = *pnEntry;
+ ++*pnEntry;
+ return pArray;
}
/*
@@ -2837,7 +2838,14 @@
if( pList==0 ) return 0;
pList->nAlloc = 0;
}
- i = sqlite3ArrayAllocate(&pList->a, sizeof(pList->a[0]), 5);
+ pList->a = sqlite3ArrayAllocate(
+ pList->a,
+ sizeof(pList->a[0]),
+ 5,
+ &pList->nId,
+ &pList->nAlloc,
+ &i
+ );
if( i<0 ){
sqlite3IdListDelete(pList);
return 0;
diff --git a/src/expr.c b/src/expr.c
index a9ae1e8..934f988 100644
--- a/src/expr.c
+++ b/src/expr.c
@@ -12,7 +12,7 @@
** This file contains routines used for analyzing expressions and
** for generating VDBE code that evaluates expressions in SQLite.
**
-** $Id: expr.c,v 1.282 2007/03/26 22:05:01 drh Exp $
+** $Id: expr.c,v 1.283 2007/03/27 13:36:37 drh Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
@@ -404,7 +404,7 @@
pExpr->iTable = ++pParse->nVar;
if( pParse->nVarExpr>=pParse->nVarExprAlloc-1 ){
pParse->nVarExprAlloc += pParse->nVarExprAlloc + 10;
- sqliteReallocOrFree(&pParse->apVarExpr,
+ pParse->apVarExpr = sqliteReallocOrFree(pParse->apVarExpr,
pParse->nVarExprAlloc*sizeof(pParse->apVarExpr[0]) );
}
if( !sqlite3MallocFailed() ){
@@ -2237,10 +2237,14 @@
*/
static int addAggInfoColumn(AggInfo *pInfo){
int i;
- i = sqlite3ArrayAllocate(&pInfo->aCol, sizeof(pInfo->aCol[0]), 3);
- if( i<0 ){
- return -1;
- }
+ pInfo->aCol = sqlite3ArrayAllocate(
+ pInfo->aCol,
+ sizeof(pInfo->aCol[0]),
+ 3,
+ &pInfo->nColumn,
+ &pInfo->nColumnAlloc,
+ &i
+ );
return i;
}
@@ -2250,10 +2254,14 @@
*/
static int addAggInfoFunc(AggInfo *pInfo){
int i;
- i = sqlite3ArrayAllocate(&pInfo->aFunc, sizeof(pInfo->aFunc[0]), 2);
- if( i<0 ){
- return -1;
- }
+ pInfo->aFunc = sqlite3ArrayAllocate(
+ pInfo->aFunc,
+ sizeof(pInfo->aFunc[0]),
+ 3,
+ &pInfo->nFunc,
+ &pInfo->nFuncAlloc,
+ &i
+ );
return i;
}
diff --git a/src/pager.c b/src/pager.c
index cf4249c..1081712 100644
--- a/src/pager.c
+++ b/src/pager.c
@@ -18,7 +18,7 @@
** file simultaneously, or one process from reading the database while
** another is writing.
**
-** @(#) $Id: pager.c,v 1.300 2007/03/26 22:05:02 drh Exp $
+** @(#) $Id: pager.c,v 1.301 2007/03/27 13:36:37 drh Exp $
*/
#ifndef SQLITE_OMIT_DISKIO
#include "sqliteInt.h"
@@ -1828,7 +1828,7 @@
if( !pPager->memDb && pPager->nRef==0 ){
pager_reset(pPager);
pPager->pageSize = pageSize;
- sqlite3ReallocOrFree(&pPager->pTmpSpace, pageSize);
+ pPager->pTmpSpace = sqlite3ReallocOrFree(pPager->pTmpSpace, pageSize);
}
return pPager->pageSize;
}
diff --git a/src/sqliteInt.h b/src/sqliteInt.h
index 7b8e71d..fcf6c2d 100644
--- a/src/sqliteInt.h
+++ b/src/sqliteInt.h
@@ -11,7 +11,7 @@
*************************************************************************
** Internal interface definitions for SQLite.
**
-** @(#) $Id: sqliteInt.h,v 1.544 2007/03/26 22:05:02 drh Exp $
+** @(#) $Id: sqliteInt.h,v 1.545 2007/03/27 13:36:37 drh Exp $
*/
#ifndef _SQLITEINT_H_
#define _SQLITEINT_H_
@@ -1567,7 +1567,7 @@
char *sqlite3StrDup(const char*);
char *sqlite3StrNDup(const char*, int);
# define sqlite3CheckMemory(a,b)
-void sqlite3ReallocOrFree(void*,int);
+void *sqlite3ReallocOrFree(void*,int);
void sqlite3FreeX(void*);
void *sqlite3MallocX(int);
int sqlite3AllocSize(void *);
@@ -1624,7 +1624,7 @@
void sqlite3DropTable(Parse*, SrcList*, int, int);
void sqlite3DeleteTable(sqlite3*, Table*);
void sqlite3Insert(Parse*, SrcList*, ExprList*, Select*, IdList*, int);
-int sqlite3ArrayAllocate(void*,int,int);
+void *sqlite3ArrayAllocate(void*,int,int,int*,int*,int*);
IdList *sqlite3IdListAppend(IdList*, Token*);
int sqlite3IdListIndex(IdList*,const char*);
SrcList *sqlite3SrcListAppend(SrcList*, Token*, Token*);
diff --git a/src/util.c b/src/util.c
index bb08c09..c46c2df 100644
--- a/src/util.c
+++ b/src/util.c
@@ -14,7 +14,7 @@
** This file contains functions for allocating memory, comparing
** strings, and stuff like that.
**
-** $Id: util.c,v 1.196 2007/03/26 22:05:02 drh Exp $
+** $Id: util.c,v 1.197 2007/03/27 13:36:37 drh Exp $
*/
#include "sqliteInt.h"
#include "os.h"
@@ -661,13 +661,13 @@
}
return p;
}
-void sqlite3ReallocOrFree(void *pp, int n){
- char **x = (char**)pp;
- void *p = sqlite3Realloc(*x, n);
- if( !p ){
- sqlite3FreeX(*x);
+void *sqlite3ReallocOrFree(void *p, int n){
+ void *pNew;
+ pNew = sqlite3Realloc(p, n);
+ if( !pNew ){
+ sqlite3FreeX(p);
}
- *x = p;
+ return pNew;
}
/*
diff --git a/src/vdbe.c b/src/vdbe.c
index 2f90af6..f38ac96 100644
--- a/src/vdbe.c
+++ b/src/vdbe.c
@@ -43,7 +43,7 @@
** 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.592 2007/03/26 22:05:02 drh Exp $
+** $Id: vdbe.c,v 1.593 2007/03/27 13:36:37 drh Exp $
*/
#include "sqliteInt.h"
#include "os.h"
@@ -4236,7 +4236,8 @@
/* FIX ME: This should be allocated as part of the vdbe at compile-time */
if( i>=p->contextStackDepth ){
p->contextStackDepth = i+1;
- sqliteReallocOrFree(&p->contextStack, sizeof(Context)*(i+1));
+ p->contextStack = sqliteReallocOrFree(p->contextStack,
+ sizeof(Context)*(i+1));
if( p->contextStack==0 ) goto no_mem;
}
pContext = &p->contextStack[i];
diff --git a/src/vdbeaux.c b/src/vdbeaux.c
index 559d362..45bf4a1 100644
--- a/src/vdbeaux.c
+++ b/src/vdbeaux.c
@@ -195,7 +195,8 @@
assert( p->magic==VDBE_MAGIC_INIT );
if( i>=p->nLabelAlloc ){
p->nLabelAlloc = p->nLabelAlloc*2 + 10;
- sqliteReallocOrFree(&p->aLabel, p->nLabelAlloc*sizeof(p->aLabel[0]));
+ p->aLabel = sqliteReallocOrFree(p->aLabel,
+ p->nLabelAlloc*sizeof(p->aLabel[0]));
}
if( p->aLabel ){
p->aLabel[i] = -1;
diff --git a/src/where.c b/src/where.c
index f457068..031053a 100644
--- a/src/where.c
+++ b/src/where.c
@@ -16,7 +16,7 @@
** so is applicable. Because this module is responsible for selecting
** indices, you might also think of this module as the "query optimizer".
**
-** $Id: where.c,v 1.240 2007/03/26 22:05:02 drh Exp $
+** $Id: where.c,v 1.241 2007/03/27 13:36:37 drh Exp $
*/
#include "sqliteInt.h"
@@ -1707,8 +1707,8 @@
sqlite3VdbeAddOp(v, OP_Rewind, iTab, 0);
VdbeComment((v, "# %.*s", pX->span.n, pX->span.z));
pLevel->nIn++;
- sqliteReallocOrFree(&pLevel->aInLoop,
- sizeof(pLevel->aInLoop[0])*2*pLevel->nIn);
+ pLevel->aInLoop = sqliteReallocOrFree(pLevel->aInLoop,
+ sizeof(pLevel->aInLoop[0])*2*pLevel->nIn);
aIn = pLevel->aInLoop;
if( aIn ){
aIn += pLevel->nIn*2 - 2;