Annotation of OpenXM/src/kan96xx/Kan/scanner.c, Revision 1.5
1.5 ! takayama 1: /*$OpenXM: OpenXM/src/kan96xx/Kan/scanner.c,v 1.4 2001/05/04 01:06:25 takayama Exp $*/
1.1 maekawa 2: /* scanner.c (SM StackMachine) */
3: /* export: struct tokens getokenSM(actionType kind,char *str);
4: scanner.c is used to get tokens from streams.
5: files: none
6: */
7: #include <stdio.h>
8: #include "datatype.h"
9: #include "stackm.h"
10: struct tokens lookupTokens(struct tokens t);
11: int isLiteral(char *s);
12: struct object lookupLiteralString(char *s);
13: char *getLOAD_SM1_PATH();
14: /**************** defined in stackm.h ****************************
15: typedef enum {INIT,GET,PUT,OPEN} actionType;
16:
17: struct tokens{
18: char *token;
19: int kind;
20: };
21:
22:
23: #define ID 2
24: #define DOLLAR 3 strings enclosed by dollar sign
25: #define EXECUTABLE_STRING 4 strings enclosed by {}
26: #define EXECUTABLE_ARRAY 8 Don't set it in this file.
27: ******************************************************************/
28:
29:
30: /******* declaration-part of lexical analizer ********************/
31: /* #define mygetchar() getSM() */
32: /* to use getSM() ( input from StringSM ),
33: setup StringSM;
34: getokenSM(INIT);
35: */
36: /* to use getchar(),
37: getokenSM(INIT);
38: */
39:
40:
41:
1.3 takayama 42: FILE *BaseFp = NULL; /* Initialized to stdin in stackmachine_init().
43: file pointer of the first file. */
1.1 maekawa 44:
45: int EchoInScanner = 0; /* echo in scanner */
46:
47: #define BUF0LIMIT 20000
48: static char *StringSM;
49: static int StrpSM = 0;
50: static char BufSMorg[BUF0LIMIT];
51: static char *BufSM = BufSMorg;
52: static int Buf0limit = BUF0LIMIT;
53: static int ExistSM = 0;
54: static int TypeSM = ID;
55:
56: #define FILESTACK_LIMIT 10
57: static FILE * Cfp; /* current input file pointer */
58: static FILE * FileStack[FILESTACK_LIMIT];
59: static int FileStackP = 0;
60: /**************** end of declaration part of lexical analizer ******/
61:
62: static int getSM();
63: static putSM();
64: static struct tokens flushSM();
65: static isSpaceSM();
66: static isDollarSM();
67: static isBraceSM();
68: static isKakkoSM();
69: static isSymbolSM();
70: static mygetchar();
71: static myungetchar();
72:
73:
74: /*
75: static mygetchar()
76: {
77: return( getc(Cfp) );
78: }
79: */
80:
81: static mygetchar()
82: { int c;
1.4 takayama 83: if (EchoInScanner) {
84: c = getc(Cfp);
85: if (c==EOF) {
86: printf("\n%% EOF of file %x\n",(int) Cfp);
87: }else{
88: printf("%c",c);
89: }
90: return( c );
91: }else{
92: return( getc(Cfp) );
93: }
1.1 maekawa 94: }
95:
96:
97: static myungetchar(c)
1.4 takayama 98: int c;
1.1 maekawa 99: {
100: return( ungetc(c,Cfp) );
101: }
102:
103: /**************** code part of lexical analizer ********************/
104: static int getSM()
1.4 takayama 105: /* get a letter from StringSM */
1.1 maekawa 106: {
107: int c;
108: c = StringSM[StrpSM++];
109: if (c == '\0') {
110: StrpSM--;return(EOF);
111: } else return(c);
112: }
113:
114: static putSM(c)
1.4 takayama 115: int c;
116: /* put a letter on BufSM */
1.1 maekawa 117: {
118: char *new; int i;
119: BufSM[ExistSM++] = ((c=='\n')? ' ' : c);
120: if (ExistSM >= Buf0limit-1) {
121: new = (char *) sGC_malloc(sizeof(char *)*Buf0limit*2) ;
122: if (new == (char *)NULL) {
123: fprintf(stderr,"No more memory in parserpass0.c\n");
124: exit(18);
125: }
126: fprintf(stderr,"\nSystem Message: Increasing BufSM to %d in scanner.c\n",Buf0limit*2);
127: for (i=0; i<Buf0limit; i++) {
128: new[i] = BufSM[i];
129: }
130: BufSM = new; Buf0limit *= 2;
131: }
132: }
133:
134: static struct tokens flushSM()
135: {
136: char *token;
137: struct tokens r;
138: if (ExistSM<=0) {
139: fprintf(stderr,"\n flushSM() is called without data. Don't use the empty string $$. \n");
140: r.token = (char *)NULL; r.kind = -10; /* -1 ==> -10 */
141: return(r);
142: }
143: BufSM[ExistSM] = '\0';
144: ExistSM = 0;
145: token = (char *)sGC_malloc((strlen(BufSM)+1)*sizeof(char));
146: strcpy(token,BufSM);
147: r.token = token;
148: r.kind = TypeSM;
149: if (r.kind == ID) {
150: if (isLiteral(r.token)) {
151: r.object = lookupLiteralString(r.token);
152: }else{
153: r = lookupTokens(r); /* Compute hashing values */
154: }
155: }
156: return(r);
157: }
158:
159: static isSpaceSM(c)
1.4 takayama 160: int c;
1.1 maekawa 161: {
1.5 ! takayama 162: static int prev=0;
! 163: if ((c == ',') && (prev == ',')) fprintf(stderr,"Warning! ,, is found.\n");
! 164: prev = c;
! 165:
! 166: if (((c <= ' ') || c == ',') && (c!= EOF)) return(1);
1.1 maekawa 167: else return(0);
168: }
169:
170: static isDollarSM(c)
1.4 takayama 171: int c;
1.1 maekawa 172: {
173: if (c == '$') return(1);
174: else return(0);
175: }
176:
177: static isBraceSM(c)
1.4 takayama 178: int c;
1.1 maekawa 179: {
180: if (c == '{') return(1);
181: else return(0);
182: }
183:
184: static isKakkoSM(c)
1.4 takayama 185: int c;
1.1 maekawa 186: {
187: if (c == '(') return(1);
188: else return(0);
189: }
190:
191: static isSymbolSM(c)
1.4 takayama 192: int c;
1.1 maekawa 193: {
194: if ((c == '{') ||
195: (c == '}') ||
196: (c == '[') ||
197: (c == ']') ||
198: (c == '(') ||
199: (c == ')'))
200: return(1);
201: else return(0);
202: }
203:
204: struct tokens getokenSM(kind,str)
1.4 takayama 205: actionType kind;
206: char *str;
1.1 maekawa 207: {
208: static int c;
209: static struct tokens rnull;
210: int level;
211: char fname[1024];
212:
213: if (kind == INIT) {
214: StrpSM = 0;
215: ExistSM = 0;
216:
217: Cfp = BaseFp; /* set the file name to BaseFp */
218: FileStackP = 0; /* Clear the file stack */
219:
220: myungetchar('\n'); /* dummy */
221: c = mygetchar(); /* Notice that you need at least on input to return
1.4 takayama 222: from the getokenSM(INIT); ^^^^^^^^*/
1.1 maekawa 223: rnull.token = (char *)NULL; rnull.kind = -1;
224: return(rnull);
225: }
226:
227: if (kind == OPEN) {
228: rnull.token = (char *)NULL; rnull.kind = -2;
229: /* -2: suceeded, -3: fail */
230: myungetchar(c);
231: FileStack[FileStackP++] = Cfp; /* push the current file */
232: if (FileStackP >= FILESTACK_LIMIT) {
233: fprintf(stderr,"\nError: I cannot open more than %d files.\n",FILESTACK_LIMIT);
234: FileStackP--;
235: c = mygetchar();
236: rnull.kind = -3;
237: return(rnull); /* error */
238: }else {
239: Cfp = fopen(str,"r");
240: if (EchoInScanner)
1.4 takayama 241: printf("\n%% I open the file %s.\n",str);
1.1 maekawa 242: if (Cfp == (FILE *)NULL) {
243:
1.4 takayama 244: strcpy(fname,getLOAD_SM1_PATH());
245: strcat(fname,str);
246: Cfp = fopen(fname,"r");
247: if (Cfp == (FILE *)NULL) {
248: strcpy(fname,LOAD_SM1_PATH);
249: strcat(fname,str);
250: Cfp = fopen(fname,"r");
251: if (Cfp == (FILE *)NULL) {
252: fprintf(stderr,"Warning: Cannot open the file <<%s>> for loading in the current directory nor the library directories %s and %s.\n",str,getLOAD_SM1_PATH(),LOAD_SM1_PATH);
253:
254: Cfp = FileStack[--FileStackP];
255: fprintf(stderr,"\nWarning: I could not open the file %s\n",str);
256: c = mygetchar();
257: rnull.kind = -3;
258: return(rnull); /* error */
259: }else{
260: c = mygetchar(); /* input from the new file */
261: return(rnull);
262: }
263: }else{
264: c = mygetchar(); /* input from the new file */
265: return(rnull);
266: }
1.1 maekawa 267: }else{
1.4 takayama 268: c = mygetchar(); /* input from the new file */
269: return(rnull);
1.1 maekawa 270: }
271: }
272: }
273:
274: for (;;) {
275: TypeSM = ID;
276: if (c == EOF) {
277: if (FileStackP <= 0) {
1.4 takayama 278: if (ExistSM) return(flushSM());
279: else return(rnull);
1.1 maekawa 280: }else { /* return to the previous file */
1.4 takayama 281: fclose(Cfp); /* close the file */
282: Cfp = FileStack[--FileStackP];
283: c = mygetchar(Cfp);
1.1 maekawa 284: }
285: } else if (isSpaceSM(c)) {
286: if (ExistSM) {
1.4 takayama 287: c = mygetchar(); return(flushSM());
1.1 maekawa 288: }else {
1.4 takayama 289: while (isSpaceSM(c=mygetchar())) ;
1.1 maekawa 290: }
291: } else if (isDollarSM(c)) { /* output contents in dollar signs. */
292: if (ExistSM) return(flushSM());
293: else {
1.4 takayama 294: c = mygetchar();
295: while ((c != EOF) && (c != '$')) {
296: putSM(c);
297: c = mygetchar();
298: }
299: if (c=='$') c=mygetchar();
300: TypeSM = DOLLAR;
301: return(flushSM());
1.1 maekawa 302: }
303: } else if (isBraceSM(c)) { /* output contents in { } */
304: /* { { } } */
305: level = 0;
306: if (ExistSM) return(flushSM());
307: else {
1.4 takayama 308: c = mygetchar();
309: while (1) {
310: if (c == '%') { /* skip the comment in the brace. */
311: while (((c=mygetchar()) != '\n') && (c != EOF)) ;
312: }
313: if (c == EOF) break;
314: if ((c == '}') && (level <= 0)) break;
315: if ( c == '{') ++level;
316: if ( c == '}') --level;
317: putSM(c);
318: c = mygetchar();
319: }
320: if (c=='}') c=mygetchar();
321: TypeSM = EXECUTABLE_STRING;
322: return(flushSM());
1.1 maekawa 323: }
324: } else if (isKakkoSM(c)) { /* output contents in ( ) */
325: level = 0;
326: if (ExistSM) return(flushSM());
327: else {
1.4 takayama 328: c = mygetchar();
329: while (1) {
330: if (c == EOF) break;
331: if (c == '\\') { /* e.g. \( */
332: putSM(c);
333: c = mygetchar();
334: if (c == EOF) break;
335: }else{
336: if ((c == ')') && (level <= 0)) break;
337: if ( c == '(') ++level;
338: if ( c == ')') --level;
339: }
340: putSM(c);
341: c = mygetchar();
342: }
343: if (c==')') c=mygetchar();
344: TypeSM = DOLLAR;
345: return(flushSM());
1.1 maekawa 346: }
347: } else if (c=='%') { /* comment */
348: while (((c=mygetchar()) != '\n') && (c != EOF)) ;
349: if(ExistSM) return(flushSM());
350: } else if (isSymbolSM(c)) { /* symbols. {,} etc */
351: if(ExistSM) return(flushSM());
352: else {
1.4 takayama 353: putSM(c);
354: c = mygetchar();
355: return(flushSM());
1.1 maekawa 356: }
357: } else { /* identifier */
358: putSM(c);
359: c =mygetchar();
360: while ((!isDollarSM(c)) &&
1.4 takayama 361: (!isSpaceSM(c)) &&
362: (!isSymbolSM(c)) &&
363: (c != EOF)) {
364: putSM(c);
365: c = mygetchar();
1.1 maekawa 366: }
367: return(flushSM());
368: }
369: }
370: }
371:
372: /*********** end of code part of lexical analizer ********************/
373:
374: /*
375: main() {
376: char input[1000];
377: struct tokens r;
378:
379: getokenSM(INIT);
380: r = getokenSM(GET);
381: while (r.token != (char *)NULL) {
382: printf("%s %d\n",r.token,r.kind);
383: r =getokenSM(GET);
384: }
385:
386: }
387: */
388:
389: /*
390: gets(input);
391: StringSM = (char *)sGC_malloc((strlen(input)+2)*sizeof(char));
392: strcpy(StringSM,input);
393: getokenSM(INIT);
394: */
395:
396: char *getLOAD_SM1_PATH() {
397: char *p;
398: char *p2;
399: char *getenv(char *s);
400: p = getenv("LOAD_SM1_PATH");
401: if (p == NULL) {
1.2 takayama 402: p = getenv("OpenXM_HOME");
403: if (p == NULL) {
404: return("/usr/local/lib/sm1/");
405: }else{
406: if (strlen(p) == 0) return(p);
407: p2 = (char *) sGC_malloc(sizeof(char)*(strlen(p)+strlen("/lib/sm1/")+3));
408: if (p2 == NULL) { fprintf(stderr,"No more memory.\n"); exit(10); }
409: if (p[strlen(p)-1] != '/') {
1.4 takayama 410: strcpy(p2,p); strcat(p2,"/lib/sm1/");
1.2 takayama 411: }else{
1.4 takayama 412: strcpy(p2,p); strcat(p2,"lib/sm1/");
1.2 takayama 413: }
414: return(p2);
415: }
1.1 maekawa 416: }else{
417: if (strlen(p) == 0) return(p);
418: if (p[strlen(p)-1] == '/') return(p);
419: /* Add / */
420: p2 = (char *) sGC_malloc(sizeof(char)*(strlen(p)+3));
421: if (p2 == NULL) { fprintf(stderr,"No more memory.\n"); exit(10); }
422: strcpy(p2,p); strcat(p2,"/");
423: return(p2);
424: }
425: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to scanner.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / kan96xx / Kan