hdiff output

r22274/attribute.tab 2017-01-21 10:39:35.813537298 +0000 r22273/attribute.tab 2017-01-21 10:39:46.554196955 +0000
  1: # attrname        Type                Class        Kind                In                        Accesss  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/attribute.tab' in revision 22273
  2: atomname        T_STRING        C_VAR        K_SCALAR        T_ATOM                        A_DIRECT 
  3: atomnum                T_INT                C_EXPR        K_SCALAR        T_ATOM                        A_FUNCTION 
  4: atomtype        T_STRING        C_VAR        K_SCALAR        T_ATOM                        A_DIRECT 
  5: bfact                T_FLOAT                C_VAR        K_SCALAR        T_ATOM                        A_DIRECT 
  6: charge                T_FLOAT                C_VAR        K_SCALAR        T_ATOM                        A_DIRECT 
  7: element                T_STRING        C_EXPR        K_SCALAR        T_ATOM                        A_DIRECT 
  8: float1                T_FLOAT                C_VAR        K_SCALAR        T_ATOM                        A_DIRECT 
  9: float2                T_FLOAT                C_VAR        K_SCALAR        T_ATOM                        A_DIRECT 
 10: fullname        T_STRING        C_EXPR        K_SCALAR        T_ATOM                        A_FUNCTION 
 11: int1                T_INT                C_VAR        K_SCALAR        T_ATOM                        A_DIRECT 
 12: natoms                T_INT                C_EXPR        K_SCALAR        T_MOLECULE                A_FUNCTION 
 13: nresidues        T_INT                C_EXPR        K_SCALAR        T_MOLECULE                A_FUNCTION 
 14: nstrands        T_INT                C_EXPR        K_SCALAR        T_MOLECULE                A_FUNCTION 
 15: occ                T_FLOAT                C_VAR        K_SCALAR        T_ATOM                        A_DIRECT 
 16: pos                T_POINT                C_VAR        K_SCALAR        T_ATOM                        A_DIRECT 
 17: radius                T_FLOAT                C_VAR        K_SCALAR        T_ATOM                        A_DIRECT 
 18: resid                T_STRING        C_VAR        K_SCALAR        { T_ATOM, T_RESIDUE }        A_DIRECT 
 19: resname                T_STRING        C_VAR        K_SCALAR        { T_ATOM, T_RESIDUE }        A_DIRECT 
 20: resnum                T_INT                C_EXPR        K_SCALAR        { T_ATOM, T_RESIDUE }        A_FUNCTION 
 21: strandname        T_STRING        C_VAR        K_SCALAR        { T_ATOM, T_RESIDUE }        A_DIRECT 
 22: strandnum        T_INT                C_EXPR        K_SCALAR        { T_ATOM, T_RESIDUE }        A_FUNCTION 
 23: tatomnum        T_INT                C_EXPR        K_SCALAR        T_ATOM                        A_FUNCTION 
 24: tresnum                T_INT                C_EXPR        K_SCALAR        { T_ATOM, T_RESIDUE }        A_FUNCTION 
 25: w                T_FLOAT                C_VAR        K_SCALAR        T_ATOM                        A_DIRECT 
 26: x                T_FLOAT                C_VAR        K_SCALAR        { T_POINT, T_ATOM }        A_DIRECT 
 27: y                T_FLOAT                C_VAR        K_SCALAR        { T_POINT, T_ATOM }        A_DIRECT 
 28: z                T_FLOAT                C_VAR        K_SCALAR        { T_POINT, T_ATOM }        A_DIRECT 


r22274/Makefile 2017-01-21 10:39:36.305568081 +0000 r22273/Makefile 2017-01-21 10:39:47.082228743 +0000
162: 162: 
163: sasad.o:  sasad.c163: sasad.o:  sasad.c
164:         $(CC) -c $(OCFLAGS) sasad.c164:         $(CC) -c $(OCFLAGS) sasad.c
165: 165: 
166: 166: 
167: #===========================================================================167: #===========================================================================
168: 168: 
169: clean:169: clean:
170:         -rm -f *.o nab$(SFX) nab2c$(SFX) libnab.a checkexpr.c170:         -rm -f *.o nab$(SFX) nab2c$(SFX) libnab.a checkexpr.c
171:         -rm -f lex.mm_options.c lex.dg_options.c lex.yy.c y.tab.c y.tab.h171:         -rm -f lex.mm_options.c lex.dg_options.c lex.yy.c y.tab.c y.tab.h
172:         (cd ../semantics; make clean )172: #        (cd ../semantics; make clean )
173: 173: 
174: install: system174: install: system
175:         $(CC) -DBINDIR='"$(BINDIR)"' \175:         $(CC) -DBINDIR='"$(BINDIR)"' \
176:                 -DINCDIR='"$(INCDIR)"' \176:                 -DINCDIR='"$(INCDIR)"' \
177:                 -DLIBDIR='"$(LIBDIR)"' \177:                 -DLIBDIR='"$(LIBDIR)"' \
178:                 $(CFLAGS) -DCC='"$(CC)"' -DCPP='"$(CPP)"' -DFLIBS='"$(FLIBS)"' \178:                 $(CFLAGS) -DCC='"$(CC)"' -DCPP='"$(CPP)"' -DFLIBS='"$(FLIBS)"' \
179:                 -o nab_install nab.c179:                 -o nab_install nab.c
180:         -mkdir $(NABHOME)/bin $(NABHOME)/lib180:         -mkdir $(NABHOME)/bin $(NABHOME)/lib
181:         -mkdir $(LIBDIR) $(BINDIR) $(INCDIR)181:         -mkdir $(LIBDIR) $(BINDIR) $(INCDIR)
182:         mv -f  nab_install$(SFX) $(BINDIR)/nab$(SFX)182:         mv -f  nab_install$(SFX) $(BINDIR)/nab$(SFX)


r22274/parse.c 2017-01-21 10:39:36.081554085 +0000 r22273/parse.c 2017-01-21 10:39:46.798211653 +0000
  1: /*  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/parse.c' in revision 22273
  2:  *        This program converts the actions described in the tables 
  3:  *        SYM_*.rules into checkexpr(), the part of the nab compiler that  
  4:  *        ensures that the operands of the various operators have the 
  5:  *        correct attributes and sets the attributes of the operator's  
  6:  *        result. 
  7:  * 
  8:  *        Three operators require special handling.  These are the array 
  9:  *        operator LBRACK and the identifier operators IDENT and ATTRIBUTE. 
 10:  * 
 11:  *        When an array element is used in a nab program, say a[i], this 
 12:  *        is converted into this parse tree: 
 13:  * 
 14:  *                ( LBRACK ( IDENT A ) ( INDEX ( IDENT i ) ) ) 
 15:  * 
 16:  *        Because nab supports both ordinary (indexed by int valued expr's) 
 17:  *        and hashed (indexed by string valued expr's), the INDEX node needs 
 18:  *        to know what kind of array it is associated with in order to decided 
 19:  *        if its subexpression is valid.  However the parse tree contains no 
 20:  *        upward pointers and it is impossible for the INDEX node to determine 
 21:  *        its context.  This problem is solved by maintaining a stack of active 
 22:  *        array refs -- astk[] and astkp.  Each time an INDEX node is encountered 
 23:  *        it checks the kind of the array at the top of this stack and if it is 
 24:  *        K_ARRAY or K_DARRAY, requires an INT valued expr; if it is K_HASHED, 
 25:  *        it requires a STRING valued expr. 
 26:  * 
 27:  *        IDENT requires special handling because the action associated 
 28:  *        with the IDENT depends on whether it is appearing a declaration or 
 29:  *        a statement.  In a statement, the IDENT must have been previously 
 30:  *        declared and the action is to introduce its attr's into the expr; 
 31:  *        in a decl, it must not have been previously declared and when 1st 
 32:  *        encountered will have only its type known;  The class and kind  
 33:  *        can not be determined until the next symbol - '(' for func's, '[' 
 34:  *        for arrays and ',' or ';' for vars has been seen.  The solution here 
 35:  *        is to provide a special case entry for IDENT that check's that it  
 36:  *        has been declared. 
 37:  * 
 38:  *        ATTRIBUTE also requires special handling.  The actions here are to 
 39:  *        look up the attribute and if it is known, return its type, kind and 
 40:  *        class and to print an errormsg if the attribute is unknown.  This 
 41:  *        is done by passing the ATTRIBUTE node to the procedure checkattr() 
 42:  *        which does the lookup and set the n_type, n_class and n_kind fields 
 43:  *        of the ATTRIBUTE node.  The procedure checkattr() is generated from 
 44:  *        attribute.tab by the auxilliary proc mk_checkattr.c 
 45:  * 
 46:  */ 
 47:  
 48: #include <stdio.h> 
 49: #include <string.h> 
 50: #include <stdlib.h> 
 51:  
 52: static        char        *progname; 
 53:  
 54: #define        FALSE        0 
 55: #define        TRUE        1 
 56: #define        UNDEF        (-1) 
 57:  
 58: #define        MAXFIELDS        50 
 59:         static        char        *fields[ MAXFIELDS ]; 
 60:         int        n_fields; 
 61:  
 62:         /* symbols (#defines) from nab.h        */ 
 63:  
 64: #define        TCK_FILE        "src/nab.h" 
 65: static        char        tckfname[ 256 ]; 
 66:  
 67: #define        DEFNAME_SIZE        32 
 68: typedef        struct        def_t        { 
 69:         char        d_name[ DEFNAME_SIZE ]; 
 70:         int        d_val; 
 71:         int        d_used; 
 72: } DEF_T; 
 73:  
 74: #define        TVTAB_SIZE        30 
 75: static        DEF_T        tvtab[ TVTAB_SIZE ]; 
 76: static        int        n_tvtab; 
 77: static        int        v_error; 
 78: static        int        l_utype; 
 79:  
 80: #define        CVTAB_SIZE        10 
 81: static        DEF_T        cvtab[ CVTAB_SIZE ]; 
 82: static        int        n_cvtab; 
 83:  
 84: #define        KVTAB_SIZE        10 
 85: static        DEF_T        kvtab[ KVTAB_SIZE ]; 
 86: static        int        n_kvtab; 
 87:  
 88: #define        AVTAB_SIZE        5 
 89: static        DEF_T        avtab[ AVTAB_SIZE ]; 
 90: static        int        n_avtab; 
 91:  
 92:         /* symbols (#defines) from y.tab.h        */ 
 93:  
 94: #define        SYM_FILE        "src/y.tab.h" 
 95: static        char        symfname[ 256 ]; 
 96:  
 97: #define        SYMTAB_SIZE        300 
 98: static        DEF_T        symtab[ SYMTAB_SIZE ]; 
 99: static        int  n_symtab; 
100:  
101: static        int        getsyms(); 
102: static        int        gettcka(); 
103: static        DEF_T        *finddef(); 
104: static        DEF_T        *finddef_withval(); 
105: static        int        countudefs(); 
106: static        int        defcmp(); 
107:  
108:         /* tokens from the rule files & attribute file        */ 
109:  
110: #define        TOK_EOF                0 
111:  
112: #define        TOK_AKIND        1 
113: #define        TOK_CLASS        2 
114: #define        TOK_CODE        3 
115: #define        TOK_IF                4 
116: #define        TOK_KIND        5 
117: #define        TOK_LEFT        6 
118: #define        TOK_OPERATOR        7 
119: #define        TOK_OUTPUT        8 
120: #define        TOK_PREC        9 
121: #define        TOK_PRINT        10 
122: #define        TOK_RIGHT        11 
123: #define        TOK_SYM                12 
124: #define        TOK_TYPE        13 
125: #define        TOK_USE                14 
126:  
127: #define        TOK_IDENT        15 
128: #define        TOK_STRING        16 
129: #define        TOK_INT                17 
130:  
131: #define        TOK_COMMENT        18 
132:  
133: #define        TOK_EQUAL        19 
134: #define        TOK_LBRACE        20 
135: #define        TOK_RBRACE        21 
136: #define        TOK_LBRACK        22 
137: #define        TOK_RBRACK        23 
138: #define        TOK_COMMA        24 
139: #define        TOK_NL                25 
140: #define        TOK_ERROR        26 
141:  
142: typedef        struct        resword { 
143:         char        *r_name; 
144:         int        r_token; 
145: } RESWORD; 
146:  
147:         /* rule files reserved words        */ 
148:  
149: static        RESWORD        rwords[] = { 
150:         { "akind", TOK_AKIND }, 
151:         { "class", TOK_CLASS }, 
152:         { "code", TOK_CODE }, 
153:         { "if", TOK_IF }, 
154:         { "kind", TOK_KIND }, 
155:         { "left", TOK_LEFT }, 
156:         { "operator", TOK_OPERATOR }, 
157:         { "output", TOK_OUTPUT }, 
158:         { "prec", TOK_PREC }, 
159:         { "print", TOK_PRINT }, 
160:         { "right", TOK_RIGHT }, 
161:         { "sym", TOK_SYM }, 
162:         { "type", TOK_TYPE }, 
163:         { "use", TOK_USE } 
164:          
165: }; 
166: static        int        n_rwords = sizeof( rwords ) / sizeof( RESWORD ); 
167:  
168:         /* attribute information:        */ 
169: #define        ATRFILE        "attribute.tab" 
170: typedef        struct        atrec_t        { 
171:         char        *a_name; 
172:         int        a_type; 
173:         int        a_class; 
174:         int        a_kind; 
175:         int        a_in; 
176:         int        a_access; 
177: } ATREC_T; 
178:  
179: #define        ATTAB_SIZE        50 
180: static        ATREC_T        attab[ ATTAB_SIZE ]; 
181: static        int        n_attab; 
182:  
183: static        int        parse_attrs(); 
184:  
185: static        char        *rfname; 
186: static        int        rfeof = FALSE; 
187: static        char        rfline[ 256 ] = ""; 
188: static        char        *rfp = rfline; 
189:  
190: static        int        readahead = FALSE; 
191: static        int        ra_tok; 
192: static        int        ra_tokval; 
193: static        char        ra_tokstr[ 256 ]; 
194:  
195: static        int        tok; 
196: static        int        tokval; 
197: static        char        tokstr[ 256 ]; 
198:  
199: typedef        struct        trow_t        {         
200:         char        *t_name;         
201:         int        t_nval; 
202:         int        t_nrvals; 
203:         int        *t_rvals; 
204: } TROW_T; 
205:  
206: typedef        struct        ttab_t        { 
207:         int        t_index; 
208:         int        t_nrows; 
209:         TROW_T        **t_rows; 
210: } TTAB_T; 
211:  
212: typedef        struct        rule_t        { 
213:         int        r_sym; 
214:         int        r_prec; 
215:         char        *r_print; 
216:         int        r_lclass; 
217:         int        r_rclass; 
218:         int        r_octok; 
219:         int        r_ocval; 
220:         int        r_nakind; 
221:         int        *r_akind; 
222:         int        r_nlkind; 
223:         int        *r_lkind; 
224:         int        r_nrkind; 
225:         int        *r_rkind; 
226:         int        r_nokind; 
227:         int        *r_oktok; 
228:         int        *r_okval; 
229:         int        *r_okqtok; 
230:         int        *r_okqval; 
231:         int        r_ntypes; 
232:         TTAB_T        *r_types; 
233: } RULE_T; 
234:  
235: #define        KIND_SIZE        10 
236: static        int        a_kind[ KIND_SIZE ]; 
237: static        int        l_kind[ KIND_SIZE ]; 
238: static        int        r_kind[ KIND_SIZE ]; 
239: static        int        o_ktok[ KIND_SIZE ]; 
240: static        int        o_kval[ KIND_SIZE ]; 
241: static        int        o_kqtok[ KIND_SIZE ]; 
242: static        int        o_kqval[ KIND_SIZE ]; 
243:  
244: #define        TTAB_SIZE        5 
245: static        TTAB_T        ttabs[ TTAB_SIZE ]; 
246: static        int        t_index; 
247:  
248: static        RULE_T        **rules; 
249: static        int        n_rules; 
250: static        RULE_T        c_rule; 
251:  
252: static        int        parse_rule(); 
253: static        int        operator();         
254: static        int        class();         
255: static        int        kind();         
256: static        int        type();         
257: static        int        getsetvalue(); 
258: static        int        getovalue(); 
259: static        int        getvecvalue(); 
260:  
261: static        int        gettoken(); 
262: static        void        ungettoken(); 
263: static        void        skiptonl(); 
264:  
265: static        void        clear_rule(); 
266: static        RULE_T        *save_rule(); 
267: static        int        check_rule(); 
268: static        int        check_type(); 
269: static        TROW_T        *findtrow(); 
270: static        void        fprint_rule(); 
271: static        void        fprint_set(); 
272: static        void        fprint_ovalue(); 
273:  
274:         /* HTML versions of the rules:        */ 
275: #define        TWID1        100 
276: #define        TWID2        400 
277: #define        SELSIZE        6 
278:  
279: #define        FRFILE        "frames.html" 
280: #define        CTLFILE        "control.html" 
281: #define        CFSIZE        30 
282: static        char        r1fname[ 256 ] = ""; 
283: static        int        mk_frameset(); 
284: static        int        mk_controlfile(); 
285: static        int        hprint_rule(); 
286: static        char        *str2hstr(); 
287:  
288: #define        CODEFILE        "checkexpr.c" 
289: static        int                mk_checkexpr(); 
290: static        void        mk_checkattr(); 
291: static        void        mk_typetabent(); 
292: static        void        mk_rulecase(); 
293:  
294: static        int        split(); 
295:  
296: char        *getenv(); 
297:  
298: main( argc, argv ) 
299: int        argc; 
300: char        *argv[]; 
301: { 
302:         FILE        *fp; 
303:         int        err, ecnt; 
304:         int        ac, ucnt; 
305:         char        *nabhome; 
306:  
307:         progname = argv[ 0 ]; 
308:         if( argc < 2 ){ 
309:                 fprintf( stderr, "usage: %s rule-files\n",  
310:                         progname ); 
311:                 exit( 1 ); 
312:         } 
313:  
314:         if( ( nabhome = getenv( "NABHOME" ) ) == NULL ){ 
315:                 fprintf( stderr, "%s: NABHOME not defined.\n", progname ); 
316:                 exit( 1 ); 
317:         } 
318:  
319:         sprintf( symfname, "%s/%s", nabhome, SYM_FILE ); 
320:         if( ( fp = fopen( symfname, "r" ) ) == NULL ){ 
321:                 fprintf( stderr, "%s: can't read symbol file %s\n", 
322:                         progname, symfname ); 
323:                 exit( 1 ); 
324:         } 
325:         if( ( n_symtab = getsyms( fp, symtab ) ) == 0 ){ 
326:                 fprintf( stderr, "%s: no symbols.\n", progname ); 
327:                 exit( 1 ); 
328:         } 
329:         fclose( fp ); 
330:         if( n_symtab == 0 ){ 
331:                 fprintf( stderr, "%s: No symbols.\n", progname ); 
332:                 exit( 1 ); 
333:         }else 
334:                 fprintf( stderr, "%s: %3d symbols.\n", progname, n_symtab ); 
335:  
336:         rules = ( RULE_T ** )malloc( n_symtab * sizeof( RULE_T * ) ); 
337:         if( rules == NULL ){ 
338:                 fprintf( stderr, "%s: can't allocate rules.\n", progname ); 
339:                 exit( 1 ); 
340:         } 
341:          
342:         sprintf( tckfname, "%s/%s", nabhome, TCK_FILE ); 
343:         if( ( fp = fopen( tckfname, "r" ) ) == NULL ){ 
344:                 fprintf( stderr, "%s: can't read type/class/kind file %s\n", 
345:                         progname, tckfname ); 
346:                 exit( 1 ); 
347:         } 
348:         if( gettcka( fp, &l_utype, &v_error, &n_tvtab, tvtab, 
349:                 &n_cvtab, cvtab, &n_kvtab, kvtab, &n_avtab, avtab ) ) 
350:                 exit( 1 ); 
351:         fclose( fp ); 
352:         fprintf( stderr, "%s: %3d types, lastuser = %d, v_error = %d.\n", 
353:                 progname, n_tvtab, l_utype, v_error );  
354:         fprintf( stderr, "%s: %3d classes.\n", progname, n_cvtab );  
355:         fprintf( stderr, "%s: %3d kinds.\n", progname, n_kvtab );  
356:         fprintf( stderr, "%s: %3d accesses.\n", progname, n_avtab );  
357:  
358:         /* experimental stuff: do attribute checkin here,        */ 
359:         /* create the file checkattr() from the file ATRFILE        */ 
360:  
361:         if( ( fp = fopen( ATRFILE, "r" ) ) == NULL ){ 
362:                 fprintf( stderr, "%s: can't read attibute file %s.\n", 
363:                         progname, ATRFILE ); 
364:                 exit( 1 ); 
365:         } 
366:         rfname = ATRFILE; 
367:         rfeof = FALSE; 
368:         err = parse_attrs( fp, &n_attab, attab ); 
369:         fclose( fp ); 
370:         if( n_attab == 0 ){         
371:                 fprintf( stderr, "%s: No attributes.\n", progname );  
372:                 exit( 1 ); 
373:         }else 
374:                 fprintf( stderr, "%s: %3d attributes.\n", progname, n_attab );  
375:  
376:  
377:         for( t_index = 0, n_rules = 0, ecnt = 0, ac = 1; ac < argc; ac++ ){ 
378:                 err = 0; 
379:                 if( ( fp = fopen( argv[ ac ], "r" ) ) == NULL ){ 
380:                         fprintf( stderr, "%s: can't read rule-file %s.\n", 
381:                                 progname, argv[ ac ] ); 
382:                         ecnt++; 
383:                         continue; 
384:                 }else{ 
385:                         rfname = argv[ ac ]; 
386:                         rfeof = FALSE; 
387:                 } 
388:                 clear_rule( &c_rule ); 
389:                 err = parse_rule( fp, &c_rule ); 
390:                 fclose( fp ); 
391:                 if( err ){ 
392:                         ecnt++; 
393:                         continue; 
394:                 } 
395:                 if( err = check_rule( &c_rule ) ){ 
396:                         ecnt++; 
397:                         continue; 
398:                 } 
399:  
400:                 rules[ n_rules ] = save_rule( &c_rule ); 
401:                 if( rules[ n_rules ] == NULL ) 
402:                         exit( 1 );        /* end of the world!        */ 
403:                 n_rules++; 
404:  
405:                 if( ( fp = fopen( argv[ ac ], "w" ) ) == NULL ){ 
406:                         fprintf( stderr, 
407:                         "%s: can't rewrite rule-file %s.\n", 
408:                                 progname, argv[ ac ] ); 
409:                         ecnt++; 
410:                         continue; 
411:                 } 
412:                 fprint_rule( fp, &c_rule ); 
413:                 fclose( fp ); 
414:                 if( err = hprint_rule( argv[ ac ], &c_rule ) ) 
415:                         ecnt++; 
416:         } 
417:  
418:         if( mk_frameset() ) 
419:                 ecnt++; 
420:         if( mk_controlfile() ) 
421:                 ecnt++; 
422:  
423:         mk_checkexpr(); 
424:  
425:         fprintf( stderr, "%s: %3d rules.\n", progname, n_rules );  
426:         ucnt = countudefs( n_symtab, symtab ); 
427:         fprintf( stderr, "%s: %3d used symbols.\n", progname, ucnt );  
428:         ucnt = countudefs( n_tvtab, tvtab ); 
429:         fprintf( stderr, "%s: %3d used types.\n", progname, ucnt );  
430:         ucnt = countudefs( n_cvtab, cvtab ); 
431:         fprintf( stderr, "%s: %3d used classes.\n", progname, ucnt );  
432:         ucnt = countudefs( n_kvtab, kvtab ); 
433:         fprintf( stderr, "%s: %3d used kinds.\n", progname, ucnt );  
434:         fprintf( stderr, "%s: %3d errors.\n", progname, ecnt ); 
435:  
436:         exit( ecnt > 0 ); 
437: } 
438:  
439: static        int        getsyms( fp, symtab ) 
440: FILE        *fp; 
441: DEF_T        symtab[]; 
442: { 
443:         char        line[ 256 ]; 
444:         DEF_T        *sp; 
445:  
446:         for( sp = symtab; fgets( line, sizeof( line ), fp ); sp++ ){ 
447:                 sscanf( line, "# define %s %d", sp->d_name, &sp->d_val ); 
448:                 sp->d_used = FALSE; 
449:         } 
450:         return( sp - symtab ); 
451: } 
452:  
453: static        int        gettcka( fp, l_utype, v_error, n_tvtab, tvtab, 
454:         n_cvtab, cvtab, n_kvtab, kvtab, n_avtab, avtab ) 
455: FILE        *fp; 
456: int        *l_utype; 
457: int        *v_error; 
458: int        *n_tvtab; 
459: DEF_T        tvtab[]; 
460: int        *n_cvtab; 
461: DEF_T        cvtab[]; 
462: int        *n_kvtab; 
463: DEF_T        kvtab[]; 
464: int        *n_avtab; 
465: DEF_T        avtab[]; 
466: { 
467:         char        line[ 256 ]; 
468:         DEF_T        *tvp, *tvp1, *cvp, *kvp, *avp; 
469:         int        found, err; 
470:         int        f, i; 
471:  
472:         err = FALSE; 
473:         *l_utype = *n_tvtab = *n_cvtab = *n_kvtab = *n_avtab = 0; 
474:         *v_error = UNDEF; 
475:         tvp = tvtab; 
476:         cvp = cvtab; 
477:         kvp = kvtab; 
478:         avp = avtab; 
479:         while( fgets( line, sizeof( line ), fp ) ){ 
480:                 n_fields = split( line, fields, " \t\n" ); 
481:                 if( n_fields < 3 ){  
482:                         for( f = 0; f < n_fields; f++ ) 
483:                                 free( fields[ f ] ); 
484:                         continue; 
485:                 } 
486:                 if( strcmp( fields[ 0 ], "#define" ) ){ 
487:                         for( f = 0; f < n_fields; f++ ) 
488:                                 free( fields[ f ] ); 
489:                         continue; 
490:                 } 
491:                 if( !strncmp( fields[ 1 ], "T_", 2 ) ){ 
492:                         if( !strcmp( fields[ 1 ], "T_LASTUSER" ) ){ 
493:                                 tvp1 = tvtab; 
494:                                 found = 0; 
495:                                 for( i = 0; i < *n_tvtab; i++, tvp1++ ){ 
496:                                         if(!strcmp( tvp1->d_name, fields[2] )){ 
497:                                                 found = 1; 
498:                                                 break; 
499:                                         } 
500:                                 } 
501:                                 if( !found ){ 
502:                                         fprintf( stderr,  
503:                         "%s: gettcka: T_LASTUSER value %s not defined.\n", 
504:                                                 progname, fields[2] ); 
505:                                         return( TRUE ); 
506:                                 }else 
507:                                         *l_utype = tvp1->d_val; 
508:                         }else{ 
509:                                 strcpy( tvp->d_name, fields[ 1 ] ); 
510:                                 tvp->d_val = atoi( fields[ 2 ] ); 
511:                                 tvp->d_used = 0; 
512:                                 tvp++; 
513:                                 ( *n_tvtab )++; 
514:                         } 
515:                 }else if( !strncmp( fields[ 1 ], "C_", 2 ) ){ 
516:                         strcpy( cvp->d_name, fields[ 1 ] ); 
517:                         cvp->d_val = atoi( fields[ 2 ] ); 
518:                         cvp->d_used = 0; 
519:                         cvp++; 
520:                         ( *n_cvtab )++; 
521:                 }else if( !strncmp( fields[ 1 ], "K_", 2 ) ){ 
522:                         strcpy( kvp->d_name, fields[ 1 ] ); 
523:                         kvp->d_val = atoi( fields[ 2 ] ); 
524:                         kvp->d_used = 0; 
525:                         kvp++; 
526:                         ( *n_kvtab )++; 
527:                 }else if( !strncmp( fields[ 1 ], "A_", 2 ) ){ 
528:                         strcpy( avp->d_name, fields[ 1 ] ); 
529:                         avp->d_val = atoi( fields[ 2 ] ); 
530:                         avp->d_used = 0; 
531:                         avp++; 
532:                         ( *n_avtab )++; 
533:                 } 
534:                 for( f = 0; f < n_fields; f++ ) 
535:                         free( fields[ f ] ); 
536:         } 
537:         if( *n_tvtab == 0 ){ 
538:                 fprintf( stderr, 
539:                         "%s: gettcka: no types (T_* defines) found.\n", 
540:                         progname ); 
541:                 err = TRUE; 
542:         } 
543:         for( tvp = tvtab, i = 0; i < *n_tvtab; i++, tvp++ ){ 
544:                 if( tvp->d_val != i ){ 
545:                         fprintf( stderr, 
546:                 "%s: gettcka: type %s has value %d should have value %d.\n", 
547:                                 progname, tvp->d_name, tvp->d_val, i ); 
548:                         err = TRUE; 
549:                 } 
550:                 if( !strcmp( tvp->d_name, "T_ERROR" ) ) 
551:                         *v_error = tvp->d_val; 
552:         } 
553:         if( *v_error == UNDEF ){ 
554:                 fprintf( stderr, 
555:                         "%s: gettcka: no #define for T_ERROR.\n", progname ); 
556:                 err = TRUE; 
557:         } 
558:         if( *n_cvtab == 0 ){ 
559:                 fprintf( stderr, "gettcka: no classes (C_* defines) found.\n" ); 
560:                 err = TRUE; 
561:         } 
562:         for( cvp = cvtab, i = 0; i < *n_cvtab; i++, cvp++ ){ 
563:                 if( cvp->d_val != i ){ 
564:                         fprintf( stderr, 
565:                 "%s: gettcka: class %s has value %d should have value %d.\n", 
566:                                 progname, cvp->d_name, cvp->d_val, i ); 
567:                         err = TRUE; 
568:                 } 
569:         } 
570:         if( *n_kvtab == 0 ){ 
571:                 fprintf( stderr, "gettcka: no kinds (K_* defines) found.\n" ); 
572:                 err = TRUE; 
573:         } 
574:         for( kvp = kvtab, i = 0; i < *n_kvtab; i++, kvp++ ){ 
575:                 if( kvp->d_val != i ){ 
576:                         fprintf( stderr, 
577:                 "%s: gettcka: kind %s has value %d should have value %d.\n", 
578:                                 progname, kvp->d_name, kvp->d_val, i ); 
579:                         err = TRUE; 
580:                 } 
581:         } 
582:         if( *n_avtab == 0 ){ 
583:                 fprintf( stderr, "gettcka: no accesses (A_* defines) found.\n" ); 
584:                 err = TRUE; 
585:         } 
586:         for( avp = avtab, i = 0; i < *n_avtab; i++, avp++ ){ 
587:                 if( avp->d_val != i ){ 
588:                         fprintf( stderr, 
589:                 "%s: gettcka: access %s has value %d should have value %d.\n", 
590:                                 progname, avp->d_name, avp->d_val, i ); 
591:                         err = TRUE; 
592:                 } 
593:         } 
594:         return( err ); 
595: } 
596:  
597: static        DEF_T        *finddef( name, n_tab, tab ) 
598: char        name[]; 
599: int        n_tab; 
600: DEF_T        tab[]; 
601: { 
602:         int        i; 
603:         DEF_T        *dp; 
604:  
605:         for( dp = tab, i = 0; i < n_tab; i++, dp++ ){ 
606:                 if( !strcmp( name, dp->d_name ) ) 
607:                         return( dp ); 
608:         } 
609:         return( NULL ); 
610: } 
611:  
612: static        DEF_T        *finddef_withval( val, n_tab, tab ) 
613: int        val; 
614: int        n_tab; 
615: DEF_T        tab[]; 
616: { 
617:         int        i; 
618:         DEF_T        *dp; 
619:  
620:         for( dp = tab, i = 0; i < n_tab; i++, dp++ ){ 
621:                 if( val == dp->d_val ) 
622:                         return( dp ); 
623:         } 
624:         return( NULL ); 
625: } 
626:  
627: static        int        countudefs( n_tab, tab ) 
628: int        n_tab; 
629: DEF_T        tab[]; 
630: { 
631:         int        i, cnt; 
632:         DEF_T        *dp; 
633:  
634:         for( cnt = 0, dp = tab, i = 0; i < n_tab; i++, dp++ ) 
635:                 cnt = dp->d_used ? cnt + 1 : cnt; 
636:         return( cnt ); 
637: } 
638:  
639: static        int        defcmp( d1, d2 ) 
640: DEF_T        **d1; 
641: DEF_T        **d2; 
642: { 
643:  
644:         return( strcmp( ( *d1 )->d_name, ( *d2 )->d_name ) ); 
645: } 
646:  
647: static        int        parse_attrs( fp, n_attab, attab ) 
648: FILE        *fp; 
649: int        *n_attab; 
650: ATREC_T        attab[]; 
651: { 
652:         int        err; 
653:         int        na; 
654:         ATREC_T        *ap; 
655:         char        *sp; 
656:         DEF_T        *dp; 
657:         int        val, t_idx; 
658:  
659:         err = FALSE; 
660:         *n_attab = 0; 
661:         for( na = 0; gettoken( fp ); ){ 
662:                 if( tok == TOK_IDENT ){ 
663:                         ap = &attab[ na ];  
664:                         na++; 
665:                         sp = ( char * )malloc( strlen( tokstr ) + 1 ); 
666:                         strcpy( sp, tokstr ); 
667:                         ap->a_name = sp; 
668:                         ap->a_type = 0; 
669:                         ap->a_class = 0; 
670:                         ap->a_kind = 0; 
671:                         ap->a_in = 0;                /* set of types        */ 
672:                         ap->a_access = 0; 
673:                         gettoken( fp ); 
674:                         if( tok == TOK_IDENT ){         
675:                                 dp = finddef( tokstr, n_tvtab, tvtab ); 
676:                                 if( dp == NULL ){ 
677:                                         fprintf( stderr, 
678:                                                 "%s: undefined type %s.\n",  
679:                                                 rfname, tokstr ); 
680:                                         err = TRUE; 
681:                                         goto skip; 
682:                                 }else 
683:                                         ap->a_type = dp->d_val; 
684:                         }else{ 
685:                                 fprintf( stderr, 
686:                                         "%s: attribute %s -- bad type value.\n", 
687:                                         rfname, ap->a_name ); 
688:                                 err = TRUE; 
689:                                 goto skip; 
690:                         } 
691:                         gettoken( fp ); 
692:                         if( tok == TOK_IDENT ){         
693:                                 dp = finddef( tokstr, n_cvtab, cvtab ); 
694:                                 if( dp == NULL ){ 
695:                                         fprintf( stderr, 
696:                                                 "%s: undefined class %s.\n",  
697:                                                 rfname, tokstr ); 
698:                                         err = TRUE; 
699:                                         goto skip; 
700:                                 }else 
701:                                         ap->a_class = dp->d_val; 
702:                         }else{ 
703:                                 fprintf( stderr, 
704:                                 "%s: attribute %s -- bad class value.\n", 
705:                                         rfname, ap->a_name ); 
706:                                 err = TRUE; 
707:                                 goto skip; 
708:                         } 
709:                         gettoken( fp ); 
710:                         if( tok == TOK_IDENT ){         
711:                                 dp = finddef( tokstr, n_kvtab, kvtab ); 
712:                                 if( dp == NULL ){ 
713:                                         fprintf( stderr, 
714:                                                 "%s: undefined kind %s.\n",  
715:                                                 rfname, tokstr ); 
716:                                         err = TRUE; 
717:                                         goto skip; 
718:                                 }else 
719:                                         ap->a_kind = dp->d_val; 
720:                         }else{ 
721:                                 fprintf( stderr, 
722:                                         "%s: attribute %s -- bad kind value.\n", 
723:                                         rfname, ap->a_name ); 
724:                                 err = TRUE; 
725:                                 goto skip; 
726:                         } 
727:                         err |= getsetvalue( fp, "attribute in vals", 
728:                                 n_tvtab, tvtab, &val, &t_idx ); 
729:                         ap->a_in = val; 
730:                         if( tok == TOK_IDENT ){ 
731:                                 dp = finddef( tokstr, n_avtab, avtab ); 
732:                                 if( dp == NULL ){ 
733:                                         fprintf( stderr, 
734:                                                 "%s: undefined access %s.\n",  
735:                                                 rfname, tokstr ); 
736:                                         err = TRUE; 
737:                                         goto skip; 
738:                                 }else 
739:                                         ap->a_access = dp->d_val; 
740:                         }else{ 
741:                                 fprintf( stderr, 
742:                                         "%s: attribute %s -- bad access value.\n", 
743:                                         rfname, ap->a_name ); 
744:                                 err = TRUE; 
745:                                 goto skip; 
746:                         } 
747:                 }else if( tok != TOK_COMMENT && tok != TOK_NL ){ 
748:                         fprintf( stderr, "%s: syntax error '%s'.\n", 
749:                                 rfname, tokstr ); 
750:                 } 
751:         skip : ; 
752:                 skiptonl( fp ); 
753:         } 
754:         *n_attab = na; 
755:         return( err ); 
756: } 
757:  
758: static        int        parse_rule( fp, rp ) 
759: FILE        *fp; 
760: RULE_T        *rp; 
761: { 
762:         int        err; 
763:          
764:         err = FALSE; 
765:         while( gettoken( fp ) ){ 
766:                 if( tok == TOK_OPERATOR ){ 
767:                         skiptonl( fp ); 
768:                         err |= operator( fp, rp ); 
769:                 }else if( tok == TOK_CLASS ){ 
770:                         skiptonl( fp ); 
771:                         err |= class( fp, rp ); 
772:                 }else if( tok == TOK_KIND ){ 
773:                         skiptonl( fp ); 
774:                         err |= kind( fp, rp ); 
775:                 }else if( tok == TOK_TYPE ){ 
776:                         err |= type( fp, rp ); 
777:                 }else if( tok == TOK_CODE ){ 
778:                         skiptonl( fp ); 
779:                 }else if( tok == TOK_ERROR ){ 
780:                         fprintf( stderr, 
781:                                 "%s: syntax error: tokstr = '%s'\n", 
782:                                 rfname, tokstr ); 
783:                         skiptonl( fp ); 
784:                         err = TRUE; 
785:                 } 
786:         } 
787:         return( err ); 
788: } 
789:  
790: static        int        operator( fp, rp ) 
791: FILE        *fp; 
792: RULE_T        *rp; 
793: { 
794:         int        err; 
795:         char        *sp; 
796:         DEF_T        *dp; 
797:         int        g_sym, g_prec, g_print; 
798:  
799:         err = FALSE; 
800:         g_sym = g_prec = g_print = FALSE; 
801:         while( gettoken( fp ) ){ 
802:                 if( tok == TOK_SYM ){ 
803:                         if( g_sym ){ 
804:                                 fprintf( stderr, 
805:                                 "%s: operator part: mulitple sym entries.\n", 
806:                                         rfname ); 
807:                                 err = TRUE; 
808:                                 skiptonl( fp ); 
809:                                 continue; 
810:                         }else 
811:                                 g_sym = TRUE; 
812:                         gettoken( fp ); 
813:                         if( tok == TOK_EQUAL ){ 
814:                                 gettoken( fp ); 
815:                                 if( tok == TOK_IDENT ){ 
816:                                         if(dp=finddef(tokstr,n_symtab,symtab)){ 
817:                                                 rp->r_sym = dp->d_val; 
818:                                                 dp->d_used = TRUE; 
819:                                         }else{ 
820:                                                 fprintf( stderr, 
821:                                 "%s: operator part: undefined sym %s.\n", 
822:                                                         rfname, tokstr ); 
823:                                                 return( TRUE ); 
824:                                         } 
825:                                 }else 
826:                                         err = TRUE; 
827:                         }else 
828:                                 err = TRUE; 
829:                         skiptonl( fp ); 
830:                 }else if( tok == TOK_PREC ){ 
831:                         if( g_prec ){ 
832:                                 fprintf( stderr, 
833:                                 "%s: operator part: multiple prec entries.\n", 
834:                                         rfname ); 
835:                                 err = TRUE; 
836:                                 skiptonl( fp ); 
837:                                 continue; 
838:                         }else 
839:                                 g_prec = TRUE; 
840:                         gettoken( fp ); 
841:                         if( tok == TOK_EQUAL ){ 
842:                                 gettoken( fp ); 
843:                                 if( tok == TOK_INT ) 
844:                                         rp->r_prec = tokval; 
845:                                 else 
846:                                         err = TRUE; 
847:                         }else 
848:                                 err = TRUE; 
849:                         skiptonl( fp ); 
850:                 }else if( tok == TOK_PRINT ){ 
851:                         if( g_print ){ 
852:                                 fprintf( stderr, 
853:                                 "%s: operator part: mulitple print entries.\n", 
854:                                         rfname ); 
855:                                 err = TRUE; 
856:                                 skiptonl( fp ); 
857:                                 continue; 
858:                         }else 
859:                                 g_print = TRUE; 
860:                         gettoken( fp ); 
861:                         if( tok == TOK_EQUAL ){ 
862:                                 gettoken( fp ); 
863:                                 if( tok == TOK_STRING ){ 
864:                                         sp = ( char * )malloc( 
865:                                                 strlen( tokstr ) + 1 ); 
866:                                         strcpy( sp, tokstr ); 
867:                                         rp->r_print = sp; 
868:                                 }else 
869:                                         err = TRUE; 
870:                         }else 
871:                                 err = TRUE; 
872:                         skiptonl( fp ); 
873:                 }else if( tok != TOK_NL && tok != TOK_COMMENT ){ 
874:                         ungettoken(); 
875:                         break; 
876:                 } 
877:         } 
878:         if( !g_sym ){ 
879:                 fprintf( stderr, 
880:                         "%s: operator part: no sym entry.\n", rfname ); 
881:                 err = TRUE; 
882:         } 
883:         if( !g_prec ){ 
884:                 fprintf( stderr, 
885:                         "%s: operator: no prec entry.\n", rfname ); 
886:                 err = TRUE; 
887:         } 
888:         if( !g_prec ){ 
889:                 fprintf( stderr, 
890:                         "%s: operator: no print entry.\n", rfname ); 
891:                 err = TRUE; 
892:         } 
893:         return( err ); 
894: } 
895:  
896: static        int        class( fp, rp ) 
897: FILE        *fp; 
898: RULE_T        *rp; 
899: { 
900:         int        err; 
901:         int        val, t_idx; 
902:         int        otok, oval, qtok, qval; 
903:         int        g_left, g_right, g_output; 
904:          
905:         err = FALSE; 
906:         g_left = g_right = g_output = FALSE; 
907:         while( gettoken( fp ) ){ 
908:                 if( tok == TOK_LEFT ){ 
909:                         if( g_left ){ 
910:                                 fprintf( stderr, 
911:                                 "%s: class part: multiple left entries.\n", 
912:                                         rfname ); 
913:                                         err = TRUE; 
914:                                 skiptonl( fp ); 
915:                                 continue; 
916:                         }else 
917:                                 g_left = TRUE; 
918:                         gettoken( fp ); 
919:                         if( tok == TOK_EQUAL ){ 
920:                                 err |= getsetvalue( fp, "class part: left", 
921:                                         n_cvtab, cvtab, &val, &t_idx ); 
922:                                 if( !err ) 
923:                                         rp->r_lclass = val; 
924:                         }else 
925:                                 err = TRUE; 
926:                         skiptonl( fp ); 
927:                 }else if( tok == TOK_RIGHT ){ 
928:                         if( g_right ){ 
929:                                 fprintf( stderr, 
930:                         "%s: class part: multiple right class entries.\n", 
931:                                         rfname ); 
932:                                         err = TRUE; 
933:                                 skiptonl( fp ); 
934:                                 continue; 
935:                         }else 
936:                                 g_right = TRUE; 
937:                         gettoken( fp ); 
938:                         if( tok == TOK_EQUAL ){ 
939:                                 err |= getsetvalue( fp, "class part: right", 
940:                                         n_cvtab, cvtab, &val, &t_idx ); 
941:                                 if( !err ) 
942:                                         rp->r_rclass = val; 
943:                         }else 
944:                                 err = TRUE; 
945:                         skiptonl( fp ); 
946:                 }else if( tok == TOK_OUTPUT ){ 
947:                         if( g_output ){ 
948:                                 fprintf( stderr, 
949:                         "%s: class part: multiple output class entries.\n", 
950:                                         rfname ); 
951:                                         err = TRUE; 
952:                                 skiptonl( fp ); 
953:                                 continue; 
954:                         }else 
955:                                 g_output = TRUE; 
956:                         gettoken( fp ); 
957:                         if( tok == TOK_EQUAL ){ 
958:                                 err |= getovalue( fp, "class part: output", 
959:                                         n_cvtab, cvtab, 
960:                                         &otok, &oval, &qtok, &qval ); 
961:                                 if( !err ){ 
962:                                         rp->r_octok = otok; 
963:                                         rp->r_ocval = oval; 
964:                                 } 
965:                         }else 
966:                                 err = TRUE; 
967:                         skiptonl( fp ); 
968:                 }else if( tok != TOK_NL && tok != TOK_COMMENT ){ 
969:                         ungettoken(); 
970:                         break; 
971:                 } 
972:         } 
973:         if( !g_left && !g_right ){ 
974:                 fprintf( stderr, 
975:                         "%s: class part: no input class entries.\n", 
976:                         rfname ); 
977:                 err = TRUE; 
978:         } 
979:         if( !g_output ){ 
980:                 fprintf( stderr, 
981:                         "%s: class part: no output class entry.\n", 
982:                         rfname ); 
983:                 err = TRUE; 
984:         } 
985:         return( err ); 
986: } 
987:  
988: static        int        kind( fp, rp ) 
989: FILE        *fp; 
990: RULE_T        *rp; 
991: { 
992:         int        err, mkind; 
993:         int        val, t_idx; 
994:         int        otok, oval; 
995:         int        g_akind, g_left, g_right, g_output; 
996:         int        qtok, qval; 
997:         int        i, j; 
998:          
999:         err = FALSE; 
1000:         mkind = FALSE; 
1001:         g_akind = g_left = g_right = g_output = FALSE; 
1002:         while( gettoken( fp ) ){ 
1003:                 if( tok == TOK_AKIND ){ 
1004:                         g_akind = TRUE; 
1005:                         gettoken( fp ); 
1006:                         if( tok == TOK_EQUAL ){ 
1007:                                 err |= getsetvalue( fp, "kind part: array", 
1008:                                         n_kvtab, kvtab, &val, &t_idx ); 
1009:                                 if( !err ){ 
1010:                                         rp->r_akind[rp->r_nakind] = val; 
1011:                                         rp->r_nakind++; 
1012:                                 } 
1013:                         }else 
1014:                                 err = TRUE; 
1015:                         skiptonl( fp ); 
1016:                 }else if( tok == TOK_LEFT ){ 
1017:                         g_left = TRUE; 
1018:                         gettoken( fp ); 
1019:                         if( tok == TOK_EQUAL ){ 
1020:                                 err |= getsetvalue( fp, "kind part: left", 
1021:                                         n_kvtab, kvtab, &val, &t_idx ); 
1022:                                 if( !err ){ 
1023:                                         rp->r_lkind[rp->r_nlkind] = val; 
1024:                                         rp->r_nlkind++; 
1025:                                 } 
1026:                         }else 
1027:                                 err = TRUE; 
1028:                         skiptonl( fp ); 
1029:                 }else if( tok == TOK_RIGHT ){ 
1030:                         g_right = TRUE; 
1031:                         gettoken( fp ); 
1032:                         if( tok == TOK_EQUAL ){ 
1033:                                 err |= getsetvalue( fp, "kind part: right", 
1034:                                         n_kvtab, kvtab, &val, &t_idx ); 
1035:                                 if( !err ){ 
1036:                                         rp->r_rkind[rp->r_nrkind] = val; 
1037:                                         rp->r_nrkind++; 
1038:                                 } 
1039:                         }else 
1040:                                 err = TRUE; 
1041:                         skiptonl( fp ); 
1042:                 }else if( tok == TOK_OUTPUT ){ 
1043:                         g_output = TRUE; 
1044:                         gettoken( fp ); 
1045:                         if( tok == TOK_EQUAL ){ 
1046:                                 err |= getovalue( fp, "kind part: output", 
1047:                                         n_kvtab, kvtab, &otok, &oval, 
1048:                                         &qtok, &qval ); 
1049:                                 if( !err ){ 
1050:                                         rp->r_oktok[rp->r_nokind] = otok; 
1051:                                         rp->r_okval[rp->r_nokind] = oval; 
1052:                                         rp->r_okqtok[rp->r_nokind] = qtok; 
1053:                                         rp->r_okqval[rp->r_nokind] = qval; 
1054:                                         rp->r_nokind++; 
1055:                                 } 
1056:                         }else 
1057:                                 err = TRUE; 
1058:                         skiptonl( fp ); 
1059:                 }else if( tok != TOK_NL && tok != TOK_COMMENT ){ 
1060:                         ungettoken(); 
1061:                         break; 
1062:                 } 
1063:         } 
1064:         if( g_akind ){ 
1065:                 if( !g_left ){ 
1066:                         fprintf( stderr, "%s: kind part: no left entry.\n", 
1067:                                 rfname ); 
1068:                         err = TRUE; 
1069:                 } 
1070:                 if( !g_right ){ 
1071:                         fprintf( stderr, "%s: kind part: no right entry.\n", 
1072:                                 rfname ); 
1073:                         err = TRUE; 
1074:                 } 
1075:         }else if( !g_left && !g_right ){ 
1076:                 fprintf( stderr, "%s: kind part: no left/right entries.\n", 
1077:                         rfname ); 
1078:                 err = TRUE; 
1079:         } 
1080:         if( !g_output ){ 
1081:                 fprintf( stderr, 
1082:                         "%s: kind part: no output entry.\n", 
1083:                         rfname ); 
1084:                 err = TRUE; 
1085:         } 
1086:         for( i = 0; i < rp->r_nakind - 1; i++ ){ 
1087:                 for( j = i + 1; j < rp->r_nakind; j++ ){ 
1088:                         if( rp->r_akind[i] & rp->r_akind[j] ){ 
1089:                                 err = TRUE; 
1090:                                 fprintf( stderr,  
1091:                 "%s: kind part: akind entries %d and %d have common members.\n", 
1092:                                         rfname, i+1, j+1 ); 
1093:                         } 
1094:                 } 
1095:         } 
1096:         for( i = 0; i < rp->r_nlkind - 1; i++ ){ 
1097:                 for( j = i + 1; j < rp->r_nlkind; j++ ){ 
1098:                         if( rp->r_lkind[i] & rp->r_lkind[j] ){ 
1099:                                 err = TRUE; 
1100:                                 fprintf( stderr,  
1101:                 "%s: kind part: left entries  %d and %d have common members.\n", 
1102:                                         rfname, i+1, j+1 ); 
1103:                         } 
1104:                 } 
1105:         } 
1106:         for( i = 0; i < rp->r_nrkind - 1; i++ ){ 
1107:                 for( j = i + 1; j < rp->r_nrkind; j++ ){ 
1108:                         if( rp->r_rkind[i] & rp->r_rkind[j] ){ 
1109:                                 err = TRUE; 
1110:                                 fprintf( stderr,  
1111:                 "%s: kind part: right entries %d and %d have common members.\n", 
1112:                                         rfname, i+1, j+1 ); 
1113:                         } 
1114:                 } 
1115:         } 
1116:         if( rp->r_nakind > 1 ) 
1117:                 mkind = TRUE; 
1118:         if( rp->r_nlkind > 1 ){ 
1119:                 if( mkind ){ 
1120:                         fprintf( stderr, 
1121:         "%s: kind part: only 1 of akind, left, right can have >1 entry.\n", 
1122:                                 rfname ); 
1123:                         err = TRUE; 
1124:                 } 
1125:                 mkind = TRUE; 
1126:         } 
1127:         if( rp->r_nrkind > 1 ){ 
1128:                 if( mkind ){ 
1129:                         fprintf( stderr, 
1130:         "%s: kind part: only 1 of akind, left, right can have >1 entry.\n", 
1131:                                 rfname ); 
1132:                         err = TRUE; 
1133:                 } 
1134:                 mkind = TRUE; 
1135:         } 
1136:         return( err ); 
1137: } 
1138:  
1139: static        int        getsetvalue( fp, ctxt, n_tab, tab, val, t_idx ) 
1140: FILE        *fp; 
1141: char        ctxt[]; 
1142: int        n_tab; 
1143: DEF_T        tab[]; 
1144: int        *val; 
1145: int        *t_idx; 
1146: { 
1147:         int        cnt; 
1148:         DEF_T        *dp; 
1149:          
1150:         *val = 0; 
1151:         *t_idx = 1; 
1152:         gettoken( fp ); 
1153:         if( tok == TOK_IDENT ){ 
1154:                 if( dp = finddef( tokstr, n_tab, tab ) ){ 
1155:                         *val = 1 << dp->d_val; 
1156:                         dp->d_used = TRUE; 
1157:                 }else{ 
1158:                         fprintf( stderr, "%s: %s entry %s undefined.\n", 
1159:                                 rfname, ctxt, tokstr ); 
1160:                         return( TRUE ); 
1161:                 } 
1162:                 gettoken( fp ); 
1163:         }else if( tok == TOK_LBRACE ){ 
1164:                 for( cnt = 0; ; ){ 
1165:                         gettoken( fp ); 
1166:                         if( tok != TOK_IDENT ){ 
1167:                                 fprintf( stderr, 
1168:                                 "%s: %s set -- syntax error.\n", 
1169:                                         rfname, ctxt ); 
1170:                                 return( TRUE ); 
1171:                         } 
1172:                         if( dp = finddef( tokstr, n_tab, tab ) ){ 
1173:                                 *val |= 1 << dp->d_val; 
1174:                                 dp->d_used = TRUE; 
1175:                                 cnt++; 
1176:                         }else{ 
1177:                                 fprintf( stderr, "%s: %s entry %s undefined.\n", 
1178:                                         rfname, ctxt, tokstr ); 
1179:                                 return( TRUE ); 
1180:                         } 
1181:                         gettoken( fp ); 
1182:                         if( tok == TOK_COMMA ) 
1183:                                 continue; 
1184:                         else if( tok == TOK_RBRACE ){ 
1185:                                 gettoken( fp ); 
1186:                                 break; 
1187:                         }else{ 
1188:                                 fprintf( stderr, 
1189:                                 "%s: %s set -- syntax error.\n", 
1190:                                         rfname, ctxt ); 
1191:                                 return( TRUE ); 
1192:                         } 
1193:                 } 
1194:                 if( cnt == 0 ){ 
1195:                         fprintf( stderr, 
1196:                                 "%s: %s set is empty.\n", 
1197:                                 rfname, ctxt ); 
1198:                         return( TRUE ); 
1199:                 } 
1200:         } 
1201:         if( tok == TOK_USE ){ 
1202:                 gettoken( fp ); 
1203:                 if( tok == TOK_TYPE ){ 
1204:                         gettoken( fp ); 
1205:                         if( tok == TOK_EQUAL ){ 
1206:                                 gettoken( fp ); 
1207:                                 if( tok == TOK_INT ) 
1208:                                         *t_idx = tokval; 
1209:                                 else{ 
1210:                                         fprintf( stderr, 
1211:                                         "%s: %s use clause -- syntax error.\n", 
1212:                                                 rfname, ctxt ); 
1213:                                         return( TRUE ); 
1214:                                 } 
1215:                         }else{ 
1216:                                 fprintf( stderr, 
1217:                                         "%s: %s use clause -- syntax error.\n", 
1218:                                         rfname, ctxt ); 
1219:                                 return( TRUE ); 
1220:                         } 
1221:                 }else{ 
1222:                         fprintf( stderr, "%s: %s use clause -- syntax error.\n", 
1223:                                 rfname, ctxt ); 
1224:                         return( TRUE ); 
1225:                 } 
1226: /* 
1227:         }else if( tok != TOK_NL && tok != TOK_EOF ){ 
1228:                 fprintf( stderr, "%s: %s set -- syntax error.\n", 
1229:                         rfname, ctxt ); 
1230:                 return( TRUE ); 
1231: */ 
1232:         } 
1233:         return( FALSE ); 
1234: } 
1235:  
1236: static        int        getovalue( fp, ctxt, n_tab, tab, otok, oval, qtok, qval ) 
1237: FILE        *fp; 
1238: char        ctxt[]; 
1239: int        n_tab; 
1240: DEF_T        tab[]; 
1241: int        *otok; 
1242: int        *oval; 
1243: int        *qtok; 
1244: int        *qval; 
1245: { 
1246:         int        err; 
1247:         DEF_T        *dp; 
1248:         int        t_idx; 
1249:  
1250:         err = FALSE; 
1251:         gettoken( fp ); 
1252:         if( tok == TOK_IDENT ){ 
1253:                 *otok = tok; 
1254:                 if( dp = finddef( tokstr, n_tab, tab ) ){ 
1255:                         dp->d_used = TRUE; 
1256:                         *oval = dp->d_val; 
1257:                 }else{ 
1258:                         fprintf( stderr, "%s: %s entry %s undefined.\n", 
1259:                                 rfname, ctxt, tokstr ); 
1260:                         return( TRUE ); 
1261:                 } 
1262:                 gettoken( fp ); 
1263:         }else if( tok == TOK_LEFT || tok == TOK_RIGHT ){ 
1264:                 *otok = tok; 
1265:                 *oval = 0; 
1266:                 gettoken( fp ); 
1267:         } 
1268:         *qtok = TOK_NL; 
1269:         *qval = 0; 
1270:         if( tok == TOK_IF ){ 
1271:                 gettoken( fp ); 
1272:                 if( tok == TOK_LEFT || tok == TOK_RIGHT ){ 
1273:                         *qtok = tok; 
1274:                         gettoken( fp ); 
1275:                         if( tok == TOK_EQUAL ){ 
1276:                                 err |= getsetvalue( fp, ctxt, n_tab, tab, 
1277:                                         qval, &t_idx ); 
1278:                         }else 
1279:                                 err = TRUE; 
1280:                 }else 
1281:                         err = TRUE; 
1282:                 skiptonl( fp ); 
1283:         } 
1284:         if( tok != TOK_NL && tok != TOK_EOF ){ 
1285:                 fprintf( stderr, "%s: %s set -- syntax error.\n", 
1286:                         rfname, ctxt ); 
1287:                 err = TRUE; 
1288:         } 
1289:         return( err ); 
1290: } 
1291:  
1292: static        int        type( fp, rp ) 
1293: FILE        *fp; 
1294: RULE_T        *rp; 
1295: { 
1296:         int        err; 
1297:         int        t, tnum; 
1298:         int        n_rows; 
1299:         TROW_T        *trows[ TVTAB_SIZE ]; 
1300:         char        *ip; 
1301:         TROW_T        *trp, **trp1; 
1302:  
1303:         err = FALSE; 
1304:         tnum = 1; 
1305:         gettoken( fp ); 
1306:         if( tok == TOK_EQUAL ){ 
1307:                 gettoken( fp ); 
1308:                 if( tok == TOK_INT ){ 
1309:                         tnum = tokval; 
1310:                 } 
1311:         }else if( tok != TOK_NL ){ 
1312:                 fprintf( stderr, "%s: type: syntax error in type header.\n", 
1313:                         rfname ); 
1314:                 err = TRUE; 
1315:         } 
1316:         skiptonl( fp ); 
1317:         for( n_rows = 0; gettoken( fp ); ){ 
1318:                 if( tok == TOK_IDENT ){ 
1319:                         trp = ( TROW_T * )malloc( sizeof( TROW_T ) ); 
1320:                         ip = ( char * )malloc( strlen( tokstr ) + 1 ); 
1321:                         strcpy( ip, tokstr ); 
1322:                         trp->t_name = ip; 
1323:                         trp->t_nval = UNDEF; 
1324:                         trp->t_nrvals = 0; 
1325:                         trp->t_rvals = NULL; 
1326:                         gettoken( fp ); 
1327:                         if( tok == TOK_EQUAL ){ 
1328:                                 gettoken( fp ); 
1329:                                 err |= getvecvalue( fp, trp ); 
1330:                                 trows[ n_rows ] = trp; 
1331:                                 n_rows++; 
1332:                         } 
1333:                         skiptonl( fp ); 
1334:                 }else if( tok != TOK_NL && tok != TOK_COMMENT ){ 
1335:                         ungettoken(); 
1336:                         break; 
1337:                 } 
1338:         } 
1339:  
1340:         trp1 = ( TROW_T ** )malloc( n_rows * sizeof( TROW_T * ) ); 
1341:         for( t = 0; t < n_rows; t++ ) 
1342:                 trp1[ t ] = trows[ t ]; 
1343:         ttabs[ tnum - 1 ].t_index = t_index; 
1344:         t_index++; 
1345:         ttabs[ tnum - 1 ].t_nrows = n_rows; 
1346:         ttabs[ tnum - 1 ].t_rows = trp1; 
1347:         rp->r_ntypes++; 
1348:  
1349:         return( err ); 
1350: } 
1351:  
1352: static        int        getvecvalue( fp, trp ) 
1353: FILE        *fp; 
1354: TROW_T        *trp; 
1355: { 
1356:         int        err; 
1357:         int        i, n_col; 
1358:         int        trow[ TVTAB_SIZE ]; 
1359:         int        *rp; 
1360:  
1361:         err = FALSE; 
1362:         if( tok != TOK_LBRACK ) 
1363:                 return( TRUE ); 
1364:         gettoken( fp ); 
1365:         for( n_col = 0; tok != TOK_RBRACK; ){ 
1366:                 if( tok == TOK_INT ){ 
1367:                         trow[ n_col ] = tokval; 
1368:                         n_col++; 
1369:                         gettoken( fp ); 
1370:                         if( tok == TOK_COMMA ) 
1371:                                 gettoken( fp ); 
1372:                 } 
1373:         } 
1374:         if( n_col == 0 ){ 
1375:                 fprintf( stderr, "%s: getvecvalue: empty vector.\n", rfname ); 
1376:                 err = TRUE; 
1377:         }else{ 
1378:                 trp->t_nrvals = n_col; 
1379:                 rp = ( int * )malloc( n_col * sizeof( int ) ); 
1380:                 for( i = 0; i < n_col; i++ ) 
1381:                         rp[ i ] = trow[ i ]; 
1382:                 trp->t_rvals = rp; 
1383:         } 
1384:         return( err ); 
1385: } 
1386:  
1387: static        int        gettoken( fp ) 
1388: FILE        *fp; 
1389: { 
1390:         char        *tsp; 
1391:         int        i; 
1392:  
1393:         if( readahead ){ 
1394:                 tok = ra_tok; 
1395:                 tokval = ra_tokval; 
1396:                 strcpy( tokstr, ra_tokstr ); 
1397:                 readahead = FALSE; 
1398:                 return( TRUE ); 
1399:         } 
1400:  
1401:         tok = TOK_EOF; 
1402:         tokval = 0; 
1403:         *tokstr = '\0'; 
1404:         if( rfeof ) 
1405:                 return( FALSE ); 
1406:         else if( *rfp == '\0' ){ 
1407:                 if( !fgets( rfline, sizeof( rfline ), fp ) ){ 
1408:                         rfeof = TRUE; 
1409:                         return( FALSE ); 
1410:                 }else 
1411:                         rfp = rfline; 
1412:         } 
1413:         while( *rfp == ' ' || *rfp == '\t' ) 
1414:                 rfp++; 
1415:         tsp = tokstr; 
1416:         if( isalpha( *rfp ) ){ 
1417:                 tok = TOK_IDENT; 
1418:                 *tsp++ = *rfp++;  
1419:                 for( ; isalnum( *rfp ) || *rfp == '_' ; rfp++ ) 
1420:                         *tsp++ = *rfp; 
1421:                 *tsp = '\0'; 
1422:                 for( i = 0; i < n_rwords; i++ ){ 
1423:                         if( !strcmp( tokstr, rwords[i].r_name ) ){ 
1424:                                 tok = rwords[i].r_token; 
1425:                                 break; 
1426:                         } 
1427:                 } 
1428:         }else if( *rfp == '"' ){ 
1429:                 tok = TOK_STRING; 
1430:                 rfp++; 
1431:                 while( *rfp != '\0' && *rfp != '"' && *rfp != '\n' ){ 
1432:                         if( *rfp == '\\' ){ 
1433:                                 if( rfp[1] == '\n' || rfp[1] == '\0' ){ 
1434:                                         fprintf( stderr, 
1435:                                         "%s: gettoken: Unterminated string.", 
1436:                                                 rfname ); 
1437:                                         break; 
1438:                                 }else 
1439:                                         rfp++; 
1440:                         } 
1441:                         *tsp++ = *rfp++; 
1442:                 } 
1443:                 *tsp = '\0'; 
1444:                 if( *rfp == '"' ) 
1445:                         rfp++; 
1446:                 tok = TOK_STRING; 
1447:         }else if( isdigit( *rfp ) ){ 
1448:                 tok = TOK_INT; 
1449:                 *tsp++ = *rfp++;  
1450:                 for( ; isdigit( *rfp ); rfp++ ) 
1451:                         *tsp++ = *rfp; 
1452:                 *tsp = '\0'; 
1453:                 tokval = atoi( tokstr ); 
1454:         }else if( *rfp == '#' ){ 
1455:                 tok = TOK_COMMENT; 
1456:                 *tsp++ = *rfp++;  
1457:                 for( ; *rfp && *rfp != '\n'; rfp++ ) 
1458:                         *tsp++ = *rfp; 
1459:                 *tsp = '\0'; 
1460:         }else if( *rfp == '=' ){ 
1461:                 tok = TOK_EQUAL; 
1462:                 *tsp++ = *rfp++;  
1463:                 *tsp = '\0'; 
1464:         }else if( *rfp == '{' ){ 
1465:                 tok = TOK_LBRACE; 
1466:                 *tsp++ = *rfp++;  
1467:                 *tsp = '\0'; 
1468:         }else if( *rfp == '}' ){ 
1469:                 tok = TOK_RBRACE; 
1470:                 *tsp++ = *rfp++;  
1471:                 *tsp = '\0'; 
1472:         }else if( *rfp == '[' ){ 
1473:                 tok = TOK_LBRACK; 
1474:                 *tsp++ = *rfp++;  
1475:                 *tsp = '\0'; 
1476:         }else if( *rfp == ']' ){ 
1477:                 tok = TOK_RBRACK; 
1478:                 *tsp++ = *rfp++;  
1479:                 *tsp = '\0'; 
1480:         }else if( *rfp == ',' ){ 
1481:                 tok = TOK_COMMA; 
1482:                 *tsp++ = *rfp++;  
1483:                 *tsp = '\0'; 
1484:         }else if( *rfp == '\n' ){ 
1485:                 tok = TOK_NL; 
1486:                 *tsp++ = *rfp++;  
1487:                 *tsp = '\0'; 
1488:         }else{ 
1489:                 tok = TOK_ERROR; 
1490:                 *tsp++ = *rfp++;  
1491:                 *tsp = '\0'; 
1492:         } 
1493:         return( TRUE ); 
1494: } 
1495:  
1496: static        void        ungettoken() 
1497: { 
1498:  
1499:         ra_tok = tok; 
1500:         ra_tokval = tokval; 
1501:         strcpy( ra_tokstr, tokstr ); 
1502:         readahead = TRUE; 
1503: } 
1504:  
1505: static        void        skiptonl( fp ) 
1506: FILE        *fp; 
1507: { 
1508:  
1509:         while( tok != TOK_NL && tok != TOK_EOF ) 
1510:                 gettoken( fp ); 
1511: } 
1512:  
1513: static        void        clear_rule( rp ) 
1514: RULE_T        *rp; 
1515: { 
1516:         int        i; 
1517:  
1518:         rp->r_sym = UNDEF; 
1519:         rp->r_prec = UNDEF; 
1520:         rp->r_print = NULL; 
1521:         rp->r_lclass = 0; 
1522:         rp->r_rclass = 0; 
1523:         rp->r_octok = 0; 
1524:         rp->r_ocval = 0; 
1525:         rp->r_nakind = 0; 
1526:         rp->r_akind = a_kind; 
1527:         rp->r_nlkind = 0; 
1528:         rp->r_lkind = l_kind; 
1529:         rp->r_nrkind = 0; 
1530:         rp->r_rkind = r_kind; 
1531:         rp->r_nokind = 0; 
1532:         rp->r_oktok = o_ktok; 
1533:         rp->r_okval = o_kval; 
1534:         rp->r_okqtok = o_kqtok; 
1535:         rp->r_okqval = o_kqval; 
1536:         for( i = 0; i < KIND_SIZE; i++ ){ 
1537:                 rp->r_akind[i] = 0; 
1538:                 rp->r_lkind[i] = 0; 
1539:                 rp->r_rkind[i] = 0; 
1540:                 rp->r_oktok[i] = 0; 
1541:                 rp->r_okval[i] = 0; 
1542:                 rp->r_okqtok[i] = 0; 
1543:                 rp->r_okqval[i] = 0; 
1544:         } 
1545:         rp->r_ntypes = 0; 
1546:         rp->r_types = ttabs; 
1547: } 
1548:  
1549: static        RULE_T        *save_rule( rp ) 
1550: RULE_T        *rp; 
1551: { 
1552:         RULE_T        *nrp; 
1553:         char        *sp; 
1554:         int        i, *ip; 
1555:  
1556:         nrp = ( RULE_T * )malloc( sizeof( RULE_T ) ); 
1557:         if( nrp == NULL ){ 
1558:                 fprintf( stderr, "%s: can't allocate new rule.\n", progname ); 
1559:                 return( NULL ); 
1560:         } 
1561:         nrp->r_sym = rp->r_sym; 
1562:         nrp->r_prec = rp->r_prec; 
1563:         sp = ( char * )malloc( strlen( rp->r_print ) + 1 ); 
1564:         if( sp == NULL ){ 
1565:                 fprintf( stderr, "%s: can't allocaate r_print for new rule.\n", 
1566:                         progname ); 
1567:                 return( NULL ); 
1568:         } 
1569:         strcpy( sp, rp->r_print ); 
1570:         nrp->r_print = sp; 
1571:  
1572:         nrp->r_lclass = rp->r_lclass; 
1573:         nrp->r_rclass = rp->r_rclass; 
1574:         nrp->r_octok = rp->r_octok; 
1575:         nrp->r_ocval = rp->r_ocval; 
1576:  
1577:         nrp->r_nakind = rp->r_nakind; 
1578:         if( nrp->r_nakind > 0 ){ 
1579:                 ip = ( int * )malloc( nrp->r_nakind * sizeof( int ) ); 
1580:                 if( ip == NULL ){ 
1581:                         fprintf( stderr, 
1582:                                 "%s: can't allocate r_akind for new rule.\n",  
1583:                                 progname ); 
1584:                         return( NULL ); 
1585:                 } 
1586:                 nrp->r_akind = ip; 
1587:                 for( i = 0; i < nrp->r_nakind; i++ ) 
1588:                         nrp->r_akind[ i ] = rp->r_akind[ i ]; 
1589:                  
1590:         }else 
1591:                 nrp->r_akind = NULL; 
1592:  
1593:         nrp->r_nlkind = rp->r_nlkind; 
1594:         if( nrp->r_nlkind > 0 ){ 
1595:                 ip = ( int * )malloc( nrp->r_nlkind * sizeof( int ) ); 
1596:                 if( ip == NULL ){ 
1597:                         fprintf( stderr, 
1598:                                 "%s: can't allocate r_lkind for new rule.\n",  
1599:                                 progname ); 
1600:                         return( NULL ); 
1601:                 } 
1602:                 nrp->r_lkind = ip; 
1603:                 for( i = 0; i < nrp->r_nlkind; i++ ) 
1604:                         nrp->r_lkind[ i ] = rp->r_lkind[ i ]; 
1605:                  
1606:         }else 
1607:                 nrp->r_lkind = NULL; 
1608:  
1609:         nrp->r_nrkind = rp->r_nrkind; 
1610:         if( nrp->r_nrkind > 0 ){ 
1611:                 ip = ( int * )malloc( nrp->r_nrkind * sizeof( int ) ); 
1612:                 if( ip == NULL ){ 
1613:                         fprintf( stderr, 
1614:                                 "%s: can't allocate r_rkind for new rule.\n",  
1615:                                 progname ); 
1616:                         return( NULL ); 
1617:                 } 
1618:                 nrp->r_rkind = ip; 
1619:                 for( i = 0; i < nrp->r_nrkind; i++ ) 
1620:                         nrp->r_rkind[ i ] = rp->r_rkind[ i ]; 
1621:                  
1622:         }else 
1623:                 nrp->r_rkind = NULL; 
1624:  
1625:         nrp->r_nokind = rp->r_nokind; 
1626:         if( nrp->r_nokind > 0 ){ 
1627:                 ip = ( int * )malloc( nrp->r_nokind * sizeof( int ) ); 
1628:                 if( ip == NULL ){ 
1629:                         fprintf( stderr, 
1630:                                 "%s: can't allocate r_oktok for new rule.\n",  
1631:                                 progname ); 
1632:                         return( NULL ); 
1633:                 } 
1634:                 nrp->r_oktok = ip; 
1635:                 for( i = 0; i < nrp->r_nokind; i++ ) 
1636:                         nrp->r_oktok[ i ] = rp->r_oktok[ i ]; 
1637:                  
1638:                 ip = ( int * )malloc( nrp->r_nokind * sizeof( int ) ); 
1639:                 if( ip == NULL ){ 
1640:                         fprintf( stderr, 
1641:                                 "%s: can't allocate r_okval for new rule.\n",  
1642:                                 progname ); 
1643:                         return( NULL ); 
1644:                 } 
1645:                 nrp->r_okval = ip; 
1646:                 for( i = 0; i < nrp->r_nokind; i++ ) 
1647:                         nrp->r_okval[ i ] = rp->r_okval[ i ]; 
1648:  
1649:                 ip = ( int * )malloc( nrp->r_nokind * sizeof( int ) ); 
1650:                 if( ip == NULL ){ 
1651:                         fprintf( stderr, 
1652:                                 "%s: can't allocate r_okqtok for new rule.\n",  
1653:                                 progname ); 
1654:                         return( NULL ); 
1655:                 } 
1656:                 nrp->r_okqtok = ip; 
1657:                 for( i = 0; i < nrp->r_nokind; i++ ) 
1658:                         nrp->r_okqtok[ i ] = rp->r_okqtok[ i ]; 
1659:                  
1660:                 ip = ( int * )malloc( nrp->r_nokind * sizeof( int ) ); 
1661:                 if( ip == NULL ){ 
1662:                         fprintf( stderr, 
1663:                                 "%s: can't allocate r_okqval for new rule.\n",  
1664:                                 progname ); 
1665:                         return( NULL ); 
1666:                 } 
1667:                 nrp->r_okqval = ip; 
1668:                 for( i = 0; i < nrp->r_nokind; i++ ) 
1669:                         nrp->r_okqval[ i ] = rp->r_okqval[ i ]; 
1670:         } 
1671:  
1672:         nrp->r_ntypes = rp->r_ntypes; 
1673:         nrp->r_types = ( TTAB_T * )malloc( nrp->r_ntypes * sizeof( TTAB_T ) ); 
1674:         if( nrp->r_types == NULL ){ 
1675:                 fprintf( stderr, "%s: can't allocate r_types for new rule.\n", 
1676:                         progname ); 
1677:                 return( NULL ); 
1678:         } 
1679:         for( i = 0; i < nrp->r_ntypes; i++ ){ 
1680:                 nrp->r_types[i].t_index = rp->r_types[i].t_index; 
1681:                 nrp->r_types[i].t_nrows = rp->r_types[i].t_nrows; 
1682:                 nrp->r_types[i].t_rows = rp->r_types[i].t_rows; 
1683:         } 
1684:  
1685:         return( nrp ); 
1686: } 
1687:  
1688: static        int        check_rule( rp ) 
1689: RULE_T        *rp; 
1690: { 
1691:         int        err; 
1692:         int        t, nkind; 
1693:         TTAB_T        *ttp; 
1694:  
1695:         err = FALSE; 
1696:         if( ( nkind = rp->r_nakind ) > 1 && nkind != rp->r_ntypes ){ 
1697:                 fprintf( stderr, "%d akind values requires %d types.\n", 
1698:                         nkind, nkind ); 
1699:                 return( TRUE ); 
1700:         } 
1701:         if( ( nkind = rp->r_nlkind ) > 1 && nkind != rp->r_ntypes ){ 
1702:                 fprintf( stderr, "%d left kind values requires %d types.\n", 
1703:                         nkind, nkind ); 
1704:                 return( TRUE ); 
1705:         } 
1706:         if( ( nkind = rp->r_nrkind ) > 1 && nkind != rp->r_ntypes ){ 
1707:                 fprintf( stderr, 
1708:                         "%d right kind values requires %d types.\n", 
1709:                         nkind, nkind ); 
1710:                 return( TRUE ); 
1711:         } 
1712:  
1713:         for( t = 0; t < rp->r_ntypes; t++ ){ 
1714:                 ttp = &rp->r_types[ t ]; 
1715:                 err |= check_type( ttp ); 
1716:         } 
1717:  
1718:         return( err ); 
1719: } 
1720:  
1721: static        int        check_type( ttp ) 
1722: TTAB_T        *ttp; 
1723: { 
1724:         int        err; 
1725:         int        t, n_rows; 
1726:         int        i, j; 
1727:         int        t1, ot, nt; 
1728:         TROW_T        *trp, *ntrp, *otrp; 
1729:         DEF_T        *dp; 
1730:         int        ins, del; 
1731:         int        lval; 
1732:         int        dv2rv[ TVTAB_SIZE ]; 
1733:         int        rv2dv[ TVTAB_SIZE ]; 
1734:         TROW_T        **newrows; 
1735:         char        *tnp; 
1736:         int        *nrp; 
1737:  
1738:         err = FALSE; 
1739:  
1740:         /* Square up the ttab array by adding/removing                */ 
1741:         /* elements:                                                */ 
1742:  
1743:         n_rows = ttp->t_nrows; 
1744:         for( t = 0; t < n_rows; t++ ){ 
1745:                 trp = ttp->t_rows[ t ]; 
1746:                 trp->t_nval = t; 
1747:                 if( trp->t_nrvals < n_rows ){ 
1748:                         fprintf( stderr, 
1749:                                 "%s: short type row: add %d T_ERROR's.\n", 
1750:                                 rfname, n_rows - trp->t_nrvals ); 
1751:                         nrp = ( int * )malloc( n_rows * sizeof( int ) ); 
1752:                         for( i = 0; i < trp->t_nrvals; i++ ) 
1753:                                 nrp[i] = trp->t_rvals[i]; 
1754:                         for( i = trp->t_nrvals; i < n_rows; i++ ) 
1755:                                 nrp[i] = v_error; 
1756:                         free( trp->t_rvals ); 
1757:                         trp->t_rvals = nrp; 
1758:                 }else if( trp->t_nrvals > n_rows ){ 
1759:                         fprintf( stderr, 
1760:                                 "%s: long type row: truncate last %d values.\n", 
1761:                                 rfname, trp->t_nrvals - n_rows ); 
1762:                         nrp = ( int * )malloc( n_rows * sizeof( int ) ); 
1763:                         for( i = 0; i < n_rows; i++ ) 
1764:                                 nrp[i] = trp->t_rvals[i]; 
1765:                         free( trp->t_rvals ); 
1766:                         trp->t_rvals = nrp; 
1767:                 } 
1768:         } 
1769:  
1770:         /* construct the mapping from values in nab.h to the        */ 
1771:         /* values from the rows of the current type                */ 
1772:         /* types of interest run from 0 .. l_utype (the last        */ 
1773:         /* type)                                                */ 
1774:  
1775:         for( i = 0; i <= l_utype; i++ ) 
1776:                 dv2rv[ i ] = UNDEF; 
1777:         ins = FALSE; 
1778:         for( t = 0; t < n_tvtab; t++ ){ 
1779:                 dp = &tvtab[ t ]; 
1780:                 if( trp = findtrow( dp->d_name, n_rows, ttp->t_rows ) ){ 
1781:                         dv2rv[ dp->d_val ] = trp->t_nval; 
1782:                         dp->d_used = TRUE; 
1783:                 }else 
1784:                         ins = TRUE; 
1785:         } 
1786:  
1787:         /* ensure that after any insert/delete ops, that the         */ 
1788:         /* symbols defined in the type table have the same         */ 
1789:         /* order as the symbols in TCK_FNAME                        */ 
1790:  
1791:         for( lval = UNDEF, i = 0; i <= l_utype; i++ ){ 
1792:                 if( dv2rv[ i ] == UNDEF ) 
1793:                         continue; 
1794:                 else{ 
1795:                         if( lval == UNDEF ) 
1796:                                 lval = dv2rv[ i ]; 
1797:                         else if( dv2rv[ i ]  < lval ){ 
1798:                                 fprintf( stderr, 
1799:                 "%s: type table row order differs from that of %s.\n", 
1800:                                         rfname, tckfname ); 
1801:                                 return( TRUE ); 
1802:                         }else 
1803:                                 lval = dv2rv[ i ]; 
1804:                 } 
1805:         } 
1806:  
1807:         /* construct the mapping from values in the type table        */ 
1808:         /* back to the values in nab.h                                */ 
1809:         for( i = 0; i < n_rows; i++ ) 
1810:                 rv2dv[ i ] = UNDEF; 
1811:         del = FALSE; 
1812:         for( i = 0; i < n_rows; i++ ){ 
1813:                 trp = ttp->t_rows[ i ]; 
1814:                 if( dp = finddef( trp->t_name, n_tvtab, tvtab ) ) 
1815:                         rv2dv[ i ] = dp->d_val; 
1816:                 else 
1817:                         del = TRUE; 
1818:         } 
1819:  
1820:         /* no inserts or deletes, table is ok as far as        */ 
1821:         /* this program is concerned.  Adding/removing        */ 
1822:         /* or changing the permitted operations and the        */ 
1823:         /* result types is beyond the scope of this         */ 
1824:         /* program                                        */ 
1825:  
1826:         if( !ins && !del ) 
1827:                 return( err ); 
1828:  
1829:         newrows = ( TROW_T ** )malloc( (l_utype+1) * sizeof( TROW_T * ) ); 
1830:         for( i = 0; i <= l_utype; i++ ){ 
1831:                 ntrp = ( TROW_T * )malloc( sizeof( TROW_T ) ); 
1832:                 tnp = ( char * )malloc( strlen( tvtab[i].d_name ) + 1 ); 
1833:                 strcpy( tnp, tvtab[i].d_name ); 
1834:                 ntrp->t_name = tnp; 
1835:                 ntrp->t_nval = i; 
1836:                 ntrp->t_nrvals = l_utype + 1; 
1837:                 nrp = ( int * )malloc( (l_utype+1) * sizeof( int ) ); 
1838:                 ntrp->t_rvals = nrp; 
1839:                 for( j = 0; j <= l_utype; j++ ) 
1840:                         ntrp->t_rvals[j] = v_error;         
1841:                 newrows[ i ] = ntrp; 
1842:         } 
1843:  
1844:         /* fix the table:                                        */ 
1845:         for( i = 0; i <= l_utype; i++ ){ 
1846:                 ntrp = newrows[ i ]; 
1847:                 /* UNDEF means new type, add row.  new row was        */ 
1848:                 /* to all T_UNDEF's above, so its done                */ 
1849:                 if( ( t1 = dv2rv[ i ] ) == UNDEF ){ 
1850:                         fprintf( stderr, "%s: add row for type = %s.\n", 
1851:                                 rfname, tvtab[ i ].d_name ); 
1852:                         continue; 
1853:                 } 
1854:                 otrp = ttp->t_rows[ t1 ]; 
1855:                 for( j = 0; j <= l_utype; j++ ){ 
1856:                         if( ( t1 = dv2rv[ j ] ) == UNDEF ) 
1857:                                 continue; 
1858:                         ot = otrp->t_rvals[ t1 ]; 
1859:                         nt = rv2dv[ ot ]; 
1860:                         if( nt == UNDEF ){ 
1861:                                 fprintf( stderr, 
1862:                                         "%s: row uses undefind value %d\n", 
1863:                                         rfname, nt ); 
1864:                                 return( TRUE ); 
1865:                         }else 
1866:                                 ntrp->t_rvals[ j ] = nt; 
1867:                 } 
1868:         } 
1869:  
1870:         ttp->t_nrows = l_utype + 1; 
1871:         ttp->t_rows = newrows; 
1872:  
1873:         return( err ); 
1874: } 
1875: static        TROW_T        *findtrow( name, n_trows, trows ) 
1876: char        name[]; 
1877: int        n_trows; 
1878: TROW_T        *trows[]; 
1879: { 
1880:         int        i; 
1881:         TROW_T        *trp; 
1882:  
1883:         for( i = 0; i < n_trows; i++ ){ 
1884:                 trp = trows[ i ]; 
1885:                 if( !strcmp( name, trp->t_name ) ) 
1886:                         return( trp ); 
1887:         } 
1888:         return( NULL ); 
1889: } 
1890:  
1891: static        void        fprint_rule( fp, rp ) 
1892: FILE        *fp; 
1893: RULE_T        *rp; 
1894: { 
1895:         int        i, j, k; 
1896:         DEF_T        *dp; 
1897:  
1898:         fprintf( fp, "operator\n" ); 
1899:         dp = finddef_withval( rp->r_sym, n_symtab, symtab ); 
1900:         fprintf( fp, "\tsym    = %s\n", dp->d_name ); 
1901:         fprintf( fp, "\tprec   = %d\n", rp->r_prec ); 
1902:         fprintf( fp, "\tprint  = \"%s\"\n", rp->r_print ); 
1903:         fprintf( fp, "\n" ); 
1904:         fprintf( fp, "class\n" ); 
1905:         if( rp->r_lclass != 0 ){ 
1906:                 fprintf( fp, "\tleft   = " ); 
1907:                 fprint_set( fp, rp->r_lclass, n_cvtab, cvtab ); 
1908:                 fprintf( fp, "\n" ); 
1909:         } 
1910:         if( rp->r_rclass != 0 ){ 
1911:                 fprintf( fp, "\tright  = " ); 
1912:                 fprint_set( fp, rp->r_rclass, n_cvtab, cvtab ); 
1913:                 fprintf( fp, "\n" ); 
1914:         } 
1915: /* 
1916:         fprintf( fp, "\toutput = %s\n", rp->r_oclass ); 
1917: */ 
1918:         fprintf( fp, "\toutput = " ); 
1919:         if( rp->r_octok == TOK_LEFT ) 
1920:                 fprintf( fp, "left\n" ); 
1921:         else if( rp->r_octok == TOK_RIGHT ) 
1922:                 fprintf( fp, "right" ); 
1923:         else{ 
1924:                 dp = finddef_withval( rp->r_ocval, n_cvtab, cvtab ); 
1925:                 fprintf( fp, "%s", dp->d_name ); 
1926:         } 
1927:         fprintf( fp, "\n" ); 
1928:         fprintf( fp, "\n" ); 
1929:         fprintf( fp, "kind\n" ); 
1930:         if( rp->r_nakind == 1 ){ 
1931:                 fprintf( fp, "\takind  = " ); 
1932:                 fprint_set( fp, *rp->r_akind, n_kvtab, kvtab ); 
1933:                 fprintf( fp, "\n" ); 
1934:         }else{ 
1935:                 for( i = 0; i < rp->r_nakind; i++ ){ 
1936:                         fprintf( fp, "\takind  = " ); 
1937:                         fprint_set( fp, rp->r_akind[i], n_kvtab, kvtab ); 
1938:                         fprintf( fp, " use type = %d\n", i + 1 ); 
1939:                 } 
1940:         } 
1941:         if( rp->r_nlkind == 1 ){ 
1942:                 fprintf( fp, "\tleft   = " ); 
1943:                 fprint_set( fp, *rp->r_lkind, n_kvtab, kvtab ); 
1944:                 fprintf( fp, "\n" ); 
1945:         }else{ 
1946:                 for( i = 0; i < rp->r_nlkind; i++ ){ 
1947:                         fprintf( fp, "\tleft   = " ); 
1948:                         fprint_set( fp, rp->r_lkind[i], n_kvtab, kvtab ); 
1949:                         fprintf( fp, " use type = %d\n", i + 1 ); 
1950:                 } 
1951:         } 
1952:         if( rp->r_nrkind == 1 ){ 
1953:                 fprintf( fp, "\tright  = " ); 
1954:                 fprint_set( fp, *rp->r_rkind, n_kvtab, kvtab ); 
1955:                 fprintf( fp, "\n" ); 
1956:         }else{ 
1957:                 for( i = 0; i < rp->r_nrkind; i++ ){ 
1958:                         fprintf( fp, "\tright  = " ); 
1959:                         fprint_set( fp, rp->r_rkind[i], n_kvtab, kvtab ); 
1960:                         fprintf( fp, " use type = %d\n", i + 1 ); 
1961:                 } 
1962:         } 
1963: /* 
1964:         fprintf( fp, "\toutput = %s\n", rp->r_okind ); 
1965:         fprintf( fp, "\n" ); 
1966: */ 
1967:         for( i = 0; i < rp->r_nokind; i++ ){ 
1968:                 fprintf( fp, "\toutput = " ); 
1969:                 if( rp->r_oktok[i] == TOK_IDENT ){ 
1970:                         dp = finddef_withval( rp->r_okval[i], n_kvtab, kvtab ); 
1971:                         fprintf( fp, "%s", dp->d_name ); 
1972:                 }else if( rp->r_oktok[i] == TOK_LEFT ) 
1973:                         fprintf( fp, "left" ); 
1974:                 else if( rp->r_oktok[i] == TOK_RIGHT ) 
1975:                         fprintf( fp, "right" ); 
1976:                 if( rp->r_okqtok[i] == TOK_LEFT ){ 
1977:                         fprintf( fp, " if left = " ); 
1978:                         fprint_set( fp, rp->r_okqval[i], n_kvtab, kvtab ); 
1979:                 }else if( rp->r_okqtok[i] == TOK_LEFT ){ 
1980:                         fprintf( fp, " if right = " ); 
1981:                         fprint_set( fp, rp->r_okqval[i], n_kvtab, kvtab ); 
1982:                 } 
1983:                 fprintf( fp, "\n" ); 
1984:         } 
1985:         fprintf( fp, "\n" ); 
1986:  
1987:         for( i = 0; i < rp->r_ntypes; i++ ){ 
1988:                 fprintf( fp, "type" ); 
1989:                 if( rp->r_ntypes > 1 ) 
1990:                         fprintf( fp, " = %d", i + 1 ); 
1991:                 fprintf( fp, "\n" ); 
1992:                 for( j = 0; j < rp->r_types[i].t_nrows; j++ ){ 
1993:                         fprintf( fp, "\t%-12s = [", 
1994:                                 rp->r_types[i].t_rows[j]->t_name ); 
1995:                         for(k = 0; k < rp->r_types[i].t_rows[j]->t_nrvals; k++){ 
1996:                                 fprintf( fp, " %2d",  
1997:                                         rp->r_types[i].t_rows[j]->t_rvals[k] ); 
1998:                                 if( k < rp->r_types[i].t_rows[j]->t_nrvals-1 ) 
1999:                                         fprintf( fp, "," ); 
2000:                         } 
2001:                         fprintf( fp, " ]\n" ); 
2002:                 } 
2003:                 fprintf( fp, "\n" ); 
2004:         } 
2005:  
2006: } 
2007:  
2008: static        void        fprint_set( fp, set, n_tab, tab ) 
2009: FILE        *fp; 
2010: int        set; 
2011: int        n_tab; 
2012: DEF_T        tab[]; 
2013: { 
2014:         int        i, c, card; 
2015:  
2016:         for( card = 0, i = 0; i < n_tab; i++ ){ 
2017:                 if( set & ( 1 << i ) ) 
2018:                         card++; 
2019:         } 
2020:         if( card == 1 ){ 
2021:                 for( i = 0; i < n_tab; i++ ){ 
2022:                         if( set & ( 1 << i ) ){ 
2023:                                 fprintf( fp, "%s", tab[i].d_name ); 
2024:                                 break; 
2025:                         } 
2026:                 } 
2027:         }else{ 
2028:                 fprintf( fp, "{" ); 
2029:                 for( c = 0, i = 0; i < n_tab; i++ ){ 
2030:                         if( set & ( 1 << i ) ){ 
2031:                                 fprintf( fp, " %s", tab[i].d_name ); 
2032:                                 c++; 
2033:                                 if( c < card ) 
2034:                                         fprintf( fp, "," ); 
2035:                         } 
2036:                 } 
2037:                 fprintf( fp, " }" ); 
2038:         } 
2039: } 
2040:  
2041: static        void        fprint_ovalue( fp, oval, n_tab, tab ) 
2042: FILE        *fp; 
2043: char        *oval; 
2044: int        n_tab; 
2045: DEF_T        tab[];         
2046: { 
2047:  
2048:         fprintf( fp, oval ); 
2049:                  
2050: } 
2051:  
2052: static        int        mk_frameset() 
2053: { 
2054:         FILE        *fp; 
2055:         int        err; 
2056:         char        hstr[ 256 ]; 
2057:          
2058:         err = FALSE; 
2059:  
2060:         if( ( fp = fopen( FRFILE, "w" ) ) == NULL ){ 
2061:                 fprintf( stderr, "%s: can't write frame file %s.\n", 
2062:                         progname, FRFILE ); 
2063:                 return( TRUE ); 
2064:         } 
2065:         fprintf( fp, "<HTML>\n" ); 
2066:         str2hstr( "NAB Operator Rules", hstr ); 
2067:         fprintf( fp, "<HEAD><TITLE>%s</TITLE></HEAD>\n", hstr ); 
2068:         fprintf( fp, "</HTML>\n" ); 
2069:         fprintf( fp, "<FRAMESET rows=%d%%,*>\n", CFSIZE ); 
2070:         fprintf( fp, "<FRAME src=\"%s\" name=\"ControlFrame\">\n", CTLFILE ); 
2071:         fprintf( fp, "<FRAME src=\"%s\" name=\"RuleFrame\">", r1fname ); 
2072:         fprintf( fp, "</FRAMESET>\n" ); 
2073:         fprintf( fp, "</HTML>\n" ); 
2074:         fclose( fp ); 
2075:         return( err ); 
2076: } 
2077:  
2078: static        int        mk_controlfile() 
2079: { 
2080:         int        err; 
2081:         FILE        *fp; 
2082:         char        hstr[ 256 ]; 
2083:         int        i, s; 
2084:         DEF_T        **s_symtab; 
2085:  
2086:         err = FALSE; 
2087:         s_symtab = ( DEF_T ** )malloc( n_symtab * sizeof( DEF_T * ) ); 
2088:         if( s_symtab == NULL ){ 
2089:                 fprintf( stderr, "%s: can't allocate s_symtab.\n", progname ); 
2090:                 return( TRUE ); 
2091:         } 
2092:  
2093:         if( ( fp = fopen( CTLFILE, "w" ) ) == NULL){ 
2094:                 fprintf( stderr, "%s: can't write control file %s.\n", 
2095:                         progname, CTLFILE ); 
2096:                 return( TRUE ); 
2097:         } 
2098:         str2hstr( "ControlFile", hstr ); 
2099:         fprintf( fp, "<HTML>\n" ); 
2100:         fprintf( fp, "<HEAD>\n" ); 
2101:         fprintf( fp, "<TITLE>%s</TITLE>\n", hstr ); 
2102:         fprintf( fp, "<SCRIPT language=\"JavaScript\" src=\"update.js\">\n" ); 
2103:         fprintf( fp, "</SCRIPT>\n" ); 
2104:         fprintf( fp, "</HEAD>\n" ); 
2105:  
2106:         fprintf( fp, "<BODY>\n" ); 
2107:         fprintf( fp, "<TABLE>\n" ); 
2108:  
2109:         fprintf( fp, "<TR>\n" ); 
2110:  
2111:         fprintf( fp, "<TD>\n" ); 
2112:         fprintf( fp, "<FORM name=\"f_dop\">\n" ); 
2113:         fprintf( fp, "<TABLE border>\n" ); 
2114:         fprintf( fp, "<CAPTION>Defined Operators</CAPTION>\n" ); 
2115:         fprintf( fp, "<TR>\n" ); 
2116:         fprintf( fp, "<TD colspan=2>\n" ); 
2117:         for( s = 0, i = 0; i < n_symtab; i++ ){  
2118:                 if( symtab[ i ].d_used ){ 
2119:                         s_symtab[ s ] = &symtab[ i ]; 
2120:                         s++; 
2121:                 } 
2122:         } 
2123:         qsort( s_symtab, s, sizeof( DEF_T * ), defcmp ); 
2124:         fprintf( fp, "Current<INPUT type=\"text\" name=\"d_current\"" ); 
2125:         fprintf( fp, " value=\"%s\"", s_symtab[0]->d_name ); 
2126:         fprintf( fp, " onChange=\"update('d','f');\">\n" ); 
2127:         fprintf( fp, "</TD>\n" ); 
2128:         fprintf( fp, "</TR>\n" ); 
2129:         fprintf( fp, "<TR>\n" ); 
2130:         fprintf( fp, "<TD colspan=2>\n" ); 
2131:         fprintf( fp, "<SELECT name=\"s_dop\" size=%d", SELSIZE ); 
2132:         fprintf( fp, " onChange=\"update('d','s');\">\n" ); 
2133:         for( i = 0; i < s; i++ ) 
2134:                 fprintf( fp, "<OPTION value=\"%s\">%s\n",  
2135:                         s_symtab[i]->d_name, 
2136:                         s_symtab[i]->d_name ); 
2137:         fprintf( fp, "</SELECT>\n" ); 
2138:         fprintf( fp, "</TD>\n" ); 
2139:         fprintf( fp, "</TR>\n" ); 
2140:         fprintf( fp, "<TR>\n" ); 
2141:         fprintf( fp, "<TD>\n" ); 
2142:         fprintf( fp, "<iNPUT type=\"button\" value=\" &lt;- Prev\"" ); 
2143:         fprintf( fp, " onClick=\"update('d','p');\">\n" ); 
2144:         fprintf( fp, "</TD>\n" ); 
2145:         fprintf( fp, "<TD>\n" ); 
2146:         fprintf( fp, "<INPUT type=\"button\" value=\"Next -&gt;\"" ); 
2147:         fprintf( fp, " onClick=\"update('d','n');\">\n" ); 
2148:         fprintf( fp, "</TD>\n" ); 
2149:         fprintf( fp, "</TR>\n" ); 
2150:         fprintf( fp, "</TABLE>\n" ); 
2151:         fprintf( fp, "</FORM>\n" ); 
2152:         fprintf( fp, "</TD>\n" ); 
2153:  
2154:         fprintf( fp, "<TD>\n" ); 
2155:         fprintf( fp, "<FORM name=\"f_uop\">\n" ); 
2156:         fprintf( fp, "<TABLE border>\n" ); 
2157:         fprintf( fp, "<CAPTION>Undefined Operators</CAPTION>\n" ); 
2158:         fprintf( fp, "<TR>\n" ); 
2159:         fprintf( fp, "<TD colspan=2>\n" ); 
2160:         for( s = 0, i = 0; i < n_symtab; i++ ){  
2161:                 if( !symtab[ i ].d_used ){ 
2162:                         s_symtab[ s ] = &symtab[ i ]; 
2163:                         s++; 
2164:                 } 
2165:         } 
2166:         qsort( s_symtab, s, sizeof( DEF_T * ), defcmp ); 
2167:         fprintf( fp, "Current<INPUT type=\"text\" name=\"u_current\"" ); 
2168:         fprintf( fp, " value=\"%s\"", s_symtab[0]->d_name ); 
2169:         fprintf( fp, " onChange=\"update('u','f');\">\n" ); 
2170:         fprintf( fp, "</TD>\n" ); 
2171:         fprintf( fp, "</TR>\n" ); 
2172:         fprintf( fp, "<TR>\n" ); 
2173:         fprintf( fp, "<TD colspan=2>\n" ); 
2174:         fprintf( fp, "<SELECT name=\"s_uop\" size=%d", SELSIZE ); 
2175:         fprintf( fp, " onChange=\"update('u','s');\">\n" ); 
2176:         for( i = 0; i < s; i++ ) 
2177:                 fprintf( fp, "<OPTION value=\"%s\">%s\n",  
2178:                         s_symtab[i]->d_name, 
2179:                         s_symtab[i]->d_name ); 
2180:         fprintf( fp, "</SELECT>\n" ); 
2181:         fprintf( fp, "</TD>\n" ); 
2182:         fprintf( fp, "</TR>\n" ); 
2183:         fprintf( fp, "<TR>\n" ); 
2184:         fprintf( fp, "<TD>\n" ); 
2185:         fprintf( fp, "<INPUT type=\"button\" value=\" &lt;- Prev\"" ); 
2186:         fprintf( fp, " onClick=\"update('u','p');\">\n" ); 
2187:         fprintf( fp, "</TD>\n" ); 
2188:         fprintf( fp, "<TD>\n" ); 
2189:         fprintf( fp, "<INPUT type=\"button\" value=\"Next -&gt;\"" ); 
2190:         fprintf( fp, " onClick=\"update('u','n');\">\n" ); 
2191:         fprintf( fp, "</TD>\n" ); 
2192:         fprintf( fp, "</TR>\n" ); 
2193:         fprintf( fp, "</TABLE>\n" ); 
2194:         fprintf( fp, "</FORM>\n" ); 
2195:         fprintf( fp, "</TD>\n" ); 
2196:  
2197:         fprintf( fp, "</TR>\n" ); 
2198:  
2199:         fprintf( fp, "</TABLE>\n" ); 
2200:         fprintf( fp, "</BODY>\n" ); 
2201:         fprintf( fp, "</HTML>\n" ); 
2202:  
2203:         fclose( fp ); 
2204:         return( err ); 
2205: } 
2206:  
2207: static        int        hprint_rule( rfname, rp ) 
2208: char        rfname[]; 
2209: RULE_T        *rp; 
2210: { 
2211:         int        err; 
2212:         char        *rfp, *dotp; 
2213:         char        htfname[ 256 ]; 
2214:         char        hstr[ 256 ]; 
2215:         FILE        *hfp; 
2216:         DEF_T        *dp, *dp1; 
2217:         int        t, i, j, tv; 
2218:  
2219:         err = FALSE; 
2220:         for( dotp = NULL, rfp = rfname; *rfp; rfp++ ){ 
2221:                 if( *rfp == '.' ) 
2222:                         dotp = rfp; 
2223:         } 
2224:         if( dotp ){ 
2225:                 strncpy( htfname, rfname, dotp - rfname ); 
2226:                 htfname[ dotp - rfname ] = '\0'; 
2227:         }else 
2228:                 strcpy( htfname, rfname ); 
2229:         strcat( htfname, ".html" ); 
2230:         if( ( hfp = fopen( htfname, "w" ) ) == NULL ){ 
2231:                 fprintf( stderr, "%s: can't write html file %s.\n", 
2232:                         progname, htfname ); 
2233:                 return( TRUE ); 
2234:         } 
2235:         if( *r1fname == '\0' ) 
2236:                 strcpy( r1fname, htfname ); 
2237:         str2hstr( rfname, hstr ); 
2238:         fprintf( hfp, "<HTML><HEAD><TITLE>%s</TITLE></HEAD>\n", hstr );  
2239:         fprintf( hfp, "<BODY>\n" ); 
2240:  
2241:         fprintf( hfp, "<B>operator</B><BR>\n" ); 
2242:         fprintf( hfp, 
2243:                 "<TABLE border bgcolor=white cellpadding=2 cellspacing=2>\n" ); 
2244:         fprintf( hfp, "<TR>\n" ); 
2245:         fprintf( hfp, "<TD width=%d>sym</TD>\n", TWID1 ); 
2246:         dp = finddef_withval( rp->r_sym, n_symtab, symtab ); 
2247:         str2hstr( dp->d_name, hstr ); 
2248:         fprintf( hfp, "<TD width=%d>%s</TD>\n", TWID2, hstr ); 
2249:         fprintf( hfp, "</TR>\n" ); 
2250:         fprintf( hfp, "<TR>\n" ); 
2251:         fprintf( hfp, "<TD>prec</TD>\n" ); 
2252:         fprintf( hfp, "<TD>%d</TD>\n", rp->r_prec ); 
2253:         fprintf( hfp, "</TR>\n" ); 
2254:         fprintf( hfp, "<TR>\n" ); 
2255:         fprintf( hfp, "<TD>print</TD>\n" ); 
2256:         str2hstr( rp->r_print, hstr ); 
2257:         fprintf( hfp, "<TD>%s</TD>\n", hstr ); 
2258:         fprintf( hfp, "</TR>\n" ); 
2259:         fprintf( hfp, "</TABLE>\n" ); 
2260:         fprintf( hfp, "<BR>\n" ); 
2261:  
2262:         fprintf( hfp, "<B>class</B><BR>\n" ); 
2263:         fprintf( hfp, 
2264:                 "<TABLE border bgcolor=white cellpadding=2 cellspacing=2>\n" ); 
2265:         if( rp->r_lclass != 0 ){ 
2266:                 fprintf( hfp, "<TR>\n" ); 
2267:                 fprintf( hfp, "<TD width=%d>left</TD>\n", TWID1 ); 
2268:                 fprintf( hfp, "<TD width=%d>\n", TWID2 ); 
2269:                 fprint_set( hfp, rp->r_lclass, n_cvtab, cvtab ); 
2270:                 fprintf( hfp, "</TD>\n" ); 
2271:                 fprintf( hfp, "</TR>\n" ); 
2272:         } 
2273:         if( rp->r_rclass != 0 ){ 
2274:                 fprintf( hfp, "<TR>\n" ); 
2275:                 fprintf( hfp, "<TD width=%d>right</TD>\n", TWID1 ); 
2276:                 fprintf( hfp, "<TD width=%d>\n", TWID2 ); 
2277:                 fprint_set( hfp, rp->r_rclass, n_cvtab, cvtab ); 
2278:                 fprintf( hfp, "</TD>\n" ); 
2279:                 fprintf( hfp, "</TR>\n" ); 
2280:         } 
2281:         fprintf( hfp, "<TR>\n" ); 
2282:         fprintf( hfp, "<TD width=%d>output</TD>\n", TWID1 ); 
2283:         fprintf( hfp, "<TD width=%d>\n", TWID2 ); 
2284: /* 
2285:         fprint_ovalue( hfp, rp->r_oclass, n_cvtab, cvtab ); 
2286: */ 
2287:         if( rp->r_octok == TOK_LEFT ) 
2288:                 fprintf( hfp, "left" ); 
2289:         else if( rp->r_octok == TOK_RIGHT ) 
2290:                 fprintf( hfp, "right" ); 
2291:         else{ 
2292:                 dp = finddef_withval( rp->r_ocval, n_cvtab, cvtab ); 
2293:                 fprintf( hfp, "%s", dp->d_name ); 
2294:         } 
2295:         fprintf( hfp, "</TD>\n" ); 
2296:         fprintf( hfp, "</TR>\n" ); 
2297:         fprintf( hfp, "</TABLE>\n" ); 
2298:         fprintf( hfp, "<BR>\n" ); 
2299:  
2300:         fprintf( hfp, "<B>kind</B><BR>\n" ); 
2301:         fprintf( hfp, 
2302:                 "<TABLE border bgcolor=white cellpadding=2 cellspacing=2>\n" ); 
2303:         if( rp->r_nakind == 1 ){ 
2304:                 fprintf( hfp, "<TR>\n" ); 
2305:                 fprintf( hfp, "<TD width=%d>akind</TD>\n", TWID1 ); 
2306:                 fprintf( hfp, "<TD width=%d>\n", TWID2 ); 
2307:                 fprint_set( hfp, *rp->r_akind, n_kvtab, kvtab ); 
2308:                 fprintf( hfp, "</TD>\n" ); 
2309:                 fprintf( hfp, "</TR>\n" ); 
2310:         }else{ 
2311:                 for( i = 0; i < rp->r_nakind; i++ ){ 
2312:                         fprintf( hfp, "<TR>\n" ); 
2313:                         fprintf( hfp, "<TD width=%d>akind</TD>\n", TWID1 ); 
2314:                         fprintf( hfp, "<TD width=%d>\n", TWID2 ); 
2315:                         fprint_set( hfp, rp->r_akind[i], n_kvtab, kvtab ); 
2316:                         fprintf( hfp, " use type = %d", i + 1 ); 
2317:                         fprintf( hfp, "</TD>\n" ); 
2318:                         fprintf( hfp, "</TR>\n" ); 
2319:                 } 
2320:         } 
2321:         if( rp->r_nlkind == 1 ){ 
2322:                 fprintf( hfp, "<TR>\n" ); 
2323:                 fprintf( hfp, "<TD width=%d>left</TD>\n", TWID1 ); 
2324:                 fprintf( hfp, "<TD width=%d>\n", TWID2 ); 
2325:                 fprint_set( hfp, *rp->r_lkind, n_kvtab, kvtab ); 
2326:                 fprintf( hfp, "</TD>\n" ); 
2327:                 fprintf( hfp, "</TR>\n" ); 
2328:         }else{ 
2329:                 for( i = 0; i < rp->r_nlkind; i++ ){ 
2330:                         fprintf( hfp, "<TR>\n" ); 
2331:                         fprintf( hfp, "<TD width=%d>left</TD>\n", TWID1 ); 
2332:                         fprintf( hfp, "<TD width=%d>\n", TWID2 ); 
2333:                         fprint_set( hfp, rp->r_lkind[i], n_kvtab, kvtab ); 
2334:                         fprintf( hfp, " use type = %d", i + 1 ); 
2335:                         fprintf( hfp, "</TD>\n" ); 
2336:                         fprintf( hfp, "</TR>\n" ); 
2337:                 } 
2338:         } 
2339:         if( rp->r_nrkind == 1 ){ 
2340:                 fprintf( hfp, "<TR>\n" ); 
2341:                 fprintf( hfp, "<TD width=%d>right</TD>\n", TWID1 ); 
2342:                 fprintf( hfp, "<TD width=%d>\n", TWID2 ); 
2343:                 fprint_set( hfp, *rp->r_rkind, n_kvtab, kvtab ); 
2344:                 fprintf( hfp, "</TD>\n" ); 
2345:                 fprintf( hfp, "</TR>\n" ); 
2346:         }else{ 
2347:                 for( i = 0; i < rp->r_nrkind; i++ ){ 
2348:                         fprintf( hfp, "<TR>\n" ); 
2349:                         fprintf( hfp, "<TD width=%d>right</TD>\n", TWID1 ); 
2350:                         fprintf( hfp, "<TD width=%d>\n", TWID2 ); 
2351:                         fprint_set( hfp, rp->r_rkind[i], n_kvtab, kvtab ); 
2352:                         fprintf( hfp, " use type = %d", i + 1 ); 
2353:                         fprintf( hfp, "</TD>\n" ); 
2354:                         fprintf( hfp, "</TR>\n" ); 
2355:                 } 
2356:         } 
2357:         fprintf( hfp, "<TR>\n" ); 
2358: /* 
2359:         fprintf( hfp, "<TD width=%d>output</TD>\n", TWID1 ); 
2360:         fprintf( hfp, "<TD width=%d>\n", TWID2 ); 
2361:         fprint_ovalue( hfp, rp->r_okind, n_kvtab, kvtab ); 
2362:         fprintf( hfp, "</TD>\n" ); 
2363:         fprintf( hfp, "</TR>\n" ); 
2364: */ 
2365:         for( i = 0; i < rp->r_nokind; i++){ 
2366:                 fprintf( hfp, "<TR>\n" ); 
2367:                 fprintf( hfp, "<TD width=%d>output</TD>\n", TWID1 ); 
2368:                 fprintf( hfp, "<TD width=%d>\n", TWID2 ); 
2369:                 if( rp->r_oktok[i] == TOK_LEFT ) 
2370:                         fprintf( hfp, "left" ); 
2371:                 else if( rp->r_oktok[i] == TOK_RIGHT ) 
2372:                         fprintf( hfp, "right" ); 
2373:                 else{ 
2374:                         dp = finddef_withval( rp->r_okval[i], n_kvtab,kvtab ); 
2375:                         fprintf( hfp, "%s", dp->d_name ); 
2376:                         if( rp->r_okqtok[i] == TOK_LEFT ){ 
2377:                                 fprintf( hfp, " if left = " ); 
2378:                                 fprint_set( hfp, rp->r_okqval[i], 
2379:                                         n_kvtab, kvtab ); 
2380:                         }else if( rp->r_okqtok[i] == TOK_RIGHT ){ 
2381:                                 fprintf( hfp, " if left = " ); 
2382:                                 fprint_set( hfp, rp->r_okqval[i], 
2383:                                         n_kvtab, kvtab ); 
2384:                         } 
2385:                 } 
2386:                 fprintf( hfp, "</TD>\n" ); 
2387:                 fprintf( hfp, "</TR>\n" ); 
2388:         } 
2389:         fprintf( hfp, "</TD>\n" ); 
2390:         fprintf( hfp, "</TR>\n" ); 
2391:  
2392:         fprintf( hfp, "</TABLE>\n" ); 
2393:         fprintf( hfp, "<BR>\n" ); 
2394:  
2395:         for( t = 0; t < rp->r_ntypes; t++ ){ 
2396:                 fprintf( hfp, "<B>type" ); 
2397:                 if( rp->r_ntypes > 1 ) 
2398:                         fprintf( hfp, " = %d", t + 1 ); 
2399:                 fprintf( hfp, ", t_index = %d</B><BR>\n", 
2400:                         rp->r_types[t].t_index ); 
2401:                 fprintf( hfp, 
2402:                 "<TABLE border bgcolor=white cellpadding=2 cellspacing=2>\n" ); 
2403:                 fprintf( hfp, "<TR>\n" ); 
2404:                 fprintf( hfp, "<TD width=%d>left/right</TD>\n", TWID1 ); 
2405:                 fprintf( hfp, "<TD></TD>\n" ); 
2406:                 for( i = 0; i <= l_utype; i++ ){ 
2407:                         dp = finddef_withval( i, n_tvtab, tvtab ); 
2408:                         fprintf( hfp, "<TD>%s</TD>\n", dp->d_name ); 
2409:                 } 
2410:                 fprintf( hfp, "</TR>\n" ); 
2411:                 fprintf( hfp, "<TR>\n" ); 
2412:                 for( i = 0; i <= l_utype + 1; i++ ) 
2413:                         fprintf( hfp, "<TD></TD>\n" ); 
2414:                 fprintf( hfp, "</TR>\n" ); 
2415:                 for( i = 0; i <= l_utype; i++ ){ 
2416:                         fprintf( hfp, "<TR>\n" ); 
2417:                         dp = finddef_withval( i, n_tvtab, tvtab ); 
2418:                         fprintf( hfp, "<TD width=%d>%s</TD>\n", 
2419:                                 TWID1, dp->d_name ); 
2420:                         fprintf( hfp, "<TD></TD>\n" ); 
2421:                         for( j = 0; j <= l_utype; j++ ){ 
2422:                                 tv = rp->r_types[t].t_rows[i]->t_rvals[j]; 
2423:                                 if( tv == v_error ) 
2424:                                         fprintf( hfp, "<TD><BR></TD>\n" ); 
2425:                                 else{ 
2426:                                         dp1 = finddef_withval(tv,n_tvtab,tvtab); 
2427:                                         fprintf( hfp, "<TD>%s</TD>\n", 
2428:                                         dp1->d_name ); 
2429:                                 } 
2430:                         } 
2431:                         fprintf( hfp, "</TR>\n" ); 
2432:                 } 
2433:                 fprintf( hfp, "</TABLE>\n" ); 
2434:                 fprintf( hfp, "<BR>\n" ); 
2435:         } 
2436:  
2437:         fprintf( hfp, "</BODY>\n" ); 
2438:         fprintf( hfp, "</HTML>\n" ); 
2439:         fclose( hfp ); 
2440:  
2441:         return( err ); 
2442: } 
2443:  
2444: static        char        *str2hstr( str, hstr ) 
2445: char        str[]; 
2446: char        hstr[]; 
2447: { 
2448:         char        *sp, *hp; 
2449:  
2450:         for( sp = str, hp = hstr; *sp; sp++ ){ 
2451:                 if( *sp == '<' ){ 
2452:                         strcpy( hp, "&lt;" ); 
2453:                         hp += 4; 
2454:                 }else if( *sp == '>' ){ 
2455:                         strcpy( hp, "&gt;" ); 
2456:                         hp += 4; 
2457:                 }else if( *sp == '&' ){ 
2458:                         strcpy( hp, "&amp;" ); 
2459:                         hp += 5; 
2460:                 }else 
2461:                         *hp++ = *sp; 
2462:         } 
2463:         *hp = '\0'; 
2464:         return( hstr ); 
2465: } 
2466:  
2467: static        int        mk_checkexpr() 
2468: { 
2469:         int        err; 
2470:         FILE        *cfp; 
2471:         int        r; 
2472:  
2473:         err = FALSE; 
2474:         if( ( cfp = fopen( CODEFILE, "w" ) ) == NULL ){ 
2475:                 fprintf( stderr, "can't write code file %s.\n", progname ); 
2476:                 return( TRUE ); 
2477:         } 
2478:         fprintf( cfp, "#include <stdio.h>\n" ); 
2479:         fprintf( cfp, "#include <string.h>\n" ); 
2480:         fprintf( cfp, "\n" ); 
2481:         fprintf( cfp, "#include \"nab.h\"\n" ); 
2482:         fprintf( cfp, "#include \"y.tab.h\"\n" ); 
2483:         fprintf( cfp, "#include \"errormsg.h\"\n" ); 
2484:         fprintf( cfp, "\n" ); 
2485:         fprintf( cfp, "#define BIT(e) (1<<(e))\n" ); 
2486:         fprintf( cfp, "#define INSET(e,s) (BIT(e)&(s))\n" ); 
2487:         fprintf( cfp, "\n" ); 
2488:         fprintf( cfp, "extern int cg_emsg_lineno;\n" ); 
2489:         fprintf( cfp, "extern SYMREC_T *astk[];\n" ); 
2490:         fprintf( cfp, "extern int astkp;\n" ); 
2491:         fprintf( cfp, "static int akind;\n" );         
2492:         fprintf( cfp, "SYMREC_T *findsym();\n" ); 
2493:         fprintf( cfp, "static void checkattr();\n" ); 
2494:         fprintf( cfp, "void checkid();\n" ); 
2495:         fprintf( cfp, "\n" ); 
2496:  
2497:         fprintf( cfp, "static char typetab[][%d][%d] = {\n", 
2498:                 l_utype+1, l_utype+1 ); 
2499:         for( r = 0; r < n_rules; r++ ) 
2500:                 mk_typetabent( cfp, r == 0, rules[ r ] ); 
2501:         fprintf( cfp, "};\n" ); 
2502:  
2503:         fprintf( cfp, "\n" ); 
2504:         fprintf( cfp, "void checkexpr( expr )\n" ); 
2505:         fprintf( cfp, "NODE_T *expr;\n" ); 
2506:         fprintf( cfp, "{\n" ); 
2507:         fprintf( cfp, "  NODE_T *npl, *npr, *npd;\n" ); 
2508:         fprintf( cfp, "  char *fname;\n" ); 
2509:         fprintf( cfp, "  int class, nd;\n" ); 
2510:         fprintf( cfp, "  SYMREC_T *s_array;\n" ); 
2511:         fprintf( cfp, "  int l_class, r_class, o_class;\n" ); 
2512:         fprintf( cfp, "  int l_kind, r_kind, o_kind;\n" ); 
2513:         fprintf( cfp, "  int t_idx, l_type, r_type, o_type;\n" ); 
2514:         fprintf( cfp, "\n" ); 
2515:         fprintf( cfp, "  if( expr ){\n" ); 
2516:         fprintf( cfp, "    npl = expr->n_left;\n" ); 
2517:         fprintf( cfp, "    npr = expr->n_right;\n" ); 
2518:         fprintf( cfp, "    if( expr->n_sym==SYM_LBRACK ){\n" ); 
2519:         fprintf( cfp, 
2520:                 "      s_array = findsym( npl->n_val.v_value.v_cval );\n" ); 
2521:         fprintf( cfp, "      akind = s_array ? s_array->s_kind : K_UNDEF;\n" ); 
2522:         fprintf( cfp, "      astk[ astkp ] = s_array;\n" ); 
2523:         fprintf( cfp, "      astkp++;\n" ); 
2524:         fprintf( cfp, "    }\n" ); 
2525:         fprintf( cfp, "    checkexpr( npl );\n" ); 
2526:         fprintf( cfp, "    checkexpr( npr );\n" ); 
2527:         fprintf( cfp, "\n" ); 
2528:         fprintf( cfp, "    cg_emsg_lineno = expr->n_lineno;\n" ); 
2529:         fprintf( cfp, "\n" ); 
2530:         fprintf( cfp, "    l_class = npl ? npl->n_class : C_UNDEF;\n" );  
2531:         fprintf( cfp, "    r_class = npr ? npr->n_class : C_UNDEF;\n" );  
2532:         fprintf( cfp, "    l_kind = npl ? npl->n_kind : K_UNDEF;\n" );  
2533:         fprintf( cfp, "    r_kind = npr ? npr->n_kind : K_UNDEF;\n" );  
2534:         fprintf( cfp, "    l_type = npl ? npl->n_type : T_UNDEF;\n" );  
2535:         fprintf( cfp, "    r_type = npr ? npr->n_type : T_UNDEF;\n" );  
2536:         fprintf( cfp, "\n" ); 
2537:         fprintf( cfp, "    switch( expr->n_sym ){\n" ); 
2538:         fprintf( cfp, "\n" ); 
2539:  
2540:         /* NOTE: code for SYM_IDENT is not from a rule-file!        */         
2541:         fprintf( cfp, "    case SYM_IDENT :\n" ); 
2542:         fprintf( cfp, "      checkid( expr );\n" ); 
2543:         fprintf( cfp, "      break;\n" ); 
2544:         fprintf( cfp, "\n" ); 
2545:  
2546:         /* NOTE: code for SYM_PERIOD is not from a rule-file!        */         
2547:         fprintf( cfp, "    case SYM_PERIOD :\n" ); 
2548:         fprintf( cfp, "      checkattr( expr, npl, npr );\n" ); 
2549:         fprintf( cfp, "      break;\n" ); 
2550:         fprintf( cfp, "\n" ); 
2551:  
2552:         for( r = 0; r < n_rules; r++ ) 
2553:                 mk_rulecase( cfp, rules[ r ] ); 
2554:          
2555:         fprintf( cfp, "\n" ); 
2556:         fprintf( cfp, "    }\n" ); 
2557:         fprintf( cfp, "\n" ); 
2558:         fprintf( cfp, "    if( expr->n_sym==SYM_LBRACK ){\n" ); 
2559:         fprintf( cfp, "      astkp--;\n" ); 
2560:         fprintf( cfp, "      if( astkp > 0 )\n" ); 
2561:         fprintf( cfp, "        akind = astk[astkp-1]->s_kind;\n" ); 
2562:         fprintf( cfp, "    }\n" ); 
2563:         fprintf( cfp, "\n" ); 
2564:         fprintf( cfp, "  }\n" ); 
2565:         fprintf( cfp, "}\n" ); 
2566:         mk_checkattr( cfp ); 
2567:         fclose( cfp ); 
2568:         return( err ); 
2569: } 
2570:  
2571: void 
2572: mk_typetabent( fp, first, rp ) 
2573: FILE        *fp; 
2574: int        first; 
2575: RULE_T        *rp; 
2576: { 
2577:         int        t, i, j; 
2578:         TTAB_T        *ttp; 
2579:         TROW_T        *trp; 
2580:         DEF_T        *dp; 
2581:  
2582:         for( t = 0; t < rp->r_ntypes; t++ ){ 
2583:                 if( first ){ 
2584:                         fprintf( fp, "  {\n" ); 
2585:                         first = FALSE; 
2586:                 }else 
2587:                         fprintf( fp, "  ,{\n" ); 
2588:                 ttp = &rp->r_types[ t ]; 
2589:                 for( i = 0; i < ttp->t_nrows; i++ ){ 
2590:                         trp = ttp->t_rows[i]; 
2591:                         if( i == 0 ) 
2592:                                 fprintf( fp, "    { " ); 
2593:                         else 
2594:                                 fprintf( fp, "   ,{ " ); 
2595:                         for( j = 0; j < trp->t_nrvals; j++ ){ 
2596:                                 dp = finddef_withval( trp->t_rvals[j], 
2597:                                         n_tvtab, tvtab ); 
2598:                                 fprintf( fp, "%s", dp->d_name ); 
2599:                                 if( j < trp->t_nrvals-1 ) 
2600:                                         fprintf( fp, "," ); 
2601:                         } 
2602:                         fprintf( fp, " }\n" ); 
2603:                 } 
2604:                 fprintf( fp, "  }\n" ); 
2605:         } 
2606: } 
2607:  
2608: void 
2609: mk_rulecase( fp, rp ) 
2610: FILE        *fp; 
2611: RULE_T        *rp; 
2612: { 
2613:         DEF_T        *dp; 
2614:         int        i; 
2615:  
2616:         dp = finddef_withval( rp->r_sym, n_symtab, symtab ); 
2617:         fprintf( fp, "    case %s :\n", dp->d_name ); 
2618:         fprintf( fp, "      expr->n_class = C_UNDEF;\n" ); 
2619:         fprintf( fp, "      expr->n_kind = K_UNDEF;\n" ); 
2620:         fprintf( fp, "      expr->n_type = T_UNDEF;\n" ); 
2621:         fprintf( fp, "      if( l_type == T_ERROR || r_type == T_ERROR ){\n" ); 
2622:         fprintf( fp, "        expr->n_type = T_ERROR;\n" ); 
2623:         fprintf( fp, "        break;\n" ); 
2624:         fprintf( fp, "      }\n" ); 
2625:         if( rp->r_lclass != 0 ){ 
2626:                 fprintf( fp, "      if( !INSET( l_class, 0%o ) ){\n", 
2627:                         rp->r_lclass ); 
2628:                 fprintf( fp, "        expr->n_type = T_ERROR;\n" ); 
2629:                 fprintf( fp, "        errormsg( FALSE," ); 
2630:                 fprintf( fp, 
2631:                         "\"operator '%s': left operand has wrong class.\\n\"", 
2632:                         rp->r_print ); 
2633:                 fprintf( fp, ");\n" ); 
2634:                 fprintf( fp, "        break;\n" ); 
2635:                 fprintf( fp, "      }\n" ); 
2636:         } 
2637:         if( rp->r_rclass != 0 ){ 
2638:                 fprintf( fp, "      if( !INSET( r_class, 0%o ) ){\n", 
2639:                         rp->r_rclass ); 
2640:                 fprintf( fp, "        expr->n_type = T_ERROR;\n" ); 
2641:                 fprintf( fp, "        errormsg( FALSE," ); 
2642:                 fprintf( fp, 
2643:                         "\"operator '%s': right operand has wrong class.\\n\"", 
2644:                         rp->r_print ); 
2645:                 fprintf( fp, ");\n" ); 
2646:                 fprintf( fp, "        break;\n" ); 
2647:                 fprintf( fp, "      }\n" ); 
2648:         } 
2649:         fprintf( fp, "      o_class = " ); 
2650: /* 
2651:         if( !strcmp( rp->r_oclass, "left" ) ) 
2652:                 fprintf( fp, "l_class;\n" ); 
2653:         else if( !strcmp( rp->r_oclass, "right" ) ) 
2654:                 fprintf( fp, "r_class;\n" ); 
2655:         else  
2656:                 fprintf( fp, "%s;\n", rp->r_oclass ); 
2657: */ 
2658:         if( rp->r_octok == TOK_LEFT ) 
2659:                 fprintf( fp, "l_class;\n" ); 
2660:         else if( rp->r_octok == TOK_RIGHT ) 
2661:                 fprintf( fp, "r_class;\n" ); 
2662:         else{ 
2663:                 dp = finddef_withval( rp->r_ocval, n_cvtab, cvtab ); 
2664:                 fprintf( fp, "%s;\n", dp->d_name ); 
2665:         } 
2666:         fprintf( fp, "      t_idx = %d;\n", rp->r_types[0].t_index ); 
2667:         if( rp->r_nakind > 0 ){ 
2668:                 for( i = 0; i < rp->r_nakind; i++ ){ 
2669:                         if( i == 0 ) 
2670:                                 fprintf( fp, "      " ); 
2671:                         else 
2672:                                 fprintf( fp, "      else " ); 
2673:                         fprintf( fp, "if( INSET( akind, 0%o ) )\n", 
2674:                                 rp->r_akind[i] ); 
2675:                         fprintf( fp, "        t_idx += %d;\n", i ); 
2676:                 } 
2677:                 fprintf( fp, "      else{\n" ); 
2678:                 fprintf( fp, "        expr->n_type = T_ERROR;\n" ); 
2679:                 fprintf( fp, "        errormsg( FALSE," ); 
2680:                 fprintf( fp, 
2681:                         "\"operator '%s': array operand has wrong kind.\\n\"", 
2682:                         rp->r_print ); 
2683:                 fprintf( fp, ");\n" ); 
2684:                 fprintf( fp, "        break;\n" ); 
2685:                 fprintf( fp, "      }\n" ); 
2686:         } 
2687:         if( rp->r_nlkind > 0 ){ 
2688:                 for( i = 0; i < rp->r_nlkind; i++ ){ 
2689:                         if( i == 0 ) 
2690:                                 fprintf( fp, "      " ); 
2691:                         else 
2692:                                 fprintf( fp, "      else " ); 
2693:                         fprintf( fp, "if( INSET( l_kind, 0%o ) )\n", 
2694:                                 rp->r_lkind[i] ); 
2695:                         fprintf( fp, "        t_idx += %d;\n", i ); 
2696:                 } 
2697:                 fprintf( fp, "      else{\n" ); 
2698:                 fprintf( fp, "        expr->n_type = T_ERROR;\n" ); 
2699:                 fprintf( fp, "        errormsg( FALSE," ); 
2700:                 fprintf( fp, 
2701:                         "\"operator '%s': left operand has wrong kind.\\n\"", 
2702:                         rp->r_print ); 
2703:                 fprintf( fp, ");\n" ); 
2704:                 fprintf( fp, "        break;\n" ); 
2705:                 fprintf( fp, "      }\n" ); 
2706:         } 
2707:         if( rp->r_nrkind > 0 ){ 
2708:                 for( i = 0; i < rp->r_nrkind; i++ ){ 
2709:                         if( i == 0 ) 
2710:                                 fprintf( fp, "      " ); 
2711:                         else 
2712:                                 fprintf( fp, "      else " ); 
2713:                         fprintf( fp, "if( INSET( r_kind, 0%o ) )\n", 
2714:                                 rp->r_rkind[i] ); 
2715:                         fprintf( fp, "        t_idx += %d;\n", i ); 
2716:                 } 
2717:                 fprintf( fp, "      else{\n" ); 
2718:                 fprintf( fp, "        expr->n_type = T_ERROR;\n" ); 
2719:                 fprintf( fp, "        errormsg( FALSE," ); 
2720:                 fprintf( fp, 
2721:                         "\"operator '%s': right operand has wrong kind.\\n\"", 
2722:                         rp->r_print ); 
2723:                 fprintf( fp, ");\n" ); 
2724:                 fprintf( fp, "        break;\n" ); 
2725:                 fprintf( fp, "      }\n" ); 
2726:         } 
2727: /* 
2728:         fprintf( fp, "      o_kind = " ); 
2729:         if( !strcmp( rp->r_okind, "left" ) ) 
2730:                 fprintf( fp, "l_kind;\n" ); 
2731:         else if( !strcmp( rp->r_okind, "right" ) ) 
2732:                 fprintf( fp, "r_kind;\n" ); 
2733:         else 
2734:                 fprintf( fp, "%s;\n", rp->r_okind ); 
2735: */ 
2736:  
2737:         for( i = 0; i < rp->r_nokind; i++ ){ 
2738:                 if( rp->r_oktok[i] == TOK_LEFT ) 
2739:                         fprintf( fp, "      o_kind = l_kind;\n" ); 
2740:                 else if( rp->r_oktok[i] == TOK_RIGHT ) 
2741:                         fprintf( fp, "      o_kind = r_kind;\n" ); 
2742:                 else if( rp->r_okqtok[i] == TOK_LEFT ){ 
2743:                         fprintf( fp, "      if( INSET( l_kind, 0%o ) )\n", rp->r_okqval[i] ); 
2744:                         dp = finddef_withval( rp->r_okval[i], n_kvtab, kvtab ); 
2745:                         fprintf( fp, "        o_kind = %s;\n", dp->d_name ); 
2746:                 }else if( rp->r_okqtok[i] == TOK_RIGHT ){ 
2747:                         fprintf( fp, "      if( INSET( r_kind, 0%o ) )\n", rp->r_okqval[i] ); 
2748:                         dp = finddef_withval( rp->r_okval[i], n_kvtab, kvtab ); 
2749:                         fprintf( fp, "        o_kind = %s;\n", dp->d_name ); 
2750:                 }else{ 
2751:                         dp = finddef_withval( rp->r_okval[i], n_kvtab, kvtab ); 
2752:                         fprintf( fp, "      o_kind = %s;\n", dp->d_name ); 
2753:                 } 
2754:         } 
2755:  
2756:         fprintf( fp, "      o_type = typetab[t_idx][l_type][r_type];\n" ); 
2757:         fprintf( fp, "      if( o_type != T_ERROR ){\n" ); 
2758:         fprintf( fp, "        expr->n_class = o_class;\n" ); 
2759:         fprintf( fp, "        expr->n_kind = o_kind;\n" ); 
2760:         fprintf( fp, "        expr->n_type = o_type;\n" ); 
2761:         fprintf( fp, "      }else{\n" ); 
2762:         fprintf( fp, "        expr->n_type = T_ERROR;\n" ); 
2763:         fprintf( fp, "        errormsg( FALSE," ); 
2764:         fprintf( fp, "\"operator '%s': operands have wrong types.\\n\"", 
2765:                 rp->r_print ); 
2766:         fprintf( fp, ");\n" ); 
2767:         fprintf( fp, "      }\n" ); 
2768:         fprintf( fp, "      break;\n" ); 
2769: } 
2770:  
2771: static        void        mk_checkattr( fp ) 
2772: FILE        *fp; 
2773: { 
2774:         int        i; 
2775:         ATREC_T        *ap; 
2776:         DEF_T        *dp; 
2777:  
2778:         fprintf( fp, "\f\n" ); 
2779:         fprintf( fp, "typedef struct atrec_t {\n" ); 
2780:         fprintf( fp, "  char *a_name;\n" ); 
2781:         fprintf( fp, "  int a_type;\n" ); 
2782:         fprintf( fp, "  int a_class;\n" ); 
2783:         fprintf( fp, "  int a_kind;\n" ); 
2784:         fprintf( fp, "  int a_in;\n" ); 
2785:         fprintf( fp, "  int a_access;\n" ); 
2786:         fprintf( fp, "} ATREC_T;\n" ); 
2787:         fprintf( fp, "\n" ); 
2788:         fprintf( fp, "static ATREC_T attab[] = {\n" ); 
2789:         for( ap = attab, i = 0; i < n_attab; i++, ap++ ){ 
2790:                 if( i == 0 ) 
2791:                         fprintf( fp, "  {" );  
2792:                 else 
2793:                         fprintf( fp, " ,{" );  
2794:                 fprintf( fp, " \"%s\"", ap->a_name ); 
2795:                 dp = finddef_withval( ap->a_type, n_tvtab, tvtab ); 
2796:                 fprintf( fp, ", %s", dp->d_name ); 
2797:                 dp = finddef_withval( ap->a_class, n_cvtab, cvtab ); 
2798:                 fprintf( fp, ", %s", dp->d_name ); 
2799:                 dp = finddef_withval( ap->a_kind, n_kvtab, kvtab ); 
2800:                 fprintf( fp, ", %s", dp->d_name ); 
2801:                 fprintf( fp, ", 0%o", ap->a_in ); 
2802:                 dp = finddef_withval( ap->a_access, n_avtab, avtab ); 
2803:                 fprintf( fp, ", %s", dp->d_name ); 
2804:                 fprintf( fp, " }\n" ); 
2805:         } 
2806:         fprintf( fp, "};\n" ); 
2807:         fprintf( fp, 
2808:                 "static int n_attab = sizeof( attab ) / sizeof( ATREC_T );\n" ); 
2809:         fprintf( fp, "\n" ); 
2810:         fprintf( fp, "int CG_get_attr_access( expr, npl, npr )\n" ); 
2811:         fprintf( fp, "NODE_T *expr;\n" ); 
2812:         fprintf( fp, "NODE_T *npl;\n" ); 
2813:         fprintf( fp, "NODE_T *npr;\n" ); 
2814:         fprintf( fp, "{\n" ); 
2815:         fprintf( fp, "  int i;\n" ); 
2816:         fprintf( fp, "  ATREC_T *ap;\n" ); 
2817:         fprintf( fp, "  VALUE_T *vp;\n" ); 
2818:         fprintf( fp, "  char e_msg[ 256 ];\n" ); 
2819:         fprintf( fp, "\n" ); 
2820:         fprintf( fp, "  vp = &npr->n_val;\n" ); 
2821:         fprintf( fp, "  ap = attab;\n" ); 
2822:         fprintf( fp, 
2823:                 "  for( i = 0; i < n_attab; i++, ap++ ){\n" ); 
2824:         fprintf( fp, "    if( !strcmp( ap->a_name, vp->v_value.v_cval ) )\n" ); 
2825:         fprintf( fp, "      return(ap->a_access);\n" ); 
2826:         fprintf( fp, "  }\n" ); 
2827:         fprintf( fp, "  sprintf( e_msg, \"unknown attribute '%%s'\\n\"," ); 
2828:         fprintf( fp, " vp->v_value.v_cval );\n" ); 
2829:         fprintf( fp, "  expr->n_type = T_ERROR;\n" ); 
2830:         fprintf( fp, "  errormsg( FALSE, e_msg );\n" ); 
2831:         dp = finddef( "A_UNDEF", n_avtab, avtab ); 
2832:         fprintf( fp, "  return(%d);\n", dp->d_val ); 
2833:         fprintf( fp, "}\n" ); 
2834:         fprintf( fp, "\n" ); 
2835:         fprintf( fp, "static void checkattr( expr, npl, npr )\n" ); 
2836:         fprintf( fp, "NODE_T *expr;\n" ); 
2837:         fprintf( fp, "NODE_T *npl;\n" ); 
2838:         fprintf( fp, "NODE_T *npr;\n" ); 
2839:         fprintf( fp, "{\n" ); 
2840:         fprintf( fp, "  int i, found;\n" ); 
2841:         fprintf( fp, "  ATREC_T *ap;\n" ); 
2842:         fprintf( fp, "  VALUE_T *vp;\n" ); 
2843:         fprintf( fp, "  char e_msg[ 256 ];\n" ); 
2844:         fprintf( fp, "\n" ); 
2845:         fprintf( fp, "  vp = &npr->n_val;\n" ); 
2846:         fprintf( fp, "  ap = attab;\n" ); 
2847:         fprintf( fp, 
2848:                 "  for( found = FALSE, i = 0; i < n_attab; i++, ap++ ){\n" ); 
2849:         fprintf( fp, "    if( !strcmp( ap->a_name, vp->v_value.v_cval ) ){\n" ); 
2850:         fprintf( fp, "      found = TRUE;\n" ); 
2851:         fprintf( fp, "      break;\n" ); 
2852:         fprintf( fp, "    }\n" ); 
2853:         fprintf( fp, "  }\n" ); 
2854:         fprintf( fp, "  if( !found ){\n" ); 
2855:         fprintf( fp, "    sprintf( e_msg, \"unknown attribute '%%s'\\n\"," ); 
2856:         fprintf( fp, " vp->v_value.v_cval );\n" ); 
2857:         fprintf( fp, "    expr->n_type = T_ERROR;\n" ); 
2858:         fprintf( fp, "    errormsg( FALSE, e_msg );\n" ); 
2859:         fprintf( fp, "    return;\n" ); 
2860:         fprintf( fp, "  }\n" ); 
2861:         fprintf( fp, "  if( npl->n_class != C_VAR ){\n" ); 
2862:         fprintf( fp, "    expr->n_type = T_ERROR;\n" ); 
2863:         fprintf( fp, 
2864: "    errormsg( FALSE,\"operator '.': left operand must be a variable.\\n\" );\n" ); 
2865:         fprintf( fp, "    return;\n" ); 
2866:         fprintf( fp, "  }\n" ); 
2867:         fprintf( fp, "  if( npl->n_kind != K_SCALAR &&\n" ); 
2868:         fprintf( fp, "      npl->n_kind != K_DARRAYEL &&\n" ); 
2869:         fprintf( fp, "      npl->n_kind != K_HASHEL ){\n" ); 
2870:         fprintf( fp, "    expr->n_type = T_ERROR;\n" ); 
2871:         fprintf( fp, 
2872: "    errormsg( FALSE,\"operator '.': left operand must be a scalar.\\n\" );\n" ); 
2873:         fprintf( fp, "    return;\n" ); 
2874:         fprintf( fp, "  }\n" ); 
2875:         fprintf( fp, "  if( !INSET( npl->n_type, ap->a_in ) ){\n" ); 
2876:         fprintf( fp, "    expr->n_type = T_ERROR;\n" ); 
2877:         fprintf( fp, 
2878: "    errormsg_s( FALSE,\"operator '.': left operand has no attribute '%%s'.\\n\"," ); 
2879:         fprintf( fp, " ap->a_name );\n" ); 
2880:         fprintf( fp, "    return;\n" ); 
2881:         fprintf( fp, "  }\n" ); 
2882:         fprintf( fp, "  expr->n_type = ap->a_type;\n" ); 
2883:         fprintf( fp, "  expr->n_class = ap->a_class;\n" ); 
2884:         fprintf( fp, "  expr->n_kind = ap->a_kind;\n" ); 
2885:         fprintf( fp, "}\n" ); 
2886: } 
2887:  
2888: static        int        split( str, fields, fsep ) 
2889: char        str[]; 
2890: char        *fields[]; 
2891: char        *fsep; 
2892: { 
2893:         int        nf, flen, white; 
2894:         char        *sp, *fp, *efp, *nfp; 
2895:  
2896:         if( !str ) 
2897:                 return( 0 ); 
2898:  
2899:         /* Use fsep of white space is special                                */  
2900:         /* although a \n is a white space character, a fsep of a        */ 
2901:         /* single \n is not considered white space, allowing multi line        */ 
2902:         /* strings to be broken into lines                                */ 
2903:  
2904:         if( !strcmp( fsep, "\n" ) ) 
2905:                 white = 0; 
2906:         else if( strspn( fsep, " \t\n" ) == strlen( fsep ) ){ 
2907:                 white = 1; 
2908:         }else 
2909:                 white = 0; 
2910:  
2911:         if( white ){ 
2912:                 for( nf = 0, sp = str; ; ){ 
2913:                         fp = sp + strspn( sp, fsep ); 
2914:                         if( !*fp ) 
2915:                                 return( nf ); 
2916:                         if( efp = strpbrk( fp, fsep ) ){ 
2917:                                 if( !( flen = efp - fp ) ) 
2918:                                         return( nf ); 
2919:                                 nfp = (char *)malloc( (flen + 1) * sizeof(char) ); 
2920:                                 strncpy( nfp, fp, flen ); 
2921:                                 nfp[ flen ] = '\0'; 
2922:                                 fields[ nf ] = nfp; 
2923:                                 sp = efp; 
2924:                                 nf++; 
2925:                         }else{ 
2926:                                 flen = strlen( fp ); 
2927:                                 nfp = (char *)malloc( (flen + 1) * sizeof(char) ); 
2928:                                 strcpy( nfp, fp ); 
2929:                                 fields[ nf ] = nfp; 
2930:                                 nf++; 
2931:                                 return( nf ); 
2932:                         } 
2933:                 } 
2934:         }else{ 
2935:                 for( nf = 0, sp = str; ; ){ 
2936:                         if( fp = strchr( sp, *fsep ) ){ 
2937:                                 flen = fp - sp; 
2938:                                 nfp = (char *)malloc( (flen + 1) * sizeof(char) ); 
2939:                                 strncpy( nfp, sp, flen ); 
2940:                                 nfp[ flen ] = '\0'; 
2941:                                 fields[ nf ] = nfp; 
2942:                                 nf++; 
2943:                                 sp = fp + 1; 
2944:                         }else{ 
2945:                                 flen = strlen( sp ); 
2946:                                 nfp = (char *)malloc( (flen + 1) * sizeof(char) ); 
2947:                                 strcpy( nfp, sp ); 
2948:                                 fields[ nf ] = nfp; 
2949:                                 nf++; 
2950:                                 return( nf ); 
2951:                         } 
2952:                 } 
2953:         } 
2954: } 


r22274/SYM_ALLOCATE.rules 2017-01-21 10:39:25.988910797 +0000 r22273/SYM_ALLOCATE.rules 2017-01-21 10:39:36.789598320 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_ALLOCATE.rules' in revision 22273
  2:         sym    = SYM_ALLOCATE 
  3:         prec   = 0 
  4:         print  = "allocate stmt" 
  5:  
  6: class 
  7:         right  = C_VAR 
  8:         output = C_EXPR 
  9:  
 10: kind 
 11:         right  = K_DARRAYEL 
 12:         output = K_DARRAY 
 13:  
 14: type 
 15:         T_UNDEF      = [ 13,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 13, 13 ] 
 16:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 17:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:  


r22274/SYM_AND.rules 2017-01-21 10:39:26.216925573 +0000 r22273/SYM_AND.rules 2017-01-21 10:39:37.053614800 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_AND.rules' in revision 22273
  2:         sym    = SYM_AND 
  3:         prec   = 2 
  4:         print  = "&&" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_ASSERT.rules 2017-01-21 10:39:26.460941389 +0000 r22273/SYM_ASSERT.rules 2017-01-21 10:39:37.293629739 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_ASSERT.rules' in revision 22273
  2:         sym    = SYM_ASSERT 
  3:         prec   = 0 
  4:         print  = "assert stmt" 
  5:  
  6: class 
  7:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         output = C_EXPR 
  9:  
 10: kind 
 11:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 12:         output = K_SCALAR 
 13:  
 14: type 
 15:         T_UNDEF      = [ 13,  1,  2,  3,  1, 13, 13,  1,  1,  1,  1,  1, 13, 13 ] 
 16:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 17:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:  


r22274/SYM_ASSIGN.rules 2017-01-21 10:39:26.704957200 +0000 r22273/SYM_ASSIGN.rules 2017-01-21 10:39:37.517643684 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_ASSIGN.rules' in revision 22273
  2:         sym    = SYM_ASSIGN 
  3:         prec   = 0 
  4:         print  = "=" 
  5:  
  6: class 
  7:         left   = C_VAR 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR, C_NULL } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = left 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  2,  2,  2, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13,  3,  3,  3, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13,  4, 13, 13, 13, 13, 13, 13, 13, 12, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13,  5, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13,  6, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13,  7, 13, 13, 13, 13, 12, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13,  8, 13, 13, 13, 12, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13,  9, 13, 13, 12, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 10, 13, 12, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 11, 12, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_ATSIGN.rules 2017-01-21 10:39:26.952973273 +0000 r22273/SYM_ATSIGN.rules 2017-01-21 10:39:37.753658372 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_ATSIGN.rules' in revision 22273
  2:         sym    = SYM_ATSIGN 
  3:         prec   = 5 
  4:         print  = "@" 
  5:  
  6: class 
  7:         left   = { C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = { C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13,  3, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_CALL.rules 2017-01-21 10:39:27.180988008 +0000 r22273/SYM_CALL.rules 2017-01-21 10:39:37.993673315 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_CALL.rules' in revision 22273
  2:         sym    = SYM_CALL 
  3:         prec   = 0 
  4:         print  = "function call" 
  5:  
  6: class 
  7:         left   = C_FUNC 
  8:         right  = C_UNDEF 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = K_SCALAR 
 13:         right  = K_UNDEF 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [  2, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [  3, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [  4, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [  5, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [  6, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [  7, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [  8, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [  9, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 11, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_DEALLOCATE.rules 2017-01-21 10:39:27.409002730 +0000 r22273/SYM_DEALLOCATE.rules 2017-01-21 10:39:38.225687706 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_DEALLOCATE.rules' in revision 22273
  2:         sym    = SYM_DEALLOCATE 
  3:         prec   = 0 
  4:         print  = "deallocate stmt" 
  5:  
  6: class 
  7:         right  = C_VAR 
  8:         output = C_UNDEF 
  9:  
 10: kind 
 11:         right  = K_DARRAY 
 12:         output = K_UNDEF 
 13:  
 14: type 
 15:         T_UNDEF      = [ 13,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 13, 13 ] 
 16:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 17:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:  


r22274/SYM_DELETE.rules 2017-01-21 10:39:27.833030106 +0000 r22273/SYM_DELETE.rules 2017-01-21 10:39:38.477703333 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_DELETE.rules' in revision 22273
  2:         sym    = SYM_DELETE 
  3:         prec   = 0 
  4:         print  = "delete stmt" 
  5:  
  6: class 
  7:         right  = C_VAR 
  8:         output = C_UNDEF 
  9:  
 10: kind 
 11:         right  = { K_HASHEL, K_HASHED } 
 12:         output = K_UNDEF 
 13:  
 14: type 
 15:         T_UNDEF      = [ 13,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 13, 13 ] 
 16:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 17:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:  


r22274/SYM_DONT_MATCH.rules 2017-01-21 10:39:28.085046360 +0000 r22273/SYM_DONT_MATCH.rules 2017-01-21 10:39:38.717718221 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_DONT_MATCH.rules' in revision 22273
  2:         sym    = SYM_DONT_MATCH 
  3:         prec   = 3 
  4:         print  = "!~" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_EQUAL.rules 2017-01-21 10:39:28.329062057 +0000 r22273/SYM_EQUAL.rules 2017-01-21 10:39:38.937731865 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_EQUAL.rules' in revision 22273
  2:         sym    = SYM_EQUAL 
  3:         prec   = 3 
  4:         print  = "==" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR, C_NULL } 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR, C_NULL } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13,  1, 13, 13, 13, 13, 13, 13, 13,  1, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13,  1, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13,  1, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13,  1, 13, 13, 13, 13,  1, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13,  1, 13, 13, 13,  1, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13,  1, 13, 13,  1, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,  1, 13,  1, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,  1,  1, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13,  1, 13, 13,  1,  1,  1,  1,  1,  1, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_FOREACH.rules 2017-01-21 10:39:28.581078269 +0000 r22273/SYM_FOREACH.rules 2017-01-21 10:39:39.165745979 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_FOREACH.rules' in revision 22273
  2:         sym    = SYM_FOREACH 
  3:         prec   = 0 
  4:         print  = "for in loop" 
  5:  
  6: class 
  7:         left   = C_VAR 
  8:         right  = C_VAR 
  9:         output = C_UNDEF 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } use type = 1 
 14:         right  = K_HASHED use type = 2 
 15:         output = K_UNDEF 
 16:  
 17: type = 1 
 18:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13,  8,  8, 13, 13, 13 ] 
 27:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,  9, 13, 13, 13 ] 
 28:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 32:  
 33: type = 2 
 34:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 35:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 36:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 37:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 38:         T_STRING     = [ 13,  4, 13,  4,  4,  4,  4,  4,  4,  4,  4,  4, 13, 13 ] 
 39:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 40:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 41:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 42:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 43:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 44:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 45:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 46:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 47:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 48:  


r22274/SYM_GREATER_EQUAL.rules 2017-01-21 10:39:29.037107592 +0000 r22273/SYM_GREATER_EQUAL.rules 2017-01-21 10:39:39.605773160 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_GREATER_EQUAL.rules' in revision 22273
  2:         sym    = SYM_GREATER_EQUAL 
  3:         prec   = 3 
  4:         print  = ">=" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_GREATER.rules 2017-01-21 10:39:28.809092939 +0000 r22273/SYM_GREATER.rules 2017-01-21 10:39:39.385759574 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_GREATER.rules' in revision 22273
  2:         sym    = SYM_GREATER 
  3:         prec   = 3 
  4:         print  = ">" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_INDEX.rules 2017-01-21 10:39:29.549140412 +0000 r22273/SYM_INDEX.rules 2017-01-21 10:39:40.041800093 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_INDEX.rules' in revision 22273
  2:         sym    = SYM_INDEX 
  3:         prec   = 0 
  4:         print  = "array index expr" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = { C_UNDEF, C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         akind  = { K_ARRAY, K_DARRAY } use type = 1 
 13:         akind  = K_HASHED use type = 2 
 14:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 15:         right  = { K_UNDEF, K_SCALAR, K_HASHEL, K_DARRAYEL } 
 16:         output = K_SCALAR 
 17:  
 18: type = 1 
 19:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_INT        = [  1,  1,  2, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_SIZE_T     = [  2,  2,  2, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 32:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 33:  
 34: type = 2 
 35:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 36:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 37:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 38:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 39:         T_STRING     = [  4, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 40:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 41:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 42:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 43:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 44:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 45:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 46:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 47:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 48:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 49:  


r22274/SYM_IN.rules 2017-01-21 10:39:29.265122207 +0000 r22273/SYM_IN.rules 2017-01-21 10:39:39.825786755 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_IN.rules' in revision 22273
  2:         sym    = SYM_IN 
  3:         prec   = 3 
  4:         print  = "in" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = C_VAR 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = K_HASHED 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_LBRACK.rules 2017-01-21 10:39:29.781155283 +0000 r22273/SYM_LBRACK.rules 2017-01-21 10:39:40.257813394 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_LBRACK.rules' in revision 22273
  2:         sym    = SYM_LBRACK 
  3:         prec   = 8 
  4:         print  = "[" 
  5:  
  6: class 
  7:         left   = C_VAR 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_VAR 
 10:  
 11: kind 
 12:         left   = { K_ARRAY, K_DARRAY } use type = 1 
 13:         left   = K_HASHED use type = 2 
 14:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 15:         output = K_SCALAR if left = K_ARRAY 
 16:         output = K_DARRAYEL if left = K_DARRAY 
 17:         output = K_HASHEL if left = K_HASHED 
 18:  
 19: type = 1 
 20:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_INT        = [ 13,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_SIZE_T     = [ 13,  2,  2, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_FLOAT      = [ 13,  3,  3, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_STRING     = [ 13,  4,  4, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_POINT      = [ 13,  5,  5, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_MATRIX     = [ 13,  6,  6, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_FILE       = [ 13,  7,  7, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_ATOM       = [ 13,  8,  8, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_RESIDUE    = [ 13,  9,  9, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_MOLECULE   = [ 13, 10, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:         T_BOUNDS     = [ 13, 11, 11, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 32:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 33:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 34:  
 35: type = 2 
 36:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 37:         T_INT        = [ 13, 13, 13, 13,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 38:         T_SIZE_T     = [ 13, 13, 13, 13,  2, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 39:         T_FLOAT      = [ 13, 13, 13, 13,  3, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 40:         T_STRING     = [ 13, 13, 13, 13,  4, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 41:         T_POINT      = [ 13, 13, 13, 13,  5, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 42:         T_MATRIX     = [ 13, 13, 13, 13,  6, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 43:         T_FILE       = [ 13, 13, 13, 13,  7, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 44:         T_ATOM       = [ 13, 13, 13, 13,  8, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 45:         T_RESIDUE    = [ 13, 13, 13, 13,  9, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 46:         T_MOLECULE   = [ 13, 13, 13, 13, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 47:         T_BOUNDS     = [ 13, 13, 13, 13, 11, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 48:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 49:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 50:  


r22274/SYM_LESS_EQUAL.rules 2017-01-21 10:39:30.225183691 +0000 r22273/SYM_LESS_EQUAL.rules 2017-01-21 10:39:40.701840729 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_LESS_EQUAL.rules' in revision 22273
  2:         sym    = SYM_LESS_EQUAL 
  3:         prec   = 3 
  4:         print  = "<=" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_LESS.rules 2017-01-21 10:39:30.005169642 +0000 r22273/SYM_LESS.rules 2017-01-21 10:39:40.481827187 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_LESS.rules' in revision 22273
  2:         sym    = SYM_LESS 
  3:         prec   = 3 
  4:         print  = "<" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_LPAREN.rules 2017-01-21 10:39:30.457198508 +0000 r22273/SYM_LPAREN.rules 2017-01-21 10:39:40.921854275 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_LPAREN.rules' in revision 22273
  2:         sym    = SYM_LPAREN 
  3:         prec   = 10 
  4:         print  = "(" 
  5:  
  6: class 
  7:         left   = C_UNDEF 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR, C_NULL } 
  9:         output = right 
 10:  
 11: kind 
 12:         left   = K_UNDEF 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL, K_ARRAY, K_DARRAY, K_HASHED } 
 14:         output = right 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13 ] 
 18:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_MATCH.rules 2017-01-21 10:39:30.713214857 +0000 r22273/SYM_MATCH.rules 2017-01-21 10:39:41.145868035 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_MATCH.rules' in revision 22273
  2:         sym    = SYM_MATCH 
  3:         prec   = 3 
  4:         print  = "=~" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_MINUS_ASSIGN.rules 2017-01-21 10:39:31.357255912 +0000 r22273/SYM_MINUS_ASSIGN.rules 2017-01-21 10:39:41.597895764 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_MINUS_ASSIGN.rules' in revision 22273
  2:         sym    = SYM_MINUS_ASSIGN 
  3:         prec   = 0 
  4:         print  = "-=" 
  5:  
  6: class 
  7:         left   = C_VAR 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = left 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  2,  2,  2, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13,  3,  3,  3, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13,  5, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_MINUS_MINUS.rules 2017-01-21 10:39:31.597271174 +0000 r22273/SYM_MINUS_MINUS.rules 2017-01-21 10:39:41.821909505 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_MINUS_MINUS.rules' in revision 22273
  2:         sym    = SYM_MINUS_MINUS 
  3:         prec   = 7 
  4:         print  = "--" 
  5:  
  6: class 
  7:         left   = { C_UNDEF, C_VAR } 
  8:         right  = { C_UNDEF, C_VAR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_UNDEF, K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_UNDEF, K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13,  1,  2, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [  2, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_MINUS.rules 2017-01-21 10:39:30.953230185 +0000 r22273/SYM_MINUS.rules 2017-01-21 10:39:41.361881285 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_MINUS.rules' in revision 22273
  2:         sym    = SYM_MINUS 
  3:         prec   = 4 
  4:         print  = "-" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  2,  3, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  2,  2,  3, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13,  3,  3,  3, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13,  5, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_MODULUS_ASSIGN.rules 2017-01-21 10:39:32.089302459 +0000 r22273/SYM_MODULUS_ASSIGN.rules 2017-01-21 10:39:42.281937660 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_MODULUS_ASSIGN.rules' in revision 22273
  2:         sym    = SYM_MODULUS_ASSIGN 
  3:         prec   = 0 
  4:         print  = "%=" 
  5:  
  6: class 
  7:         left   = C_VAR 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = left 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  2,  2, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_MODULUS.rules 2017-01-21 10:39:31.837286448 +0000 r22273/SYM_MODULUS.rules 2017-01-21 10:39:42.061924213 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_MODULUS.rules' in revision 22273
  2:         sym    = SYM_MODULUS 
  3:         prec   = 5 
  4:         print  = "%" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  2, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  2,  2, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_NEGATE.rules 2017-01-21 10:39:32.341318439 +0000 r22273/SYM_NEGATE.rules 2017-01-21 10:39:42.505951351 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_NEGATE.rules' in revision 22273
  2:         sym    = SYM_NEGATE 
  3:         prec   = 7 
  4:         print  = "(Unary) -" 
  5:  
  6: class 
  7:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         output = C_EXPR 
  9:  
 10: kind 
 11:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 12:         output = K_SCALAR 
 13:  
 14: type 
 15:         T_UNDEF      = [ 13,  1,  2,  3, 13,  5, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 16:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 17:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:  


r22274/SYM_NOT_EQUAL.rules 2017-01-21 10:39:32.805347854 +0000 r22273/SYM_NOT_EQUAL.rules 2017-01-21 10:39:42.957978980 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_NOT_EQUAL.rules' in revision 22273
  2:         sym    = SYM_NOT_EQUAL 
  3:         prec   = 3 
  4:         print  = "!=" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR, C_NULL } 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR, C_NULL } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13,  1, 13, 13, 13, 13, 13, 13, 13,  1, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13,  1, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13,  1, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13,  1, 13, 13, 13, 13,  1, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13,  1, 13, 13, 13,  1, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13,  1, 13, 13,  1, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,  1, 13,  1, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,  1,  1, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13,  1, 13, 13,  1,  1,  1,  1,  1,  1, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_NOT.rules 2017-01-21 10:39:32.577333399 +0000 r22273/SYM_NOT.rules 2017-01-21 10:39:42.737965534 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_NOT.rules' in revision 22273
  2:         sym    = SYM_NOT 
  3:         prec   = 7 
  4:         print  = "!" 
  5:  
  6: class 
  7:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         output = C_EXPR 
  9:  
 10: kind 
 11:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 12:         output = K_SCALAR 
 13:  
 14: type 
 15:         T_UNDEF      = [ 13,  1,  1,  3,  1,  1,  1,  1,  1,  1,  1,  1, 13, 13 ] 
 16:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 17:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:  


r22274/SYM_OR.rules 2017-01-21 10:39:33.037362549 +0000 r22273/SYM_OR.rules 2017-01-21 10:39:43.618019182 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_OR.rules' in revision 22273
  2:         sym    = SYM_OR 
  3:         prec   = 1 
  4:         print  = "||" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_PARM.rules 2017-01-21 10:39:33.261376697 +0000 r22273/SYM_PARM.rules 2017-01-21 10:39:43.846033064 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_PARM.rules' in revision 22273
  2:         sym    = SYM_PARM 
  3:         prec   = 0 
  4:         print  = "parameter" 
  5:  
  6: class 
  7:         right  = { C_LIT, C_VAR, C_FUNC, C_DEFINE, C_EXPR, C_NULL } 
  8:         output = C_UNDEF 
  9:  
 10: kind 
 11:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL, K_ARRAY, K_DARRAY, K_HASHED } 
 12:         output = K_UNDEF 
 13:  
 14: type 
 15:         T_UNDEF      = [ 13,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13 ] 
 16:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 17:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:  


r22274/SYM_PLUS_ASSIGN.rules 2017-01-21 10:39:33.713405252 +0000 r22273/SYM_PLUS_ASSIGN.rules 2017-01-21 10:39:44.322061986 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_PLUS_ASSIGN.rules' in revision 22273
  2:         sym    = SYM_PLUS_ASSIGN 
  3:         prec   = 0 
  4:         print  = "+=" 
  5:  
  6: class 
  7:         left   = C_VAR 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = left 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  2,  2,  2, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13,  3,  3,  3, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13,  4, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13,  5, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_PLUS_PLUS.rules 2017-01-21 10:39:33.937419405 +0000 r22273/SYM_PLUS_PLUS.rules 2017-01-21 10:39:44.658082374 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_PLUS_PLUS.rules' in revision 22273
  2:         sym    = SYM_PLUS_PLUS 
  3:         prec   = 7 
  4:         print  = "++" 
  5:  
  6: class 
  7:         left   = { C_UNDEF, C_VAR } 
  8:         right  = { C_UNDEF, C_VAR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_UNDEF, K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_UNDEF, K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13,  1,  2, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [  2, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_PLUS.rules 2017-01-21 10:39:33.489391103 +0000 r22273/SYM_PLUS.rules 2017-01-21 10:39:44.086047664 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_PLUS.rules' in revision 22273
  2:         sym    = SYM_PLUS 
  3:         prec   = 4 
  4:         print  = "+" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  2,  3, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  2,  2,  3, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13,  3,  3,  3, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13,  4, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13,  5, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_SLASH_ASSIGN.rules 2017-01-21 10:39:34.393448117 +0000 r22273/SYM_SLASH_ASSIGN.rules 2017-01-21 10:39:45.142111711 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_SLASH_ASSIGN.rules' in revision 22273
  2:         sym    = SYM_SLASH_ASSIGN 
  3:         prec   = 0 
  4:         print  = "/=" 
  5:  
  6: class 
  7:         left   = C_VAR 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = left 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  2,  2,  2, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13,  3,  3,  3, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13,  5,  5,  5, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_SLASH.rules 2017-01-21 10:39:34.161433514 +0000 r22273/SYM_SLASH.rules 2017-01-21 10:39:44.914097907 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_SLASH.rules' in revision 22273
  2:         sym    = SYM_SLASH 
  3:         prec   = 5 
  4:         print  = "/" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  2,  3, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  2,  2,  3, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13,  3,  3,  3, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13,  5,  5,  5, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_STAR_ASSIGN.rules 2017-01-21 10:39:34.841476311 +0000 r22273/SYM_STAR_ASSIGN.rules 2017-01-21 10:39:45.630141213 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_STAR_ASSIGN.rules' in revision 22273
  2:         sym    = SYM_STAR_ASSIGN 
  3:         prec   = 0 
  4:         print  = "*=" 
  5:  
  6: class 
  7:         left   = C_VAR 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = left 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  1,  1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  2,  2,  2, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13,  3,  3,  3, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13,  5,  5,  5, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_STAR.rules 2017-01-21 10:39:34.621462465 +0000 r22273/SYM_STAR.rules 2017-01-21 10:39:45.414128154 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_STAR.rules' in revision 22273
  2:         sym    = SYM_STAR 
  3:         prec   = 5 
  4:         print  = "*" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13,  1,  2,  3, 13,  5, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13,  2,  2,  3, 13,  5, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13,  3,  3,  3, 13,  5, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13,  5,  5,  5, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_TEST.rules 2017-01-21 10:39:35.073490899 +0000 r22273/SYM_TEST.rules 2017-01-21 10:39:45.846154273 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_TEST.rules' in revision 22273
  2:         sym    = SYM_TEST 
  3:         prec   = 0 
  4:         print  = "test-for-true" 
  5:  
  6: class 
  7:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         output = C_UNDEF 
  9:  
 10: kind 
 11:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 12:         output = K_UNDEF 
 13:  
 14: type 
 15:         T_UNDEF      = [ 13,  1,  1,  3,  1,  1,  1,  1,  1,  1,  1,  1, 13, 13 ] 
 16:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 17:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_POINT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:  


r22274/SYM_UPARROW_ASSIGN.rules 2017-01-21 10:39:35.561521497 +0000 r22273/SYM_UPARROW_ASSIGN.rules 2017-01-21 10:39:46.306182016 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_UPARROW_ASSIGN.rules' in revision 22273
  2:         sym    = SYM_UPARROW_ASSIGN 
  3:         prec   = 0 
  4:         print  = "^=" 
  5:  
  6: class 
  7:         left   = C_VAR 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = left 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13,  5, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


r22274/SYM_UPARROW.rules 2017-01-21 10:39:35.305505444 +0000 r22273/SYM_UPARROW.rules 2017-01-21 10:39:46.074168041 +0000
  1: operator  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/NAB/semantics/SYM_UPARROW.rules' in revision 22273
  2:         sym    = SYM_UPARROW 
  3:         prec   = 6 
  4:         print  = "^" 
  5:  
  6: class 
  7:         left   = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  8:         right  = { C_LIT, C_VAR, C_DEFINE, C_EXPR } 
  9:         output = C_EXPR 
 10:  
 11: kind 
 12:         left   = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 13:         right  = { K_SCALAR, K_HASHEL, K_DARRAYEL } 
 14:         output = K_SCALAR 
 15:  
 16: type 
 17:         T_UNDEF      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 18:         T_INT        = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 19:         T_SIZE_T     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 20:         T_FLOAT      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 21:         T_STRING     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 22:         T_POINT      = [ 13, 13, 13, 13, 13,  5, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 23:         T_MATRIX     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 24:         T_FILE       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 25:         T_ATOM       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 26:         T_RESIDUE    = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 27:         T_MOLECULE   = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 28:         T_BOUNDS     = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 29:         T_NULL       = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 30:         T_ERROR      = [ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 ] 
 31:  


legend
Lines Added 
Lines changed
 Lines Removed

hdiff - version: 2.1.0