Return to errors.c CVS log

Up to [Research Unix] / researchv9 / jerq / sgs / as

Annotation of researchv9/jerq/sgs/as/errors.c, revision 1.1.1.1

1.1       root        1: static char ID[] = "@(#) errors.c: 1.4 12/1/83";
                      2: 
                      3: /*
                      4:  *
                      5:  *     "errors.c" is a file containing a routine "aerror" that prints
                      6:  *     out  error messages and (currently) terminates execution when
                      7:  *     an error is encountered.  It prints out  the  file  and  line
                      8:  *     number  where  the  error  was  encountered and uses a switch
                      9:  *     statement to select a diagnostic message based on  the  error
                     10:  *     code.   If  this  error  was  reported by anything other than
                     11:  *     "makeinst" (indicated by "pass" being non-zero), the  command
                     12:  *     "rm" is "exec"ed to remove all temporary files.   The following
                     13:  *     global variables are used in this file:
                     14:  *
                     15:  *     line    Gives the line  number  in  the  current  file  being
                     16:  *             assembled.
                     17:  *
                     18:  *     file    A character  array that contains the name of the
                     19:  *             file being assembled.
                     20:  *
                     21:  *     fderr   The file descriptor for error output.
                     22:  *
                     23:  *     filenames  This is an array of pointers to character strings
                     24:  *             that contains pointers to all of the file names
                     25:  *             obtained from the argument list. This array is used
                     26:  *             to obtain the names of the temporary files to be
                     27:  *             removed.
                     28:  *
                     29:  */
                     30: 
                     31: #include <stdio.h>
                     32: #include <signal.h>
                     33: #include "systems.h"
                     34: #include "gendefs.h"
                     35: 
                     36: #define MAXERRS        30
                     37: 
                     38: unsigned short
                     39:        line = 1,
                     40:        cline = 0; /* `c' line number (from `.ln') */
                     41: short  anyerrs = 0;
                     42: char   file[134];
                     43: char   cfile[15] = { "" }; /* name of `c' source file */
                     44: 
                     45: FILE   *fderr;
                     46: 
                     47: char   *filenames[16];
                     48: 
                     49: #if M4ON
                     50: short  rflag = NO; /* if set, remove (unlink) input when through */
                     51: #endif
                     52: 
                     53: onintr()
                     54: {
                     55:        signal(SIGINT,onintr);
                     56:        signal(SIGTERM,onintr);
                     57:        delexit();
                     58: }
                     59: 
                     60: aerror(str)
                     61:        register char *str;
                     62: {
                     63:        errmsg("",str);
                     64:        delexit();
                     65: }
                     66: 
                     67: yyerror(str)
                     68:        char *str;
                     69: {
                     70:        errmsg("",str);
                     71:        if (++anyerrs > MAXERRS) {
                     72:                fprintf(stderr,"Too many errors - Goodbye\n");
                     73:                delexit();
                     74:        }
                     75: }
                     76: 
                     77: werror(str)
                     78:        char *str;
                     79: {
                     80:        errmsg("Warning: ",str);
                     81: }
                     82: 
                     83: errmsg(str1,str2)
                     84:        char *str1,*str2;
                     85: {
                     86:        char *msgfile;
                     87:        static short firsterr = 1;
                     88: 
                     89:        if (firsterr) {
                     90:                if (cfile[0] == '\0')
                     91:                        msgfile = file;
                     92:                else
                     93:                        msgfile = cfile;
                     94:                fprintf(stderr,"Assembler: %s\n",msgfile);
                     95:                firsterr = 0;
                     96:        }
                     97:        fprintf(stderr,"\taline %u",line);
                     98:        if (cline != 0)
                     99:                fprintf(stderr,"(cline %u)",cline);
                    100:        else
                    101:                fprintf(stderr,"\t");
                    102:        fprintf(stderr,": %s%s\n",str1,str2);
                    103: }
                    104: 
                    105: delexit()
                    106: {
                    107:        unlink(filenames[1]); /* unlink object (.o) file */
                    108:        deltemps();
                    109:        exit(127);
                    110: }
                    111: 
                    112: deltemps()
                    113: {
                    114:        register short i;
                    115: 
                    116: #if M4ON
                    117:        if (rflag)
                    118:                unlink(file);
                    119: #endif
                    120:        for (i = 2; i < NFILES; ++i)
                    121:                unlink(filenames[i]);
                    122: }

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