![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to string.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ingres / source / ovqp|
Return to string.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ingres / source / ovqp |
1.1 root 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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.