![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to com.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / qed|
Return to com.c CVS log | Up to [Research Unix] / researchv8dc / cmd / qed |
1.1 root 1: /*% cc -c -O %
2: */
3: #include "vars.h"
4: #define OUT 10
5: #define BACKWARD 11
6: #define FORWARD 12
7: char jumpcs[] = "0123456789o`'";
8: jump() /* this should be pronounced with a Swedish accent */
9: {
10: register int i;
11: register cond;
12: register c;
13:
14: if(stackp->type==TTY)
15: error('y');
16: c = getchar();
17: cond = TRUE;
18: if(c=='t' || c=='f'){
19: cond = ((c=='t') == truth());
20: c = getchar();
21: }
22: i = posn(c, jumpcs);
23: if(i==-1){ /* to handle y[tf] without labels for globals */
24: ungetchar(c);
25: if(cond){
26: while((c = getc())!='\n')
27: if(c==EOF)
28: return;
29: }
30: }
31: else if(i<=9){
32: stacktype(BUF);
33: ungetchar(c);
34: i = getnum();
35: stacktype(BUF); /* we may have popped stack! */
36: if(cond){
37: /* getchar will handle problems if off end of buffer */
38: bbempty = TRUE;
39: stackp->lineno = i;
40: stackp->charno = 0;
41: }
42: }
43: else if(i==OUT){
44: if(cond){
45: if(stackp==stack)
46: error('y');
47: if(stackp->type==GLOB){
48: --nestlevel;
49: stackp->globp = "";
50: }else
51: popinp();
52: }
53: }
54: else if(i==FORWARD || i==BACKWARD){
55: stacktype(BUF);
56: getlabel(); /* must eat label even if not yumping */
57: stacktype(BUF);
58: if(cond)
59: search(i==FORWARD);
60: }
61: }
62: stacktype(t)
63: {
64: if(stackp->type != t)
65: error('y');
66: }
67: getlabel(){
68: register char *p, c;
69: p = genbuf;
70: for(c=getchar(); posn(c," \"\t\n")<0; c=getchar()){
71: *p++ = c;
72: *p = '\0';
73: }
74: if(p==genbuf)
75: error('y');
76: }
77: int *looper(a1,a2,str,dir)
78: register int *a1, *a2;
79: register char *str;
80: {
81: register char *p1;
82: register char *p2;
83: while(dir ? a1<=a2 : a1>=a2){
84: p2 = getline(*a1, linebuf);
85: while(*p2==' ' || *p2=='\t')
86: p2++;
87: if(*p2++=='"' && *p2!=' ' && *p2!='\t' && *p2!='\0') {
88: for(p1=str; *p2 && (*p1 == *p2); p2++)
89: p1++;
90: if(*p1==0 && (*p2==0 || *p2==' ' || *p2=='\t'))
91: return(a1);
92: }
93: if(dir)
94: a1++;
95: else
96: --a1;
97: }
98: return((int *)0);
99: }
100: search(forward)
101: {
102: register int *a1;
103: struct buffer *bufp;
104: bufp = stackp->bufptr;
105: if(forward){
106: if((a1 = looper(bufp->zero + (stackp->lineno + 1),
107: bufp->dol,genbuf,1))==0){
108: a1 = looper(bufp->zero + 1,bufp->zero + (stackp->lineno - 1),genbuf,1);
109: }
110: }else{
111: if((a1 = looper(bufp->zero + (stackp->lineno - 1),
112: bufp->zero + 1,genbuf,0))==0){
113: a1 = looper(bufp->dol,bufp->zero + stackp->lineno + 1,genbuf,0);
114: }
115: }
116: if(a1){
117: stackp->lineno = a1 - bufp->zero;
118: stackp->charno = 0;
119: }
120: }
121: int pchar;
122: setapp()
123: {
124: register c;
125: c=getchar();
126: if(posn(c, lchars)>=0) {
127: pchar = c;
128: c = getchar();
129: }
130: if(c==' ' || c=='\t'){
131: oneline++;
132: if(c=='\t')
133: ungetchar(c);
134: }
135: else if(c!='\n')
136: error('x');
137: }
138: #define LDCHUNK 512
139: append(f, a)
140: int (*f)();
141: int *a;
142: {
143: register *a1, *a2, *rdot;
144: int nline, tl;
145: struct integer { int iint; };
146: appflag++;
147: nline = 0;
148: dot = a;
149: while ((*f)()==0) {
150: if (lastdol>=endcore) {
151: if (sbrk(LDCHUNK*(sizeof *endcore))==(char *)-1)
152: error('c');
153: endcore += LDCHUNK;
154: }
155: tl = putline();
156: nline++;
157: lock++;
158: ++dol;
159: a1 = ++lastdol;
160: fixbufs(1);
161: a2 = a1+1;
162: rdot = ++dot;
163: while (a1 > rdot)
164: *--a2 = *--a1;
165: *rdot = tl;
166: unlock();
167: if(oneline)
168: break;
169: }
170: appflag=0;
171: oneline=0;
172: if(pchar) {
173: a1 = addr1; addr1 = dot;
174: a2 = addr2; addr2 = dot;
175: display(pchar);
176: pchar = 0;
177: addr1 = a1; addr2 = a2;
178: }
179: return(nline);
180: }
181: char bformat = 'p';
182: bcom()
183: {
184: register dir, n;
185: register psize;
186: register *olddot=addr2; /* for b. */
187: dir=1;
188: if((peekc=getchar())!='\n'){ /* really nextchar() */
189: if (peekc=='-' || peekc=='+' || peekc=='.') {
190: if(peekc=='-')
191: dir= -1;
192: else if(peekc=='.')
193: dir=0;
194: getchar(); /* eat peekc */
195: }
196: if((n=getnum())>0)
197: pagesize=n;
198: }
199: psize=pagesize;
200: if(dir==0)
201: psize/=2;
202: if(posn(nextchar(), lchars)>=0)
203: bformat=getchar();
204: if(dir<=0) {
205: if((addr1=addr2-(psize-1))<=zero)
206: addr1=zero+1;
207: if(dir==0){
208: display(bformat);
209: puts("^^^^^");
210: addr2++;
211: }
212: }
213: if (dir>=0) {
214: addr1=addr2;
215: if((addr2+=(psize-1))>dol)
216: addr2=dol;
217: }
218: display(bformat);
219: if(dir==0)
220: dot=olddot;
221: }
222: delete()
223: {
224: register *a1, *a2, *a3;
225: setdot();
226: a1 = addr1;
227: a2 = addr2;
228: if(a1==zero) {
229: if(a2!=zero)
230: *(a1++);
231: else
232: return; /* 0,$d on an empty buffer */
233: }
234: *(a2++);
235: a3 = lastdol;
236: lock++;
237: dol -= a2 - a1;
238: lastdol -= a2 - a1;
239: fixbufs(a1-a2);
240: do
241: *a1++ = *a2++;
242: while (a2<=a3);
243: a1 = addr1;
244: if (a1 > dol)
245: a1 = dol;
246: dot = a1;
247: unlock();
248: modified();
249: }
250: allnums()
251: {
252: register int i;
253: register char *p;
254: setdot();
255: for(i=0; i<NBUFS; i++){
256: p = string[i].str;
257: if(*p!='\0' && alldigs(p)){
258: putct(bname[i]);
259: puts(p);
260: }
261: }
262: }
263: numcom(z)
264: {
265: register n;
266: register struct string *sp;
267: register char *l;
268: char c;
269: int numeric;
270: extern char digits[]; /* defined in getchar.c = "0123456789" */
271:
272: /*
273: * Must generate error if attempt is made to do arithmetic on
274: * a register which is not numeric; this is done by remembering
275: * (via `numeric') whether the initial string was numeric or not.
276: */
277: sp = &string[z];
278: numeric = alldigs(sp->str);
279: n = atoi(sp->str);
280: for(;;){
281: switch(c=getchar()){
282: default:
283: goto Done;
284: case ':':
285: n=getsigned();
286: goto Not_numeric;
287: case 'a':
288: n=addr2-zero;
289: goto Not_numeric;
290: case 'r':
291: if(z+1>=NBUFS)
292: error('z');
293: n = addr1-zero;
294: numset(z+1, addr2-zero);
295: goto Not_numeric;
296: case 'n':
297: nonzero();
298: l = getline(*addr2,linebuf);
299: do; while(*l++);
300: n = l - linebuf - 1;
301: goto Not_numeric;
302: case 'P':
303: n = getpid();
304: Not_numeric:
305: numeric = TRUE; /* It's numeric now! */
306: break;
307:
308: case 'p':
309: if(n<0)
310: putchar('-');
311: putdn(abs(n));
312: goto Numeric;
313: case '+':
314: n += getsigned();
315: goto Numeric;
316: case '-':
317: n -= getsigned();
318: goto Numeric;
319: case '*':
320: n *= getsigned();
321: goto Numeric;
322: case '/':
323: n /= getsigned();
324: goto Numeric;
325: case '%':
326: n %= getsigned();
327: goto Numeric;
328: case '!':
329: if(posn(c=getchar(), "=><")<0)
330: error('#');
331: settruth(condition(n, getsigned(), c, 1));
332: goto Numeric;
333: case '<':
334: case '>':
335: case '=':
336: settruth(condition(n, getsigned(), c, 0));
337: Numeric:
338: if(numeric == FALSE)
339: error('#');
340: break;
341: }
342: }
343: Done:
344: ungetchar(c);
345: numset(z, n);
346: }
347: condition(n, m, cond, negate)
348: register n, m, cond, negate;
349: {
350: int retval;
351: if(cond=='=')
352: retval = (n==m);
353: else if(cond=='<')
354: retval = (n<m);
355: else if(cond=='>')
356: retval = (n>m);
357: else
358: error("!");
359: return(negate^retval);
360: }
361: numset(z, n)
362: register z;
363: register n;
364: {
365: startstring();
366: numbuild(n);
367: setstring(z);
368: }
369: numbuild(n)
370: register n;
371: {
372: register i;
373: if(n<0){
374: addstring('-');
375: n = -n;
376: }
377: i = n/10;
378: if(i)
379: numbuild(i);
380: addstring(n%10+'0');
381: }
382: strcom(z)
383: {
384: register char *q;
385: register n;
386: int getchar();
387: register struct string *sp;
388: int cond, c, negate;
389: setdot();
390: sp = &string[z];
391: if(nextchar()=='#'){
392: getchar(); /* eat the '#' */
393: numcom(z);
394: return;
395: }
396: negate=FALSE;
397: switch(cond=getchar()){
398: default:
399: error('x');
400: case 'p':
401: puts(sp->str);
402: break;
403: case 'l':
404: putl(sp->str);
405: break;
406: case ':':
407: startstring();
408: for(;;){
409: c = getquote("\n", getchar);
410: if(c=='\n'){
411: setstring(z);
412: return;
413: }
414: addstring(c&0177);
415: }
416: case '\'':
417: startstring();
418: dupstring(getname('z'));
419: setstring(z);
420: break;
421: case '.':
422: nonzero();
423: startstring();
424: copystring(getline(*addr2, linebuf));
425: setstring(z);
426: break;
427: case '/':
428: nonzero();
429: compile('/');
430: if(execute(addr2)==0){
431: clearstring(z);
432: settruth(FALSE);
433: return;
434: }
435: q = loc1;
436: startstring();
437: while(q < loc2)
438: addstring(*q++);
439: setstring(z);
440: settruth(TRUE);
441: return;
442: case 's':
443: substitute(stackp!=&stack[0], z);
444: return;
445: case '+':
446: strinc(z, getsigned());
447: break;
448: case '-':
449: strinc(z, -getsigned());
450: break;
451: case 'n':
452: setcount(sp->len);
453: break;
454: case 'e':
455: startstring();
456: addstring(lasterr);
457: setstring(z);
458: break;
459: case '(':
460: n=getsigned();
461: if(abs(n) > sp->len)
462: error('[');
463: if(n>=0){
464: sp->str += n;
465: sp->len -= n;
466: }
467: else{
468: sp->str += sp->len+n;
469: sp->len = -n;
470: }
471: break;
472: case ')':
473: n=getsigned();
474: if(abs(n) > sp->len)
475: error('[');
476: if(n<0){
477: sp->str[sp->len+n]='\0';
478: sp->len += n;
479: } else if(n==0)
480: clearstring(z);
481: else {
482: sp->str[n]='\0';
483: sp->len=n;
484: }
485: break;
486: case '[':
487: cpstr(sp->str, linebuf);
488: loc2=0; /* Tell execute that it's already in linebuf */
489: compile(getchar());
490: if(execute(0)==0){
491: settruth(FALSE);
492: setcount(-1);
493: } else {
494: settruth(TRUE);
495: setcount(loc2-linebuf-1);
496: }
497: return;
498: case 'C':
499: startstring();
500: clean(z);
501: setstring(z);
502: break;
503: case '!':
504: if(posn(cond=getchar(), "=><")<0)
505: error('x');
506: negate=TRUE;
507: case '=':
508: case '<':
509: case '>':
510: settruth(FALSE);
511: q=sp->str;
512: for(;;){
513: c=getchar();
514: if(c=='\n' && *q==0){
515: if(cond == '=')
516: settruth(!negate);
517: return;
518: }
519: if(*q++!=c){
520: if(cond=='<')
521: settruth(negate ^ (*--q < c));
522: else if(cond=='>')
523: settruth(negate ^ (*--q > c));
524: while(c!='\n')
525: c=getchar();
526: return;
527: }
528: }
529: case '{':
530: q = genbuf;
531: while(posn(c=getchar(), "} \t\n")<0 && c!=EOF)
532: *q++ = c;
533: *q = '\0';
534: if((q=getenv(genbuf)) == 0)
535: clearstring(z);
536: else{
537: startstring();
538: copystring(q);
539: setstring(z);
540: }
541: break;
542: /* end of switch */
543: }
544: }
545: strinc(z, n)
546: {
547: register char *q;
548: q=string[z].str;
549: while(*q)
550: *q++ += n;
551: }
552: locn(ap, aq)
553: char *ap, *aq;
554: {
555: register char *p, *q, *lastq;
556: p=ap;
557: q=aq;
558: for(;;){
559: lastq=q;
560: while(*p==*q){
561: if(*p++==0 || *p==0)
562: return(lastq - aq);
563: q++;
564: }
565: if(*q==0)
566: return(-1);
567: p=ap;
568: q=lastq+1;
569: }
570: }
571: #define EMPTY (TRUE+1) /* ==> ignore this buf in G/V */
572: ncom(c)
573: {
574: register struct buffer *bufp;
575: struct buffer *stop;
576: register char *f, *lp;
577: int globflag;
578:
579: setnoaddr();
580: syncbuf();
581: globflag = FALSE;
582: if(c == 'f')
583: stop = bufp = curbuf;
584: else{
585: bufp = buffer;
586: stop = buffer+NBUFS-1;
587: if(c=='G')
588: globflag = TRUE;
589: }
590: do{
591: lp = linebuf;
592: f = string[FILE(bufp-buffer)].str;
593: if(c=='N' && (!bufp->cflag || *f==0))
594: continue;
595: if(bufp->dol==bufp->zero && *f=='\0'){
596: if(globflag)
597: bufp->gmark = EMPTY;
598: if(globflag || bufp!=curbuf)
599: continue;
600: }
601: *lp++ = bname[bufp-buffer];
602: *lp++ = (bufp->cflag) ? '\'' : ' ';
603: *lp++ = (bufp==curbuf) ? '.' : ' ';
604: numset(FILEBUF, bufp->dol-bufp->zero);
605: cpstr(string[FILEBUF].str, lp);
606: lp += string[FILEBUF].len;
607: f = string[FILE(bufp-buffer)].str; /* in case strings got g.c.'d */
608: if(*f)
609: *lp++ = '\t';
610: if(globflag){
611: cpstr(f, lp);
612: loc2 = 0; /* ==> we are about to search for 1st time */
613: bufp->gmark = execute((int *)0);
614: } else {
615: *lp = '\0';
616: lp = linebuf;
617: while(*lp)
618: putchar(*lp++);
619: putl(f);
620: }
621: }while(bufp++!=stop);
622: }
623: allstrs()
624: {
625: register int i;
626: char *p;
627: setdot();
628: for(i=0; i<NBUFS; i++){
629: p=string[i].str;
630: if(*p!=0){
631: putct(bname[i]);
632: putl(p);
633: }
634: }
635: putct('P');
636: putl(string[SAVPAT].str);
637: putct('R');
638: putl(string[SAVRHS].str);
639: if(*string[BROWSE].str) {
640: putct('B');
641: putl(string[BROWSE].str);
642: }
643: }
644: /*
645: * clean (string) to support zaC
646: * strips leading and trailing white space from a string
647: * and replaces interior white space by single blanks
648: */
649: clean(z) {
650: register char *s;
651: register char *d;
652: register char c;
653: d = genbuf;
654: for (s = string[z].str; (c = *s) == ' ' || c == '\t'; s++);
655: while (c = *s++) {
656: if (c == ' ' || c == '\t') {
657: *d++ = ' ';
658: while(*s == ' ' || *s == '\t')
659: s++;
660: } else {
661: *d++ = c;
662: }
663: }
664: while (d > genbuf && d[-1] == ' ')
665: --d;
666: *d = 0;
667: copystring(genbuf);
668: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.