![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / basic / bas|
Return to main.c CVS log | Up to [Research Unix] / researchv10no / cmd / basic / bas |
1.1 root 1: #include <stdio.h>
2: #include "ctype.h"
3: #include "typedef.h"
4: #include "basic.h"
5: #include "tokens.h"
6:
7: static int listlevel, /* listing indentation level */
8: rflg; /* automatic run flag */
9:
10: char lnrdelims[] = {MINUS, COMMA, '-', ',', 0};
11:
12: char *endstr();
13: Linep findline();
14: Lnr cvtlnr();
15: Stkptr pop();
16: void old(), dorun(), doline();
17: FILE *file;
18: char *frstwd, *using;
19:
20:
21: /*
22: * main --- main program for basic
23: */
24:
25: main(argc, argv)
26: int argc;
27: char **argv;
28: {
29: register char *argp;
30:
31: --argc;
32: ++argv;
33:
34: while (argc > 0 && *(argp = *argv) == '-') {
35: ++argv;
36: --argc;
37: while (*++argp)
38: switch (*argp) {
39: case 'r':
40: ++rflg;
41: break;
42: case 's':
43: typelens[FLOAT] = sizeof(float);
44: break;
45: case 't':
46: ++tflg;
47: break;
48: case 'p':
49: pltini(*argv++);
50: --argc;
51: break;
52: default:
53: fprintf(stderr, "I don't know about -%c\n",
54: *argp);
55: exit(1);
56: }
57: }
58:
59: initsys();
60: init();
61: if (argc > 0) {
62: argcnt = argc;
63: argvec = argv;
64: argc = 0;
65: enter(old, *argv);
66: }
67: if (rflg) {
68: enter(dorun, NULL);
69: exit(0);
70: }
71: for (;;)
72: enter(doline, NULL);
73: }
74:
75:
76: /*
77: * doline --- read and process one line
78: */
79:
80: void doline()
81: {
82:
83: if (tty)
84: fputs(prompt, stderr);
85: if (readline(line, infile) < 0) {
86: if (attnflg)
87: err("attn!!");
88: exit(0);
89: }
90: inptr = line;
91: if (line[0] == 0)
92: ;
93: else if (!moncmd())
94: compile();
95: }
96:
97:
98: /*
99: * compile --- tokenize a line; store numbered ones, execute others
100: */
101:
102: compile()
103: {
104: register Lnr lnr;
105: register int l;
106: register Linep p;
107:
108: inptr = line;
109: tokenize(line, line);
110: if (tflg)
111: listline(&immed, stderr);
112: inptr = line;
113: if (isdigit(line[0])) {
114: lnr = cvtlnr();
115: if (*inptr) {
116: l = strlen(inptr) + 1;
117: move(l, inptr, immed.l_line);
118: if (l & 1)
119: ++l;
120: l += LINESIZE;
121: immed.l_len = l;
122: immed.l_lnr = lnr;
123: storeline(&immed);
124: }
125: else {
126: p = findline(lnr, NEXTLNR);
127: if (p->l_lnr == lnr)
128: delline(p);
129: }
130: }
131: else {
132: curline = (Linep)NULL;
133: immed.l_len = 0;
134: execute(&immed);
135: }
136: return(YES);
137: }
138:
139:
140: /*
141: * findline --- search for the specified line; return pointer to it
142: * if line is not found and flag==NEXTLNR, return pointer
143: * to next higher-numbered line
144: */
145:
146: Linep findline(lnr, flag)
147: Lnr lnr;
148: int flag;
149: {
150: register Linep p;
151:
152: for ALL_LINES(p)
153: if (lnr <= p->l_lnr)
154: break;
155: if (p->l_lnr != lnr && flag != NEXTLNR)
156: err("line not found");
157: return(p);
158: }
159:
160:
161: /*
162: * list --- list the specified range of lines
163: */
164:
165: list(line1, line2, file)
166: Lnr line1, line2;
167: FILE *file;
168: {
169: register Linep p;
170:
171: listlevel = 0;
172: for ALL_LINES(p) {
173: if (attnflg)
174: err("attn!");
175: if (p->l_lnr >= line1)
176: if (p->l_lnr <= line2)
177: listline(p, file);
178: else
179: break;
180: }
181: }
182:
183:
184: /*
185: * listline --- list a single line
186: */
187:
188: listline(linep, file)
189: Linep linep;
190: FILE *file;
191: {
192: register char *p;
193: register Linep l;
194: register int c;
195: int i, wastoken = YES;
196:
197: l = linep;
198: fprintf(file, "%5u\t", l->l_lnr);
199: for (i = 0; i < listlevel; ++i)
200: putc('\t', file);
201:
202: for (p = l->l_line; *p; ++p)
203: if (istoken(*p)) {
204: if (!wastoken)
205: putc(' ', file);
206: wastoken = YES;
207: switch (c = *p) {
208: case QUOTE:
209: case PRIME:
210: c = tokens[UNTOKEN(c)][0];
211: putc(c, file);
212: while (*++p && !istoken(*p)) {
213: if (*p == c)
214: putc(c, file);
215: putc(*p, file);
216: }
217: putc(c, file);
218: putc(' ', file);
219: break;
220: case REM:
221: case PRFORM:
222: case DATA:
223: fputs(tokens[UNTOKEN(c)], file);
224: break;
225: case FOR:
226: if (p[1] != INPUT && p[1] != OUTPUT && p[1] != APPEND)
227: listlevel++;
228: goto normal;
229: case NEXT:
230: listlevel--;
231: default:
232: normal:
233: fputs(tokens[UNTOKEN(c)], file);
234: putc(' ', file);
235: }
236: }
237: else {
238: putc(*p, file);
239: wastoken = NO;
240: }
241:
242: putc('\n', file);
243: }
244:
245:
246: /*
247: * getlnrs2 --- parse up to two line numbers from current line
248: * but don't check for end of line in case there
249: * are more arguments on line (for example,
250: * renumber 1000, 10, 300-400
251: */
252:
253: getlnrs2(lp1, lp2, type)
254: Lnr *lp1, *lp2;
255: int type;
256: {
257: register Lnr line1, line2;
258:
259: if (type == LISTLNRS) {
260: line1 = MINLNR;
261: line2 = MAXLNR;
262: }
263: else {
264: line1 = *lp1;
265: line2 = *lp2;
266: }
267: if (*inptr) {
268: skipbl();
269: optional(lnrdelims);
270: skipbl();
271: line1 = cvtlnr();
272: if (type == LISTLNRS)
273: line2 = line1;
274: skipbl();
275: optional(lnrdelims);
276: skipbl();
277: if (*inptr)
278: line2 = cvtlnr();
279: }
280: *lp1 = line1;
281: *lp2 = line2;
282:
283: }
284: /*
285: * getlnrs --- parse up to two line numbers from current line
286: */
287:
288: getlnrs(lp1, lp2, type)
289: Lnr *lp1, *lp2;
290: int type;
291: {
292: register Lnr line1, line2;
293:
294: if (type == LISTLNRS) {
295: line1 = MINLNR;
296: line2 = MAXLNR;
297: }
298: else {
299: line1 = *lp1;
300: line2 = *lp2;
301: }
302: if (*inptr) {
303: skipbl();
304: optional(lnrdelims);
305: skipbl();
306: line1 = cvtlnr();
307: if (type == LISTLNRS)
308: line2 = line1;
309: skipbl();
310: optional(lnrdelims);
311: skipbl();
312: if (*inptr)
313: line2 = cvtlnr();
314: }
315: endchk();
316: *lp1 = line1;
317: *lp2 = line2;
318: }
319:
320:
321: /*
322: * delete --- delete the specified range of lines
323: */
324:
325: delete(line1, line2)
326: Lnr line1, line2;
327: {
328: register Linep p;
329:
330: for (p = findline(line1, NEXTLNR);
331: isline(p) && p->l_lnr <= line2; delline(p))
332: ;
333: }
334:
335:
336: /*
337: * delline --- delete the line pointed to by linep
338: */
339:
340: delline(linep)
341: register Linep linep;
342: {
343: register char *p, *q;
344: register int l;
345:
346: p = (char *)linep;
347: l = linep->l_len;
348: q = p + l;
349: smartmove(lastline - q, q, p);
350: lastline -= l;
351: --linecnt;
352: }
353:
354:
355: /*
356: * storeline --- save the line pointed to by linep
357: */
358:
359: storeline(linep)
360: Linep linep;
361: {
362: register Linep l;
363: register char *p, *q;
364: int overlap;
365:
366: l = linep;
367: p = (char *)findline(l->l_lnr, NEXTLNR);
368: if (l->l_lnr != ((Linep)p)->l_lnr)
369: q = p;
370: else
371: q = p + ((Linep)p)->l_len;
372: overlap = q - p;
373: if (overlap >= l->l_len && overlap - l->l_len <= LEN_FUZZ)
374: l->l_len = overlap;
375: else {
376: while (lastline + l->l_len - overlap > endlines)
377: if (!morelines())
378: err("out of room");
379: smartmove(lastline - q, q, p + l->l_len);
380: }
381: move(l->l_len, (char *)l, p);
382: lastline += l->l_len - overlap;
383: if (!overlap)
384: ++linecnt;
385: }
386:
387:
388: /*
389: * cvtlnr --- parse one line number from the current input line
390: */
391:
392: Lnr cvtlnr()
393: {
394: register Lnr l, lastl;
395: register int c;
396:
397: lastl = l = 0;
398: while ((c = *inptr) && isdigit(c)) {
399: l = 10 * l + (c - '0');
400: if (l > MAXLNR || l < lastl)
401: err("bad line number");
402: lastl = l;
403: ++inptr;
404: }
405: return(l);
406: }
407:
408:
409: /*
410: * optional --- accept any single character in str if present
411: */
412:
413: optional(str)
414: char *str;
415: {
416: register char *s;
417:
418: if (*inptr)
419: for (s = str; *s; ++s)
420: if (*s == *inptr) {
421: inptr++;
422: return(YES);
423: }
424: return(NO);
425: }
426:
427:
428: /*
429: * tokenize --- convert input line into a string of tokens
430: */
431:
432: tokenize(inp, outp)
433: char *inp, *outp;
434: {
435: register char *t, *p;
436: register int c;
437: int i;
438:
439: while ((c = *inp++)) {
440: if (c == ' ' || c == '\t')
441: continue;
442: for (i = -1; (t = tokens[UNTOKEN(i)]); --i) {
443: for (p = inp - 1;; ) {
444: if (*p++ != *t++) {
445: if (p[-1] == ' ' || p[-1] == '\t') {
446: --t;
447: continue;
448: }
449: else if (isupper(p[-1])
450: && p[-1] == toupper(t[-1]))
451: ;
452: else
453: break;
454: }
455: if (*t == 0) {
456: if (tflg)
457: fprintf(stderr, "token %d ", i);
458: inp = p;
459: c = i;
460: switch (i) {
461: case REM:
462: case PRFORM:
463: case DATA:
464: *outp++ = c;
465: while ((*outp++ = *inp++))
466: ;
467: return;
468: case PRIME:
469: case QUOTE:
470: --t;
471: *outp++ = c;
472: while (*inp) {
473: if (*inp == *t && *++inp != *t)
474: break;
475: *outp++ = *inp++;
476: }
477: if (*inp == 0) {
478: *outp++ = c;
479: *outp = 0;
480: return;
481: }
482: break;
483: }
484: goto loop;
485: }
486: }
487: }
488: if (isupper(c))
489: c = tolower(c);
490: loop:
491: *outp++ = c;
492: }
493: *outp = c;
494: }
495:
496:
497: /*
498: * execute --- interpret the line pointed to by linep
499: */
500:
501: execute(linep)
502: Linep linep;
503: {
504: register Lnr line1;
505: register int c;
506: register Stkptr s;
507: Linep fmlnep;
508: char *p;
509:
510: curline = linep;
511: if (curline != &immed && !isline(curline))
512: return;
513: loop:
514: inptr = curline->l_line;
515: if (trace && curline != &immed)
516: fprintf(stderr, "#%u\n", curline->l_lnr);
517: do {
518: if (attnflg)
519: err("attn");
520: next:
521: c = *inptr;
522: if (istoken(c)) {
523: ++inptr;
524: switch (c) {
525: case END:
526: return;
527: case TRACE:
528: trace = YES;
529: break;
530: case NOTRACE:
531: trace = NO;
532: break;
533: case PRINT:
534: if (*inptr == ' ')
535: inptr++;
536: if (*inptr != USING)
537: prtstmt();
538: else {
539: inptr++;
540: line1 = cvtlnr();
541: fmlnep = findline(line1, EXACTLNR);
542: p = fmlnep->l_line;
543: if (*p++ != PRFORM)
544: err("image-line not found");
545: else
546: prtusing(p);
547: }
548: break;
549: case INPUT:
550: case ASK:
551: ask();
552: break;
553: case READ:
554: readdata();
555: break;
556: case RESTORE:
557: if (data.k_un.k_gosub.g_inptr != NULL)
558: restore();
559: break;
560: case DIM:
561: dim();
562: break;
563: case FOR:
564: forstmt();
565: break;
566: case NEXT:
567: nextstmt();
568: break;
569: case REM:
570: case MORE:
571: case ELSE:
572: case QUOTE:
573: case PRIME:
574: case PRFORM:
575: case DATA:
576: while (*inptr)
577: ++inptr;
578: break;
579: case RETURN:
580: while (((Stkptr)stkptr)->k_type == STK_FOR)
581: (void)pop(ANYTYPE);
582: s = pop(STK_GOSUB);
583: curline = s->k_un.k_gosub.g_curline;
584: inptr = s->k_un.k_gosub.g_inptr;
585: break;
586: case GOSUB:
587: line1 = cvtlnr();
588: endchk();
589: gosub.k_un.k_gosub.g_curline = curline;
590: gosub.k_un.k_gosub.g_inptr = inptr;
591: gosub.k_type = STK_GOSUB;
592: gosub.k_len = GOSUBFRLEN;
593: push(&gosub);
594: curline = findline(line1, EXACTLNR);
595: inptr = NULL;
596: break;
597: case GOTO:
598: line1 = cvtlnr();
599: endchk();
600: curline = findline(line1, EXACTLNR);
601: inptr = NULL;
602: break;
603: case DEF:
604: def();
605: break;
606: case LET:
607: let();
608: break;
609: case IF:
610: ifstmt();
611: goto nochk;
612: case STOP:
613: endchk();
614: err("stop");
615: break;
616: case COLON:
617: goto next;
618: case ON:
619: ongoto();
620: break;
621: case CHAIN:
622: chain();
623: break;
624: case HPLOT:
625: hplot();
626: break;
627: case HGR:
628: hgr();
629: break;
630: case OPEN:
631: openstmt();
632: break;
633: case CLOSE:
634: clsstmt();
635: break;
636: case FLUSH:
637: flsstmt();
638: break;
639: case USING:
640: err("print must precede using");
641: break;
642: default:
643: badsyn();
644: }
645: }
646: else
647: let();
648: if (inptr)
649: endchk();
650: nochk:
651: ;
652: } while (inptr && *inptr);
653:
654: if (inptr == NULL) {
655: if (curline && isline(curline))
656: goto loop;
657: return;
658: }
659: else if (curline != &immed) {
660: curline = nextline(curline);
661: if (isline(curline))
662: goto loop;
663: }
664: }
665:
666:
667: /*
668: * run --- handle the RUN command
669: */
670:
671: run()
672: {
673: register Lnr line1;
674:
675: line1 = cvtlnr();
676: endchk();
677: dorun(line1);
678: }
679:
680:
681: /*
682: * dorun --- begin execution at the specified line
683: */
684:
685: void dorun(line1)
686: Lnr line1;
687: {
688:
689: clrsym();
690: clrstk();
691: clrio();
692: curline = findline(line1, NEXTLNR);
693: inptr = NULL;
694: execute(curline);
695: }
696:
697:
698: /*
699: * autonumber --- handle the AUTO command
700: */
701:
702: autonumber(line1, line2)
703: register Lnr line1, line2;
704: {
705: register Linep p;
706: register char *q;
707:
708: curline = (Linep)NULL;
709: for (;; line1 += line2) {
710: if ((p = findline(line1, NEXTLNR)) && p->l_lnr == line1)
711: err("line %u already exists", line1);
712: sprintf(line, "%5u ", line1);
713: fputs(line, stderr);
714: /* fflush(stderr); */
715: q = endstr(line);
716: if (readline(q, infile) < 0 || *q == 0) {
717: if (attnflg)
718: err("attn!!");
719: break;
720: }
721: inptr = line;
722: compile();
723: }
724: }
725:
726:
727: /*
728: * badsyn --- report bad syntax
729: */
730:
731: badsyn()
732: {
733:
734: err("bad syntax");
735: }
736:
737:
738: /*
739: * init --- perform startup initialization
740: */
741:
742: init()
743: {
744:
745: initprio();
746: clrsym();
747: clrstk();
748: clrprog();
749: }
750:
751:
752: /*
753: * clrprog --- reinitialize the line storage space
754: */
755:
756: clrprog()
757: {
758: register Linep l;
759:
760: l = (Linep)lines;
761: l->l_len = 0;
762: l->l_lnr = MAXLNR;
763: lastline = lines + LINESIZE;
764: linecnt = 0;
765: }
766:
767:
768: /*
769: * nextline --- return ptr to line following one pointed to by lp
770: */
771:
772: Linep nextline(lp)
773: register Linep lp;
774: {
775:
776: return((Linep)((char *)lp + lp->l_len));
777: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.