/*  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: sc2.c 3590 2006-06-24 14:16:39Z thiadmer $

 */

#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(102,"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(103);             /* 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(100,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 */