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