Annotation of OpenXM/src/k097/d.c, Revision 1.1.1.1
1.1 maekawa 1: /* simple.c, 1996, 1/1 --- 1/5 */
2: #include <stdio.h>
3: #include <ctype.h>
4: #include <setjmp.h>
5: #include <stdlib.h>
6: #include "d.h"
7: #include "simple.tab.h"
8:
9:
10: jmp_buf KCenvOfParser;
11:
12: int DebugMode = 1;
13: extern int K00_verbose;
14:
15: static FILE *outfile = stdout;
16: int Linenumber = 0;
17: objectp Inop = (objectp) NULL; /* Input stream */
18: int Saki = 0; /* Look a head */
19:
20: #define SSIZE 10
21: objectp InopStack[SSIZE];
22: int LinenumberStack[SSIZE];
23: int SakiStack[SSIZE];
24: int Stackp = 0;
25:
26: int Mydebug = 1;
27: int Replace = 0;
28: int Debug2 = 0;
29: /* If you need to check only the lexical analizer,
30: change main2() ---> main()
31: main() ----> main2()
32: */
33:
34: int Interactive = 1;
35:
36: main2(int argc, char *argv[]) {
37: FILE *f;
38: FILE *outf;
39: char name[1024];
40: int n;
41: int i;
42: if (argc < 2) {
43: repl(stdin,stdout);
44: }else{
45: for (i=1; i<argc; i++) {
46: fprintf(stderr,"Input file=%s\n",argv[i]);
47: f = fopen(argv[i],"r");
48: if (f == (FILE *)NULL) {
49: fprintf(stderr,"Error: No file %s\n",argv[i]);
50: exit(10);
51: }
52: strcpy(name,argv[i]);
53: n = strlen(name);
54: name[n] = '.'; name[n+1] = 't'; name[n+2]='\0';
55: outf = fopen(name,"w");
56: if (f == (FILE *)NULL) {
57: fprintf(stderr,"Error: failed to open the file %s\n",name);
58: exit(10);
59: }
60: fprintf(stderr,"Output file=%s\n",name);
61: repl(f,outf);
62: }
63: }
64: }
65:
66: repl(FILE *inFile,FILE *outFile) {
67: int c;
68: int t;
69: Inop = newObject_d();
70: Inop->tag = Sfile;
71: Inop->lc.file = inFile;
72: Inop->rc.sbuf = newStringBuf((char *)NULL);
73:
74: outfile = outFile;
75: while ( (c = KClex()) != EOF) {
76: if (Mydebug) {
77: if ( c > ' ' && c < 0x7f ) {
78: printf("\nKClex returns --- %x [ %c ].",c,c);
79: }else{
80: switch(c) {
81: case ID: printf("\nKClex returns --- ID.[%s]",
82: KClval->lc.str); break;
83: case QUOTE: printf("\nKClex returns --- QUOTE. [%s]",
84: KClval->lc.str); break;
85: case SINGLEQUOTE: printf("\nKClex returns --- SINGLEQUOTE.[%x]",
86: KClval->lc.ival); break;
87: /*case NUMBER: printf("\nKClex returns --- NUMBER.[%d]",
88: KClval->lc.ival); break;*/
89: case NUMBER: printf("\nKClex returns --- NUMBER.[%s]",
90: KClval->lc.str); break;
91:
92: case CLASS: printf("\nKClex returns --- CLASS."); break;
93: case SUPER: printf("\nKClex returns --- SUPER."); break;
94: case OPERATOR: printf("\nKClex returns --- OPERATOR."); break;
95: case FINAL: printf("\nKClex returns --- FINAL."); break;
96: case EXTENDS: printf("\nKClex returns --- EXTENDS."); break;
97: case INCETANCEVARIABLE:
98: printf("\nKClex returns --- INCETANCEVARIABLE."); break;
99: case MODULE: printf("\nKClex returns --- MODULE."); break;
100: case SM1: printf("\nKClex returns --- SM1."); break;
101: case PRINT: printf("\nKClex returns --- PRINT."); break;
102: case LOCAL: printf("\nKClex returns --- LOCAL."); break;
103: case DEF: printf("\nKClex returns --- DEF."); break;
104: case BREAK: printf("\nKClex returns --- BREAK."); break;
105: case CASE: printf("\nKClex returns --- CASE."); break;
106: case CHAR: printf("\nKClex returns --- CHAR."); break;
107: case CONST: printf("\nKClex returns --- CONST."); break;
108: case CONTINUE: printf("\nKClex returns --- CONTINUE."); break;
109: case DEFAULT: printf("\nKClex returns --- DEFAULT."); break;
110: case DO: printf("\nKClex returns --- DO."); break;
111: case DOUBLE: printf("\nKClex returns --- DOUBLE."); break;
112: case ELSE: printf("\nKClex returns --- ELSE."); break;
113: case ENUM: printf("\nKClex returns --- ENUM."); break;
114: case EXTERN: printf("\nKClex returns --- EXTERN."); break;
115: case FLOAT: printf("\nKClex returns --- FLOAT."); break;
116: case FOR: printf("\nKClex returns --- FOR."); break;
117: case GOTO: printf("\nKClex returns --- GOTO."); break;
118: case IF: printf("\nKClex returns --- IF."); break;
119: case INT: printf("\nKClex returns --- INT."); break;
120: case LONG: printf("\nKClex returns --- LONG."); break;
121: case REGISTER: printf("\nKClex returns --- REGISTER."); break;
122: case RETURN: printf("\nKClex returns --- RETURN."); break;
123: case SHORT: printf("\nKClex returns --- SHORT."); break;
124: case SIGNED: printf("\nKClex returns --- SIGNED."); break;
125: case SIZEOF: printf("\nKClex returns --- SIZEOF."); break;
126: case STATIC: printf("\nKClex returns --- STATIC."); break;
127: case STRUCT: printf("\nKClex returns --- SWITCH."); break;
128: case TYPEDEF: printf("\nKClex returns --- TYPEDEF."); break;
129: case UNION: printf("\nKClex returns --- UNION."); break;
130: case UNSIGNED: printf("\nKClex returns --- UNSIGNED."); break;
131: case VOLATILE: printf("\nKClex returns --- VOLATILE."); break;
132: case VOID: printf("\nKClex returns --- VOID."); break;
133: case WHILE: printf("\nKClex returns --- WHILE."); break;
134:
135: case EQUAL: printf("\nKClex returns --- ==."); break;
136: case LESSEQUAL: printf("\nKClex returns --- <=."); break;
137: case LEFTSHIFT: printf("\nKClex returns --- <<."); break;
138: case GREATEREQUAL: printf("\nKClex returns --- >=."); break;
139: case RIGHTSHIFT: printf("\nKClex returns --- >>."); break;
140: case AND: printf("\nKClex returns --- &&."); break;
141: case OR: printf("\nKClex returns --- ||."); break;
142: case NOTEQUAL: printf("\nKClex returns --- !=."); break;
143: case PUT: printf("\nKClex returns --- :=."); break;
144: case INCREMENT: printf("\nKClex returns --- ++."); break;
145: case DECREMENT: printf("\nKClex returns --- --."); break;
146: case MEMBER: printf("\nKClex returns --- ->."); break;
147: case RESIDUEPUT: printf("\nKClex returns --- %=."); break;
148: case NEGATEPUT: printf("\nKClex returns --- ^=."); break;
149: case MULTPUT: printf("\nKClex returns --- *=."); break;
150:
151: default:
152: printf("\nKClex returns --- %x(%d)[%c].",c,c,c);
153: }
154: }
155: printf(" line=%d.\n",Linenumber);
156: }
157: }
158: }
159:
160: /* --------------------------------------------------------- */
161: objectp newObject_d() {
162: objectp obj;
163: obj = (objectp) mymalloc(sizeof(struct Object));
164: if (obj == (objectp) NULL) {
165: fprintf(stderr,"Error: No more memory in newObject_d().\n");
166: exit(10);
167: }
168: obj->tag = Snull;
169: return(obj);
170: }
171:
172: char *newString(int size) {
173: char *str;
174: if (size <= 0) size=1;
175: str = (char *)mymalloc(sizeof(char)*size);
176: if (str == (char *)NULL) {
177: fprintf(stderr,"Error: No more memory in newObject_d().\n");
178: exit(10);
179: }
180: return(str);
181: }
182:
183: void printObject_d(FILE *fp,objectp op)
184: {
185: if (op == (objectp) NULL) {
186: fprintf(fp," <null objectp> ");
187: return;
188: }
189: switch(op->tag) {
190: case Sinteger:
191: fprintf(fp,"%d",op->lc.ival);
192: return;
193: break;
194: case Sstring:
195: fprintf(fp,"%s",op->lc.str);
196: return;
197: break;
198: case CLASSNAME_CONTEXT:
199: K00fprintContext(fp,K00objectToContext(op));
200: return;
201: break;
202: default:
203: fprintf(stderr,"printObject_d(): Sorry. Not implemented.");
204: break;
205: }
206: }
207:
208: void printObjectSymbol(objectp op)
209: {
210: static char tmp[1024];
211: if (op == (objectp) NULL) {
212: printf(" <null objectp> ");
213: return;
214: }
215: switch(op->tag) {
216: case Sinteger:
217: sprintf(tmp,"%d",op->lc.ival);
218: pkkan(tmp);
219: return; break;
220: case Sstring:
221: pkkan(op->lc.str);
222: return; break;
223: default:
224: fprintf(stderr,"(printObjectSymbol(): Sorry. Not implemented.)");
225: break;
226: }
227: }
228:
229: void printTens(objectp op)
230: {
231: static char tmp[1024];
232: int n;
233: int i;
234: if (op == (objectp) NULL) {
235: printf(" <null objectp> ");
236: return;
237: }
238: switch(op->tag) {
239: case Sstring:
240: n = strlen(op->lc.str);
241: if (n > 1022) {
242: fprintf(stderr,"printTens(): Too long string. ");
243: return;
244: }
245: tmp[0] = '1';
246: for (i=1; i<=n; i++) tmp[i] = '0';
247: tmp[n+1] = 0;
248: pkkan(tmp);
249: return; break;
250: default:
251: fprintf(stderr,"(printTens(): Sorry. Not implemented.)");
252: break;
253: }
254: }
255:
256: char *objectSymbolToString(objectp op)
257: {
258: static char tmp[1024];
259: char *r = (char *)NULL;
260: if (op == (objectp) NULL) {
261: printf(" <null objectp> ");
262: return (r);
263: }
264: switch(op->tag) {
265: case Sinteger:
266: sprintf(tmp,"%d",op->lc.ival);
267: r = (char *)GC_malloc(sizeof(char)*(strlen(tmp)+2));
268: strcpy(r,tmp);
269: break;
270: case Sstring:
271: r = (char *)GC_malloc(sizeof(char)*(strlen(op->lc.str)+2));
272: strcpy(r,op->lc.str);
273: break;
274: default:
275: fprintf(stderr,"(objectSymbolToString(): Sorry. Not implemented.)");
276: break;
277: }
278: return(r);
279: }
280:
281: objectp ooAdd(objectp a,objectp b)
282: {
283: objectp r;
284: if (a == (objectp)NULL || b == (objectp)NULL) return((objectp) NULL);
285: if (a->tag == Sinteger && b->tag == Sinteger) {
286: r = newObject_d();
287: r->tag = Sinteger;
288: r->lc.ival = a->lc.ival + b->lc.ival;
289: return(r);
290: }else{
291: fprintf(stderr,"ooAdd(): Sorry. Not implemented.");
292: return((objectp)NULL);
293: }
294: }
295:
296: objectp ooMult(objectp a,objectp b)
297: {
298: objectp r;
299: if (a == (objectp)NULL || b == (objectp)NULL) return((objectp) NULL);
300: if (a->tag == Sinteger && b->tag == Sinteger) {
301: r = newObject_d();
302: r->tag = Sinteger;
303: r->lc.ival = a->lc.ival * b->lc.ival;
304: return(r);
305: }else{
306: fprintf(stderr,"ooMult(): Sorry. Not implemented.");
307: return((objectp)NULL);
308: }
309: }
310:
311: /* ------------------------------------------- */
312:
313: int KClex() {
314: extern int Saki; /* Saki-yomi */
315: int d;
316: int state = 0;
317: int i;
318: static char nametmp[1024];
319: char *name = nametmp;
320: char *str;
321: KClval = (objectp) NULL;
322: while (1) {
323: switch( state ) {
324: case 0:
325: /* printf(" <%x> ",Saki); */
326: if (Saki == EOF) {
327: return(Saki);
328: }
329: if (Saki <= ' ') {
330: if (Saki == '\n') ++Linenumber;
331: if (Replace) putchar0(Saki);
332: Saki = fsgetc(Inop); break;
333: }
334: if ( Saki == '\"' ) {
335: str = readstring();
336: /* if (Mydebug) printf("[string: %s]",str); */
337:
338: KClval = newObject_d();
339: KClval->tag = Sstring;
340: KClval->lc.str = newString(strlen(str)+1);
341: strcpy(KClval->lc.str,str);
342:
343: Saki = fsgetc(Inop);
344: return(QUOTE);
345: break;
346: }
347: if (Saki == '\'' ) {
348: d = readchar();
349: Saki = fsgetc(Inop);
350:
351: KClval = newObject_d();
352: KClval->tag = Sinteger;
353: KClval->lc.ival = d;
354:
355: return(SINGLEQUOTE);
356: }
357: /* single */
358: if ( Saki == '(' || Saki == ')' || Saki == ';' ||
359: Saki == '{' || Saki == '}' || Saki == ',' ||
360: Saki == '[' || Saki == ']' || Saki == '~' ||
361: Saki == '?' || Saki == '.') {
362: d = Saki; Saki = fsgetc(Inop);
363: if (Replace) putchar0(d);
364: return(d);
365: }
366:
367: /* single or combination =, == */
368: if ( Saki == '=') {
369: state = 51; Saki = fsgetc(Inop); break;
370: } else if ( Saki == '<' ) {
371: state = 52; Saki = fsgetc(Inop); break;
372: } else if ( Saki == '>' ) {
373: state = 53; Saki = fsgetc(Inop); break;
374: } else if ( Saki == '/' ) {
375: state = 54; Saki = fsgetc(Inop); break;
376: } else if ( Saki == '&' ) {
377: state = 55; Saki = fsgetc(Inop); break;
378: } else if ( Saki == '|' ) {
379: state = 56; Saki = fsgetc(Inop); break;
380: } else if ( Saki == '!' ) {
381: state = 57; Saki = fsgetc(Inop); break;
382: } else if ( Saki == ':' ) {
383: state = 58; Saki = fsgetc(Inop); break;
384: } else if ( Saki == '+' ) {
385: state = 59; Saki = fsgetc(Inop); break;
386: } else if ( Saki == '-' ) {
387: state = 60; Saki = fsgetc(Inop); break;
388: } else if ( Saki == '%' ) {
389: state = 61; Saki = fsgetc(Inop); break;
390: } else if ( Saki == '^' ) {
391: state = 62; Saki = fsgetc(Inop); break;
392: } else if ( Saki == '*' ) {
393: state = 63; Saki = fsgetc(Inop); break;
394: } else ;
395:
396:
397: /* else : Identifier or function names. */
398: name[0] = Saki; i=1; name[i] = '\0';
399: Saki = fsgetc(Inop);
400: if (isdigit(name[0])) {
401: /*while (isdigit(Saki) || isalpha(Saki) || Saki=='.') */
402: while (isdigit(Saki) || isalpha(Saki)) {
403: name[i++] = Saki; name[i] = '\0';
404: Saki = fsgetc(Inop);
405: }
406: }else{
407: while (isdigit(Saki) || isalpha(Saki) || (Saki=='_') ||
408: ( Saki>= 256)) {
409: name[i++] = Saki; name[i] = '\0';
410: Saki = fsgetc(Inop);
411: }
412: }
413: /*if (Mydebug) printf("identifier string=[%s]",name);*/
414: if (isdigit(name[0])) {
415: /****************************
416: /**case : machine integer.
417: KClval = newObject_d();
418: KClval->tag = Sinteger;
419: sscanf(name,"%d",&(KClval->lc.ival));*************/
420: /* Other cases. */
421: KClval = newObject_d();
422: KClval->tag = Sstring;
423: KClval->lc.str = newString(strlen(name)+1);
424: strcpy(KClval->lc.str,name);
425: return(NUMBER);
426: break;
427: } /* else : Identifier case.*/
428:
429: if (d = isReserved(name)) {
430: if (Replace) printf0(name);
431: return(d);
432: } else {
433: if (Replace) {
434: if (shouldReplace(name))
435: printf1(name); /* do your own replacement in printf1*/
436: else
437: printf0(name);
438: }
439: KClval = newObject_d();
440: KClval->tag = Sstring;
441: KClval->lc.str = newString(strlen(name)+1);
442: strcpy(KClval->lc.str,name);
443: return(ID);
444: }
445: break;
446:
447: case 51:
448: if (Replace) putchar0('=');
449: if ( Saki == '=') {
450: if (Replace) putchar0('=');
451: Saki = fsgetc(Inop);state = 0;return(EQUAL); /* == */
452: }else{
453: state = 0;return('=');
454: }
455: break;
456: case 52: /* 52 --- 60 tmporary return values */
457: if (Replace) putchar0('<');
458: if ( Saki == '=') {
459: if (Replace) putchar0('=');
460: Saki = fsgetc(Inop);state = 0;return(LESSEQUAL); /* <= */
461: } else if ( Saki == '<') {
462: if (Replace) putchar0('<');
463: Saki = fsgetc(Inop);state = 0;return(LEFTSHIFT); /* << */
464: }else{
465: state = 0;return('<');
466: }
467: break;
468: case 53:
469: if (Replace) putchar0('>');
470: if ( Saki == '=') {
471: if (Replace) putchar0('=');
472: Saki = fsgetc(Inop);state = 0;return(GREATEREQUAL); /* >= */
473: } else if ( Saki == '>') {
474: if (Replace) putchar0('>');
475: Saki = fsgetc(Inop);state = 0;return(RIGHTSHIFT); /* >> */
476: }else{
477: state = 0;return('>');
478: }
479: break;
480: case 54:
481: if ( Saki == '*') {
482: readcomment();
483: Saki = fsgetc(Inop);state = 0;break; /* clike-comment */
484: }else{
485: if (Replace) putchar0('/');
486: state = 0;return('/');
487: }
488: break;
489: case 55:
490: if (Replace) putchar0('&');
491: if ( Saki == '&') {
492: if (Replace) putchar0('&');
493: Saki = fsgetc(Inop);state = 0;return(AND); /* && */
494: }else{
495: state = 0;return('&');
496: }
497: break;
498: case 56:
499: if (Replace) putchar0('|');
500: if ( Saki == '|') {
501: if (Replace) putchar0('|');
502: Saki = fsgetc(Inop);state = 0;return(OR); /* || */
503: }else{
504: state = 0;return('|');
505: }
506: break;
507: case 57:
508: if (Replace) putchar0('!');
509: if ( Saki == '=') {
510: if (Replace) putchar0('=');
511: Saki = fsgetc(Inop);state = 0;return(NOTEQUAL); /* != */
512: }else{
513: state = 0;return('!');
514: }
515: break;
516: case 58:
517: if (Replace) putchar0(':');
518: if ( Saki == '=') {
519: if (Replace) putchar0('=');
520: Saki = fsgetc(Inop);state = 0;return(PUT); /* := */
521: }else{
522: state = 0;return(':');
523: }
524: break;
525: case 59:
526: if (Replace) putchar0('+');
527: if ( Saki == '+') {
528: if (Replace) putchar0('+');
529: Saki = fsgetc(Inop);state = 0;return(INCREMENT); /* ++ */
530: }else{
531: state = 0;return('+');
532: }
533: break;
534: case 60:
535: if (Replace) putchar0('-');
536: if ( Saki == '-') {
537: if (Replace) putchar0('-');
538: Saki = fsgetc(Inop);state = 0;return(DECREMENT); /* -- */
539: }else if (Saki == '>') {
540: if (Replace) putchar0('>');
541: Saki = fsgetc(Inop);state = 0;return(MEMBER); /* -> */
542: }else{
543: state = 0;return('-');
544: }
545: break;
546: case 61:
547: if (Replace) putchar0('%');
548: if ( Saki == '=') {
549: if (Replace) putchar0('=');
550: Saki = fsgetc(Inop);state = 0;return(RESIDUEPUT); /* %= */
551: }else{
552: state = 0;return('%');
553: }
554: break;
555: case 62:
556: if (Replace) putchar0('^');
557: if ( Saki == '=') {
558: if (Replace) putchar0('=');
559: Saki = fsgetc(Inop);state = 0;return(NEGATEPUT); /* ^= */
560: }else{
561: state = 0;return('^');
562: }
563: break;
564: case 63:
565: if (Replace) putchar0('*');
566: if ( Saki == '=') {
567: if (Replace) putchar0('=');
568: Saki = fsgetc(Inop);state = 0;return(MULTPUT); /* *= */
569: }else{
570: state = 0;return('*');
571: }
572: break;
573:
574:
575: default:
576: fprintf(stderr,"%d: Error in KClex().\n",Linenumber);
577: }
578: }
579:
580: }
581:
582: KCerror(char *s) /* You need this function. Otherwise, you get core. */
583: {
584: K00recoverFromError();
585: fprintf(stderr,"\nSyntax Error in the line %d:%s\n",Linenumber,s);
586: showStringBuff(Inop); return ;
587: longjmp(KCenvOfParser,2);
588: exit(1);
589: }
590:
591: readcomment() {
592: int c;
593: while (1) {
594: c = fsgetc(Inop);
595: if (c == EOF) {
596: fprintf(stderr,"%d: Unexpected end of file in a comment.\n",Linenumber);
597: fsungetc(c,Inop); /* should change */
598: return;
599: }
600: if (c == '*') {
601: c = fsgetc(Inop);
602: if (c == '/') return;
603: }
604: }
605: }
606:
607:
608: char *readstring() {
609: static char strtmp[1024]; /* temporary */
610: static int size = 1024;
611: static char *str = strtmp;
612: int i=0;
613: int c;
614: static char *strwork;
615:
616:
617: if (Replace) putchar0('\"'); /* output " */
618: while (1) {
619: c = fsgetc(Inop);
620: if (Replace) putchar0(c);
621: if (c == '\"') {
622: str[i] = '\0';
623: return(str);
624: }
625: if (c == EOF) {
626: fprintf(stderr,"%d: Unexpected end of file in the string.\n",Linenumber);
627: fsungetc(c,Inop); /* should change */
628: str[i]= '\0';
629: return(str);
630: }
631: if (c == '\\') {
632: c = fsgetc(Inop);
633: if (Replace) {
634: putchar0(c);
635: }
636: if (c == EOF) {
637: fprintf(stderr,"%d: Unexpected end of file in the escape sequence.\n",Linenumber);
638: fsungetc(c,Inop); /* should change */
639: str[i]= '\0';
640: return(str);
641: }
642: }
643:
644: str[i++] = c;
645: if (i >= size-10) {
646: size = size*2;
647: strwork = newString(size);
648: strcpy(strwork,str);
649: str = strwork;
650: }
651: }
652: }
653:
654:
655: readchar() {
656: int c;
657: if (Replace) putchar0('\'');
658: c = fsgetc(Inop); /* 'c.' '\.c' */
659: if (Replace) putchar0(c);
660: if ( c == '\\') {
661: c = fsgetc(Inop); /* '\c.' */
662: if (Replace) putchar0(c);
663: if (c == EOF) {
664: fprintf(stderr,"%d: Unexpected end of file in the escape sequence.\n",Linenumber);
665: fsungetc(c,Inop); /* should change */
666: return(-1);
667: }
668: if (fsgetc(Inop) != '\'') {
669: fprintf(stderr,"%d: Error in single quote string (escape seq)\n",Linenumber);
670: return(c);
671: }
672: if (Replace) putchar0('\'');
673: return(c);
674: }
675:
676: if (fsgetc(Inop) != '\'') {
677: fprintf(stderr,"%d: Error in single quote string\n",Linenumber);
678: }
679: if (Replace) putchar0('\'');
680: return(c);
681: }
682:
683: putchar0(c)
684: int c;
685: {
686: if (c > 0) fputc(c,outfile);
687: }
688:
689: printf0(s)
690: char *s;
691: {
692: int i = 0;
693: while (s[i] != '\0') putchar0(s[i++]);
694: }
695:
696: printf1(s)
697: char *s;
698: {
699: int i = 0;
700: /* putchar0('K'); */ /* do your own replacement */
701: while (s[i] != '\0') putchar0(s[i++]);
702: }
703:
704: isReserved(s)
705: char *s;
706: {
707: char *r[] = {"auto","break","case","char","const","continue",
708: "default","do","double","else","enum","extern",
709: "float","for","goto","if","int","long","register",
710: "return","short","signed","sizeof","static","struct",
711: "switch","typedef","union","unsigned","volatile",
712: "void","while",
713: "print","module","local","def","sm1","load","Test","special",
714: "class","super","operator","final","extends",
715: "incetanceVariable","this","new","startOfThisClass",
716: "sizeOfThisClass","PSfor","OutputPrompt"};
717:
718: int val[]= {AUTO, BREAK, CASE, CHAR, CONST, CONTINUE, DEFAULT, DO, DOUBLE,
719: ELSE, ENUM,
720: EXTERN, FLOAT, FOR, GOTO, IF, INT, LONG, REGISTER,
721: RETURN, SHORT, SIGNED, SIZEOF, STATIC, STRUCT, SWITCH,
722: TYPEDEF, UNION,
723: UNSIGNED, VOLATILE, VOID, WHILE,
724: PRINT,MODULE,LOCAL,DEF,SM1,LOAD,TEST,SPECIAL,
725: CLASS,SUPER,OPERATOR,FINAL,EXTENDS,INCETANCEVARIABLE,
726: THIS, NEW, STARTOFTHISCLASS, SIZEOFTHISCLASS,PSFOR,PROMPT};
727: int n = 52; /* Length of the list above */
728: /* You have to change simple.y, too. */
729:
730: int i;
731: for (i=0; i<n; i++) {
732: if (strcmp(r[i],s) == 0) {
733: if (Debug2) printf("\nReserved word: %s ---\n",s);
734: return(val[i]);
735: }
736: }
737: return(0);
738:
739: }
740:
741: shouldReplace(s)
742: char *s;
743: {
744: char *r[] = {"dummy"};
745: int n = 1;
746: int i;
747: for (i=0; i<n; i++) {
748: if (strcmp(r[i],s) == 0) {
749: /* printf("\n--- %s ---\n",s); */
750: return(1);
751: }
752: }
753: return(1); /* change to 0. */
754: }
755:
756: /* --------------------------- protection of symbols ------------------ */
757: #include "Stable/sm1symbol.h"
758: int ips(objectp op) {
759: return(isProtectedSymbol(op->lc.str));
760: }
761: int isProtectedSymbol(char *s)
762: {
763:
764: static char **sn = SymbolTableOfsm1;
765: int size = SizeOfSymbolTableOfsm1;
766: int start = 0;
767: int end = size-1;
768: int r;
769:
770: while (1) {
771: /* binary search */
772: if (start>end) break;
773: r = strcmp(s,sn[start+(end-start)/2]);
774: if (r == 0) {
775: fprintf(stderr,"Warning: Protected symbol %s is used as user variable.\n",s);
776: return(0);
777: }
778: if (r > 0) {
779: start = start + (end-start)/2 + 1;
780: } else if ( r < 0) {
781: end = start + (end-start)/2-1;
782: }
783: }
784: return(0);
785: }
786:
787: /* ------------------ read from file ------------------- */
788: struct stringBuf *newStringBuf(char *initstr)
789: {
790: #define INITSIZE 1024
791: struct stringBuf *stringBuf;
792: int limit;
793: stringBuf = mymalloc(sizeof(struct stringBuf));
794: if (stringBuf == (struct stringBuf *)NULL) {
795: fprintf(stderr,"No memory\n"); exit(10);
796: }
797: if (initstr == (char *)NULL) limit = INITSIZE;
798: else limit = strlen(initstr)+11;
799: stringBuf->str = mymalloc(sizeof(char)*limit);
800: stringBuf->ptr = 0;
801: stringBuf->limit = limit;
802: if (stringBuf->str == (char *)NULL) {
803: fprintf(stderr,"No memory\n"); exit(10);
804: }
805: if (initstr != (char *)NULL) {
806: strcpy(stringBuf->str,initstr);
807: } else (stringBuf->str)[0] = '\0';
808: return(stringBuf);
809: }
810:
811: void doublingStringBuf(struct stringBuf *obuf)
812: {
813: char *t;
814: t = mymalloc(sizeof(char)*(obuf->limit)*2);
815: if (t == (char *)NULL) {
816: fprintf(stderr,"No memory\n"); exit(10);
817: }
818: strcpy(t,obuf->str);
819: obuf->str = t;
820: obuf->limit *= 2;
821: }
822:
823: void readlineFromFile(FILE *fp,struct stringBuf *obuf)
824: {
825: int c;
826: obuf->ptr = 0; (obuf->str)[obuf->ptr]='\0';
827: while (1) {
828: c = fgetc(fp);
829: /* for debug.
830: if (c<' ') printf(" %x(%x) ",c,(int) fp); else printf(" <%c>(%x) ",c,(int) fp); fflush(NULL);
831: if (c == EOF) {
832: printf("Stackp=%d ",Stackp);
833: printf("File=%x\n",(int) fp); fflush(NULL);
834: }
835: */
836: if (c == EOF) {
837: (obuf->str)[obuf->ptr]='\0';
838: obuf->ptr = 0;
839: return;
840: }
841: (obuf->str)[(obuf->ptr)++] = c;
842: (obuf->str)[obuf->ptr] = '\0';
843: if (c == '\n') {
844: obuf->ptr = 0;
845: return;
846: }
847: if (obuf->ptr > obuf->limit - 5) doublingStringBuf(obuf);
848: }
849: }
850:
851: static int popFile() {
852: if (Inop->tag == Sfile) {
853: if (Inop->lc.file != stdin) {
854: fclose(Inop->lc.file);
855: /* sendKan(10); output In[n]= */
856: }
857: }
858: /* fprintf(stderr,"popFile(), Stackp=%d\n",Stackp); fflush(NULL); */
859: if (Stackp <= 1) return(EOF);
860: Stackp--;
861: Linenumber = LinenumberStack[Stackp];
862: Inop = InopStack[Stackp];
863: if (Inop == (objectp) NULL) {
864: fprintf(stderr,"popFile: Inop==NULL\n"); fflush(stdout); /* was fflush(NULL); */
865: return(EOF);
866: }
867: if (Inop->tag == Sfile) {
868: if (Inop->lc.file != stdin) {
869: Interactive = 0;
870: }else{
871: Interactive = 1;
872: }
873: }
874: /* Saki = SakiStack[Stackp]; */
875: Saki = '\n';
876: return(Saki);
877: }
878:
879: int fsgetc(objectp op) {
880: struct stringBuf *obuf;
881: char *str;
882: int ptr;
883: if (op->tag == Sfile) {
884: /* return(fgetc(op->lc.file)); non-buffered reading */
885: obuf = op->rc.sbuf;
886: str = obuf->str;
887: ptr = obuf->ptr;
888: if (str[ptr] == '\0') {
889: readlineFromFile(op->lc.file,obuf);
890: str = obuf->str;
891: ptr = obuf->ptr;
892: }
893: if (str[ptr] == '\0') {
894: return(popFile());
895: } else return( str[(obuf->ptr)++] );
896: }else if (op->tag == Slist) {
897: obuf = op->lc.sbuf;
898: str = obuf->str;
899: ptr = obuf->ptr;
900: if (str[ptr] == '\0') {
901: return(popFile());
902: } else return(str[(obuf->ptr)++]);
903: }else {
904: fprintf(stderr,"unknown tag?\n");
905: }
906: return(EOF);
907: }
908:
909: int fsungetc(int c,objectp op) {
910: fprintf(stderr,"Sorry. fsungetc has not yet implemented.\n");
911: }
912:
913: void clearInop() {
914: Saki = '\0';
915: Inop = (objectp) NULL;
916: Stackp = 0;
917: }
918:
919: static void pushOld() {
920: LinenumberStack[Stackp]=Linenumber;
921: InopStack[Stackp] = Inop;
922: SakiStack[Stackp] = Saki;
923: /* fprintf(stderr,"pushOld, Stackp=%d, fp=%x\n",Stackp,(int)(Inop->lc.file)); fflush(NULL); */
924: Stackp++;
925: if (Stackp >= SSIZE) {
926: fprintf(stderr,"Stackp overflow.\n");
927: exit(10);
928: }
929: }
930:
931: void parseAfile(FILE *fp) {
932: int c;
933:
934: pushOld();
935:
936: Linenumber = 0;
937: Inop = newObject_d();
938: Inop->tag = Sfile;
939: Inop->lc.file = fp;
940: Inop->rc.sbuf = newStringBuf((char *)NULL);
941: if (fp != stdin) {
942: Interactive = 0;
943: }
944:
945: }
946:
947: void parseAstring(char *s)
948: {
949: int c;
950: int prevLineNumber;
951: objectp prevInop;
952: int prevSaki;
953:
954: pushOld();
955:
956: Linenumber = 0;
957: Inop = newObject_d();
958: Inop->tag = Slist;
959: Inop->lc.sbuf = newStringBuf(s);
960:
961: }
962:
963: void loadFile(objectp op)
964: {
965: FILE *fp;
966: char fname[1024];
967: if (op->tag != Sstring) {
968: fprintf(stderr,"File name must be given as an argment of load.\n");
969: return;
970: }
971: if (strlen(op->lc.str) > 1000) {
972: fprintf(stderr,"Too long file name.\n");
973: return;
974: }
975: fp = fopen(op->lc.str,"r");
976: if (fp == (FILE *)NULL) {
977: strcpy(fname,getLOAD_K_PATH());
978: strcat(fname,op->lc.str);
979: fp = fopen(fname,"r");
980: if (fp == (FILE *)NULL) {
981: strcpy(fname,LOAD_K_PATH);
982: strcat(fname,op->lc.str);
983: fp = fopen(fname,"r");
984: if (fp == (FILE *)NULL) {
985: fprintf(stderr,"Cannot open the file <<%s>> for loading in the current directory nor the library directories %s and %s.\n",op->lc.str,getLOAD_K_PATH(),LOAD_K_PATH);
986: return;
987: }
988: }
989: }
990: if (K00_verbose) fprintf(stderr,"Reading the file <<%s>>... ",op->lc.str);
991: parseAfile(fp);
992: if (K00_verbose) fprintf(stderr,"\nClosed the file <<%s>>.\n",op->lc.str);
993: }
994:
995: void loadFileWithCpp(objectp op)
996: {
997: FILE *fp;
998: char fname[1024];
999: objectp ob;
1000: if (op->tag != Sstring) {
1001: fprintf(stderr,"File name must be given as an argment of load.\n");
1002: return;
1003: }
1004: if (strlen(op->lc.str) > 900) {
1005: fprintf(stderr,"Too long file name.\n");
1006: return;
1007: }
1008: system("/bin/rm -f k00.cppload.tmp");
1009: strcpy(fname,"/lib/cpp -P -lang-c++ <");
1010: strcat(fname,op->lc.str);
1011: strcat(fname," >k00.cppload.tmp");
1012: system(fname);
1013: ob = newObject_d();
1014: ob->tag = Sstring;
1015: ob->lc.str = "k00.cppload.tmp";
1016: loadFile(ob);
1017: }
1018:
1019: void showStringBuff(objectp op)
1020: {
1021: struct stringBuf *sb;
1022: int i;
1023: int start;
1024: int ptr;
1025: if (op->tag == Sfile) {
1026: sb = op->rc.sbuf;
1027: }else if (op->tag == Slist) {
1028: sb = op->lc.sbuf;
1029: }else fprintf(stderr,"Unknown tag.\n");
1030: ptr = sb->ptr;
1031: if (K00_verbose) {
1032: fprintf(stderr,"stringBuff ptr = %d, ",ptr);
1033: fprintf(stderr,"sb[ptr] = %x,%d",(sb->str)[ptr],(sb->str)[ptr]);
1034: fprintf(stderr,"Saki(yomi) = %x \n",Saki,Saki);
1035: }
1036: if (ptr == 0 && Saki == -1) {
1037: fprintf(stderr," ; was expected.\n");
1038: }
1039: start = (ptr-20<0?0:ptr-20);
1040: fprintf(stderr,"The error occured when the system is reading the line: ");
1041: for (i=start; i<ptr+20 && (sb->str)[i] >= ' '; i++) {
1042: fprintf(stderr,"%c",(sb->str)[i]);
1043: if (i==ptr-1) fprintf(stderr,"<<error>> \n");
1044: }
1045: fprintf(stderr,"\n");
1046: }
1047:
1048: char *getLOAD_K_PATH() {
1049: char *p;
1050: char *p2;
1051: p = getenv("LOAD_K_PATH");
1052: if (p == NULL) {
1053: return("/usr/local/lib/kxx97/yacc/");
1054: }else{
1055: if (strlen(p) == 0) return(p);
1056: if (p[strlen(p)-1] == '/') return(p);
1057: /* Add / */
1058: p2 = (char *) malloc(sizeof(char)*(strlen(p)+3));
1059: if (p2 == NULL) { fprintf(stderr,"No more memory.\n"); exit(10); }
1060: strcpy(p2,p); strcat(p2,"/");
1061: return(p2);
1062: }
1063: }
1064:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to d.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / k097