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

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

unix.superglobalmegacorp.com

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