/*  Pawn compiler

  *

  *  Function and variable definition and declaration, statement parser.

  *

  *  Copyright (c) ITB CompuPhase, 1997-2006

  *

  *  This software is provided "as-is", without any express or implied warranty.

  *  In no event will the authors be held liable for any damages arising from

  *  the use of this software.

  *

  *  Permission is granted to anyone to use this software for any purpose,

  *  including commercial applications, and to alter it and redistribute it

  *  freely, subject to the following restrictions:

  *

  *  1.  The origin of this software must not be misrepresented; you must not

  *      claim that you wrote the original software. If you use this software in

  *      a product, an acknowledgment in the product documentation would be

  *      appreciated but is not required.

  *  2.  Altered source versions must be plainly marked as such, and must not be

  *      misrepresented as being the original software.

  *  3.  This notice may not be removed or altered from any source distribution.

  *

  *  Version: $Id$

  */

 #include <assert.h>

 #include <ctype.h>

 #include <limits.h>

 #include <stdarg.h>

 #include <stdio.h>

 #include <stdlib.h>

 #include <string.h>

 #if defined	__WIN32__ || defined _WIN32 || defined __MSDOS__

   #include <conio.h>

   #include <io.h>

 #endif

 #if defined LINUX || defined __FreeBSD__ || defined __OpenBSD__

   #include <sclinux.h>

   #include <binreloc.h> /* from BinReloc, see www.autopackage.org */

 #endif

 #if defined FORTIFY

   #include <alloc/fortify.h>

 #endif

 #if defined __BORLANDC__ || defined __WATCOMC__

   #include <dos.h>

   static unsigned total_drives; /* dummy variable */

   #define dos_setdrive(i)       _dos_setdrive(i,&total_drives)

 #elif defined _MSC_VER && defined _WIN32

   #include <direct.h>           /* for _chdrive() */

   #define dos_setdrive(i)       _chdrive(i)

 #endif

 #if defined __BORLANDC__

   #include <dir.h>              /* for chdir() */

 #elif defined __WATCOMC__

   #include <direct.h>           /* for chdir() */

 #endif

 #if defined __WIN32__ || defined _WIN32 || defined _Windows

   #include <windows.h>

 #endif

 #include <time.h>

 #include "lstring.h"

 #include "sc.h"

 #include "svn_version.h"

 #include "sctracker.h"

 #define VERSION_STR "3.2.3636"

 #define VERSION_INT 0x0302

 int pc_functag = 0;

 int pc_tag_string = 0;

 static void resetglobals(void);

 static void initglobals(void);

 static char *get_extension(char *filename);

 static void setopt(int argc,char **argv,char *oname,char *ename,char *pname,

                    char *rname,char *codepage);

 static void setconfig(char *root);

 static void setcaption(void);

 static void about(void);

 static void setconstants(void);

 static void parse(void);

 static void dumplits(void);

 static void dumpzero(int count);

 static void declfuncvar(int fpublic,int fstatic,int fstock,int fconst);

 static void declglb(char *firstname,int firsttag,int fpublic,int fstatic,

                     int stock,int fconst);

 static void declstructvar(char *firstname,int fpublic, pstruct_t *pstruct);

 static int declloc(int fstatic);

 static void decl_const(int table);

 static void declstruct();

 static void decl_enum(int table);

 static cell needsub(int *tag,constvalue **enumroot);

 static void initials(int ident,int tag,cell *size,int dim[],int numdim,

                      constvalue *enumroot);

 static cell initarray(int ident,int tag,int dim[],int numdim,int cur,

                       int startlit,int counteddim[],constvalue *lastdim,

                       constvalue *enumroot,int *errorfound);

 static cell initvector(int ident,int tag,cell size,int fillzero,

                        constvalue *enumroot,int *errorfound);

 static cell init(int ident,int *tag,int *errorfound);

 static int getstates(const char *funcname);

 static void attachstatelist(symbol *sym, int state_id);

 static void funcstub(int fnative);

 static int newfunc(char *firstname,int firsttag,int fpublic,int fstatic,int stock);

 static int declargs(symbol *sym,int chkshadow);

 static void doarg(char *name,int ident,int offset,int tags[],int numtags,

                   int fpublic,int fconst,int chkshadow,arginfo *arg);

 static void make_report(symbol *root,FILE *log,char *sourcefile);

 static void reduce_referrers(symbol *root);

 static long max_stacksize(symbol *root,int *recursion);

 static int testsymbols(symbol *root,int level,int testlabs,int testconst);

 static void destructsymbols(symbol *root,int level);

 static constvalue *find_constval_byval(constvalue *table,cell val);

 static symbol *fetchlab(char *name);

 static void statement(int *lastindent,int allow_decl);

 static void compound(int stmt_sameline,int starttok);

 static int test(int label,int parens,int invert);

 static int doexpr(int comma,int chkeffect,int allowarray,int mark_endexpr,

                   int *tag,symbol **symptr,int chkfuncresult);

 static int doexpr2(int comma,int chkeffect,int allowarray,int mark_endexpr,

 				  int *tag,symbol **symptr,int chkfuncresult,value *lval);

 static void doassert(void);

 static void doexit(void);

 static int doif(void);

 static int dowhile(void);

 static int dodo(void);

 static int dofor(void);

 static void doswitch(void);

 static void dogoto(void);

 static void dolabel(void);

 static void doreturn(void);

 static void dofuncenum(int listmode);

 static void dobreak(void);

 static void docont(void);

 static void dosleep(void);

 static void dostate(void);

 static void addwhile(int *ptr);

 static void delwhile(void);

 static int *readwhile(void);

 static void inst_datetime_defines(void);

 enum {

   TEST_PLAIN,           /* no parentheses */

   TEST_THEN,            /* '(' <expr> ')' or <expr> 'then' */

   TEST_DO,              /* '(' <expr> ')' or <expr> 'do' */

   TEST_OPT,             /* '(' <expr> ')' or <expr> */

 };

 static int norun      = 0;      /* the compiler never ran */

 static int autozero   = 1;      /* if 1 will zero out the variable, if 0 omit the zeroing */

 static int lastst     = 0;      /* last executed statement type */

 static int nestlevel  = 0;      /* number of active (open) compound statements */

 static int endlessloop= 0;      /* nesting level of endless loop */

 static int rettype    = 0;      /* the type that a "return" expression should have */

 static int skipinput  = 0;      /* number of lines to skip from the first input file */

 static int optproccall = TRUE;  /* support "procedure call" */

 static int verbosity  = 1;      /* verbosity level, 0=quiet, 1=normal, 2=verbose */

 static int sc_reparse = 0;      /* needs 3th parse because of changed prototypes? */

 static int sc_parsenum = 0;     /* number of the extra parses */

 static int wq[wqTABSZ];         /* "while queue", internal stack for nested loops */

 static int *wqptr;              /* pointer to next entry */

 #if !defined SC_LIGHT

   static char sc_rootpath[_MAX_PATH];

   static char *sc_documentation=NULL;/* main documentation */

 #endif

 #if defined	__WIN32__ || defined _WIN32 || defined _Windows

   static HWND hwndFinish = 0;

 #endif

 SC_VDECL int glbstringread = 0;

 char g_tmpfile[_MAX_PATH] = {0};

 /*  "main" of the compiler

  */

 #if defined __cplusplus

   extern "C"

 #endif

 int pc_compile(int argc, char *argv[])

 {

   int entry,i,jmpcode;

   int retcode;

   char incfname[_MAX_PATH];

   char reportname[_MAX_PATH];

   char codepage[MAXCODEPAGE+1];

   FILE *binf;

   void *inpfmark;

   int lcl_packstr,lcl_needsemicolon,lcl_tabsize;

   #if !defined SC_LIGHT

     int hdrsize=0;

   #endif

   char *ptr;

   /* set global variables to their initial value */

   binf=NULL;

   initglobals();

   errorset(sRESET,0);

   errorset(sEXPRRELEASE,0);

   lexinit();

   /* make sure that we clean up on a fatal error; do this before the first

    * call to error(). */

   if ((jmpcode=setjmp(errbuf))!=0)

     goto cleanup;

   /* allocate memory for fixed tables */

   inpfname=(char*)malloc(_MAX_PATH);

   if (inpfname==NULL)

     error(103);         /* insufficient memory */

   litq=(cell*)malloc(litmax*sizeof(cell));

   if (litq==NULL)

     error(103);         /* insufficient memory */

   if (!phopt_init())

     error(103);         /* insufficient memory */

   setopt(argc,argv,outfname,errfname,incfname,reportname,codepage);

   strcpy(binfname,outfname);

   ptr=get_extension(binfname);

   if (ptr!=NULL && stricmp(ptr,".asm")==0)

     set_extension(binfname,".smx",TRUE);

   else

     set_extension(binfname,".smx",FALSE);

   /* set output names that depend on the input name */

   if (sc_listing)

     set_extension(outfname,".lst",TRUE);

   else

     set_extension(outfname,".asm",TRUE);

   if (strlen(errfname)!=0)

     remove(errfname);   /* delete file on startup */

   else if (verbosity>0)

     setcaption();

   setconfig(argv[0]);   /* the path to the include and codepage files */

   sc_ctrlchar_org=sc_ctrlchar;

   lcl_packstr=sc_packstr;

   lcl_needsemicolon=sc_needsemicolon;

   lcl_tabsize=sc_tabsize;

   #if !defined NO_CODEPAGE

     if (!cp_set(codepage))      /* set codepage */

       error(108);               /* codepage mapping file not found */

   #endif

   /* optionally create a temporary input file that is a collection of all

    * input files

    */

   assert(get_sourcefile(0)!=NULL);  /* there must be at least one source file */

   if (get_sourcefile(1)!=NULL) {

     /* there are at least two or more source files */

     char *tname,*sname;

     FILE *ftmp,*fsrc;

     int fidx;

     #if defined	__WIN32__ || defined _WIN32

       tname=_tempnam(NULL,"pawn");

     #elif defined __MSDOS__ || defined _Windows

       tname=tempnam(NULL,"pawn");

     #elif defined(MACOS) && !defined(__MACH__)

       /* tempnam is not supported for the Macintosh CFM build. */

       error(104,get_sourcefile(1));

       tname=NULL;

       sname=NULL;

     #else

       tname=tempnam(NULL,"pawn");

     #endif

     ftmp=(FILE*)pc_createsrc(tname);

     for (fidx=0; (sname=get_sourcefile(fidx))!=NULL; fidx++) {

       unsigned char tstring[128];

       fsrc=(FILE*)pc_opensrc(sname);

       if (fsrc==NULL) {

         pc_closesrc(ftmp);

         remove(tname);

         strcpy(inpfname,sname); /* avoid invalid filename */

         error(100,sname);

       } /* if */

       pc_writesrc(ftmp,(unsigned char*)"#file \"");

       pc_writesrc(ftmp,(unsigned char*)sname);

       pc_writesrc(ftmp,(unsigned char*)"\"\n");

       while (!pc_eofsrc(fsrc) && pc_readsrc(fsrc,tstring,sizeof tstring)) {

         pc_writesrc(ftmp,tstring);

       } /* while */

       pc_closesrc(fsrc);

     } /* for */

     pc_closesrc(ftmp);

     strcpy(inpfname,tname);

 	strcpy(g_tmpfile,tname);

     free(tname);

   } else {

     strcpy(inpfname,get_sourcefile(0));

   } /* if */

   inpf_org=(FILE*)pc_opensrc(inpfname);

   if (inpf_org==NULL)

     error(100,inpfname);

   freading=TRUE;

   outf=(FILE*)pc_openasm(outfname); /* first write to assembler file (may be temporary) */

   if (outf==NULL)

     error(101,outfname);

   /* immediately open the binary file, for other programs to check */

   if (sc_asmfile || sc_listing) {

     binf=NULL;

   } else {

     binf=(FILE*)pc_openbin(binfname);

     if (binf==NULL)

       error(101,binfname);

   } /* if */

   setconstants();               /* set predefined constants and tagnames */

   for (i=0; i<skipinput; i++)   /* skip lines in the input file */

     if (pc_readsrc(inpf_org,pline,sLINEMAX)!=NULL)

       fline++;                  /* keep line number up to date */

   skipinput=fline;

   sc_status=statFIRST;

   /* write starting options (from the command line or the configuration file) */

   if (sc_listing) {

     char string[150];

     sprintf(string,"#pragma ctrlchar 0x%02x\n"

                    "#pragma pack %s\n"

                    "#pragma semicolon %s\n"

                    "#pragma tabsize %d\n",

             sc_ctrlchar,

             sc_packstr ? "true" : "false",

             sc_needsemicolon ? "true" : "false",

             sc_tabsize);

     pc_writeasm(outf,string);

     setfiledirect(inpfname);

   } /* if */

   /* do the first pass through the file (or possibly two or more "first passes") */

   sc_parsenum=0;

   inpfmark=pc_getpossrc(inpf_org);

   do {

     /* reset "defined" flag of all functions and global variables */

     reduce_referrers(&glbtab);

     delete_symbols(&glbtab,0,TRUE,FALSE);

     #if !defined NO_DEFINE

       delete_substtable();

       inst_datetime_defines();

     #endif

     resetglobals();

     pstructs_free();

 	funcenums_free();

     sc_ctrlchar=sc_ctrlchar_org;

     sc_packstr=lcl_packstr;

     sc_needsemicolon=lcl_needsemicolon;

     sc_tabsize=lcl_tabsize;

     errorset(sRESET,0);

     /* reset the source file */

     inpf=inpf_org;

     freading=TRUE;

     pc_resetsrc(inpf,inpfmark); /* reset file position */

     fline=skipinput;            /* reset line number */

     sc_reparse=FALSE;           /* assume no extra passes */

     sc_status=statFIRST;        /* resetglobals() resets it to IDLE */

     if (strlen(incfname)>0) {

       if (strcmp(incfname,sDEF_PREFIX)==0) {

         plungefile(incfname,FALSE,TRUE);    /* parse "default.inc" */

       } else {

         if (!plungequalifiedfile(incfname)) /* parse "prefix" include file */

           error(100,incfname);          /* cannot read from ... (fatal error) */

       } /* if */

     } /* if */

     preprocess();                       /* fetch first line */

     parse();                            /* process all input */

     sc_parsenum++;

   } while (sc_reparse);

   /* second (or third) pass */

   sc_status=statWRITE;                  /* set, to enable warnings */

   state_conflict(&glbtab);

   /* write a report, if requested */

   #if !defined SC_LIGHT

     if (sc_makereport) {

       FILE *frep=stdout;

       if (strlen(reportname)>0)

         frep=fopen(reportname,"wb");    /* avoid translation of \n to \r\n in DOS/Windows */

       if (frep!=NULL) {

         make_report(&glbtab,frep,get_sourcefile(0));

         if (strlen(reportname)>0)

           fclose(frep);

       } /* if */

       if (sc_documentation!=NULL) {

         free(sc_documentation);

         sc_documentation=NULL;

       } /* if */

     } /* if */

   #endif

   if (sc_listing)

     goto cleanup;

   /* ??? for re-parsing the listing file instead of the original source

    * file (and doing preprocessing twice):

    * - close input file, close listing file

    * - re-open listing file for reading (inpf)

    * - open assembler file (outf)

    */

   /* reset "defined" flag of all functions and global variables */

   reduce_referrers(&glbtab);

   delete_symbols(&glbtab,0,TRUE,FALSE);

   funcenums_free();

   pstructs_free();

   #if !defined NO_DEFINE

     delete_substtable();

     inst_datetime_defines();

   #endif

   resetglobals();

   sc_ctrlchar=sc_ctrlchar_org;

   sc_packstr=lcl_packstr;

   sc_needsemicolon=lcl_needsemicolon;

   sc_tabsize=lcl_tabsize;

   errorset(sRESET,0);

   /* reset the source file */

   inpf=inpf_org;

   freading=TRUE;

   pc_resetsrc(inpf,inpfmark);   /* reset file position */

   fline=skipinput;              /* reset line number */

   lexinit();                    /* clear internal flags of lex() */

   sc_status=statWRITE;          /* allow to write --this variable was reset by resetglobals() */

   writeleader(&glbtab);

   insert_dbgfile(inpfname);

   if (strlen(incfname)>0) {

     if (strcmp(incfname,sDEF_PREFIX)==0)

       plungefile(incfname,FALSE,TRUE);  /* parse "default.inc" (again) */

     else

       plungequalifiedfile(incfname);    /* parse implicit include file (again) */

   } /* if */

   preprocess();                         /* fetch first line */

   parse();                              /* process all input */

   /* inpf is already closed when readline() attempts to pop of a file */

   writetrailer();                       /* write remaining stuff */

   entry=testsymbols(&glbtab,0,TRUE,FALSE);  /* test for unused or undefined

                                              * functions and variables */

   if (!entry)

     error(13);                  /* no entry point (no public functions) */

 cleanup:

   if (inpf!=NULL)               /* main source file is not closed, do it now */

     pc_closesrc(inpf);

   /* write the binary file (the file is already open) */

   if (!(sc_asmfile || sc_listing) && errnum==0 && jmpcode==0) {

     assert(binf!=NULL);

     pc_resetasm(outf);          /* flush and loop back, for reading */

     #if !defined SC_LIGHT

       hdrsize=

     #endif

     assemble(binf,outf);        /* assembler file is now input */

   } /* if */

   if (outf!=NULL) {

     pc_closeasm(outf,!(sc_asmfile || sc_listing));

     outf=NULL;

   } /* if */

   if (binf!=NULL) {

     pc_closebin(binf,errnum!=0);

     binf=NULL;

   } /* if */

   #if !defined SC_LIGHT

     if (errnum==0 && strlen(errfname)==0) {

       int recursion;

       long stacksize=max_stacksize(&glbtab,&recursion);

       int flag_exceed=0;

       if (pc_amxlimit>0) {

         long totalsize=hdrsize+code_idx;

         if (pc_amxram==0)

           totalsize+=(glb_declared+pc_stksize)*sizeof(cell);

         if (totalsize>=pc_amxlimit)

           flag_exceed=1;

       } /* if */

       if (pc_amxram>0 && (glb_declared+pc_stksize)*sizeof(cell)>=(unsigned long)pc_amxram)

         flag_exceed=1;

       if (!norun && (sc_debug & sSYMBOLIC)!=0 || verbosity>=2 || stacksize+32>=(long)pc_stksize || flag_exceed) {

         pc_printf("Header size:       %8ld bytes\n", (long)hdrsize);

         pc_printf("Code size:         %8ld bytes\n", (long)code_idx);

         pc_printf("Data size:         %8ld bytes\n", (long)glb_declared*sizeof(cell));

         pc_printf("Stack/heap size:   %8ld bytes; ", (long)pc_stksize*sizeof(cell));

         pc_printf("estimated max. usage");

         if (recursion)

           pc_printf(": unknown, due to recursion\n");

         else if ((pc_memflags & suSLEEP_INSTR)!=0)

           pc_printf(": unknown, due to the \"sleep\" instruction\n");

         else

           pc_printf("=%ld cells (%ld bytes)\n",stacksize,stacksize*sizeof(cell));

         pc_printf("Total requirements:%8ld bytes\n", (long)hdrsize+(long)code_idx+(long)glb_declared*sizeof(cell)+(long)pc_stksize*sizeof(cell));

       } /* if */

       if (flag_exceed)

         error(106,pc_amxlimit+pc_amxram); /* this causes a jump back to label "cleanup" */

     } /* if */

   #endif

   if (g_tmpfile[0] != '\0') {

     remove(g_tmpfile);

   }

   if (inpfname!=NULL) {

     free(inpfname);

   } /* if */

   if (litq!=NULL)

     free(litq);

   phopt_cleanup();

   stgbuffer_cleanup();

   clearstk();

   assert(jmpcode!=0 || loctab.next==NULL);/* on normal flow, local symbols

                                            * should already have been deleted */

   delete_symbols(&loctab,0,TRUE,TRUE);    /* delete local variables if not yet

                                            * done (i.e. on a fatal error) */

   delete_symbols(&glbtab,0,TRUE,TRUE);

   delete_consttable(&tagname_tab);

   delete_consttable(&libname_tab);

   delete_consttable(&sc_automaton_tab);

   delete_consttable(&sc_state_tab);

   state_deletetable();

   delete_aliastable();

   delete_pathtable();

   delete_sourcefiletable();

   delete_dbgstringtable();

   funcenums_free();

   pstructs_free();

   #if !defined NO_DEFINE

     delete_substtable();

   #endif

   #if !defined SC_LIGHT

     delete_docstringtable();

     if (sc_documentation!=NULL)

       free(sc_documentation);

   #endif

   delete_autolisttable();

   if (errnum!=0) {

     if (strlen(errfname)==0)

       pc_printf("\n%d Error%s.\n",errnum,(errnum>1) ? "s" : "");

     retcode=1;

   } else if (warnnum!=0){

     if (strlen(errfname)==0)

       pc_printf("\n%d Warning%s.\n",warnnum,(warnnum>1) ? "s" : "");

     retcode=0;          /* use "0", so that MAKE and similar tools continue */

   } else {

     retcode=jmpcode;

     if (retcode==0 && verbosity>=2)

       pc_printf("\nDone.\n");

   } /* if */

   #if defined	__WIN32__ || defined _WIN32 || defined _Windows

     if (IsWindow(hwndFinish))

       PostMessageA(hwndFinish,RegisterWindowMessageA("PawnNotify"),retcode,0L);

   #endif

   #if defined FORTIFY

     Fortify_ListAllMemory();

   #endif

   return retcode;

 }

 #if defined __cplusplus

   extern "C"

 #endif

 int pc_addconstant(char *name,cell value,int tag)

 {

   errorset(sFORCESET,0);        /* make sure error engine is silenced */

   sc_status=statIDLE;

   add_constant(name,value,sGLOBAL,tag);

   return 1;

 }

 static void inst_datetime_defines(void)

 {

   char date[64];

   char ltime[64];

   time_t td;

   struct tm *curtime;

   time(&td);

   curtime = localtime(&td);

   strftime(date, 31, "\"%m/%d%Y\"", curtime);

   strftime(ltime, 31, "\"%H:%M:%S\"", curtime);

   insert_subst("__DATE__", date, 8);

   insert_subst("__TIME__", ltime, 8);

 }

 #if defined __cplusplus

   extern "C"

 #endif

 int pc_addtag(char *name)

 {

   cell val;

   constvalue *ptr;

   int last,tag;

   if (name==NULL) {

     /* no tagname was given, check for one */

     if (lex(&val,&name)!=tLABEL) {

       lexpush();

       return 0;         /* untagged */

     } /* if */

   } /* if */

   assert(strchr(name,':')==NULL); /* colon should already have been stripped */

   last=0;

   ptr=tagname_tab.next;

   while (ptr!=NULL) {

     tag=(int)(ptr->value & TAGMASK);

     if (strcmp(name,ptr->name)==0)

       return tag;       /* tagname is known, return its sequence number */

     tag &= (int)~FIXEDTAG;

     tag &= (int)~FUNCTAG;

     if (tag>last)

       last=tag;

     ptr=ptr->next;

   } /* while */

   /* tagname currently unknown, add it */

   tag=last+1;           /* guaranteed not to exist already */

   if (isupper(*name))

     tag |= (int)FIXEDTAG;

   append_constval(&tagname_tab,name,(cell)tag,0);

   return tag;

 }

 int pc_addfunctag(char *name)

 {

   cell val;

   constvalue *ptr;

   int last,tag;

   if (name==NULL) {

     /* no tagname was given, check for one */

     if (lex(&val,&name)!=tLABEL) {

       lexpush();

       return 0;         /* untagged */

     } /* if */

   } /* if */

   assert(strchr(name,':')==NULL); /* colon should already have been stripped */

   last=0;

   ptr=tagname_tab.next;

   while (ptr!=NULL) {

     tag=(int)(ptr->value & TAGMASK);

     if (strcmp(name,ptr->name)==0)

       return tag;       /* tagname is known, return its sequence number */

     tag &= (int)~FIXEDTAG;

     tag &= (int)~FUNCTAG;

     if (tag>last)

       last=tag;

     ptr=ptr->next;

   } /* while */

   /* tagname currently unknown, add it */

   tag=last+1;           /* guaranteed not to exist already */

   if (isupper(*name))

     tag |= (int)FIXEDTAG;

   tag |= (int)FUNCTAG;

   append_constval(&tagname_tab,name,(cell)tag,0);

   return tag;

 }

 static void resetglobals(void)

 {

   /* reset the subset of global variables that is modified by the first pass */

   curfunc=NULL;         /* pointer to current function */

   lastst=0;             /* last executed statement type */

   nestlevel=0;          /* number of active (open) compound statements */

   rettype=0;            /* the type that a "return" expression should have */

   litidx=0;             /* index to literal table */

   stgidx=0;             /* index to the staging buffer */

   sc_labnum=0;          /* top value of (internal) labels */

   staging=0;            /* true if staging output */

   declared=0;           /* number of local cells declared */

   glb_declared=0;       /* number of global cells declared */

   code_idx=0;           /* number of bytes with generated code */

   ntv_funcid=0;         /* incremental number of native function */

   curseg=0;             /* 1 if currently parsing CODE, 2 if parsing DATA */

   freading=FALSE;       /* no input file ready yet */

   fline=0;              /* the line number in the current file */

   fnumber=0;            /* the file number in the file table (debugging) */

   fcurrent=0;           /* current file being processed (debugging) */

   sc_intest=FALSE;      /* true if inside a test */

   sideeffect=0;         /* true if an expression causes a side-effect */

   stmtindent=0;         /* current indent of the statement */

   indent_nowarn=FALSE;  /* do not skip warning "217 loose indentation" */

   sc_allowtags=TRUE;    /* allow/detect tagnames */

   sc_status=statIDLE;

   sc_allowproccall=FALSE;

   pc_addlibtable=TRUE;  /* by default, add a "library table" to the output file */

   sc_alignnext=FALSE;

   pc_docexpr=FALSE;

   pc_deprecate=NULL;

   sc_curstates=0;

   pc_memflags=0;

 }

 static void initglobals(void)

 {

   resetglobals();

   sc_asmfile=FALSE;     /* do not create .ASM file */

   sc_listing=FALSE;     /* do not create .LST file */

   skipinput=0;          /* number of lines to skip from the first input file */

   sc_ctrlchar=CTRL_CHAR;/* the escape character */

   litmax=sDEF_LITMAX;   /* current size of the literal table */

   errnum=0;             /* number of errors */

   warnnum=0;            /* number of warnings */

   optproccall=FALSE;    /* sourcemod: do not support "procedure call" */

   verbosity=1;          /* verbosity level, no copyright banner */

   sc_debug=sCHKBOUNDS|sSYMBOLIC;   /* sourcemod: full debug stuff */

   pc_optimize=sOPTIMIZE_DEFAULT;   /* sourcemod: full optimization */

   sc_packstr=TRUE;     /* strings are packed by default */

   sc_compress=FALSE;	/* always disable compact encoding! */

   sc_needsemicolon=FALSE;/* semicolon required to terminate expressions? */

   sc_dataalign=sizeof(cell);

   pc_stksize=sDEF_AMXSTACK;/* default stack size */

   pc_amxlimit=0;        /* no limit on size of the abstract machine */

   pc_amxram=0;          /* no limit on data size of the abstract machine */

   sc_tabsize=8;         /* assume a TAB is 8 spaces */

   sc_rationaltag=0;     /* assume no support for rational numbers */

   rational_digits=0;    /* number of fractional digits */

   outfname[0]='\0';     /* output file name */

   errfname[0]='\0';     /* error file name */

   inpf=NULL;            /* file read from */

   inpfname=NULL;        /* pointer to name of the file currently read from */

   outf=NULL;            /* file written to */

   litq=NULL;            /* the literal queue */

   glbtab.next=NULL;     /* clear global variables/constants table */

   loctab.next=NULL;     /*   "   local      "    /    "       "   */

   tagname_tab.next=NULL;/* tagname table */

   libname_tab.next=NULL;/* library table (#pragma library "..." syntax) */

   pline[0]='\0';        /* the line read from the input file */

   lptr=NULL;            /* points to the current position in "pline" */

   curlibrary=NULL;      /* current library */

   inpf_org=NULL;        /* main source file */

   wqptr=wq;             /* initialize while queue pointer */

 #if !defined SC_LIGHT

   sc_documentation=NULL;

   sc_makereport=FALSE;  /* do not generate a cross-reference report */

 #endif

 }

 static char *get_extension(char *filename)

 {

   char *ptr;

   assert(filename!=NULL);

   ptr=strrchr(filename,'.');

   if (ptr!=NULL) {

     /* ignore extension on a directory or at the start of the filename */

     if (strchr(ptr,DIRSEP_CHAR)!=NULL || ptr==filename || *(ptr-1)==DIRSEP_CHAR)

       ptr=NULL;

   } /* if */

   return ptr;

 }

 /* set_extension

  * Set the default extension, or force an extension. To erase the

  * extension of a filename, set "extension" to an empty string.

  */

 SC_FUNC void set_extension(char *filename,char *extension,int force)

 {

   char *ptr;

   assert(extension!=NULL && (*extension=='\0' || *extension=='.'));

   assert(filename!=NULL);

   ptr=get_extension(filename);

   if (force && ptr!=NULL)

     *ptr='\0';          /* set zero terminator at the position of the period */

   if (force || ptr==NULL)

     strcat(filename,extension);

 }

 static const char *option_value(const char *optptr)

 {

   return (*(optptr+1)=='=' || *(optptr+1)==':') ? optptr+2 : optptr+1;

 }

 static int toggle_option(const char *optptr, int option)

 {

   switch (*option_value(optptr)) {

   case '\0':

     option=!option;

     break;

   case '-':

     option=FALSE;

     break;

   case '+':

     option=TRUE;

     break;

   default:

     about();

   } /* switch */

   return option;

 }

 /* Parsing command line options is indirectly recursive: parseoptions()

  * calls parserespf() to handle options in a a response file and

  * parserespf() calls parseoptions() at its turn after having created

  * an "option list" from the contents of the file.

  */

 static void parserespf(char *filename,char *oname,char *ename,char *pname,

                        char *rname, char *codepage);

 static void parseoptions(int argc,char **argv,char *oname,char *ename,char *pname,

                          char *rname, char *codepage)

 {

   char str[_MAX_PATH],*name;

   const char *ptr;

   int arg,i,isoption;

   for (arg=1; arg<argc; arg++) {

     #if DIRSEP_CHAR=='/'

       isoption= argv[arg][0]=='-';

     #else

       isoption= argv[arg][0]=='/' || argv[arg][0]=='-';

     #endif

     if (isoption) {

       ptr=&argv[arg][1];

       switch (*ptr) {

       case 'A':

         i=atoi(option_value(ptr));

         if ((i % sizeof(cell))==0)

           sc_dataalign=i;

         else

           about();

         break;

       case 'a':

         if (*(ptr+1)!='\0')