Return to perror.c CVS log

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

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

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