Return to perror.c CVS log

Up to [CSRG BSD Unix] / 41BSD / cmd / px

Annotation of 41BSD/cmd/px/perror.c, revision 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: }

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