1: # include <stdio.h> 2: # include <ingres.h> 3: # include <aux.h> 4: # include <symbol.h> 5: # include <tree.h> 6: # include "../decomp/globs.h" 7: # include <sccs.h> 8: # include <errors.h> 9: 10: char *malloc(); 11: 12: SCCSID(@(#)string.c 8.3 2/8/85) 13: 14: /* 15: ** This file contains the string 16: ** manipulation routines 17: */ 18: 19: 20: 21: 22: 23: 24: 25: /* 26: ** Concat takes the two character strings in 27: ** s1 and s2 and concatenates them together 28: ** into a new location. 29: ** 30: ** trailing blanks are removed from the first symbol. 31: ** The size of the concatenation equals the sum of 32: ** the two original strings. 33: */ 34: 35: concatsym(s1, s2) 36: register SYMBOL *s1, *s2; 37: { 38: register char *p; 39: int size1, size2, i; 40: char *px; 41: extern char *need(); 42: 43: /* size1 = size(s1);*/ /* compute size w/o trailing blanks */ 44: size1 = s1->len & I1MASK; 45: if (size1 == 0 && s1->len != 0) 46: size1++; /* don't allow string to be trunc to zero length */ 47: size2 = s2->len & I1MASK; /* size of second string remains the same */ 48: i = (s1->len & I1MASK) + size2; /* i equals sum of original sizes */ 49: if (i > MAXFIELD) 50: i = MAXFIELD; /* a string can't exceed this size */ 51: if (size2 + size1 > MAXFIELD) 52: size2 = MAXFIELD - size1; /* adjust size2 to not exceed MAXFIELD */ 53: 54: px = p = need(De.ov_ovqpbuf, i); /* request the needed space */ 55: bmove(s1->value.sym_data.cptype, p, size1); /* copy first string */ 56: p = &p[size1]; 57: bmove(s2->value.sym_data.cptype, p, size2); 58: p = &p[size2]; 59: s1->value.sym_data.cptype = px; 60: s1->len = i; 61: /* pad with blanks if necessary */ 62: i -= size1 - size2; 63: while (i--) 64: *p++ = ' '; 65: 66: # ifdef xOTR1 67: if (tTf(82, 0)) 68: { 69: printf("Concat:"); 70: prstack(s1); 71: } 72: # endif 73: } 74: /* 75: ** Size determines the size of a character symbol 76: ** without trailing blanks. 77: */ 78: 79: size(s) 80: register SYMBOL *s; 81: { 82: register char *c; 83: register int i; 84: 85: c = s->value.sym_data.cptype; 86: i = s->len & I1MASK; 87: 88: for (c += i; i; i--) 89: if(*--c != ' ') 90: break; 91: 92: return (i); 93: } 94: /* 95: ** Converts the numeric symbol to 96: ** ascii. Formats to be used are determined 97: ** by Out_arg. 98: */ 99: 100: ascii(s) 101: register SYMBOL *s; 102: { 103: register int i; 104: register char *p; 105: char temp[MAXFIELD]; 106: extern struct out_arg Out_arg; /* used for float conversions */ 107: char *locv(); 108: 109: p = temp; 110: switch(s->type) 111: { 112: 113: case INT: 114: if (s->len == 4) 115: { 116: i = Out_arg.i4width; 117: p = locv(s->value.sym_data.i4type); 118: } 119: else 120: { 121: itoa(s->value.sym_data.i2type, p); 122: if (s->len == 2) 123: i = Out_arg.i2width; 124: else 125: i = Out_arg.i1width; 126: } 127: break; 128: 129: case CHAR: 130: return; 131: 132: case FLOAT: 133: if (s->len == 4) 134: { 135: i = Out_arg.f4width; 136: ftoa(s->value.sym_data.f8type, p, i, Out_arg.f4prec, Out_arg.f4style); 137: } 138: else 139: { 140: i = Out_arg.f8width; 141: ftoa(s->value.sym_data.f8type, p, i, Out_arg.f8prec, Out_arg.f8style); 142: } 143: } 144: s->value.sym_data.cptype = need(De.ov_ovqpbuf, i); 145: pmove(p, s->value.sym_data.cptype, i, ' '); /* blank pad to fixed length i */ 146: s->type = CHAR; 147: s->len = i; 148: } 149: /* 150: ** LEXCOMP performs character comparisons between the two 151: ** strings ss1 and ss2. All blanks and null are ignored in 152: ** both strings. In addition pattern matching is performed 153: ** using the "shell syntax". Pattern matching characters 154: ** are converted to the pattern matching symbols PAT_ANY etc. 155: ** by the scanner. 156: ** 157: ** Pattern matching characters can appear in either or 158: ** both strings. Since they cannot be stored in relations, 159: ** pattern matching chars in both strings can only happen 160: ** if the user types in such an expression. 161: ** 162: ** examples: 163: ** 164: ** "Smith, Homer" = "Smith,Homer" 165: ** 166: ** "abcd" < "abcdd" 167: ** 168: ** "abcd" = "aPAT_ANYd" 169: ** 170: ** returns <0 if s1 < s2 171: ** 0 if s1 = s2 172: ** >0 if s1 > s2 173: */ 174: 175: char *S1,*S2; 176: int L1,L2; 177: 178: lexcomp(s1, l1, s2, l2, x) 179: register char *s1, *s2; 180: register int l1, l2; 181: int x; 182: { 183: char c1, c2; 184: int howmany = Patnum; /* howmany PAT_SPEC char matchings so far */ 185: int retval; 186: int i; 187: char *t1, *t2; 188: 189: # ifdef xOTR1 190: if (tTf(82, 0)) 191: { 192: printf("LEXCOMP: starting...\n"); 193: t1 = s1; 194: t2 = s2; 195: printf("howmany = %d\n", howmany); 196: printf("first string= '"); 197: for (i = 0; i < l1; i++) 198: printf("%c", *t1++); 199: printf("'\n"); 200: printf("length = %d\n", l1); 201: printf("second string= '"); 202: for (i = 0; i < l2; i++) 203: printf("%c", *t2++); 204: printf("'\n"); 205: printf("length = %d\n", l2); 206: } 207: # endif 208: /* save initial information in case a PAT_GLOB is found */ 209: if (x==0) 210: { 211: S1 = s1; 212: S2 = s2; 213: L1 = l1; 214: L2 = l2; 215: } 216: loop: 217: while (l1--) 218: { 219: switch (c1 = *s1++) 220: { 221: 222: /* case ' ': */ 223: case '\0': 224: break; 225: 226: case PAT_GLOB: 227: { 228: return(gmatch(S1,L1,S2,L2)); 229: } 230: 231: case PAT_ANY: 232: return (pmatch(FALSE, s1, l1, s2, l2)); 233: 234: case PAT_SPEC: 235: retval = pmatch(*(s1-1),++s1, --l1, s2, l2); 236: 237: /* 238: ** If there was no match in pmatch, 239: ** reset Patnum to previous value 240: */ 241: 242: # ifdef xOTR1 243: if (tTf(82,0)) 244: printf("lexcomp: return %d\n", retval); 245: 246: # endif 247: if (retval) 248: Patnum = howmany; 249: return (retval); 250: 251: case PAT_LBRAC: 252: return (lmatch(s1, l1, s2, l2)); 253: 254: default: 255: while (l2--) 256: { 257: switch (c2 = *s2++) 258: { 259: 260: /* case ' ': */ 261: case '\0': 262: continue; 263: 264: case PAT_GLOB: 265: { 266: return(gmatch(S2,L2,S1,L1)); 267: } 268: 269: case PAT_ANY: 270: return( pmatch(FALSE,s2,l2,--s1,++l1)); 271: 272: case PAT_SPEC: 273: retval = pmatch(*(s2-1),++s2, --l2, --s1, ++l1); 274: 275: # ifdef xOTR1 276: if (tTf(82,0)) 277: printf("lexcomp: retval = %d\n", retval); 278: # endif 279: 280: if (retval) 281: Patnum = howmany; 282: return (retval); 283: 284: case PAT_LBRAC: 285: return (lmatch(s2, l2, --s1, ++l1)); 286: 287: default: 288: if (c1 == c2) 289: goto loop; 290: if (c1 == PAT_ONE || c2 == PAT_ONE) 291: goto loop; 292: # ifdef xOTR1 293: if (tTf(82,0)) 294: printf("lexcomp: 2.return %d\n",c1 - c2); 295: # endif 296: return (c1 - c2); 297: } 298: } 299: # ifdef xOTR1 300: if (tTf(82,0)) 301: printf("lexcomp: returning 1\n"); 302: # endif 303: return (1); /* s1 > s2 */ 304: } 305: } 306: 307: /* examine remainder of s2 for any characters */ 308: while (l2) { 309: l2--; 310: if ((c1 = *s2++) == PAT_SPEC) 311: { 312: pat_insert("",0,*s2,0); /* insert empty string */ 313: *s2++,l2--; /* get rid of index */ 314: } 315: /* if (((c1 = *s2) != ' ') && (c1 != '\0') */ 316: if ((c1 != ' ') && (c1 != '\0') 317: && (c1 != PAT_ANY) && (c1 != PAT_SPEC)) 318: { 319: # ifdef xOTR1 320: if (tTf(82,0)) 321: printf("lexcomp: returning -1\n"); 322: # endif 323: Patnum = howmany; 324: return (-1); /* s1 < s2 */ 325: } 326: } 327: # ifdef xOTR1 328: if (tTf(82,0)) 329: printf("lexcomp: returning 0\n"); 330: # endif 331: return (0); 332: } 333: 334: 335: /* 336: ** PMATCH 337: ** 338: ** Checks if a pattern containing a pattern matching character 339: ** (either PAT_ANY or PAT_SPEC) is found in a string. 340: ** 341: ** Returns: 342: ** 0 -- if pattern found in string 343: ** -1 -- if no match 344: ** 345: ** Called By: 346: ** lexcomp 347: ** 348: ** Calls: 349: ** pat_insert, lexcomp 350: */ 351: 352: pmatch(patarg,pat, plen, str, slength) 353: char patarg; /* index for pattern matching--FALSE when no indices 354: used */ 355: char *pat; /* the string holding the pattern matching char */ 356: char *str; /* the string to be checked */ 357: int plen, slength; /* the lengths */ 358: { 359: register char d, *s; 360: register int slen,count; 361: char c; 362: 363: # ifdef xOTR1 364: if (tTf(82,0)) 365: { 366: printf("PMATCH: starting\n"); 367: printf("patarg = %c\n",patarg); 368: printf("string with pattern char = %s\n", pat); 369: printf("string len = %d \n", plen); 370: printf("string to check = %s\n", str); 371: printf("string len = %d\n", slength); 372: } 373: # endif 374: s = str; 375: slen = slength; 376: 377: if (plen == 0) 378: { 379: if ( patarg ) 380: { 381: pat_insert(str,slength,patarg,1); 382: } 383: return (0); /* a match if no more chars in p */ 384: } 385: 386: /* 387: ** If the next character in "pat" is not another 388: ** pattern matching character, then scan until 389: ** first matching char and continue comparison. 390: */ 391: if ((c = *pat) != PAT_ANY && c != PAT_SPEC 392: && c != PAT_LBRAC && c != PAT_ONE) 393: { 394: count = 0; 395: while (slen--) 396: { 397: if ((d = *s) == c || d == PAT_ANY || d == PAT_SPEC 398: || d == PAT_LBRAC && d != PAT_ONE) 399: { 400: if ( patarg ) 401: { 402: pat_insert(str,count,patarg,0); 403: } 404: if (lexcomp(s, slen + 1,pat, plen, 1) == 0) 405: { 406: return (0); 407: } 408: } 409: s++; 410: count++; 411: } 412: } 413: else 414: { 415: while (slen) 416: { 417: if (lexcomp(s++, slen--,pat, plen, 1) == 0) 418: return (0); /* match */ 419: } 420: } 421: return (-1); /* no match */ 422: } 423: 424: 425: lmatch(pat, plen, str, slen) 426: char *pat; /* the string holding the pattern matching char */ 427: char *str; /* the other string */ 428: int plen, slen; /* their respective sizes */ 429: { 430: register char *p, *s; 431: register int cc; 432: int oldc, c, found; 433: 434: # ifdef xOTR1 435: if (tTf(82,0)) 436: { 437: printf("LMATCH: starting...\n"); 438: printf("Pat = %s, length = %d\n", pat, plen); 439: printf("Str = %s, length = %d\n", str, slen); 440: } 441: # endif 442: p = pat; 443: s = str; 444: 445: /* find a non-blank, non-null char in s */ 446: while (slen--) 447: { 448: if ((c = *s++) != ' ' && c != '\0') 449: { 450: /* search for a match on 'c' */ 451: found = 0; /* assume failure */ 452: oldc = 0777; /* make previous char large */ 453: 454: while (plen--) 455: { 456: 457: switch(cc = *p++) 458: { 459: 460: case PAT_RBRAC: 461: if (found) 462: { 463: return (lexcomp(s, slen,p, plen, 1)); 464: } 465: return (-1); 466: 467: case '-': 468: if (plen-- == 0) 469: return (-1); /* not found */ 470: if (oldc <= c && c <= (cc = *p++)) 471: found++; 472: break; 473: 474: default: 475: if (c == (oldc = cc)) 476: found++; 477: } 478: } 479: return (-1); /* no match */ 480: } 481: } 482: return (1); 483: } 484: 485: 486: 487: /* 488: ** GMATCH: checks for string matches while grabbing all instances 489: ** of the string delimited by PAT_GLOB. 490: ** 491: */ 492: 493: gmatch(s1,l1,s2,l2) 494: register char *s1,*s2; 495: register int l1,l2; 496: { 497: char *start,*end,*pat,*c,*temps2; 498: int slen=0,elen=0,plen=0; 499: int index,stindex,endex; 500: int retval,templ2,smlen,first; 501: GLIST *g; 502: 503: # ifdef xOTR1 504: if (tTf(82,0)) 505: { 506: printf("GMATCH: s1 = %s\n", s1); 507: printf("GMATCH: l1 = %d\n", l1); 508: printf("GMATCH: s2= %s\n", s2); 509: printf("GMATCH: l2 = %d\n", l2); 510: } 511: # endif 512: c = s2; 513: for (c += l2; l2; l2--) 514: if(*--c != ' ') 515: break; 516: c = s1; 517: for (c += l1; l1; l1--) 518: if(*--c != ' ') 519: break; 520: 521: if (*s1 == PAT_SPEC) 522: { 523: s1 += 2; 524: l1 -= 2; 525: } 526: else if (*s1 == PAT_ANY) 527: { 528: s1++; 529: l1--; 530: } 531: c = (start = malloc(l1)); 532: while (l1-- && PAT_GLOB != *s1++) { 533: *c++ = *(s1-1); 534: slen++; 535: } 536: c = (pat = malloc(l1)); 537: while ( l1-- && *s1++ != PAT_GLOB) { 538: *c++ = *(s1-1); 539: plen++; 540: } 541: end = s1; 542: elen = l1; 543: 544: if (slen != elen && (!slen || !elen)) 545: { 546: return(-1); 547: } 548: 549: Globs = NULL; 550: if (!slen) 551: { 552: index = scanstr(s2,l2,pat,plen,1,1); 553: if (index == -1) 554: { 555: return(-1); 556: } 557: add_glob(s2,index); 558: for (;;) { /* this loop ends when index is -1 */ 559: s2 += index + plen; 560: l2 -= index + plen; 561: index = scanstr(s2, l2,pat,plen,1,1); 562: if (index == -1) 563: { /* since string is finite, guaranteed to happen */ 564: add_glob(s2,l2); 565: Globfoot->next = NULL; 566: return(0); 567: } 568: add_glob(s2,index); 569: } 570: } 571: else { 572: retval = 1; 573: first = 0; 574: temps2 = s2; 575: templ2 = 0; 576: for(;;) { 577: if (first) { 578: s2 += smlen + elen; 579: l2 -= smlen + elen; 580: templ2 += smlen + elen; 581: } 582: else 583: first = 1; 584: if ((stindex=scanstr(s2,l2,start,slen,1,1)) == -1 || 585: (endex = scanstr(s2+stindex+slen,l2-stindex-slen,end,elen,1,1)) == -1) 586: { 587: if (!retval) 588: { 589: templ2 += l2; 590: add_glob(temps2,templ2); 591: } 592: return(retval); 593: } 594: s2 += stindex + slen; 595: l2 -= stindex + slen; 596: templ2 += stindex + slen; 597: smlen = endex; 598: for (;(index = scanstr(s2,smlen,pat,plen,1,1)) != -1;) 599: { 600: retval = 0; 601: templ2 += index; 602: add_glob(temps2,templ2); 603: temps2 += templ2 + plen; 604: templ2 = 0; 605: s2 += index + plen; 606: l2 -= index + plen; 607: smlen -= index + plen; 608: } 609: } 610: } 611: 612: } 613: 614: 615: add_glob(str,slen) 616: char *str; 617: int slen; 618: { 619: # ifdef xOTR1 620: if (tTf(82,0)) 621: printf("ADD_GLOB: str = %s, slen = %d\n", str, slen); 622: # endif 623: if (Globs == NULL) { 624: Globs = (Globfoot = (GLIST *) malloc(sizeof(GLIST))); 625: Globs->string = malloc(slen); 626: bmove(str,Globs->string,slen); 627: Globlen = Globs->len = slen; 628: Globnum = 1; 629: } 630: else { 631: Globfoot->next = (GLIST *) malloc(sizeof(GLIST)); 632: Globfoot = Globfoot->next; 633: Globfoot->string = malloc(slen); 634: bmove(str,Globfoot->string,slen); 635: Globlen += (Globfoot->len = slen); 636: Globnum++; 637: } 638: 639: } 640: 641: /* 642: ** PAT_INSERT 643: ** 644: ** Moves str and its corresponding length into Pats[index] 645: ** where index refers to the PAT_SPEC index. 646: ** 647: ** May be called even though the Pats[index] string is not the one 648: ** which will eventually be used for the replace. For instance, 649: ** if the pattern matching coincides but the line number doesn't. 650: ** 651: ** Side Effects: 652: ** Patnum is incremented indicating an insertion was done. 653: ** Pats[index] record gets a new string and length. 654: ** 655: ** Returns: none 656: ** 657: ** Calls: bmove 658: ** 659: ** Called By: 660: ** pmatch, lexcomp 661: */ 662: 663: pat_insert(str,slen,where,no_blanks) 664: char *str; /* the string being moved to Pats[where] */ 665: int slen; /* length of str */ 666: char where; /* index into Pats */ 667: int no_blanks; 668: { 669: int index; /* integer value of Pats' index */ 670: int i; 671: 672: index = where - '0'; 673: if (no_blanks) /* get rid of blanks */ 674: while (*(str + slen - 1) == ' ') 675: slen--; 676: 677: if (Pats[index].string) /* for overwriting string */ 678: { 679: free(Pats[index].string); 680: Pats[index].string = NULL; /* Not really necessary, but helps with debugging */ 681: } 682: Patnum++; 683: 684: Pats[index].string = malloc(slen); 685: bmove(str,Pats[index].string,slen); /* move str to Pats[].string */ 686: Pats[index].len = slen; 687: # ifdef xOTR1 688: if (tTf(82,0)) 689: { 690: for (i = 0; i < PATNUM; i++) 691: printf("Pats[%d] = %s, len = %d\n", i,Pats[i].string, Pats[i].len); 692: } 693: # endif 694: 695: } 696: 697: 698: /* 699: ** 700: ** INSERT_CHARS replaces all [PAT_SPEC, index] pairs with strings from 701: ** the Pats[] array. The PAT_SPEC index corresponds to the index into 702: ** the Pats[] array. 703: ** 704: ** Calls: bmove 705: ** 706: ** Called by: interpret 707: ** 708: ** Returns: none 709: */ 710: 711: insert_chars(op) 712: SYMBOL *op; 713: { 714: char *st, *s, /* pointers to SYMBOL string */ 715: *new; /* pointer to new string being formed */ 716: int l, /* length of SYMBOL string */ 717: size = 0; /* size of new string being formed */ 718: int tot, /* total size of new string being formed */ 719: index, /* PAT_SPEC index */ 720: flag=0; 721: 722: # ifdef xOTR1 723: if (tTf(82,0)) 724: printf("INSERT_CHARS: starting...\n"); 725: # endif 726: l = op->len & I1MASK; 727: st = s = op->value.sym_data.cptype; 728: while (*(s+l-1) == ' ') 729: l--; /* don't worry about blanks */ 730: tot = l; 731: while (l--) { 732: if (*st == PAT_GLOB) 733: { 734: insert_glob(&s,++st,&tot,l); 735: break; 736: } 737: if (*st++ == PAT_SPEC) { 738: index = *st++ - '0'; 739: l--; 740: 741: /* subtract 2 for PAT_SPEC and corresponding index */ 742: tot += Pats[index].len - 2; 743: 744: new = malloc(tot); 745: if (size) 746: bmove(s,new,size); 747: 748: /* append the Pats[] string to the currently forming string */ 749: bmove(Pats[index].string,new+size,Pats[index].len); 750: 751: if (!flag) 752: flag = 1; 753: else 754: free(s); 755: s = new; 756: size += Pats[index].len; 757: if (l) { 758: bmove(st,new+size,l); 759: st = new + size; 760: } 761: } 762: else 763: size++; 764: } /* while */ 765: 766: /* 767: ** replace SYMBOL string with 768: ** new string and length 769: */ 770: op->value.sym_data.cptype = s; 771: op->len = tot; 772: } 773: 774: 775: insert_glob(start,rest,slen,rlen) 776: char **start,*rest; 777: int *slen,rlen; 778: { 779: char *pat = rest,*new; 780: int plen = 0,newlen,i; 781: GLIST *g; 782: 783: while (rlen-- && *rest++ != PAT_GLOB) 784: plen++; 785: /* put in error checking about 2nd PAT_GLOB */ 786: *slen -= plen + 2 + rlen; 787: newlen = *slen + rlen + Globlen + (Globnum-1)*plen; 788: new = malloc(newlen); 789: bmove(*start,new,*slen); 790: *start = new; 791: new += *slen; 792: for (i = Globnum,g=Globs;i>1;i--,g=g->next) { 793: bmove(g->string,new,g->len); 794: new += g->len; 795: bmove(pat,new,plen); 796: new += plen; 797: } 798: bmove(g->string,new,g->len); 799: new += g->len; 800: bmove(rest,new,rlen); 801: *slen = newlen; 802: } 803: 804: 805: 806: int flink[MAXFIELD]; /* array for storing failure points in string */ 807: 808: newstring(op1,op2) 809: register SYMBOL *op1,*op2; 810: { 811: int stsize,psize,index,index2; 812: 813: psize = op2->len & I1MASK; /* ignore trailing blanks */ 814: stsize = op1->len & I1MASK; 815: if (op2->start != -1) 816: { 817: index = op2->start; 818: } 819: else 820: index = scanstr(op1->value.sym_data.cptype,stsize, 821: op2->value.sym_data.cptype,psize, 822: CLOSED,(char) 1); /* get start of string */ 823: if (index != -1) { 824: index2 = index + psize; 825: bmove(op1->value.sym_data.cptype + index2, 826: op1->value.sym_data.cptype + index, stsize - index2); 827: for (index += stsize - index2; index < stsize; index++) 828: *(op1->value.sym_data.cptype + index) = ' '; 829: } 830: } 831: 832: 833: 834: createlink(pat,plen) 835: char *pat; 836: int plen; 837: { 838: int i,j; 839: 840: flink[0] = -1; 841: i = 1; 842: while (i < plen) 843: { 844: j = flink[i-1]; 845: while (j != -1 && pat[j] != pat[i-1]) 846: j = flink[j]; 847: flink[i] = j + 1; 848: i += 1; 849: } 850: } 851: 852: 853: backlink(pat,plen) 854: char *pat; 855: int plen; 856: { 857: int i,j; 858: 859: flink[plen - 1] = plen; 860: i = plen - 2; 861: while (i >= 0) 862: { 863: j = flink[i+1]; 864: while (j != plen && pat[j] != pat[i+1]) 865: j = flink[j]; 866: flink[i] = j - 1; 867: i -= 1; 868: } 869: } 870: 871: 872: 873: /* 874: ** SCANSTR: Scan a string for a pattern. 875: ** 876: ** Returns: 877: ** -1 -- couldn't find pattern in string 878: ** index in string to start of pattern -- if getstart is true 879: ** index in string following pattern -- if getstart is false 880: */ 881: 882: scanstr(str,slen,pat,plen,getstart,num) 883: char *str, /* string being scanned */ 884: *pat; /* pattern being searched for */ 885: int slen, /* str length */ 886: plen; /* pat length */ 887: int getstart; /* if true, include pat in the string to be returned */ 888: char num; /* number of occurance to look for */ 889: { 890: int i, /* index into str */ 891: j, /* index into pat */ 892: k, 893: found; /* true when pattern found in string */ 894: 895: # ifdef xOTR1 896: if (tTf(82,0)) 897: { 898: printf("SCANSTR: \n"); 899: printf("str = %s, len = %d\n", str, slen); 900: printf("pat = %s, len = %d\n", pat, plen); 901: } 902: # endif 903: 904: createlink(pat,plen); 905: i = -1; 906: 907: /* for each occurance of pattern in string */ 908: for (k = 0; k < num & I1MASK; k++) { 909: i += 1; 910: j = 0; 911: found = 0; 912: while (i < slen) { 913: 914: /* keep searching str until a potential match for pat is found */ 915: while ( j != -1 && pat[j] != str[i]) 916: j = flink[j]; 917: 918: if (j == plen-1) /* found pat in str */ 919: { 920: found = 1; 921: break; 922: } 923: else { /* else check that rest of pat matches */ 924: i += 1; 925: j += 1; 926: } 927: } 928: if (!found || i == slen) return(-1); /* didn't find pat in str */ 929: } 930: 931: /** at this point, found pattern in string **/ 932: if (getstart) 933: { 934: return(i-plen+1); 935: } 936: else 937: { 938: return(i+1); 939: } 940: } /* scanstr */ 941: 942: /* 943: ** BACKSCAN 944: ** 945: ** Searches backwards through string for pattern. 946: ** 947: ** Returns: 948: ** -1 -- if pattern not found 949: ** index in string where pattern starts -- if getstart is true 950: ** index in string right after pattern ends -- if getstart is false 951: */ 952: 953: backscan(str,slen,pat,plen,getstart,num) 954: char *str, /* string being scanned */ 955: *pat; /* pattern being searched for */ 956: int slen, /* length of string */ 957: plen; /* length of pattern */ 958: int getstart; /* if true, return pointer which includes pat */ 959: /* if false, return pointer following pat */ 960: char num; /* which occurance of pat in string */ 961: { 962: int i, /* index into string */ 963: j, /* index into pat and flink */ 964: k, /* number of occurance found */ 965: found; /* true if pattern found in string */ 966: 967: # ifdef xOTR1 968: if (tTf(82,0)) 969: { 970: printf("BACKSCAN: \n"); 971: printf("str = %s, len = %d\n", str, slen); 972: printf("pat = %s, len = %d\n", pat, plen); 973: } 974: # endif 975: backlink(pat,plen); /* set up flink for backwards scanning */ 976: i = slen ; 977: 978: /* for each occurance of pat in string */ 979: for (k = 0; k < num & I1MASK; k++) { 980: i -= 1; 981: j = plen - 1; 982: found = 0; 983: 984: /* search for pat from end of string until whole string is examined */ 985: while (i >= 0) { 986: while ( j != plen && pat[j] != str[i]) 987: j = flink[j]; 988: if (j == 0) { 989: found = 1; 990: break; 991: } 992: else { 993: i -= 1; 994: j -= 1; 995: } 996: } 997: if (!found || i < 0) return(-1); 998: } 999: /* return pointers to pattern in string */ 1000: if (getstart) 1001: { 1002: return(i); 1003: } 1004: else 1005: { 1006: return(i+plen); 1007: } 1008: } /* backscan */ 1009: 1010: getend(len,dropend,howmany) 1011: int len,dropend,howmany; 1012: { 1013: int i; 1014: 1015: for (i=0;i<howmany & I1MASK;i++) 1016: len--; 1017: if (dropend) 1018: len--; 1019: return(len); 1020: } 1021: 1022: 1023: 1024: /* 1025: ** GRABSTRING grabs a string described by a pattern matching 1026: ** interval in a query. 1027: ** 1028: ** Called by: getsymbol 1029: ** 1030: ** Calls: scanstr, backscan, getend, specdelim 1031: ** 1032: ** Returns: 1033: ** NULL -- if pattern was not found in string 1034: ** ptr to pattern which matches interval -- otherwise 1035: */ 1036: 1037: char * 1038: grabstring(strinfo,str,len,startptr) 1039: STRKEEPER *strinfo; /* info about delimitors */ 1040: char *str; /* string to search */ 1041: int *len; /* length of string */ 1042: int *startptr; 1043: { 1044: int start=0,end=0; /* start and end of substring */ 1045: int done = 0; 1046: char *s; 1047: char leftint, rightint; /* type of interval */ 1048: char leftnum, rightnum; /* number of occurrence to find */ 1049: char leftspec, rightspec; /* special chars 1= special delim */ 1050: /* 2 = search backwards */ 1051: char *leftpat, *rightpat; /* left and right patterns */ 1052: int stsearch; /* where to start searching 2nd time */ 1053: int leftlen, rightlen; /* lengths of patterns returned from specdelim*/ 1054: 1055: /* initialization */ 1056: leftint = strinfo->type[0]; 1057: rightint = strinfo->type[1]; 1058: leftnum = strinfo->number[0]; 1059: rightnum = strinfo->number[1]; 1060: leftspec = strinfo->flag[0]; 1061: rightspec = strinfo->flag[1]; 1062: leftpat = strinfo->string[0]; 1063: rightpat = strinfo->string[1]; 1064: 1065: *len &= I1MASK; /* only look at lower byte */ 1066: 1067: while (*(str+*len-1) == ' ') /* find last nonblank char of string */ 1068: *len -= 1; 1069: 1070: # ifdef xOTR1 1071: if (tTf(82,0)) 1072: { 1073: printf("GRABSTRING:\n"); 1074: printf("str = %s, len = %d\n", str, *len); 1075: printf("leftint = %d, leftnum = %d, leftspec = %d\n", leftint, leftnum, leftspec); 1076: printf("left pattern = %s, len = %d\n", leftpat, strlen(leftpat)); 1077: printf("rightint = %d, rightnum = %d, rightspec = %d\n", rightint, rightnum, rightspec); 1078: printf("right pattern = %s, len = %d\n", rightpat, strlen(rightpat)); 1079: } 1080: # endif 1081: 1082: 1083: 1084: /* search for left endpoint */ 1085: 1086: /* CASE 1: special chars */ 1087: if (leftspec & 1) 1088: { 1089: start = specdelim(str,*len,leftpat,leftint,leftnum,&leftlen); 1090: if (leftint == CLOSED) 1091: stsearch = start + leftlen; 1092: else 1093: { 1094: start += leftlen; 1095: stsearch = start; 1096: } 1097: } 1098: /* CASE 2: backwards searching */ 1099: else if (leftspec & 2) 1100: { 1101: if (leftpat == NULL) 1102: start = 1 + getend(*len,leftint,leftnum); 1103: else 1104: start = backscan(str , *len, leftpat, 1105: strlen(leftpat),leftint,leftnum); 1106: 1107: } 1108: /* CASE 3: forwards searching */ 1109: else 1110: { 1111: start = scanstr(str + start, *len, leftpat, 1112: strlen(leftpat),leftint,leftnum); 1113: if (leftint == CLOSED) 1114: stsearch = start + strlen(leftpat); 1115: else 1116: stsearch = start; 1117: } 1118: 1119: 1120: 1121: if (start == -1) /* if pattern was not found in str */ 1122: { 1123: return(NULL); 1124: } 1125: 1126: /* search for right endpoint */ 1127: 1128: /* CASE 1: special chars */ 1129: if (rightspec & 1) 1130: { 1131: if ((end = specdelim(str + stsearch,*len - stsearch,rightpat,1 - rightint,rightnum, &rightlen)) == -1) 1132: return(NULL); 1133: else 1134: { 1135: if (rightint == CLOSED) 1136: end = end + stsearch + rightlen; 1137: else 1138: end += stsearch; 1139: } 1140: } 1141: /* Backwards searching */ 1142: else if (rightspec & 2) 1143: { 1144: if (rightpat == NULL) 1145: end = 1 + getend(*len,1-rightint,rightnum); 1146: else 1147: end = backscan(str, *len, rightpat, 1148: strlen(rightpat),1 - rightint, 1149: rightnum); 1150: } 1151: /* Forwards searching */ 1152: else 1153: { 1154: 1155: if ((end = scanstr(str + stsearch, *len,rightpat, 1156: strlen(rightpat),1 - rightint, 1157: rightnum)) == -1) 1158: return(NULL); 1159: else 1160: { 1161: end += stsearch; 1162: } 1163: 1164: } 1165: 1166: 1167: if (end == -1 || end - start <= 0) /* if end of interval couldn't 1168: ** be found or end did not come 1169: ** after start */ 1170: { 1171: return(NULL); 1172: } 1173: else 1174: { 1175: *len = end - start; 1176: s = malloc(*len); 1177: bmove (str + start, s, *len); 1178: *startptr = start; 1179: } 1180: 1181: 1182: return(s); 1183: } /* grabstring */ 1184: 1185: /* 1186: ** SPECDELIM -- scan a string for a pattern specified by a special 1187: ** delimiter 1188: ** 1189: ** Parameters: 1190: ** str - string to be scanned 1191: ** slen - length of string 1192: ** dname - name of delimitor 1193: ** getstart - type of interval 1194: ** num - occurrence of pattern to look for 1195: ** 1196: ** Returns: 1197: ** index into string of pattern 1198: ** -1 if pattern not found 1199: ** -2 if delimitor was never defined 1200: ** 1201: ** Called by: 1202: ** grabstring 1203: ** 1204: */ 1205: specdelim(str, slen, dname, getstart, num, plen) 1206: char *str; 1207: int slen; 1208: char *dname; 1209: int getstart; 1210: char num; 1211: int *plen; 1212: { 1213: extern DELIMLIST *Delimhead; /* ptr to queue of delims */ 1214: DELIMLIST *d; 1215: DMAP *map; /* ptr to bitmap */ 1216: char patch; 1217: int start = -1; /* index to start of pattern */ 1218: int match; /* true while a pattern is matching */ 1219: char *savestr; 1220: int savelen; 1221: int k; 1222: int i; 1223: 1224: 1225: # ifdef xOTR1 1226: if (tTf(82,0)) 1227: { 1228: printf("SPECDELIM: starting...\n"); 1229: printf("str = %s\n",str); 1230: printf("slen = %d\n",slen); 1231: printf("delim = %s\n",dname); 1232: } 1233: # endif 1234: 1235: savestr = str; 1236: savelen = slen; 1237: *plen = 0; 1238: /* find correct delimiter in the queue */ 1239: for (d = Delimhead; d != NULL && strcmp(d->delim,dname);d = d->back) 1240: continue; 1241: 1242: if (d == NULL) 1243: { 1244: ov_err(BADDELIM); 1245: } 1246: 1247: for(k = 0;k < (num & I1MASK); k++) 1248: { 1249: if(k) 1250: { 1251: start = start - 1 + *plen; 1252: /* savestr = &savestr[start]; */ 1253: 1254: for ( i = 0; i < *plen - 1; i++) 1255: { 1256: *savestr++; 1257: savelen--; 1258: } 1259: 1260: } 1261: while (savelen > 0) 1262: { 1263: map = d->maptr; 1264: start++; 1265: *plen = 0; 1266: str = savestr; 1267: slen = savelen; 1268: *savestr++; 1269: savelen--; 1270: patch = *str++; 1271: match = TRUE; 1272: 1273: while ((map != NULL) && (slen >= 0) && (match)) 1274: { 1275: switch (map->type) 1276: { 1277: case ONE: 1278: if (test(map->bits, patch)) 1279: { 1280: map = map->next; 1281: patch = *str++; 1282: slen--; 1283: (*plen)++; 1284: } 1285: else 1286: match = FALSE; 1287: break; 1288: 1289: case ZEROMORE: 1290: while((slen >= 0) && (test(map->bits,patch))) 1291: { 1292: patch = *str++; 1293: slen--; 1294: (*plen)++; 1295: } 1296: map = map->next; 1297: break; 1298: } 1299: } 1300: 1301: if ((map == NULL)) 1302: { 1303: /* pattern was found */ 1304: break; 1305: } 1306: } 1307: if ((slen <= 1) && (map != NULL)) 1308: return(-1); 1309: } 1310: return(start); 1311: }
|
Last modified: 1986-04-17
Generated: 2016-12-26 |
Generated by src2html V0.67
page hit count: 2656 |
|