![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to demo.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bed|
Return to demo.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bed |
1.1 root 1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */
2: static char rcsid[] = "$Header: demo.c,v 2.6 85/08/22 16:01:21 timo Exp $";
3:
4: /*
5: * B editor -- Editor command processor.
6: */
7:
8: #include <ctype.h>
9:
10: #include "b.h"
11: #include "feat.h"
12: #include "erro.h"
13: #include "bobj.h"
14: #include "node.h"
15: #include "gram.h"
16: #include "keys.h"
17: #include "supr.h"
18:
19: #ifdef BTOP
20: #include <setjmp.h>
21:
22: #ifndef CMDPROMPT
23: #define CMDPROMPT ">>> " /* Prompt user for immediate command */
24: #endif CMDPROMPT
25: #endif BTOP
26:
27:
28: value editqueue();
29:
30: /* Command line flags */
31: extern bool dflag;
32: extern bool slowterminal;
33:
34: #ifdef SAVEBUF
35: extern char copysavefile[];
36: #endif SAVEBUF
37:
38:
39: Visible bool lefttorite;
40: /* Saves some time in nosuggtoqueue() for read from file */
41:
42: #define MAXHIST 101 /* One more than the number of UNDO's allowed. */
43:
44: #define Mod(k) (((k)+MAXHIST) % MAXHIST)
45: #define Succ(k) (((k)+1) % MAXHIST)
46: #define Pred(k) (((k)+MAXHIST-1) % MAXHIST)
47:
48: Hidden environ *tobesaved;
49: Hidden string savewhere;
50:
51:
52: #ifdef BTOP
53:
54: extern jmp_buf jumpback;
55: extern bool interrupted;
56: extern bool canjump;
57:
58: /*
59: * Main loop, called from main program if -t option present.
60: */
61:
62: Visible Procedure
63: mainloop()
64: {
65: environ env;
66: environ *ep = &env;
67: FILE *pdown;
68: FILE *pup;
69: int cmdchar;
70:
71: savewhere = (string)NULL;
72: tobesaved = (environ*)NULL;
73: start_b(&pdown, &pup);
74: clrenv(ep);
75: #ifdef SAVEBUF
76: ep->copybuffer = editqueue(copysavefile);
77: if (ep->copybuffer)
78: ep->copyflag = Yes;
79: #endif SAVEBUF
80:
81: for (;;) {
82: cmdchar = sleur();
83: if (cmdchar == EOF)
84: break;
85: getinput(ep, cmdchar, pdown, pup);
86: }
87: #ifdef SAVEBUF
88: if (ep->copyflag)
89: savequeue(ep->copybuffer, copysavefile);
90: else
91: savequeue(Vnil, copysavefile);
92: #endif SAVEBUF
93: Erelease(*ep);
94: }
95:
96:
97: /*
98: * Provide input for the interpreter.
99: */
100:
101: Hidden Procedure
102: getinput(ep, cmdchar, pdown, pup)
103: environ *ep;
104: int cmdchar;
105: FILE *pdown;
106: FILE *pup;
107: {
108: int n;
109: char buffer[100];
110: char filename[100];
111: int lineno;
112:
113:
114: switch (cmdchar) {
115:
116: case '>': /* Immediate command */
117: case 'E': /* Expression */
118: case 'R': /* Raw input */
119: case 'Y': /* Yes/No */
120: if (cmdchar == '>')
121: setroot("Imm_cmd");
122: else if (cmdchar == 'E')
123: setroot("Expression");
124: else
125: setroot("Raw_input");
126: delfocus(&ep->focus);
127: initshow();
128: if (cmdchar == '>')
129: cmdprompt(CMDPROMPT);
130: editdocument(ep);
131: endshow();
132: top(&ep->focus);
133: ep->mode = WHOLE;
134: if (!interrupted)
135: send(ep->focus, pdown);
136: delete(ep);
137: break;
138:
139: case ':':
140: case '=':
141: fgets(buffer, sizeof buffer, pup);
142: if (index(buffer, '+'))
143: n = sscanf(buffer, " +%d %s", &lineno, filename) - 1;
144: else {
145: n = sscanf(buffer, " %s", filename);
146: lineno = 0;
147: }
148: if (n == 1) {
149: initshow();
150: dofile(ep, filename, lineno);
151: endshow();
152: top(&ep->focus);
153: ep->mode = WHOLE;
154: delete(ep);
155: if (!ep->copyflag) {
156: release(ep->copybuffer);
157: ep->copybuffer = Vnil;
158: }
159: }
160: putc('\n', pdown);
161: interrupted = No; /* Interrupts handled locally in editdocument! */
162: break;
163:
164: default:
165: printf("[Unrecognized command character '%c' (0%o)]\n",
166: cmdchar&0177, cmdchar);
167:
168: }
169: }
170:
171: #endif BTOP
172:
173:
174: #ifdef FILEARGS
175:
176: /*
177: * Edit a single unit or target, called from main program if file name
178: * arguments are present.
179: */
180:
181: Visible Procedure
182: demo(filename, linenumber)
183: string filename;
184: int linenumber;
185: {
186: environ env;
187: environ *ep = &env;
188: bool ok;
189:
190: clrenv(ep);
191: #ifdef SAVEBUF
192: ep->copybuffer = editqueue(copysavefile);
193: if (ep->copybuffer)
194: ep->copyflag = Yes;
195: #endif SAVEBUF
196: initshow();
197: ok = dofile(ep, filename, linenumber);
198: endshow();
199: if (!ok)
200: return No;
201: #ifdef SAVEBUF
202: if (ep->copyflag)
203: savequeue(ep->copybuffer, copysavefile);
204: else
205: savequeue(Vnil, copysavefile);
206: #endif SAVEBUF
207: Erelease(*ep);
208: return Yes;
209: }
210:
211: #endif !FILEARGS
212:
213:
214: /*
215: * Edit a unit or target, using the environment offered as a parameter.
216: */
217:
218: Hidden bool
219: dofile(ep, filename, linenumber)
220: environ *ep;
221: string filename;
222: int linenumber;
223: {
224: #ifdef HELPFUL
225: static bool didmessage;
226:
227: if (!didmessage) {
228: didmessage = Yes;
229: message("[Press ? or ESC-? for help]");
230: }
231: #endif HELPFUL
232: #ifdef SAVEPOS
233: if (linenumber <= 0)
234: linenumber = getpos(filename);
235: #endif SAVEPOS
236: setroot(filename[0] == '=' ? "Target_edit" : "Unit_edit");
237: savewhere = filename;
238: tobesaved = (environ*)NULL;
239:
240: lefttorite = Yes;
241: edit(ep, filename, linenumber);
242: #ifdef USERSUGG
243: readsugg(ep->focus);
244: #endif USERSUGG
245: lefttorite = No;
246:
247: ep->generation = 0;
248: if (!editdocument(ep))
249: return No;
250: if (ep->generation > 0) {
251: if (!save(ep->focus, filename))
252: error("Cannot save unit: %s", unixerror(filename));
253: #ifdef USERSUGG
254: writesugg(ep->focus);
255: #endif USERSUGG
256: }
257: #ifdef SAVEPOS
258: savepos(filename, lineno(ep)+1);
259: #endif SAVEPOS
260: savewhere = (char*)NULL;
261: tobesaved = (environ*)NULL;
262: return Yes;
263: }
264:
265:
266: /*
267: * Call the editor for a given document.
268: */
269:
270: Hidden bool
271: editdocument(ep)
272: environ *ep;
273: {
274: int k;
275: int first = 0;
276: int last = 0;
277: int current = 0;
278: int onscreen = -1;
279: bool reverse = No;
280: environ newenv;
281: int cmd;
282: bool errors = No;
283: int undoage = 0;
284: bool done = No;
285: environ history[MAXHIST];
286:
287: Ecopy(*ep, history[0]);
288:
289: for (;;) { /* Command interpretation loop */
290: if (onscreen != current)
291: virtupdate(onscreen < 0 ? (environ*)NULL : &history[onscreen],
292: &history[current],
293: reverse && onscreen >= 0 ?
294: history[onscreen].highest : history[current].highest);
295: onscreen = current;
296: if (done)
297: break;
298: #ifdef BTOP
299: if (!interrupted && !moreinput())
300: #else BTOP
301: if (!moreinput())
302: #endif BTOP
303: actupdate(history[current].copyflag ?
304: history[current].copybuffer : Vnil,
305: #ifdef RECORDING
306: history[current].newmacro != Vnil,
307: #else !RECORDING
308: No,
309: #endif !RECORDING
310: No);
311: #ifdef BTOP
312: if (interrupted || setjmp(jumpback))
313: break;
314: canjump = Yes;
315: #endif BTOP
316: cmd = inchar();
317: #ifdef BTOP
318: canjump = No;
319: #endif BTOP
320: errors = No;
321:
322: switch (cmd) {
323:
324: #ifndef NDEBUG
325: case Ctl(@): /* Debug exit with variable dump */
326: tobesaved = (environ*)NULL;
327: return No;
328: #endif NDEBUG
329:
330: #ifndef SMALLSYS
331: case Ctl(^): /* Debug status message */
332: dbmess(&history[current]);
333: errors = Yes; /* Causes clear after new keystroke seen */
334: continue;
335: #endif !SMALLSYS
336:
337: case UNDO:
338: if (current == first)
339: errors = Yes;
340: else {
341: if (onscreen == current)
342: reverse = Yes;
343: current = Pred(current);
344: undoage = Mod(last-current);
345: }
346: break;
347:
348: case REDO:
349: if (current == last)
350: errors = Yes;
351: else {
352: if (current == onscreen)
353: reverse = No;
354: if (history[Succ(current)].generation <
355: history[current].generation)
356: error(REDO_OLD); /***** Should refuse altogether??? *****/
357: current = Succ(current);
358: undoage = Mod(last-current);
359: }
360: break;
361:
362: #ifdef HELPFUL
363: case HELP:
364: if (help())
365: onscreen = -1;
366: break;
367: #endif HELPFUL
368:
369: case REDRAW:
370: onscreen = -1;
371: trmundefined();
372: break;
373:
374: case EOF:
375: done = Yes;
376: break;
377:
378: default:
379: Ecopy(history[current], newenv);
380: newenv.highest = Maxintlet;
381: newenv.changed = No;
382: if (cmd != EXIT)
383: errors = !execute(&newenv, cmd) || !checkep(&newenv);
384: else
385: done = Yes;
386: if (errors) {
387: switch (cmd) {
388: case '\r':
389: case '\n':
390: if (newenv.mode == ATEND && !parent(newenv.focus)) {
391: errors = !checkep(&newenv);
392: if (!errors)
393: done = Yes;
394: }
395: break;
396: #ifdef HELPFUL
397: case '?':
398: if (help())
399: onscreen = -1;
400: #endif HELPFUL
401: }
402: }
403: if (errors)
404: Erelease(newenv);
405: else {
406: #ifndef SMALLSYS
407: if (done)
408: done = canexit(&newenv);
409: #endif SMALLSYS
410: if (newenv.changed)
411: ++newenv.generation;
412: last = Succ(last);
413: current = Succ(current);
414: if (last == first) {
415: /* Array full (always after a while). Discard "oldest". */
416: if (current == last
417: || undoage < Mod(current-first)) {
418: Erelease(history[first]);
419: first = Succ(first);
420: if (undoage < MAXHIST)
421: ++undoage;
422: }
423: else {
424: last = Pred(last);
425: Erelease(history[last]);
426: }
427: }
428: if (current != last
429: && newenv.highest < history[current].highest)
430: history[current].highest = newenv.highest;
431: /* Move entries beyond current one up. */
432: for (k = last; k != current; k = Pred(k)) {
433: if (Pred(k) == onscreen)
434: onscreen = k;
435: Emove(history[Pred(k)], history[k]);
436: }
437: Ecopy(newenv, history[current]);
438: Erelease(history[current]);
439: }
440: break; /* default */
441:
442: } /* switch */
443:
444: if (errors && cmd != '?') {
445: if (!slowterminal && isascii(cmd)
446: && (isprint(cmd) || cmd == ' '))
447: error(INS_BAD, cmd);
448: else
449: error((char*)NULL);
450: }
451: if (savewhere)
452: tobesaved = &history[current];
453: } /* for (;;) */
454:
455: actupdate(Vnil, No, Yes);
456: Erelease(*ep);
457: Ecopy(history[current], *ep);
458: if (savewhere)
459: tobesaved = ep;
460: for (current = first; current != last; current = Succ(current))
461: Erelease(history[current]);
462: Erelease(history[last]);
463: /* endshow(); */
464: return Yes;
465: }
466:
467:
468: /*
469: * Execute a command, return success or failure.
470: */
471:
472: Hidden bool
473: execute(ep, cmd)
474: register environ *ep;
475: register int cmd;
476: {
477: register bool spflag = ep->spflag;
478: register int i;
479: environ env;
480: char buf[2];
481: register char *cp;
482: #ifdef USERSUGG
483: bool sugg = symbol(tree(ep->focus)) == Suggestion;
484: #define ACCSUGG(ep) if (sugg) accsugg(ep)
485: #define KILLSUGG(ep) if (sugg) killsugg(ep)
486: #else !USERSUGG
487: #define ACCSUGG(ep) /* NULL */
488: #define KILLSUGG(ep) /* NULL */
489: #endif !USERSUGG
490:
491: #ifdef RECORDING
492: if (ep->newmacro && cmd != USEMACRO && cmd != SAVEMACRO) {
493: buf[0] = cmd;
494: buf[1] = 0;
495: concato(&ep->newmacro, buf);
496: }
497: #endif RECORDING
498: ep->spflag = No;
499:
500: switch (cmd) {
501:
502: #ifdef RECORDING
503: case SAVEMACRO:
504: ep->spflag = spflag;
505: if (ep->newmacro) { /* End definition */
506: release(ep->oldmacro);
507: if (ep->newmacro && Length(ep->newmacro) > 0) {
508: ep->oldmacro = ep->newmacro;
509: message(REC_OK);
510: }
511: else {
512: release(ep->newmacro);
513: ep->oldmacro = Vnil;
514: }
515: ep->newmacro = Vnil;
516: }
517: else /* Start definition */
518: ep->newmacro = mk_text("");
519: return Yes;
520:
521: case USEMACRO:
522: if (!ep->oldmacro || Length(ep->oldmacro) <= 0) {
523: error(PLB_NOK);
524: return No;
525: }
526: ep->spflag = spflag;
527: cp = Str(ep->oldmacro);
528: for (i = 0; i < Length(ep->oldmacro); ++i) {
529: Ecopy(*ep, env);
530: if (execute(ep, cp[i]&0377) && checkep(ep))
531: Erelease(env);
532: else {
533: Erelease(*ep);
534: Emove(env, *ep);
535: if (!i)
536: return No;
537: error((char*)NULL); /* Just a bell */
538: /* The error must be signalled here, because the overall
539: command (USEMACRO) succeeds, so the main loop
540: doesn't ring the bell; but we want to inform the
541: that not everything was done either. */
542: return Yes;
543: }
544: }
545: return Yes;
546: #endif RECORDING
547:
548: #ifndef SMALLSYS
549: case Ctl(_): /* 'Touch', i.e. set modified flag */
550: ep->changed = Yes;
551: return Yes;
552: #endif SMALLSYS
553:
554: case GOTO:
555: ACCSUGG(ep);
556: #ifdef RECORDING
557: if (ep->newmacro) {
558: error(GOTO_REC);
559: return No;
560: }
561: #endif RECORDING
562: return gotocursor(ep);
563:
564: case NEXT:
565: ACCSUGG(ep);
566: return next(ep);
567:
568: case PREVIOUS:
569: ACCSUGG(ep);
570: return previous(ep);
571:
572: case LEFTARROW:
573: ACCSUGG(ep);
574: return leftarrow(ep);
575:
576: case RITEARROW:
577: ACCSUGG(ep);
578: return ritearrow(ep);
579:
580: case WIDEN:
581: ACCSUGG(ep);
582: return widen(ep);
583:
584: case EXTEND:
585: ACCSUGG(ep);
586: return extend(ep);
587:
588: case NARROW:
589: ACCSUGG(ep);
590: return narrow(ep);
591:
592: case RNARROW:
593: ACCSUGG(ep);
594: return rnarrow(ep);
595:
596: case UPARROW:
597: ACCSUGG(ep);
598: return uparrow(ep);
599:
600: case DOWNARROW:
601: ACCSUGG(ep);
602: return downarrow(ep);
603:
604: case UPLINE:
605: ACCSUGG(ep);
606: return upline(ep);
607:
608: case DOWNLINE:
609: ACCSUGG(ep);
610: return downline(ep);
611:
612: case COPY:
613: ACCSUGG(ep);
614: ep->spflag = spflag;
615: return copyinout(ep);
616:
617: case DELETE:
618: ACCSUGG(ep);
619: return delete(ep);
620:
621: case ACCEPT:
622: ACCSUGG(ep);
623: return accept(ep);
624:
625: default:
626: if (!isascii(cmd) || !isprint(cmd))
627: return No;
628: ep->spflag = spflag;
629: return ins_char(ep, cmd, islower(cmd) ? toupper(cmd) : -1);
630:
631: case ' ':
632: ep->spflag = spflag;
633: return ins_char(ep, ' ', -1);
634:
635: case RETURN:
636: case NEWLINE:
637: KILLSUGG(ep);
638: return ins_newline(ep);
639: }
640: }
641:
642:
643: /*
644: * Initialize an environment variable. Most things are set to 0 or NULL.
645: */
646:
647: Hidden Procedure
648: clrenv(ep)
649: environ *ep;
650: {
651: ep->focus = newpath(Pnil, gram(Optional), 1);
652: ep->mode = WHOLE;
653: ep->copyflag = ep->spflag = ep->changed = No;
654: ep->s1 = ep->s2 = ep->s3 = 0;
655: ep->highest = Maxintlet;
656: ep->copybuffer = Vnil;
657: #ifdef RECORDING
658: ep->oldmacro = ep->newmacro = Vnil;
659: #endif RECORDING
660: ep->generation = 0;
661: ep->changed = No;
662: }
663:
664:
665: /*
666: * Save parse tree and copy buffer.
667: */
668:
669: Visible Procedure
670: enddemo()
671: {
672: register environ *ep = tobesaved;
673:
674: tobesaved = (environ*)NULL;
675: /* To avoid loops if saving is interrupted. */
676: if (savewhere && ep) {
677: if (ep->generation > 0) {
678: save(ep->focus, savewhere);
679: #ifdef USERSUGG
680: writesugg(ep->focus);
681: #endif USERSUGG
682: }
683: #ifdef SAVEBUF
684: if (ep->copyflag)
685: savequeue(ep->copybuffer, copysavefile);
686: else
687: savequeue(Vnil, copysavefile);
688: #endif SAVEBUF
689: #ifdef SAVEPOS
690: savepos(savewhere, lineno(ep)+1);
691: #endif SAVEPOS
692: }
693: #ifdef BTOP
694: waitchild();
695: #endif BTOP
696: }
697:
698:
699: /*
700: * Find out if the current position is higher in the tree
701: * than `ever' before (as remembered in ep->highest).
702: * The algorithm of pathlength() is repeated here to gain
703: * some efficiency by stopping as soon as it is clear
704: * no change can occur.
705: * (Higher() is called VERY often, so this pays).
706: */
707:
708: Visible Procedure
709: higher(ep)
710: register environ *ep;
711: {
712: register path p = ep->focus;
713: register int pl = 0;
714: register int max = ep->highest;
715:
716: while (p) {
717: ++pl;
718: if (pl >= max)
719: return;
720: p = parent(p);
721: }
722: ep->highest = pl;
723: }
724:
725:
726: /*
727: * Issue debug status message.
728: */
729:
730: Visible Procedure
731: dbmess(ep)
732: register environ *ep;
733: {
734: #ifndef SMALLSYS
735: char stuff[80];
736: register string str = stuff;
737:
738: switch (ep->mode) {
739: case VHOLE:
740: sprintf(stuff, "VHOLE:%d.%d", ep->s1, ep->s2);
741: break;
742: case FHOLE:
743: sprintf(stuff, "FHOLE:%d.%d", ep->s1, ep->s2);
744: break;
745: case ATBEGIN:
746: str = "ATBEGIN";
747: break;
748: case ATEND:
749: str = "ATEND";
750: break;
751: case WHOLE:
752: str = "WHOLE";
753: break;
754: case SUBRANGE:
755: sprintf(stuff, "SUBRANGE:%d.%d-%d", ep->s1, ep->s2, ep->s3);
756: break;
757: case SUBSET:
758: sprintf(stuff, "SUBSET:%d-%d", ep->s1, ep->s2);
759: break;
760: case SUBLIST:
761: sprintf(stuff, "SUBLIST...%d", ep->s3);
762: break;
763: default:
764: sprintf(stuff, "UNKNOWN:%d,%d,%d,%d",
765: ep->mode, ep->s1, ep->s2, ep->s3);
766: }
767: message(
768: #ifdef SAVEBUF
769: "%s, %s, wi=%d, hi=%d, (y,x,l)=(%d,%d,%d) %s",
770: symname(symbol(tree(ep->focus))),
771: #else !SAVEBUF
772: "%d, %s, wi=%d, hi=%d, (y,x,l)=(%d,%d,%d) %s",
773: symbol(tree(ep->focus)),
774: #endif SAVEBUF
775: str, width(tree(ep->focus)), ep->highest,
776: Ycoord(ep->focus), Xcoord(ep->focus), Level(ep->focus),
777: ep->spflag ? "spflag on" : "");
778: #endif !SMALLSYS
779: }
780:
781: #ifndef SMALLSYS
782:
783: Hidden bool
784: canexit(ep)
785: environ *ep;
786: {
787: environ env;
788:
789: shrink(ep);
790: if (ishole(ep))
791: delete(ep);
792: Ecopy(*ep, env);
793: top(&ep->focus);
794: higher(ep);
795: ep->mode = WHOLE;
796: if (findhole(&ep->focus)) {
797: Erelease(env);
798: error(EXIT_HOLES); /* There are holes left */
799: return No;
800: }
801: Erelease(*ep);
802: Emove(env, *ep);
803: return Yes;
804: }
805:
806:
807: Hidden bool
808: findhole(pp)
809: register path *pp;
810: {
811: register node n = tree(*pp);
812:
813: if (Type(n) == Tex)
814: return No;
815: if (symbol(n) == Hole)
816: return Yes;
817: if (!down(pp))
818: return No;
819: for (;;) {
820: if (findhole(pp))
821: return Yes;
822: if (!rite(pp))
823: break;
824:
825: }
826: up(pp) || Abort();
827: return No;
828: }
829:
830: #endif !SMALLSYS
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.