home *** CD-ROM | disk | FTP | other *** search
/ CD Shareware Magazine 1996 December / CD_shareware_12-96.iso / DOS / Programa / CCDL122.ZIP / SOURCE / ERROR.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-06  |  25.3 KB  |  714 lines
  1. /*
  2.  * 68K/386 32-bit C compiler.
  3.  *
  4.  * copyright (c) 1996, David Lindauer
  5.  * 
  6.  * This compiler is intended for educational use.  It may not be used
  7.  * for profit without the express written consent of the author.
  8.  *
  9.  * It may be freely redistributed, as long as this notice remains intact
  10.  * and sources are distributed along with any executables derived from them.
  11.  *
  12.  * The author is not responsible for damages, either direct or consequential,
  13.  * that may arise from use of this software.
  14.  *
  15.  * v1.5 August 1996
  16.  * David Lindauer, gclind01@starbase.spd.louisville.edu
  17.  *
  18.  * Credits to Mathew Brandt for original K&R C compiler
  19.  *
  20.  */
  21. #include        <stdio.h>
  22. #include        "expr.h"
  23. #include        "c.h"
  24. #include        "gen.h"
  25. #include        "cglbdec.h"
  26.  
  27. extern FILE *tempfil;
  28. extern int prm_asmfile;
  29. extern FILE *outputFile;
  30. extern int prm_maxerr;
  31. extern int prm_diag;
  32. extern int prm_listfile;
  33. extern FILE            *inclfile[10];  /* shared with preproc */
  34. extern int             incldepth;      /* shared with preproc */
  35. extern char *infile;
  36. extern SYM *currentfunc;
  37. extern FILE *tempfil;
  38. extern int prm_warning,prm_cplusplus;
  39.  
  40. int diagcount = 0;
  41. static ERRORS *errlist = 0;
  42. static ERRORS *errtail = 0;
  43. static ERRORS *curerr = 0;
  44. static char expectlist[] = { "#############=###################,:;#[]{}()" };
  45. static int errline;
  46.  
  47. char nowarn[ERR_MAX] = { 
  48.  0,0,0,0,0,0,0,0,
  49.  0,0,0,0,0,0,0,0,
  50.  0,0,0,0,0,0,0,0,
  51.  0,0,0,0,0,0,0,0,
  52.  0,0,0,0,0,0,0,0,
  53.  0,0,0,0,0,0,0,0,
  54.  0,0,0,0,0,0,0,0,
  55.  0,0,0,0,0,0,0,0,
  56.  0,0,0,0,0,0,0,0,
  57.  0,0,0,0,0,0,0,0,
  58.  0,0,0,0,0,0,0,0,
  59.  0,0,0,0,
  60. };
  61. char warnarray[ERR_MAX][3] = { 
  62.     "all","","","","","","","",
  63.     "","","","","","","","",
  64.     "","","","","","","","",
  65.     "","","","","","","","",
  66.     "","","","","cln","","","",
  67.     "","","","","","","","",
  68.     "","","","","","ret","sun","sud",
  69.     "sas","npo","urc","fun","cno","ieq","","nco",
  70.     "lad","","","zer","dpc","nsf","lun","pro",
  71.     "cnv","","irg","san","ssu","","","",
  72.     "","","tua","","tui","","","",
  73.     "","","","","","","","",
  74.     "","","","",
  75. };
  76. int             total_errors = 0;
  77. void initerr(void)
  78. {
  79.                                 errlist = errtail = curerr = 0;
  80.         total_errors = 0;
  81.                                 diagcount  = 0;                 
  82.     errline = 0;
  83. }
  84. void warning_setup(char select, char *string)
  85. {
  86.     int bool = FALSE;
  87.     while (*string) {
  88.         int i;
  89.         if (string[0] == '-') {
  90.             bool = TRUE;
  91.             string++;
  92.         }
  93.         else
  94.             if (string[0] == '+')
  95.                 string++;
  96.         for (i=0; i < ERR_MAX; i++)
  97.             if (!strncmp(warnarray[i],string,3)) {
  98.                 if (i== 0) {
  99.                     int j;
  100.                     for (j =0; j < ERR_MAX; j++)
  101.                         nowarn[j] = bool;
  102.                 }
  103.                 else
  104.                     nowarn[i] = bool;
  105.                 string += 3;
  106.                 break;
  107.             }
  108.         if (i==ERR_MAX) {
  109.             fatal("Invalid warning");
  110.         }
  111.     }
  112. }
  113. void diag(char *s)
  114. { 
  115.         diagcount++;
  116.   if (prm_diag) {
  117.                 printf("DIAG - %s\n",s);
  118.                 if (prm_listfile && listFile)
  119.                         fprintf(listFile,"/*DIAG - %s*/",s);
  120.                 if (prm_asmfile)
  121. #ifdef i386
  122.                         fprintf(tempfil,"DIAG - %s\n",s);
  123. #else
  124.                         fprintf(outputFile,"DIAG - %s\n",s);
  125. #endif
  126.         }
  127. }
  128. int printerr(char *buf, ERRORS *err)
  129. {
  130.         int errlvl = 0;
  131.         switch (err->errno) {
  132.                 case ERR_PUNCT:
  133.                         sprintf(buf,"Expected '%c'",expectlist[(int)err->data]);
  134.                         break;
  135.                 case ERR_INSERT:
  136.                         sprintf(buf,"Inserted '%c'",expectlist[(int)err->data]);
  137.                         break;
  138.                 case ERR_NEEDCHAR:
  139.                         sprintf(buf,"Expected '%c'",(char)err->data);
  140.                         break;
  141.                 case ERR_ILLCHAR:
  142.                         sprintf(buf,"Illegal character '%c'",(char)err->data);
  143.                         break;
  144.                 case ERR_NEEDCONST:
  145.                         sprintf(buf,"Constant value expected");
  146.                         break;
  147.                 case ERR_UNDEFINED:
  148.                         sprintf(buf,"Undefined symbol '%s'", (char *)err->data);
  149.                         break;
  150.                 case ERR_DUPSYM:
  151.                         sprintf(buf,"Duplicate symbol '%s'", (char *)err->data);
  152.                         break;
  153.                 case ERR_IDENTEXPECT:
  154.                         sprintf(buf,"Expected '%s'",(char *)err->data);
  155.                         break;
  156.                 case ERR_IDEXPECT:
  157.                         sprintf(buf,"Identifier expected");
  158.                         break;
  159.                 case ERR_INITSIZE:
  160.                         sprintf(buf,"Too many initializers");
  161.                         break;
  162.                 case ERR_NOINIT:
  163.                         sprintf(buf,"Cannot initialize '%s'",(char *)err->data);
  164.                         break;
  165.                 case ERR_PREPROCID:
  166.                         sprintf(buf,"Invalid preprocessor directive '%s'",(char *)err->data);
  167.                         break;
  168.                 case ERR_INCLFILE:
  169.                         sprintf(buf,"File name expected in #include directive");
  170.                         break;
  171.                 case ERR_CANTOPEN:
  172.                         sprintf(buf,"Cannot open file \"%s\" for read access",(char *)err->data);
  173.                         break;
  174.                 case ERR_ILLCLASS:
  175.                         sprintf(buf,"Illegal storage class specifier '%s'",(char *)err->data);
  176.                         break;
  177.                 case ERR_ILLCLASS2:
  178.                         sprintf(buf,"Illegal storage class specifier on '%s'",(char *)err->data);
  179.                         break;
  180.                 case ERR_DUPCASE:
  181.                         sprintf(buf,"Duplicate case %d",(int)err->data);
  182.                         break;
  183.                 case ERR_RETMISMATCH:
  184.                         sprintf(buf,"Type mismatch in return");
  185.                         break;
  186.                 case ERR_ARGMISMATCH:
  187.                         sprintf(buf,"Type mismatch in arg '%s'",(char *)err->data);
  188.                         break;
  189.                 case ERR_ARGLENSHORT:
  190.                         sprintf(buf,"Argument list too short in redeclaration of function '%s'",(char *)err->data);
  191.                         break;
  192.                 case ERR_ARGLENLONG:
  193.                         sprintf(buf,"Argument list too long in redeclaration of function '%s'",(char*)err->data);
  194.                         break;
  195.                 case ERR_FUNCMISMATCH:
  196.                         sprintf(buf,"Type mismatch in redeclaration of function '%s'",(char *)err->data);
  197.                         break;
  198.                 case ERR_CALLMISMATCH:
  199.                         sprintf(buf,"Type mismatch in arg %s",(char *)err->data);
  200.                         break;
  201.                 case ERR_CALLLENSHORT:
  202.                         sprintf(buf,"Argument list too short %s",(char *)err->data);
  203.                         break;
  204.                 case ERR_CALLLENLONG:
  205.                         sprintf(buf,"Argument list too long %s",(char *)err->data);
  206.                         errlvl = 1;
  207.                         break;
  208.                 case ERR_LABEL:
  209.                         sprintf(buf,"'%s' is not a label",(char *)err->data);
  210.                         break;
  211.                 case ERR_NOPOINTER:
  212.                         sprintf(buf,"Pointer type expected");
  213.                         break;
  214.                 case ERR_LVALUE:
  215.                         sprintf(buf,"Lvalue expected");
  216.                         break;
  217.                 case ERR_NOFUNC:
  218.                         sprintf(buf,"'%s' is not a function",(char *)err->data);
  219.                         break;
  220.                 case ERR_MISMATCH:
  221.                         sprintf(buf,"Type mismatch");
  222.                         break;
  223.                 case ERR_ELSE:
  224.                         sprintf(buf,"Misplaced else");
  225.                         break;
  226.                 case ERR_EXPREXPECT:
  227.                         sprintf(buf,"Expression expected");
  228.                         break;
  229.                 case ERR_DEREF:
  230.                         sprintf(buf,"Illegal pointer");
  231.                         break;
  232.                 case ERR_UNEXPECT:
  233.                         if (lastst == id)
  234.                                 sprintf(buf,"Unexpected '%s'",lastid);
  235.                         else
  236.                                 sprintf(buf,"Unexpected '%c'",lastch);
  237.                         break;
  238.                 case ERR_ILLTYPE:
  239.                         sprintf(buf,"Illegal typedef of '%s'",(char *)err->data);
  240.                         break;
  241.                 case ERR_ARRAYMISMATCH:
  242.                         sprintf(buf,"Non-scalar array index");
  243.                         break;
  244.                 case ERR_PREPROCMATCH:
  245.                         sprintf(buf,"Unbalanced preprocessor directives");
  246.                         break;
  247.                 case ERR_MACROSUBS:
  248.                         sprintf(buf,"Macro substitution error");
  249.                         break;
  250.                 case ERR_DECLEXPECT:
  251.                         sprintf(buf,"Declaration expected");
  252.                         break;
  253.                 case ERR_INVFLOAT:
  254.                         sprintf(buf,"Invalid floating point");
  255.                         break;
  256.                 case ERR_INVTRAP:
  257.                         sprintf(buf,"Invalid trap id");
  258.                         break;
  259.                 case ERR_BFILLEGAL:
  260.                         sprintf(buf,"Can't use bit field here");
  261.                         break;
  262.                 case ERR_BFTOOBIG:
  263.                         sprintf(buf,"Bit field too big");
  264.                         break;
  265.                 case ERR_BFTYPE:
  266.                         sprintf(buf,"Bit field only allowed on scalar types");
  267.                         break;
  268.                 case ERR_ERROR:
  269.                         sprintf(buf,"User error: %s",(char *)err->data);
  270.                         break;
  271.                 case ERR_INTERP:
  272.                         sprintf(buf,"%s",(char *)err->data);
  273.                         break;
  274.                 case ERR_BFADDR:
  275.                         sprintf(buf,"Cannot take address of bit field");
  276.                         break;
  277.                 case ERR_MODCONS:
  278.                         sprintf(buf,"Cannot modify a const val");
  279.                         break;
  280.                 case ERR_SZTYPE:
  281.                         sprintf(buf,"Type expected in sizeof");
  282.                         break;
  283.                 case ERR_FUNCRETVAL:
  284.                         sprintf(buf,"Function should return a value");
  285.                         errlvl = 1;
  286.                         break;
  287.                 case ERR_STATICSYMUNUSED:
  288.                         sprintf(buf,"Static variable '%s' is declared but never used",(char *)err->data);
  289.                         errlvl = 1;
  290.                         break;
  291.                 case ERR_SYMUNUSED:
  292.                         sprintf(buf,"Variable '%s' is declared but never used",(char *)err->data);
  293.                         errlvl = 1;
  294.                         break;
  295.                 case ERR_FUNCUNUSED:
  296.                         sprintf(buf,"Static function '%s' is declared but never used",(char *)err->data);
  297.                         errlvl = 1;
  298.                         break;
  299.                 case ERR_SYMUNDEF:
  300.                         sprintf(buf,"Possible use of '%s' before assignment",(char *)err->data);
  301.                         errlvl = 1;
  302.                         break;
  303.                 case ERR_SYMASSIGNED:
  304.                         sprintf(buf,"Variable '%s' is assigned a value which is never used",(char *)err->data);
  305.                         errlvl = 1;
  306.                         break;
  307.                 case ERR_NONPORT:
  308.                         sprintf(buf,"Nonportable pointer conversion");
  309.                         errlvl = 1;
  310.                         break;
  311.                 case ERR_UNREACHABLE:
  312.                         sprintf(buf,"Unreachable code");
  313.                         errlvl = 1;
  314.                         break;
  315.                                 case ERR_CODENONE:
  316.                                                 sprintf(buf,"Code has no effect");
  317.                                                 errlvl = 1;
  318.                                                 break;
  319.                                 case ERR_BADEQUATE:
  320.                                                 sprintf(buf,"Possible incorrect assignment");
  321.                                                 errlvl = 1;
  322.                                                 break;
  323.                                 case ERR_NOANDREG:
  324.                                                 sprintf(buf,"Invalid '&' on register var '%s'",(char *)err->data);    
  325.                                                 break;
  326.                                 case ERR_NOCONTINUE:
  327.                                                 sprintf(buf,"Continue not allowed");    
  328.                                                 break;
  329.                                 case ERR_DUPLABEL:
  330.                                                 sprintf(buf,"Duplicate label '%s'",(char *)err->data);    
  331.                                                 break;
  332.                                 case ERR_NOFUNCARRAY:
  333.                                                 sprintf(buf,"Function cannot return array");    
  334.                                                 break;
  335.                                 case ERR_NOVOIDRET:
  336.                                                 sprintf(buf,"Return type is void");    
  337.                                                 errlvl = 1;
  338.                                                 break;
  339.                                 case ERR_ZEROSTORAGE:
  340.                                                 sprintf(buf,"No memory allocated for '%s'",(char *)err->data);    
  341.                                                 errlvl = 1;
  342.                                                 break;
  343.                                 case ERR_ZEROPTR:
  344.                                                 sprintf(buf,"Illegal use of void pointer");
  345.                                                 break;
  346.                                 case ERR_SHORTPOINTER:
  347.                                                 sprintf(buf,"Dangerous pointer cast");    
  348.                                                 errlvl = 1;
  349.                                                 break;
  350.                                 case ERR_NOSTATICFUNC:
  351.                                                 sprintf(buf,"Nonexistant static func '%s'",(char *)err->data);    
  352.                                                 break;
  353.                                 case ERR_UNUSEDLABEL:                                                
  354.                                                 errlvl = 1;
  355.                                                 sprintf(buf,"Unused label '%s'",(char *)err->data);    
  356.                                                 break;
  357.                                 case ERR_NOPROTO:
  358.                                                 sprintf(buf,"Call to function '%s' with no prototype",(char *)err->data);    
  359.                                                 errlvl = prm_cplusplus==0;
  360.                                                 break;
  361.                                 case ERR_LOSTCONV:
  362.                                                 sprintf(buf,"Conversion may truncate significant digits");    
  363.                                                 errlvl = 1;
  364.                                                 break;
  365.                                 case ERR_UNDEFLABEL:
  366.                                                 sprintf(buf,"Undefined label '%s'",(char *)err->data);    
  367.                                                 break;
  368.                                 case ERR_ILLREGISTER:
  369.                                                 sprintf(buf,"Illegal register var '%s'",(char *)err->data);
  370.                                                 errlvl = 1;
  371.                                                 break;
  372.                                 case ERR_SUPERAND:
  373.                                                 sprintf(buf,"Possible superfluous &");
  374.                                                 errlvl = 1;
  375.                                                 break;
  376.                                 case ERR_NODECLARE:
  377.                                                 sprintf(buf,"Declaration not allowed here");
  378.                                                 break;
  379.                                 case ERR_NOMAIN:
  380.                                                 sprintf(buf,"Illegal call to main() from within program");
  381.                                                 break;
  382.                                 case ERR_NOREF:
  383.                                                 sprintf(buf,"Illegal use of reference operator");
  384.                                                 break;
  385.                                 case ERR_CANTREF:
  386.                                                 sprintf(buf,"Cannot define a pointer or reference to a reference");
  387.                                                 break;
  388.                                 case ERR_TEMPUSED:
  389.                                                 sprintf(buf,"Temporary used for parameter %s",(char *)err->data);
  390.                                                 errlvl = 1;
  391.                                                 break;
  392.                                 case ERR_REFMUSTINIT:
  393.                                                 sprintf(buf,"Reference variable '%s' must be initialized",(char *)err->data);
  394.                                                 break;
  395.                                 case ERR_TEMPINIT:
  396.                                                 sprintf(buf,"Temporary used to initialize %s",(char *)err->data);
  397.                                                 errlvl = 1;
  398.                                                 break;
  399.                                 case ERR_REFLVALUE:
  400.                                                 sprintf(buf,"Reference initialization needs lvalue");
  401.                                                 break;
  402.                                 case ERR_REFNOCONS:
  403.                                                 sprintf(buf,"Reference member '%s' in a class with no constructors",(char *)err->data);
  404.                                                 break;
  405.                                 case ERR_MISSINGDEFAULT:
  406.                                                 sprintf(buf,"Default missing after parameter '%s'",(char *)err->data);
  407.                                                 break;
  408.                                 case ERR_AMBIGFUNC:
  409.                                                 sprintf(buf,"Ambiguity between %s",(char *)err->data);
  410.                                                 break;
  411.                                 case ERR_NOLOCALDEFAULT:
  412.                                                 sprintf(buf,"Local variables may not be used as parameter defaults");
  413.                                                 break;
  414.                                 case ERR_CPPMISMATCH:
  415.                                                 sprintf(buf,"Cannot cast %s",(char *)err->data);
  416.                                                 break;
  417.                                 case ERR_NOOVERMAIN:
  418.                                                 sprintf(buf,"Cannot overload 'main'",(char *)err->data);
  419.                                                 break;
  420.                                 case ERR_SWITCHINT:
  421.                                                 sprintf(buf,"Switch argument must be of integral type");
  422.                                                 break;
  423.                                 case ERR_NOFUNCMATCH:
  424.                                                 sprintf(buf,"Could not find a match for '%s'",(char *)err->data);
  425.                                                 break;
  426. /*
  427.                                 case ERR_PREDEFSTRUCT:
  428.                                                 sprintf(buf,"'%s' must be a predefined class or struct",(char *)err->data);
  429.                                                 break;
  430.                                 case ERR_LOCALCLASS:
  431.                                                 sprintf(buf,"Local class functions not supported",(char *)err->data);
  432.                                                 break;
  433.                                 case ERR_PUREDECL:
  434.                                                 sprintf(buf,"Illegal pure declaration syntzx of '%s'",(char *)err->data);
  435.                                                 break;
  436.                                 case ERR_BADESTRUCT:
  437.                                                 sprintf(buf,"Destructor for class '%s' expected",(char *)err->data);
  438.                                                 break;
  439.                                 case ERR_TYPECONSTRUCT:
  440.                                                 sprintf(buf,"Constructor/destructor must be untyped");
  441.                                                 break;
  442.                                 case ERR_NOTYPEQUAL:
  443.                                                 sprintf(buf,"Variable '%s' cannot have a type qualifier",(char *)err->data);
  444.                                                 break;
  445.                                 case ERR_NOTACLASS:
  446.                                                 sprintf(buf,"Variable '%s' is not a class instance",(char *)err->data);
  447.                                                 break;
  448. */                default:
  449.                         sprintf(buf,"Error #%d",err->errno);
  450.                         break;
  451.         }
  452.         return errlvl;
  453. }
  454. void     lferror(void)
  455. {  
  456.                                 char buf[100];
  457.         while(curerr) {
  458.                                                 int errlvl = printerr(buf,curerr);
  459.                                                 if (!errlvl)
  460.                                                         fprintf(listFile,"**** ERROR: %s",buf);
  461.                                                 else if (prm_warning)
  462.                                                         fprintf(listFile,"** WARNING: %s\n",buf);
  463.                                                 curerr = curerr->link;
  464.                                 }
  465.                                                 
  466. }
  467. void basicskim(int *skimlist)
  468. {
  469.                 int i = 0;
  470.                 for (i=0;;i++) {
  471.                         if (lastst == skimlist[i] || lastst == eof)
  472.                                 break;
  473.                         if (skimlist[i] == 0) {
  474.                                 getsym();
  475.                                 i = 0;
  476.                         }
  477.                 }
  478. }
  479. BALANCE *newbalance(BALANCE *bal)
  480. {
  481.         BALANCE *rv = xalloc(sizeof(BALANCE));
  482.         rv->back = bal;
  483.         rv->count = 0;
  484.         if (lastst == openpa)
  485.                 rv->type = BAL_PAREN;
  486.         else
  487.                 rv->type = BAL_BRACKET;
  488.         return(rv);
  489. }
  490. void setbalance(BALANCE **bal)
  491. {
  492.         if (bal == 0)
  493.                 if (lastst = openpa || lastst == closepa)
  494.                         *bal = newbalance(*bal);
  495.                 else
  496.                         return;
  497.         switch (lastst) {
  498.                 case closepa:
  499.                                         while (*bal && (*bal)->type != BAL_PAREN) {
  500.                                                 (*bal) = (*bal)->back;
  501.                                         }
  502.                                         if (!((*bal)->type)--)
  503.                                                 (*bal) = (*bal)->back;
  504.                                         else return;    
  505.                 case closebr:
  506.                                         while (*bal && (*bal)->type != BAL_BRACKET) {
  507.                                                 (*bal) = (*bal)->back;
  508.                                         }
  509.                                         if (!((*bal)->type)--)
  510.                                                 (*bal) = (*bal)->back;
  511.                 case openpa:
  512.                                         if ((*bal)->type != BAL_PAREN)
  513.                                                 *bal = newbalance(*bal);
  514.                                         (*bal)->count++;
  515.                                         break;
  516.                                         
  517.                 case openbr:
  518.                                         if ((*bal)->type != BAL_BRACKET)
  519.                                                 *bal = newbalance(*bal);
  520.                                         (*bal)->count++;
  521.                                         break;
  522.         }
  523.         return;
  524. }
  525. void expskim(int *skimlist)
  526. {
  527.         BALANCE *bal = 0;
  528.         int i = 0;
  529.         for (i = 0; ; i++) {
  530.                 if (lastst == openpa || lastst == openbr) {
  531.                         setbalance(&bal);
  532.                         getsym();
  533.                 }
  534.                 else
  535.                         if (lastst == eof)
  536.                                 break;
  537.                         else
  538.                                 if (lastst == skimlist[i])
  539.                                         if (lastst == closepa || lastst == openpa) {
  540.                                                 if (!bal)
  541.                                                         break;
  542.                                                 setbalance(&bal);
  543.                                                 getsym();
  544.                                         }
  545.                                         else
  546.                                                 break;
  547.                                 else
  548.                                         if (skimlist[i] == 0) {
  549.                                                 i = 0;
  550.                                                 getsym();
  551.                                         }
  552.         }
  553.         
  554. }
  555. void basicerror(int n, void *data)
  556. {
  557.         char buf[100];
  558.         ERRORS *nexterr;
  559.         int errlvl,errored = 0;;
  560.         global_flag++;
  561.             nexterr = xalloc(sizeof(ERRORS));
  562.             global_flag--;
  563.             nexterr->errno = n;
  564.             nexterr->link = 0;
  565.             nexterr->data = data;
  566.             if (errlist == 0)
  567.                     errlist = errtail = nexterr;
  568.             else {
  569.                     errtail->link = nexterr;
  570.                     errtail = nexterr;
  571.             }
  572.         errlvl = printerr(buf, nexterr);
  573.         if (curerr == 0)
  574.                 curerr = nexterr;
  575.         if (!errlvl) {
  576.                                 errline = lineno;
  577.                 fprintf(stdout,"Error   %s(%d):  %s",infile,lineno,buf);
  578.                                 errored++;
  579.                 total_errors++;
  580.         }
  581.         else if (prm_warning && !nowarn[n] && (errline != lineno)) {
  582.                                 errored++;
  583.                 fprintf(stdout,"Warning %s(%d):  %s",infile,lineno,buf);
  584.                 }
  585.                 if (errored) {
  586.             if (currentfunc) {
  587.                                 unmangle(buf,currentfunc->name);
  588.                 fprintf(stdout," in function '%s'",buf);
  589.                     }
  590.             fputc('\n',stdout);
  591.                 }
  592.   if (total_errors > prm_maxerr) {
  593. #ifdef i386
  594.                 fclose(tempfil);
  595. #endif
  596.                 fatal("Too many errors");
  597.         }
  598. }
  599. void Error(char *string)
  600. {
  601.         basicerror(ERR_INTERP,(void *)string);
  602. }
  603. void generror(int n, int data, int *skimlist)
  604. {                
  605.         basicerror(n,(void *)data);
  606.         if (skimlist) 
  607.                 basicskim(skimlist);
  608. }
  609. void gensymerror(int n, char *data)
  610. {
  611.                 char buf[100];
  612.                 unmangle(buf,data);
  613.         global_flag++;
  614.         basicerror(n,(void *)litlate(buf));
  615.         global_flag--;
  616. }
  617. void genfuncerror(int n, char*func, char *data)
  618. {
  619.                 char buf[100],buf1[100],buf2[100];
  620.                 unmangle(buf1,func);
  621.                 if (data) {
  622.                     unmangle(buf2,data);
  623.                     buf[0] = '\'';
  624.                     buf[1] = 0;
  625.                     strcat(buf,buf2);
  626.                     strcat(buf,"' ");
  627.                 }
  628.                 else
  629.                     buf[0] = 0;
  630.                 strcat(buf,"in call to function ");
  631.                 strcat(buf,"'");
  632.                 strcat(buf,buf1);
  633.                 strcat(buf,"'");
  634.         global_flag++;
  635.         basicerror(n,(void *)litlate(buf));
  636.         global_flag--;
  637. }
  638. void genfunc2error(int n, char*func, char *func2)
  639. {
  640.                 char buf[100],buf1[100],buf2[100];
  641.                 unmangle(buf1,func);
  642.                 unmangle(buf2,func2);
  643.                 buf[0] = '\'';
  644.                 buf[1] = 0;
  645.                 strcpy(buf,buf2);
  646.                 strcat(buf,"'");
  647.                 strcat(buf," and ");
  648.                 strcat(buf,"'");
  649.                 strcat(buf,buf1);
  650.                 strcat(buf,"'");
  651.         global_flag++;
  652.         basicerror(n,(void *)litlate(buf));
  653.         global_flag--;
  654. }
  655. void genclasserror(int n, char *struc, char *elem)
  656. {
  657.                 char buf[100],buf1[100],buf2[100];
  658.                 unmangle(buf1,elem);
  659.                 unmangle(buf2,struc);
  660.                 buf[0] = '\'';
  661.                 buf[1] = 0;
  662.                 strcpy(buf,buf2);
  663.                 strcat(buf,"::");
  664.                 strcat(buf,buf1);
  665.                 strcat(buf,"'");
  666.         global_flag++;
  667.         basicerror(n,(void *)litlate(buf));
  668.         global_flag--;
  669. }
  670. void genmismatcherror(TYP *tp1, TYP *tp2)
  671. {
  672.                 char buf[100],buf1[100],buf2[100];
  673.                 typenum(buf1,tp1);
  674.                 typenum(buf2,tp2);
  675.                 buf[0] = '\'';
  676.                 buf[1] = 0;
  677.                 strcat(buf,buf1);
  678.                 strcat(buf,"'");
  679.                 strcat(buf," to ");
  680.                 strcat(buf,"'");
  681.                 strcat(buf,buf2);
  682.                 strcat(buf,"'");
  683.         global_flag++;
  684.         basicerror(ERR_CPPMISMATCH,(void *)litlate(buf));
  685.         global_flag--;
  686. }
  687.  
  688.     
  689. void expecttoken(int n, int *skimlist)
  690. {
  691.         if (skimlist)
  692.                 generror(ERR_PUNCT, n, skimlist);
  693.         else
  694.                 generror(ERR_INSERT, n, 0);
  695. }
  696. void generrorexp(int n, int data, int *skimlist)
  697. {                
  698.         basicerror(n,(void *)data);
  699.         if (skimlist) 
  700.                 expskim(skimlist);
  701. }
  702. void gensymerrorexp(int n, char *data)
  703. {
  704.         global_flag++;
  705.         basicerror(n,(void *)litlate(data));
  706.         global_flag--;
  707. }
  708. void expecttokenexp(int n, int *skimlist)
  709. {
  710.         if (skimlist)
  711.                 generrorexp(ERR_PUNCT, n, skimlist);
  712.         else
  713.                 generrorexp(ERR_INSERT, n, 0);
  714. }