Return to error.c CVS log

Up to [Research Unix] / researchv10no / cmd / f77

Annotation of researchv10no/cmd/f77/error.c, revision 1.1

1.1     ! root        1: #include "defs"
        !             2: 
        !             3: 
        !             4: warn1(s,t)
        !             5: char *s, *t;
        !             6: {
        !             7:        char buff[100];
        !             8:        sprintf(buff, s, t);
        !             9:        warn(buff);
        !            10: }
        !            11: 
        !            12: 
        !            13: warn(s)
        !            14: char *s;
        !            15: {
        !            16:        if(nowarnflag)
        !            17:                return;
        !            18:        fprintf(diagfile, "Warning on line %d of %s: %s\n", lineno, infname, s);
        !            19:        ++nwarn;
        !            20: }
        !            21: 
        !            22: warnb1(s,t)
        !            23:  char *s, *t;
        !            24: {
        !            25:        int x;
        !            26:        x = nowarnflag;
        !            27:        nowarnflag = 0;
        !            28:        warn1(s,t);
        !            29:        nowarnflag = x;
        !            30:        }
        !            31: 
        !            32: warnb(s)
        !            33:  char *s;
        !            34: {
        !            35:        int x;
        !            36:        x = nowarnflag;
        !            37:        nowarnflag = 0;
        !            38:        warn(s);
        !            39:        nowarnflag = x;
        !            40:        }
        !            41: 
        !            42: 
        !            43: errstr(s, t)
        !            44: char *s, *t;
        !            45: {
        !            46:        char buff[100];
        !            47:        sprintf(buff, s, t);
        !            48:        err(buff);
        !            49: }
        !            50: 
        !            51: 
        !            52: 
        !            53: erri(s,t)
        !            54: char *s;
        !            55: int t;
        !            56: {
        !            57:        char buff[100];
        !            58:        sprintf(buff, s, t);
        !            59:        err(buff);
        !            60: }
        !            61: 
        !            62: 
        !            63: err(s)
        !            64: char *s;
        !            65: {
        !            66:        fprintf(diagfile, "Error on line %d of %s: %s\n", lineno, infname, s);
        !            67:        ++nerr;
        !            68: }
        !            69: 
        !            70: 
        !            71: yyerror(s)
        !            72: char *s;
        !            73: { 
        !            74:        err(s); 
        !            75: }
        !            76: 
        !            77: 
        !            78: 
        !            79: dclerr(s, v)
        !            80: char *s;
        !            81: Namep v;
        !            82: {
        !            83:        char buff[100];
        !            84: 
        !            85:        if(v)
        !            86:        {
        !            87:                sprintf(buff, "Declaration error for %s: %s", varstr(VL, v->varname), s);
        !            88:                err(buff);
        !            89:        }
        !            90:        else
        !            91:                errstr("Declaration error %s", s);
        !            92: }
        !            93: 
        !            94: 
        !            95: 
        !            96: execerr(s, n)
        !            97: char *s, *n;
        !            98: {
        !            99:        char buf1[100], buf2[100];
        !           100: 
        !           101:        sprintf(buf1, "Execution error %s", s);
        !           102:        sprintf(buf2, buf1, n);
        !           103:        err(buf2);
        !           104: }
        !           105: 
        !           106: 
        !           107: fatal(t)
        !           108: char *t;
        !           109: {
        !           110:        fprintf(diagfile, "Compiler error line %d of %s: %s\n", lineno, infname, t);
        !           111:        if(debugflag)
        !           112:                abort();
        !           113:        done(3);
        !           114:        exit(3);
        !           115: }
        !           116: 
        !           117: 
        !           118: 
        !           119: 
        !           120: fatalstr(t,s)
        !           121: char *t, *s;
        !           122: {
        !           123:        char buff[100];
        !           124:        sprintf(buff, t, s);
        !           125:        fatal(buff);
        !           126: }
        !           127: 
        !           128: 
        !           129: 
        !           130: fatali(t,d)
        !           131: char *t;
        !           132: int d;
        !           133: {
        !           134:        char buff[100];
        !           135:        sprintf(buff, t, d);
        !           136:        fatal(buff);
        !           137: }
        !           138: 
        !           139: 
        !           140: 
        !           141: badthing(thing, r, t)
        !           142: char *thing, *r;
        !           143: int t;
        !           144: {
        !           145:        char buff[50];
        !           146:        sprintf(buff, "Impossible %s %d in routine %s", thing, t, r);
        !           147:        fatal(buff);
        !           148: }
        !           149: 
        !           150: 
        !           151: 
        !           152: badop(r, t)
        !           153: char *r;
        !           154: int t;
        !           155: {
        !           156:        badthing("opcode", r, t);
        !           157: }
        !           158: 
        !           159: 
        !           160: 
        !           161: badtag(r, t)
        !           162: char *r;
        !           163: int t;
        !           164: {
        !           165:        badthing("tag", r, t);
        !           166: }
        !           167: 
        !           168: 
        !           169: 
        !           170: 
        !           171: 
        !           172: badstg(r, t)
        !           173: char *r;
        !           174: int t;
        !           175: {
        !           176:        badthing("storage class", r, t);
        !           177: }
        !           178: 
        !           179: 
        !           180: 
        !           181: 
        !           182: badtype(r, t)
        !           183: char *r;
        !           184: int t;
        !           185: {
        !           186:        badthing("type", r, t);
        !           187: }
        !           188: 
        !           189: 
        !           190: many(s, c, n)
        !           191: char *s, c;
        !           192: int n;
        !           193: {
        !           194:        char buff[250];
        !           195: 
        !           196:        sprintf(buff,
        !           197:            "Too many %s.\nTable limit now %d.\nTry recompiling using the -N%c%d option\n",
        !           198:            s, n, c, 2*n);
        !           199:        fatal(buff);
        !           200: }
        !           201: 
        !           202: 
        !           203: err66(s)
        !           204: char *s;
        !           205: {
        !           206:        errstr("Fortran 77 feature used: %s", s);
        !           207: }
        !           208: 
        !           209: 
        !           210: 
        !           211: errext(s)
        !           212: char *s;
        !           213: {
        !           214:        errstr("F77 compiler extension used: %s", s);
        !           215: }

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