Annotation of OpenXM/src/kan96xx/trans/yylex_polymake.c, Revision 1.5
1.5 ! takayama 1: /* $OpenXM: OpenXM/src/kan96xx/trans/yylex_polymake.c,v 1.4 2004/08/21 00:39:53 takayama Exp $ */
1.1 takayama 2: /* parser for polymake output */
3: /* This program requires
4:
5:
6: */
7:
8: #include <stdio.h>
9: #include "yylex_polymake.h"
10: #include "yy_polymake.tab.h"
11:
12: #define mymalloc(n) sGC_malloc(n)
13: /*
14: #define mymalloc(n) malloc(n)
15: */
16: /* pm = PolyMake */
17: #define PM_emptyLineCode 1
18:
19:
20: static char *S=NULL;
21: /* It is assumed that the newline code is only \n (preprocessed).
22: Empty line is marked with 0x1. More than one empty line does not appear. */
23: static int Pt=-1;
24: static int PMdebug = 0;
25:
26: /* char *PMlval; */
27:
28: /* The function putstr() uses static variables inside,
29: so if it is under use, it must not be initialized.
30: The function putstr2() is for the second use and is identical
31: function with putstr().
32: */
33: static char *putstr(int c);
34: static char *putstr2(int c);
35: static char *putstr2s(char *s);
36:
37: char *pmPutstr(int c) {
38: return putstr(c);
39: }
40:
41: pmSetS(char *s) {
42: S = s;
43: return 0;
44: }
45:
46: int PMlex() {
47: int type;
48: type = PMlex_aux();
49:
50: if (PMdebug) {
51: printf("type=%d ",type);
52: if ((type == PM_number) || (type == PM_keyword)) {
53: printf("value="); pmPrintObject(stdout,PMlval);
54: }
55: printf("\n");
56: }
57:
58: return type;
59: }
60: int PMlex_aux() {
61: if (Pt < 0) {
62: return PM_noToken;
63: }
64: if (S[Pt] == 0) { Pt=-1; return PM_noToken; }
65: while ((S[Pt]<=' ') && (S[Pt]!='\n') && (S[Pt] != PM_emptyLineCode)) Pt++;
66: if (S[Pt] == '\n') { Pt++; return PM_newline; }
67: if (S[Pt] == PM_emptyLineCode) {Pt++; return PM_emptyLine; }
68: if (S[Pt] == '{') { Pt++; return PM_LCurryBrace; }
69: if (S[Pt] == '}') { Pt++; return PM_RCurryBrace; }
1.3 takayama 70: if (S[Pt] == '<') { Pt++; return PM_LAngle; }
71: if (S[Pt] == '>') { Pt++; return PM_RAngle; }
72: if (S[Pt] == '(') { Pt++; return PM_LBrace; }
73: if (S[Pt] == ')') { Pt++; return PM_RBrace; }
74: if (S[Pt] == '[') { Pt++; return PM_LBracket; }
75: if (S[Pt] == ']') { Pt++; return PM_RBracket; }
76: if (S[Pt] == ':') { Pt++; return PM_colon; }
1.5 ! takayama 77: if (S[Pt] == '=') { Pt++; return PM_eq; }
1.1 takayama 78: if (((S[Pt] >= '0') && (S[Pt] <= '9')) || (S[Pt] == '-')) {
79: putstr(-1); putstr(S[Pt++]);
80: while (((S[Pt]>='0') && (S[Pt]<='9')) || (S[Pt] == '/')) putstr(S[Pt++]);
81: PMlval = pmNewStrObject(putstr(0));
82: return PM_number;
83: }
84: if (((S[Pt] >= 'A') && (S[Pt] <= 'Z')) ||
85: ((S[Pt] >= 'a') && (S[Pt] <= 'z')) ||
1.4 takayama 86: (S[Pt] == '_') || S[Pt] == '!') {
87: if (S[Pt] != '!') {putstr(-1); putstr(S[Pt++]);}
88: else {
89: putstr(-1); Pt++;
90: putstr('N'); putstr('O'); putstr('T'); putstr('_'); putstr('_');
91: }
92: while (((S[Pt] >= 'A') && (S[Pt] <= 'Z')) ||
93: ((S[Pt] >= 'a') && (S[Pt] <= 'z')) ||
94: (S[Pt] == '_')) putstr(S[Pt++]);
95: PMlval = pmNewStrObject(putstr(0));
96: return PM_keyword;
1.1 takayama 97: }
98: Pt++; return PM_unknown;
99: }
100:
101: #define PUTSTR_INIT 10
102: static char *putstr(int c) {
103: static char *s=NULL;
104: static int pt=0;
105: static int limit=0;
106: int i;
107: char *old;
108: if (c < 0) {
109: s = (char *)mymalloc(PUTSTR_INIT);
110: if (s == NULL) {fprintf(stderr,"No more memory.\n"); exit(10);}
111: limit = PUTSTR_INIT;
112: pt = 0; s[pt] = 0;
113: return s;
114: }
115: if (s == NULL) putstr(-1);
116: if (pt < limit-1) {
117: s[pt++]=c; s[pt]=0;
118: return s;
119: }else{
120: old = s;
121: limit = 2*limit;
122: s = (char *)mymalloc(limit);
123: if (s == NULL) {fprintf(stderr,"No more memory.\n"); exit(10);}
124: for (i=0; i<=pt; i++) {
125: s[i] = old[i];
126: }
127: return putstr(c);
128: }
129: }
130: static char *putstr2(int c) {
131: static char *s=NULL;
132: static int pt=0;
133: static int limit=0;
134: int i;
135: char *old;
136: if (c < 0) {
137: s = (char *)mymalloc(PUTSTR_INIT);
138: if (s == NULL) {fprintf(stderr,"No more memory.\n"); exit(10);}
139: limit = PUTSTR_INIT;
140: pt = 0; s[pt] = 0;
141: return s;
142: }
143: if (s == NULL) putstr2(-1);
144: if (pt < limit-1) {
145: s[pt++]=c; s[pt]=0;
146: return s;
147: }else{
148: old = s;
149: limit = 2*limit;
150: s = (char *)mymalloc(limit);
151: if (s == NULL) {fprintf(stderr,"No more memory.\n"); exit(10);}
152: for (i=0; i<=pt; i++) {
153: s[i] = old[i];
154: }
155: return putstr2(c);
156: }
157: }
158: static char *putstr2s(char *s) {
159: int i;
160: char *ss;
161: for (i=0; i<strlen(s); i++) {
162: ss = putstr2(s[i]);
163: }
164: return ss;
165: }
166:
167: pmPreprocess() {
168: int newp,oldp;
169: int state;
170: int i,j;
171: if (S == NULL) return -1;
172: Pt = 0;
173: for (oldp = newp = 0; S[oldp] != 0; oldp++) {
174: if ((S[oldp] == 0xd) && (S[oldp] == 0xa)) { /* Windows 0d 0a */
175: S[newp++] = '\n'; oldp++;
176: }else{
177: S[newp++] = S[oldp];
178: }
179: }
180: S[newp] = '\0';
181:
182: for (oldp = newp = 0; S[oldp] != 0; oldp++) {
183: if (S[oldp] == 0xd) { /* Replace for mac 0xd to 0xa */
184: S[newp++] = '\n';
185: }else{
186: S[newp++] = S[oldp];
187: }
188: }
189: S[newp] = '\0';
190:
191: /* Remove #, empty lines, ... */
192: state = 1; newp=0;
193: for (oldp=0; S[oldp] != 0; oldp++) {
194: /* printf("oldp=%d, state=%d, char=%c\n",oldp,state,S[oldp]); */
195: switch(state) {
196: case 0:
197: if (S[oldp] == '\n') {state=1; newp=oldp+1;}
198: break;
199: case 1:
200: if ((S[oldp] == ' ') || (S[oldp] == '\t')) break;
1.2 takayama 201: if ((S[oldp] == '#') || ((S[oldp]=='_') && (oldp == 0))
202: || ((S[oldp]=='_') && (S[oldp-1]<' '))) {
1.1 takayama 203: /* skip the rest of the line, state=1; */
204: for (; S[oldp] != 0 ; oldp++) {
205: if (S[oldp] == '\n') {oldp--; break;}
206: }
207: if (S[oldp] == 0) oldp--;
208: }else if (S[oldp] == '\n') {
209: /* replace the empty line by PM_emptyLine */
210: S[newp]= PM_emptyLineCode; j=oldp+1;
211: for (i=newp+1; S[j] != 0; i++) {
212: S[i] = S[j]; j++;
213: }
214: oldp=newp;
215: S[i] = 0;
216: }else{
217: state = 0;
218: }
219: break;
220: default:
221: break;
222: }
223: }
224: }
225:
226: /* --------------- pmObjects --------------------- */
227: pmObjectp pmNewStrObject(char *s) {
228: pmObjectp ob;
229: ob = (pmObjectp) mymalloc(sizeof(struct pmObject));
230: if (ob == NULL) {
231: fprintf(stderr,"No more memory.\n");
232: exit(10);
233: }
234: ob->tag = PMobject_str;
235: ob->body = s;
236: return ob;
237: }
238: pmObjectp pmNewListObject(pmObjectp a) {
239: pmObjectp ob;
240: struct pmList *aa;
241: ob = (pmObjectp) mymalloc(sizeof(struct pmObject));
242: if (ob == NULL) {
243: fprintf(stderr,"No more memory.\n");
244: exit(10);
245: }
246: aa= (struct pmList *)mymalloc(sizeof(struct pmList));
247: if (aa == NULL) {
248: fprintf(stderr,"No more memory.\n");
249: exit(10);
250: }
251: aa->left=a;
252: aa->right=NULL;
253: ob->tag = PMobject_list;
254: ob->body = aa;
255: return ob;
256: }
257: pmObjectp pmCons(pmObjectp a,struct pmList *b) {
258: pmObjectp ob;
259: struct pmList *t;
260: ob = pmNewListObject(a);
261: t = ob->body;
262: t->right = b;
263: return ob;
264: }
265:
266: int pmListLength(struct pmList *list) {
267: struct pmList *t;
268: int n;
269: if (list == NULL) return 0;
270: n = 0;
271: t = list;
272: while (t != NULL) {
273: n++; t = t->right;
274: }
275: return n;
276: }
277:
278: pmObjectp pmNewTreeObjecto(pmObjectp s)
279: {
280: if ((s == NULL) || (s->tag != PMobject_str)) {
281: warning_yylex_polymake("Invalid argument for pmNewObjecto\n");
282: return pmNewTreeObject("?");
283: }
284: return pmNewTreeObject((char *)(s->body));
285: }
286: pmObjectp pmNewTreeObject(char *s) {
287: pmObjectp ob;
288: struct pmTree *aa;
289: ob = (pmObjectp) mymalloc(sizeof(struct pmObject));
290: if (ob == NULL) {
291: fprintf(stderr,"No more memory.\n");
292: exit(10);
293: }
294: aa= (struct pmTree *)mymalloc(sizeof(struct pmTree));
295: if (aa == NULL) {
296: fprintf(stderr,"No more memory.\n");
297: exit(10);
298: }
299: aa->nodeName = s;
300: aa->attrList = NULL;
301: aa->childs = NULL;
302: ob->tag = PMobject_tree;
303: ob->body = aa;
304: return ob;
305: }
306:
307: pmObjectp pmAddAttr(pmObjectp c,pmObjectp a) {
308: struct pmTree *tree;
309: if (a->tag != PMobject_tree) {
310: warning_yylex_polymake("pmAddAttr: the argument is not tree object.\n");
311: return a;
312: }
313: tree = a->body;
314: if (tree->attrList == NULL) {
315: tree->attrList = pmNewListObject(c);
316: }else{
317: if (tree->attrList->tag == PMobject_list) {
318: tree->attrList = pmCons(c,(struct pmList *)(tree->attrList->body));
319: }else{
320: warning_yylex_polymake("pmAddAttr: the attrbute list is broken.\n");
321: }
322: }
323: return a;
324: }
325:
326: /* Add c to the tree a */
327: pmObjectp pmAddChild(pmObjectp c,pmObjectp a) {
328: struct pmTree *tree;
329: if (a->tag != PMobject_tree) {
330: warning_yylex_polymake("pmAddAttr: the argument is not tree object.\n");
331: return a;
332: }
333: tree = a->body;
334: if (tree->childs == NULL) {
335: tree->childs = pmNewListObject(c);
336: }else{
337: if (tree->childs->tag == PMobject_list) {
338: tree->childs = pmCons(c,(struct pmList *)(tree->childs->body));
339: }else{
340: warning_yylex_polymake("pmAddAttr: the child list is broken.\n");
341: }
342: }
343: return a;
344: }
345:
346: warning_yylex_polymake(char *s) {
347: fprintf(stderr,"Warning: %s",s);
348: }
349:
350: void pmPrintObject(FILE *fp,pmObjectp p) {
351: fprintf(fp,"%s",pmObjectToStr(p));
352: }
353: char *pmObjectToStr(pmObjectp p) {
354: char *s;
355: s=putstr2(-1);
356: s=pmObjectToStr_aux(p);
357: return putstr2(0);
358: }
359: char *pmObjectToStr_aux(pmObjectp p) {
360: int n,i;
361: struct pmList *list;
362: struct pmList *t;
363: struct pmTree *tree;
364: char *ans;
365: if (p == NULL) {
366: /* fprintf(stderr,"NULL "); */
367: return putstr2s("[]");
368: }
369: /* fprintf(stderr,"tag=%d ",p->tag); */
370: switch (p->tag) {
371: case PMobject_str:
372: ans=putstr2s((char *)(p->body));
373: break;
374: case PMobject_list:
375: list = (struct pmList *)(p->body);
376: if (list == NULL) break;
377: n = pmListLength(list);
378: t = list;
379: ans=putstr2s("[");
380: for (i=0; i<n; i++) {
381: ans=pmObjectToStr_aux(t->left);
382: if (i != n-1) ans=putstr2s(",");
383: if (t == NULL) break; else t = t->right;
384: }
385: ans=putstr2s("]");
386: break;
387: case PMobject_tree:
388: tree = p->body;
389: ans=putstr2s("polymake."); ans=putstr2s(tree->nodeName);
390: ans=putstr2s("(");
391: /* Ignore attribute list */
392: if (tree->childs == NULL) {n = 0; t = NULL; }
393: else {
394: t = tree->childs->body;
395: n = pmListLength(t);
396: }
397: for (i=0; i<n; i++) {
398: ans=pmObjectToStr_aux(t->left);
399: t = t->right;
400: if (i != n-1) ans=putstr2(',');
401: }
402: ans = putstr2s(")");
403: break;
404: default:
405: fprintf(stderr,"Unknown object tag %d.\n",p->tag);
406: /* sleep(100); to call debugger. */
407: break;
408: }
409: return ans;
410: }
411:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to yylex_polymake.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / kan96xx / trans