Return to err.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / icon / tran

Annotation of 43BSD/contrib/icon/tran/err.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Routines for producing error messages.
        !             3:  */
        !             4: 
        !             5: #include "itran.h"
        !             6: #include "token.h"
        !             7: #include "tree.h"
        !             8: #include "lex.h"
        !             9: 
        !            10: struct errmsg {
        !            11:    int e_state;                /* parser state number */
        !            12:    char *e_mesg;               /* message text */
        !            13:    } errtab[] = {
        !            14: #include "synerr.h"
        !            15:     -1,  "syntax error"
        !            16:    };
        !            17: 
        !            18: /*
        !            19:  * yyerror produces syntax error messages.  tok is the offending token
        !            20:  *  (yychar), lval is yylval, and state is the parser's state.
        !            21:  *
        !            22:  * errtab is searched for the state, if it is found, the associated
        !            23:  *  message is produced; if the state isn't found, "syntax error"
        !            24:  *  is produced.
        !            25:  */
        !            26: yyerror(tok, lval, state)
        !            27: int tok, state;
        !            28: nodeptr lval;
        !            29:    {
        !            30:    register struct errmsg *p;
        !            31:    char *mapterm();
        !            32: 
        !            33:    if (*filep)
        !            34:       fprintf(stderr, "%s, ", *filep);
        !            35:    if (tok == EOFX)   /* special case end of file */
        !            36:       fprintf(stderr, "unexpected end of file\n");
        !            37:    else {
        !            38:       fprintf(stderr, "line %d: ", LINE(lval));
        !            39:       if (COL(lval))
        !            40:          fprintf(stderr, "\"%s\": ", mapterm(tok,lval));
        !            41:       for (p = errtab; p->e_state != state && p->e_state >= 0; p++) ;
        !            42:       fprintf(stderr, "%s\n", p->e_mesg);
        !            43:       }
        !            44:    fatalerrs++;
        !            45:    nocode++;
        !            46:    }
        !            47: /*
        !            48:  * err produces the error messages s1 and s2 (if non-null).  The
        !            49:  *  current line number is found in tline.
        !            50:  */
        !            51: err(s1, s2)
        !            52: char *s1, *s2;
        !            53:    {
        !            54:    if (*filep)
        !            55:       fprintf(stderr, "%s, ", *filep);
        !            56:    fprintf(stderr, "line %d: ", tline);
        !            57:    if (s2)
        !            58:       fprintf(stderr, "\"%s\": ", s2);
        !            59:    fprintf(stderr, "%s\n", s1);
        !            60:    fatalerrs++;
        !            61:    nocode++;
        !            62:    }
        !            63: 
        !            64: /*
        !            65:  * lerr produces the error message s and associates it with line l.
        !            66:  */
        !            67: lerr(l, s)
        !            68: int l;
        !            69: char *s;
        !            70:    {
        !            71:    if (*filep)
        !            72:       fprintf(stderr, "%s, ", *filep);
        !            73:    fprintf(stderr, "line %d: ", l);
        !            74:    fprintf(stderr, "%s\n", s);
        !            75:    fatalerrs++;
        !            76:    nocode++;
        !            77:    }
        !            78: 
        !            79: /*
        !            80:  * warn produces s1 and s2 (if non-null) as warning messages.  The current
        !            81:  *  line is in tline.
        !            82:  */
        !            83: warn(s1, s2)
        !            84: char *s1, *s2;
        !            85:    {
        !            86:    if (*filep)
        !            87:       fprintf(stderr, "%s, ", *filep);
        !            88:    fprintf(stderr, "line %d: ", tline);
        !            89:    if (s2)
        !            90:       fprintf(stderr, "\"%s\": ", s2);
        !            91:    fprintf(stderr, "%s\n", s1);
        !            92:    warnings++;
        !            93:    }
        !            94: 
        !            95: /*
        !            96:  * syserr is called for fatal errors.  The message s is produced and the
        !            97:  *  translator exits.
        !            98:  */
        !            99: syserr(s)
        !           100: char *s;
        !           101:    {
        !           102:    if (*filep)
        !           103:       fprintf(stderr, "%s, ", *filep);
        !           104:    fprintf(stderr, "line %d: %s\n", inline, s);
        !           105:    exit(1);
        !           106:    }
        !           107: 
        !           108: /*
        !           109:  * mapterm finds a printable string for the given token type
        !           110:  *  and value.
        !           111:  */
        !           112: char *mapterm(typ,val)
        !           113: int typ;
        !           114: nodeptr val;
        !           115:    {
        !           116:    register struct toktab *t;
        !           117:    register i;
        !           118: 
        !           119:    i = typ;
        !           120:    if (i == IDENT || i == INTLIT || i == REALLIT || i == STRINGLIT || i == CSETLIT)
        !           121:       return (STR0(val));
        !           122:    for (t = toktab; t->t_type != i; t++)
        !           123:       if (t->t_type == 0)
        !           124:          return ("???");
        !           125:    return (t->t_word);
        !           126:    }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.