Return to sigs.c CVS log

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

Annotation of researchv10no/cmd/spitbol/sigs.c, revision 1.1.1.1

1.1       root        1: #define I_ADDF2                0x40
                      2: #define I_ADDF3                0x41
                      3: #define I_DIVF2                0x46
                      4: #define I_DIVF3                0x47
                      5: #define I_MULF2                0x44
                      6: #define I_MULF3                0x45
                      7: #define I_SUBF2                0x42
                      8: #define I_SUBF3                0x43
                      9: 
                     10: #define PC 15
                     11: 
                     12: #include <signal.h>
                     13: 
                     14: void setsigs();
                     15: 
                     16: static void
                     17: ovfltrap (signo, param, xx, pc, psl)
                     18:        unsigned char *pc;
                     19: {
                     20:        register int operands = 2;
                     21:        register unsigned char *rpc = pc;
                     22: 
                     23:        setsigs();              /* trap overflow again */
                     24:        psl |= 02;              /* set the overflow bit */
                     25: 
                     26:        /* Adjust the PC if this is an op code we know about */
                     27:        switch (*rpc) {
                     28: 
                     29:        case I_ADDF3:
                     30:        case I_SUBF3:
                     31:        case I_MULF3:
                     32:        case I_DIVF3:
                     33:                operands++;
                     34: 
                     35:        case I_ADDF2:
                     36:        case I_SUBF2:
                     37:        case I_MULF2:
                     38:        case I_DIVF2:
                     39: 
                     40:                rpc++;
                     41: 
                     42:                do {
                     43: 
                     44:                        /* Fetch and step past the first operand byte */
                     45:                        register int mode = (*rpc & 0xf0) >> 4;
                     46:                        register int reg = *rpc++ & 0xf;
                     47: 
                     48:                        switch (mode) {
                     49: 
                     50:                        case 0:         /* literal */
                     51:                        case 1:         /* literal */
                     52:                        case 2:         /* literal */
                     53:                        case 3:         /* literal */
                     54:                                break;
                     55: 
                     56:                        case 4:         /* [reg] */
                     57:                                operands++;
                     58:                                break;
                     59: 
                     60:                        case 5:         /* reg */
                     61:                        case 6:         /* (reg) */
                     62:                        case 7:         /* -(reg) */
                     63:                                break;
                     64: 
                     65:                        case 8:         /* (reg)+ */
                     66:                                if (reg == PC)
                     67:                                        rpc += sizeof (float);
                     68:                                break;
                     69: 
                     70:                        case 9:         /* autoincrement deferred or absolute */
                     71:                                if (reg == PC)
                     72:                                        rpc += 4;
                     73:                                break;
                     74: 
                     75:                        case 10:        /* byte displacement */
                     76:                        case 11:        /* byte displacement deferred */
                     77:                                rpc++;
                     78:                                break;
                     79: 
                     80:                        case 12:        /* word displacement */
                     81:                        case 13:        /* word displacement deferred */
                     82:                                rpc += 2;
                     83:                                break;
                     84: 
                     85:                        case 14:        /* longword displacement */
                     86:                        case 15:        /* longword displacement deferred */
                     87:                                rpc += 4;
                     88:                                break;
                     89:                        }
                     90:                } while (--operands);
                     91: 
                     92:        }
                     93:        pc = rpc;
                     94: }
                     95: 
                     96: void
                     97: setsigs()
                     98: {
                     99:        signal (SIGFPE, ovfltrap);
                    100: }

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