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