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