home *** CD-ROM | disk | FTP | other *** search
/ Acorn User 11 / AUCD11B.iso / LANGUAGES / WraithSet / AwkStuff / MawkSrc / c / error < prev    next >
Text File  |  1995-06-05  |  8KB  |  398 lines
  1.  
  2. /********************************************
  3. error.c
  4. copyright 1991, 1992 Michael D. Brennan
  5.  
  6. This is a source file for mawk, an implementation of
  7. the AWK programming language.
  8.  
  9. Mawk is distributed without warranty under the terms of
  10. the GNU General Public License, version 2, 1991.
  11. ********************************************/
  12.  
  13.  
  14. /* $Log: error.c,v $
  15.  * Revision 1.6  1995/06/06  00:18:22  mike
  16.  * change mawk_exit(1) to mawk_exit(2)
  17.  *
  18.  * Revision 1.5  1994/12/13  00:26:33  mike
  19.  * rt_nr and rt_fnr for run-time error messages
  20.  *
  21.  * Revision 1.4  1994/09/23  00:20:00  mike
  22.  * minor bug fix: handle \ in eat_nl()
  23.  *
  24.  * Revision 1.3  1993/07/17  13:22:49  mike
  25.  * indent and general code cleanup
  26.  *
  27.  * Revision 1.2  1993/07/04  12:51:44  mike
  28.  * start on autoconfig changes
  29.  *
  30.  * Revision 1.1.1.1  1993/07/03  18:58:11  mike
  31.  * move source to cvs
  32.  *
  33.  * Revision 5.3  1993/01/22  14:55:46  mike
  34.  * trivial change for unexpected_char()
  35.  *
  36.  * Revision 5.2  1992/10/02  23:26:04  mike
  37.  * using vargs.h
  38.  *
  39.  * Revision 5.1  1991/12/05  07:55:48  brennan
  40.  * 1.1 pre-release
  41.  *
  42. */
  43.  
  44.  
  45. #include  "mawk.h"
  46. #include  "scan.h"
  47. #include  "bi_vars.h"
  48. #include  "vargs.h"
  49.  
  50.  
  51. #ifndef  EOF
  52. #define  EOF  (-1)
  53. #endif
  54.  
  55. static void  PROTO( rt_where, (void) ) ;
  56. static void  PROTO( missing, (int, char *, int) ) ;
  57. static char *PROTO( type_to_str, (int) ) ;
  58.  
  59.  
  60. #ifdef  NO_VFPRINTF
  61. #define  vfprintf  simple_vfprintf
  62. #endif
  63.  
  64.  
  65. /* for run time error messages only */
  66. unsigned rt_nr , rt_fnr ;
  67.  
  68. static struct token_str  {
  69. short token ;
  70. char *str ; }  token_str[] = {
  71. EOF , "end of file" ,
  72. NL , "end of line",
  73. SEMI_COLON , ";" ,
  74. LBRACE , "{" ,
  75. RBRACE , "}" ,
  76. SC_FAKE_SEMI_COLON, "}",
  77. LPAREN , "(" ,
  78. RPAREN , ")" ,
  79. LBOX , "[",
  80. RBOX , "]",
  81. QMARK , "?",
  82. COLON , ":",
  83. OR, "||",
  84. AND, "&&",
  85. ASSIGN , "=" ,
  86. ADD_ASG, "+=",
  87. SUB_ASG, "-=",
  88. MUL_ASG, "*=",
  89. DIV_ASG, "/=",
  90. MOD_ASG, "%=",
  91. POW_ASG, "^=",
  92. EQ  , "==" ,
  93. NEQ , "!=",
  94. LT, "<" ,
  95. LTE, "<=" ,
  96. GT, ">",
  97. GTE, ">=" ,
  98. MATCH, string_buff,
  99. PLUS , "+" ,
  100. MINUS, "-" ,
  101. MUL , "*" ,
  102. DIV, "/"  , 
  103. MOD, "%" ,
  104. POW, "^" ,
  105. NOT, "!" ,
  106. COMMA, "," ,
  107. INC_or_DEC , string_buff ,
  108. DOUBLE  , string_buff ,
  109. STRING_  , string_buff ,
  110. ID  , string_buff ,
  111. FUNCT_ID  , string_buff ,
  112. BUILTIN  , string_buff ,
  113. IO_OUT , string_buff ,
  114. IO_IN, "<" ,
  115. PIPE, "|" ,
  116. DOLLAR, "$" ,
  117. FIELD, "$" ,
  118. 0, (char *) 0 } ;
  119.  
  120. /* if paren_cnt >0 and we see one of these, we are missing a ')' */
  121. static int missing_rparen[] =
  122. { EOF, NL, SEMI_COLON, SC_FAKE_SEMI_COLON, RBRACE, 0 } ;
  123.  
  124. /* ditto for '}' */
  125. static int missing_rbrace[] =
  126. { EOF, BEGIN, END , 0 } ;
  127.  
  128. static void missing( c, n , ln)
  129.   int c ;
  130.   char *n ;
  131.   int ln ;
  132. { char *s0, *s1 ;
  133.  
  134.   if ( pfile_name )
  135.   { s0 = pfile_name ; s1 = ": " ; }
  136.   else s0 = s1 = "" ;
  137.  
  138.   errmsg(0, "%s%sline %u: missing %c near %s" ,s0, s1, ln, c, n) ; 
  139. }  
  140.  
  141. void  yyerror(s)
  142.   char *s ; /* we won't use s as input 
  143.   (yacc and bison force this).
  144.   We will use s for storage to keep lint or the compiler
  145.   off our back */
  146. { struct token_str *p ;
  147.   int *ip ;
  148.  
  149.   s = (char *) 0 ;
  150.  
  151.   for ( p = token_str ; p->token ; p++ )
  152.       if ( current_token == p->token )
  153.       { s = p->str ; break ; }
  154.  
  155.   if ( ! s )  /* search the keywords */
  156.          s = find_kw_str(current_token) ;
  157.  
  158.   if ( s )
  159.   {
  160.     if ( paren_cnt )
  161.         for( ip = missing_rparen ; *ip ; ip++)
  162.           if ( *ip == current_token )
  163.           { missing(')', s, token_lineno) ;
  164.             paren_cnt = 0 ;
  165.             goto done ;
  166.           }
  167.  
  168.     if ( brace_cnt )
  169.         for( ip = missing_rbrace ; *ip ; ip++)
  170.           if ( *ip == current_token )
  171.           { missing('}', s, token_lineno) ;
  172.             brace_cnt = 0 ;
  173.             goto done ;
  174.           }
  175.  
  176.     compile_error("syntax error at or near %s", s) ;
  177.  
  178.   }
  179.   else  /* special cases */
  180.   switch ( current_token )
  181.   {
  182.     case UNEXPECTED :
  183.             unexpected_char() ; 
  184.             goto done ;
  185.  
  186.     case BAD_DECIMAL :
  187.             compile_error(
  188.               "syntax error in decimal constant %s",
  189.               string_buff ) ;
  190.             break ;
  191.  
  192.     case RE :
  193.             compile_error(
  194.             "syntax error at or near /%s/", 
  195.             string_buff ) ;
  196.             break ;
  197.  
  198.     default :
  199.             compile_error("syntax error") ;
  200.             break ;
  201.   }
  202.   return ;
  203.  
  204. done :
  205.   if ( ++compile_error_count == MAX_COMPILE_ERRORS ) mawk_exit(2) ;
  206. }
  207.  
  208.  
  209. /* generic error message with a hook into the system error 
  210.    messages if errnum > 0 */
  211.  
  212. void  errmsg VA_ALIST2(int , errnum, char *, format)
  213.   va_list args ;
  214.  
  215.   fprintf(stderr, "%s: " , progname) ;
  216.  
  217.   VA_START2(args, int, errnum, char *, format) ;
  218.   vfprintf(stderr, format, args) ;
  219.   va_end(args) ;
  220.  
  221.   if ( errnum > 0 ) fprintf(stderr, " (%s)" , strerror(errnum) ) ;
  222.  
  223.   fprintf( stderr, "\n") ;
  224. }
  225.  
  226. void  compile_error  VA_ALIST(char *, format)
  227.   va_list args ;
  228.   char *s0, *s1 ;
  229.  
  230.   /* with multiple program files put program name in
  231.      error message */
  232.   if ( pfile_name )
  233.   { s0 = pfile_name ; s1 = ": " ; }
  234.   else
  235.   { s0 = s1 = "" ; }
  236.  
  237.   fprintf(stderr, "%s: %s%sline %u: " , progname, s0, s1,token_lineno) ;
  238.   VA_START(args, char *, format) ;
  239.   vfprintf(stderr, format, args) ;
  240.   va_end(args) ;
  241.   fprintf(stderr, "\n") ;
  242.   if ( ++compile_error_count == MAX_COMPILE_ERRORS ) mawk_exit(2) ;
  243. }
  244.  
  245. void  rt_error VA_ALIST( char *, format)
  246.   va_list args ;
  247.  
  248.   fprintf(stderr, "%s: run time error: " , progname ) ;
  249.   VA_START(args, char *, format) ;
  250.   vfprintf(stderr, format, args) ;
  251.   va_end(args) ;
  252.   putc('\n',stderr) ;
  253.   rt_where() ;
  254.   mawk_exit(2) ;
  255. }
  256.  
  257.  
  258. void bozo(s)
  259.   char *s ;
  260. { 
  261.   errmsg(0, "bozo: %s" , s) ; 
  262.   mawk_exit(3) ;
  263. }
  264.  
  265. void overflow(s, size)
  266.   char *s ; unsigned size ;
  267. { 
  268.   errmsg(0 , "program limit exceeded: %s size=%u", s, size) ;
  269.   mawk_exit(2) ; 
  270. }
  271.  
  272.  
  273. /* print as much as we know about where a rt error occured */
  274.  
  275. static void rt_where()
  276. {
  277.   if ( FILENAME->type != C_STRING ) cast1_to_s(FILENAME) ;
  278.  
  279.   fprintf(stderr, "\tFILENAME=\"%s\" FNR=%u NR=%u\n", 
  280.     string(FILENAME)->str, rt_fnr, rt_nr) ;
  281. }
  282.  
  283. /* run time */
  284. void rt_overflow(s, size)
  285.   char *s ; unsigned size ;
  286. { 
  287.   errmsg(0 , "program limit exceeded: %s size=%u", s, size) ;
  288.   rt_where() ;
  289.   mawk_exit(2) ;
  290. }
  291.  
  292. void 
  293. unexpected_char()
  294. { int c = yylval.ival ;
  295.  
  296.   fprintf(stderr, "%s: %u: ", progname, token_lineno) ;
  297.   if ( c > ' ' && c < 127 )
  298.       fprintf(stderr, "unexpected character '%c'\n" , c) ;
  299.   else
  300.       fprintf(stderr, "unexpected character 0x%02x\n" , c) ;
  301. }
  302.  
  303. static char *type_to_str( type )
  304.   int type ;
  305. { char *retval ;
  306.  
  307.   switch( type )
  308.   {
  309.     case  ST_VAR :  retval = "variable" ; break ;
  310.     case  ST_ARRAY :  retval = "array" ; break ;
  311.     case  ST_FUNCT :  retval = "function" ; break ;
  312.     case  ST_LOCAL_VAR : retval = "local variable" ; break ;
  313.     case  ST_LOCAL_ARRAY : retval = "local array" ; break ;
  314.     default : bozo("type_to_str") ;
  315.   }
  316.   return retval ;
  317. }
  318.  
  319. /* emit an error message about a type clash */
  320. void type_error(p)
  321.   SYMTAB *p ;
  322. { compile_error("illegal reference to %s %s", 
  323.     type_to_str(p->type) , p->name) ;
  324. }
  325.  
  326.  
  327.  
  328. #ifdef  NO_VFPRINTF
  329.  
  330. /* a minimal vfprintf  */
  331. int simple_vfprintf( fp, format, argp)
  332.   FILE *fp ;
  333.   char *format ; 
  334.   va_list  argp ;
  335. { 
  336.   char *q , *p, *t ;
  337.   int l_flag ;
  338.   char xbuff[64] ;
  339.  
  340.   q = format ;
  341.   xbuff[0] = '%' ;
  342.  
  343.   while ( *q != 0 )
  344.   { 
  345.     if ( *q != '%' )
  346.     {
  347.       putc(*q, fp) ; q++ ; continue ;
  348.     }
  349.  
  350.     /* mark the start with p */
  351.     p = ++q ;  t = xbuff + 1 ;
  352.  
  353.     if ( *q == '-' )  *t++ = *q++ ;
  354.     while ( scan_code[*(unsigned char*)q] == SC_DIGIT ) *t++ = *q++ ;
  355.     if ( *q == '.' )
  356.     { *t++ = *q++ ;
  357.       while ( scan_code[*(unsigned char*)q] == SC_DIGIT ) *t++ = *q++ ;
  358.     }
  359.  
  360.     if ( *q == 'l' )  { l_flag = 1 ; *t++ = *q++ ; }
  361.     else l_flag = 0 ;
  362.  
  363.     
  364.     *t = *q++ ; t[1] = 0 ;
  365.  
  366.     switch( *t )
  367.     {
  368.       case 'c' :  
  369.       case 'd' :
  370.       case 'o' :
  371.       case 'x' :
  372.       case 'u' :
  373.            if ( l_flag )  fprintf(fp, xbuff, va_arg(argp,long) ) ;
  374.            else  fprintf(fp, xbuff, va_arg(argp, int)) ;
  375.            break ;
  376.  
  377.       case  's' :
  378.            fprintf(fp, xbuff, va_arg(argp, char*)) ;
  379.            break ;
  380.  
  381.       case  'g' :
  382.       case  'f' :
  383.            fprintf(fp, xbuff, va_arg(argp, double)) ;
  384.            break ;
  385.  
  386.       default:
  387.            putc('%', fp) ; 
  388.            q = p ;
  389.            break ;
  390.     }
  391.   }
  392.   return 0 ; /* shut up */
  393. }
  394.  
  395. #endif  /* USE_SIMPLE_VFPRINTF */
  396.  
  397.  
  398.