![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to match.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / mip|
Return to match.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / mip |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)match.c 1.1 86/02/03 SMI"; ! 3: #endif ! 4: ! 5: # include "cpass2.h" ! 6: ! 7: # ifdef WCARD1 ! 8: # ifdef WCARD2 ! 9: # define NOINDIRECT ! 10: # endif ! 11: # endif ! 12: ! 13: extern vdebug; ! 14: ! 15: int fldsz, fldshf; ! 16: ! 17: int mamask[] = { /* masks for matching dope with shapes */ ! 18: SIMPFLG, /* OPSIMP */ ! 19: SIMPFLG|ASGFLG, /* ASG OPSIMP */ ! 20: COMMFLG, /* OPCOMM */ ! 21: COMMFLG|ASGFLG, /* ASG OPCOMM */ ! 22: MULFLG, /* OPMUL */ ! 23: MULFLG|ASGFLG, /* ASG OPMUL */ ! 24: DIVFLG, /* OPDIV */ ! 25: DIVFLG|ASGFLG, /* ASG OPDIV */ ! 26: UTYPE, /* OPUNARY */ ! 27: TYFLG, /* ASG OPUNARY is senseless */ ! 28: LTYPE, /* OPLEAF */ ! 29: TYFLG, /* ASG OPLEAF is senseless */ ! 30: 0, /* OPANY */ ! 31: ASGOPFLG|ASGFLG,/* ASG OPANY */ ! 32: LOGFLG, /* OPLOG */ ! 33: TYFLG, /* ASG OPLOG is senseless */ ! 34: FLOFLG, /* OPFLOAT */ ! 35: FLOFLG|ASGFLG, /* ASG OPFLOAT */ ! 36: SHFFLG, /* OPSHFT */ ! 37: SHFFLG|ASGFLG, /* ASG OPSHIFT */ ! 38: SPFLG, /* OPLTYPE */ ! 39: TYFLG, /* ASG OPLTYPE is senseless */ ! 40: INTRFLG, /* OPINTR */ ! 41: TYFLG, /* ASG OPINTR is senseless */ ! 42: }; ! 43: ! 44: int sdebug = 0; ! 45: ! 46: tshape( p, shape ) ! 47: register NODE *p; ! 48: { ! 49: /* ! 50: * return true if shape is appropriate for the node p ! 51: * side effect for SFLD is to set up fldsz,etc ! 52: */ ! 53: register o, mask; ! 54: register lval; ! 55: ! 56: o = p->in.op; ! 57: ! 58: # ifndef BUG3 ! 59: if ( sdebug ){ ! 60: printf( "tshape( %o, %o), op = %d\n", p, shape, o ); ! 61: } ! 62: # endif ! 63: ! 64: if ( shape & SPECIAL ){ ! 65: switch ( shape ){ ! 66: case SZERO: ! 67: if ( o != ICON || p->in.name[0] ) return(0); ! 68: return(p->tn.lval == 0); ! 69: case SONE: ! 70: if ( o != ICON || p->in.name[0] ) return(0); ! 71: return(p->tn.lval == 1); ! 72: case SMONE: ! 73: if ( o != ICON || p->in.name[0] ) return(0); ! 74: return(p->tn.lval == -1); ! 75: case SSCON: ! 76: if ( o != ICON || p->in.name[0] ) return(0); ! 77: lval = p->tn.lval; ! 78: return(lval >= -32768 && lval <= 32767); ! 79: case SCCON: ! 80: if ( o != ICON || p->in.name[0] ) return(0); ! 81: lval = p->tn.lval; ! 82: return(lval >= -128 && lval <= 127); ! 83: case SSOREG: /* non-indexed OREG */ ! 84: return(o == OREG && !R2TEST(p->tn.rval)); ! 85: ! 86: default: ! 87: # ifdef MULTILEVEL ! 88: if ( shape & MULTILEVEL ) ! 89: return( mlmatch(p,shape,0) ); ! 90: else ! 91: # endif ! 92: return (special( p, shape )); ! 93: } ! 94: } ! 95: if ( shape & SANY ) return(1); ! 96: if ( (shape&INTEMP) && shtemp(p) ) return(1); ! 97: if ( (shape&SWADD) && (o==NAME||o==OREG) ){ ! 98: if ( BYTEOFF(p->tn.lval) ) return(0); ! 99: } ! 100: ! 101: # ifdef WCARD1 ! 102: if ( shape & WCARD1 ) ! 103: return( wcard1(p) & shape ); ! 104: # endif ! 105: ! 106: # ifdef WCARD2 ! 107: if ( shape & WCARD2 ) ! 108: return( wcard2(p) & shape ); ! 109: # endif ! 110: switch( o ){ ! 111: case NAME: ! 112: return( shape&SNAME ); ! 113: case FCON: ! 114: case ICON: ! 115: mask = SCON; ! 116: return( shape & mask ); ! 117: case FLD: ! 118: if ( shape & SFLD ){ ! 119: if ( !flshape( p->in.left ) ) return(0); ! 120: /* it is a FIELD shape; make side-effects */ ! 121: o = p->tn.rval; ! 122: fldsz = UPKFSZ(o); ! 123: # ifdef RTOLBYTES ! 124: fldshf = UPKFOFF(o); ! 125: # else ! 126: fldshf = SZINT - fldsz - UPKFOFF(o); ! 127: # endif ! 128: return(1); ! 129: } ! 130: return(0); ! 131: case FCCODES: ! 132: case CCODES: ! 133: return( shape&SCC ); ! 134: case REG: ! 135: /* distinctions: ! 136: * SAREG any scalar register ! 137: * STAREG any temporary scalar register ! 138: * SBREG any lvalue (index) register ! 139: * STBREG any temporary lvalue register ! 140: * SCREG any floating register ! 141: * STCREG any temporary floating register ! 142: */ ! 143: if (isbreg( p->tn.rval )) ! 144: mask = SBREG; ! 145: else if (iscreg( p->tn.rval )) ! 146: mask = SCREG; ! 147: else ! 148: mask = SAREG; ! 149: if ( istreg( p->tn.rval ) && busy[p->tn.rval]<=1 ) { ! 150: if (mask==SAREG) ! 151: mask |= STAREG; ! 152: else if (mask==SBREG) ! 153: mask |= STBREG; ! 154: else ! 155: mask |= STCREG; ! 156: } ! 157: return( shape & mask ); ! 158: case OREG: ! 159: return( shape & SOREG ); ! 160: ! 161: # ifndef NOINDIRECT ! 162: case UNARY MUL: ! 163: /* return STARNM or STARREG or 0 */ ! 164: return( shumul(p->in.left) & shape ); ! 165: # endif ! 166: ! 167: } ! 168: ! 169: return(0); ! 170: } ! 171: ! 172: int tdebug = 0; ! 173: ! 174: ttype( t, tword ) ! 175: register TWORD t; ! 176: register tword; ! 177: { ! 178: /* does the type t match tword */ ! 179: ! 180: if ( tword & TANY ) return(1); ! 181: if ( t == UNDEF ) t=INT; /* void functions eased thru tables */ ! 182: # ifndef BUG3 ! 183: if ( tdebug ){ ! 184: printf( "ttype( %o, %o )\n", t, tword ); ! 185: } ! 186: # endif ! 187: if ( ISPTR(t) && (tword&TPTRTO) ) { ! 188: do { ! 189: t = DECREF(t); ! 190: } while ( ISARY(t) ); ! 191: /* arrays that are left are usually only ! 192: in structure references... */ ! 193: return( ttype( t, tword&(~TPTRTO) ) ); ! 194: } ! 195: if ( t != BTYPE(t) ) ! 196: return( tword & TPOINT ); /* TPOINT means not simple! */ ! 197: if ( tword & TPTRTO ) return(0); ! 198: switch( t ){ ! 199: case CHAR: ! 200: return( tword & TCHAR ); ! 201: case SHORT: ! 202: return( tword & TSHORT ); ! 203: case STRTY: ! 204: case UNIONTY: ! 205: return( tword & TSTRUCT ); ! 206: case INT: ! 207: return( tword & TINT ); ! 208: case UNSIGNED: ! 209: return( tword & TUNSIGNED ); ! 210: case USHORT: ! 211: return( tword & TUSHORT ); ! 212: case UCHAR: ! 213: return( tword & TUCHAR ); ! 214: case ULONG: ! 215: return( tword & TULONG ); ! 216: case LONG: ! 217: return( tword & TLONG ); ! 218: case FLOAT: ! 219: return( tword & TFLOAT ); ! 220: case DOUBLE: ! 221: return( tword & TDOUBLE ); ! 222: } ! 223: return(0); ! 224: } ! 225: ! 226: #define MAXOPSET 2000 ! 227: ! 228: struct opvect { ! 229: struct optab **first; ! 230: struct optab **rewrite; ! 231: }; ! 232: ! 233: struct opvect opvect[DSIZE]; ! 234: struct optab *opsets[MAXOPSET]; ! 235: ! 236: static struct optab **firstelement= opsets; ! 237: static struct optab **nextelement = opsets; ! 238: ! 239: extern int opmatch(/* op, targetop */); /* returns 1 if op matches targetop */ ! 240: ! 241: /* ! 242: * setrew() ! 243: * Generates sets of templates to be examined by match(), one ! 244: * for each operator in 0..DSIZE. The sets are represented as ! 245: * vectors of pointers into the code table. The sets could be ! 246: * constructed by a separate program when the compiler is compiled, ! 247: * but doing it at startup enables us to deal more conveniently ! 248: * with user-selected processor options (e.g., -m68020 -m68881) ! 249: */ ! 250: ! 251: setrew() ! 252: { ! 253: register struct optab *q; ! 254: register int op; ! 255: register struct optab **nextel = nextelement; ! 256: register struct optab **firstel = firstelement; ! 257: ! 258: for( op = 0; op < DSIZE; ++op ) { ! 259: if (dope[op]) { ! 260: /* ! 261: * operator exists; ! 262: * scan table for matching templates ! 263: */ ! 264: register struct optab **firstrew; ! 265: firstrew = (struct optab**)NULL; ! 266: for (q = table; q->op != FREE; q++) { ! 267: if (opmatch(op, q->op)) { ! 268: if (q->needs == REWRITE) { ! 269: if (!firstrew) { ! 270: firstrew = nextel; ! 271: } ! 272: } ! 273: *nextel++ = q; ! 274: } ! 275: } ! 276: if (nextel-opsets >= MAXOPSET) { ! 277: cerror("too many opsets (%d)", ! 278: nextel-opsets); ! 279: } ! 280: opvect[op].first = firstel; ! 281: opvect[op].rewrite = firstrew; ! 282: *nextel++ = (struct optab*)NULL; ! 283: firstel = nextel; ! 284: } else { ! 285: /* no operator */ ! 286: opvect[op].first = (struct optab**)NULL; ! 287: opvect[op].rewrite = (struct optab**)NULL; ! 288: } /* else */ ! 289: } /* for each op */ ! 290: nextelement = nextel; ! 291: firstelement = firstel; ! 292: } /* setrew */ ! 293: ! 294: match( p, cookie ) ! 295: NODE *p; ! 296: { ! 297: /* ! 298: * called by: order, gencall ! 299: * look for match in table and generate code if found unless ! 300: * entry specified REWRITE. ! 301: * returns MDONE, MNOPE, or rewrite specification from table ! 302: */ ! 303: ! 304: register struct optab **opset; ! 305: register struct optab *q; ! 306: register op; ! 307: register NODE *r; ! 308: ! 309: rcount(); ! 310: op = p->in.op; ! 311: if (cookie == FORREW) { ! 312: opset = opvect[op].rewrite; ! 313: } else { ! 314: opset = opvect[op].first; ! 315: /* ! 316: * finish the special-case test for autoincrement trees ! 317: */ ! 318: if (op == UNARY MUL && !shumul(p->in.left)) { ! 319: return(MNOPE); ! 320: } ! 321: } ! 322: if (opset == (struct optab**)NULL) { ! 323: cerror("no template for op '%s'", opst[op]); ! 324: } ! 325: for (q = *opset++; q != (struct optab *)NULL; q = *opset++) { ! 326: ! 327: /* see if goal matches */ ! 328: if ( !(q->visit & cookie ) ) continue; ! 329: ! 330: /* see if left child matches */ ! 331: r = ( optype( op ) == LTYPE ? p : p->in.left ); ! 332: if ( !tshape( r, q->lshape ) ) ! 333: continue; ! 334: if ( !ttype( r->in.type, q->ltype ) ) ! 335: continue; ! 336: ! 337: /* see if right child matches */ ! 338: r = ( optype( op ) != BITYPE ? p : p->in.right ); ! 339: if ( !tshape( r, q->rshape ) ) ! 340: continue; ! 341: if ( !ttype( r->in.type, q->rtype ) ) ! 342: continue; ! 343: ! 344: /* ! 345: * REWRITE means no code from this match but go ahead ! 346: * and rewrite node to help future match. ! 347: */ ! 348: if ( q->needs & REWRITE ) ! 349: return( q->rewrite ); ! 350: if ( !allo( p, q ) ) ! 351: continue; /* if can't generate code, skip entry */ ! 352: ! 353: /* resources are available */ ! 354: ! 355: /* generate code */ ! 356: expand( p, cookie, q->cstring ); ! 357: reclaim( p, q->rewrite, cookie ); ! 358: ! 359: return(MDONE); ! 360: ! 361: } ! 362: ! 363: return(MNOPE); ! 364: } ! 365: ! 366: int rtyflg = 0; ! 367: ! 368: expand( p, cookie, cp ) ! 369: NODE *p; ! 370: register char *cp; ! 371: { ! 372: /* generate code by interpreting table entry */ ! 373: ! 374: register char c; ! 375: CONSZ val; ! 376: ! 377: rtyflg = 0; ! 378: ! 379: for( ; *cp; ++cp ){ ! 380: switch( *cp ){ ! 381: ! 382: case '\\': ! 383: cp++; ! 384: /* FALL THROUGH */ ! 385: default: ! 386: PUTCHAR( *cp ); ! 387: continue; /* this is the usual case... */ ! 388: case 'T': ! 389: /* rewrite register type is suppressed */ ! 390: rtyflg = 1; ! 391: continue; ! 392: ! 393: case 'Z': /* special machine dependent operations */ ! 394: # ifdef NEWZZZ ! 395: switch( c = *++cp ) { ! 396: ! 397: case '1': ! 398: case '2': ! 399: case '3': ! 400: case 'R': ! 401: case 'L': /* get down first */ ! 402: zzzcode( getlr( p, c ), *++cp ); ! 403: break; ! 404: default: /* normal zzzcode processing otherwise */ ! 405: zzzcode( p, c ); ! 406: break; ! 407: } ! 408: # else ! 409: zzzcode( p, *++cp, cookie ); ! 410: # endif ! 411: continue; ! 412: ! 413: case 'F': /* this line deleted if FOREFF is active */ ! 414: if ( cookie & FOREFF ) ! 415: while( *++cp != '\n' ) ! 416: ; /* VOID */ ! 417: continue; ! 418: ! 419: #ifdef undef ! 420: case 'R': /* this line deleted if descendent is already in a temp register */ ! 421: { ! 422: NODE * t; ! 423: ! 424: t = getlr(p, *++cp ); ! 425: if ( istnode(t) ) ! 426: while( *++cp != '\n' ) ! 427: ; /* VOID */ ! 428: continue; ! 429: } ! 430: #endif sun ! 431: case 'S': /* field size */ ! 432: print_d(fldsz ); ! 433: continue; ! 434: ! 435: case 'H': /* field shift */ ! 436: print_d( fldshf ); ! 437: continue; ! 438: ! 439: case 'M': /* field mask */ ! 440: case 'N': /* complement of field mask */ ! 441: val = 1; ! 442: val <<= fldsz; ! 443: --val; ! 444: val <<= fldshf; ! 445: adrcon( *cp=='M' ? val : ~val ); ! 446: continue; ! 447: ! 448: case 'L': /* output special label field */ ! 449: print_d( p->bn.label ); ! 450: continue; ! 451: ! 452: case 'O': /* opcode string */ ! 453: hopcode( *++cp, p->in.op ); ! 454: continue; ! 455: ! 456: case 'B': /* byte offset in word */ ! 457: val = getlr(p,*++cp)->tn.lval; ! 458: val = BYTEOFF(val); ! 459: printf( CONFMT, val ); ! 460: continue; ! 461: ! 462: case 'C': /* for constant value only */ ! 463: conput( getlr( p, *++cp ) ); ! 464: continue; ! 465: ! 466: case 'I': /* in instruction */ ! 467: insput( getlr( p, *++cp ) ); ! 468: continue; ! 469: ! 470: case 'A': /* address of */ ! 471: adrput( getlr( p, *++cp ) ); ! 472: continue; ! 473: ! 474: case 'U': /* for upper half of address, only */ ! 475: upput( getlr( p, *++cp ) ); ! 476: continue; ! 477: ! 478: } ! 479: ! 480: } ! 481: ! 482: } ! 483: ! 484: NODE * ! 485: getlr( p, c ) ! 486: NODE *p; ! 487: { ! 488: ! 489: /* ! 490: * return the pointer to the left or right side of p, or p itself, ! 491: * depending on the optype of p ! 492: */ ! 493: ! 494: switch ( c ) { ! 495: ! 496: case '1': ! 497: case '2': ! 498: case '3': ! 499: return ( &resc[c-'1'] ); ! 500: ! 501: case 'L': ! 502: return ( optype( p->in.op ) == LTYPE ? p : p->in.left ); ! 503: ! 504: case 'R': ! 505: return ( optype( p->in.op ) != BITYPE ? p : p->in.right ); ! 506: ! 507: case '.': ! 508: return ( p ); ! 509: ! 510: } ! 511: cerror( "bad getlr: %c", c ); ! 512: /* NOTREACHED */ ! 513: } ! 514: ! 515: # ifdef MULTILEVEL ! 516: ! 517: union mltemplate{ ! 518: struct ml_head{ ! 519: int tag; /* identifies class of tree */ ! 520: int subtag; /* subclass of tree */ ! 521: union mltemplate * nexthead; /* linked by mlinit() */ ! 522: } mlhead; ! 523: struct ml_node{ ! 524: int op; /* either an operator or op description */ ! 525: int nshape; /* shape of node */ ! 526: /* both op and nshape must match the node. ! 527: * where the work is to be done entirely by ! 528: * op, nshape can be SANY, visa versa, op can ! 529: * be OPANY. ! 530: */ ! 531: int ntype; /* type descriptor from mfile2 */ ! 532: } mlnode; ! 533: }; ! 534: ! 535: # define MLSZ 30 ! 536: ! 537: extern union mltemplate mltree[]; ! 538: int mlstack[MLSZ]; ! 539: int *mlsp; /* pointing into mlstack */ ! 540: NODE * ststack[MLSZ]; ! 541: NODE **stp; /* pointing into ststack */ ! 542: ! 543: mlinit(){ ! 544: union mltemplate **lastlink; ! 545: register union mltemplate *n; ! 546: register mlop; ! 547: ! 548: lastlink = &(mltree[0].nexthead); ! 549: n = &mltree[0]; ! 550: for( ; (n++)->mlhead.tag != 0; ! 551: *lastlink = ++n, lastlink = &(n->mlhead.nexthead) ){ ! 552: # ifndef BUG3 ! 553: if ( vdebug )print_str_d_nl("mlinit: ",(n-1)->mlhead.tag); ! 554: # endif ! 555: /* wander thru a tree with a stack finding ! 556: * its structure so the next header can be located. ! 557: */ ! 558: mlsp = mlstack; ! 559: ! 560: for( ;; ++n ){ ! 561: if ( (mlop = n->mlnode.op) < OPSIMP ){ ! 562: switch( optype(mlop) ){ ! 563: ! 564: default: ! 565: cerror("(1)unknown opcode: %o",mlop); ! 566: case BITYPE: ! 567: goto binary; ! 568: case UTYPE: ! 569: break; ! 570: case LTYPE: ! 571: goto leaf; ! 572: } ! 573: } ! 574: else{ ! 575: if ( mamask[mlop-OPSIMP] & ! 576: (SIMPFLG|COMMFLG|MULFLG|DIVFLG|LOGFLG|FLOFLG|SHFFLG) ){ ! 577: binary: ! 578: *mlsp++ = BITYPE; ! 579: } ! 580: else if ( ! (mamask[mlop-OPSIMP] & UTYPE) ){/* includes OPANY */ ! 581: ! 582: leaf: ! 583: if ( mlsp == mlstack ) ! 584: goto tree_end; ! 585: else if ( *--mlsp != BITYPE ) ! 586: cerror("(1)bad multi-level tree descriptor around mltree[%d]", ! 587: n-mltree); ! 588: } ! 589: } ! 590: } ! 591: tree_end: /* n points to final leaf */ ! 592: ; ! 593: } ! 594: # ifndef BUG3 ! 595: if ( vdebug > 3 ){ ! 596: print_str("mltree={\n"); ! 597: for( n= &(mltree[0]); n->mlhead.tag != 0; ++n) ! 598: printf("%o: %d, %d, %o,\n",n, ! 599: n->mlhead.tag,n->mlhead.subtag,n->mlhead.nexthead); ! 600: print_str(" }\n"); ! 601: } ! 602: # endif ! 603: } ! 604: ! 605: mlmatch( subtree, target, subtarget ) NODE * subtree; int target,subtarget;{ ! 606: /* ! 607: * does subtree match a multi-level tree with ! 608: * tag "target"? Return zero on failure, ! 609: * non-zero subtag on success (or MDONE if ! 610: * there is a zero subtag field). ! 611: */ ! 612: union mltemplate *head; /* current template header */ ! 613: register union mltemplate *n; /* node being matched */ ! 614: NODE * st; /* subtree being matched */ ! 615: register int mlop; ! 616: ! 617: # ifndef BUG3 ! 618: if ( vdebug ) printf("mlmatch(%o,%d)\n",subtree,target); ! 619: # endif ! 620: for( head = &(mltree[0]); head->mlhead.tag != 0; ! 621: head=head->mlhead.nexthead){ ! 622: # ifndef BUG3 ! 623: if ( vdebug > 1 )printf("mlmatch head(%o) tag(%d)\n", ! 624: head->mlhead.tag); ! 625: # endif ! 626: if ( head->mlhead.tag != target )continue; ! 627: if ( subtarget && head->mlhead.subtag != subtarget)continue; ! 628: # ifndef BUG3 ! 629: if ( vdebug ) print_str_d_nl("mlmatch for ",target); ! 630: # endif ! 631: ! 632: /* potential for match */ ! 633: ! 634: n = head + 1; ! 635: st = subtree; ! 636: stp = ststack; ! 637: mlsp = mlstack; ! 638: /* compare n->op, ->nshape, ->ntype to ! 639: * the subtree node st ! 640: */ ! 641: for( ;; ++n ){ /* for each node in multi-level template */ ! 642: /* opmatch */ ! 643: if ( n->op < OPSIMP ){ ! 644: if ( st->op != n->op )break; ! 645: } ! 646: else { ! 647: register opmtemp; ! 648: if ((opmtemp=mamask[n->op-OPSIMP])&SPFLG){ ! 649: if (st->op!=NAME && st->op!=ICON && st->op!=OREG && ! 650: ! shltype(st->op,st)) break; ! 651: } ! 652: else if ((dope[st->op]&(opmtemp|ASGFLG))!=opmtemp) break; ! 653: } ! 654: /* check shape and type */ ! 655: ! 656: if ( ! tshape( st, n->mlnode.nshape ) ) break; ! 657: if ( ! ttype( st->type, n->mlnode.ntype ) ) break; ! 658: ! 659: /* that node matched, let's try another */ ! 660: /* must advance both st and n and halt at right time */ ! 661: ! 662: if ( (mlop = n->mlnode.op) < OPSIMP ){ ! 663: switch( optype(mlop) ){ ! 664: ! 665: default: ! 666: cerror("(2)unknown opcode: %o",mlop); ! 667: case BITYPE: ! 668: goto binary; ! 669: case UTYPE: ! 670: st = st->left; ! 671: break; ! 672: case LTYPE: ! 673: goto leaf; ! 674: } ! 675: } ! 676: else{ ! 677: if ( mamask[mlop - OPSIMP] & ! 678: (SIMPFLG|COMMFLG|MULFLG|DIVFLG|LOGFLG|FLOFLG|SHFFLG) ){ ! 679: binary: ! 680: *mlsp++ = BITYPE; ! 681: *stp++ = st; ! 682: st = st->left; ! 683: } ! 684: else if ( ! (mamask[mlop-OPSIMP] & UTYPE) ){/* includes OPANY */ ! 685: ! 686: leaf: ! 687: if ( mlsp == mlstack ) ! 688: goto matched; ! 689: else if ( *--mlsp != BITYPE ) ! 690: cerror("(2)bad multi-level tree descriptor around mltree[%d]", ! 691: n-mltree); ! 692: st = (*--stp)->right; ! 693: } ! 694: else /* UNARY */ st = st->left; ! 695: } ! 696: continue; ! 697: ! 698: matched: ! 699: /* complete multi-level match successful */ ! 700: # ifndef BUG3 ! 701: if ( vdebug ) print_str("mlmatch() success\n"); ! 702: # endif ! 703: if ( head->mlhead.subtag == 0 ) return( MDONE ); ! 704: else { ! 705: # ifndef BUG3 ! 706: if ( vdebug )print_str_d_nl("\treturns ", ! 707: head->mlhead.subtag ); ! 708: # endif ! 709: return( head->mlhead.subtag ); ! 710: } ! 711: } ! 712: } ! 713: return( 0 ); ! 714: } ! 715: # endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.