/*  Pawn compiler - Error message system

  *  In fact a very simple system, using only 'panic mode'.

  *

  *  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>

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

   #include <io.h>

 #endif

 #if defined LINUX || defined __GNUC__

   #include <unistd.h>

 #endif

 #include <stdio.h>

 #include <stdlib.h>

 #include <stdarg.h>     /* ANSI standardized variable argument list functions */

 #include <string.h>

 #if defined FORTIFY

   #include <alloc/fortify.h>

 #endif

 #include "sc.h"

 #if defined _MSC_VER

   #pragma warning(push)

   #pragma warning(disable:4125)  /* decimal digit terminates octal escape sequence */

 #endif

 #include "sc5.scp"

 #if defined _MSC_VER

   #pragma warning(pop)

 #endif

 #define NUM_WARNINGS    (sizeof warnmsg / sizeof warnmsg[0])

 static unsigned char warndisable[(NUM_WARNINGS + 7) / 8]; /* 8 flags in a char */

 static int errflag;

 static int errstart;    /* line number at which the instruction started */

 static int errline;     /* forced line number for the error message */

 /*  error

  *

  *  Outputs an error message (note: msg is passed optionally).

  *  If an error is found, the variable "errflag" is set and subsequent

  *  errors are ignored until lex() finds a semicolumn or a keyword

  *  (lex() resets "errflag" in that case).

  *

  *  Global references: inpfname   (reffered to only)

  *                     fline      (reffered to only)

  *                     fcurrent   (reffered to only)

  *                     errflag    (altered)

  */

 SC_FUNC int error(int number,...)

 {

 static char *prefix[3]={ "error", "fatal error", "warning" };

 static int lastline,errorcount;

 static short lastfile;

   char *msg,*pre;

   va_list argptr;

   /* errflag is reset on each semicolon.

    * In a two-pass compiler, an error should not be reported twice. Therefore

    * the error reporting is enabled only in the second pass (and only when

    * actually producing output). Fatal errors may never be ignored.

    */

   if ((errflag || sc_status!=statWRITE) && (number<120 || number>=200))

     return 0;

   /* also check for disabled warnings */

   if (number>=200) {

     int index=(number-200)/8;

     int mask=1 << ((number-200)%8);

     if ((warndisable[index] & mask)!=0)

       return 0;

   } /* if */

   if (number<120){

     msg=errmsg[number-1];

     pre=prefix[0];

     errflag=TRUE;       /* set errflag (skip rest of erroneous expression) */

     errnum++;

   } else if (number<200){

     msg=fatalmsg[number-120];

     pre=prefix[1];

     errnum++;           /* a fatal error also counts as an error */

   } else {

     msg=warnmsg[number-200];

     pre=prefix[2];

     warnnum++;

   } /* if */

   assert(errstart<=fline);

   if (errline>0)

     errstart=errline;

   else

     errline=fline;

   assert(errstart<=errline);

   va_start(argptr,number);

   if (strlen(errfname)==0) {

     int start= (errstart==errline) ? -1 : errstart;

     if (pc_error(number,msg,inpfname,start,errline,argptr)) {

       if (outf!=NULL) {

         pc_closeasm(outf,TRUE);

         outf=NULL;

       } /* if */

       longjmp(errbuf,3);        /* user abort */

     } /* if */

   } else {

     FILE *fp=fopen(errfname,"a");

     if (fp!=NULL) {

       if (errstart>=0 && errstart!=errline)

         fprintf(fp,"%s(%d -- %d) : %s %03d: ",inpfname,errstart,errline,pre,number);

       else

         fprintf(fp,"%s(%d) : %s %03d: ",inpfname,errline,pre,number);

       vfprintf(fp,msg,argptr);

       fclose(fp);

     } /* if */

   } /* if */

   va_end(argptr);

   if (number>=120 && number<200 || errnum>25){

     if (strlen(errfname)==0) {

       va_start(argptr,number);

       pc_error(0,"\nCompilation aborted.",NULL,0,0,argptr);

       va_end(argptr);

     } /* if */

     if (outf!=NULL) {

       pc_closeasm(outf,TRUE);

       outf=NULL;

     } /* if */

     longjmp(errbuf,2);          /* fatal error, quit */

   } /* if */

   errline=-1;

   /* check whether we are seeing many errors on the same line */

   if ((errstart<0 && lastline!=fline) || lastline<errstart || lastline>fline || fcurrent!=lastfile)

     errorcount=0;

   lastline=fline;

   lastfile=fcurrent;

   if (number<200)

     errorcount++;

   if (errorcount>=3)

     error(127);         /* too many error/warning messages on one line */

   return 0;

 }

 SC_FUNC void errorset(int code,int line)

 {

   switch (code) {

   case sRESET:

     errflag=FALSE;      /* start reporting errors */

     break;

   case sFORCESET:

     errflag=TRUE;       /* stop reporting errors */

     break;

   case sEXPRMARK:

     errstart=fline;     /* save start line number */

     break;

   case sEXPRRELEASE:

     errstart=-1;        /* forget start line number */

     errline=-1;

     break;

   case sSETPOS:

     errline=line;

     break;

   } /* switch */

 }

 /* sc_enablewarning()

  * Enables or disables a warning (errors cannot be disabled).

  * Initially all warnings are enabled. The compiler does this by setting bits

  * for the *disabled* warnings and relying on the array to be zero-initialized.

  *

  * Parameter enable can be:

  *  o  0 for disable

  *  o  1 for enable

  *  o  2 for toggle

  */

 int pc_enablewarning(int number,int enable)

 {

   int index;

   unsigned char mask;

   if (number<200)

     return FALSE;       /* errors and fatal errors cannot be disabled */

   number -= 200;

   if (number>=NUM_WARNINGS)

     return FALSE;

   index=number/8;

   mask=(unsigned char)(1 << (number%8));

   switch (enable) {

   case 0:

     warndisable[index] |= mask;

     break;

   case 1:

     warndisable[index] &= (unsigned char)~mask;

     break;

   case 2:

     warndisable[index] ^= mask;

     break;

   } /* switch */

   return TRUE;

 }

 #undef SCPACK_TABLE