1File: DIR.C Page 1 1 /* 2 Copyright 1981 3 Alcyon Corporation 4 8716 Production Ave. 5 San Diego, Ca. 92121 6 */ 7 8 /* Pass 1 and pass 2 directive handling routines */ 9 /* code to handle conditional assembly directives */ 10 11 #include "as68.h" 12 #include "cout.h" 13 14 long lseek(); 15 int p1gi(); 16 int p2gi(); 17 int igrst(); 18 19 /*directive to define an opcode*/ 20 hopd() 21 { 22 23 if(!lbt[0]) { 24 xerr(4); /*no label*/ 25 return; 26 } 27 setname(); /*move label into main table*/ 28 if((lblpt=lemt(oirt,TRUE))!=lmte) { 29 xerr(5); /*opcode redefined*/ 30 return; 31 } 32 mmte(); /*make main table entry*/ 33 expr(&p1gi); /*get instruction format*/ 34 if(itype!=ITCN || ival<0 || ival>OPFF) { 35 xerr(18); /*illegal format specifier*/ 36 return; 37 } 38 lblpt->flags =| ival|SYIN; /*remember format*/ 39 if(fchr != ',') { /*field separator*/ 40 xerr(10); 41 return; 42 } 43 expr(&p1gi); /*get opcode value*/ 44 if(itype != ITCN) { 45 xerr(17); /*not a constant*/ 46 return; 47 } 48 lblpt->vl1 = ival; /*put value in main table*/ 49 igrst(); /*ignore rest of statement-comment*/ 50 } 51 52 /* equate directive*/ 53 hequ() 54 { 55 if(lbt[0] == 0) { 56 xerr(4); /*no label*/ 57 return; 58 } 59 setname(); 1File: DIR.C Page 2 60 if((lblpt=lemt(sirt,FALSE))!=lmte) { /*aready there*/ 61 if(lbt[0] == '~') { /*local symbol*/ 62 lblpt = lmte; 63 mmte(); 64 } 65 } 66 else 67 mmte(); 68 if(lblpt->flags&SYXR) { 69 xerr(29); 70 return; 71 } 72 lblpt->flags =| SYDF|SYEQ; /*defined & equate*/ 73 equflg = 1; 74 modelen = 4; 75 expr(&p1gi); 76 equflg = 0; 77 if(itype == ITSY && ival.ptrw2->flags&SYER) { 78 lblpt->flags =| SYER; /*equated register*/ 79 ival = ival.ptrw2->vl1; 80 } 81 else if(itype != ITCN) { 82 xerr(7); /*not a constant*/ 83 return; 84 } 85 if (inoffset && reloc != ABS) { /* [vlh] */ 86 xerr(11); 87 return; 88 } 89 if(initflg) /*doing symbol table initialization*/ 90 lblpt->flags =| SYIN; /*internal symbol*/ 91 lblpt->vl1 = ival; 92 if(reloc == DATA) /*check relocation*/ 93 { 94 lblpt->flags =| SYRA; /*DATA relocatable*/ 95 } 96 else if(reloc == TEXT) 97 lblpt->flags =| SYRO; /*TEXT relocatable*/ 98 else if(reloc == BSS) 99 lblpt->flags =| SYBS; /*BSS relocatable*/ 100 else if(fchr==',' && (fchr=gchr())=='r') 101 lblpt->flags =| SYER; /*equated register*/ 102 if (refpc) /*[vlh] flag directive is pc relative */ 103 lblpt->flags =| SYPC; 104 igrst(); 105 } 106 107 /* process dsect directive*/ 108 hdsect() 109 { 110 dorlst(DATA); 111 } 112 113 dorlst(xrtyp) 114 { 115 inoffset = 0; /* [vlh] offset mode terminated my sect directive */ 116 chkeven(); /* May need to make pc even */ 117 dlabl(); /*define label on old base if there is one*/ 118 savelc[rlflg] = loctr; /*save old base relocation*/ 1File: DIR.C Page 3 119 rlflg = xrtyp; 120 loctr = savelc[xrtyp]; /*set new base relocation ctr*/ 121 opitb(); 122 stbuf[0].itrl = itwc; 123 wostb(); 124 igrst(); 125 } 126 127 /*process psect directive*/ 128 hpsect() 129 { 130 dorlst(TEXT); 131 } 132 133 hbss() 134 { 135 dorlst(BSS); 136 } 137 138 /*make pc even*/ 139 heven() 140 { 141 modelen = 2; /*Try to figure this one out...*/ 142 if(loctr&1) { /*have to make it even*/ 143 dorlst(rlflg); 144 } 145 else { 146 igrst(); 147 } 148 } 149 150 /*process globl directive*/ 151 hent() 152 { 153 while(1) { 154 gterm(TRUE); /*get entry symbol*/ 155 if(itype!=ITSY) { /*error if not symbol*/ 156 xerr(28); 157 return; 158 } 159 if((lblpt=lemt(sirt,FALSE)) == lmte) /*look up in main table*/ 160 mmte(); /*not there, make new entry*/ 161 else 162 if(lblpt->flags&SYER) /*already there*/ 163 uerr(29); 164 lblpt->flags =| SYGL; /*symbol is an entry*/ 165 if(lblpt->flags&SYXR) { /*been thru hext code*/ 166 lblpt->flags =& ~(SYXR|SYDF); /*reset for init of .comm*/ 167 } 168 if (inoffset && reloc != ABS) { /* [vlh] */ 169 xerr(11); 170 return; 171 } 172 if(fchr == ',') /*skip ',' between entries*/ 173 fchr = gchr(); 174 else { 175 igrst(); /*statement finished*/ 176 return; 177 } 1File: DIR.C Page 4 178 } 179 } 180 181 /*process comm directive*/ 182 hext() 183 { 184 gterm(TRUE); /*get external symbol*/ 185 if(itype!=ITSY) { /*error if not symbol*/ 186 xerr(28); 187 return; 188 } 189 if((lblpt=lemt(sirt,FALSE)) == lmte) /*look up in main table*/ 190 mmte(); /*not there, make new entry*/ 191 else 192 if(lblpt->flags&SYDF && (lblpt->flags&SYXR)==0) /*already there*/ 193 uerr(29); 194 lblpt->flags =| SYXR | SYDF; /*symbol is an external*/ 195 mkextidx(lblpt); /*put into external table*/ 196 if(fchr == ',') { /*skip ',' between operands*/ 197 fchr = gchr(); 198 gterm(TRUE); 199 if(itype != ITCN) { 200 xerr(17); 201 return; 202 } 203 lblpt->vl1.wd1 = ival; /* # bytes of storage required*/ 204 } 205 else 206 lblpt->vl1.wd1 = 1; /* default # bytes*/ 207 igrst(); 208 } 209 210 mkextidx(p) 211 struct symtab *p; 212 { 213 214 if(extindx >= EXTSZ) { /*check for overflow of external symbol tbl*/ 215 rpterr("overflow of external table\n"); 216 endit(); 217 } 218 p->vl1.wd2 = pexti - extbl; /* external symbol index #*/ 219 *pexti++ = p; /*save external in external table*/ 220 extindx++; 221 } 222 223 /* end statement*/ 224 hend() 225 { 226 register short i; 227 register int j; 228 229 inoffset = 0; /*[vlh] turn off inoffset mode*/ 230 lblpt = 0; /*no label*/ 231 opitb(); /*output beginning of statement*/ 232 igrst(); /* [vlh] ignore operands */ 233 stbuf[0].itrl = itwc; /*number of it entries*/ 234 wostb(); /*write out statement buffer*/ 235 for(i=0; i1 && loctr&1) { 283 pi = opcpt; 284 opcpt = evenptr; 285 opitb(); 286 stbuf[0].itrl = itwc; 287 wostb(); 288 opcpt = pi; 289 loctr++; 290 } 291 } 292 293 /* define byte directive*/ 294 hdc() 295 { 1File: DIR.C Page 6 296 chkeven(); 297 hdata(modelen); 298 } 299 300 /* 301 * define bytes or words of data 302 * call with: 303 * 1 => defining bytes 304 * 2 => defining words 305 * 4 => defining long words 306 */ 307 hdata(mul) 308 { 309 dlabl(); /*define label*/ 310 opitb(); /*beginning of statement*/ 311 numops = 0; /*initialize count for number of operands*/ 312 opito(); /*output it for operands*/ 313 stbuf[0].itrl = itwc; /* # of it entries*/ 314 wostb(); /*write out statement buffer*/ 315 loctr =+ numops*mul; /* count by bytes or words*/ 316 } 317 318 /* handle org statement*/ 319 horg() 320 { 321 register i; 322 323 if(rlflg==TEXT && loctr!=0) 324 didorg++; /*can't do branch optimization as separate pass now*/ 325 expr(&p1gi); /*value of new relocation counter*/ 326 if(reloc != rlflg && reloc != ABS) { 327 xerr(27); 328 return; 329 } 330 if(ival < loctr) { 331 xerr(40); /*trying to go backwards*/ 332 return; 333 } 334 opcpt = orgptr; /*org directive for pass 2*/ 335 opitb(); 336 opitoo(); 337 stbuf[0].itrl = itwc; 338 wostb(); 339 loctr = ival; 340 dlabl(); /*define label*/ 341 } 342 343 /* Assemble for mask2 (R9M), ignore... */ 344 hmask2() /* [vlh] */ 345 { 346 igrst(); 347 } 348 349 /* Define register list */ 350 hreg() /* [vlh] */ 351 { 352 int mask; 353 if(lbt[0]==0) { 354 xerr(4); /*no label*/ 1File: DIR.C Page 7 355 return; 356 } 357 setname(); /*move label into main table*/ 358 if((lblpt=lemt(sirt,FALSE))!=lmte) { 359 xerr(5); /*opcode redefined*/ 360 return; 361 } 362 if (inoffset) 363 if (reloc != ABS) { 364 xerr(11); 365 return; 366 } 367 mmte(); /*make main table entry*/ 368 if ((mask = mkmask()) == -1) { 369 xerr(6); 370 return; 371 } 372 lblpt->flags =| SYDF|SYEQ|SYRM; /* register mask, defined & equated */ 373 lblpt->vl1 = mask; 374 igrst(); 375 } 376 377 int regmsk[] {0100000,040000,020000,010000,04000,02000,01000,0400,0200, 378 0100,040,020,010,4,2,1}; 379 /* make a register mask for the reg routine */ 380 mkmask() /* [vlh] */ 381 { 382 register int *p, i, j, mask; 383 384 p = ®msk; mask = 0; 385 while ((i = chkreg()) != -1) { 386 if (fchr == '-') { 387 fchr = gchr(); 388 if ((j = chkreg()) == -1) { 389 xerr(40); 390 return(-1); 391 } 392 while (i <= j) 393 mask =| p[i++]; 394 } 395 else mask =| p[i]; 396 if (fchr != '/' && fchr != ',') break; /*[vlh] Signetics fix*/ 397 fchr = gchr(); 398 } 399 return(mask); 400 } 401 402 /* get a register # from file, return -1 if none or illegal */ 403 chkreg() /* [vlh] */ 404 { 405 register int i, j; 406 407 i = j = 0; 408 if (fchr == 'a' || fchr == 'A') 409 i = 8; 410 else if (fchr != 'd' && fchr != 'r' && fchr != 'D' && fchr != 'R') 411 return(-1); 412 fchr = gchr(); 413 do { 1File: DIR.C Page 8 414 j = (j*10) + (fchr - '0'); 415 fchr = gchr(); 416 } while (isdigit(fchr)); 417 if (j < 0 || j > AREGHI) return(-1); 418 i =+ j; 419 if (i >= 0 && i <= AREGHI) return(i); 420 else return(-1); 421 } 422 423 /* Define constant block */ 424 hdcb() /* [vlh] */ 425 { 426 chkeven(); /* on even boundary if not byte block. */ 427 dlabl(); /* define label... */ 428 opitb(); 429 opito(); 430 stbuf[0].itrl = itwc; 431 numops = stbuf[ITOP1].itop; 432 loctr =+ numops * modelen; 433 wostb(); /* write out statement buffer */ 434 } 435 436 /* Command line, similar to ds.b */ 437 hcomline() /* [vlh] */ 438 { 439 dlabl(); /*define label maybe*/ 440 modelen = 1; /* byte store... */ 441 opitb(); /*output it for beginning of statement*/ 442 refpc = 0; 443 expr(&p1gi); 444 if(itype!=ITCN) { 445 xerr(17); /*must be constant*/ 446 return; 447 } 448 if(reloc != ABS) { 449 xerr(9); /*must be absolute*/ 450 return; 451 } 452 opitoo(); /*output one operand*/ 453 stbuf[0].itrl = itwc; 454 wostb(); /*write out statement buffer*/ 455 loctr =+ ival; 456 igrst(); 457 } 458 459 /* Relocateable id record, ignore */ 460 hidnt() /* [vlh] */ 461 { 462 igrst(); 463 } 464 465 /* Define offsets */ 466 hoffset() /* [vlh] */ 467 { 468 inoffset = 1; 469 expr(&p1gi); /* get new location counter */ 470 if (itype != ITCN) { 471 xerr(17); /* constant required */ 472 return; 1File: DIR.C Page 9 473 } 474 if (reloc != ABS) { 475 xerr(9); /* must be absolute */ 476 return; 477 } 478 loctr = ival; 479 igrst(); 480 } 481 482 /* define sections: map to bss, text and data */ 483 hsection() /* [vlh] */ 484 { 485 inoffset = 0; /* reseting section turns off offset mode */ 486 dlabl(); /* define label on old base if there is one */ 487 savelc[rlflg] = loctr; /* save old base relocation */ 488 opitb(); /* intermediate table... */ 489 expr(&p1gi); /* get section # */ 490 if (itype != ITCN) { 491 xerr(17); /* must be a constant */ 492 return; 493 } 494 if (ival > 15 || ival < 0) { 495 xerr(9); /* proper range 0..15 */ 496 return; 497 } 498 if (ival==14) rlflg = DATA; 499 else if (ival==15) rlflg = BSS; 500 else rlflg = TEXT; 501 loctr = savelc[rlflg]; 502 stbuf[3].itop = loctr; /* pass 1 location counter */ 503 stbuf[3].itrl = rlflg; /* relocation base */ 504 stbuf[0].itrl = itwc; 505 wostb(); 506 igrst(); 507 } 508 509 /* hopt -- ignore, set up assembler options */ 510 hopt() /* vlh */ 511 { 512 igrst(); 513 } 514 515 /**** Second pass directive handling routines ****/ 516 517 /* second pass end statement*/ 518 send() 519 { 520 register int i; 521 522 savelc[rlflg] = loctr; 523 if(savelc[TEXT]&1) { 524 rlflg = TEXT; 525 outbyte(0,DABS); 526 savelc[TEXT]++; 527 } 528 if(savelc[DATA]&1) { 529 rlflg = DATA; 530 outbyte(0,DABS); 531 savelc[DATA]++; 1File: DIR.C Page 10 532 } 533 if(savelc[BSS]&1) { 534 savelc[BSS]++; 535 } 536 537 ival = 0; 538 reloc = ABS; 539 ckeop(9); 540 print(0); 541 cpdata(); /*copy data to loader file*/ 542 osymt(); /*output symbol table*/ 543 myfflush(&tbuf); /*flush text relocation bits*/ 544 cprlbits(); /*copy relocation bits*/ 545 myfflush(&lbuf); 546 i = (sizeof couthd.ch_magic) + 3*(sizeof couthd.ch_tsize); 547 if((lseek(lfn,(long)i,0) == -1) || write(lfn,&stlen,4) != 4) 548 rpterr("I/O error on loader output file\n"); 549 endit(); /*end*/ 550 } 551 552 /*second pass define storage - ds*/ 553 sds() 554 { 555 print(0); 556 if(rlflg == TEXT || rlflg==DATA) { 557 expr(&p2gi); 558 if(itype != ITCN) { 559 uerr(13); 560 return; 561 } 562 ival =* modelen; 563 while(ival) { 564 outbyte(0,DABS); 565 loctr++; 566 ival--; 567 } 568 } 569 else 570 loctr =+ stbuf[ITOP1].itop*modelen; /*reserve storage*/ 571 } 572 573 /* second pass - define block storage, initialized */ 574 sdcb() /* [vlh] */ 575 { 576 register int pfg, i, hflg, len; 577 578 expr(&p2gi); 579 if (itype != ITCN || reloc != ABS) { 580 uerr(13); /* must be absolute constant */ 581 return; 582 } 583 len = ival; 584 expr(&p2gi); 585 if (modelen==1 && (ival<-128 || ival>=256 || reloc != ABS)) { 586 uerr(20); 587 ival = 0; 588 reloc = ABS; 589 } 590 while (len--) { 1File: DIR.C Page 11 591 if (modelen==1) { 592 if (!hflg) { 593 ins[i].hibyte = ival; 594 outbyte(ival.wd2,DABS); 595 hflg++; 596 } 597 else { 598 ins[i++].lobyte = ival; 599 outbyte(ival.wd2,DABS); 600 hflg=0; 601 } 602 goto sdbl2; 603 } 604 else if (modelen==2) { 605 sdbl1: 606 ins[i++] = ival.wd2; 607 outword(ival.wd2, reloc); 608 sdbl2: 609 if (i>3) { 610 instrlen = i*2; 611 print ((pfg++) ? 2 : 1); 612 loctr =+ instrlen; 613 i=0; 614 } 615 } 616 else { /* long word... */ 617 ins[i++] = ival.wd1; 618 outword(ival.wd1,LUPPER); 619 goto sdbl1; 620 } 621 } 622 if (i) { /* more printing */ 623 instrlen = i*2 - hflg; 624 print ((pfg) ? 2 : 1); 625 loctr =+ instrlen; 626 } 627 } 628 629 /*second pass data*/ 630 sdsect() 631 { 632 savelc[rlflg] = loctr; 633 rlflg = DATA; 634 loctr = savelc[DATA]; 635 print(0); /*print the new location counter*/ 636 } 637 638 /*second pass text*/ 639 spsect() 640 { 641 savelc[rlflg] = loctr; 642 rlflg = TEXT; 643 loctr = savelc[TEXT]; 644 print(0); /*print the new location counter*/ 645 } 646 647 sbss() 648 { 649 savelc[rlflg] = loctr; 1File: DIR.C Page 12 650 rlflg = BSS; 651 loctr = savelc[BSS]; 652 print(0); /*print the new location counter*/ 653 } 654 655 /* make loctr even*/ 656 seven() 657 { 658 if(loctr&1) { 659 if(rlflg==TEXT || rlflg==DATA) 660 outbyte(0,DABS); 661 loctr++; 662 } 663 print(0); 664 } 665 666 /* second pass org*/ 667 sorg() 668 { 669 long l; 670 671 if(rlflg==TEXT || rlflg==DATA) { /*must put out zeros*/ 672 l = stbuf[ITOP1].itop - loctr; /*# zeroes to output*/ 673 ins[0] = 0; 674 print(1); 675 while(l > 0) { 676 outbyte(0,DABS); 677 loctr++; 678 l--; 679 } 680 } 681 else { /*BSS*/ 682 loctr = stbuf[ITOP1].itop; /*new location counter*/ 683 print(0); 684 } 685 } 686 687 /* 688 *second pass define data (words or bytes) 689 * call with 690 * 2 => defining words 691 * 1 => defining bytes 692 * 4 => defining long words 693 */ 694 sdata(dtyp) 695 { 696 register pfg,i; 697 register hflg; 698 699 hflg = i = pfg = 0; 700 while(1) { 701 expr(&p2gi); /*evaluate expression*/ 702 if(pitw < pnite) 703 pitw--; /*expr passed a token*/ 704 if(itype!=ITCN && reloc != EXTRN) { /*must be constant*/ 705 uerr(13); 706 ival=0; 707 reloc = ABS; 708 } 1File: DIR.C Page 13 709 if(reloc == EXTRN) 710 reloc = (extref<<3)|EXTVAR; /*gen extern reference*/ 711 if(dtyp==1) { /*defining a byte*/ 712 if(ival<-128 || ival>=256 || reloc!=ABS) { /*not a byte*/ 713 uerr(20); 714 ival=0; 715 reloc = ABS; 716 } 717 if(!hflg) { 718 ins[i].hibyte = ival; 719 outbyte(ival.wd2,DABS); 720 hflg++; 721 } 722 else { 723 ins[i++].lobyte = ival; 724 hflg = 0; 725 outbyte(ival.wd2,DABS); 726 } 727 goto sdal2; 728 } 729 else if(dtyp == 2) { /*defining a word*/ 730 sdal1: 731 ins[i++] = ival.wd2; 732 outword(ival.wd2, reloc); 733 sdal2: 734 if(i>3) { 735 instrlen = i*2; 736 print ((pfg++) ? 2 : 1); 737 loctr =+ instrlen; 738 i=0; 739 } 740 } 741 else { /*long words*/ 742 ins[i++] = ival.wd1; 743 outword(ival.wd1,LUPPER); 744 goto sdal1; 745 } 746 if(!ckeop(15)) /*should be end of operand*/ 747 return; 748 pitw++; 749 if(ckein()) { 750 if(hflg) { 751 ins[i++].lobyte = 0; 752 } 753 if(i) { /*more printing*/ 754 instrlen = i*2 - hflg; 755 print ((pfg) ? 2 : 1); 756 loctr =+ instrlen; 757 } 758 return; 759 } 760 } 761 } 762 763 sdc() 764 { 765 sdata(modelen); 766 } 767 1File: DIR.C Page 14 768 ssection() /* [vlh] */ 769 { 770 int sect; 771 772 sect = stbuf[3].itrl; 773 if (sect==DATA) sdsect(); 774 else if (sect==BSS) sbss(); 775 else spsect(); 776 } 777 778 /*define word statement*/ 779 sdw() 780 { 781 sdata(0); /*defining words*/ 782 } 783 /**** Conditional assembly directives ****/ 784 785 hifeq() /* [vlh] */ 786 { 787 if (!acok()) return; 788 if (ival) { 789 if (ca_true) ca_level = ca; 790 ca_true = 0; 791 } 792 ca++; 793 } 794 795 hifne() /* [vlh] */ 796 { 797 if (!acok()) return; 798 if (!ival) { 799 if (ca_true) ca_level = ca; 800 ca_true = 0; 801 } 802 ca++; 803 } 804 805 hiflt() /* [vlh] */ 806 { 807 if (!acok()) return; 808 if (ival >= 0) { 809 if (ca_true) ca_level = ca; 810 ca_true = 0; 811 } 812 ca++; 813 } 814 815 hifle() /* [vlh] */ 816 { 817 if (!acok()) return; 818 if (ival > 0) { 819 if (ca_true) ca_level = ca; 820 ca_true = 0; 821 } 822 ca++; 823 } 824 825 hifgt() /* [vlh] */ 826 { 1File: DIR.C Page 15 827 if (!acok()) return; 828 if (ival <= 0) { 829 if (ca_true) ca_level = ca; 830 ca_true = 0; 831 } 832 ca++; 833 } 834 835 hifge() /* [vlh] */ 836 { 837 if (!acok()) return; 838 if (ival < 0) { 839 if (ca_true) ca_level = ca; 840 ca_true = 0; 841 } 842 ca++; 843 } 844 845 hifc() /* [vlh] */ 846 { 847 if (!cmp_ops()) { 848 if (ca_true) ca_level = ca; 849 ca_true = 0; 850 } 851 ca++; 852 } 853 854 hifnc() /* [vlh] */ 855 { 856 if (cmp_ops()) { 857 if (ca_true) ca_level = ca; 858 ca_true = 0; 859 } 860 ca++; 861 } 862 863 hendc() /* [vlh] */ 864 { 865 if (!ca) { 866 xerr(25); /* unexpected endc */ 867 return; 868 } 869 ca--; 870 if (!ca_true) 871 if (ca_level == ca) ca_true = 1; 872 igrst(); 873 } 874 hpage() 875 { 876 opitb(); /* Output beginning */ 877 wostb(); /* Write out buffer */ 878 igrst(); /* Ignore rest of line */ 879 } 880 spage() 881 { 882 print(0); /* Print the directive */ 883 xline = LPP; /* Force page on next print */ 884 page(); 885 } 1File: DIR.C Page 16 886 acok() 887 { 888 expr(&p1gi); 889 if (itype != ITCN) { 890 xerr(7); /* must be a constant */ 891 return(0); 892 } 893 if (reloc != ABS) { 894 xerr(11); /* must be absolute, no forward references */ 895 return(0); 896 } 897 igrst(); 898 return(1); 899 } 900 901 cmp_ops() 902 { 903 char str1[25], str2[25]; 904 register int len1, len2; 905 906 if (fchr != '\'') { xerr(9); return(0); } 907 len1 = len2 = 0; 908 while (fchr = gchr()) { 909 if (fchr == '\'') break; 910 if (fchr == EOLC) return(0); 911 str1[len1++] = fchr; 912 } 913 if ((fchr=gchr()) != ',') { xerr(9); return; } 914 if ((fchr=gchr()) != '\'') { xerr(10); return;} 915 while (fchr = gchr()) { 916 if (fchr == '\'') break; 917 if (fchr == EOLC) return(0); 918 str2[len2++] = fchr; 919 } 920 igrst(); 921 if (len1 != len2) return(0); 922 str1[len1] = str2[len2] = NULL; 923 if (strcmp(str1,str2) == 0) return(1); 924 return(0); 925 } 926 927 strcmp(s,t) 928 register char *s, *t; 929 { 930 for( ; *s == *t; s++, t++ ) 931 if( *s == '\0' ) 932 return(0); 933 return( *s - *t ); 934 }