/*  Pawn compiler - File input, preprocessing and lexical analysis functions

  *

  *  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 <stdio.h>

 #include <stdlib.h>

 #include <string.h>

 #include <ctype.h>

 #include <math.h>

 #include "lstring.h"

 #include "sc.h"

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

   #include <sclinux.h>

 #endif

 #if defined FORTIFY

   #include <alloc/fortify.h>

 #endif

 /* flags for litchar() */

 #define RAWMODE         1

 #define UTF8MODE        2

 static cell litchar(const unsigned char **lptr,int flags);

 static symbol *find_symbol(const symbol *root,const char *name,int fnumber,int automaton,int *cmptag);

 static void substallpatterns(unsigned char *line,int buffersize);

 static int match(char *st,int end);

 static int alpha(char c);

 #define SKIPMODE      1 /* bit field in "#if" stack */

 #define PARSEMODE     2 /* bit field in "#if" stack */

 #define HANDLED_ELSE  4 /* bit field in "#if" stack */

 #define SKIPPING      (skiplevel>0 && (ifstack[skiplevel-1] & SKIPMODE)==SKIPMODE)

 static short icomment;  /* currently in multiline comment? */

 static char ifstack[sCOMP_STACK]; /* "#if" stack */

 static short iflevel;   /* nesting level if #if/#else/#endif */

 static short skiplevel; /* level at which we started skipping (including nested #if .. #endif) */

 static unsigned char term_expr[] = "";

 static int listline=-1; /* "current line" for the list file */

 /*  pushstk & popstk

  *

  *  Uses a LIFO stack to store information. The stack is used by doinclude(),

  *  doswitch() (to hold the state of "swactive") and some other routines.

  *

  *  Porting note: I made the bold assumption that an integer will not be

  *  larger than a pointer (it may be smaller). That is, the stack element

  *  is typedef'ed as a pointer type, but I also store integers on it. See

  *  SC.H for "stkitem"

  *

  *  Global references: stack,stkidx,stktop (private to pushstk(), popstk()

  *                     and clearstk())

  */

 static stkitem *stack=NULL;

 static int stkidx=0,stktop=0;

 SC_FUNC void pushstk(stkitem val)

 {

   assert(stkidx<=stktop);

   if (stkidx==stktop) {

     stkitem *newstack;

     int newsize= (stktop==0) ? 16 : 2*stktop;

     /* try to resize the stack */

     assert(newsize>stktop);

     newstack=(stkitem*)malloc(newsize*sizeof(stkitem));

     if (newstack==NULL)

       error(122,"parser stack");  /* stack overflow (recursive include?) */

     /* swap the stacks */

     memcpy(newstack,stack,stkidx*sizeof(stkitem));

     if (stack!=NULL)

       free(stack);

     stack=newstack;

     stktop=newsize;

   } /* if */

   assert(stkidx<stktop);

   stack[stkidx]=val;

   stkidx+=1;

 }

 SC_FUNC stkitem popstk(void)

 {

   if (stkidx==0) {

     stkitem s;

     s.i=-1;             /* stack is empty */

     return s;

   } /* if */

   stkidx--;

   assert(stack!=NULL);

   return stack[stkidx];

 }

 SC_FUNC void clearstk(void)

 {

   assert(stack!=NULL || stktop==0);

   if (stack!=NULL) {

     free(stack);

     stack=NULL;

     stktop=0;

   } /* if */

   assert(stktop==0);

 }

 SC_FUNC int plungequalifiedfile(char *name)

 {

 static char *extensions[] = { ".inc", ".p", ".pawn" };

   FILE *fp;

   char *ext;

   int ext_idx;

   ext_idx=0;

   do {

     fp=(FILE*)pc_opensrc(name);

     ext=strchr(name,'\0');      /* save position */

     if (fp==NULL) {

       /* try to append an extension */

       strcpy(ext,extensions[ext_idx]);

       fp=(FILE*)pc_opensrc(name);

       if (fp==NULL)

         *ext='\0';              /* on failure, restore filename */

     } /* if */

     ext_idx++;

   } while (fp==NULL && ext_idx<(sizeof extensions / sizeof extensions[0]));

   if (fp==NULL) {

     *ext='\0';                  /* restore filename */

     return FALSE;

   } /* if */

   PUSHSTK_P(inpf);

   PUSHSTK_P(inpfname);          /* pointer to current file name */

   PUSHSTK_P(curlibrary);

   PUSHSTK_I(iflevel);

   assert(!SKIPPING);

   assert(skiplevel==iflevel);   /* these two are always the same when "parsing" */

   PUSHSTK_I(sc_is_utf8);

   PUSHSTK_I(icomment);

   PUSHSTK_I(fcurrent);

   PUSHSTK_I(fline);

   inpfname=duplicatestring(name);/* set name of include file */

   if (inpfname==NULL)

     error(123);             /* insufficient memory */

   inpf=fp;                  /* set input file pointer to include file */

   fnumber++;

   fline=0;                  /* set current line number to 0 */

   fcurrent=fnumber;

   icomment=0;               /* not in a comment */

   insert_dbgfile(inpfname);

   setfiledirect(inpfname);

   listline=-1;              /* force a #line directive when changing the file */

   sc_is_utf8=(short)scan_utf8(inpf,name);

   return TRUE;

 }

 SC_FUNC int plungefile(char *name,int try_currentpath,int try_includepaths)

 {

   int result=FALSE;

   if (try_currentpath) {

     result=plungequalifiedfile(name);

     if (!result) {

       /* failed to open the file in the active directory, try to open the file

        * in the same directory as the current file --but first check whether

        * there is a (relative) path for the current file

        */

       char *ptr;

       if ((ptr=strrchr(inpfname,DIRSEP_CHAR))!=0) {

         int len=(int)(ptr-inpfname)+1;

         if (len+strlen(name)<_MAX_PATH) {

           char path[_MAX_PATH];

           strlcpy(path,inpfname,len+1);

           strlcat(path,name,sizeof path);

           result=plungequalifiedfile(path);

         } /* if */

       } /* if */

     } /* if */

   } /* if */

   if (try_includepaths && name[0]!=DIRSEP_CHAR) {

     int i;

     char *ptr;

     for (i=0; !result && (ptr=get_path(i))!=NULL; i++) {

       char path[_MAX_PATH];

       strlcpy(path,ptr,sizeof path);

       strlcat(path,name,sizeof path);

       result=plungequalifiedfile(path);

     } /* while */

   } /* if */

   return result;

 }

 static void check_empty(const unsigned char *lptr)

 {

   /* verifies that the string contains only whitespace */

   while (*lptr<=' ' && *lptr!='\0')

     lptr++;

   if (*lptr!='\0')

     error(38);          /* extra characters on line */

 }

 /*  doinclude

  *

  *  Gets the name of an include file, pushes the old file on the stack and

  *  sets some options. This routine doesn't use lex(), since lex() doesn't

  *  recognize file names (and directories).

  *

  *  Global references: inpf     (altered)

  *                     inpfname (altered)

  *                     fline    (altered)

  *                     lptr     (altered)

  */

 static void doinclude(int silent)

 {

   char name[_MAX_PATH];

   char symname[sNAMEMAX];

   char *ptr;

   char c;

   int i, result;

   while (*lptr<=' ' && *lptr!='\0')         /* skip leading whitespace */

     lptr++;

   if (*lptr=='<' || *lptr=='\"'){

     c=(char)((*lptr=='\"') ? '\"' : '>');   /* termination character */

     lptr++;

     while (*lptr<=' ' && *lptr!='\0')       /* skip whitespace after quote */

       lptr++;

   } else {

     c='\0';

   } /* if */

   i=0;

   while (*lptr!=c && *lptr!='\0' && i<sizeof name - 1)  /* find the end of the string */

     name[i++]=*lptr++;

   while (i>0 && name[i-1]<=' ')

     i--;                        /* strip trailing whitespace */

   assert(i>=0 && i<sizeof name);

   name[i]='\0';                 /* zero-terminate the string */

   if (*lptr!=c) {               /* verify correct string termination */

     error(37);                  /* invalid string */

     return;

   } /* if */

   if (c!='\0')

     check_empty(lptr+1);        /* verify that the rest of the line is whitespace */

   /* create a symbol from the name of the include file; this allows the system

    * to test for multiple inclusions

    */

   strcpy(symname,"_inc_");

   if ((ptr=strrchr(name,DIRSEP_CHAR))!=NULL)

     strlcat(symname,ptr+1,sizeof symname);

   else

     strlcat(symname,name,sizeof symname);

   if (find_symbol(&glbtab,symname,fcurrent,-1,NULL)==NULL) {

     /* constant is not present, so this file has not been included yet */

     /* Include files between "..." or without quotes are read from the current

      * directory, or from a list of "include directories". Include files

      * between <...> are only read from the list of include directories.

      */

     result=plungefile(name,(c!='>'),TRUE);

     if (result)

       add_constant(symname,1,sGLOBAL,0);

     else if (!silent)

       error(120,name);            /* cannot read from ... (fatal error) */

   } /* if */

 }

 /*  readline

  *

  *  Reads in a new line from the input file pointed to by "inpf". readline()

  *  concatenates lines that end with a \ with the next line. If no more data

  *  can be read from the file, readline() attempts to pop off the previous file

  *  from the stack. If that fails too, it sets "freading" to 0.

  *

  *  Global references: inpf,fline,inpfname,freading,icomment (altered)

  */

 static void readline(unsigned char *line)

 {

   int i,num,cont;

   unsigned char *ptr;

   if (lptr==term_expr)

     return;

   num=sLINEMAX;

   cont=FALSE;

   do {

     if (inpf==NULL || pc_eofsrc(inpf)) {

       if (cont)

         error(49);        /* invalid line continuation */

       if (inpf!=NULL && inpf!=inpf_org)

         pc_closesrc(inpf);

       i=POPSTK_I();

       if (i==-1) {        /* All's done; popstk() returns "stack is empty" */

         freading=FALSE;

         *line='\0';

         /* when there is nothing more to read, the #if/#else stack should

          * be empty and we should not be in a comment

          */

         assert(iflevel>=0);

         if (iflevel>0)

           error(1,"#endif","-end of file-");

         else if (icomment!=0)

           error(1,"*/","-end of file-");

         return;

       } /* if */

       fline=i;

       fcurrent=(short)POPSTK_I();

       icomment=(short)POPSTK_I();

       sc_is_utf8=(short)POPSTK_I();

       iflevel=(short)POPSTK_I();

       skiplevel=iflevel;        /* this condition held before including the file */

       assert(!SKIPPING);        /* idem ditto */

       curlibrary=(constvalue *)POPSTK_P();

       free(inpfname);           /* return memory allocated for the include file name */

       inpfname=(char *)POPSTK_P();

       inpf=(FILE *)POPSTK_P();

       insert_dbgfile(inpfname);

       setfiledirect(inpfname);

       listline=-1;              /* force a #line directive when changing the file */

     } /* if */

     if (pc_readsrc(inpf,line,num)==NULL) {

       *line='\0';     /* delete line */

       cont=FALSE;

     } else {

       /* check whether to erase leading spaces */

       if (cont) {

         unsigned char *ptr=line;

         while (*ptr<=' ' && *ptr!='\0')

           ptr++;

         if (ptr!=line)

           memmove(line,ptr,strlen((char*)ptr)+1);

       } /* if */

       cont=FALSE;

       /* check whether a full line was read */

       if (strchr((char*)line,'\n')==NULL && !pc_eofsrc(inpf))

         error(75);      /* line too long */

       /* check if the next line must be concatenated to this line */

       if ((ptr=(unsigned char*)strchr((char*)line,'\n'))==NULL)

         ptr=(unsigned char*)strchr((char*)line,'\r');

       if (ptr!=NULL && ptr>line) {

         assert(*(ptr+1)=='\0'); /* '\n' or '\r' should be last in the string */

         while (ptr>line && *ptr<=' ')

           ptr--;        /* skip trailing whitespace */

         if (*ptr=='\\') {

           cont=TRUE;

           /* set '\a' at the position of '\\' to make it possible to check

            * for a line continuation in a single line comment (error 49)

            */

           *ptr++='\a';

           *ptr='\0';    /* erase '\n' (and any trailing whitespace) */

         } /* if */

       } /* if */

       num-=strlen((char*)line);

       line+=strlen((char*)line);

     } /* if */

     fline+=1;

   } while (num>=0 && cont);

 }

 /*  stripcom

  *

  *  Replaces all comments from the line by space characters. It updates

  *  a global variable ("icomment") for multiline comments.

  *

  *  This routine also supports the C++ extension for single line comments.

  *  These comments are started with "//" and end at the end of the line.

  *

  *  The function also detects (and manages) "documentation comments". The

  *  global variable "icomment" is set to 2 for documentation comments.

  *

  *  Global references: icomment  (private to "stripcom")

  */

 static void stripcom(unsigned char *line)

 {

   char c;

   #if !defined SC_LIGHT

     #define COMMENT_LIMIT 100

     #define COMMENT_MARGIN 40   /* length of the longest word */

     char comment[COMMENT_LIMIT+COMMENT_MARGIN];

     int commentidx=0;

     int skipstar=TRUE;

     static int prev_singleline=FALSE;

     int singleline=prev_singleline;

     prev_singleline=FALSE;  /* preset */

   #endif

   while (*line){

     if (icomment!=0) {

       if (*line=='*' && *(line+1)=='/') {

         #if !defined SC_LIGHT

           if (icomment==2) {

             assert(commentidx<COMMENT_LIMIT+COMMENT_MARGIN);

             comment[commentidx]='\0';

             if (strlen(comment)>0)

               insert_docstring(comment);

           } /* if */

         #endif

         icomment=0;     /* comment has ended */

         *line=' ';      /* replace '*' and '/' characters by spaces */

         *(line+1)=' ';

         line+=2;

       } else {

         if (*line=='/' && *(line+1)=='*')

           error(216);   /* nested comment */

         #if !defined SC_LIGHT

           /* collect the comment characters in a string */

           if (icomment==2) {

             if (skipstar && (*line!='\0' && *line<=' ' || *line=='*')) {

               /* ignore leading whitespace and '*' characters */

             } else if (commentidx<COMMENT_LIMIT+COMMENT_MARGIN-1) {

               comment[commentidx++]=(char)((*line!='\n') ? *line : ' ');

               if (commentidx>COMMENT_LIMIT && *line!='\0' && *line<=' ') {

                 comment[commentidx]='\0';

                 insert_docstring(comment);

                 commentidx=0;

               } /* if */

               skipstar=FALSE;

             } /* if */

           } /* if */

         #endif

         *line=' ';      /* replace comments by spaces */

         line+=1;

       } /* if */

     } else {

       if (*line=='/' && *(line+1)=='*'){

         icomment=1;     /* start comment */

         #if !defined SC_LIGHT

           /* there must be two "*" behind the slash and then white space */

           if (*(line+2)=='*' && *(line+3)<=' ') {

             /* if we are not in a function, we must attach the previous block

              * to the global documentation

              */

             if (curfunc==NULL && get_docstring(0)!=NULL)

               sc_attachdocumentation(NULL);

             icomment=2; /* documentation comment */

           } /* if */

           commentidx=0;

           skipstar=TRUE;

         #endif

         *line=' ';      /* replace '/' and '*' characters by spaces */

         *(line+1)=' ';

         line+=2;

         if (icomment==2)

           *line++=' ';

       } else if (*line=='/' && *(line+1)=='/'){  /* comment to end of line */

         if (strchr((char*)line,'\a')!=NULL)

           error(49);    /* invalid line continuation */

         #if !defined SC_LIGHT

           if (*(line+2)=='/' && *(line+3)<=' ') {

             /* documentation comment */

             char *str=(char*)line+3;

             char *end;

             while (*str<=' ' && *str!='\0')

               str++;    /* skip leading whitespace */

             if ((end=strrchr(str,'\n'))!=NULL)

               *end='\0';/* erase trailing '\n' */

             /* if there is a disjunct block, we may need to attach the previous

              * block to the global documentation

              */

             if (!singleline && curfunc==NULL && get_docstring(0)!=NULL)

               sc_attachdocumentation(NULL);

             insert_docstring(str);

             prev_singleline=TRUE;

           } /* if */

         #endif

         *line++='\n';   /* put "newline" at first slash */

         *line='\0';     /* put "zero-terminator" at second slash */

       } else {

         if (*line=='\"' || *line=='\''){        /* leave literals unaltered */

           c=*line;      /* ending quote, single or double */

           line+=1;

           while ((*line!=c || *(line-1)==sc_ctrlchar) && *line!='\0')

             line+=1;

           line+=1;      /* skip final quote */

         } else {

           line+=1;

         } /* if */

       } /* if */

     } /* if */

   } /* while */

   #if !defined SC_LIGHT

     if (icomment==2) {

       assert(commentidx<COMMENT_LIMIT+COMMENT_MARGIN);

       comment[commentidx]='\0';

       if (strlen(comment)>0)

         insert_docstring(comment);

     } /* if */

   #endif

 }

 /*  btoi

  *

  *  Attempts to interpret a numeric symbol as a boolean value. On success

  *  it returns the number of characters processed (so the line pointer can be

  *  adjusted) and the value is stored in "val". Otherwise it returns 0 and

  *  "val" is garbage.

  *

  *  A boolean value must start with "0b"

  */

 static int btoi(cell *val,const unsigned char *curptr)

 {

   const unsigned char *ptr;

   *val=0;

   ptr=curptr;

   if (*ptr=='0' && *(ptr+1)=='b') {

     ptr+=2;

     while (*ptr=='0' || *ptr=='1' || *ptr=='_') {

       if (*ptr!='_')

         *val=(*val<<1) | (*ptr-'0');

       ptr++;

     } /* while */

   } else {

     return 0;

   } /* if */

   if (alphanum(*ptr))   /* number must be delimited by non-alphanumeric char */

     return 0;

   else

     return (int)(ptr-curptr);

 }

 /*  dtoi

  *

  *  Attempts to interpret a numeric symbol as a decimal value. On success

  *  it returns the number of characters processed and the value is stored in

  *  "val". Otherwise it returns 0 and "val" is garbage.

  */

 static int dtoi(cell *val,const unsigned char *curptr)

 {

   const unsigned char *ptr;

   *val=0;

   ptr=curptr;

   if (!isdigit(*ptr))   /* should start with digit */

     return 0;

   while (isdigit(*ptr) || *ptr=='_') {

     if (*ptr!='_')

       *val=(*val*10)+(*ptr-'0');

     ptr++;

   } /* while */

   if (alphanum(*ptr))   /* number must be delimited by non-alphanumerical */

     return 0;

   if (*ptr=='.' && isdigit(*(ptr+1)))

     return 0;           /* but a fractional part must not be present */

   return (int)(ptr-curptr);

 }

 /*  htoi

  *

  *  Attempts to interpret a numeric symbol as a hexadecimal value. On

  *  success it returns the number of characters processed and the value is

  *  stored in "val". Otherwise it return 0 and "val" is garbage.

  */

 static int htoi(cell *val,const unsigned char *curptr)

 {

   const unsigned char *ptr;

   *val=0;

   ptr=curptr;

   if (!isdigit(*ptr))   /* should start with digit */

     return 0;

   if (*ptr=='0' && *(ptr+1)=='x') {     /* C style hexadecimal notation */

     ptr+=2;

     while (ishex(*ptr) || *ptr=='_') {

       if (*ptr!='_') {

         assert(ishex(*ptr));

         *val= *val<<4;

         if (isdigit(*ptr))

           *val+= (*ptr-'0');

         else

           *val+= (tolower(*ptr)-'a'+10);

       } /* if */

       ptr++;

     } /* while */

   } else {

     return 0;

   } /* if */

   if (alphanum(*ptr))

     return 0;

   else

     return (int)(ptr-curptr);

 }

 #if defined __GNUC__

 static double pow10(int value)

 {

   double res=1.0;

   while (value>=4) {

     res*=10000.0;

     value-=5;

   } /* while */

   while (value>=2) {

     res*=100.0;

     value-=2;

   } /* while */

   while (value>=1) {

     res*=10.0;

     value-=1;

   } /* while */

   return res;

 }

 #endif

 /*  ftoi

  *

  *  Attempts to interpret a numeric symbol as a rational number, either as

  *  IEEE 754 single/double precision floating point or as a fixed point integer.

  *  On success it returns the number of characters processed and the value is

  *  stored in "val". Otherwise it returns 0 and "val" is unchanged.

  *

  *  Pawn has stricter definition for rational numbers than most:

  *  o  the value must start with a digit; ".5" is not a valid number, you

  *     should write "0.5"

  *  o  a period must appear in the value, even if an exponent is given; "2e3"

  *     is not a valid number, you should write "2.0e3"

  *  o  at least one digit must follow the period; "6." is not a valid number,

  *     you should write "6.0"

  */

 static int ftoi(cell *val,const unsigned char *curptr)

 {

   const unsigned char *ptr;

   double fnum,ffrac,fmult;

   unsigned long dnum,dbase;

   int i, ignore;

   assert(rational_digits>=0 && rational_digits<9);

   for (i=0,dbase=1; i<rational_digits; i++)

     dbase*=10;

   fnum=0.0;

   dnum=0L;

   ptr=curptr;

   if (!isdigit(*ptr))   /* should start with digit */

     return 0;

   while (isdigit(*ptr) || *ptr=='_') {

     if (*ptr!='_') {

       fnum=(fnum*10.0)+(*ptr-'0');

       dnum=(dnum*10L)+(*ptr-'0')*dbase;

     } /* if */

     ptr++;

   } /* while */

   if (*ptr!='.')

     return 0;           /* there must be a period */

   ptr++;

   if (!isdigit(*ptr))   /* there must be at least one digit after the dot */

     return 0;

   ffrac=0.0;

   fmult=1.0;

   ignore=FALSE;

   while (isdigit(*ptr) || *ptr=='_') {

     if (*ptr!='_') {

       ffrac=(ffrac*10.0)+(*ptr-'0');

       fmult=fmult/10.0;

       dbase /= 10L;

       dnum += (*ptr-'0')*dbase;

       if (dbase==0L && sc_rationaltag && rational_digits>0 && !ignore) {

         error(222);     /* number of digits exceeds rational number precision */

         ignore=TRUE;

       } /* if */

     } /* if */

     ptr++;

   } /* while */

   fnum += ffrac*fmult;  /* form the number so far */

   if (*ptr=='e') {      /* optional fractional part */

     int exp,sign;

     ptr++;

     if (*ptr=='-') {

       sign=-1;

       ptr++;

     } else {

       sign=1;

     } /* if */

     if (!isdigit(*ptr)) /* 'e' should be followed by a digit */

       return 0;

     exp=0;

     while (isdigit(*ptr)) {

       exp=(exp*10)+(*ptr-'0');

       ptr++;

     } /* while */

     #if defined __GNUC__

       fmult=pow10(exp*sign);

     #else

       fmult=pow(10,exp*sign);

     #endif

     fnum *= fmult;

     dnum *= (unsigned long)(fmult+0.5);

   } /* if */

   /* decide how to store the number */

   if (sc_rationaltag==0) {

     error(70);          /* rational number support was not enabled */

     *val=0;

   } else if (rational_digits==0) {

     /* floating point */

     #if PAWN_CELL_SIZE==32

       float value=(float)fnum;

       *val=*((cell *)&value);

       #if 0 /* SourceMod - not needed */

         /* I assume that the C/C++ compiler stores "float" values in IEEE 754

          * format (as mandated in the ANSI standard). Test this assumption

          * anyway.

          * Note: problems have been reported with GCC 3.2.x, version 3.3.x works.

          */

         { float test1 = 0.0, test2 = 50.0, test3 = -50.0;

           uint32_t bit = 1;

           /* test 0.0 == all bits 0 */

           assert(*(uint32_t*)&test1==0x00000000L);

           /* test sign & magnitude format */

           assert(((*(uint32_t*)&test2) ^ (*(uint32_t*)&test3)) == (bit << (PAWN_CELL_SIZE-1)));

           /* test a known value */

           assert(*(uint32_t*)&test2==0x42480000L);

         }

       #endif

     #elif PAWN_CELL_SIZE==64

       *val=*((cell *)&fnum);

       #if 0 /* SourceMod - not needed */

         /* I assume that the C/C++ compiler stores "double" values in IEEE 754

          * format (as mandated in the ANSI standard).

          */

         { float test1 = 0.0, test2 = 50.0, test3 = -50.0;

           uint64_t bit = 1;

           /* test 0.0 == all bits 0 */

           assert(*(uint64_t*)&test1==0x00000000L);

           /* test sign & magnitude format */

           assert(((*(uint64_t*)&test2) ^ (*(uint64_t*)&test3)) == (bit << (PAWN_CELL_SIZE-1)));

         }

       #endif

     #else

       #error Unsupported cell size

     #endif

   } else {

     /* fixed point */

     *val=(cell)dnum;

   } /* if */

   return (int)(ptr-curptr);

 }

 /*  number

  *

  *  Reads in a number (binary, decimal or hexadecimal). It returns the number

  *  of characters processed or 0 if the symbol couldn't be interpreted as a

  *  number (in this case the argument "val" remains unchanged). This routine

  *  relies on the 'early dropout' implementation of the logical or (||)

  *  operator.

  *

  *  Note: the routine doesn't check for a sign (+ or -). The - is checked

  *        for at "hier2()" (in fact, it is viewed as an operator, not as a

  *        sign) and the + is invalid (as in K&R C, and unlike ANSI C).

  */

 static int number(cell *val,const unsigned char *curptr)

 {

   int i;

   cell value;

   if ((i=btoi(&value,curptr))!=0      /* binary? */

       || (i=htoi(&value,curptr))!=0   /* hexadecimal? */

       || (i=dtoi(&value,curptr))!=0)  /* decimal? */

   {

     *val=value;

     return i;

   } else {

     return 0;                      /* else not a number */

   } /* if */

 }

 static void chrcat(char *str,char chr)

 {

   str=strchr(str,'\0');

   *str++=chr;

   *str='\0';

 }

 static int preproc_expr(cell *val,int *tag)

 {

   int result;

   int index;

   cell code_index;

   char *term;

   /* Disable staging; it should be disabled already because

    * expressions may not be cut off half-way between conditional

    * compilations. Reset the staging index, but keep the code

    * index.

    */

   if (stgget(&index,&code_index)) {

     error(57);                          /* unfinished expression */

     stgdel(0,code_index);

     stgset(FALSE);

   } /* if */

   assert((lptr-pline)<(int)strlen((char*)pline));   /* lptr must point inside the string */

   #if !defined NO_DEFINE

     /* preprocess the string */

     substallpatterns(pline,sLINEMAX);

     assert((lptr-pline)<(int)strlen((char*)pline)); /* lptr must STILL point inside the string */

   #endif

   /* append a special symbol to the string, so the expression

    * analyzer won't try to read a next line when it encounters

    * an end-of-line

    */

   assert(strlen((char*)pline)<sLINEMAX);

   term=strchr((char*)pline,'\0');

   assert(term!=NULL);

   chrcat((char*)pline,PREPROC_TERM);    /* the "DEL" code (see SC.H) */

   result=constexpr(val,tag,NULL);       /* get value (or 0 on error) */

   *term='\0';                           /* erase the token (if still present) */

   lexclr(FALSE);                        /* clear any "pushed" tokens */

   return result;

 }

 /* getstring

  * Returns returns a pointer behind the closing quote or to the other

  * character that caused the input to be ended.

  */

 static const unsigned char *getstring(unsigned char *dest,int max,const unsigned char *line)

 {

   assert(dest!=NULL && line!=NULL);

   *dest='\0';

   while (*line<=' ' && *line!='\0')

     line++;             /* skip whitespace */

   if (*line=='"') {

     int len=0;

     line++;             /* skip " */

     while (*line!='"' && *line!='\0') {

       if (len<max-1)

         dest[len++]=*line;

       line++;

     } /* if */

     dest[len]='\0';

     if (*line=='"')

       line++;           /* skip closing " */

     else

       error(37);        /* invalid string */

   } else {

     error(37);          /* invalid string */

   } /* if */

   return line;

 }

 enum {

   CMD_NONE,

   CMD_TERM,

   CMD_EMPTYLINE,

   CMD_CONDFALSE,

   CMD_INCLUDE,

   CMD_DEFINE,

   CMD_IF,

   CMD_DIRECTIVE,

 };

 /*  command

  *

  *  Recognizes the compiler directives. The function returns:

  *     CMD_NONE         the line must be processed

  *     CMD_TERM         a pending expression must be completed before processing further lines

  *     Other value: the line must be skipped, because:

  *     CMD_CONDFALSE    false "#if.." code

  *     CMD_EMPTYLINE    line is empty

  *     CMD_INCLUDE      the line contains a #include directive

  *     CMD_DEFINE       the line contains a #subst directive

  *     CMD_IF           the line contains a #if/#else/#endif directive

  *     CMD_DIRECTIVE    the line contains some other compiler directive

  *

  *  Global variables: iflevel, ifstack (altered)

  *                    lptr      (altered)

  */

 static int command(void)

 {

   int tok,ret;

   cell val;

   char *str;

   int index;

   cell code_index;

   while (*lptr<=' ' && *lptr!='\0')

     lptr+=1;

   if (*lptr=='\0')