Return to xebec.c CVS log

Up to [Net/2] / Net2 / netiso / xebec

Annotation of Net2/netiso/xebec/xebec.c, revision 1.1.1.2

1.1.1.2 ! root        1: /* $Header: /cvsroot/src/sys/netiso/xebec/xebec.c,v 1.1 1993/04/09 12:02:22 cgd Exp $ */
        !             2: /* $Source: /cvsroot/src/sys/netiso/xebec/xebec.c,v $ */
1.1       root        3: 
                      4: #include "xebec.h"
                      5: #include "llparse.h"
                      6: #ifndef        E_TABLE
                      7: #define        E_TABLE "xebec.e"
                      8: #endif E_TABLE
                      9: 
                     10: #include "main.h"
                     11: #include "sets.h"
                     12: #include <stdio.h> 
                     13: 
                     14: extern FILE *eventfile_h, *actfile; 
                     15: 
                     16: llaction(lln,token)
                     17: LLtoken *token;
                     18: {
                     19:        struct llattr *llattr;
                     20:        llattr = &llattrdesc[lldescindex-1];
                     21: switch(lln) {
                     22: case 1:
                     23:        llfinprod();
                     24:        break;
                     25: 
                     26: case 10: {
                     27:        
                     28:                                        if(strlen(llattr->llabase[3].ID.address) > 50 ) {
                     29:                                                fprintf(stderr, 
                     30:                                                "Protocol name may not exceed 50 chars in length.\n"); 
                     31:                                                Exit(-1);
                     32:                                        }
                     33:                                        strcpy(protocol, llattr->llabase[3].ID.address); 
                     34:                                        openfiles(protocol); 
                     35:                                
                     36: } break;
                     37: 
                     38: case 11: {
                     39:  
                     40:                                        llattr->llabase[7].pcb.isevent = 0; 
                     41:                                
                     42: } break;
                     43: 
                     44: case 12: {
                     45: 
                     46:                                  fprintf(actfile, "\ntypedef %s %s%s;\n",
                     47:                                                          llattr->llabase[7].pcb.address,protocol, PCBNAME); 
                     48:                                  llattr->llabase[8].syn.type = PCB_SYN;
                     49:                                
                     50: } break;
                     51: 
                     52: case 13: {
                     53:  llattr->llabase[11].part.type = (unsigned char) STATESET; 
                     54: } break;
                     55: 
                     56: case 14: {
                     57:  end_states(eventfile_h); 
                     58: } break;
                     59: 
                     60: case 15: {
                     61:  llattr->llabase[14].pcb.isevent = 1; 
                     62: } break;
                     63: 
                     64: case 16: {
                     65: 
                     66:                                        fprintf(eventfile_h, "\t"); /* fmq gags on single chars */
                     67:                                        includecode(eventfile_h, llattr->llabase[14].pcb.address);
                     68:                                        fprintf(eventfile_h, "\n"); /* fmq gags on single chars */
                     69:                                        llattr->llabase[15].syn.type = EVENT_SYN;
                     70:                                
                     71: } break;
                     72: 
                     73: case 17: {
                     74:  
                     75:                                        llattr->llabase[16].part.type = (unsigned char)EVENTSET; 
                     76:                                
                     77: } break;
                     78: 
                     79: case 18: {
                     80:  end_events(); 
                     81: } break;
                     82: 
                     83: case 19: {
                     84:  
                     85:                                        putincludes();
                     86:                                        putdriver(actfile, 9);
                     87:                                
                     88: } break;
                     89: 
                     90: case 20: {
                     91:        if(llattr->llabase[0].pcb.isevent)  {
                     92:                                        fprintf(stderr, 
                     93:                                        "Event is a list of objects enclosed by \"{}\"\n");
                     94:                                        Exit(-1);
                     95:                                }
                     96:                          fprintf(eventfile_h, "struct "); 
                     97:                        
                     98: } break;
                     99: 
                    100: case 21: {
                    101:  llattr->llabase[0].pcb.address = llattr->llabase[2].ACTION.address; 
                    102: } break;
                    103: 
                    104: case 22: {
                    105:        if( ! llattr->llabase[0].pcb.isevent)  {
                    106:                                        fprintf(stderr, 
                    107:                                        "Pcb requires a type or structure definition.\"{}\"\n");
                    108:                                        Exit(-1);
                    109:                                }
                    110:                           llattr->llabase[0].pcb.address = llattr->llabase[1].ACTION.address; 
                    111:                        
                    112: } break;
                    113: 
                    114: case 23: {
                    115:   llattr->llabase[0].pcb.address = llattr->llabase[1].ID.address; 
                    116: } break;
                    117: 
                    118: case 24: {
                    119:  synonyms[llattr->llabase[0].syn.type] = stash( llattr->llabase[2].ID.address ); 
                    120: } break;
                    121: 
                    122: case 25: {
                    123:  includecode(actfile, llattr->llabase[2].ACTION.address);
                    124: } break;
                    125: 
                    126: case 26: {
                    127:  
                    128:                        llattr->llabase[2].partrest.address = llattr->llabase[1].ID.address;
                    129:                        llattr->llabase[2].partrest.type = llattr->llabase[0].part.type; 
                    130:                
                    131: } break;
                    132: 
                    133: case 27: {
                    134:  llattr->llabase[3].parttail.type = llattr->llabase[0].part.type; 
                    135: } break;
                    136: 
                    137: case 28: {
                    138:  llattr->llabase[1].part.type = llattr->llabase[0].parttail.type; 
                    139: } break;
                    140: 
                    141: case 29: {
                    142:  
                    143:                          if(  lookup( llattr->llabase[0].partrest.type, llattr->llabase[0].partrest.address ) ) {
                    144:                                fprintf(stderr, "bnf:trying to redefine obj type 0x%x, adr %s\n",
                    145:                                        llattr->llabase[0].partrest.type, llattr->llabase[0].partrest.address);
                    146:                                Exit(-1);
                    147:                          } 
                    148:                          llattr->llabase[2].setdef.type = llattr->llabase[0].partrest.type;
                    149:                          llattr->llabase[2].setdef.address = stash( llattr->llabase[0].partrest.address );
                    150:                          llattr->llabase[2].setdef.keep = 1;
                    151:                        
                    152: } break;
                    153: 
                    154: case 30: {
                    155:  llattr->llabase[3].setstruct.object = llattr->llabase[2].setdef.object; 
                    156: } break;
                    157: 
                    158: case 31: {
                    159:  
                    160:                 defineitem(llattr->llabase[0].partrest.type, 
                    161:                                        llattr->llabase[0].partrest.address, llattr->llabase[1].ACTION.address); 
                    162:                
                    163: } break;
                    164: 
                    165: case 32: {
                    166:  
                    167:                        defineitem(llattr->llabase[0].partrest.type, llattr->llabase[0].partrest.address, (char *)0);
                    168:                
                    169: } break;
                    170: 
                    171: case 33: {
                    172: 
                    173:                                if(llattr->llabase[0].setstruct.object)  {
                    174:                                        /* WHEN COULD THIS BE FALSE?? 
                    175:                                         * isn't it supposed to be setstruct.object???
                    176:                                         * (it used to be $ACTION.address)
                    177:                                         */
                    178: 
                    179:                                        llattr->llabase[0].setstruct.object->obj_struc = llattr->llabase[1].ACTION.address;
                    180:                                        fprintf(eventfile_h, 
                    181:                                                "struct %s %s%s;\n\n", llattr->llabase[1].ACTION.address, 
                    182:                                                EV_PREFIX,  llattr->llabase[0].setstruct.object->obj_name);
                    183:                                }
                    184:                        
                    185: } break;
                    186: 
                    187: case 34: {
                    188:  
                    189:                        llattr->llabase[2].setlist.setnum = 
                    190:                        defineset(llattr->llabase[0].setdef.type, llattr->llabase[0].setdef.address, llattr->llabase[0].setdef.keep); 
                    191:                
                    192: } break;
                    193: 
                    194: case 35: {
                    195:  llattr->llabase[0].setdef.object = llattr->llabase[2].setlist.setnum; 
                    196: } break;
                    197: 
                    198: case 36: {
                    199:  
                    200:                member(llattr->llabase[0].setlist.setnum, llattr->llabase[1].ID.address); 
                    201:                                llattr->llabase[2].setlisttail.setnum = llattr->llabase[0].setlist.setnum; 
                    202:        
                    203: } break;
                    204: 
                    205: case 37: {
                    206:  llattr->llabase[2].setlist.setnum = llattr->llabase[0].setlisttail.setnum; 
                    207: } break;
                    208: 
                    209: case 38: {
                    210:  transno ++; 
                    211: } break;
                    212: 
                    213: case 39: {
                    214:  
                    215:                CurrentEvent /* GAG! */ = llattr->llabase[6].event.object; 
                    216:         
                    217: } break;
                    218: 
                    219: case 40: {
                    220:  
                    221:                llattr->llabase[8].actionpart.string = llattr->llabase[7].predicatepart.string; 
                    222:                llattr->llabase[8].actionpart.newstate = llattr->llabase[1].newstate.object; 
                    223:                llattr->llabase[8].actionpart.oldstate = llattr->llabase[5].oldstate.object;
                    224:        
                    225: } break;
                    226: 
                    227: case 41: {
                    228:  
                    229:                 llattr->llabase[0].predicatepart.string = stash ( llattr->llabase[1].PREDICATE.address );
                    230:        
                    231: } break;
                    232: 
                    233: case 42: {
                    234:  
                    235:                llattr->llabase[0].predicatepart.string = (char *)0;
                    236:        
                    237: } break;
                    238: 
                    239: case 43: {
                    240: 
                    241:          statetable( llattr->llabase[0].actionpart.string, llattr->llabase[0].actionpart.oldstate, 
                    242:                                        llattr->llabase[0].actionpart.newstate,
                    243:                                        acttable(actfile, llattr->llabase[1].ACTION.address ), 
                    244:                                        CurrentEvent ); 
                    245:          if( print_trans ) {
                    246:                dump_trans( llattr->llabase[0].actionpart.string, llattr->llabase[0].actionpart.oldstate, 
                    247:                                        llattr->llabase[0].actionpart.newstate,
                    248:                                        llattr->llabase[1].ACTION.address, CurrentEvent ); 
                    249:          }
                    250:        
                    251: } break;
                    252: 
                    253: case 44: {
                    254: 
                    255:          statetable(llattr->llabase[0].actionpart.string, llattr->llabase[0].actionpart.oldstate, llattr->llabase[0].actionpart.newstate,
                    256:                                  0, CurrentEvent ); /* KLUDGE - remove this */
                    257:          if( print_trans ) {
                    258:                dump_trans( llattr->llabase[0].actionpart.string, llattr->llabase[0].actionpart.oldstate, 
                    259:                                        llattr->llabase[0].actionpart.newstate,
                    260:                                        "NULLACTION", CurrentEvent ); 
                    261:          }
                    262:        
                    263: } break;
                    264: 
                    265: case 45: {
                    266:        
                    267:                llattr->llabase[0].oldstate.object = Lookup(STATESET, llattr->llabase[1].ID.address);
                    268:        
                    269: } break;
                    270: 
                    271: case 46: {
                    272: 
                    273:                        llattr->llabase[1].setdef.address = (char *)0;
                    274:                        llattr->llabase[1].setdef.type = (unsigned char)STATESET; 
                    275:                        llattr->llabase[1].setdef.keep = 0;
                    276:                
                    277: } break;
                    278: 
                    279: case 47: {
                    280:  
                    281:                        llattr->llabase[0].oldstate.object = llattr->llabase[1].setdef.object; 
                    282:                
                    283: } break;
                    284: 
                    285: case 48: {
                    286:  
                    287:                llattr->llabase[0].newstate.object = Lookup(STATESET, llattr->llabase[1].ID.address); 
                    288:        
                    289: } break;
                    290: 
                    291: case 49: {
                    292:  
                    293:                extern struct Object *SameState;
                    294: 
                    295:                llattr->llabase[0].newstate.object = SameState;
                    296:        
                    297: } break;
                    298: 
                    299: case 50: {
                    300: 
                    301:                        llattr->llabase[0].event.object = Lookup(EVENTSET, llattr->llabase[1].ID.address); 
                    302:                
                    303: } break;
                    304: 
                    305: case 51: {
                    306: 
                    307:                        llattr->llabase[1].setdef.address = (char *)0;
                    308:                        llattr->llabase[1].setdef.type = (unsigned char)EVENTSET; 
                    309:                        llattr->llabase[1].setdef.keep = 0;
                    310:                
                    311: } break;
                    312: 
                    313: case 52: {
                    314:  
                    315:                        llattr->llabase[0].event.object = llattr->llabase[1].setdef.object; 
                    316:                
                    317: } break;
                    318: }
                    319: }
                    320: char *llstrings[] = {
                    321:        "<null>",
                    322:        "ID",
                    323:        "STRUCT",
                    324:        "SYNONYM",
                    325:        "PREDICATE",
                    326:        "ACTION",
                    327:        "PROTOCOL",
                    328:        "LBRACK",
                    329:        "RBRACK",
                    330:        "LANGLE",
                    331:        "EQUAL",
                    332:        "COMMA",
                    333:        "STAR",
                    334:        "EVENTS",
                    335:        "TRANSITIONS",
                    336:        "INCLUDE",
                    337:        "STATES",
                    338:        "SEMI",
                    339:        "PCB",
                    340:        "DEFAULT",
                    341:        "NULLACTION",
                    342:        "SAME",
                    343:        "ENDMARKER",
                    344:        "pcb",
                    345:        "syn",
                    346:        "setlist",
                    347:        "setlisttail",
                    348:        "part",
                    349:        "parttail",
                    350:        "partrest",
                    351:        "setstruct",
                    352:        "setdef",
                    353:        "translist",
                    354:        "transition",
                    355:        "event",
                    356:        "oldstate",
                    357:        "newstate",
                    358:        "predicatepart",
                    359:        "actionpart",
                    360:        "program",
                    361:        "includelist",
                    362:        "optsemi",
                    363:        "translisttail",
                    364:        "$goal$",
                    365:        (char *) 0
                    366: };
                    367: short llnterms = 23;
                    368: short llnsyms = 44;
                    369: short llnprods = 38;
                    370: short llinfinite = 10000;
                    371: short llproductions[] = {
                    372: 41, -21, 5, -20, 2, 
                    373: 41, -22, 5, 
                    374: 41, -23, 1, 
                    375: -24, 1, 3, 
                    376: 
                    377: 26, -36, 1, 
                    378: 25, -37, 11, 
                    379: 
                    380: 28, -27, 29, -26, 1, 
                    381: 27, -28, 
                    382: 
                    383: 30, -30, 31, -29, 10, 
                    384: -31, 5, 
                    385: -32, 
                    386: -33, 5, 
                    387: 
                    388: -35, 8, 25, -34, 7, 
                    389: 42, 33, 
                    390: 17, 38, -40, 37, -39, 34, 35, 10, 10, 9, -38, 36, 
                    391: -50, 1, 
                    392: -52, 31, -51, 
                    393: -45, 1, 
                    394: -47, 31, -46, 
                    395: -48, 1, 
                    396: -49, 21, 
                    397: -41, 4, 
                    398: -42, 19, 
                    399: -43, 5, 
                    400: -44, 20, 
                    401: 32, -19, 14, -18, 12, 27, -17, 24, -16, 23, -15, 13, -14, 12, 27, -13, 16, 12, 24, -12, 23, -11, 18, 40, 12, -10, 1, 6, 12, 
                    402: 12, -25, 5, 15, 
                    403: 
                    404: 17, 
                    405: 
                    406: 32, 
                    407: 
                    408: 22, 39, 
                    409: 0
                    410: };
                    411: struct llprodindex llprodindex[] = {
                    412: {   0,   0,   0 }, {   0,   5,  19 }, {   5,   3,   3 }, {   8,   3,   2 }, 
                    413: {  11,   3,   2 }, {  14,   0,   2 }, {  14,   3,   0 }, {  17,   3,   1 }, 
                    414: {  20,   0,   0 }, {  20,   5,   3 }, {  25,   2,   0 }, {  27,   0,   3 }, 
                    415: {  27,   5,   1 }, {  32,   2,   0 }, {  34,   1,   3 }, {  35,   2,   1 }, 
                    416: {  37,   0,   0 }, {  37,   5,   1 }, {  42,   2,   0 }, {  44,  12,   3 }, 
                    417: {  56,   2,   2 }, {  58,   3,   2 }, {  61,   2,   0 }, {  63,   3,   2 }, 
                    418: {  66,   2,   1 }, {  68,   2,   0 }, {  70,   2,   9 }, {  72,   2,   1 }, 
                    419: {  74,   2,   1 }, {  76,   2,   1 }, {  78,  29,   1 }, { 107,   4,   1 }, 
                    420: { 111,   0,   1 }, { 111,   1,   1 }, { 112,   0,   1 }, { 112,   1,   1 }, 
                    421: { 113,   0,   1 }, { 113,   2,   2 }, {   0,   0,   0 }
                    422: };
                    423: short llepsilon[] = {
                    424:  0, 0, 0, 0, 0, 1, 0, 0, 1, 0,
                    425:  0, 1, 0, 0, 1, 0, 1, 0, 0, 0,
                    426:  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                    427:  0, 0, 1, 0, 1, 0, 1, 0, 0
                    428: };
                    429: struct llparsetable llparsetable[] = {
                    430: {   1,   3 }, {   2,   1 }, {   5,   2 }, {   0,  23 }, {   1,   5 }, 
                    431: {   3,   4 }, {  12,   5 }, {   0,  24 }, {   1,   6 }, {   0,  25 }, 
                    432: {   8,   8 }, {  11,   7 }, {   0,  26 }, {   1,   9 }, {   0,  27 }, 
                    433: {   1,  10 }, {  12,  11 }, {   0,  28 }, {   1,  14 }, {   5,  13 }, 
                    434: {  10,  12 }, {  12,  14 }, {   0,  29 }, {   1,  16 }, {   5,  15 }, 
                    435: {  12,  16 }, {   0,  30 }, {   7,  17 }, {   0,  31 }, {   1,  18 }, 
                    436: {  21,  18 }, {   0,  32 }, {   1,  19 }, {  21,  19 }, {   0,  33 }, 
                    437: {   1,  20 }, {   7,  21 }, {   0,  34 }, {   1,  22 }, {   7,  23 }, 
                    438: {   0,  35 }, {   1,  24 }, {  21,  25 }, {   0,  36 }, {   4,  26 }, 
                    439: {  19,  27 }, {   0,  37 }, {   5,  28 }, {  20,  29 }, {   0,  38 }, 
                    440: {  12,  30 }, {   0,  39 }, {  15,  31 }, {  18,  32 }, {   0,  40 }, 
                    441: {   1,  34 }, {   3,  34 }, {  12,  34 }, {  17,  33 }, {   0,  41 }, 
                    442: {   1,  35 }, {  21,  35 }, {  22,  36 }, {   0,  42 }, {  12,  37 }, 
                    443: {   0,  43 }, {   0,   0 }
                    444: };
                    445: short llparseindex[] = {
                    446:  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                    447:  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                    448:  0, 0, 0, 0, 4, 8, 10, 13, 15, 18,
                    449:  23, 27, 29, 32, 35, 38, 41, 44, 47, 50,
                    450:  52, 55, 60, 64, 0
                    451: };

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