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