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