Annotation of OpenXM/src/kan96xx/Kan/scanner2.c, Revision 1.2
1.2 ! takayama 1: /* $OpenXM$ */
1.1 maekawa 2: /* scanner2.c (SM StackMachine) */
3: /* export: struct tokens decompostToTokens(char *str,int *sizep);
4: scanner2.c is for getting tokens from a string.
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: /**************** defined in stackm.h ****************************
13: typedef enum {INIT,GET,PUT,OPEN} actionType;
14:
15: struct tokens{
16: char *token;
17: int kind;
18: };
19:
20:
21: #define ID 2
22: #define DOLLAR 3 strings enclosed by dollar sign
23: #define EXECUTABLE_STRING 4 strings enclosed by {}
24: #define EXECUTABLE_ARRAY 8 Don't set it in this file.
25: ******************************************************************/
26:
27:
28: /******* declaration-part of lexical analizer ********************/
29: #define mygetchar() getSM()
30: /* to use getSM() ( input from StringSM ),
31: setup StringSM;
32: getokenSM(INIT);
33: */
34:
35:
36:
37:
38: #define BUF0LIMIT 40000
39: static char *StringSM;
40: static int StrpSM = 0;
41: static char BufSMorg[BUF0LIMIT];
42: static char *BufSM = BufSMorg;
43: static int Buf0limit = BUF0LIMIT ;
44: static int ExistSM = 0;
45: static int TypeSM = ID;
46:
47: /**************** end of declaration part of lexical analizer ******/
48:
49: static int getSM();
50: static putSM();
51: static struct tokens flushSM();
52: static isSpaceSM();
53: static isDollarSM();
54: static isBraceSM();
55: static isKakkoSM();
56: static isSymbolSM();
57: static struct tokens getokenSM2();
58:
59: /**************** code part of lexical analizer ********************/
60:
61: struct tokens *decomposeToTokens(str,sizep)
62: char *str;
63: int *sizep;
64: {
65: struct tokens *tArray;
66: struct tokens token;
67: int k;
68: int size;
69:
70: StringSM = (char *) sGC_malloc((strlen(str)+3)*sizeof(char));
71: if (StringSM == (char *)NULL) {
72: errorScanner2("I have no memormy.");
73: }
74: strcpy(StringSM,str);
75: getokenSM2(INIT);
76: size = 0;
77: token = getokenSM2(GET);
78: while (token.kind != -1) {
79: size++;
80: token = getokenSM2(GET);
81: }
82:
83: tArray = (struct tokens *)sGC_malloc((size+1)*sizeof(struct tokens));
84: strcpy(StringSM,str);
85: getokenSM2(INIT);
86: for (k=0; k<size; k++) {
87: tArray[k] = getokenSM2(GET);
88: }
89:
90: *sizep = size;
91: return(tArray);
92: }
93:
94:
95:
96: static int getSM()
97: /* get a letter from StringSM */
98: {
99: int c;
100: c = StringSM[StrpSM++];
101: if (c == '\0') {
102: StrpSM--;return(EOF);
103: } else return(c);
104: }
105:
106: static putSM(c)
107: int c;
108: /* put a letter on BufSM */
109: {
110: char *new; int i;
111: BufSM[ExistSM++] = ((c=='\n')? ' ' : c);
112: if (ExistSM >= Buf0limit-1) {
113: new = (char *) sGC_malloc(sizeof(char *)*Buf0limit*2) ;
114: if (new == (char *)NULL) {
115: fprintf(stderr,"No more memory in parserpass0.c\n");
116: exit(18);
117: }
118: fprintf(stderr,"\nSystem Message: Increasing BufSM to %d in scanner2.c\n",Buf0limit*2);
119: for (i=0; i<Buf0limit; i++) {
120: new[i] = BufSM[i];
121: }
122: BufSM = new; Buf0limit *= 2;
123: }
124: }
125:
126: static struct tokens flushSM()
127: {
128: char *token;
129: struct tokens r;
130: if (ExistSM<=0) {
131: fprintf(stderr,"\n flushSM() is called without data. Don't use the empty string $$. \n");
132: r.token = (char *)NULL; r.kind = -10; /* -1 ==> -10 ***/
133: return(r);
134: }
135: BufSM[ExistSM] = '\0';
136: ExistSM = 0;
137: token = (char *)sGC_malloc((strlen(BufSM)+1)*sizeof(char));
138: strcpy(token,BufSM);
139: r.token = token;
140: r.kind = TypeSM;
141: if (r.kind == ID) {
142: if (isLiteral(r.token)) {
143: r.object = lookupLiteralString(r.token);
144: }else{
145: r = lookupTokens(r); /* Compute hashing values */
146: }
147: }
148: return(r);
149: }
150:
151: static isSpaceSM(c)
152: int c;
153: {
154: if ((c <= ' ') && (c!= EOF)) return(1);
155: else return(0);
156: }
157:
158: static isDollarSM(c)
159: int c;
160: {
161: if (c == '$') return(1);
162: else return(0);
163: }
164:
165: static isBraceSM(c)
166: int c;
167: {
168: if (c == '{') return(1);
169: else return(0);
170: }
171:
172: static isKakkoSM(c)
173: int c;
174: {
175: if (c == '(') return(1);
176: else return(0);
177: }
178:
179: static isSymbolSM(c)
180: int c;
181: {
182: if ((c == '{') ||
183: (c == '}') ||
184: (c == '[') ||
185: (c == ']') ||
186: (c == '(') ||
187: (c == ')'))
188: return(1);
189: else return(0);
190: }
191:
192: static struct tokens getokenSM2(kind,str)
193: actionType kind;
194: char *str;
195: {
196: static int c;
197: static struct tokens rnull;
198: int level;
199:
200: if (kind == INIT) {
201: StrpSM = 0;
202: ExistSM = 0;
203:
204: c = mygetchar();
205: rnull.token = (char *)NULL; rnull.kind = -1;
206: return(rnull);
207: }
208:
209:
210:
211: for (;;) {
212: TypeSM = ID;
213: if (c == EOF) {
214: if (ExistSM) return(flushSM());
215: else return(rnull);
216: } else if (isSpaceSM(c)) {
217: if (ExistSM) {
218: c = mygetchar(); return(flushSM());
219: }else {
220: while (isSpaceSM(c=mygetchar())) ;
221: }
222: } else if (isDollarSM(c)) { /* output contents in dollar signs. */
223: if (ExistSM) return(flushSM());
224: else {
225: c = mygetchar();
226: while ((c != EOF) && (c != '$')) {
227: putSM(c);
228: c = mygetchar();
229: }
230: if (c=='$') c=mygetchar();
231: TypeSM = DOLLAR;
232: return(flushSM());
233: }
234: } else if (isBraceSM(c)) { /* output contents in { } */
235: /* { { } } */
236: level = 0;
237: if (ExistSM) return(flushSM());
238: else {
239: c = mygetchar();
240: while (1) {
241: if (c == '%') { /* skip the comment in the brace. */
242: while (((c=mygetchar()) != '\n') && (c != EOF)) ;
243: }
244: if (c == EOF) break;
245: if ((c == '}') && (level <= 0)) break;
246: if ( c == '{') ++level;
247: if ( c == '}') --level;
248: putSM(c);
249: c = mygetchar();
250: }
251: if (c=='}') c=mygetchar();
252: TypeSM = EXECUTABLE_STRING;
253: return(flushSM());
254: }
255: } else if (isKakkoSM(c)) { /* output contents in ( ) */
256: level = 0;
257: if (ExistSM) return(flushSM());
258: else {
259: c = mygetchar();
260: while (1) {
261: if (c == EOF) break;
262: if (c == '\\') { /* e.g. \( */
263: putSM(c);
264: c = mygetchar();
265: if (c == EOF) break;
266: }else{
267: if ((c == ')') && (level <= 0)) break;
268: if ( c == '(') ++level;
269: if ( c == ')') --level;
270: }
271: putSM(c);
272: c = mygetchar();
273: }
274: if (c==')') c=mygetchar();
275: TypeSM = DOLLAR;
276: return(flushSM());
277: }
278: } else if (c=='%') { /* comment */
279: while (((c=mygetchar()) != '\n') && (c != EOF)) ;
280: if(ExistSM) return(flushSM());
281: } else if (isSymbolSM(c)) { /* symbols. {,} etc */
282: if(ExistSM) return(flushSM());
283: else {
284: putSM(c);
285: c = mygetchar();
286: return(flushSM());
287: }
288: } else { /* identifier */
289: putSM(c);
290: c =mygetchar();
291: while ((!isDollarSM(c)) &&
292: (!isSpaceSM(c)) &&
293: (!isSymbolSM(c)) &&
294: (c != EOF)) {
295: putSM(c);
296: c = mygetchar();
297: }
298: return(flushSM());
299: }
300: }
301: }
302:
303: /*********** end of code part of lexical analizer ********************/
304:
305:
306: errorScanner2(str)
307: char *str;
308: {
309: fprintf(stderr,"Error (scanner2.c): %s\n",str);
310: exit(10);
311: }
312:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to scanner2.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / kan96xx / Kan