*/
#define lemonStrlen(X) ((int)strlen(X))
+/*
+** Header on the linked list of memory allocations.
+*/
+typedef struct MemChunk MemChunk;
+struct MemChunk {
+ MemChunk *pNext;
+ size_t sz;
+ /* Actually memory follows */
+};
+
+/*
+** Global linked list of all memory allocations.
+*/
+static MemChunk *memChunkList = 0;
+
+/*
+** Wrappers around malloc(), calloc(), realloc() and free().
+**
+** All memory allocations are kept on a doubly-linked list. The
+** lemon_free_all() function can be called prior to exit to clean
+** up any memory leaks.
+**
+** This is not necessary. But compilers and getting increasingly
+** fussy about memory leaks, even in command-line programs like Lemon
+** where they do not matter. So this code is provided to hush the
+** warnings.
+*/
+static void *lemon_malloc(size_t nByte){
+ MemChunk *p;
+ if( nByte<0 ) return 0;
+ p = malloc( nByte + sizeof(MemChunk) );
+ if( p==0 ){
+ fprintf(stderr, "Out of memory. Failed to allocate %lld bytes.\n",
+ (long long int)nByte);
+ exit(1);
+ }
+ p->pNext = memChunkList;
+ p->sz = nByte;
+ memChunkList = p;
+ return (void*)&p[1];
+}
+static void *lemon_calloc(size_t nElem, size_t sz){
+ void *p = lemon_malloc(nElem*sz);
+ memset(p, 0, nElem*sz);
+ return p;
+}
+static void lemon_free(void *pOld){
+ if( pOld ){
+ MemChunk *p = (MemChunk*)pOld;
+ p--;
+ memset(pOld, 0, p->sz);
+ }
+}
+static void *lemon_realloc(void *pOld, size_t nNew){
+ void *pNew;
+ MemChunk *p;
+ if( pOld==0 ) return lemon_malloc(nNew);
+ p = (MemChunk*)pOld;
+ p--;
+ if( p->sz>=nNew ) return pOld;
+ pNew = lemon_malloc( nNew );
+ memcpy(pNew, pOld, p->sz);
+ return pNew;
+}
+
+/* Free all outstanding memory allocations.
+** Do this right before exiting.
+*/
+static void lemon_free_all(void){
+ while( memChunkList ){
+ MemChunk *pNext = memChunkList->pNext;
+ free( memChunkList );
+ memChunkList = pNext;
+ }
+}
+
/*
** Compilers are starting to complain about the use of sprintf() and strcpy(),
** saying they are unsafe. So we define our own versions of those routines too.
if( actionfreelist==0 ){
int i;
int amt = 100;
- actionfreelist = (struct action *)calloc(amt, sizeof(struct action));
+ actionfreelist = (struct action *)lemon_calloc(amt, sizeof(struct action));
if( actionfreelist==0 ){
fprintf(stderr,"Unable to allocate memory for a new parser action.");
exit(1);
/* Free all memory associated with the given acttab */
void acttab_free(acttab *p){
- free( p->aAction );
- free( p->aLookahead );
- free( p );
+ lemon_free( p->aAction );
+ lemon_free( p->aLookahead );
+ lemon_free( p );
}
/* Allocate a new acttab structure */
acttab *acttab_alloc(int nsymbol, int nterminal){
- acttab *p = (acttab *) calloc( 1, sizeof(*p) );
+ acttab *p = (acttab *) lemon_calloc( 1, sizeof(*p) );
if( p==0 ){
fprintf(stderr,"Unable to allocate memory for a new acttab.");
exit(1);
void acttab_action(acttab *p, int lookahead, int action){
if( p->nLookahead>=p->nLookaheadAlloc ){
p->nLookaheadAlloc += 25;
- p->aLookahead = (struct lookahead_action *) realloc( p->aLookahead,
+ p->aLookahead = (struct lookahead_action *) lemon_realloc( p->aLookahead,
sizeof(p->aLookahead[0])*p->nLookaheadAlloc );
if( p->aLookahead==0 ){
fprintf(stderr,"malloc failed\n");
if( p->nAction + n >= p->nActionAlloc ){
int oldAlloc = p->nActionAlloc;
p->nActionAlloc = p->nAction + n + p->nActionAlloc + 20;
- p->aAction = (struct lookahead_action *) realloc( p->aAction,
+ p->aAction = (struct lookahead_action *) lemon_realloc( p->aAction,
sizeof(p->aAction[0])*p->nActionAlloc);
if( p->aAction==0 ){
fprintf(stderr,"malloc failed\n");
/* Return a pointer to a new configuration */
PRIVATE struct config *newconfig(void){
- return (struct config*)calloc(1, sizeof(struct config));
+ return (struct config*)lemon_calloc(1, sizeof(struct config));
}
/* The configuration "old" is no longer used */
static void handle_D_option(char *z){
char **paz;
nDefine++;
- azDefine = (char **) realloc(azDefine, sizeof(azDefine[0])*nDefine);
+ azDefine = (char **) lemon_realloc(azDefine, sizeof(azDefine[0])*nDefine);
if( azDefine==0 ){
fprintf(stderr,"out of memory\n");
exit(1);
}
- bDefineUsed = (char*)realloc(bDefineUsed, nDefine);
+ bDefineUsed = (char*)lemon_realloc(bDefineUsed, nDefine);
if( bDefineUsed==0 ){
fprintf(stderr,"out of memory\n");
exit(1);
}
bDefineUsed[nDefine-1] = 0;
paz = &azDefine[nDefine-1];
- *paz = (char *) malloc( lemonStrlen(z)+1 );
+ *paz = (char *) lemon_malloc( lemonStrlen(z)+1 );
if( *paz==0 ){
fprintf(stderr,"out of memory\n");
exit(1);
*/
static char *outputDir = NULL;
static void handle_d_option(char *z){
- outputDir = (char *) malloc( lemonStrlen(z)+1 );
+ outputDir = (char *) lemon_malloc( lemonStrlen(z)+1 );
if( outputDir==0 ){
fprintf(stderr,"out of memory\n");
exit(1);
static char *user_templatename = NULL;
static void handle_T_option(char *z){
- user_templatename = (char *) malloc( lemonStrlen(z)+1 );
+ user_templatename = (char *) lemon_malloc( lemonStrlen(z)+1 );
if( user_templatename==0 ){
memory_error();
}
/* return 0 on success, 1 on failure. */
exitcode = ((lem.errorcnt > 0) || (lem.nconflict > 0)) ? 1 : 0;
+ lemon_free_all();
exit(exitcode);
return (exitcode);
}
case IN_RHS:
if( x[0]=='.' ){
struct rule *rp;
- rp = (struct rule *)calloc( sizeof(struct rule) +
+ rp = (struct rule *)lemon_calloc( sizeof(struct rule) +
sizeof(struct symbol*)*psp->nrhs + sizeof(char*)*psp->nrhs, 1);
if( rp==0 ){
ErrorMsg(psp->filename,psp->tokenlineno,
struct symbol *msp = psp->rhs[psp->nrhs-1];
if( msp->type!=MULTITERMINAL ){
struct symbol *origsp = msp;
- msp = (struct symbol *) calloc(1,sizeof(*msp));
+ msp = (struct symbol *) lemon_calloc(1,sizeof(*msp));
memset(msp, 0, sizeof(*msp));
msp->type = MULTITERMINAL;
msp->nsubsym = 1;
- msp->subsym = (struct symbol **) calloc(1,sizeof(struct symbol*));
+ msp->subsym = (struct symbol**)lemon_calloc(1,sizeof(struct symbol*));
msp->subsym[0] = origsp;
msp->name = origsp->name;
psp->rhs[psp->nrhs-1] = msp;
}
msp->nsubsym++;
- msp->subsym = (struct symbol **) realloc(msp->subsym,
+ msp->subsym = (struct symbol **) lemon_realloc(msp->subsym,
sizeof(struct symbol*)*msp->nsubsym);
msp->subsym[msp->nsubsym-1] = Symbol_new(&x[1]);
if( ISLOWER(x[1]) || ISLOWER(msp->subsym[0]->name[0]) ){
nLine = lemonStrlen(zLine);
n += nLine + lemonStrlen(psp->filename) + nBack;
}
- *psp->declargslot = (char *) realloc(*psp->declargslot, n);
+ *psp->declargslot = (char *) lemon_realloc(*psp->declargslot, n);
zBuf = *psp->declargslot + nOld;
if( addLineMacro ){
if( nOld && zBuf[-1]!='\n' ){
}else if( ISUPPER(x[0]) || ((x[0]=='|' || x[0]=='/') && ISUPPER(x[1])) ){
struct symbol *msp = psp->tkclass;
msp->nsubsym++;
- msp->subsym = (struct symbol **) realloc(msp->subsym,
+ msp->subsym = (struct symbol **) lemon_realloc(msp->subsym,
sizeof(struct symbol*)*msp->nsubsym);
if( !ISUPPER(x[0]) ) x++;
msp->subsym[msp->nsubsym-1] = Symbol_new(x);
fseek(fp,0,2);
filesize = ftell(fp);
rewind(fp);
- filebuf = (char *)malloc( filesize+1 );
+ filebuf = (char *)lemon_malloc( filesize+1 );
if( filesize>100000000 || filebuf==0 ){
ErrorMsg(ps.filename,0,"Input file too large.");
- free(filebuf);
+ lemon_free(filebuf);
gp->errorcnt++;
fclose(fp);
return;
if( fread(filebuf,1,filesize,fp)!=filesize ){
ErrorMsg(ps.filename,0,"Can't read in all %d bytes of this file.",
filesize);
- free(filebuf);
+ lemon_free(filebuf);
gp->errorcnt++;
fclose(fp);
return;
*cp = (char)c; /* Restore the buffer */
cp = nextcp;
}
- free(filebuf); /* Release the buffer after parsing */
+ lemon_free(filebuf); /* Release the buffer after parsing */
gp->rule = ps.firstrule;
gp->errorcnt = ps.errorcnt;
}
if( plink_freelist==0 ){
int i;
int amt = 100;
- plink_freelist = (struct plink *)calloc( amt, sizeof(struct plink) );
+ plink_freelist = (struct plink *)lemon_calloc( amt, sizeof(struct plink) );
if( plink_freelist==0 ){
fprintf(stderr,
"Unable to allocate memory for a new follow-set propagation link.\n");
** Procedures for generating reports and tables in the LEMON parser generator.
*/
-/* Generate a filename with the given suffix. Space to hold the
-** name comes from malloc() and must be freed by the calling
-** function.
+/* Generate a filename with the given suffix.
*/
PRIVATE char *file_makename(struct lemon *lemp, const char *suffix)
{
sz += lemonStrlen(suffix);
if( outputDir ) sz += lemonStrlen(outputDir) + 1;
sz += 5;
- name = (char*)malloc( sz );
+ name = (char*)lemon_malloc( sz );
if( name==0 ){
fprintf(stderr,"Can't allocate space for a filename.\n");
exit(1);
){
FILE *fp;
- if( lemp->outname ) free(lemp->outname);
+ if( lemp->outname ) lemon_free(lemp->outname);
lemp->outname = file_makename(lemp, suffix);
fp = fopen(lemp->outname,mode);
if( fp==0 && *mode=='w' ){
if( cp ){
c = *cp;
*cp = 0;
- path = (char *)malloc( lemonStrlen(argv0) + lemonStrlen(name) + 2 );
+ path = (char *)lemon_malloc( lemonStrlen(argv0) + lemonStrlen(name) + 2 );
if( path ) lemon_sprintf(path,"%s/%s",argv0,name);
*cp = c;
}else{
pathlist = getenv("PATH");
if( pathlist==0 ) pathlist = ".:/bin:/usr/bin";
- pathbuf = (char *) malloc( lemonStrlen(pathlist) + 1 );
- path = (char *)malloc( lemonStrlen(pathlist)+lemonStrlen(name)+2 );
+ pathbuf = (char *) lemon_malloc( lemonStrlen(pathlist) + 1 );
+ path = (char *)lemon_malloc( lemonStrlen(pathlist)+lemonStrlen(name)+2 );
if( (pathbuf != 0) && (path!=0) ){
pathbufptr = pathbuf;
lemon_strcpy(pathbuf, pathlist);
if( access(path,modemask)==0 ) break;
}
}
- free(pathbufptr);
+ lemon_free(pathbufptr);
}
return path;
}
fprintf(stderr,"Can't open the template file \"%s\".\n",tpltname);
lemp->errorcnt++;
}
- free(toFree);
+ lemon_free(toFree);
return in;
}
}
if( (int) (n+sizeof(zInt)*2+used) >= alloced ){
alloced = n + sizeof(zInt)*2 + used + 200;
- z = (char *) realloc(z, alloced);
+ z = (char *) lemon_realloc(z, alloced);
}
if( z==0 ) return empty;
while( n-- > 0 ){
/* Allocate and initialize types[] and allocate stddt[] */
arraysize = lemp->nsymbol * 2;
- types = (char**)calloc( arraysize, sizeof(char*) );
+ types = (char**)lemon_calloc( arraysize, sizeof(char*) );
if( types==0 ){
fprintf(stderr,"Out of memory.\n");
exit(1);
len = lemonStrlen(sp->datatype);
if( len>maxdtlength ) maxdtlength = len;
}
- stddt = (char*)malloc( maxdtlength*2 + 1 );
+ stddt = (char*)lemon_malloc( maxdtlength*2 + 1 );
if( stddt==0 ){
fprintf(stderr,"Out of memory.\n");
exit(1);
}
if( types[hash]==0 ){
sp->dtnum = hash + 1;
- types[hash] = (char*)malloc( lemonStrlen(stddt)+1 );
+ types[hash] = (char*)lemon_malloc( lemonStrlen(stddt)+1 );
if( types[hash]==0 ){
fprintf(stderr,"Out of memory.\n");
exit(1);
for(i=0; i<arraysize; i++){
if( types[i]==0 ) continue;
fprintf(out," %s yy%d;\n",types[i],i+1); lineno++;
- free(types[i]);
+ lemon_free(types[i]);
}
if( lemp->errsym && lemp->errsym->useCnt ){
fprintf(out," int yy%d;\n",lemp->errsym->dtnum); lineno++;
}
- free(stddt);
- free(types);
+ lemon_free(stddt);
+ lemon_free(types);
fprintf(out,"} YYMINORTYPE;\n"); lineno++;
*plineno = lineno;
}
if( mhflag ){
char *incName = file_makename(lemp, ".h");
fprintf(out,"#include \"%s\"\n", incName); lineno++;
- free(incName);
+ lemon_free(incName);
}
tplt_xfer(lemp->name,in,out,&lineno);
** table must be computed before generating the YYNSTATE macro because
** we need to know how many states can be eliminated.
*/
- ax = (struct axset *) calloc(lemp->nxstate*2, sizeof(ax[0]));
+ ax = (struct axset *) lemon_calloc(lemp->nxstate*2, sizeof(ax[0]));
if( ax==0 ){
fprintf(stderr,"malloc failed\n");
exit(1);
}
#endif
}
- free(ax);
+ lemon_free(ax);
/* Mark rules that are actually used for reduce actions after all
** optimizations have been applied
/* Allocate a new set */
char *SetNew(void){
char *s;
- s = (char*)calloc( size, 1);
+ s = (char*)lemon_calloc( size, 1);
if( s==0 ){
memory_error();
}
/* Deallocate a set */
void SetFree(char *s)
{
- free(s);
+ lemon_free(s);
}
/* Add a new element to the set. Return TRUE if the element was added
if( y==0 ) return 0;
z = Strsafe_find(y);
- if( z==0 && (cpy=(char *)malloc( lemonStrlen(y)+1 ))!=0 ){
+ if( z==0 && (cpy=(char *)lemon_malloc( lemonStrlen(y)+1 ))!=0 ){
lemon_strcpy(cpy,y);
z = cpy;
Strsafe_insert(z);
/* Allocate a new associative array */
void Strsafe_init(void){
if( x1a ) return;
- x1a = (struct s_x1*)malloc( sizeof(struct s_x1) );
+ x1a = (struct s_x1*)lemon_malloc( sizeof(struct s_x1) );
if( x1a ){
x1a->size = 1024;
x1a->count = 0;
- x1a->tbl = (x1node*)calloc(1024, sizeof(x1node) + sizeof(x1node*));
+ x1a->tbl = (x1node*)lemon_calloc(1024, sizeof(x1node) + sizeof(x1node*));
if( x1a->tbl==0 ){
- free(x1a);
+ lemon_free(x1a);
x1a = 0;
}else{
int i;
struct s_x1 array;
array.size = arrSize = x1a->size*2;
array.count = x1a->count;
- array.tbl = (x1node*)calloc(arrSize, sizeof(x1node) + sizeof(x1node*));
+ array.tbl = (x1node*)lemon_calloc(arrSize, sizeof(x1node)+sizeof(x1node*));
if( array.tbl==0 ) return 0; /* Fail due to malloc failure */
array.ht = (x1node**)&(array.tbl[arrSize]);
for(i=0; i<arrSize; i++) array.ht[i] = 0;
newnp->from = &(array.ht[h]);
array.ht[h] = newnp;
}
- /* free(x1a->tbl); // This program was originally for 16-bit machines.
+ /* lemon_free(x1a->tbl); // This program was originally for 16-bit machines.
** Don't worry about freeing memory on modern platforms. */
*x1a = array;
}
sp = Symbol_find(x);
if( sp==0 ){
- sp = (struct symbol *)calloc(1, sizeof(struct symbol) );
+ sp = (struct symbol *)lemon_calloc(1, sizeof(struct symbol) );
MemoryCheck(sp);
sp->name = Strsafe(x);
sp->type = ISUPPER(*x) ? TERMINAL : NONTERMINAL;
/* Allocate a new associative array */
void Symbol_init(void){
if( x2a ) return;
- x2a = (struct s_x2*)malloc( sizeof(struct s_x2) );
+ x2a = (struct s_x2*)lemon_malloc( sizeof(struct s_x2) );
if( x2a ){
x2a->size = 128;
x2a->count = 0;
- x2a->tbl = (x2node*)calloc(128, sizeof(x2node) + sizeof(x2node*));
+ x2a->tbl = (x2node*)lemon_calloc(128, sizeof(x2node) + sizeof(x2node*));
if( x2a->tbl==0 ){
- free(x2a);
+ lemon_free(x2a);
x2a = 0;
}else{
int i;
struct s_x2 array;
array.size = arrSize = x2a->size*2;
array.count = x2a->count;
- array.tbl = (x2node*)calloc(arrSize, sizeof(x2node) + sizeof(x2node*));
+ array.tbl = (x2node*)lemon_calloc(arrSize, sizeof(x2node)+sizeof(x2node*));
if( array.tbl==0 ) return 0; /* Fail due to malloc failure */
array.ht = (x2node**)&(array.tbl[arrSize]);
for(i=0; i<arrSize; i++) array.ht[i] = 0;
newnp->from = &(array.ht[h]);
array.ht[h] = newnp;
}
- /* free(x2a->tbl); // This program was originally written for 16-bit
+ /* lemon_free(x2a->tbl); // This program was originally written for 16-bit
** machines. Don't worry about freeing this trivial amount of memory
** on modern platforms. Just leak it. */
*x2a = array;
int i,arrSize;
if( x2a==0 ) return 0;
arrSize = x2a->count;
- array = (struct symbol **)calloc(arrSize, sizeof(struct symbol *));
+ array = (struct symbol **)lemon_calloc(arrSize, sizeof(struct symbol *));
if( array ){
for(i=0; i<arrSize; i++) array[i] = x2a->tbl[i].data;
}
struct state *State_new()
{
struct state *newstate;
- newstate = (struct state *)calloc(1, sizeof(struct state) );
+ newstate = (struct state *)lemon_calloc(1, sizeof(struct state) );
MemoryCheck(newstate);
return newstate;
}
/* Allocate a new associative array */
void State_init(void){
if( x3a ) return;
- x3a = (struct s_x3*)malloc( sizeof(struct s_x3) );
+ x3a = (struct s_x3*)lemon_malloc( sizeof(struct s_x3) );
if( x3a ){
x3a->size = 128;
x3a->count = 0;
- x3a->tbl = (x3node*)calloc(128, sizeof(x3node) + sizeof(x3node*));
+ x3a->tbl = (x3node*)lemon_calloc(128, sizeof(x3node) + sizeof(x3node*));
if( x3a->tbl==0 ){
- free(x3a);
+ lemon_free(x3a);
x3a = 0;
}else{
int i;
struct s_x3 array;
array.size = arrSize = x3a->size*2;
array.count = x3a->count;
- array.tbl = (x3node*)calloc(arrSize, sizeof(x3node) + sizeof(x3node*));
+ array.tbl = (x3node*)lemon_calloc(arrSize, sizeof(x3node)+sizeof(x3node*));
if( array.tbl==0 ) return 0; /* Fail due to malloc failure */
array.ht = (x3node**)&(array.tbl[arrSize]);
for(i=0; i<arrSize; i++) array.ht[i] = 0;
newnp->from = &(array.ht[h]);
array.ht[h] = newnp;
}
- free(x3a->tbl);
+ lemon_free(x3a->tbl);
*x3a = array;
}
/* Insert the new data */
int i,arrSize;
if( x3a==0 ) return 0;
arrSize = x3a->count;
- array = (struct state **)calloc(arrSize, sizeof(struct state *));
+ array = (struct state **)lemon_calloc(arrSize, sizeof(struct state *));
if( array ){
for(i=0; i<arrSize; i++) array[i] = x3a->tbl[i].data;
}
/* Allocate a new associative array */
void Configtable_init(void){
if( x4a ) return;
- x4a = (struct s_x4*)malloc( sizeof(struct s_x4) );
+ x4a = (struct s_x4*)lemon_malloc( sizeof(struct s_x4) );
if( x4a ){
x4a->size = 64;
x4a->count = 0;
- x4a->tbl = (x4node*)calloc(64, sizeof(x4node) + sizeof(x4node*));
+ x4a->tbl = (x4node*)lemon_calloc(64, sizeof(x4node) + sizeof(x4node*));
if( x4a->tbl==0 ){
- free(x4a);
+ lemon_free(x4a);
x4a = 0;
}else{
int i;
struct s_x4 array;
array.size = arrSize = x4a->size*2;
array.count = x4a->count;
- array.tbl = (x4node*)calloc(arrSize, sizeof(x4node) + sizeof(x4node*));
+ array.tbl = (x4node*)lemon_calloc(arrSize,
+ sizeof(x4node) + sizeof(x4node*));
if( array.tbl==0 ) return 0; /* Fail due to malloc failure */
array.ht = (x4node**)&(array.tbl[arrSize]);
for(i=0; i<arrSize; i++) array.ht[i] = 0;
newnp->from = &(array.ht[h]);
array.ht[h] = newnp;
}
- /* free(x4a->tbl); // This code was originall written for 16-bit machines.
- ** on modern machines, don't worry about freeing this trival amount of
- ** memory. */
*x4a = array;
}
/* Insert the new data */
projects / thirdparty / sqlite.git / commitdiff
