Annotation of OpenXM/src/kan96xx/Kan/scanner2.c, Revision 1.5
1.5 ! takayama 1: /* $OpenXM: OpenXM/src/kan96xx/Kan/scanner2.c,v 1.4 2004/09/10 13:20:23 takayama Exp $ */
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 ****************************
1.3 takayama 13: typedef enum {INIT,GET,PUT,OPEN} actionType;
1.1 maekawa 14:
1.3 takayama 15: struct tokens{
16: char *token;
17: int kind;
18: };
1.1 maekawa 19:
20:
1.3 takayama 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.
1.1 maekawa 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)
1.3 takayama 62: char *str;
63: int *sizep;
1.1 maekawa 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()
1.3 takayama 97: /* get a letter from StringSM */
1.1 maekawa 98: {
99: int c;
1.5 ! takayama 100:
! 101: if ((StrpSM > 0) && (StringSM[StrpSM] == ',') && (StringSM[StrpSM-1] == ',')) { int i;
! 102: fprintf(stderr,"Warning: ,, is found: ");
! 103: for (i=(StrpSM-30>0?StrpSM-30:0); i<=StrpSM; i++) {
! 104: fprintf(stderr,"%c",StringSM[i]);
! 105: }
! 106: fprintf(stderr,"\n");
! 107: }
! 108:
1.1 maekawa 109: c = StringSM[StrpSM++];
110: if (c == '\0') {
111: StrpSM--;return(EOF);
112: } else return(c);
113: }
114:
115: static putSM(c)
1.3 takayama 116: int c;
117: /* put a letter on BufSM */
1.1 maekawa 118: {
119: char *new; int i;
120: BufSM[ExistSM++] = ((c=='\n')? ' ' : c);
121: if (ExistSM >= Buf0limit-1) {
122: new = (char *) sGC_malloc(sizeof(char *)*Buf0limit*2) ;
123: if (new == (char *)NULL) {
124: fprintf(stderr,"No more memory in parserpass0.c\n");
125: exit(18);
126: }
127: fprintf(stderr,"\nSystem Message: Increasing BufSM to %d in scanner2.c\n",Buf0limit*2);
128: for (i=0; i<Buf0limit; i++) {
129: new[i] = BufSM[i];
130: }
131: BufSM = new; Buf0limit *= 2;
132: }
133: }
134:
135: static struct tokens flushSM()
136: {
137: char *token;
138: struct tokens r;
139: if (ExistSM<=0) {
140: fprintf(stderr,"\n flushSM() is called without data. Don't use the empty string $$. \n");
141: r.token = (char *)NULL; r.kind = -10; /* -1 ==> -10 ***/
142: return(r);
143: }
144: BufSM[ExistSM] = '\0';
145: ExistSM = 0;
146: token = (char *)sGC_malloc((strlen(BufSM)+1)*sizeof(char));
147: strcpy(token,BufSM);
148: r.token = token;
149: r.kind = TypeSM;
150: if (r.kind == ID) {
151: if (isLiteral(r.token)) {
1.3 takayama 152: r.object = lookupLiteralString(r.token);
1.1 maekawa 153: }else{
154: r = lookupTokens(r); /* Compute hashing values */
155: }
156: }
157: return(r);
158: }
159:
160: static isSpaceSM(c)
1.3 takayama 161: int c;
1.1 maekawa 162: {
1.4 takayama 163: if (((c <= ' ') || c == ',') && (c!= EOF)) return(1);
1.1 maekawa 164: else return(0);
165: }
166:
167: static isDollarSM(c)
1.3 takayama 168: int c;
1.1 maekawa 169: {
170: if (c == '$') return(1);
171: else return(0);
172: }
173:
174: static isBraceSM(c)
1.3 takayama 175: int c;
1.1 maekawa 176: {
177: if (c == '{') return(1);
178: else return(0);
179: }
180:
181: static isKakkoSM(c)
1.3 takayama 182: int c;
1.1 maekawa 183: {
184: if (c == '(') return(1);
185: else return(0);
186: }
187:
188: static isSymbolSM(c)
1.3 takayama 189: int c;
1.1 maekawa 190: {
191: if ((c == '{') ||
192: (c == '}') ||
193: (c == '[') ||
194: (c == ']') ||
195: (c == '(') ||
196: (c == ')'))
197: return(1);
198: else return(0);
199: }
200:
201: static struct tokens getokenSM2(kind,str)
1.3 takayama 202: actionType kind;
203: char *str;
1.1 maekawa 204: {
205: static int c;
206: static struct tokens rnull;
207: int level;
208:
209: if (kind == INIT) {
210: StrpSM = 0;
211: ExistSM = 0;
212:
213: c = mygetchar();
214: rnull.token = (char *)NULL; rnull.kind = -1;
215: return(rnull);
216: }
217:
218:
219:
220: for (;;) {
221: TypeSM = ID;
222: if (c == EOF) {
223: if (ExistSM) return(flushSM());
224: else return(rnull);
225: } else if (isSpaceSM(c)) {
226: if (ExistSM) {
1.3 takayama 227: c = mygetchar(); return(flushSM());
1.1 maekawa 228: }else {
1.3 takayama 229: while (isSpaceSM(c=mygetchar())) ;
1.1 maekawa 230: }
231: } else if (isDollarSM(c)) { /* output contents in dollar signs. */
232: if (ExistSM) return(flushSM());
233: else {
1.3 takayama 234: c = mygetchar();
235: while ((c != EOF) && (c != '$')) {
236: putSM(c);
237: c = mygetchar();
238: }
239: if (c=='$') c=mygetchar();
240: TypeSM = DOLLAR;
241: return(flushSM());
1.1 maekawa 242: }
243: } else if (isBraceSM(c)) { /* output contents in { } */
244: /* { { } } */
245: level = 0;
246: if (ExistSM) return(flushSM());
247: else {
1.3 takayama 248: c = mygetchar();
249: while (1) {
250: if (c == '%') { /* skip the comment in the brace. */
251: while (((c=mygetchar()) != '\n') && (c != EOF)) ;
252: }
253: if (c == EOF) break;
254: if ((c == '}') && (level <= 0)) break;
255: if ( c == '{') ++level;
256: if ( c == '}') --level;
257: putSM(c);
258: c = mygetchar();
259: }
260: if (c=='}') c=mygetchar();
261: TypeSM = EXECUTABLE_STRING;
262: return(flushSM());
1.1 maekawa 263: }
264: } else if (isKakkoSM(c)) { /* output contents in ( ) */
265: level = 0;
266: if (ExistSM) return(flushSM());
267: else {
1.3 takayama 268: c = mygetchar();
269: while (1) {
270: if (c == EOF) break;
271: if (c == '\\') { /* e.g. \( */
272: putSM(c);
273: c = mygetchar();
274: if (c == EOF) break;
275: }else{
276: if ((c == ')') && (level <= 0)) break;
277: if ( c == '(') ++level;
278: if ( c == ')') --level;
279: }
280: putSM(c);
281: c = mygetchar();
282: }
283: if (c==')') c=mygetchar();
284: TypeSM = DOLLAR;
285: return(flushSM());
1.1 maekawa 286: }
287: } else if (c=='%') { /* comment */
288: while (((c=mygetchar()) != '\n') && (c != EOF)) ;
289: if(ExistSM) return(flushSM());
290: } else if (isSymbolSM(c)) { /* symbols. {,} etc */
291: if(ExistSM) return(flushSM());
292: else {
1.3 takayama 293: putSM(c);
294: c = mygetchar();
295: return(flushSM());
1.1 maekawa 296: }
297: } else { /* identifier */
298: putSM(c);
299: c =mygetchar();
300: while ((!isDollarSM(c)) &&
1.3 takayama 301: (!isSpaceSM(c)) &&
302: (!isSymbolSM(c)) &&
303: (c != EOF)) {
304: putSM(c);
305: c = mygetchar();
1.1 maekawa 306: }
307: return(flushSM());
308: }
309: }
310: }
311:
312: /*********** end of code part of lexical analizer ********************/
313:
314:
315: errorScanner2(str)
1.3 takayama 316: char *str;
1.1 maekawa 317: {
318: fprintf(stderr,"Error (scanner2.c): %s\n",str);
319: exit(10);
320: }
321:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>