Annotation of OpenXM/src/kan96xx/trans/yylex_polymake.c, Revision 1.2
1.2 ! takayama 1: /* $OpenXM: OpenXM/src/kan96xx/trans/yylex_polymake.c,v 1.1 2003/11/24 02:33:39 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; }
70: if (((S[Pt] >= '0') && (S[Pt] <= '9')) || (S[Pt] == '-')) {
71: putstr(-1); putstr(S[Pt++]);
72: while (((S[Pt]>='0') && (S[Pt]<='9')) || (S[Pt] == '/')) putstr(S[Pt++]);
73: PMlval = pmNewStrObject(putstr(0));
74: return PM_number;
75: }
76: if (((S[Pt] >= 'A') && (S[Pt] <= 'Z')) ||
77: ((S[Pt] >= 'a') && (S[Pt] <= 'z')) ||
78: (S[Pt] == '_')) {
79: putstr(-1); putstr(S[Pt++]);
80: while (((S[Pt] >= 'A') && (S[Pt] <= 'Z')) ||
81: ((S[Pt] >= 'a') && (S[Pt] <= 'z')) ||
82: (S[Pt] == '_')) putstr(S[Pt++]);
83: PMlval = pmNewStrObject(putstr(0));
84: return PM_keyword;
85: }
86: Pt++; return PM_unknown;
87: }
88:
89: #define PUTSTR_INIT 10
90: static char *putstr(int c) {
91: static char *s=NULL;
92: static int pt=0;
93: static int limit=0;
94: int i;
95: char *old;
96: if (c < 0) {
97: s = (char *)mymalloc(PUTSTR_INIT);
98: if (s == NULL) {fprintf(stderr,"No more memory.\n"); exit(10);}
99: limit = PUTSTR_INIT;
100: pt = 0; s[pt] = 0;
101: return s;
102: }
103: if (s == NULL) putstr(-1);
104: if (pt < limit-1) {
105: s[pt++]=c; s[pt]=0;
106: return s;
107: }else{
108: old = s;
109: limit = 2*limit;
110: s = (char *)mymalloc(limit);
111: if (s == NULL) {fprintf(stderr,"No more memory.\n"); exit(10);}
112: for (i=0; i<=pt; i++) {
113: s[i] = old[i];
114: }
115: return putstr(c);
116: }
117: }
118: static char *putstr2(int c) {
119: static char *s=NULL;
120: static int pt=0;
121: static int limit=0;
122: int i;
123: char *old;
124: if (c < 0) {
125: s = (char *)mymalloc(PUTSTR_INIT);
126: if (s == NULL) {fprintf(stderr,"No more memory.\n"); exit(10);}
127: limit = PUTSTR_INIT;
128: pt = 0; s[pt] = 0;
129: return s;
130: }
131: if (s == NULL) putstr2(-1);
132: if (pt < limit-1) {
133: s[pt++]=c; s[pt]=0;
134: return s;
135: }else{
136: old = s;
137: limit = 2*limit;
138: s = (char *)mymalloc(limit);
139: if (s == NULL) {fprintf(stderr,"No more memory.\n"); exit(10);}
140: for (i=0; i<=pt; i++) {
141: s[i] = old[i];
142: }
143: return putstr2(c);
144: }
145: }
146: static char *putstr2s(char *s) {
147: int i;
148: char *ss;
149: for (i=0; i<strlen(s); i++) {
150: ss = putstr2(s[i]);
151: }
152: return ss;
153: }
154:
155: pmPreprocess() {
156: int newp,oldp;
157: int state;
158: int i,j;
159: if (S == NULL) return -1;
160: Pt = 0;
161: for (oldp = newp = 0; S[oldp] != 0; oldp++) {
162: if ((S[oldp] == 0xd) && (S[oldp] == 0xa)) { /* Windows 0d 0a */
163: S[newp++] = '\n'; oldp++;
164: }else{
165: S[newp++] = S[oldp];
166: }
167: }
168: S[newp] = '\0';
169:
170: for (oldp = newp = 0; S[oldp] != 0; oldp++) {
171: if (S[oldp] == 0xd) { /* Replace for mac 0xd to 0xa */
172: S[newp++] = '\n';
173: }else{
174: S[newp++] = S[oldp];
175: }
176: }
177: S[newp] = '\0';
178:
179: /* Remove #, empty lines, ... */
180: state = 1; newp=0;
181: for (oldp=0; S[oldp] != 0; oldp++) {
182: /* printf("oldp=%d, state=%d, char=%c\n",oldp,state,S[oldp]); */
183: switch(state) {
184: case 0:
185: if (S[oldp] == '\n') {state=1; newp=oldp+1;}
186: break;
187: case 1:
188: if ((S[oldp] == ' ') || (S[oldp] == '\t')) break;
1.2 ! takayama 189: if ((S[oldp] == '#') || ((S[oldp]=='_') && (oldp == 0))
! 190: || ((S[oldp]=='_') && (S[oldp-1]<' '))) {
1.1 takayama 191: /* skip the rest of the line, state=1; */
192: for (; S[oldp] != 0 ; oldp++) {
193: if (S[oldp] == '\n') {oldp--; break;}
194: }
195: if (S[oldp] == 0) oldp--;
196: }else if (S[oldp] == '\n') {
197: /* replace the empty line by PM_emptyLine */
198: S[newp]= PM_emptyLineCode; j=oldp+1;
199: for (i=newp+1; S[j] != 0; i++) {
200: S[i] = S[j]; j++;
201: }
202: oldp=newp;
203: S[i] = 0;
204: }else{
205: state = 0;
206: }
207: break;
208: default:
209: break;
210: }
211: }
212: }
213:
214: /* --------------- pmObjects --------------------- */
215: pmObjectp pmNewStrObject(char *s) {
216: pmObjectp ob;
217: ob = (pmObjectp) mymalloc(sizeof(struct pmObject));
218: if (ob == NULL) {
219: fprintf(stderr,"No more memory.\n");
220: exit(10);
221: }
222: ob->tag = PMobject_str;
223: ob->body = s;
224: return ob;
225: }
226: pmObjectp pmNewListObject(pmObjectp a) {
227: pmObjectp ob;
228: struct pmList *aa;
229: ob = (pmObjectp) mymalloc(sizeof(struct pmObject));
230: if (ob == NULL) {
231: fprintf(stderr,"No more memory.\n");
232: exit(10);
233: }
234: aa= (struct pmList *)mymalloc(sizeof(struct pmList));
235: if (aa == NULL) {
236: fprintf(stderr,"No more memory.\n");
237: exit(10);
238: }
239: aa->left=a;
240: aa->right=NULL;
241: ob->tag = PMobject_list;
242: ob->body = aa;
243: return ob;
244: }
245: pmObjectp pmCons(pmObjectp a,struct pmList *b) {
246: pmObjectp ob;
247: struct pmList *t;
248: ob = pmNewListObject(a);
249: t = ob->body;
250: t->right = b;
251: return ob;
252: }
253:
254: int pmListLength(struct pmList *list) {
255: struct pmList *t;
256: int n;
257: if (list == NULL) return 0;
258: n = 0;
259: t = list;
260: while (t != NULL) {
261: n++; t = t->right;
262: }
263: return n;
264: }
265:
266: pmObjectp pmNewTreeObjecto(pmObjectp s)
267: {
268: if ((s == NULL) || (s->tag != PMobject_str)) {
269: warning_yylex_polymake("Invalid argument for pmNewObjecto\n");
270: return pmNewTreeObject("?");
271: }
272: return pmNewTreeObject((char *)(s->body));
273: }
274: pmObjectp pmNewTreeObject(char *s) {
275: pmObjectp ob;
276: struct pmTree *aa;
277: ob = (pmObjectp) mymalloc(sizeof(struct pmObject));
278: if (ob == NULL) {
279: fprintf(stderr,"No more memory.\n");
280: exit(10);
281: }
282: aa= (struct pmTree *)mymalloc(sizeof(struct pmTree));
283: if (aa == NULL) {
284: fprintf(stderr,"No more memory.\n");
285: exit(10);
286: }
287: aa->nodeName = s;
288: aa->attrList = NULL;
289: aa->childs = NULL;
290: ob->tag = PMobject_tree;
291: ob->body = aa;
292: return ob;
293: }
294:
295: pmObjectp pmAddAttr(pmObjectp c,pmObjectp a) {
296: struct pmTree *tree;
297: if (a->tag != PMobject_tree) {
298: warning_yylex_polymake("pmAddAttr: the argument is not tree object.\n");
299: return a;
300: }
301: tree = a->body;
302: if (tree->attrList == NULL) {
303: tree->attrList = pmNewListObject(c);
304: }else{
305: if (tree->attrList->tag == PMobject_list) {
306: tree->attrList = pmCons(c,(struct pmList *)(tree->attrList->body));
307: }else{
308: warning_yylex_polymake("pmAddAttr: the attrbute list is broken.\n");
309: }
310: }
311: return a;
312: }
313:
314: /* Add c to the tree a */
315: pmObjectp pmAddChild(pmObjectp c,pmObjectp a) {
316: struct pmTree *tree;
317: if (a->tag != PMobject_tree) {
318: warning_yylex_polymake("pmAddAttr: the argument is not tree object.\n");
319: return a;
320: }
321: tree = a->body;
322: if (tree->childs == NULL) {
323: tree->childs = pmNewListObject(c);
324: }else{
325: if (tree->childs->tag == PMobject_list) {
326: tree->childs = pmCons(c,(struct pmList *)(tree->childs->body));
327: }else{
328: warning_yylex_polymake("pmAddAttr: the child list is broken.\n");
329: }
330: }
331: return a;
332: }
333:
334: warning_yylex_polymake(char *s) {
335: fprintf(stderr,"Warning: %s",s);
336: }
337:
338: void pmPrintObject(FILE *fp,pmObjectp p) {
339: fprintf(fp,"%s",pmObjectToStr(p));
340: }
341: char *pmObjectToStr(pmObjectp p) {
342: char *s;
343: s=putstr2(-1);
344: s=pmObjectToStr_aux(p);
345: return putstr2(0);
346: }
347: char *pmObjectToStr_aux(pmObjectp p) {
348: int n,i;
349: struct pmList *list;
350: struct pmList *t;
351: struct pmTree *tree;
352: char *ans;
353: if (p == NULL) {
354: /* fprintf(stderr,"NULL "); */
355: return putstr2s("[]");
356: }
357: /* fprintf(stderr,"tag=%d ",p->tag); */
358: switch (p->tag) {
359: case PMobject_str:
360: ans=putstr2s((char *)(p->body));
361: break;
362: case PMobject_list:
363: list = (struct pmList *)(p->body);
364: if (list == NULL) break;
365: n = pmListLength(list);
366: t = list;
367: ans=putstr2s("[");
368: for (i=0; i<n; i++) {
369: ans=pmObjectToStr_aux(t->left);
370: if (i != n-1) ans=putstr2s(",");
371: if (t == NULL) break; else t = t->right;
372: }
373: ans=putstr2s("]");
374: break;
375: case PMobject_tree:
376: tree = p->body;
377: ans=putstr2s("polymake."); ans=putstr2s(tree->nodeName);
378: ans=putstr2s("(");
379: /* Ignore attribute list */
380: if (tree->childs == NULL) {n = 0; t = NULL; }
381: else {
382: t = tree->childs->body;
383: n = pmListLength(t);
384: }
385: for (i=0; i<n; i++) {
386: ans=pmObjectToStr_aux(t->left);
387: t = t->right;
388: if (i != n-1) ans=putstr2(',');
389: }
390: ans = putstr2s(")");
391: break;
392: default:
393: fprintf(stderr,"Unknown object tag %d.\n",p->tag);
394: /* sleep(100); to call debugger. */
395: break;
396: }
397: return ans;
398: }
399:
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