![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pepy_do.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / pepy|
Return to pepy_do.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / pepy |
1.1 root 1: /* pepy_do.c - PE parser (yacc-based) building routines */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/pepy/RCS/pepy_do.c,v 7.0 89/11/23 22:11:49 mrose Rel $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/pepy/RCS/pepy_do.c,v 7.0 89/11/23 22:11:49 mrose Rel $
9: *
10: *
11: * $Log: pepy_do.c,v $
12: * Revision 7.0 89/11/23 22:11:49 mrose
13: * Release 6.0
14: *
15: */
16:
17: /*
18: * NOTICE
19: *
20: * Acquisition, use, and distribution of this module and related
21: * materials are subject to the restrictions of a license agreement.
22: * Consult the Preface in the User's Manual for the full terms of
23: * this agreement.
24: *
25: */
26:
27: #include "pepy.h"
28: #include <ctype.h>
29: #include <stdio.h>
30:
31: extern struct tuple tuples[];
32: extern int rflag;
33:
34: char *gensym (), *modsym ();
35:
36: YP lookup_type (), lookup_binding ();
37: YT lookup_tag ();
38: char *add_point ();
39:
40: /* */
41:
42: do_type (yp, level, id, arg)
43: register YP yp;
44: register int level;
45: register char *id,
46: *arg;
47: {
48: register int i;
49: register char *narg;
50: char *narg2,
51: *narg3;
52: register struct tuple *t;
53: register YP y;
54: register YV yv;
55: char *class, *value, *form;
56: char tbuf1[32], tbuf2[32];
57: int pushdown = 0;
58:
59: if (yp -> yp_flags & YP_COMPONENTS) {
60: warning ("I shouldn't be here!");
61: return;
62: }
63:
64: if (level == 1) {
65: printf ("(pe, explicit, len, buffer, parm)\n");
66: printf ("%sPE *pe;\nint\texplicit;\n",
67: yp -> yp_code != YP_ANY
68: && yp -> yp_code != YP_NULL
69: && (yp -> yp_code != YP_CHOICE
70: || (yp -> yp_flags & YP_CONTROLLED))
71: ? "register " : "");
72: printf ("integer\tlen;\nchar *buffer;\n%s parm;\n{\n",
73: yp -> yp_param_type ? yp -> yp_param_type : "PEPYPARM");
74:
75: if (yp -> yp_action0) {
76: if (!Pflag && *sysin)
77: printf ("# line %d \"%s\"\n", yp -> yp_act0_lineno, sysin);
78: printf ("%*s%s\n", level * 4, "", yp -> yp_action0);
79: }
80: }
81:
82: pushdown = (yp -> yp_flags & (YP_TAG | YP_IMPLICIT)) == YP_TAG;
83:
84: for (t = tuples; t -> t_type != YP_UNDF; t++)
85: if (t -> t_type == yp -> yp_code) {
86: class = t -> t_class;
87: value = t -> t_id;
88: if((form = t -> t_form) == NULL)
89: form = "PE_FORM_PRIM";
90: break;
91: }
92: if ((yp -> yp_flags & (YP_TAG | YP_IMPLICIT)) == (YP_TAG | YP_IMPLICIT)) {
93: (void) sprintf (tbuf2, "PE_CLASS_%s",
94: pe_classlist[yp -> yp_tag -> yt_class]);
95: class = tbuf2;
96: (void) sprintf (tbuf1, "%d",val2int (yp -> yp_tag -> yt_value));
97: value = tbuf1;
98: }
99:
100: switch (yp -> yp_code) {
101: case YP_BOOL:
102: printf ("%*sregister int %s = %s;\n\n", level * 4, "",
103: narg = gensym (), yp -> yp_intexp ? yp -> yp_intexp
104: : level == 1 ? "len" : "0");
105: break;
106: case YP_INT:
107: case YP_INTLIST:
108: case YP_ENUMLIST:
109: printf ("%*sregister integer %s = %s;\n\n", level * 4, "",
110: narg = gensym (), yp -> yp_intexp ? yp -> yp_intexp
111: : level == 1 ? "len" : "0");
112: break;
113:
114: case YP_REAL:
115: printf ("%*sregister double %s = 0.0;\n\n", level * 4, "",
116: narg = gensym ());
117: if (yp -> yp_strexp)
118: printf ("%*s%s = %s;\n", level * 4, "", narg,
119: yp -> yp_strexp);
120: break;
121:
122: case YP_BIT:
123: case YP_BITLIST:
124: printf ("%*sPE\t%s_z = NULLPE;\n", level * 4, "",
125: narg = gensym ());
126: printf ("%*sregister PE *%s = &%s_z;\n\n", level * 4, "",
127: narg, narg);
128: narg = add_point (narg);
129: printf ("%*schar *%s;\n%*sint %s;\n", level * 4, "",
130: narg2 = gensym (), level * 4, "", narg3 = gensym ());
131:
132: if (yp -> yp_strexp)
133: printf ("%*s%s = %s;\n%*s%s = %s;\n", level * 4, "",
134: narg2, yp -> yp_strexp, level * 4, "", narg3,
135: yp -> yp_intexp);
136: else
137: if (level == 1)
138: printf ("%*s%s = buffer;\n%*s%s = len;\n", level * 4, "",
139: narg2, level * 4, "", narg3);
140: else
141: printf ("%*s%s = NULLCP;\n%*s%s = 0;\n", level * 4, "",
142: narg2, level * 4, "", narg3);
143: printf ("%*s%s = %s ? strb2bitstr (%s, %s, %s, %s) : NULLPE;\n",
144: level * 4, "", narg, narg2, narg2, narg3, class, value);
145: break;
146:
147: case YP_OCT:
148: narg = gensym ();
149: if (yp -> yp_prfexp != 'q') {
150: printf ("%*sregister char *%s;\n%*sint %s_len;\n\n",
151: level * 4, "", narg, level * 4, "", narg);
152: if (yp -> yp_strexp) {
153: printf ("%*s%s = %s;\n", level * 4, "",
154: narg, yp -> yp_strexp);
155: if (yp -> yp_intexp)
156: printf ("%*s%s_len = %s;\n", level * 4, "",
157: narg, yp -> yp_intexp);
158: else
159: printf ("%*s%s_len = strlen (%s);\n", level * 4, "",
160: narg, narg);
161: }
162: else
163: if (level == 1) {
164: printf ("%*s%s = buffer;\n", level * 4, "", narg);
165: printf ("%*sif ((%s_len = len) == 0)\n", level * 4, "",
166: narg);
167: printf ("%*s%s_len = strlen (%s);\n",
168: (level + 1) * 4, "", narg, narg);
169: }
170: else
171: printf ("%*s%s = NULLCP;\n%*s%s_len = 0;\n",
172: level * 4, "", narg, level * 4, "", narg);
173: }
174: else {
175: printf ("%*sregister struct qbuf *%s;\n\n",
176: level * 4, "", narg);
177: printf ("%*s%s = %s;\n", level * 4, "", narg, yp -> yp_strexp);
178: }
179: break;
180:
181: case YP_SEQ:
182: case YP_SET:
183: case YP_ANY:
184: if (yp -> yp_strexp) {
185: printf ("%*sPE\t%s = %s;\n\n", level * 4, "",
186: narg = gensym (), yp -> yp_strexp);
187: break;
188: }
189: /* else fall */
190: case YP_NULL:
191: case YP_IDEFINED:
192: narg = NULL;
193: break;
194:
195: case YP_CHOICE:
196: if (yp -> yp_type && yp -> yp_control)
197: printf ("%*sint\t%s;\n\n", level * 4, "", narg2 = gensym ());
198: narg = NULL;
199: break;
200:
201: case YP_OID:
202: printf ("%*sregister OID %s;\n\n", level * 4, "",
203: narg = gensym ());
204: if (yp -> yp_strexp)
205: printf ("%*s%s = %s;\n", level * 4, "", narg, yp -> yp_strexp);
206: else if (level == 1)
207: printf ("%*s%s = buffer ? str2oid (buffer) : NULLOID;\n",
208: level * 4, "", narg);
209: else
210: printf ("%*s%s = NULLOID;\n", level * 4, "", narg);
211: break;
212:
213: case YP_SEQTYPE:
214: case YP_SETTYPE:
215: printf ("%*sPE\t%s = NULLPE;\n", level * 4, "",
216: narg2 = gensym ());
217: /* and fall ... */
218: case YP_SEQLIST:
219: case YP_SETLIST:
220: printf ("%*sPE\t%s_z = NULLPE;\n", level * 4, "",
221: narg = gensym ());
222: printf ("%*sregister PE *%s = &%s_z;\n\n", level * 4, "",
223: narg, narg);
224: narg = add_point(narg);
225: break;
226:
227: default:
228: myyerror ("unknown type: %d", yp -> yp_code);
229: }
230:
231: switch (yp -> yp_code) {
232: case YP_SEQ:
233: case YP_SET:
234: if (yp -> yp_strexp)
235: break;
236: /* else fall */
237: case YP_SEQTYPE:
238: case YP_SETTYPE:
239: case YP_SEQLIST:
240: case YP_SETLIST:
241: case YP_NULL:
242: printf ("%*sif ((%s = pe_alloc (%s, %s, %s)) == NULLPE) {\n",
243: level * 4, "", arg, class, form, value);
244: printf ("%*sadvise (NULLCP, \"%s: %%s\", PEPY_ERR_NOMEM);\n",
245: (level + 1) * 4, "", id);
246: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "",
247: level * 4, "");
248: break;
249: }
250:
251: if (!dflag && yp -> yp_action05)
252: do_action (yp -> yp_action05, level, narg ? narg : arg,
253: yp -> yp_act05_lineno);
254: if (!dflag && yp -> yp_action1)
255: do_action (yp -> yp_action1, level, narg ? narg : arg,
256: yp -> yp_act1_lineno);
257:
258: switch (yp -> yp_code) {
259: case YP_BOOL:
260: printf ("%*sif ((%s = flag2prim (%s, %s, ",
261: level * 4, "", arg, narg, class);
262: printf ("%s)) == NULLPE) {\n", value);
263: printf ("%*sadvise (NULLCP, \"%s: %%s\", PEPY_ERR_NOMEM);\n",
264: (level + 1) * 4, "", id);
265: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "",
266: level * 4, "");
267: break;
268:
269: case YP_INT:
270: case YP_INTLIST:
271: case YP_ENUMLIST:
272: printf ("%*sif ((%s = %snum2prim (%s, %s, ",
273: level * 4, "", arg,
274: yp->yp_code == YP_ENUMLIST ? "e" : "",
275: narg, class);
276: printf ("%s)) == NULLPE) {\n", value);
277: printf ("%*sadvise (NULLCP, \"%s: %%s\", PEPY_ERR_NOMEM);\n",
278: (level + 1) * 4, "", id);
279: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "",
280: level * 4, "");
281: if (yp -> yp_code == YP_INT)
282: break;
283: uniqint (yp -> yp_value);
284: printf ("%*sswitch (%s) {\n", level * 4, "", narg);
285: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) {
286: printf ("%*scase %d:", (level + 1) * 4, "", val2int (yv));
287: if (yv -> yv_flags & YV_NAMED)
288: printf ("\t/* %s */", yv -> yv_named);
289: printf ("\n");
290: if (!dflag && yv -> yv_action)
291: do_action (yv -> yv_action, level + 2, narg,
292: yv -> yv_act_lineno);
293: printf ("%*sbreak;\n", (level + 2) * 4, "");
294: }
295: if (!rflag && yp -> yp_code == YP_ENUMLIST) {
296: printf ("%*sdefault:\n", (level + 1) * 4, "");
297: printf ("%*sadvise (NULLCP, \"%s %%s%%d\", PEPY_ERR_UNK_COMP, %s);\n",
298: (level + 2) * 4, "", id, narg);
299: printf ("%*sreturn NOTOK;\n", (level + 2) * 4, "");
300: }
301: printf ("%*s}\n", level * 4, "");
302: break;
303:
304: case YP_REAL:
305: printf ("%*sif ((%s = real2prim (%s, %s, ",
306: level * 4, "", arg, narg, class);
307: printf ("%s)) == NULLPE) {\n", value);
308: printf ("%*sadvise (NULLCP, \"%s: %%s\", PEPY_ERR_NOMEM);\n",
309: (level + 1) * 4, "", id);
310: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "",
311: level * 4, "");
312: break;
313:
314: case YP_BIT:
315: case YP_BITLIST:
316: printf ("%*sif (%s == NULLPE) {\n", level * 4, "", narg);
317: printf ("%*sadvise (NULLCP, \"%s %%s\", PEPY_ERR_INIT_FAILED);\n",
318: (level + 1) * 4, "", id);
319: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "",
320: level * 4, "");
321: if (!yp -> yp_strexp && level != 1)
322: printf ("%*s%s -> pe_class = %s;\n%*s%s -> pe_id = %s;\n",
323: level * 4, "", narg, class, level * 4, "", narg, value);
324: if (yp -> yp_code == YP_BITLIST) {
325: register int j;
326:
327: for (yv = yp -> yp_value, i = -1; yv; yv = yv -> yv_next)
328: if ((j = val2int (yv)) > i)
329: i = j;
330: if (i >= 0)
331: printf ("%*sif (bit_test (%s, %d) == NOTOK)\n%*s(void) bit_off (%s, %d);\n",
332: level * 4, "", narg, i,
333: (level + 1) * 4, "", narg, i);
334: }
335: printf ("%*sif ((%s = bit2prim (%s)) == NULLPE) {\n",
336: level * 4, "", arg, narg);
337: printf ("%*sadvise (NULLCP, \"%s: %%s\", PEPY_ERR_NOMEM);\n",
338: (level + 1) * 4, "", id);
339: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "",
340: level * 4, "");
341: if (yp -> yp_code == YP_BIT)
342: break;
343: printf ("#define\tBITS\t\"\\020");
344: for (yv = yp -> yp_value; yv; yv = yv -> yv_next)
345: if (yv -> yv_flags & YV_NAMED)
346: printf ("\\0%o%s", val2int (yv) + 1, yv -> yv_named);
347: else
348: printf ("\\0%oBIT%d", val2int (yv) + 1, val2int (yv));
349: printf ("\"\n");
350: uniqint (yp -> yp_value);
351: if (!dflag)
352: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) {
353: if (!yv -> yv_action)
354: continue;
355: printf ("%*sif (bit_test (%s, %d) > OK) {",
356: level * 4, "", narg, val2int (yv));
357: if (yv -> yv_flags & YV_NAMED)
358: printf ("\t/* %s */", yv -> yv_named);
359: printf ("\n");
360: do_action (yv -> yv_action, level + 1, narg,
361: yv -> yv_act_lineno);
362: printf ("%*s}\n", level * 4, "");
363: }
364: break;
365:
366: case YP_OCT:
367: printf ("%*sif (%s == %s) {\n",
368: level * 4, "", narg,
369: yp -> yp_prfexp != 'q' ? "NULLCP" : "((struct qbuf *) 0)");
370: printf ("%*sadvise (NULLCP, \"%s %%s\", PEPY_ERR_INIT_FAILED);\n",
371: (level + 1) * 4, "", id);
372: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "",
373: level * 4, "");
374: printf ("%*sif ((%s = ", level * 4, "", arg);
375: if (yp -> yp_prfexp != 'q')
376: printf ("str2prim (%s, %s_len,", narg, narg);
377: else
378: printf ("qb2prim (%s,", narg);
379: printf (" %s, %s)) == NULLPE) {\n", class, value);
380: printf ("%*sadvise (NULLCP, \"%s: %%s\", PEPY_ERR_NOMEM);\n",
381: (level + 1) * 4, "", id);
382: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "",
383: level * 4, "");
384: break;
385:
386: case YP_NULL:
387: break;
388:
389: case YP_ANY:
390: case YP_SEQ:
391: case YP_SET:
392: if (!yp -> yp_strexp)
393: break;
394: printf ("%*sif (%s == NULLPE) {\n", level * 4, "", narg);
395: printf ("%*sadvise (NULLCP, \"%s %%s\", PEPY_ERR_INIT_FAILED);\n",
396: (level + 1) * 4, "", id);
397: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "",
398: level * 4, "");
399: #ifdef notdef
400: printf ("%*sif ((%s = pe_cpy (%s)) == NULLPE) {\n",
401: level * 4, "", arg, narg);
402: printf ("%*sadvise (NULLCP, \"%s: %%s\", PEPY_ERR_NOMEM);\n",
403: (level + 1) * 4, "", id);
404: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "",
405: level * 4, "");
406: #else
407: printf ("%*s(%s = %s) -> pe_refcnt++;\n",
408: level * 4, "", arg, narg);
409: #endif
410: break;
411:
412: case YP_OID:
413: printf ("%*sif (%s == NULLOID) {\n", level * 4, "", narg);
414: printf ("%*sadvise (NULLCP, \"%s %%s\", PEPY_ERR_INIT_FAILED);\n",
415: (level + 1) * 4, "", id);
416: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "",
417: level * 4, "");
418: printf ("%*sif ((%s = obj2prim (%s, %s, %s)) == NULLPE) {\n",
419: level * 4, "", arg, narg, class, value);
420: printf ("%*sadvise (NULLCP, \"%s: %%s\", PEPY_ERR_NOMEM);\n",
421: (level + 1) * 4, "", id);
422: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "",
423: level * 4, "");
424: break;
425:
426: case YP_SEQTYPE:
427: if (yp -> yp_type && yp -> yp_control) {
428: printf ("%*sfor (%s) {\n",
429: level * 4, "", yp -> yp_control);
430: if (!dflag && yp -> yp_action3) {
431: do_action (yp -> yp_action3, ++level, narg ? narg : arg,
432: yp -> yp_act3_lineno);
433: printf ("%*s{\n", level * 4, "");
434: }
435: do_type (yp -> yp_type, level + 1, "element", narg);
436: if (!dflag && yp -> yp_action3)
437: printf ("%*s}\n", level-- * 4, "");
438: #ifndef notdef
439: printf ("%*sseq_addon (%s, %s, %s);\n", (level + 1) * 4, "",
440: arg, narg2, narg);
441: printf ("%*s%s = %s;\n%*s}\n", (level + 1) * 4, "",
442: narg2, narg, level * 4, "");
443: #else
444: printf ("%*sif (seq_add (%s, %s, -1) == NOTOK) {\n",
445: (level + 1) * 4, "", arg, narg);
446: printf ("%*sadvise (NULLCP, \"%s %%s: %%s\", PEPY_ERR_BAD_SEQ,\n",
447: (level + 2) * 4, "", id);
448: printf ("%*spe_error (%s -> pe_errno));\n", (level + 4) * 4,
449: "", arg);
450: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 2) * 4, "",
451: (level + 1) * 4, "");
452: printf ("%*s}\n", level * 4, "");
453: #endif
454: }
455: break;
456:
457: case YP_SEQLIST:
458: for (y = yp -> yp_type, i = 0; y; y = y -> yp_next, i++) {
459: if (y -> yp_flags & YP_COMPONENTS)
460: do_components_seq (y, level, y -> yp_next == NULLYP,
461: id, arg, narg);
462: else {
463: do_type_element (y, level, y -> yp_next == NULLYP,
464: id, narg);
465: printf ("%*sif (%s != NULLPE)\n", level * 4, "", narg);
466: printf ("%*sif (seq_add (%s, %s, -1) == NOTOK) {\n",
467: (level + 1) * 4, "", arg, narg);
468: printf ("%*sadvise (NULLCP, \"%s %%s%%s\", PEPY_ERR_BAD_SEQ,\n",
469: (level + 2) * 4, "", id);
470: printf ("%*spe_error (%s -> pe_errno));\n", (level + 4) * 4,
471: "", arg);
472: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 2) * 4, "",
473: (level + 1) * 4, "");
474: }
475: }
476: for (y = yp -> yp_type; y; y = y -> yp_next) {
477: register YP z;
478:
479: if (!(y -> yp_flags & (YP_OPTIONAL | YP_DEFAULT))
480: || lookup_tag (y) == NULLYT)
481: continue;
482: for (z = y -> yp_next; z; z = z -> yp_next)
483: if (!(z -> yp_flags & (YP_OPTIONAL | YP_DEFAULT))
484: || lookup_tag (z) == NULLYT)
485: break;
486: uniqtag (y, z);
487: if (z == NULLYP)
488: break;
489: y = z;
490: }
491: break;
492:
493: case YP_SETTYPE:
494: if (yp -> yp_type && yp -> yp_control) {
495: printf ("%*sfor (%s) {\n",
496: level * 4, "", yp -> yp_control);
497: if (!dflag && yp -> yp_action3) {
498: do_action (yp -> yp_action3, ++level, narg ? narg : arg,
499: yp -> yp_act3_lineno);
500: printf ("%*s{\n", level * 4, "");
501: }
502: do_type (yp -> yp_type, level + 1, "member", narg);
503: if (!dflag && yp -> yp_action3)
504: printf ("%*s}\n", level-- * 4, "");
505: #ifndef notdef
506: printf ("%*sset_addon (%s, %s, %s);\n", (level + 1) * 4, "",
507: arg, narg2, narg);
508: printf ("%*s%s = %s;\n%*s}\n", (level + 1) * 4, "",
509: narg2, narg, level * 4, "");
510: #else
511: printf ("%*sif (seq_add (%s, %s, -1) == NOTOK) {\n",
512: (level + 1) * 4, "", arg, narg);
513: printf ("%*sadvise (NULLCP, \"%s %%s%%s\", PEPY_ERR_BAD_SET,\n",
514: (level + 2) * 4, "", id);
515: printf ("%*spe_error (%s -> pe_errno));\n", (level + 4) * 4,
516: "", arg);
517: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 2) * 4, "",
518: (level + 1) * 4, "");
519: printf ("%*s}\n", level * 4, "");
520: #endif
521: }
522: break;
523:
524: case YP_SETLIST:
525: if (yp -> yp_type) {
526: for (y = yp -> yp_type; y; y = y -> yp_next) {
527: if (y -> yp_flags & YP_COMPONENTS)
528: do_components_set (y, level, id, arg, narg);
529: else {
530: do_type_member (y, level, narg);
531: printf ("%*sif (%s != NULLPE)\n", level * 4, "", narg);
532: printf ("%*sif (set_add (%s, %s) == NOTOK) {\n",
533: (level + 1) * 4, "", arg, narg);
534: printf ("%*sadvise (NULLCP, \"%s %%s%%s\", PEPY_ERR_BAD_SET,\n",
535: (level + 2) * 4, "", id);
536: printf ("%*spe_error (%s -> pe_errno));\n",
537: (level + 4) * 4, "", arg);
538: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 2) * 4, "",
539: (level + 1) * 4, "");
540: }
541: }
542: /* now pull up fully to check uniqueness */
543: choice_pullup (y = copy_type (yp), CH_FULLY);
544: uniqtag (y -> yp_type, NULLYP);
545: }
546: break;
547:
548: case YP_CHOICE:
549: if (yp -> yp_type && yp -> yp_control) {
550: printf ("%*sswitch (%s = (%s)) {\n",
551: level * 4, "", narg2, yp -> yp_control);
552: for (y = yp -> yp_type, i = 0; y; y = y -> yp_next)
553: do_type_choice (y, ++i, level + 1, arg);
554: choice_pullup (yp, CH_FULLY);
555: uniqtag (yp -> yp_type, NULLYP);
556: printf ("\n%*sdefault:\n", (level + 1) * 4, "");
557: printf ("%*sadvise (NULLCP, \"%s %%s%%d\", PEPY_ERR_INVALID_CHOICE, \n",
558: (level + 2) * 4, "", id);
559: printf ("%*s%s);\n", (level + 4) * 4, "", narg2);
560: printf ("%*sreturn NOTOK;\n", (level + 2) * 4, "");
561: printf ("%*s}\n", level * 4, "");
562: if ((yp -> yp_flags & YP_TAG)
563: && !(yp -> yp_flags & YP_PULLEDUP))
564: tag_pushdown (yp, level, arg, "choice");
565: }
566: break;
567:
568: case YP_IDEFINED:
569: printf ("%*sif (%s (", level * 4, "", modsym (yp -> yp_module,
570: yp -> yp_identifier, YP_ENCODER));
571: i = strlen (arg) - 3;
572: printf ("%*.*s, 0, ", i, i, arg + 2);
573: if (yp -> yp_intexp)
574: printf ("%s, ", yp -> yp_intexp);
575: else if (level == 1)
576: printf ("len, ");
577: else
578: printf ("NULLINT, ");
579: if (yp -> yp_strexp)
580: printf ("%s", yp -> yp_strexp);
581: else if (level == 1)
582: printf ("buffer");
583: else
584: printf ("NULLCP");
585: if (yp -> yp_flags & YP_PARMVAL)
586: printf (", %s", yp -> yp_parm);
587: else
588: printf (", NullParm");
589: printf (") == NOTOK)\n%*sreturn NOTOK;\n", (level + 1) * 4, "");
590: if ((yp -> yp_flags & (YP_TAG | YP_IMPLICIT))
591: == (YP_TAG | YP_IMPLICIT)) {
592: if (is_nonimplicit_type (yp))
593: pushdown = 1;
594: else {
595: printf ("%*s%s -> pe_class = %s;\n", level * 4, "",
596: arg, class);
597: printf ("%*s%s -> pe_id = %s;\n", level * 4, "",
598: arg, value);
599: }
600: }
601: break;
602:
603: default:
604: myyerror ("unknown type: %d", yp -> yp_code);
605: }
606: if (pushdown && !(yp -> yp_flags & YP_PULLEDUP)) {
607: switch (yp -> yp_code) { /* sets & seqs are implicit implicit's? */
608: case YP_CHOICE:
609: break;
610:
611: default:
612: tag_pushdown (yp, level, arg, id);
613: break;
614: }
615: }
616:
617: printf ("\n#ifdef DEBUG\n%*s(void) testdebug (%s, \"",
618: level * 4, "", arg);
619: if (level == 1)
620: printf ("%s.", mymodule);
621: printf ("%s\");\n#endif\n\n", id);
622:
623: if (!dflag && yp -> yp_action2)
624: do_action (yp -> yp_action2, level, arg, yp -> yp_act2_lineno);
625:
626: switch (yp -> yp_code) {
627: case YP_BITLIST:
628: printf ("#undef\tBITS\n");
629: break;
630:
631: default:
632: break;
633: }
634: }
635:
636:
637: static char *add_point (arg)
638: char *arg;
639: {
640: char buffer[BUFSIZ];
641:
642: (void) sprintf (buffer, "(*%s)", arg);
643: return new_string (buffer);
644: }
645:
646: /* */
647:
648: static do_type_member (yp, level, narg)
649: register YP yp;
650: register int level;
651: char *narg;
652: {
653: int pushdown = (yp -> yp_flags & (YP_TAG | YP_IMPLICIT)) == YP_TAG;
654: char *id = yp -> yp_flags & YP_ID ? yp -> yp_id : "member";
655:
656: if (!(yp -> yp_flags & YP_TAG)) {
657: switch (yp -> yp_code) {
658: case YP_CHOICE:
659: break;
660: case YP_IDEFINED:
661: if (lookup_tag (yp) == NULLYT)
662: break;
663: /* else drop ... */
664: default:
665: tag_type (yp);
666: break;
667: }
668: }
669: printf ("%*s%s = NULLPE;\n\n", level * 4, "", narg);
670: if (yp -> yp_flags & (YP_OPTIONAL | YP_DEFAULT)) {
671: if (yp -> yp_flags & YP_OPTCONTROL)
672: printf ("%*sif (%s) {\n", level * 4, "", yp -> yp_optcontrol);
673: else
674: return;
675: }
676: else
677: printf ("%*s{\n", level * 4, "");
678:
679: level++;
680: yp -> yp_flags |= YP_PULLEDUP;
681:
682: do_type (yp, level, id, narg);
683:
684: if (pushdown)
685: tag_pushdown (yp, level, narg, id);
686:
687: level--;
688: printf ("%*s}\n", level * 4, "");
689: }
690:
691:
692: /* */
693:
694: static do_type_choice (yp, caseindex, level, narg)
695: register YP yp;
696: register int caseindex,
697: level;
698: register char *narg;
699: {
700: int pushdown = (yp -> yp_flags & YP_TAG)
701: && !(yp -> yp_flags & YP_IMPLICIT);
702: char *id = yp -> yp_flags & YP_ID ? yp -> yp_id : "member";
703:
704: printf ("%*scase %d:", level * 4, "", caseindex);
705: if (yp -> yp_flags & YP_ID)
706: printf ("\t/* %s */", yp -> yp_id);
707: printf ("\n");
708: level++;
709:
710: printf ("%*s{\n", level * 4, "");
711: level++;
712:
713: yp -> yp_flags |= YP_PULLEDUP;
714:
715: do_type (yp, level, id, narg);
716:
717: if (pushdown) {
718: tag_pushdown (yp, level, narg, id);
719: }
720:
721: level--;
722: printf ("%*s}\n%*sbreak;\n", level * 4, "", level * 4, "");
723: }
724:
725: /* */
726:
727: do_action (action, level, arg, lineno)
728: register char *action,
729: *arg;
730: register int level;
731: int lineno;
732: {
733: register char c,
734: d;
735:
736: printf ("%*s{\n", level * 4, "");
737:
738: if (!Pflag && *sysin)
739: printf ("# line %d \"%s\"\n", lineno, sysin);
740:
741: for (d = NULL; c = *action++; d = c)
742: switch (d) {
743: case '$':
744: if (c == '$') {
745: printf ("%s", arg);
746: c = NULL;
747: break;
748: }
749: putchar ('$'); /* fall */
750:
751: default:
752: if (c != '$')
753: putchar (c);
754: break;
755: }
756:
757: switch (d) {
758: case '\n':
759: break;
760:
761: case '$':
762: putchar ('$'); /* fall */
763: default:
764: putchar ('\n');
765: break;
766: }
767:
768: printf ("%*s}\n", level * 4, "");
769: }
770:
771: /* */
772:
773: /* ARGSUSED */
774:
775: static do_type_element (yp, level, last, id, narg)
776: register YP yp;
777: register int level;
778: int last;
779: char *id;
780: register char *narg;
781: {
782: printf ("%*s%s = NULLPE;\n\n", level * 4, "", narg);
783: if (yp -> yp_flags & (YP_OPTIONAL | YP_DEFAULT)) {
784: if (yp -> yp_flags & YP_OPTCONTROL)
785: printf ("%*sif (%s) {", level * 4, "", yp -> yp_optcontrol);
786: else
787: return;
788: }
789: else {
790: printf ("%*s{", level * 4, "");
791: }
792: level++;
793: if (yp -> yp_flags & YP_ID)
794: printf ("\t/* %s */", yp -> yp_id);
795: printf ("\n");
796: do_type (yp, level, yp -> yp_flags & YP_ID ? yp -> yp_id : "element",
797: narg);
798:
799: level--;
800: printf ("%*s}\n\n", level * 4, "");
801: }
802:
803: static do_components_seq (yp, level, last, id, arg, narg)
804: YP yp;
805: register int level;
806: register char *id,
807: *arg,
808: *narg;
809: {
810: YP newyp, y;
811:
812: if (yp -> yp_module) {
813: pyyerror (yp, "Can't do COMPONENTS OF with external types for %s",
814: yp -> yp_identifier);
815: return;
816: }
817:
818: if (!(newyp = lookup_type (yp->yp_module, yp -> yp_identifier))) {
819: pyyerror (yp, "Can't find refernced COMPONENTS OF");
820: return;
821: }
822:
823: if (newyp -> yp_code != YP_SEQLIST) {
824: yyerror_aux ("COMPONENTS OF type is not a SEQUENCE");
825: print_type (yp, 0);
826: return;
827: }
828: for (y = newyp -> yp_type; y; y = y -> yp_next) {
829: if (y -> yp_flags & YP_COMPONENTS)
830: do_components_seq (y, level, last && y -> yp_next == NULLYP,
831: id, arg, narg);
832: else {
833: do_type_element (y, level, last && y -> yp_next == NULLYP,
834: id, narg);
835: printf ("%*sif (%s != NULLPE)\n", level * 4, "", narg);
836: printf ("%*sif (seq_add (%s, %s, -1) == NOTOK) {\n",
837: (level + 1) * 4, "", arg, narg);
838: printf ("%*sadvise (NULLCP, \"%s %%s%%s\", PEPY_ERR_BAD_SEQ,\n",
839: (level + 2) * 4, "", id);
840: printf ("%*spe_error (%s -> pe_errno));\n", (level + 4) * 4,
841: "", arg);
842: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 2) * 4, "",
843: (level + 1) * 4, "");
844: }
845: }
846: for (y = newyp -> yp_type; y; y = y -> yp_next) {
847: register YP z;
848:
849: if (!(y -> yp_flags & (YP_OPTIONAL | YP_DEFAULT))
850: || lookup_tag (y) == NULLYT)
851: continue;
852: for (z = y -> yp_next; z; z = z -> yp_next)
853: if (!(z -> yp_flags & (YP_OPTIONAL | YP_DEFAULT))
854: || lookup_tag (z) == NULLYT)
855: break;
856: uniqtag (y, z);
857: if (z == NULLYP)
858: break;
859: y = z;
860: }
861: return;
862: }
863:
864:
865:
866: static do_components_set (yp, level, arg, id, narg)
867: register YP yp;
868: register int level;
869: char *narg, *arg, *id;
870: {
871:
872: YP newyp, y;
873:
874: if (yp -> yp_module) {
875: pyyerror (yp, "Can't do COMPONENTS OF with external types for %s",
876: yp -> yp_identifier);
877: return;
878: }
879:
880: if (!(newyp = lookup_type (yp->yp_module, yp -> yp_identifier))) {
881: pyyerror (yp, "Can't find refernced COMPONENTS OF");
882: return;
883: }
884:
885: if (newyp -> yp_code != YP_SETLIST) {
886: yyerror_aux ("COMPONENTS OF type is not a SET");
887: print_type (yp, 0);
888: return;
889: }
890:
891: for (y = newyp -> yp_type; y; y = y -> yp_next) {
892: if (y -> yp_flags & YP_COMPONENTS)
893: do_components_set (y, level, arg, id, narg);
894: else {
895: do_type_member (y, level, narg);
896: printf ("%*sif (%s != NULLPE)\n", level * 4, "", narg);
897: printf ("%*sif (set_add (%s, %s) == NOTOK) {\n",
898: (level + 1) * 4, "", arg, narg);
899: printf ("%*sadvise (NULLCP, \"%s %%s%%s\", PEPY_ERR_BAD_SET,\n",
900: (level + 2) * 4, "", id);
901: printf ("%*spe_error (%s -> pe_errno));\n",
902: (level + 4) * 4, "", arg);
903: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 2) * 4, "",
904: (level + 1) * 4, "");
905: }
906: }
907: choice_pullup (newyp, CH_FULLY);
908: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.