开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
ERROR.C
资源名称：c_compiler.zip　[点击查看]
上传用户：hlzzc88
上传日期：2007-01-06
资源大小：220k
文件大小：30k
源码类别：

编译器/解释器

开发平台：

Others

ERROR.C：源码内容
  1. /*
  2.  * 68K/386 32-bit C compiler.
  3.  *
  4.  * copyright (c) 1997, 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 either the original sources or derived sources 
  11.  * are distributed along with any executables derived from the originals.
  12.  *
  13.  * The author is not responsible for any damages that may arise from use
  14.  * of this software, either idirect or consequential.
  15.  *
  16.  * v1.35 March 1997
  17.  * David Lindauer, gclind01@starbase.spd.louisville.edu
  18.  *
  19.  * Credits to Mathew Brandt for original K&R C compiler
  20.  *
  21.  */
  22. /* 
  23.  * error handler
  24.  */
  25. #include        <stdio.h>
  26. #include  <string.h>
  27. #include        "expr.h"
  28. #include        "c.h"
  29. #include        "errors.h"
  30. #include  "diag.h"
  32. extern int prm_errfile;
  33. extern FILE *errFile;
  34. extern int global_flag;
  35. extern FILE *listFile;
  36. extern int errlineno;
  37. extern char *errfile;
  38. extern int prm_asmfile;
  39. extern FILE *outputFile;
  40. extern int prm_maxerr;
  41. extern int prm_diag;
  42. extern int prm_listfile;
  43. extern int lastch;
  44. extern enum e_sym lastst;
  45. extern char lastid[];
  46. extern int lineno;
  47. extern FILE            *inclfile[10];  /* shared with preproc */
  48. extern int             incldepth;      /* shared with preproc */
  49. extern char *infile;
  50. extern SYM *currentfunc;
  51. extern int prm_warning,prm_cplusplus;
  53. int diagcount = 0;
  54. ERRORS *errlist = 0;
  55. static ERRORS *errtail = 0;
  56. static ERRORS *curerr = 0; 
  57. static char expectlist[] = { "########################=##############,:;#[]{}()" };
  58. static int errline;
  60. /* table of which warnings are enabled */
  61. char nowarn[ERR_MAX];
  62. /* table of warning keywords for the -w command line option
  63.  */
  64. char warnarray[ERR_MAX][4] = { 
  65. "all","","","","","","","",
  66. "","","","","","","","",
  67. "","","","","","","","",
  68. "","","","","","","","",
  69. "","","","","cln","","","",
  70. "","","","","","","","",
  71. "","","","","","ret","sun","sud",
  72. "sas","npo","urc","fun","cno","ieq","","nco",
  73. "lad","","","zer","dpc","nsf","lun","pro",
  74. "cnv","","irg","san","ssu","","","",
  75. "","","tua","","tui","","","",
  76. "","","","","","","","",
  77. "","","","","","suz","fsu","lli",
  78.   "","","","","","spc","","",
  79. "","","","","","","","",
  80.   "","","","","",""
  81. };
  82. int             total_errors = 0;
  83. void initerr(void)
  84. {
  85.                                 errlist = errtail = curerr = 0;
  86.         total_errors = 0;
  87.                                 diagcount  = 0;                 
  88. errline = 0;
  89. }
  90. /*
  91.  * handling for warnings on the command line
  92.  */
  93. void warning_setup(char select, char *string)
  94. {
  95. int bool = FALSE;
  96. while (*string) {
  97. int i;
  98. if (string[0] == '-') {
  99. bool = TRUE;
  100. string++;
  101. }
  102. else
  103. if (string[0] == '+')
  104. string++;
  105. for (i=0; i < ERR_MAX; i++)
  106. if (!strncmp(warnarray[i],string,3)) {
  107. if (i== 0) {
  108. int j;
  109. for (j =0; j < ERR_MAX; j++)
  110. nowarn[j] = (unsigned char)bool;
  111. }
  112. else
  113. nowarn[i] = (unsigned char)bool;
  114. string += 3;
  115. break;
  116. }
  117. if (i==ERR_MAX) {
  118. fatal("Invalid warning");
  119. }
  120. }
  121. }
  122. #ifdef DIAGNOSTICS
  123. void diag(char *s)
  124. /*
  125.  * internal diags come here
  126.  */
  127. { 
  128.         diagcount++;
  129.   if (prm_diag) {
  130.                 printf("DIAG - %sn",s);
  131.                 if (prm_errfile && errFile)
  132.                         fprintf(errFile,"/*DIAG - %s*/",s);
  133.                 if (prm_listfile && listFile)
  134.                         fprintf(listFile,"/*DIAG - %s*/",s);
  135.                 if (prm_asmfile)
  136.                         fprintf(outputFile,"DIAG - %sn",s);
  137.         }
  138. }
  139. #endif
  140. int printerr(char *buf, ERRORS *err)
  141. /*
  142.  * subroutine gets the error code and returns whether it is an error or
  143.  * warning
  144.  */
  145. {
  146.         int errlvl = 0;
  147.         switch (err->errornumber) {
  148. case ERR_NOCASE:
  149.                         sprintf(buf,"Expected 'case' or 'default'");
  150.                         break;
  151.                 case ERR_PUNCT:
  152.                         sprintf(buf,"Expected '%c'",expectlist[(int)err->data]);
  153.                         break;
  154.                 case ERR_INSERT:
  155.                         sprintf(buf,"Inserted '%c'",expectlist[(int)err->data]);
  156.                         break;
  157.                 case ERR_NEEDCHAR:
  158.                         sprintf(buf,"Expected '%c'",(char)err->data);
  159.                         break;
  160.                 case ERR_ILLCHAR:
  161.                         sprintf(buf,"Illegal character '%c'",(char)err->data);
  162.                         break;
  163.                 case ERR_NEEDCONST:
  164.                         sprintf(buf,"Constant value expected");
  165.                         break;
  166.                 case ERR_UNDEFINED:
  167.                         sprintf(buf,"Undefined symbol '%s'", (char *)err->data);
  168.                         break;
  169.                 case ERR_DUPSYM:
  170.                         sprintf(buf,"Duplicate symbol '%s'", (char *)err->data);
  171.                         break;
  172.                 case ERR_IDENTEXPECT:
  173.                         sprintf(buf,"Expected '%s'",(char *)err->data);
  174.                         break;
  175.                 case ERR_IDEXPECT:
  176.                         sprintf(buf,"Identifier expected");
  177.                         break;
  178.                 case ERR_INITSIZE:
  179.                         sprintf(buf,"Too many initializers");
  180.                         break;
  181.                 case ERR_NOINIT:
  182.                         sprintf(buf,"Cannot initialize '%s'",(char *)err->data);
  183.                         break;
  184.                 case ERR_PREPROCID:
  185.                         sprintf(buf,"Invalid preprocessor directive '%s'",(char *)err->data);
  186.                         break;
  187.                 case ERR_INCLFILE:
  188.                         sprintf(buf,"File name expected in #include directive");
  189.                         break;
  190.                 case ERR_CANTOPEN:
  191.                         sprintf(buf,"Cannot open file "%s" for read access",(char *)err->data);
  192.                         break;
  193.                 case ERR_ILLCLASS:
  194.                         sprintf(buf,"Illegal storage class specifier '%s'",(char *)err->data);
  195.                         break;
  196.                 case ERR_ILLCLASS2:
  197.                         sprintf(buf,"Illegal storage class specifier on '%s'",(char *)err->data);
  198.                         break;
  199.                 case ERR_DUPCASE:
  200.                         sprintf(buf,"Duplicate case %d",(int)err->data);
  201.                         break;
  202.                 case ERR_RETMISMATCH:
  203.                         sprintf(buf,"Type mismatch in return");
  204.                         break;
  205.                 case ERR_ARGMISMATCH:
  206.                         sprintf(buf,"Type mismatch in arg '%s'",(char *)err->data);
  207.                         break;
  208.                 case ERR_ARGLENSHORT:
  209.                         sprintf(buf,"Argument list too short in redeclaration of function '%s'",(char *)err->data);
  210.                         break;
  211.                 case ERR_ARGLENLONG:
  212.                         sprintf(buf,"Argument list too long in redeclaration of function '%s'",(char*)err->data);
  213.                         break;
  214.                 case ERR_DECLMISMATCH:
  215.                         sprintf(buf,"Type mismatch in redeclaration of '%s'",(char *)err->data);
  216.                         break;
  217.                 case ERR_CALLMISMATCH:
  218.                         sprintf(buf,"Type mismatch in arg %s",(char *)err->data);
  219.                         break;
  220.                 case ERR_CALLLENSHORT:
  221.                         sprintf(buf,"Argument list too short %s",(char *)err->data);
  222.                         break;
  223.                 case ERR_CALLLENLONG:
  224.                         sprintf(buf,"Argument list too long %s",(char *)err->data);
  225.                         errlvl = 1;
  226.                         break;
  227.                 case ERR_LABEL:
  228.                         sprintf(buf,"'%s' is not a label",(char *)err->data);
  229.                         break;
  230.                 case ERR_NOPOINTER:
  231.                         sprintf(buf,"Pointer type expected");
  232.                         break;
  233.                 case ERR_LVALUE:
  234.                         sprintf(buf,"Lvalue expected");
  235.                         break;
  236.                 case ERR_NOFUNC:
  237.                         sprintf(buf,"'%s' is not a function",(char *)err->data);
  238.                         break;
  239.                 case ERR_MISMATCH:
  240.                         sprintf(buf,"Type mismatch");
  241.                         break;
  242.                 case ERR_ELSE:
  243.                         sprintf(buf,"Misplaced else");
  244.                         break;
  245.                 case ERR_EXPREXPECT:
  246.                         sprintf(buf,"Expression expected");
  247.                         break;
  248.                 case ERR_DEREF:
  249.                         sprintf(buf,"Illegal pointer");
  250.                         break;
  251.                 case ERR_UNEXPECT:
  252.                         if (lastst == id)
  253.                                 sprintf(buf,"Unexpected '%s'",lastid);
  254.                         else
  255.                                 sprintf(buf,"Unexpected '%c'",lastch);
  256.                         break;
  257.                 case ERR_ILLTYPE:
  258.                         sprintf(buf,"Illegal typedef of '%s'",(char *)err->data);
  259.                         break;
  260.                 case ERR_ARRAYMISMATCH:
  261.                         sprintf(buf,"Non-scalar array index");
  262.                         break;
  263.                 case ERR_PREPROCMATCH:
  264.                         sprintf(buf,"Unbalanced preprocessor directives");
  265.                         break;
  266.                 case ERR_MACROSUBS:
  267.                         sprintf(buf,"Macro substitution error");
  268.                         break;
  269.                 case ERR_DECLEXPECT:
  270.                         sprintf(buf,"Declaration expected");
  271.                         break;
  272.                 case ERR_INVFLOAT:
  273.                         sprintf(buf,"Invalid floating point");
  274.                         break;
  275.                 case ERR_INVTRAP:
  276.                         sprintf(buf,"Invalid trap id");
  277.                         break;
  278.                 case ERR_BFILLEGAL:
  279.                         sprintf(buf,"Cannot use bit field as a non-member");
  280.                         break;
  281.                 case ERR_BFTOOBIG:
  282.                         sprintf(buf,"Bit field too big");
  283.                         break;
  284.                 case ERR_BFTYPE:
  285.                         sprintf(buf,"Bit field only allowed on scalar types");
  286.                         break;
  287.                 case ERR_ERROR:
  288.                         sprintf(buf,"User error: %s",(char *)err->data);
  289.                         break;
  290.                 case ERR_INTERP:
  291.                         sprintf(buf,"%s",(char *)err->data);
  292.                         break;
  293.                 case ERR_BFADDR:
  294.                         sprintf(buf,"Cannot take address of bit field");
  295.                         break;
  296.                 case ERR_MODCONS:
  297.                         sprintf(buf,"Cannot modify a const val");
  298.                         break;
  299.                 case ERR_SZTYPE:
  300.                         sprintf(buf,"Type expected in sizeof");
  301.                         break;
  302.                 case ERR_FUNCRETVAL:
  303.                         sprintf(buf,"Function should return a value");
  304.                         errlvl = 1;
  305.                         break;
  306.                 case ERR_STATICSYMUNUSED:
  307.                         sprintf(buf,"Static variable '%s' is declared but never used",(char *)err->data);
  308.                         errlvl = 1;
  309.                         break;
  310.                 case ERR_SYMUNUSED:
  311.                         sprintf(buf,"Variable '%s' is declared but never used",(char *)err->data);
  312.                         errlvl = 1;
  313.                         break;
  314.                 case ERR_FUNCUNUSED:
  315.                         sprintf(buf,"Static function '%s' is declared but never used",(char *)err->data);
  316.                         errlvl = 1;
  317.                         break;
  318.                 case ERR_SYMUNDEF:
  319.                         sprintf(buf,"Possible use of '%s' before assignment",(char *)err->data);
  320.                         errlvl = 1;
  321.                         break;
  322.                 case ERR_SYMASSIGNED:
  323.                         sprintf(buf,"Variable '%s' is possibly assigned a value which is never used",(char *)err->data);
  324.                         errlvl = 1;
  325.                         break;
  326.                 case ERR_NONPORT:
  327.                         sprintf(buf,"Nonportable pointer conversion");
  328.                         errlvl = 1;
  329.                         break;
  330.                 case ERR_UNREACHABLE:
  331.                         sprintf(buf,"Unreachable code");
  332.                         errlvl = 1;
  333.                         break;
  334. case ERR_CODENONE:
  335. sprintf(buf,"Code has no effect");
  336. errlvl = 1;
  337. break;
  338. case ERR_BADEQUATE:
  339. sprintf(buf,"Possible incorrect assignment");
  340. errlvl = 1;
  341. break;
  342. case ERR_NOANDREG:
  343. sprintf(buf,"Invalid '&' on register var '%s'",(char *)err->data);
  344. break;
  345. case ERR_NOCONTINUE:
  346. sprintf(buf,"Continue not allowed");
  347. break;
  348. case ERR_DUPLABEL:
  349. sprintf(buf,"Duplicate label '%s'",(char *)err->data);
  350. break;
  351. case ERR_NOFUNCARRAY:
  352. sprintf(buf,"Function cannot return array");
  353. break;
  354. case ERR_NOVOIDRET:
  355. sprintf(buf,"Return type is void");
  356. errlvl = 1;
  357. break;
  358. case ERR_ZEROSTORAGE:
  359. sprintf(buf,"No memory allocated for '%s'",(char *)err->data);
  360. errlvl = 1;
  361. break;
  362. case ERR_ZEROPTR:
  363. sprintf(buf,"Illegal use of void pointer");
  364. break;
  365. case ERR_SHORTPOINTER:
  366. sprintf(buf,"Dangerous pointer cast");
  367. errlvl = 1;
  368. break;
  369. case ERR_NOSTATICFUNC:
  370. sprintf(buf,"Nonexistant static func '%s'",(char *)err->data);
  371. break;
  372. case ERR_UNUSEDLABEL:
  373. errlvl = 1;
  374. sprintf(buf,"Unused label '%s'",(char *)err->data);
  375. break;
  376. case ERR_NOPROTO:
  377. sprintf(buf,"Call to function '%s' with no prototype",(char *)err->data);
  378. errlvl = prm_cplusplus==0;
  379. break;
  380. case ERR_LOSTCONV:
  381. sprintf(buf,"Conversion may truncate significant digits");
  382. errlvl = 1;
  383. break;
  384. case ERR_UNDEFLABEL:
  385. sprintf(buf,"Undefined label '%s'",(char *)err->data);
  386. break;
  387. case ERR_ILLREGISTER:
  388. sprintf(buf,"Illegal register var '%s'",(char *)err->data);
  389. errlvl = 1;
  390. break;
  391. case ERR_SUPERAND:
  392. sprintf(buf,"Possible superfluous &");
  393. errlvl = 1;
  394. break;
  395. case ERR_NODECLARE:
  396. sprintf(buf,"Declaration not allowed here");
  397. break;
  398. case ERR_NOMAIN:
  399. sprintf(buf,"Illegal call to main() from within program");
  400. break;
  401. case ERR_NOREF:
  402. sprintf(buf,"Illegal use of reference operator");
  403. break;
  404. case ERR_CANTREF:
  405. sprintf(buf,"Cannot define a pointer or reference to a reference");
  406. break;
  407. case ERR_TEMPUSED:
  408. sprintf(buf,"Temporary used for parameter %s",(char *)err->data);
  409. errlvl = 1;
  410. break;
  411. case ERR_REFMUSTINIT:
  412. sprintf(buf,"Reference variable '%s' must be initialized",(char *)err->data);
  413. break;
  414. case ERR_TEMPINIT:
  415. sprintf(buf,"Temporary used to initialize %s",(char *)err->data);
  416. errlvl = 1;
  417. break;
  418. case ERR_REFLVALUE:
  419. sprintf(buf,"Reference initialization needs lvalue");
  420. break;
  421. case ERR_REFNOCONS:
  422. sprintf(buf,"Reference member '%s' in a class with no constructors",(char *)err->data);
  423. break;
  424. case ERR_MISSINGDEFAULT:
  425. sprintf(buf,"Default missing after parameter '%s'",(char *)err->data);
  426. break;
  427. case ERR_AMBIGFUNC:
  428. sprintf(buf,"Ambiguity between %s",(char *)err->data);
  429. break;
  430. case ERR_NOLOCALDEFAULT:
  431. sprintf(buf,"Local variables may not be used as parameter defaults");
  432. break;
  433. case ERR_CPPMISMATCH:
  434. sprintf(buf,"Cannot cast %s",(char *)err->data);
  435. break;
  436. case ERR_NOOVERMAIN:
  437. sprintf(buf,"Cannot overload 'main'",(char *)err->data);
  438. break;
  439. case ERR_SWITCHINT:
  440. sprintf(buf,"Switch argument must be of integral type");
  441. break;
  442. case ERR_NOFUNCMATCH:
  443. sprintf(buf,"Could not find a match for '%s'",(char *)err->data);
  444. break;
  445. /*
  446. case ERR_PREDEFSTRUCT:
  447. sprintf(buf,"'%s' must be a predefined class or struct",(char *)err->data);
  448. break;
  449. case ERR_LOCALCLASS:
  450. sprintf(buf,"Local class functions not supported",(char *)err->data);
  451. break;
  452. case ERR_PUREDECL:
  453. sprintf(buf,"Illegal pure declaration syntzx of '%s'",(char *)err->data);
  454. break;
  455. case ERR_BADESTRUCT:
  456. sprintf(buf,"Destructor for class '%s' expected",(char *)err->data);
  457. break;
  458. case ERR_TYPECONSTRUCT:
  459. sprintf(buf,"Constructor/destructor must be untyped");
  460. break;
  461. case ERR_NOTYPEQUAL:
  462. sprintf(buf,"Variable '%s' cannot have a type qualifier",(char *)err->data);
  463. break;
  464. case ERR_NOTACLASS:
  465. sprintf(buf,"Variable '%s' is not a class instance",(char *)err->data);
  466. break;
  467. */                case ERR_SIZE:
  468. if (err->data)
  469.   sprintf(buf,"Size of '%s' is unknown or zero",(char *)err->data);
  470. else
  471.   sprintf(buf,"Size is unknown or zero");
  472. break;
  473. case ERR_NEVERSTRUCT:
  474. sprintf(buf,"Structure '%s' is undefined",(char *)err->data);
  475. errlvl = 1;
  476. break;
  478. case ERR_LONGLONG:
  479. sprintf(buf,"long long int type not supported, defaulting to long int");
  480. errlvl = 1;
  481. break;
  482. case ERR_UPDOWN:
  483. sprintf(buf,"Startup/rundown function '%s' is unknown or not a function",(char *)err->data);
  484. break;
  485. case ERR_INTBITFIELDS:
  486.                          sprintf(buf,"Bit fields must be signed or unsigned int");
  487. break;
  488. case ERR_COMMENTMATCH:
  489. sprintf(buf,"File ended with comment in progress");
  490. break;
  491. case ERR_PASCAL_NO_ELLIPSE:
  492. sprintf(buf,"Ellipse (...) not allowed in pascal declaration");
  493. break;
  494. case ERR_PASCAL_NO_INT:
  495. sprintf(buf,"_int keyword not allowed in pascal declaration");
  496. break;
  497.     case ERR_SUSPICIOUS:
  498. sprintf(buf,"Suspicious pointer conversion");
  499.   errlvl = 1;
  500. break;
  501.     case ERR_NOFUNCSTRUCT:
  502. sprintf(buf,"Function declaration not allowed here");
  503. break;
  504.     case ERR_STRINGTOOBIG:
  505. sprintf(buf,"String constant too long");
  506. break;
  507.     case ERR_CONSTTOOLARGE:
  508. sprintf(buf,"Numeric constant is too large");
  509. break;
  510. case ERR_MULTIPLEINIT:
  511.   sprintf(buf,"Multiple initialization for '%s'",(char *)err->data);
  512. break;
  513. case ERR_INVALIDSTRING:
  514.   sprintf(buf,"Invalid string operation");
  515. break;
  516. case ERR_AMODEEXPECT:
  517.   sprintf(buf,"Assembler: Address mode expected");
  518. break;
  519. case ERR_ASCALE:
  520.   sprintf(buf,"Assembler: Valid scale factor expected");
  521. break;
  522. case ERR_AINVINDXMODE:
  523.   sprintf(buf,"Assembler: Invalid indexing");
  524. break;
  525. case ERR_AILLADDRESS:
  526.   sprintf(buf,"Assembler: Invalid address mode");
  527. break;
  528. case ERR_ATOOMANYSPECS:
  529.   sprintf(buf,"Assembler: Too many specifiers");
  530. break;
  531. case ERR_ATOOMANYSEGS:
  532.   sprintf(buf,"Assembler: Too many segments");
  533. break;
  534. case ERR_AINVOP:
  535.   sprintf(buf,"Assembler: Invalid opcode");
  536. break;
  537. case ERR_AINVSIZE:
  538.   sprintf(buf,"Assembler: Size mismatch");
  539. break;
  540. case ERR_AUSELEA:
  541.   sprintf(buf,"Assembler: Must use LEA to take the address of a local variable");
  542. break;
  543. case ERR_ALABEXPECT:
  544.   sprintf(buf,"Assembler: Label expected");
  545. break;
  546. case ERR_ANEEDFP:
  547.   sprintf(buf,"Assembler: Floating point register expected");
  548. break;
  550.   default:
  551.                         sprintf(buf,"Error #%d",err->errornumber);
  552.                         break;
  553.         }
  554.         return errlvl;
  555. }
  556. void     lferror(void)
  557. /*
  558.  * sticck an error in the list file
  559.  */
  560. {  
  561.         char buf[100];
  562.         while(curerr) {
  563.                                                 int errlvl = printerr(buf,curerr);
  564.                                                 if (!errlvl) {
  565. if (prm_listfile)
  566.                                                         fprintf(listFile,"**** ERROR: %sn",buf);
  567. }
  568.                                                 else if (prm_warning) {
  569. if (prm_listfile)
  570.                                                         fprintf(listFile,"** WARNING: %sn",buf);
  571. }
  572.                                                 curerr = curerr->link;
  573.                                 }
  574.                                                 
  575. }
  576. void basicskim(int *skimlist)
  577. /*
  578.  * simple skim for a token with no nesting
  579.  */
  580. {
  581.                 int i;
  582.                 for (i=0;;i++) {
  583.                         if (lastst == skimlist[i] || lastst == eof)
  584.                                 break;
  585.                         if (skimlist[i] == 0) {
  586.                                 getsym();
  587.                                 i = 0;
  588.                         }
  589.                 }
  590. }
  591. /*
  592.  * the following routines do token skimming and keep track of parenthesis
  593.  * and brace nesting levels as well
  594.  */
  595. BALANCE *newbalance(BALANCE *bal)
  596. {
  597.         BALANCE *rv = xalloc(sizeof(BALANCE));
  598.         rv->back = bal;
  599.         rv->count = 0;
  600.         if (lastst == openpa)
  601.                 rv->type = BAL_PAREN;
  602.         else
  603.                 rv->type = BAL_BRACKET;
  604.         return(rv);
  605. }
  606. void setbalance(BALANCE **bal)
  607. {
  608.         if (*bal == 0)
  609.                 if (lastst = openpa || lastst == closepa)
  610.                         *bal = newbalance(*bal);
  611.                 else
  612.                         return;
  613.         switch (lastst) {
  614.                 case closepa:
  615.                                         while (*bal && (*bal)->type != BAL_PAREN) {
  616.                                                 (*bal) = (*bal)->back;
  617.                                         }
  618.                                         if (!((*bal)->type)--)
  619.                                                 (*bal) = (*bal)->back;
  620.                                         else return;    
  621.                 case closebr:
  622.                                         while (*bal && (*bal)->type != BAL_BRACKET) {
  623.                                                 (*bal) = (*bal)->back;
  624.                                         }
  625.                                         if (!((*bal)->type)--)
  626.                                                 (*bal) = (*bal)->back;
  627.                 case openpa:
  628.                                         if ((*bal)->type != BAL_PAREN)
  629.                                                 *bal = newbalance(*bal);
  630.                                         (*bal)->count++;
  631.                                         break;
  632.                                         
  633.                 case openbr:
  634.                                         if ((*bal)->type != BAL_BRACKET)
  635.                                                 *bal = newbalance(*bal);
  636.                                         (*bal)->count++;
  637.                                         break;
  638.         }
  639.         return;
  640. }
  641. void expskim(int *skimlist)
  642. {
  643.         BALANCE *bal = 0;
  644.         int i = 0;
  645.         for (i = 0; ; i++) {
  646.                 if (lastst == openpa || lastst == openbr) {
  647.                         setbalance(&bal);
  648.                         getsym();
  649.                 }
  650.                 else
  651.                         if (lastst == eof)
  652.                                 break;
  653.                         else
  654.                                 if (lastst == skimlist[i])
  655.                                         if (lastst == closepa || lastst == openpa) {
  656.                                                 if (!bal)
  657.                                                         break;
  658.                                                 setbalance(&bal);
  659.                                                 getsym();
  660.                                         }
  661.                                         else
  662.                                                 break;
  663.                                 else
  664.                                         if (skimlist[i] == 0) {
  665.                                                 i = 0;
  666.                                                 getsym();
  667.                                         }
  668.         }
  669.         
  670. }
  671. void basicerror(int n, void *data)
  672. /*
  673.  * standard routine for putting out an error
  674.  */
  675. {
  676.         char buf[100];
  677.         ERRORS *nexterr;
  678.         int errlvl,errored = 0;;
  679.         global_flag++;
  680.         nexterr = xalloc(sizeof(ERRORS));
  681.          global_flag--;
  682.          nexterr->errornumber = n;
  683.          nexterr->link = 0;
  684.          nexterr->data = data;
  685.         if (errlist == 0)
  686.                  errlist = errtail = nexterr;
  687.          else {
  688.                  errtail->link = nexterr;
  689.                  errtail = nexterr;
  690.         }
  691.         errlvl = printerr(buf, nexterr);
  692.         if (curerr == 0)
  693.                 curerr = nexterr;
  694.         if (!errlvl) {
  695. errline = lineno;
  696.                 fprintf(stdout,"Error   %s(%d):  %s",errfile,errlineno,buf);
  697. if (prm_errfile)
  698.                  fprintf(errFile,"Error   %s(%d):  %s",errfile,errlineno,buf);
  699. errored++;
  700.                 total_errors++;
  701.         }
  702.         else if (prm_warning && !nowarn[n] && (errline != lineno)) {
  703. errored++;
  704.                 fprintf(stdout,"Warning %s(%d):  %s",errfile,errlineno,buf);
  705. if (prm_errfile)
  706.                  fprintf(errFile,"Warning %s(%d):  %s",errfile,errlineno,buf);
  707. }
  708. if (errored) {
  709.          if (currentfunc) {
  710. unmangle(buf,currentfunc->name);
  711.                 fprintf(stdout," in function '%s'",buf);
  712. if (prm_errfile)
  713.                  fprintf(errFile," in function '%s'",buf);
  714. }
  715.          fputc('n',stdout);
  716. if (prm_errfile)
  717.          fputc('n',errFile);
  718. }
  719.   if (total_errors > prm_maxerr) {
  720.                 fatal("Too many errors");
  721.         }
  722. }
  723. void Error(char *string)
  724. /*
  725.  * some of the library functions required a generic error function
  726.  *
  727.  * we are remapping it to the C/C++ error routines
  728.  */
  729. {
  730.         basicerror(ERR_INTERP,(void *)string);
  731. }
  732. void generror(int n, int data, int *skimlist)
  733. /*
  734.  * most errors come here
  735.  */
  736. {                
  738.         basicerror(n,(void *)data);
  739.         if (skimlist) 
  740.                 basicskim(skimlist);
  741. }
  742. void gensymerror(int n, char *data)
  743. /*
  744.  * errors come here if the error has a symbol name
  745.  */
  746. {
  747. char buf[100];
  748. if (data)
  749. unmangle(buf,data);
  750. else
  751. buf[0] = 0;
  752.         global_flag++;
  753.         basicerror(n,(void *)litlate(buf));
  754.         global_flag--;
  755. }
  756. /*
  757.  * the next two functions are for reporting full C++ functions with
  758.  * the argument list types
  759.  */
  760. void genfuncerror(int n, char*func, char *data)
  761. {
  762. char buf[100],buf1[100],buf2[100];
  763. unmangle(buf1,func);
  764. if (data) {
  765. unmangle(buf2,data);
  766. buf[0] = ''';
  767. buf[1] = 0;
  768. strcat(buf,buf2);
  769. strcat(buf,"' ");
  770. }
  771. else
  772. buf[0] = 0;
  773. strcat(buf,"in call to function ");
  774. strcat(buf,"'");
  775. strcat(buf,buf1);
  776. strcat(buf,"'");
  777.         global_flag++;
  778.         basicerror(n,(void *)litlate(buf));
  779.         global_flag--;
  780. }
  781. void genfunc2error(int n, char*func, char *func2)
  782. {
  783. char buf[100],buf1[100],buf2[100];
  784. unmangle(buf1,func);
  785. unmangle(buf2,func2);
  786. buf[0] = ''';
  787. buf[1] = 0;
  788. strcpy(buf,buf2);
  789. strcat(buf,"'");
  790. strcat(buf," and ");
  791. strcat(buf,"'");
  792. strcat(buf,buf1);
  793. strcat(buf,"'");
  794.         global_flag++;
  795.         basicerror(n,(void *)litlate(buf));
  796.         global_flag--;
  797. }
  798. /*
  799.  * C++ errors for class names and type checking
  800.  */
  801. void genclasserror(int n, char *struc, char *elem)
  802. {
  803. char buf[100],buf1[100],buf2[100];
  804. unmangle(buf1,elem);
  805. unmangle(buf2,struc);
  806. buf[0] = ''';
  807. buf[1] = 0;
  808. strcpy(buf,buf2);
  809. strcat(buf,"::");
  810. strcat(buf,buf1);
  811. strcat(buf,"'");
  812.         global_flag++;
  813.         basicerror(n,(void *)litlate(buf));
  814.         global_flag--;
  815. }
  816. void genmismatcherror(TYP *tp1, TYP *tp2)
  817. {
  818. #ifdef CPLUSPLUS
  819. char buf[100],buf1[100],buf2[100];
  820. typenum(buf1,tp1);
  821. typenum(buf2,tp2);
  822. buf[0] = ''';
  823. buf[1] = 0;
  824. strcat(buf,buf1);
  825. strcat(buf,"'");
  826. strcat(buf," to ");
  827. strcat(buf,"'");
  828. strcat(buf,buf2);
  829. strcat(buf,"'");
  830.         global_flag++;
  831.         basicerror(ERR_CPPMISMATCH,(void *)litlate(buf));
  832.         global_flag--;
  833. #endif
  834. }
  835. /*
  836.  * various utilities for special case errors
  837.  */
  838. void expecttoken(int n, int *skimlist)
  839. {
  840.         if (skimlist)
  841.                 generror(ERR_PUNCT, n, skimlist);
  842.         else
  843.                 generror(ERR_INSERT, n, 0);
  844. }
  845. void generrorexp(int n, int data, int *skimlist)
  846. {                
  847.         basicerror(n,(void *)data);
  848.         if (skimlist) 
  849.                 expskim(skimlist);
  850. }
  851. void gensymerrorexp(int n, char *data)
  852. {
  853.         global_flag++;
  854.         basicerror(n,(void *)litlate(data));
  855.         global_flag--;
  856. }
  857. void expecttokenexp(int n, int *skimlist)
  858. {
  859.         if (skimlist)
  860.                 generrorexp(ERR_PUNCT, n, skimlist);
  861.         else
  862.                 generrorexp(ERR_INSERT, n, 0);
  863. }