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