Annotation of 40BSD/cmd/px/perror.c, revision 1.1.1.1

1.1       root        1: /* Copyright (c) 1979 Regents of the University of California */
                      2: 
                      3: static char sccsid[] = "@(#)perror.c 4.1 10/10/80";
                      4: 
                      5: #include       "stdio.h"
                      6: #include       "signal.h"
                      7: #include       "h00vars.h"
                      8: #include       "h01errs.h"
                      9: 
                     10: /*
                     11:  * Routine error is called from the interpreter when a runtime error occurs.
                     12:  * Its argument is the internal number of the error which occurred.
                     13:  * See Edata, Emake etc.
                     14:  */
                     15: error(errnum)
                     16: long   errnum;
                     17: {
                     18: register long i;
                     19: extern long errno;
                     20: 
                     21: signal(SIGINT,SIG_IGN);
                     22: signal(SIGSEGV,SIG_DFL);
                     23: signal(SIGFPE,SIG_DFL);
                     24: i = errno;
                     25: pflush();
                     26: errno = i;
                     27: fputs("\n\n",stderr);
                     28: switch (errnum) {
                     29:        case EINTR:
                     30:                break;
                     31:        case ECHR:
                     32:                fputs("Argument to chr out of range\n",stderr);
                     33:                break;
                     34:        case EASSIGN:
                     35:                fputs("Overflow during assignment conversion\n",stderr);
                     36:                break;
                     37:        case EFIXADD:
                     38:                fputs("Overflow in fixed point addition\n",stderr);
                     39:                break;
                     40:        case EFLTADD:
                     41:                fputs("Floating point addition out of range\n",stderr);
                     42:                break;
                     43:        case EFIXSUB:
                     44:                fputs("Overflow in fixed point subtraction\n",stderr);
                     45:                break;
                     46:        case EFLTSUB:
                     47:                fputs("Floating point subtraction out of range\n",stderr);
                     48:                break;
                     49:        case EFIXMUL:
                     50:                fputs("Overflow in fixed point multiplication\n",stderr);
                     51:                break;
                     52:        case EFLTMUL:
                     53:                fputs("Floating point multiplication out of range\n",stderr);
                     54:                break;
                     55:        case EFIXDIV:
                     56:                fputs("Fixed point division by zero\n",stderr);
                     57:                break;
                     58:        case EFLTDIV:
                     59:                fputs("Floating point division error\n",stderr);
                     60:                break;
                     61:        case EMODDIV:
                     62:                fputs("Fixed point modulo by zero\n",stderr);
                     63:                break;
                     64:        case EFIXNEG:
                     65:                fputs("Overflow in fixed point negation\n",stderr);
                     66:                break;
                     67:        case ESYSTEM:
                     68:                fputs("Panic: Computational error in interpreter\n",stderr);
                     69:                break;
                     70:        case EBUILTIN:
                     71:                fputs("Overflow in builtin function\n",stderr);
                     72:                break;
                     73:        case EHALT:
                     74: /*
                     75:                nodump = 0;
                     76: */
                     77:                fputs("Call to procedure halt\n",stderr);
                     78:                break;
                     79:        case ENILPTR:
                     80:                fputs("Reference through a nil pointer\n",stderr);
                     81:                break;
                     82:        case EPASTEOF:
                     83:                fprintf(stderr,"%s: Tried to read past end of file\n",file);
                     84:                break;
                     85:        case EREADIT:
                     86:                fprintf(stderr,"%s: Attempt to read, but open for writing\n",file);
                     87:                break;
                     88:        case EWRITEIT:
                     89:                fprintf(stderr,"%s: Attempt to write, but open for reading\n",file);
                     90:                break;
                     91:        case ECLOSE:
                     92:                fprintf(stderr,"%s: Close failed\n",file);
                     93:                break;
                     94:        case ELLIMIT:
                     95:                fprintf(stderr,"%s: Line limit exceeded\n",file);
                     96:                break;
                     97:        case ESQRT:
                     98:                fputs("Negative argument to sqrt\n",stderr);
                     99:                break;
                    100:        case ESTKNEMP:
                    101:                fputs("Panic: stack not empty between statements\n",stderr);
                    102:                break;
                    103:        case ESUBSCR:
                    104:                fputs("Subscript out of range\n",stderr);
                    105:                break;
                    106:        case EREFINAF:
                    107:                fputs("Reference to an inactive file\n",stderr);
                    108:                break;
                    109:        case EWRITE:
                    110:                fputs("Could not write to ",stderr);
                    111:                perror(file);
                    112:                break;
                    113:        case EOPEN:
                    114:                fputs("Could not open ",stderr);
                    115:                perror(file);
                    116:                break;
                    117:        case ECREATE:
                    118:                fputs("Could not create ",stderr);
                    119:                perror(file);
                    120:                break;
                    121:        case EREMOVE:
                    122:                fputs("Could not remove ",stderr);
                    123:                perror(file);
                    124:                break;
                    125:        case ESEEK:
                    126:                fputs("Could not reset ",stderr);
                    127:                perror(file);
                    128:                break;
                    129:        case ENAMESIZE:
                    130:                fputs("File name too long\n",stderr);
                    131:                break;
                    132:        case ELN:
                    133:                fputs("Non-positive argument to ln\n",stderr);
                    134:                break;
                    135:        case EBADOP:
                    136:                fputs("Panic: bad op code\n",stderr);
                    137:                break;
                    138:        case EBADINUM:
                    139:                fputs("Bad data found on integer read\n",stderr);
                    140:                break;
                    141:        case EBADFNUM:
                    142:                fputs("Bad data found on real read\n",stderr);
                    143:                break;
                    144:        case ENUMNTFD:
                    145:                fputs("Unknown name found on enumerated type read\n",stderr);
                    146:                break;
                    147:        case ENAMRNG:
                    148:                fputs("Enumerated type value out of range on output\n",stderr);
                    149:                break;
                    150:        case EFMTSIZE:
                    151:                fputs("Negative format width\n",stderr);
                    152:                break;
                    153:        case ENARGS:
                    154:                fputs("Improper number of arguments to formal routine\n"
                    155:                        ,stderr);
                    156:                break;
                    157:        case EGOTO:
                    158:                fputs("Panic: active frame not found in goto\n",stderr);
                    159:                break;
                    160:        case ECASE:
                    161:                fputs("Label not found in case\n",stderr);
                    162:                break;
                    163:        case EOUTOFMEM:
                    164:                fputs("Ran out of memory\n",stderr);
                    165:                break;
                    166:        case ETRASHHEAP:
                    167:                fputs("Improper use of new variables has caused heap integrity check to fail\n",stderr);
                    168:                break;
                    169:        case ECTLWR:
                    170:                fputs("Range lower bound out of set bounds\n", stderr);
                    171:                break;
                    172:        case ECTUPR:
                    173:                fputs("Range upper bound out of set bounds\n", stderr);
                    174:                break;
                    175:        case ECTSNG:
                    176:                fputs("Single value out of set bounds\n", stderr);
                    177:                break;
                    178:        case EARGV:
                    179:                fputs("Argument to argv out of range\n",stderr);
                    180:                break;
                    181:        case EPACK:
                    182:                fputs("Bad i to pack(a,i,z)\n",stderr);
                    183:                break;
                    184:        case EUNPACK:
                    185:                fputs("Bad i to unpack(z,a,i)\n",stderr);
                    186:                break;
                    187:        case ERANGE:
                    188:                fputs("Value out of range\n",stderr);
                    189:                break;
                    190:        case EASRT:
                    191:                fputs("Assertion failed\n",stderr);
                    192:                break;
                    193:        case ESTLIM:
                    194:                fputs("Statement count limit exceeded\n",stderr);
                    195:                break;
                    196:        case ESTKOVFLO:
                    197:                fputs("Runtime stack overflow\n",stderr);
                    198:                break;
                    199:        default:
                    200:                fputs("Panic: unknown error\n",stderr);
                    201: }
                    202: backtrace(errnum);
                    203: psexit(errnum);
                    204: }

unix.superglobalmegacorp.com

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