![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to io.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 io.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: #define MAXUNIT 5
8: #define MAXSTR 255
9: #define MAXBUF 7
10: #define INUNIT 0
11: #define OUTUNIT 1
12:
13: static struct iotab {
14: int io_flag; /* if currently open etc. */
15: int io_col; /* current column */
16: FILE *io_ptr; /* input/output stdio table entry */
17: } units[MAXUNIT];
18:
19: static char buffers[MAXBUF][BUFSIZ];
20: static char bufflg[MAXBUF];
21: static char pflgs[_NFILE];
22:
23: char askdelims[] = { COMMA, ';', 0 };
24:
25: char *getsvar(), *strpop();
26: FILE *xopen(), *fopen(), *popen();
27: double popfloat();
28: struct iotab *getunit();
29:
30:
31: /*
32: * xopen --- open a file or a pipe; assign a buffer
33: */
34:
35: FILE *xopen(file, how)
36: char *file, *how;
37: {
38: register FILE *f;
39:
40: if (*file == '!') { /* open a pipe */
41: if (f = popen(&file[1], how))
42: pflgs[fileno(f)]++;
43: }
44: else
45: f = fopen(file, how);
46: if (f != (FILE *)NULL)
47: assbuf(f);
48: return(f);
49: }
50:
51:
52: /*
53: * xclose --- close a file previously opened by xopen
54: */
55:
56: xclose(file)
57: register FILE *file;
58: {
59: register char *b = file->_base;
60: register int i;
61:
62: i = fileno(file);
63: if (pflgs[i])
64: pclose(file);
65: else
66: fclose(file);
67: pflgs[i] = 0;
68: for (i = 0; i < MAXBUF; ++i)
69: if (b == buffers[i])
70: bufflg[i] = 0;
71: }
72:
73:
74: /*
75: * assbuf --- assign a buffer to a newly opened file
76: */
77:
78: assbuf(f)
79: register FILE *f;
80: {
81: register int i;
82:
83: for (i = 0; i < MAXBUF; ++i)
84: if (bufflg[i] == 0) {
85: setbuf(f, buffers[i]);
86: ++bufflg[i];
87: return;
88: }
89: err("no buffers available");
90: }
91:
92:
93: /*
94: * initio --- initialize i/o related structures
95: */
96:
97: initio()
98: {
99:
100: assbuf(stdin);
101: clrio();
102: }
103:
104:
105: /*
106: * clrio --- reinitialize i/o related structures
107: */
108:
109: clrio()
110: {
111: register struct iotab *i;
112:
113: for (i = units; i < &units[MAXUNIT]; ++i)
114: if (i->io_flag)
115: iocls(i);
116:
117: units[INUNIT].io_flag = INPUT;
118: units[INUNIT].io_ptr = stdin;
119: units[INUNIT].io_col = 1;
120: units[OUTUNIT].io_flag = OUTPUT;
121: units[OUTUNIT].io_ptr = stdout;
122: units[OUTUNIT].io_col = 1;
123: }
124:
125: iocls(i)
126: register struct iotab *i;
127: {
128: if (i->io_flag) {
129: if (i->io_ptr != stdin && i->io_ptr != stdout)
130: xclose(i->io_ptr);
131: i->io_flag = 0;
132: i->io_ptr = (FILE *)NULL;
133: i->io_col = 1;
134: }
135: }
136:
137:
138: /*
139: * getunit --- get and check unit number for OPEN statement
140: */
141:
142: struct iotab *getunit(flag, defunit)
143: {
144: register int n;
145: register struct iotab *i;
146:
147: if (*inptr != SHARP)
148: n = defunit;
149: else {
150: ++inptr;
151: n = fexpr();
152: if (!endtest()) {
153: while (*inptr == ' ' || *inptr == TAB)
154: ++inptr;
155: if (*inptr != THEN)
156: expectc(COMMA);
157: }
158: }
159: if (n < 0 || n >= MAXUNIT)
160: err("invalid unit %d", n);
161: i = &units[n];
162: if (flag && flag != i->io_flag)
163: err("unit not opened for %s",
164: ((flag == INPUT)? "input" : "output"));
165: return(i);
166: }
167:
168:
169: /*
170: * openstmt --- interpret an OPEN statement
171: */
172:
173: openstmt()
174: {
175: register struct iotab *i;
176: int len, how;
177: char *str, *code, *file;
178:
179: expr();
180: file = strpop();
181: expectc(FOR);
182: how = *inptr;
183: switch (how) {
184: case INPUT:
185: code = "r";
186: break;
187: case OUTPUT:
188: code = "w";
189: break;
190: case APPEND:
191: code = "a";
192: how = OUTPUT; /* same as OUTPUT mostly */
193: break;
194: default:
195: badsyn();
196: }
197: ++inptr;
198: i = getunit(0, ((how == INPUT)? INUNIT : OUTUNIT));
199: i->io_ptr = xopen(file, code);
200: if (i->io_ptr == (FILE *)NULL)
201: err("cannot open %s", file);
202: i->io_flag = how;
203: i->io_col = 1;
204: }
205:
206:
207: /*
208: * prtusing --- interpret a PRINT USING statement
209: */
210:
211: prtusing(fmtptr)
212: char *fmtptr;
213: {
214:
215: register struct iotab *i;
216:
217:
218: /* linefeed and carriage return and
219: * set column count to 1
220: */
221:
222: while (*inptr == ' ' || *inptr == COMMA || *inptr == TAB)
223: inptr++; /* skip spaces & first comma or tab */
224:
225: i = getunit(OUTPUT, OUTUNIT);
226: col = i->io_col;
227: if (col > 1) {
228: i->io_col = 1;
229: }
230:
231: getformat(fmtptr, i->io_ptr);
232: }
233:
234: /*
235: * getformat - get format field and variable for print-using
236: */
237:
238: getformat(fmtptr, file)
239: char *fmtptr;
240: FILE *file;
241: {
242:
243: register Stkptr s;
244: register int l;
245: int flag;
246: double f;
247: char *p, *fp, *tmp, *doformat(), *doformat(), *donumeric();
248:
249: fp = fmtptr;
250: while (!endtest()) {
251: while (*inptr == ' ' || *inptr == COMMA || *inptr == TAB)
252: inptr++; /* skip spaces & first comma or tab */
253: expr();
254: s = (Stkptr)stkptr;
255: switch(s->k_type) {
256: case FLOATEXPR:
257: f = popfloat();
258: fp = donumeric(fp, f, file);
259: break;
260: case STRINGEXPR:
261: pop(ANYTYPE);
262: fp = doformat(fp, s->k_un.k_str.s_ptr,
263: s->k_un.k_str.s_len, file);
264: break;
265: default:
266: badtype();
267: break;
268: }
269: switch(*inptr) {
270: case ' ':
271: case ';':
272: case COMMA:
273: ++inptr;
274: break;
275: case '\0':
276: case '\n':
277: case ELSE:
278: case COLON:
279: break;
280: default:
281: badsyn();
282: break;
283: }
284: }
285: while (*fp > 0) {
286: switch (*fp) {
287: case '\'': /* found a ' */
288: fp++;
289: switch (*fp) {
290: case 'l':
291: case 'L':
292: case 'r':
293: case 'R':
294: case 'c':
295: case 'C':
296: fprintf(file, " ");
297: for(tmp = fp+1;*fp && (*tmp == *fp); fp++,tmp++)
298: fprintf(file, " ");
299: fprintf(file, " ");
300: fp++;
301: break;
302: default:
303: fprintf(file, "'");
304: break;
305: }
306: break;
307: case '#':
308: fprintf(file, " ");
309: fp++;
310: break;
311: default:
312: putc(*fp++, file);
313: break;
314: }
315: }
316: if (*(inptr - 1) != ';')
317: putc('\n', file);
318: if (file == stdout)
319: fflush(file);
320:
321: }
322:
323: /*
324: * donumeric -- print numeric variable in print-using format
325: */
326:
327: char *donumeric(fmtptr, num, file)
328: char *fmtptr;
329: double num;
330: FILE *file;
331:
332: {
333: register int k,c,d,l;
334: register char *fp;
335: int negativeflag, dollarflag, periodflag;
336: int intsize, decsize;
337: long intpart, decpart;
338: double f;
339:
340:
341: /* the next line is for testing
342: printf("beginning donumeric routine");*/
343:
344: fp = fmtptr;
345: c = 0;
346: d = 0;
347: f = num;
348:
349: if (f > 999999999)
350: err("number too large ( > 999,999,999)");
351: /* check to see is number is too large to handle */
352:
353: if (f < 0) {
354: negativeflag = YES;
355: f = -f;
356: }
357: else
358: negativeflag = NO;
359:
360: dollarflag = NO; /* dollar in format field */
361: periodflag = NO; /* period in format field */
362: intsize = 1; /* 1 more than max integer part */
363: decsize = 1; /* 1 more than max decimal part */
364:
365: /* if character in the format line is not a $ or #, print it.
366: Or, if it is a $ or a . but is not followed by a #, print it. */
367:
368: while ((*fp > 0) && ((*fp != '$' && *fp != '#' && *fp != '.') ||
369: (*fp == '$' && *(fp + 1) != '#') ||
370: (*fp == '.' && *(fp + 1) != '#')))
371: fprintf(file, "%.1s", fp++);
372:
373:
374:
375:
376: /* at this point we have either a # or
377: a $ followed by a # */
378:
379:
380: if (*fp == '$') {
381: dollarflag = YES;
382: fp++;
383: }
384:
385: while (*fp == '#') {
386: c++;
387: intsize = intsize * 10;
388: fp++;
389: }
390:
391: if (*fp == '.') {
392: periodflag = YES;
393: fp++;
394: while (*fp == '#') {
395: d++;
396: decsize = decsize * 10;
397: fp++;
398: }
399: }
400:
401:
402: /* round-off number before checking for size */
403:
404: f = f + (5 / (10 * (float)decsize));
405:
406: intpart = f; /* integer part of passed float */
407:
408: /* check for number too large for field
409: if so, print *-filled format field */
410:
411: if (negativeflag == YES)
412: intsize = intsize/10; /* leave room for negative sign */
413:
414: if (intpart > (intsize -1)) {
415: if (dollarflag == YES)
416: fprintf(file, "$");
417: for (; c; c--)
418: fprintf(file, "*");
419: if (periodflag == YES)
420: fprintf(file, ".");
421: for (; d; d--)
422: fprintf(file, "*");
423: return(fp);
424: }
425:
426:
427: /* number fits in field, begin print */
428:
429: /* the following line is for testing only
430: printf("beginning print %d %d", intsize, c);
431: used to enclode previous line in a comment when not used */
432:
433: /* if number is zero, divide intsize by 10 to allow room
434: for the printing of the zero */
435:
436: if (intpart == 0)
437: intsize = intsize/10;
438:
439: for (; intsize > ( 1 + intpart * 10); intsize = intsize / 10)
440: fprintf(file, " ");
441:
442: if (negativeflag == YES)
443: fprintf(file, "-");
444:
445: if (dollarflag == YES)
446: fprintf(file, "$");
447:
448: if (intsize >= .01)
449: fprintf(file, "%u", intpart);
450:
451: if (periodflag == YES)
452: fprintf(file, ".");
453:
454:
455: if (decsize > 1) { /* if decsize is 1, no decimal part of # field */
456:
457: decpart = (f - intpart) * decsize;
458: if (decpart == 0)
459: while (d--)
460: fprintf(file, "0");
461: else {
462: while (decpart < (decsize / 10)){
463: fprintf(file, "0");
464: decsize = decsize / 10;
465: }
466: fprintf(file, "%u", decpart);
467: }
468: }
469:
470:
471: return(fp);
472:
473: }
474:
475: /*
476: * doformat - determine format and print string
477: */
478:
479: char *doformat(fmtptr, ptr, len, file)
480: char *fmtptr;
481: char *ptr;
482: int len;
483: FILE *file;
484: {
485: register int k, c, d, l;
486: register char *p;
487: register char *fp, *tmp;
488:
489: p = ptr;
490: fp = fmtptr;
491: l = len;
492: c = 1;
493: while (*fp > 0) {
494: if (*fp != '\'') {
495: fprintf(file, "%.1s", fp++);
496: continue;
497: }
498: fp++;
499: switch (*fp) {
500: case 'l':
501: case 'L':
502: tmp = fp + 1;
503: while (*fp == *tmp) {
504: c++;
505: fp++;
506: tmp++;
507: }
508: c = c + 1; /* count the last l or L */
509: fp++; /* move past last l or L */
510: while (c-- > 0 && l-- > 0)
511: fprintf(file, "%.1s", p++);
512: while (c-- >= 0)
513: fprintf(file, " ");
514: return (fp);
515: break;
516: case 'r':
517: case 'R':
518: tmp = fp + 1;
519: while (*fp == *tmp) {
520: c++;
521: fp++;
522: tmp++;
523: }
524: c = c + 1; /* count the last r or R */
525: fp++; /* move past last r or R */
526: if (l >= c) {
527: p = p + (l - c);
528: while (c-- > 0)
529: fprintf(file, "%.1s", p++);
530: }
531: else {
532: for (d = c - l; d > 0; d--)
533: fprintf(file, " ");
534: while (l-- > 0)
535: fprintf(file, "%.1s", p++);
536: }
537: return (fp);
538: break;
539: case 'c':
540: case 'C':
541: tmp = fp + 1;
542: while (*fp == *tmp) {
543: c++;
544: fp++;
545: tmp++;
546: }
547: c = c + 1; /* count the last c or C */
548: fp++; /* move past last c or C */
549: if (l < c) {
550: d = (c - l)/2;
551: k = (c - l) - d;
552:
553: /* this next line is for testing
554: printf( "d = %d c = %d k = %d l = %d, d, c, k, l);*/
555:
556: while (d--)
557: fprintf(file, " ");
558: while (l-- > 0)
559: fprintf(file, "%.1s", p++);
560: while (k-- > 0)
561: fprintf(file, " ");
562: }
563: else {
564: d = (l - c)/2;
565: p = p + d;
566: while (c-- > 0)
567: fprintf(file, "%.1s", p++);
568: }
569: return(fp);
570: break;
571: default:
572: fprintf(file, "'");
573: break;
574:
575: }
576: }
577: return(fp);
578: }
579:
580:
581: /*
582: * prtstmt --- interpret a PRINT statement
583: */
584:
585: prtstmt()
586: {
587: register struct iotab *i;
588:
589: i = getunit(OUTPUT, OUTUNIT);
590: col = i->io_col;
591: print(i->io_ptr);
592: i->io_col = col;
593: }
594:
595:
596: /*
597: * clsstmt --- interpret a CLOSE statement
598: */
599:
600: clsstmt()
601: {
602: register struct iotab *i;
603:
604: i = getunit(0, 0);
605: iocls(i);
606: }
607:
608:
609: /*
610: * flsstmt --- interpret a FLUSH statement
611: */
612:
613: flsstmt()
614: {
615: register struct iotab *i;
616:
617: i = getunit(OUTPUT, OUTUNIT);
618: if (i->io_flag == OUTPUT)
619: fflush(i->io_ptr);
620: }
621:
622:
623: /*
624: * print --- do the work for a PRINT statement
625: */
626:
627: print(file)
628: FILE *file;
629: {
630: register Stkptr s;
631: register int l;
632: int flag;
633: float f;
634:
635: flag = NO;
636: while (!endtest()) {
637: flag = NO;
638: if (*inptr == TAB) { /* tab(expr) */
639: ++inptr;
640: l = fexpr();
641: if (l < 0 || l > 80)
642: l = 1;
643: expectc(RPAR);
644: while (col < l - 8)
645: printstr("\t", 1, file);
646: if (col < l)
647: printstr(" ", l - col, file);
648: }
649: else {
650: expr();
651: s = (Stkptr)stkptr;
652: switch (s->k_type) {
653: case FLOATEXPR:
654: printstr(fprint(popfloat()), MAXSTR, file);
655: break;
656: case STRINGEXPR:
657: pop(ANYTYPE);
658: printstr(s->k_un.k_str.s_ptr,
659: s->k_un.k_str.s_len, file);
660: break;
661: default:
662: badtype();
663: }
664: }
665: switch(*inptr) {
666: case COMMA:
667: ++inptr;
668: printstr("\t", 1, file);
669: if ((col % 16) == 9)
670: printstr("\t", 1, file);
671: flag = YES; /* suppress the NL */
672: break;
673: case ';':
674: ++inptr;
675: flag = YES;
676: break;
677: case '\0':
678: case ELSE:
679: case COLON:
680: break;
681: default:
682: badsyn();
683: }
684: }
685: if (!flag)
686: printstr("\n", 1, file);
687: if (file == stdout)
688: fflush(file);
689: }
690:
691:
692: /*
693: * printstr --- print a string of specified length; update col
694: */
695:
696: printstr(ptr, len, file)
697: char *ptr;
698: FILE *file;
699: {
700: register int c, l;
701: register char *p;
702:
703: l = len;
704: if ((p = ptr) == NULL && l)
705: err("invalid string pointer");
706: while (--l >= 0 && (c = *p++)) {
707: switch (c) {
708: case '\n':
709: col = 1;
710: break;
711: case '\t':
712: col = ((col-1 + 8) & ~07) + 1;
713: break;
714: default:
715: col++;
716: break;
717: }
718: putc(c, file);
719: }
720: }
721:
722:
723: /*
724: * ask --- interpret an INPUT or ASK statement
725: */
726:
727: ask()
728: {
729: register char *v;
730: char *ptr;
731: int len, type;
732: FILE *f;
733:
734: f = getunit(INPUT, INUNIT)->io_ptr;
735: askptr = askline;
736: askline[0] = 0;
737: while (!endtest()) {
738: if (*inptr == QUOTE || *inptr == PRIME) {
739: strconst(*inptr++);
740: popstring(&ptr, &len);
741: printstr(ptr, len, stderr);
742: optional(askdelims);
743: }
744: v = getsvar(&type);
745: optional(askdelims);
746: while (*askptr == ' ')
747: ++askptr;
748: if (*askptr == 0) {
749: if (f == stdin)
750: fputs("? ", stderr);
751: if (readline(askline, f) < 0)
752: err("EOF on input");
753: askptr = askline;
754: }
755: cvtdata(v, type, &askptr);
756: }
757: }
758:
759:
760: /*
761: * morefiledata --- check to see if specified file is at end
762: */
763:
764: morefiledata()
765: {
766: int c;
767: FILE *f;
768:
769: f = getunit(INPUT, INUNIT)->io_ptr;
770: if ((c = getc(f)) != EOF) {
771:
772: /* not at end of file. put character back and return 1 */
773:
774: ungetc(c, f);
775: return(1);
776: }
777: else
778:
779: /* at end of file. return 0 */
780:
781: return(0);
782:
783: }
784: /*
785: * strpop --- pop string from stack; convert to null-terminated format
786: */
787:
788: char *strpop()
789: {
790: static char strtemp[MAXSTR];
791: char *str;
792: int len;
793:
794: popstring(&str, &len);
795: if (len >= MAXSTR - 1)
796: err("string too long");
797: move(len, str, strtemp);
798: strtemp[len] = 0;
799: return(strtemp);
800: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.