![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to posy.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 posy.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / pepy |
1.1 root 1: /* posy.c - PEPY optional structure-generator (yacc-based) */
2:
3: /* OPEN QUESTIONS:
4:
5: How to do smarter DEFAULT determination for the other types and NULLs
6:
7: Perhaps pull-up primitive IDentifiers
8:
9: Abort a CHOICE encoding if the structure is empty
10:
11:
12: HEURISTICS
13:
14: 1. LANGUAGE SIMPLIFICATIONS:
15:
16:
17: Pull-up uni-member SEQUENCEs/SETs/CHOICEs
18:
19:
20: 2. LANGUAGE ASSUMPTIONS:
21:
22: Unique tags to avoid conflicts for internal structures (-h1 option)
23:
24:
25: 3. STYLE ISSUES:
26:
27: SEQUENCE/SET OF Type should have Type be an ID for nicer naming
28: */
29:
30: #ifndef lint
31: static char *rcsid = "$Header: /f/osi/pepy/RCS/posy.c,v 7.3 90/02/23 17:50:09 mrose Exp $";
32: #endif
33:
34: /*
35: * $Header: /f/osi/pepy/RCS/posy.c,v 7.3 90/02/23 17:50:09 mrose Exp $
36: *
37: *
38: * $Log: posy.c,v $
39: * Revision 7.3 90/02/23 17:50:09 mrose
40: * update
41: *
42: * Revision 7.2 90/02/19 13:09:35 mrose
43: * update
44: *
45: * Revision 7.1 90/01/11 18:37:05 mrose
46: * real-sync
47: *
48: * Revision 7.0 89/11/23 22:11:59 mrose
49: * Release 6.0
50: *
51: */
52:
53: /*
54: * NOTICE
55: *
56: * Acquisition, use, and distribution of this module and related
57: * materials are subject to the restrictions of a license agreement.
58: * Consult the Preface in the User's Manual for the full terms of
59: * this agreement.
60: *
61: */
62:
63:
64: #include <ctype.h>
65: #include <stdio.h>
66: #include <varargs.h>
67: #include "pepy.h"
68:
69:
70: #define SVAL(s) ((s) ? (s) : "")
71: #define PARVAL(s) ((s) ? (s) : "parm")
72:
73: /* DATA */
74:
75: static int aflag = 0;
76: int Cflag = 0; /* posy */
77: int dflag = 0;
78: int Pflag = 0; /* pepy compat ... */
79: char *bflag = NULL; /* .. */
80: char *module_actions = NULL;
81: int pepydebug = 0;
82: int doexternals = 1;
83: static int fflag = 0;
84: static int linepos = 0;
85: static int mflag = 0;
86: static int sflag = 0;
87:
88: #define hflag (options[0])
89: #define Hflag (options[1])
90: #define h2flag (options[2])
91: #define NOPTIONS 3
92:
93: static int options[NOPTIONS];
94:
95: static char *eval = NULLCP;
96:
97: char *mymodule = "";
98: OID mymoduleid = NULLOID;
99: static char modulename[BUFSIZ];
100:
101: int yysection = YP_DECODER;
102: char *yyencpref = "encode";
103: char *yydecpref = "decode";
104: char *yyprfpref = "print";
105: char *yyencdflt = "encode";
106: char *yydecdflt = "decode";
107: char *yyprfdflt = "print";
108:
109: static char *classes[] = {
110: "UNIVERSAL ",
111: "APPLICATION ",
112: "",
113: "PRIVATE "
114: };
115:
116: static char *tags[] = {
117: "", "BOOLEAN", "INTEGER", "INTEGER", "BIT STRING", "BIT STRING",
118: "OCTET STRING", "NULL", "SEQUENCE", "SEQUENCE OF", "SEQUENCE", "SET",
119: "SET OF", "SET", "CHOICE", "ANY", "OBJECT IDENTIFIER", "", "ENUMERATED",
120: "REAL",
121:
122: NULL
123: };
124:
125: static char autogen[BUFSIZ];
126:
127: char *sysin = NULLCP;
128: static char sysout[BUFSIZ];
129: static char sysdef[BUFSIZ];
130: static char sysact[BUFSIZ];
131:
132: static FILE *fact;
133: static FILE *fdef;
134:
135: typedef struct modlist {
136: char *md_module;
137:
138: struct modlist *md_next;
139: } modlist, *MD;
140: #define NULLMD ((MD) 0)
141:
142: static MD mymodules = NULLMD;
143:
144: typedef struct symlist {
145: char *sy_encpref;
146: char *sy_decpref;
147: char *sy_prfpref;
148: char *sy_module;
149: char *sy_name;
150:
151: YP sy_type;
152:
153: struct symlist *sy_next;
154: } symlist, *SY;
155: #define NULLSY ((SY) 0)
156:
157: static SY mysymbols = NULLSY;
158:
159:
160: char *gensym (), *modsym (), *array ();
161: MD lookup_module ();
162: SY new_symbol (), add_symbol ();
163: static double val2real ();
164: static void prime_default ();
165: YP lookup_type ();
166:
167: /* MAIN */
168:
169: /* ARGSUSED */
170:
171: main (argc, argv, envp)
172: int argc;
173: char **argv,
174: **envp;
175: {
176: int i;
177: register char *cp,
178: *dp;
179:
180: dp = pepyversion + strlen ("pepy ");
181: fprintf (stderr, "posy %s\n", dp);
182:
183: sysout[0] = sysdef[0] = sysact[0] = NULL;
184: for (argc--, argv++; argc > 0; argc--, argv++) {
185: cp = *argv;
186:
187: if (strcmp (cp, "-a") == 0) {
188: aflag++;
189: continue;
190: }
191: if (strcmp (cp, "-d") == 0) {
192: dflag++;
193: continue;
194: }
195: if (strcmp (cp, "-f") == 0) {
196: dflag++, fflag++;
197: continue;
198: }
199: if (strncmp (cp, "-h", 2) == 0) {
200: if (cp[2] == NULL) {
201: hflag++;
202: continue;
203: }
204: if (sscanf (cp + 2, "%d", &i) != 1 || i >= NOPTIONS)
205: goto usage;
206: hflag++, options[i]++;
207: continue;
208: }
209: if (strcmp (cp, "-m") == 0) {
210: mflag++;
211: continue;
212: }
213: if (strcmp (cp, "-o") == 0) {
214: if (sysout[0]) {
215: fprintf (stderr, "too many output files\n");
216: exit (1);
217: }
218: argc--, argv++;
219: if ((cp = *argv) == NULL || (*cp == '-' && cp[1] != NULL))
220: goto usage;
221: (void) strcpy (sysout, cp);
222:
223: continue;
224: }
225: if (strcmp (cp, "-s") == 0) {
226: sflag++;
227: continue;
228: }
229:
230: if (sysin) {
231: usage: ;
232: fprintf (stderr,
233: "usage: posy [-a] [-d] [-f] [-Hh] [-o newmodule.py] [-s] module.py\n");
234: exit (1);
235: }
236:
237: if (*cp == '-') {
238: if (*++cp != NULL)
239: goto usage;
240: sysin = "";
241: }
242: sysin = cp;
243: }
244:
245: switch (pepydebug = (cp = getenv ("POSYTEST")) && *cp ? atoi (cp) : 0) {
246: case 2:
247: yydebug++; /* fall */
248: case 1:
249: sflag++; /* .. */
250: case 0:
251: break;
252: }
253:
254: if (sysin == NULLCP)
255: sysin = "";
256:
257: if (*sysin && freopen (sysin, "r", stdin) == NULL) {
258: fprintf (stderr, "unable to read "), perror (sysin);
259: exit (1);
260: }
261:
262: if (strcmp (sysout, "-") == 0)
263: sysout[0] = NULL;
264: if (*sysout && freopen (sysout, "w", stdout) == NULL) {
265: fprintf (stderr, "unable to write "), perror (sysout);
266: exit (1);
267: }
268:
269: if (cp = index (dp, ')')) {
270: for (cp++; *cp != ' '; cp++)
271: if (*cp == NULL)
272: break;
273: if (*cp == NULL)
274: cp = NULL;
275: }
276: if (cp == NULL)
277: cp = dp + strlen (dp);
278: (void) sprintf (autogen, "posy %*.*s", cp - dp, cp - dp, dp);
279: printf ("-- automatically generated by %s, do not edit!\n\n", autogen);
280:
281: initoidtbl ();
282:
283: exit (yyparse ()); /* NOTREACHED */
284: }
285:
286: /* ERRORS */
287:
288: yyerror (s)
289: register char *s;
290: {
291: yyerror_aux (s);
292:
293: if (*sysout)
294: (void) unlink (sysout);
295: if (*sysdef)
296: (void) unlink (sysdef);
297: if (*sysact)
298: (void) unlink (sysact);
299:
300: exit (1);
301: }
302:
303: #ifndef lint
304: warning (va_alist)
305: va_dcl
306: {
307: char buffer[BUFSIZ];
308: char buffer2[BUFSIZ];
309: char *cp;
310: va_list ap;
311:
312: va_start (ap);
313:
314: _asprintf (buffer, NULLCP, ap);
315:
316: va_end (ap);
317:
318: (void) sprintf (buffer2, "Warning: %s", buffer);
319: yyerror_aux (buffer2);
320: }
321:
322: #else
323:
324: /* VARARGS1 */
325: warning (fmt)
326: char *fmt;
327: {
328: warning (fmt);
329: }
330: #endif
331:
332: static yyerror_aux (s)
333: register char *s;
334: {
335: if (linepos)
336: fprintf (stderr, "\n"), linepos = 0;
337:
338: if (eval)
339: fprintf (stderr, "type %s: ", eval);
340: else
341: fprintf (stderr, "line %d: ", yylineno);
342: fprintf (stderr, "%s\n", s);
343: if (!eval)
344: fprintf (stderr, "last token read was \"%s\"\n", yytext);
345: }
346:
347: /* */
348:
349: #ifndef lint
350: myyerror (va_alist)
351: va_dcl
352: {
353: char buffer[BUFSIZ];
354: va_list ap;
355:
356: va_start (ap);
357:
358: _asprintf (buffer, NULLCP, ap);
359:
360: va_end (ap);
361:
362: yyerror (buffer);
363: }
364: #else
365: /* VARARGS */
366:
367: myyerror (fmt)
368: char *fmt;
369: {
370: myyerror (fmt);
371: }
372: #endif
373:
374:
375: #ifndef lint
376: static pyyerror (va_alist)
377: va_dcl
378: {
379: char buffer[BUFSIZ];
380: register YP yp;
381: va_list ap;
382:
383: va_start (ap);
384:
385: yp = va_arg (ap, YP);
386:
387: _asprintf (buffer, NULLCP, ap);
388:
389: va_end (ap);
390:
391: yyerror_aux (buffer);
392: print_type (yp, 0);
393:
394:
395: if (*sysout)
396: (void) unlink (sysout);
397: if (*sysdef)
398: (void) unlink (sysdef);
399: if (*sysact)
400: (void) unlink (sysact);
401:
402: exit (1);
403: }
404: #else
405: /* VARARGS */
406:
407: static pyyerror (yp, fmt)
408: YP yp;
409: char *fmt;
410: {
411: pyyerror (yp, fmt);
412: }
413: #endif
414:
415: /* */
416:
417: yywrap () {
418: if (linepos)
419: fprintf (stderr, "\n"), linepos = 0;
420:
421: return 1;
422: }
423:
424: /* */
425:
426: /* ARGSUSED */
427:
428: yyprint (s, f, top)
429: char *s;
430: int f;
431: int top;
432: {
433: int len;
434: static int nameoutput = 0;
435: static int outputlinelen = 79;
436:
437: if (sflag || !s)
438: return;
439:
440: if (!nameoutput) {
441: if (linepos)
442: fprintf (stderr, "\n\n");
443:
444: fprintf (stderr, "%s", mymodule);
445: nameoutput = (linepos = strlen (mymodule)) + 1;
446:
447: fprintf (stderr, " types:");
448: linepos += 7;
449:
450: if (top)
451: return;
452: }
453:
454: len = strlen (s);
455: if (linepos != nameoutput)
456: if (len + linepos + 1 > outputlinelen)
457: fprintf (stderr, "\n%*s", linepos = nameoutput, "");
458: else
459: fprintf (stderr, " "), linepos++;
460: fprintf (stderr, "%s", s);
461: linepos += len;
462: }
463:
464: /* PASS1 */
465:
466: pass1 ()
467: {
468: printf ("%s ", mymodule);
469: if (mymoduleid) {
470: printf ("%s ", oidprint(mymoduleid));
471: }
472: printf ("DEFINITIONS ::=\n\n");
473: }
474:
475: /* */
476:
477: pass1_type (encpref, decpref, prfpref, mod, id, yp)
478: register char *encpref,
479: *decpref,
480: *prfpref,
481: *mod,
482: *id;
483: register YP yp;
484: {
485: register SY sy;
486:
487: if (lookup_type (mod, id)) /* no duplicate entries, please... */
488: return;
489:
490: if (pepydebug) {
491: if (linepos)
492: fprintf (stderr, "\n"), linepos = 0;
493:
494: fprintf (stderr, "%s.%s\n", mod ? mod : mymodule, id);
495: print_type (yp, 0);
496: fprintf (stderr, "--------\n");
497: }
498: else
499: if (!(yp -> yp_flags & YP_IMPORTED))
500: yyprint (id, 0, 0);
501:
502: sy = new_symbol (encpref, decpref, prfpref, mod, id, yp);
503: mysymbols = add_symbol (mysymbols, sy);
504: }
505:
506: /* PASS2 */
507:
508: pass2 () {
509: int first;
510: register SY sy;
511: register YP yp,
512: y;
513:
514: if (!sflag)
515: (void) fflush (stderr);
516:
517: modsym_aux (mymodule, modulename);
518:
519: (void) sprintf (sysdef, "%s-types.h", mymodule);
520: if ((fdef = fopen (sysdef, "w")) == NULL)
521: myyerror ("unable to write %s", sysdef);
522: fprintf (fdef, "/* automatically generated by %s, do not edit! */\n\n",
523: autogen);
524: fprintf (fdef, "#ifndef\t_module_%s_defined_\n", modulename);
525: fprintf (fdef, "#define\t_module_%s_defined_\n\n", modulename);
526:
527: fprintf (fdef, "#ifndef PEPYPATH\n");
528: fprintf (fdef, "#include <isode/psap.h>\n");
529: if (strcmp (mymodule, "UNIV"))
530: fprintf (fdef, "#include <isode/pepy/UNIV-types.h>\n");
531: fprintf (fdef, "#else\n");
532: fprintf (fdef, "#include \"psap.h\"\n");
533: if (strcmp (mymodule, "UNIV"))
534: fprintf (fdef, "#include \"../pepy/UNIV-types.h\"\n");
535: fprintf (fdef, "#endif\n");
536:
537: fprintf (fdef, "\n\n");
538:
539: if (fflag) {
540: (void) sprintf (sysact, "%s-types.tmp", mymodule);
541: if ((fact = fopen (sysact, "w+")) == NULL)
542: myyerror ("unable to write %s", sysact);
543: }
544:
545: for (sy = mysymbols; sy; sy = sy -> sy_next) {
546: eval = sy -> sy_name;
547: yp = sy -> sy_type;
548: if (sy -> sy_module == NULLCP)
549: yyerror ("no module name associated with symbol");
550: if (yp -> yp_flags & YP_IMPORTED)
551: continue;
552:
553: do_struct0 (yp, eval);
554: if (ferror (stdout) || ferror (fdef) || (fflag && ferror (fact)))
555: myyerror ("write error - %s", sys_errname (errno));
556: }
557:
558: for (sy = mysymbols; sy; sy = sy -> sy_next) {
559: eval = sy -> sy_name;
560: yp = sy -> sy_type;
561: if (yp -> yp_flags & YP_IMPORTED)
562: continue;
563:
564: do_struct1 (yp, eval, NULLCP);
565: if (ferror (stdout) || ferror (fdef) || (fflag && ferror (fact)))
566: myyerror ("write error - %s", sys_errname (errno));
567: }
568:
569: for (sy = mysymbols; sy; sy = sy -> sy_next) {
570: eval = sy -> sy_name;
571: yp = sy -> sy_type;
572: if (yp -> yp_flags & YP_IMPORTED)
573: continue;
574:
575: do_struct2 (yp, eval, NULLCP);
576: if (ferror (stdout) || ferror (fdef) || (fflag && ferror (fact)))
577: myyerror ("write error - %s", sys_errname (errno));
578: }
579:
580: if (Cflag == 0)
581: printf ("%%{\n#include <stdio.h>\n#include \"%s\"\n%%}\n", sysdef);
582:
583: printf ("\nPREFIXES %s %s %s\n", yyencdflt, yydecdflt, yyprfdflt);
584:
585: printf ("\nBEGIN\n");
586:
587: print_expimp ();
588:
589: first = 1;
590: for (sy = mysymbols; sy; sy = sy -> sy_next) {
591: eval = sy -> sy_name;
592: yp = sy -> sy_type;
593: if (sy -> sy_module == NULLCP)
594: yyerror ("no module name associated with symbol");
595: if (yp -> yp_flags & YP_IMPORTED)
596: continue;
597:
598: if (first) {
599: printf ("\nENCODER %s\n", yyencpref);
600: first = 0;
601: }
602:
603: printf ("\n%s", sy -> sy_name);
604: printf (" [[P struct %s *]]",
605: modsym (mymodule, sy -> sy_name, "type"));
606: switch (yp -> yp_code) {
607: case YP_SEQTYPE:
608: case YP_SEQLIST:
609: case YP_SETTYPE:
610: case YP_SETLIST:
611: case YP_CHOICE:
612: if (yp -> yp_declexp || yp -> yp_type)
613: do_type0 (yp, YP_ENCODER);
614: break;
615:
616: case YP_BIT:
617: case YP_BITLIST:
618: do_type0 (yp, YP_ENCODER);
619: break;
620:
621: default:
622: if (!yp -> yp_declexp)
623: break;
624: do_type0 (yp, YP_ENCODER);
625: break;
626: }
627: printf (" ::=\n");
628: do_type1 (yp, 1, (yp -> yp_flags & YP_TAG) ? 1 : 2, eval, "parm",
629: NULLCP, YP_ENCODER);
630: printf ("\n");
631: if (ferror (stdout) || ferror (fdef) || (fflag && ferror (fact)))
632: myyerror ("write error - %s", sys_errname (errno));
633: }
634:
635: first = 1;
636: for (sy = mysymbols; sy; sy = sy -> sy_next) {
637: eval = sy -> sy_name;
638: yp = sy -> sy_type;
639: if (sy -> sy_module == NULLCP)
640: yyerror ("no module name associated with symbol");
641: if (yp -> yp_flags & YP_IMPORTED)
642: continue;
643:
644: if (first) {
645: printf ("\nDECODER %s\n", yydecpref);
646: first = 0;
647: }
648:
649: printf ("\n%s", sy -> sy_name);
650: printf (" [[P struct %s **]]",
651: modsym (mymodule, sy -> sy_name, "type"));
652: switch (yp -> yp_code) {
653: case YP_SEQTYPE:
654: case YP_SEQLIST:
655: case YP_SETTYPE:
656: case YP_SETLIST:
657: case YP_CHOICE:
658: if (yp -> yp_declexp || yp -> yp_type)
659: do_type0 (yp, YP_DECODER);
660: break;
661:
662: default:
663: if (!yp -> yp_declexp)
664: break;
665: do_type0 (yp, YP_DECODER);
666: break;
667: }
668: printf (" ::=\n");
669:
670: y = yp;
671: again: ;
672: switch (y -> yp_code) {
673: case YP_SEQTYPE:
674: case YP_SETTYPE:
675: if (h2flag)
676: xalloc (y, 0, 1, "parm",
677: modsym (mymodule, sy -> sy_name, "type"), 1);
678: break;
679:
680: case YP_BIT:
681: case YP_BITLIST:
682: case YP_SEQ:
683: case YP_SET:
684: case YP_ANY:
685: case YP_OCT:
686: case YP_OID:
687: case YP_IDEFINED:
688: case YP_REAL:
689: break;
690:
691: case YP_SEQLIST:
692: case YP_SETLIST:
693: case YP_CHOICE:
694: if (hflag && y -> yp_type && !y -> yp_type -> yp_next) {
695: y = y -> yp_type;
696: goto again;
697: }
698: /* else fall */
699:
700: default:
701: xalloc (y, 1, 1, "parm",
702: modsym (mymodule, sy -> sy_name, "type"), 1);
703: break;
704: }
705: do_type1 (yp, 1, (yp -> yp_flags & YP_TAG) ? 1 : 2, eval, "(*parm)",
706: NULLCP, YP_DECODER);
707: printf ("\n");
708: if (ferror (stdout) || ferror (fdef) || (fflag && ferror (fact)))
709: myyerror ("write error - %s", sys_errname (errno));
710: }
711:
712: printf ("\nEND\n");
713:
714: if (fflag) {
715: register int c;
716:
717: (void) fflush (fact);
718: (void) fseek (fact, 0L, 0);
719:
720: printf ("\n%%{\n");
721: while ((c = getc (fact)) != EOF)
722: putchar (c);
723: printf ("\n%%}\n");
724:
725: (void) fclose (fact);
726: if (*sysact)
727: (void) unlink (sysact);
728: }
729:
730: fprintf (fdef, "#endif\n");
731: (void) fflush (fdef);
732: (void) fflush (stdout);
733: if (ferror (stdout) || ferror (fdef))
734: myyerror ("write error - %s", sys_errname (errno));
735: (void) fclose (fdef);
736: }
737:
738: /* */
739:
740: /* ARGSUSED */
741:
742: static do_struct0 (yp, id)
743: register YP yp;
744: char *id;
745: {
746: register YP y;
747:
748: switch (yp -> yp_code) {
749: case YP_SEQLIST:
750: case YP_SETLIST:
751: components_pullup (yp);
752: break;
753:
754: default:
755: break;
756: }
757:
758: switch (yp -> yp_code) {
759: case YP_SEQTYPE:
760: case YP_SETTYPE:
761: do_struct0 (yp -> yp_type, id);
762: break;
763:
764: case YP_CHOICE:
765: case YP_SETLIST:
766: choice_pullup (yp, yp -> yp_code == YP_CHOICE ? CH_FULLY
767: : CH_PARTIAL);
768: /* and fall */
769: case YP_SEQLIST:
770: for (y = yp -> yp_type; y; y = y -> yp_next)
771: do_struct0 (y, id);
772: break;
773:
774: case YP_IDEFINED:
775: if (yp -> yp_module
776: && strcmp (yp -> yp_module, mymodule)
777: && !lookup_module (yp -> yp_module))
778: fprintf (fdef, "#include \"%s-types.h\"\n", yp -> yp_module);
779: break;
780:
781: default:
782: break;
783: }
784: }
785:
786: /* */
787:
788: static do_struct1 (yp, id, pullup)
789: register YP yp;
790: char *id,
791: *pullup;
792: {
793: register int i,
794: j;
795: char buf1[BUFSIZ];
796: register YP y;
797: register YV yv;
798:
799: switch (yp -> yp_code) {
800: case YP_BIT:
801: case YP_BITLIST:
802: case YP_SEQ:
803: case YP_SET:
804: case YP_ANY:
805: fprintf (fdef, "\n");
806: if (aflag)
807: printag (yp, 4, pullup);
808: fprintf (fdef, "#define\t%s\tPElement\n",
809: modsym (mymodule, id, "type"));
810: if (yp -> yp_code == YP_BITLIST) {
811: i = -1;
812: for (yv = yp -> yp_value; yv; yv = yv -> yv_next)
813: if ((j = val2int (yv)) < 0)
814: pyyerror (yp, "invalid bit number in BIT STRING");
815: else
816: if (j > i)
817: i = j;
818: if (i < sizeof (int) * 8) { /* NBBY */
819: fprintf (fdef, "#define\t%s\t\"\\020",
820: modsym (mymodule, eval, "bits"));
821: for (yv = yp -> yp_value; yv; yv = yv -> yv_next)
822: if (yv -> yv_flags & YV_NAMED)
823: fprintf (fdef, "\\0%o%s",
824: val2int (yv) + 1, yv -> yv_named);
825: else
826: fprintf (fdef, "\\0%oBIT%d",
827: val2int (yv) + 1, val2int (yv));
828: fprintf (fdef, "\"\n");
829: }
830: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) {
831: modsym_aux (yv -> yv_named, buf1);
832: fprintf (fdef, "#define\t%s_%s\t%d\n",
833: modsym (mymodule, eval, "bit"),
834: buf1, val2int (yv));
835: }
836: }
837: if (fflag)
838: fprintf (fdef, "#define\t%s\tpe_free\n",
839: modsym (mymodule, id, "free"));
840: break;
841:
842: case YP_OCT:
843: fprintf (fdef, "\n");
844: if (aflag)
845: printag (yp, 4, pullup);
846: fprintf (fdef, "#define\t%s\tqbuf\n",
847: modsym (mymodule, id, "type"));
848: if (fflag)
849: fprintf (fdef, "#define\t%s\tqb_free\n",
850: modsym (mymodule, id, "free"));
851: break;
852:
853: case YP_OID:
854: fprintf (fdef, "\n");
855: if (aflag)
856: printag (yp, 4, pullup);
857: fprintf (fdef, "#define\t%s\tOIDentifier\n",
858: modsym (mymodule, id, "type"));
859: if (fflag)
860: fprintf (fdef, "#define\t%s\toid_free\n",
861: modsym (mymodule, id, "free"));
862: break;
863:
864: case YP_IDEFINED:
865: fprintf (fdef, "\n");
866: if (aflag)
867: printag (yp, 4, pullup);
868: fprintf (fdef, "#define\t%s\t",
869: modsym (mymodule, id, "type"));
870: fprintf (fdef, "%s\n",
871: modsym (yp -> yp_module, yp -> yp_identifier, "type"));
872: if (fflag) {
873: fprintf (fdef, "#define\t%s\t",
874: modsym (mymodule, id, "free"));
875: fprintf (fdef, "%s\n",
876: modsym (yp -> yp_module, yp -> yp_identifier, "free"));
877: }
878: break;
879:
880: case YP_SEQLIST:
881: case YP_SETLIST:
882: case YP_CHOICE:
883: if (hflag && (y = yp -> yp_type) && !y -> yp_next) {
884: do_struct1 (y, id, tags[yp -> yp_code]);
885: break;
886: }
887: /* else fall */
888:
889: default:
890: break;
891: }
892: }
893:
894: /* */
895:
896: static do_struct2 (yp, id, pullup)
897: register YP yp;
898: char *id,
899: *pullup;
900: {
901: register YP y;
902: int flg = (yp -> yp_code == YP_SEQTYPE || yp -> yp_code == YP_SETTYPE);
903:
904: switch (yp -> yp_code) {
905: case YP_BIT:
906: case YP_BITLIST:
907: case YP_SEQ:
908: case YP_SET:
909: case YP_ANY:
910: case YP_OCT:
911: case YP_OID:
912: case YP_IDEFINED:
913: break;
914:
915: case YP_SEQLIST:
916: case YP_SETLIST:
917: case YP_CHOICE:
918: if (hflag && (y = yp -> yp_type) && !y -> yp_next) {
919: do_struct2 (y, id, tags[yp -> yp_code]);
920: break;
921: }
922: /* else fall */
923:
924: default:
925: fprintf (fdef, "\n");
926: if (aflag)
927: printag (yp, 4, pullup);
928: fprintf (fdef, "struct %s {\n", modsym (mymodule, id, "type"));
929: if (fflag) {
930: fprintf (fact, "\n%s (arg)\n", modsym (mymodule, id, "free"));
931: fprintf (fact, "struct %s *arg;\n{\n",
932: modsym (mymodule, id, "type"));
933: fprintf (fact, " struct %s *parm = arg;\n",
934: modsym (mymodule, id, "type"));
935: if (h2flag && flg)
936: fprintf (fact, " int\tn_parm;\n");
937: fprintf (fact, "\n if (parm == NULL)\n\treturn;\n\n");
938: }
939: posy (yp, 1, 1, "parm", id, "parm", flg && h2flag);
940: fprintf (fdef, "};\n");
941: fprintf (fdef, "int\t%s ();\n", modsym (mymodule, id, "free"));
942: if (fflag) {
943: if (yp -> yp_code != YP_SEQTYPE &&
944: yp -> yp_code != YP_SETTYPE)
945: fprintf (fact, "\n free ((char *) arg);");
946: fprintf (fact, "\n}\n");
947: }
948:
949: break;
950: }
951: }
952:
953: /* */
954:
955: static int type0_brackets;
956: static int type0_bit;
957:
958: static do_type0 (yp, direction)
959: register YP yp;
960: int direction;
961: {
962: type0_brackets = type0_bit = 0;
963: do_type0_aux (yp, direction);
964: if (type0_brackets)
965: printf (" %%}\n ");
966: }
967:
968: static do_type0_aux (yp, direction)
969: register YP yp;
970: int direction;
971: {
972: register YP y;
973:
974: if (yp -> yp_declexp) {
975: if (type0_brackets++ == 0)
976: printf ("\n %%{\n");
977: printf ("\tstruct %s *%s%s;\n", yp -> yp_declexp,
978: direction == YP_DECODER ? "*" : "", yp -> yp_declexp);
979: }
980:
981: switch (yp -> yp_code) {
982: case YP_SEQTYPE:
983: case YP_SETTYPE:
984: if (h2flag) {
985: if (type0_brackets++ == 0)
986: printf ("\n %%{\n");
987: printf ("\tint n_%s = 0;\n", yp -> yp_declexp ?
988: yp -> yp_declexp : "parm");
989: }
990: do_type0_aux (yp -> yp_type, direction);
991: break;
992:
993: case YP_SEQLIST:
994: case YP_SETLIST:
995: case YP_CHOICE:
996: for (y = yp -> yp_type; y; y = y -> yp_next)
997: do_type0_aux (y, direction);
998: break;
999:
1000: case YP_BIT:
1001: case YP_BITLIST:
1002: if (direction == YP_ENCODER) {
1003: if (type0_brackets++ == 0)
1004: printf ("\n %%{\n");
1005: if (type0_bit++ == 0)
1006: printf ("\tchar *bit_parm;\n");
1007: }
1008: break;
1009:
1010: default:
1011: break;
1012: }
1013: }
1014:
1015: /* */
1016:
1017: /* ARGSUSED */
1018:
1019: static do_type1 (yp, top, level, id, var, action2, direction)
1020: register YP yp;
1021: int top,
1022: level;
1023: char *id,
1024: *var,
1025: *action2;
1026: int direction;
1027: {
1028: int i;
1029: char *cp,
1030: *ep,
1031: buffer[BUFSIZ],
1032: varbuf[BUFSIZ];
1033: register YP y;
1034: register YV yv;
1035: register YT yt;
1036:
1037: printf ("%*s", level * 4, "");
1038:
1039: if (yp -> yp_flags & YP_ID) {
1040: printf ("%s", yp -> yp_id);
1041: if (!(yp -> yp_flags & YP_TAG))
1042: printf ("\n%*s", ++level * 4, "");
1043: }
1044:
1045: if (yp -> yp_flags & YP_TAG) {
1046: yt = yp -> yp_tag;
1047: printf ("[%s%d]\n", classes[yt -> yt_class], val2int (yt -> yt_value));
1048: level++;
1049: printf ("%*s", level * 4, "");
1050: }
1051: if (yp -> yp_flags & YP_OPTIONAL && yp -> yp_varexp) {
1052: if ((ep = index (yp -> yp_varexp, ' ')) == NULL)
1053: yyerror ("Bug in varexp!");
1054:
1055: (void) sprintf (varbuf, "%*.*s", ep - yp -> yp_varexp,
1056: ep - yp -> yp_varexp, yp -> yp_varexp);
1057: }
1058:
1059: switch (yp -> yp_code) {
1060: case YP_BOOL:
1061: if ((yp -> yp_flags & (YP_OPTIONAL|YP_DEFAULT)) &&
1062: direction == YP_DECODER) {
1063: if (!top && !(yp -> yp_flags & (YP_ID | YP_TAG)))
1064: printf ("dummy-for-default\n%*s", ++level * 4, "");
1065: if (yp -> yp_flags & YP_OPTIONAL)
1066: printf ("%%{ %s -> optionals |= %s; %%}\n%*s",
1067: varbuf, yp -> yp_optcontrol, level * 4, "");
1068: else
1069: printf ("%%{ %s%s = %d; %%}\n%*s",
1070: var, SVAL (yp -> yp_varexp),
1071: val2int (yp -> yp_default) ? 1 : 0, level * 4, "");
1072: }
1073: break;
1074:
1075: case YP_INT:
1076: if ((yp -> yp_flags & (YP_OPTIONAL|YP_DEFAULT)) &&
1077: direction == YP_DECODER) {
1078: if (!top && !(yp -> yp_flags & (YP_ID | YP_TAG)))
1079: printf ("dummy-for-default\n%*s", ++level * 4, "");
1080: if (yp -> yp_flags & YP_OPTIONAL)
1081: printf ("%%{ %s -> optionals |= %s; %%}\n%*s",
1082: varbuf, yp -> yp_optcontrol, level * 4, "");
1083: else
1084: printf ("%%{ %s%s = %d; %%}\n%*s",
1085: var, SVAL (yp -> yp_varexp),
1086: val2int (yp -> yp_default), level * 4, "");
1087: }
1088: break;
1089:
1090: case YP_INTLIST:
1091: case YP_ENUMLIST:
1092: if ((yp -> yp_flags & (YP_OPTIONAL|YP_DEFAULT)) &&
1093: direction == YP_DECODER) {
1094: if (!top && !(yp -> yp_flags & (YP_ID | YP_TAG)))
1095: printf ("dummy-for-default\n%*s", ++level * 4, "");
1096: if (yp -> yp_flags & YP_OPTIONAL)
1097: printf ("%%{ %s -> optionals |= %s; %%}\n%*s",
1098: varbuf, yp -> yp_optcontrol, level * 4, "");
1099: else
1100: printf ("%%{ %s%s = %d; %%}\n%*s",
1101: var, SVAL (yp -> yp_varexp), dfl2int (yp),
1102: level * 4, "");
1103: }
1104: break;
1105:
1106: case YP_REAL:
1107: if ((yp -> yp_flags & (YP_OPTIONAL|YP_DEFAULT)) &&
1108: direction == YP_DECODER) {
1109: if (!top && !(yp -> yp_flags & (YP_ID | YP_TAG)))
1110: printf ("dummy-for-default\n%*s", ++level * 4, "");
1111: if (yp -> yp_flags & YP_OPTIONAL)
1112: printf ("%%{ %s -> optionals |= %s; %%}\n%*s",
1113: varbuf, yp -> yp_optcontrol, level * 4, "");
1114: else
1115: printf ("%%{ %s%s = %g; %%}\n%*s",
1116: var, SVAL (yp -> yp_varexp),
1117: val2real (yp -> yp_default), level * 4, "");
1118: }
1119: break;
1120:
1121: case YP_NULL:
1122: if ((yp -> yp_flags & YP_OPTIONAL) && direction == YP_DECODER) {
1123: if (!top && !(yp -> yp_flags & (YP_ID | YP_TAG)))
1124: printf ("dummy-for-default\n%*s", ++level * 4, "");
1125: printf ("%%{ %s -> optionals |= %s; %%}\n%*s",
1126: varbuf, yp -> yp_optcontrol, level * 4, "");
1127: }
1128: break;
1129: }
1130:
1131: if ((yp -> yp_flags & (YP_TAG | YP_IMPLICIT)) == (YP_TAG | YP_IMPLICIT))
1132: printf ("IMPLICIT ");
1133: if (yp -> yp_flags & YP_BOUND)
1134: printf ("%s < ", yp -> yp_bound);
1135: if (yp -> yp_flags & YP_COMPONENTS)
1136: printf ("COMPONENTS OF ");
1137: if (yp -> yp_flags & YP_ENCRYPTED)
1138: printf ("ENCRYPTED ");
1139:
1140: switch (yp -> yp_code) {
1141: case YP_BOOL:
1142: printf ("BOOLEAN");
1143: switch (direction) {
1144: case YP_ENCODER:
1145: case YP_DECODER:
1146: printf (top ? "\n%*s[[b %s -> %s ]]" : "\n%*s[[b %s%s ]]",
1147: level * 4, "", var, SVAL (yp -> yp_varexp));
1148: break;
1149: }
1150: break;
1151:
1152: case YP_INT:
1153: printf ("INTEGER");
1154: switch (direction) {
1155: case YP_ENCODER:
1156: case YP_DECODER:
1157: printf (top ? "\n%*s[[i %s -> %s ]]" : "\n%*s[[i %s%s ]]",
1158: level * 4, "", var, SVAL (yp -> yp_varexp));
1159: break;
1160: }
1161: break;
1162:
1163: case YP_INTLIST:
1164: case YP_ENUMLIST:
1165: if (yp -> yp_code == YP_ENUMLIST)
1166: printf ("ENUMERATED");
1167: else
1168: printf ("INTEGER");
1169: switch (direction) {
1170: case YP_ENCODER:
1171: case YP_DECODER:
1172: printf (top ? "\n%*s[[i %s -> %s ]]\n%*s{\n"
1173: : "\n%*s[[i %s%s ]]\n%*s{\n",
1174: level * 4, "", var, SVAL (yp -> yp_varexp),
1175: level * 4, "");
1176: break;
1177:
1178: default:
1179: printf (" {\n");
1180: break;
1181: }
1182: level++;
1183: for (yv = yp -> yp_value; yv; yv = yv -> yv_next)
1184: printf ("%*s%s(%d)%s\n", level * 4, "", yv -> yv_named,
1185: val2int (yv), yv -> yv_next ? "," : "");
1186: level--;
1187: printf ("%*s}", level * 4, "");
1188: break;
1189:
1190: case YP_BIT:
1191: printf ("BIT STRING");
1192: switch (direction) {
1193: case YP_ENCODER:
1194: printf ("\n%*s[[x bit_parm = bitstr2strb (%s%s, &len) $ len]]",
1195: level * 4, "", var, SVAL (yp -> yp_varexp));
1196: printf ("\n%*s%%{\n%*sfree (bit_parm);\n", level * 4, "",
1197: (level + 1) * 4, "");
1198: if (action2)
1199: printf ("%*s%s\n", (level + 1) * 4, "", action2);
1200: printf ("%*s%%}\n", level * 4, "");
1201: break;
1202:
1203: case YP_DECODER:
1204: balloc (yp, var, action2, level);
1205: break;
1206: }
1207: break;
1208:
1209: case YP_BITLIST:
1210: printf ("BIT STRING");
1211: switch (direction) {
1212: case YP_ENCODER:
1213: printf ("\n%*s[[x bit_parm = bitstr2strb (%s%s, &len) $ len]]\n%*s{\n",
1214: level * 4, "", var, SVAL (yp -> yp_varexp),
1215: level * 4, "");
1216: break;
1217:
1218: case YP_DECODER:
1219: default:
1220: printf (" {\n");
1221: break;
1222: }
1223: level++;
1224: for (yv = yp -> yp_value; yv; yv = yv -> yv_next)
1225: printf ("%*s%s(%d)%s\n", level * 4, "", yv -> yv_named,
1226: val2int (yv), yv -> yv_next ? "," : "");
1227: level--;
1228: printf ("%*s}", level * 4, "");
1229: switch (direction) {
1230: case YP_DECODER:
1231: balloc (yp, var, action2, level);
1232: break;
1233:
1234: case YP_ENCODER:
1235: printf ("\n%*s%%{\n%*sfree (bit_parm);\n", level * 4, "",
1236: (level + 1) * 4, "");
1237: if (action2)
1238: printf ("%*s%s\n", (level + 1) * 4, "", action2);
1239: printf ("%*s%%}\n", level * 4, "");
1240: break;
1241: }
1242: break;
1243:
1244: case YP_OCT:
1245: printf ("OCTET STRING");
1246: switch (direction) {
1247: case YP_ENCODER:
1248: printf ("\n%*s[[q %s%s ]]", level * 4, "",
1249: var, SVAL (yp -> yp_varexp));
1250: break;
1251:
1252: case YP_DECODER:
1253: printf ("\n%*s[[q %s%s ]]", level * 4, "",
1254: var, SVAL (yp -> yp_varexp));
1255: break;
1256: }
1257: break;
1258:
1259: case YP_REAL:
1260: printf ("REAL");
1261: printf (top ? "\n%*s[[r %s -> %s ]]" : "\n%*s[[r %s%s ]]",
1262: level * 4, "", var, SVAL (yp -> yp_varexp));
1263: break;
1264:
1265: case YP_NULL:
1266: printf ("NULL");
1267: break;
1268:
1269: case YP_SEQ:
1270: case YP_SET:
1271: case YP_ANY:
1272: printf ("%s", tags[yp -> yp_code]);
1273: switch (direction) {
1274: case YP_ENCODER:
1275: case YP_DECODER:
1276: printf ("\n%*s[[a %s%s ]]",
1277: level * 4, "", var, SVAL (yp -> yp_varexp));
1278: break;
1279: }
1280: break;
1281:
1282: case YP_SEQTYPE:
1283: case YP_SETTYPE:
1284: ep = yp -> yp_code != YP_SETTYPE ? "element" : "member";
1285: printf ("%s\n", tags [yp -> yp_code]);
1286: switch (direction) {
1287: case YP_ENCODER:
1288: if ((y = yp -> yp_type) -> yp_declexp) {
1289: printf ("%*s%%{ %s = %s; %%}\n",
1290: (level + 1) * 4, "", y -> yp_declexp,
1291: SVAL (y -> yp_varexp));
1292: }
1293: if (h2flag) {
1294: if (top) {
1295: printf ("%*s<<n_parm = 0; ", (level + 1) * 4, "");
1296: printf ("n_parm < parm -> nelem; n_parm++>>\n");
1297: }
1298: else {
1299: printf ("%*s<<n_%s = 0;\n%*sn_%s < %s -> nelem;\n",
1300: (level + 1) * 4, "", yp -> yp_declexp,
1301: (level + 3) * 4, "", yp -> yp_declexp,
1302: yp -> yp_declexp);
1303: printf ("%*sn_%s++>>\n",
1304: (level + 3) * 4, "", yp -> yp_declexp);
1305: }
1306: }
1307: else {
1308: if (top)
1309: printf ("%*s<<; parm; parm = parm -> next>>\n",
1310: (level + 1) * 4, "");
1311: else
1312: printf ("%*s<<%s = %s%s;\n%*s%s;\n%*s%s = %s -> next>>\n",
1313: (level + 1) * 4, "", yp -> yp_declexp,
1314: var, SVAL (yp -> yp_varexp),
1315: (level + 3) * 4, "", yp -> yp_declexp,
1316: (level + 3) * 4, "", yp -> yp_declexp,
1317: yp -> yp_declexp);
1318: }
1319: break;
1320:
1321: case YP_DECODER:
1322: if (h2flag) {
1323: y = yp -> yp_type;
1324: xalloc (y, 0, level + 2, y -> yp_declexp,
1325: y -> yp_declexp, 1);
1326: }
1327: else
1328: xalloc (yp, 0, level + 1,
1329: top ? "parm" : yp -> yp_declexp,
1330: top ? modsym (mymodule, eval, "type")
1331: : yp -> yp_declexp, 1);
1332: break;
1333: }
1334: do_type1 (yp -> yp_type, 0, level + 1, ep, "", NULLCP, direction);
1335: switch (direction) {
1336: case YP_DECODER:
1337: printf ("\n%*s%%{ ", (level + 1) * 4, "");
1338: if (h2flag)
1339: printf ("n_%s++;", top ? "parm" : yp -> yp_declexp);
1340: else
1341: if (top)
1342: printf ("parm = &((*parm) -> next);");
1343: else
1344: printf ("%s = &((*%s) -> next);",
1345: yp -> yp_declexp, yp -> yp_declexp);
1346: if (action2)
1347: printf (" %s", action2);
1348: printf (" %%}");
1349: break;
1350: }
1351: break;
1352:
1353: case YP_SEQLIST:
1354: case YP_SETLIST:
1355: ep = yp -> yp_code != YP_SETLIST ? "element" : "member";
1356: printf ("%s", tags [yp -> yp_code]);
1357: printf ("\n%*s%%{\n", (level + 1) * 4, "");
1358: if (direction == YP_DECODER)
1359: xalloc (yp, 1, level + 2, yp -> yp_declexp,
1360: yp -> yp_declexp, 0);
1361: for (y = yp -> yp_type; y; y = y -> yp_next) {
1362: if (y -> yp_declexp)
1363: switch (direction) {
1364: case YP_ENCODER:
1365: printf ("%*s%s = %s;\n",
1366: (level + 2) * 4, "",
1367: y -> yp_declexp, y -> yp_varexp);
1368: break;
1369:
1370: case YP_DECODER:
1371: printf ("%*s%s = &(%s);\n",
1372: (level + 2) * 4, "",
1373: y -> yp_declexp, y -> yp_varexp);
1374: break;
1375: }
1376: if (direction == YP_DECODER &&
1377: y -> yp_flags & YP_DEFAULT) {
1378: prime_default (y, level + 2);
1379: }
1380: }
1381: printf ("%*s%%}\n%*s{\n", (level + 1) * 4, "",
1382: level * 4, "");
1383:
1384: if (!hflag || !(y = yp -> yp_type) || y -> yp_next) {
1385: var = "";
1386: top = 0;
1387: }
1388: for (y = yp -> yp_type; y; y = y -> yp_next) {
1389: do_type1 (y, top,
1390: level + ((y -> yp_flags & (YP_ID | YP_TAG)) ? 1 : 2),
1391: ep, var, NULLCP, direction);
1392: printf ("%s\n", y -> yp_next ? ",\n" : "");
1393: }
1394: printf ("%*s}", level * 4, "");
1395: break;
1396:
1397: case YP_CHOICE:
1398: printf ("CHOICE");
1399: if (!hflag || !(y = yp -> yp_type) || y -> yp_next)
1400: var = "";
1401: i = 0;
1402: for (y = yp -> yp_type; y; y = y -> yp_next)
1403: if (y -> yp_declexp)
1404: i++;
1405: switch (direction) {
1406: case YP_ENCODER:
1407: if (i) {
1408: printf ("\n%*s%%{\n", (level + 1) * 4, "");
1409: for (y = yp -> yp_type; y; y = y -> yp_next)
1410: if (y -> yp_declexp)
1411: printf ("%*s%s = %s;\n", (level + 2) * 4, "",
1412: y -> yp_declexp, y -> yp_varexp);
1413: printf ("%*s%%}\n%*s", (level + 1) * 4, "",
1414: (level + 1) * 4 - 1, "" );
1415: }
1416: if (*var)
1417: printf (" <<1>>");
1418: else
1419: if (top)
1420: printf (" <<parm -> offset>>");
1421: else
1422: printf (" <<%s -> offset>>",
1423: yp -> yp_declexp);
1424: printf (i ? "\n%*s{\n" : " {\n", level * 4, "");
1425: break;
1426:
1427: case YP_DECODER:
1428: printf ("\n");
1429: xalloc (yp, 0, level + 1, yp -> yp_declexp,
1430: yp -> yp_declexp, 1);
1431: printf ("%*s{\n", level * 4, "");
1432: break;
1433:
1434: default:
1435: printf (" {\n");
1436: break;
1437: }
1438: if (direction == YP_DECODER) {
1439: (void) sprintf (cp = buffer, "(*(%s)) -> offset = ",
1440: top ? "parm" : yp -> yp_declexp);
1441: cp += strlen (cp);
1442: }
1443: else
1444: cp = NULL;
1445: if (!hflag || !(y = yp -> yp_type) || y -> yp_next)
1446: top = 0;
1447: else
1448: if (top)
1449: cp = NULL;
1450: for (y = yp -> yp_type; y; y = y -> yp_next) {
1451: if (cp)
1452: (void) sprintf (cp, "%s;", y -> yp_offset);
1453: do_type1 (y, top, level + 1, "choice", var,
1454: cp ? buffer : NULLCP, direction);
1455: printf ("%s\n", y -> yp_next ? ",\n" : "");
1456: }
1457: printf ("%*s}", level * 4, "");
1458: break;
1459:
1460: case YP_OID:
1461: printf ("OBJECT IDENTIFIER");
1462: switch (direction) {
1463: case YP_ENCODER:
1464: case YP_DECODER:
1465: printf ("\n%*s[[O %s%s ]]",
1466: level * 4, "", var, SVAL (yp -> yp_varexp));
1467: break;
1468: }
1469: break;
1470:
1471: case YP_IDEFINED:
1472: if (yp -> yp_module && strcmp (yp -> yp_module, mymodule))
1473: printf ("%s.", yp -> yp_module);
1474: printf ("%s", yp -> yp_identifier);
1475: switch (direction) {
1476: case YP_ENCODER:
1477: printf ("\n%*s[[p %s%s ]]",
1478: level * 4, "", var, SVAL (yp -> yp_varexp));
1479: break;
1480:
1481: case YP_DECODER:
1482: printf ("\n%*s[[p &(%s%s)]]",
1483: level * 4, "", var, SVAL (yp -> yp_varexp));
1484: break;
1485: }
1486: break;
1487:
1488: default:
1489: myyerror ("unknown type: %d", yp -> yp_code);
1490: }
1491:
1492: if (action2)
1493: switch (yp -> yp_code) {
1494: case YP_BIT:
1495: case YP_BITLIST:
1496: if (direction == YP_ENCODER)
1497: break;
1498: case YP_SEQTYPE:
1499: case YP_SETTYPE:
1500: if (direction == YP_DECODER)
1501: break;
1502: /* else fall */
1503:
1504: default:
1505: printf ("\n%*s%%{ %s %%}", level * 4, "", action2);
1506: break;
1507: }
1508:
1509: if (yp -> yp_flags & YP_OPTIONAL) {
1510: printf ("\n%*sOPTIONAL", level * 4, "");
1511:
1512: if (direction == YP_ENCODER)
1513: switch (yp -> yp_code) {
1514: case YP_BOOL:
1515: case YP_INT:
1516: case YP_INTLIST:
1517: case YP_ENUMLIST:
1518: case YP_NULL:
1519: case YP_REAL:
1520: printf (" <<%s -> optionals & %s >>",
1521: varbuf, yp -> yp_optcontrol);
1522: default:
1523: break;
1524:
1525: case YP_BIT:
1526: case YP_BITLIST:
1527: case YP_OCT:
1528: case YP_SEQ:
1529: case YP_SEQTYPE:
1530: case YP_SEQLIST:
1531: case YP_SET:
1532: case YP_SETTYPE:
1533: case YP_SETLIST:
1534: case YP_CHOICE:
1535: case YP_ANY:
1536: case YP_OID:
1537: case YP_IDEFINED:
1538: printf (" <<%s%s>>", var, SVAL (yp -> yp_varexp));
1539: break;
1540: }
1541: }
1542: else
1543: if (yp -> yp_flags & YP_DEFAULT) {
1544: printf ("\n%*sDEFAULT ", level * 4, "");
1545: val2prf (yp -> yp_default, level + 2);
1546:
1547: if (direction == YP_ENCODER)
1548: switch (yp -> yp_code) {
1549: case YP_BOOL:
1550: printf (" <<%s%s%s>>",
1551: val2int (yp -> yp_default) ? "!" : "",
1552: var, SVAL (yp -> yp_varexp));
1553: break;
1554:
1555: case YP_INT:
1556: case YP_INTLIST:
1557: case YP_ENUMLIST:
1558: printf (" <<%s%s != %d>>", var, SVAL (yp -> yp_varexp),
1559: dfl2int (yp));
1560: break;
1561:
1562: case YP_REAL:
1563: printf (" << %s%s != %g >>",
1564: var, SVAL (yp -> yp_varexp),
1565: val2real (yp -> yp_default));
1566: break;
1567:
1568: case YP_NULL:
1569: default:
1570: break;
1571:
1572: case YP_BIT:
1573: case YP_BITLIST:
1574: case YP_OCT:
1575: case YP_SEQ:
1576: case YP_SEQTYPE:
1577: case YP_SEQLIST:
1578: case YP_SET:
1579: case YP_SETTYPE:
1580: case YP_SETLIST:
1581: case YP_CHOICE:
1582: case YP_ANY:
1583: case YP_OID:
1584: case YP_IDEFINED:
1585: printf (" <<%s%s>>", var, SVAL (yp -> yp_varexp));
1586: break;
1587: }
1588: }
1589:
1590: if (direction == YP_ENCODER
1591: && yp -> yp_varexp
1592: && (cp = index (yp -> yp_varexp, ' '))
1593: && strncmp (cp + 1, "-> ", 3) == 0) {
1594: *cp = NULL;
1595: (void) sprintf (buffer, "(*%s) -> %s", yp -> yp_varexp, cp + 4);
1596: yp -> yp_varexp = new_string (buffer);
1597: }
1598: }
1599:
1600: /* TYPE HANDLING */
1601:
1602: static YP lookup_type (mod, id)
1603: register char *mod,
1604: *id;
1605: {
1606: register SY sy;
1607:
1608: for (sy = mysymbols; sy; sy = sy -> sy_next) {
1609: if (mod) {
1610: if (strcmp (sy -> sy_module, mod))
1611: continue;
1612: }
1613: else
1614: if (strcmp (sy -> sy_module, mymodule)
1615: && strcmp (sy -> sy_module, "UNIV"))
1616: continue;
1617:
1618: if (strcmp (sy -> sy_name, id) == 0)
1619: return sy -> sy_type;
1620: }
1621:
1622: return NULLYP;
1623: }
1624:
1625: /* */
1626:
1627: static posy (yp, top, level, id, val, var, arrayflg)
1628: register YP yp;
1629: int top,
1630: level,
1631: arrayflg;
1632: char *id,
1633: *val,
1634: *var;
1635: {
1636: register int i,
1637: j;
1638: register char *bp;
1639: char *cp,
1640: *dp,
1641: *ep,
1642: *newid,
1643: buf1[BUFSIZ],
1644: buf2[BUFSIZ],
1645: buf3[BUFSIZ];
1646: register YP y;
1647: register YV yv;
1648:
1649: (void) strcpy (bp = buf2, var);
1650: bp += strlen (bp);
1651:
1652: switch (yp -> yp_code) {
1653: case YP_BOOL:
1654: if (aflag)
1655: printag (yp, level + 4, NULLCP);
1656: fprintf (fdef, "%*schar %s;\n", level * 4, "",
1657: array(id, arrayflg));
1658: yp -> yp_varexp = new_string (buf2);
1659: break;
1660:
1661: case YP_INT:
1662: case YP_INTLIST:
1663: case YP_ENUMLIST:
1664: if (aflag)
1665: printag (yp, level + 4, NULLCP);
1666: fprintf (fdef, "%*sinteger %s;\n", level * 4, "",
1667: array(id, arrayflg));
1668: yp -> yp_varexp = new_string (buf2);
1669: if (yp -> yp_code == YP_INT)
1670: break;
1671: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) {
1672: modsym_aux (yv -> yv_named, buf1);
1673: fprintf (fdef, "#define\t%s_%s\t%d\n",
1674: modsym (mymodule, top ? eval : id, "int"),
1675: buf1, val2int (yv));
1676: }
1677: break;
1678:
1679: case YP_BIT:
1680: case YP_BITLIST:
1681: if (!top) {
1682: if (aflag)
1683: printag (yp, level + 4, NULLCP);
1684: fprintf (fdef, "%*sPE %s;\n", level * 4, "",
1685: array(id, arrayflg));
1686: }
1687: if (fflag) {
1688: fprintf (fact, "%*sif (%s)\n", level * 4, "", buf2);
1689: fprintf (fact,
1690: "%*spe_free (%s),\n%*s%s = NULLPE;\n",
1691: (level + 1) * 4, "", buf2,
1692: (level + 2) * 4, "", buf2);
1693: }
1694: yp -> yp_varexp = new_string (buf2);
1695: if (yp -> yp_code != YP_BITLIST)
1696: break;
1697: i = -1;
1698: for (yv = yp -> yp_value; yv; yv = yv -> yv_next)
1699: if ((j = val2int (yv)) < 0)
1700: pyyerror (yp, "invalid bit number in BIT STRING");
1701: else
1702: if (j > i)
1703: i = j;
1704: if (i < sizeof (int) * 8) { /* NBBY */
1705: fprintf (fdef, "#define\t%s\t\"\\020",
1706: modsym (mymodule, top ? eval : id, "bits"));
1707: for (yv = yp -> yp_value; yv; yv = yv -> yv_next)
1708: if (yv -> yv_flags & YV_NAMED)
1709: fprintf (fdef, "\\0%o%s",
1710: val2int (yv) + 1, yv -> yv_named);
1711: else
1712: fprintf (fdef, "\\0%oBIT%d",
1713: val2int (yv) + 1, val2int (yv));
1714: fprintf (fdef, "\"\n");
1715: }
1716: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) {
1717: modsym_aux (yv -> yv_named, buf1);
1718: fprintf (fdef, "#define\t%s_%s\t%d\n",
1719: modsym (mymodule, top ? eval : id, "bit"),
1720: buf1, val2int (yv));
1721: }
1722: break;
1723:
1724: case YP_REAL:
1725: if (aflag)
1726: printag (yp, level + 4, NULLCP);
1727: fprintf (fdef, "%*sdouble %s;\n", level * 4, "",
1728: array(id, arrayflg));
1729: yp -> yp_varexp = new_string (buf2);
1730: break;
1731:
1732: case YP_OCT:
1733: if (!top) {
1734: if (aflag)
1735: printag (yp, level + 4, NULLCP);
1736: fprintf (fdef, "%*sstruct qbuf *%s;\n", level * 4, "",
1737: array(id, arrayflg));
1738: }
1739: if (fflag) {
1740: fprintf (fact, "%*sif (%s)\n", level * 4, "", buf2);
1741: fprintf (fact,
1742: "%*sqb_free (%s),\n%*s%s = NULL;\n",
1743: (level + 1) * 4, "", buf2,
1744: (level + 2) * 4, "", buf2);
1745: }
1746: yp -> yp_varexp = new_string (buf2);
1747: break;
1748:
1749: case YP_NULL:
1750: if (aflag)
1751: printag (yp, level + 4, NULLCP);
1752: fprintf (fdef, "%*schar %s;\n", level * 4, "",
1753: array(id, arrayflg));
1754: if (yp -> yp_flags & YP_OPTIONAL)
1755: yp -> yp_varexp = new_string (buf2);
1756: break;
1757:
1758: case YP_SEQ:
1759: case YP_SET:
1760: case YP_ANY:
1761: if (!top) {
1762: if (aflag)
1763: printag (yp, level + 4, NULLCP);
1764: fprintf (fdef, "%*sPE %s;\n", level * 4, "",
1765: array(id, arrayflg));
1766: }
1767: if (fflag) {
1768: fprintf (fact, "%*sif (%s)\n", level * 4, "", buf2);
1769: fprintf (fact,
1770: "%*spe_free (%s),\n%*s%s = NULLPE;\n",
1771: (level + 1) * 4, "", buf2,
1772: (level + 2) * 4, "", buf2);
1773: }
1774: yp -> yp_varexp = new_string (buf2);
1775: break;
1776:
1777: case YP_SEQTYPE:
1778: case YP_SETTYPE:
1779: ep = yp -> yp_code != YP_SETTYPE ? "element" : "member";
1780: if ((cp = rindex (buf2, ' ')) && *++cp) {
1781: if ((dp = rindex (cp, '.')) && *++dp)
1782: cp = dp;
1783: (void) sprintf (dp = buf1, "%*.*s",
1784: cp - buf2, cp - buf2, buf2);
1785: dp += strlen (dp);
1786: }
1787: else {
1788: (void) strcpy (buf1, buf2);
1789: dp = NULL;
1790: }
1791: newid = yp -> yp_ptrname ? yp -> yp_ptrname : id;
1792: if (h2flag && top)
1793: fprintf (fdef, "%*sint\tnelem;\n", level * 4, "");
1794: if (!top) {
1795: if (yp -> yp_structname)
1796: id = yp -> yp_structname;
1797: else if (!Hflag)
1798: id = gensym (ep, NULLCP);
1799: if (aflag)
1800: printag (yp, level + 4, NULLCP);
1801: fprintf (fdef, "%*sstruct %s {\n", level * 4, "", id);
1802: if (h2flag)
1803: fprintf (fdef, "%*sint\tnelem;\n", (level + 1) * 4, "");
1804: }
1805: if (dp)
1806: (void) strcpy (dp, newid);
1807: (void) strcpy (bp = buf2, id);
1808: bp += strlen (bp);
1809:
1810: if (!top)
1811: yp -> yp_declexp = new_string (id);
1812:
1813: if (dp)
1814: (void) strcpy (dp, newid);
1815: yp -> yp_varexp = new_string (buf1);
1816: if ((y = yp -> yp_type) -> yp_code == YP_IDEFINED && hflag) {
1817: modsym_aux (y -> yp_identifier, cp = buf3);
1818: if (h2flag) {
1819: cp += strlen(cp);
1820: (void) sprintf (cp, "[n_%s]", PARVAL (yp->yp_declexp));
1821: cp = buf3;
1822: }
1823: }
1824: else {
1825: switch (y -> yp_code) {
1826: case YP_SEQLIST:
1827: case YP_SETLIST:
1828: case YP_SETTYPE:
1829: case YP_SEQTYPE:
1830: case YP_CHOICE:
1831: case YP_IDEFINED:
1832: cp = gensym (ep, h2flag ? PARVAL(yp->yp_declexp) : NULLCP);
1833: break;
1834: default:
1835: cp = gensym (ep, NULLCP);
1836: break;
1837: }
1838: }
1839: (void) sprintf (bp, " -> %s", cp);
1840: if (fflag) {
1841: if (!top) {
1842: fprintf (fact, "%*s{\n", level * 4, "");
1843: level++;
1844: if (h2flag) {
1845: fprintf (fact, "%*sint n_%s;\n",
1846: level * 4, "", PARVAL (yp->yp_declexp));
1847: fprintf (fact, "%*sstruct %s *%s = %s;\n\n",
1848: level * 4, "", id, id, var);
1849: }
1850: else
1851: fprintf (fact, "%*sstruct %s *%s;\n\n",
1852: level * 4, "", id, id);
1853: }
1854: if (h2flag) {
1855: fprintf (fact, "%*sfor (n_%s = 0;\n",
1856: level * 4, "", PARVAL(yp -> yp_declexp));
1857: fprintf (fact, "%*sn_%s < %s -> nelem;\n",
1858: (level + 2) * 4, "", PARVAL(yp->yp_declexp), id);
1859: fprintf (fact, "%*sn_%s++) {\n",
1860: (level + 2) * 4, "", PARVAL(yp->yp_declexp));
1861: }
1862: else {
1863: fprintf (fact,
1864: "%*sfor (%s = %s; %s;) {\n",
1865: level * 4, "", id, buf1, id);
1866: fprintf (fact, "%*sstruct %s *f_%s = %s -> next;\n\n",
1867: (level + 1) * 4, "",
1868: top ? modsym (mymodule, val, "type") : id,
1869: id, id);
1870: }
1871: }
1872: level++;
1873: posy (y, 0, level, cp, ep, buf2, h2flag);
1874: *bp = NULL;
1875: if (y -> yp_code != YP_IDEFINED)
1876: free (cp);
1877: if (!h2flag)
1878: fprintf (fdef, "\n%*sstruct %s *next;\n", level * 4, "",
1879: top ? modsym (mymodule, val, "type") : id);
1880:
1881: level--;
1882:
1883: (void) strcpy (bp = buf2, var);
1884: bp += strlen (bp);
1885: if (fflag) {
1886: if (!h2flag) {
1887: fprintf (fact, "\n%*sif (%s)\n%*sfree ((char *) %s);",
1888: (level + 1) * 4, "", id,
1889: (level + 2) * 4, "", id);
1890: fprintf (fact, "\n%*s%s = f_%s;", (level + 1) * 4, "",
1891: id, id);
1892: }
1893: fprintf (fact, "\n%*s}\n", level * 4, "");
1894:
1895: if (!top) {
1896: if (h2flag)
1897: fprintf (fact, "\n%*s%s = NULL;\n",
1898: level * 4, "", var);
1899: else
1900: fprintf (fact, "\n%*s%s = NULL;\n",
1901: level * 4, "", yp -> yp_varexp);
1902:
1903: level--;
1904: fprintf (fact, "%*s}\n", level * 4, "");
1905: }
1906: }
1907:
1908: if (!top) {
1909: fprintf (fdef, "%*s} *%s;\n", level * 4, "",
1910: array(newid, arrayflg));
1911: if (!Hflag)
1912: free (id);
1913: }
1914: break;
1915:
1916: case YP_SEQLIST:
1917: case YP_SETLIST:
1918: ep = yp -> yp_code != YP_SETLIST ? "element" : "member";
1919: if ((cp = rindex (buf2, ' ')) && *++cp) {
1920: if ((dp = rindex (cp, '.')) && *++dp)
1921: cp = dp;
1922: (void) sprintf (dp = buf1, "%*.*s",
1923: cp - buf2, cp - buf2, buf2);
1924: dp += strlen (dp);
1925: }
1926: else {
1927: (void) strcpy (buf1, buf2);
1928: dp = NULL;
1929: }
1930: newid = yp -> yp_ptrname ? yp -> yp_ptrname : id;
1931: if (!top) {
1932: if (yp -> yp_structname)
1933: id = yp -> yp_structname;
1934: else if (!Hflag)
1935: id = gensym (ep, NULLCP);
1936: if (aflag)
1937: printag (yp, level + 4, NULLCP);
1938: fprintf (fdef, "%*sstruct %s {\n", level * 4, "", id);
1939:
1940: if (dp)
1941: (void) strcpy (dp, newid);
1942:
1943: if (fflag) {
1944: fprintf (fact, "%*sif (%s) {\n",
1945: level * 4, "", buf1);
1946: i = 0;
1947: for (y = yp -> yp_type; y; y = y -> yp_next) {
1948: switch (y -> yp_code) {
1949: case YP_BOOL:
1950: case YP_INT:
1951: case YP_INTLIST:
1952: case YP_ENUMLIST:
1953: case YP_REAL:
1954: case YP_NULL:
1955: continue;
1956:
1957: default:
1958: i = 1;
1959: break;
1960: }
1961: break;
1962: }
1963: if (i)
1964: fprintf (fact, "%*sstruct %s *%s = %s;\n\n",
1965: (level + 1) * 4, "", id, id, buf1);
1966: }
1967: (void) strcpy (bp = buf2, id);
1968: bp += strlen (bp);
1969: yp -> yp_declexp = new_string (id);
1970:
1971: level++;
1972: }
1973: if (dp)
1974: (void) strcpy (dp, newid);
1975: yp -> yp_varexp = new_string (buf1);
1976: for (y = yp -> yp_type, i = 0; y; y = y -> yp_next) {
1977: if (y -> yp_flags & YP_OPTIONAL)
1978: switch (y -> yp_code) {
1979: case YP_BOOL:
1980: case YP_INT:
1981: case YP_INTLIST:
1982: case YP_ENUMLIST:
1983: case YP_REAL:
1984: case YP_NULL:
1985: {
1986: char obuf[BUFSIZ];
1987:
1988: if (i == 0)
1989: fprintf (fdef, "%*sint optionals;\n",
1990: level * 4, "");
1991: if (y -> yp_flags & YP_ID)
1992: modsym_aux (y -> yp_id, cp = buf1);
1993: else {
1994: cp = gensym (ep, NULLCP);
1995: (void) strcpy (buf1, cp);
1996: free (cp);
1997: cp = buf1;
1998: }
1999: (void) sprintf (obuf, "%s_%s",
2000: modsym (mymodule,
2001: top ? eval : id,
2002: "opt"), cp);
2003: fprintf (fdef, "#define\t%s (0%08o)\n", obuf,
2004: 1 << i);
2005: y -> yp_optcontrol = new_string (obuf);
2006: y -> yp_flags |= YP_OPTCONTROL;
2007:
2008: i ++;
2009: if (i >= 8 * sizeof (int))
2010: yyerror ("too many optionals in structure");
2011: }
2012: break;
2013: }
2014: }
2015: if (i > 0) fprintf (fdef, "\n");
2016:
2017: for (y = yp -> yp_type, i = 1; y; y = y -> yp_next, i++) {
2018: if (y -> yp_flags & YP_ID)
2019: modsym_aux (y -> yp_id, cp = buf1);
2020: else
2021: cp = gensym (ep, NULLCP);
2022: (void) sprintf (bp, " -> %s", cp);
2023: posy (y, 0, level, cp, ep, buf2, 0);
2024: *bp = NULL;
2025: if (!(y -> yp_flags & YP_ID))
2026: free (cp);
2027: if (y -> yp_next)
2028: fprintf (fdef, "\n");
2029: }
2030: if (i == 1)
2031: fprintf (fdef, "%*schar dummy;\n", level * 4, "");
2032: if (!top) {
2033: level--;
2034:
2035: (void) strcpy (bp = buf2, var);
2036: bp += strlen (bp);
2037: if (fflag) {
2038: fprintf (fact, "\n%*sif (%s)\n%*sfree ((char *) %s);\n%*s%s = NULL;\n",
2039: (level + 1) * 4, "", yp -> yp_varexp,
2040: (level + 2) * 4, "", yp -> yp_varexp,
2041: (level + 1) * 4, "", yp -> yp_varexp);
2042: fprintf (fact, "%*s}\n", level * 4, "");
2043: }
2044:
2045: fprintf (fdef, "%*s} *%s;\n", level * 4, "",
2046: array(newid, arrayflg));
2047: if (!Hflag)
2048: free (id);
2049: }
2050: break;
2051:
2052: case YP_CHOICE:
2053: if ((cp = rindex (buf2, ' ')) && *++cp) {
2054: if ((dp = rindex (cp, '.')) && *++dp)
2055: cp = dp;
2056: (void) sprintf (dp = buf1, "%*.*s",
2057: cp - buf2, cp - buf2, buf2);
2058: dp += strlen (dp);
2059: }
2060: else {
2061: (void) strcpy (buf1, buf2);
2062: dp = NULL;
2063: }
2064: newid = yp -> yp_ptrname ? yp -> yp_ptrname : id;
2065: if (!top) {
2066: if (yp -> yp_structname)
2067: id = yp -> yp_structname;
2068: else if (!Hflag)
2069: id = gensym ("choice", NULLCP);
2070: if (aflag)
2071: printag (yp, level + 4, NULLCP);
2072: fprintf (fdef, "%*sstruct %s {\n", level * 4, "", id);
2073:
2074: if (dp)
2075: (void) strcpy (dp, newid);
2076: if (fflag) {
2077: fprintf (fact, "%*sif (%s) {\n%*sstruct %s *%s = %s;\n\n",
2078: level * 4, "", buf1,
2079: (level + 1) * 4, "", id, id, buf1);
2080: }
2081: (void) strcpy (bp = buf2, id);
2082: bp += strlen (bp);
2083: yp -> yp_declexp = new_string (id);
2084:
2085: level++;
2086: }
2087: if (dp)
2088: (void) strcpy (dp, newid);
2089: yp -> yp_varexp = new_string (buf1);
2090: fprintf (fdef, "%*sint offset;\n", level * 4, "");
2091: if (fflag)
2092: fprintf (fact, "%*sswitch (%s -> offset) {\n",
2093: level * 4, "", id);
2094: if (top)
2095: cp = modsym (mymodule, val, "type");
2096: else
2097: cp = id;
2098: (void) sprintf (ep = buf1, "%s_", cp);
2099: ep += strlen (ep);
2100: for (y = yp -> yp_type, i = 1; y; y = y -> yp_next, i++) {
2101: if (y -> yp_flags & YP_ID)
2102: modsym_aux (y -> yp_id, ep);
2103: else
2104: (void) sprintf (ep, "%d", i);
2105: y -> yp_offset = new_string (buf1);
2106: fprintf (fdef, "#define\t%s\t%d\n", y -> yp_offset, i);
2107: }
2108: fprintf (fdef, "\n%*sunion {\n", level * 4, "");
2109: level++;
2110: for (y = yp -> yp_type; y; y = y -> yp_next) {
2111: if (y -> yp_flags & YP_ID)
2112: modsym_aux (y -> yp_id, cp = buf1);
2113: else
2114: cp = gensym ("choice", NULLCP);
2115: if (fflag) {
2116: fprintf (fact, "%*scase %s:\n", level * 4, "",
2117: y -> yp_offset);
2118: level++;
2119: }
2120: (void) sprintf (bp, " -> un.%s", cp);
2121: posy (y, 0, level, cp, "choice", buf2, 0);
2122: *bp = NULL;
2123: if (fflag) {
2124: fprintf (fact, "%*sbreak;\n", level * 4, "");
2125: if (y -> yp_next)
2126: fprintf (fact, "\n");
2127: level--;
2128: }
2129: if (!(y -> yp_flags & YP_ID))
2130: free (cp);
2131: if (y -> yp_next)
2132: fprintf (fdef, "\n");
2133: }
2134: level--;
2135: fprintf (fdef, "%*s} un;\n", level * 4, "");
2136: if (fflag)
2137: fprintf (fact, "%*s}\n", level * 4, "");
2138: if (!top) {
2139: level--;
2140:
2141: (void) strcpy (bp = buf2, var);
2142: bp += strlen (bp);
2143: if (fflag) {
2144: fprintf (fact, "\n%*sif (%s)\n%*sfree ((char *) %s);\n%*s%s = NULL;\n",
2145: (level + 1) * 4, "", yp -> yp_varexp,
2146: (level + 2) * 4, "", yp -> yp_varexp,
2147: (level + 1) * 4, "", yp -> yp_varexp);
2148: fprintf (fact, "%*s}\n", level * 4, "");
2149: }
2150:
2151: fprintf (fdef, "%*s} *%s;\n", level * 4, "",
2152: array(newid, arrayflg));
2153: if (!Hflag)
2154: free (id);
2155: }
2156: break;
2157:
2158: case YP_OID:
2159: if (!top) {
2160: if (aflag)
2161: printag (yp, level + 4, NULLCP);
2162: fprintf (fdef, "%*sOID %s;\n", level * 4, "",
2163: array(id, arrayflg));
2164: }
2165: if (fflag) {
2166: fprintf (fact, "%*sif (%s)\n", level * 4, "", buf2);
2167: fprintf (fact,
2168: "%*soid_free (%s),\n%*s%s = NULLOID;\n",
2169: (level + 1) * 4, "", buf2,
2170: (level + 2) * 4, "", buf2);
2171: }
2172: yp -> yp_varexp = new_string (buf2);
2173: break;
2174:
2175: case YP_IDEFINED:
2176: if (aflag)
2177: printag (yp, level + 4, NULLCP);
2178: fprintf (fdef, "%*sstruct %s *%s;\n", level * 4, "",
2179: modsym (yp -> yp_module, yp -> yp_identifier, "type"),
2180: array(id, arrayflg));
2181: if (fflag) {
2182: fprintf (fact, "%*sif (%s)\n", level * 4, "", buf2);
2183: fprintf (fact,
2184: "%*s%s (%s),\n%*s%s = NULL;\n",
2185: (level + 1) * 4, "",
2186: modsym (yp -> yp_module, yp -> yp_identifier, "free"),
2187: buf2, (level + 2) * 4, "", buf2);
2188: }
2189: yp -> yp_varexp = new_string (buf2);
2190: break;
2191:
2192: default:
2193: myyerror ("unknown type: %d", yp -> yp_code);
2194: }
2195: }
2196:
2197: /* */
2198:
2199: static printag (yp, level, pullup)
2200: register YP yp;
2201: int level;
2202: char *pullup;
2203: {
2204: fprintf (fdef, "%*s/* ", level * 4, "");
2205: switch (yp -> yp_code) {
2206: case YP_IDEFINED:
2207: if (yp -> yp_module && strcmp (yp -> yp_module, mymodule))
2208: fprintf (fdef, "%s.", yp -> yp_module);
2209: fprintf (fdef, "%s", yp -> yp_identifier);
2210: break;
2211:
2212: default:
2213: fprintf (fdef, "%s", tags[yp -> yp_code]);
2214: break;
2215: }
2216: if (pullup)
2217: fprintf (fdef, " pulled up from %s", pullup);
2218: fprintf (fdef, " */\n");
2219: }
2220:
2221: /* */
2222:
2223: static xalloc (yp, top, level, arg, type, brackets)
2224: register YP yp;
2225: int top,
2226: level,
2227: brackets;
2228: char *arg,
2229: *type;
2230: {
2231: int didone;
2232: register YP y;
2233:
2234: if (hflag && !arg && !type)
2235: return;
2236:
2237: didone = 0;
2238:
2239: if (arg && type) {
2240: if (brackets && !didone) {
2241: printf ("%*s%%{\n", level * 4, "");
2242: level++, didone++;
2243: }
2244:
2245: if (h2flag && (yp -> yp_code == YP_SEQTYPE ||
2246: yp -> yp_code == YP_SETTYPE)) {
2247: printf ("%*s{\n%*sPE xx_pe = prim2%s ($$);\n\n",
2248: level * 4, "", (level +1) * 4, "",
2249: yp -> yp_code == YP_SEQTYPE ? "seq" : "set");
2250: printf ("%*sn_%s = xx_pe -> pe_cardinal > 0 ",
2251: (level + 1) * 4, "", arg);
2252: printf ("? xx_pe -> pe_cardinal : 0;\n%*s}\n", level * 4, "");
2253: printf ("%*sif ((*(%s) = (struct %s *)\n",
2254: level * 4, "", arg, type);
2255: printf ("%*scalloc (1 + (unsigned) n_%s, sizeof **(%s)",
2256: (level + 2) * 4, "", arg, arg);
2257: printf (")) == ((struct %s *) 0)) {\n", type);
2258: printf ("%*sadvise (NULLCP, \"%%s\", PEPY_ERR_NOMEM);\n",
2259: (level + 1) * 4, "");
2260: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "",
2261: level * 4, "");
2262: printf ("%*s(*%s) -> nelem = n_%s;\n", level * 4, "", arg, arg);
2263: printf ("%*sn_%s = 0;\n", level * 4, "", arg);
2264: } else {
2265: printf ("%*sif ((*(%s) = (struct %s *)\n",
2266: level * 4, "", arg, type);
2267: printf ("%*scalloc (1, sizeof **(%s))) == ((struct %s *) 0)) {\n",
2268: (level + 2) * 4, "", arg, type);
2269: printf ("%*sadvise (NULLCP, \"%%s\", PEPY_ERR_NOMEM);\n",
2270: (level + 1) * 4, "");
2271: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "",
2272: level * 4, "");
2273: }
2274: }
2275: switch (yp -> yp_code) {
2276: case YP_SEQTYPE:
2277: case YP_SETTYPE:
2278: if (top) break;
2279: case YP_CHOICE:
2280: case YP_SEQLIST:
2281: case YP_SETLIST:
2282: for (y = yp -> yp_type; y; y = y -> yp_next)
2283: switch (y -> yp_code) {
2284: case YP_SEQTYPE:
2285: case YP_SETTYPE:
2286: if (h2flag && (yp -> yp_code == YP_SETLIST ||
2287: yp -> yp_code == YP_SEQLIST)) {
2288: /* include allocation here - no chance later */
2289: if (brackets && !didone) {
2290: printf ("%*s%%{\n", level * 4, "");
2291: level++, didone++;
2292: }
2293: if (y -> yp_declexp)
2294: printf ("%*s%s = &(%s);\n", level * 4, "",
2295: y -> yp_declexp,
2296: y -> yp_varexp);
2297: xalloc (y, top, level, y -> yp_declexp,
2298: y -> yp_declexp, 0);
2299: }
2300: /* and continue ... */
2301: case YP_SEQLIST:
2302: case YP_SETLIST:
2303: case YP_CHOICE:
2304: if (brackets && !didone) {
2305: printf ("%*s%%{\n", level * 4, "");
2306: level++, didone++;
2307: }
2308: printf ("%*s%s = &(%s);\n",
2309: level * 4, "", y -> yp_declexp,
2310: y -> yp_varexp);
2311: break;
2312: }
2313: break;
2314: }
2315:
2316: if (brackets && didone) {
2317: level--;
2318: printf ("%*s%%}\n", level * 4, "");
2319: }
2320: }
2321:
2322:
2323: static balloc (yp, var, action2, level)
2324: register YP yp;
2325: char *var, *action2;
2326: int level;
2327: {
2328: printf ("\n%*s%%{\n", level * 4, "");
2329: level++;
2330:
2331: printf ("%*sif ((%s%s = prim2bit (pe_cpy ($$))) == NULLPE) {\n",
2332: level * 4, "", var, SVAL (yp -> yp_varexp));
2333: printf ("%*sadvise (NULLCP, \"%%s\", PEPY_ERR_NOMEM);\n", (level + 1) * 4, "");
2334: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", level * 4, "");
2335:
2336: if (action2)
2337: printf ("\n%*s%s\n", level * 4, "", action2);
2338:
2339: level--;
2340: printf ("%*s%%}", level * 4, "");
2341: }
2342:
2343: #ifdef notdef
2344: static qalloc (yp, var, action2, level)
2345: register YP yp;
2346: char *var,
2347: *action2;
2348: int level;
2349: {
2350: printf ("\n%*s%%{\n", level * 4, "");
2351: level++;
2352:
2353: printf ("%*sif ((%s%s = str2qb ($$, $$_len, 1)) == ((struct qbuf *) 0)) {\n",
2354: level * 4, "", var, SVAL (yp -> yp_varexp));
2355: printf ("%*sadvise (NULLCP, \"%%s\", PEPY_ERR_NOMEM);\n", (level + 1) * 4, "");
2356: printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", level * 4, "");
2357:
2358: if (action2)
2359: printf ("\n%*s%s\n", level * 4, "", action2);
2360:
2361: level--;
2362: printf ("%*s%%}", level * 4, "");
2363: }
2364: #endif
2365:
2366: /* */
2367:
2368: static choice_pullup (yp, partial)
2369: register YP yp;
2370: int partial;
2371: {
2372: register YP *x,
2373: y,
2374: z,
2375: *z1,
2376: z2,
2377: z3;
2378:
2379: for (x = &yp -> yp_type; y = *x; x = &y -> yp_next) {
2380: if (y -> yp_flags & (YP_TAG | YP_BOUND))
2381: continue;
2382:
2383: switch (y -> yp_code) {
2384: case YP_IDEFINED:
2385: if ((z = lookup_type (y -> yp_module, y -> yp_identifier))
2386: == NULLYP
2387: || z -> yp_code != YP_CHOICE)
2388: continue;
2389: choice_pullup (z2 = copy_type (z), CH_FULLY);
2390: goto patch;
2391:
2392: case YP_CHOICE:
2393: choice_pullup (z2 = copy_type (y), CH_FULLY);
2394: patch: ;
2395: if (partial) {
2396: *x = z2;
2397: z2 -> yp_next = y -> yp_next;
2398: continue;
2399: }
2400: break;
2401:
2402: default:
2403: continue;
2404: }
2405: z = z3 = z2 -> yp_type;
2406: for (z1 = &z -> yp_next; z2 = *z1; z1 = &z2 -> yp_next)
2407: z3 = z2;
2408: *z1 = y -> yp_next;
2409: *x = z;
2410: y = z3;
2411: }
2412: }
2413:
2414: /* */
2415:
2416: static components_pullup (yp)
2417: register YP yp;
2418: {
2419: register YP *x,
2420: y,
2421: z,
2422: z1,
2423: z2;
2424:
2425: for (x = &yp -> yp_type; y = *x; x = &y -> yp_next) {
2426: if (!(y -> yp_flags & YP_COMPONENTS))
2427: continue;
2428:
2429: switch (y -> yp_code) {
2430: case YP_SEQLIST:
2431: case YP_SETLIST:
2432: z = y;
2433: break;
2434:
2435: case YP_IDEFINED:
2436: if ((z = lookup_type (y -> yp_module, y -> yp_identifier))
2437: == NULLYP) {
2438: warning ("COMPONENTS OF target \"%s\" is undefined",
2439: y -> yp_identifier);
2440: continue;
2441: }
2442: break;
2443: }
2444: if (yp -> yp_code != z -> yp_code) {
2445: warning ("COMPONENTS OF target \"%s\" is wrong type, should be %s",
2446: y -> yp_code == YP_IDEFINED ? y -> yp_identifier
2447: : y -> yp_id ? y -> yp_id
2448: : "",
2449: yp -> yp_code == YP_SEQLIST ? "SEQUENCE" : "SET");
2450: continue;
2451: }
2452: if (z -> yp_type == NULLYP)
2453: continue;
2454: components_pullup (z = copy_type (z));
2455: *x = z2 = z -> yp_type;
2456: for (x = &z -> yp_type; z1 = *x; x = &z1 -> yp_next)
2457: z2 = z1;
2458: *x = y -> yp_next;
2459: y = z2;
2460: }
2461: }
2462:
2463: /* VALUE HANDLING */
2464:
2465: static int val2int (yv)
2466: register YV yv;
2467: {
2468: switch (yv -> yv_code) {
2469: case YV_BOOL:
2470: case YV_NUMBER:
2471: return yv -> yv_number;
2472:
2473: case YV_STRING:
2474: yyerror ("need an integer, not a string");
2475:
2476: case YV_IDEFINED:
2477: case YV_IDLIST:
2478: yyerror ("haven't written symbol table for values yet");
2479:
2480: case YV_NULL:
2481: yyerror ("need an integer, not NULL");
2482:
2483: default:
2484: myyerror ("unknown value: %d", yv -> yv_code);
2485: }
2486: /* NOTREACHED */
2487: }
2488:
2489: static double val2real (yv)
2490: register YV yv;
2491: {
2492: switch (yv -> yv_code) {
2493: case YV_NUMBER:
2494: return yv -> yv_number;
2495:
2496: case YV_REAL:
2497: return yv -> yv_real;
2498:
2499: case YV_STRING:
2500: yyerror ("need an integer, not a string");
2501:
2502: case YV_IDEFINED:
2503: case YV_IDLIST:
2504: yyerror ("haven't written symbol table for values yet");
2505:
2506: case YV_NULL:
2507: yyerror ("need an integer, not NULL");
2508:
2509: default:
2510: myyerror ("unknown value: %d", yv -> yv_code);
2511: }
2512: /* NOTREACHED */
2513: }
2514:
2515: /* */
2516:
2517: static val2prf (yv, level)
2518: register YV yv;
2519: int level;
2520: {
2521: register YV y;
2522:
2523: if (yv -> yv_flags & YV_ID)
2524: printf ("%s ", yv -> yv_id);
2525:
2526: if (yv -> yv_flags & YV_TYPE) /* will this REALLY work??? */
2527: do_type1 (yv -> yv_type, 0, level, NULLCP, NULLCP, NULLCP, NULL);
2528:
2529: switch (yv -> yv_code) {
2530: case YV_BOOL:
2531: printf (yv -> yv_number ? "TRUE" : "FALSE");
2532: break;
2533:
2534: case YV_NUMBER:
2535: if (yv -> yv_named)
2536: printf ("%s", yv -> yv_named);
2537: else
2538: printf ("%d", yv -> yv_number);
2539: break;
2540:
2541: case YV_REAL:
2542: dump_real (yv -> yv_real);
2543: break;
2544:
2545: case YV_STRING:
2546: printf ("\"%s\"", yv -> yv_string);
2547: break;
2548:
2549: case YV_IDEFINED:
2550: if (yv -> yv_module)
2551: printf ("%s.", yv -> yv_module);
2552: printf ("%s", yv -> yv_identifier);
2553: break;
2554:
2555: case YV_IDLIST:
2556: case YV_VALIST:
2557: printf ("{");
2558: for (y = yv -> yv_idlist; y; y = y -> yv_next) {
2559: printf (" ");
2560: val2prf (y, level + 1);
2561: printf (y -> yv_next ? ", " : " ");
2562: }
2563: printf ("}");
2564: break;
2565:
2566: case YV_NULL:
2567: printf ("NULL");
2568: break;
2569:
2570: default:
2571: myyerror ("unknown value: %d", yv -> yv_code);
2572: /* NOTREACHED */
2573: }
2574: }
2575: static dump_real (r)
2576: double r;
2577: {
2578: #ifndef BSD44
2579: extern char *ecvt ();
2580: char *cp;
2581: char sbuf[128];
2582: int decpt, sign;
2583:
2584: cp = ecvt (r, 20, &decpt, &sign);
2585: (void) strcpy (sbuf, cp); /* cp gets overwritten by printf */
2586: printf ("{ %s%s, 10, %d }", sign ? "-" : "", sbuf,
2587: decpt - strlen (sbuf));
2588: #else
2589: register char *cp,
2590: *dp,
2591: *sp;
2592: char sbuf[128];
2593:
2594: (void) sprintf (sbuf, "%.19e", r);
2595: if (*(dp = sbuf) == '-')
2596: sp = "-", dp++;
2597: else
2598: sp = "";
2599:
2600: if (dp[1] != '.' || (cp = index (dp, 'e')) == NULL) {
2601: printf ("{ 0, 10, 0 } -- %s --", sbuf);
2602: return;
2603: }
2604: *cp++ = NULL;
2605: printf ("{ %s%c%s, 10, %d }",
2606: sp, *dp, dp + 2, atoi (cp) - strlen (dp + 2));
2607: #endif
2608: }
2609:
2610: /* */
2611:
2612: static int dfl2int (yp)
2613: register YP yp;
2614: {
2615: register YV yv,
2616: y;
2617:
2618: yv = yp -> yp_default;
2619: switch (yv -> yv_code) {
2620: case YV_BOOL:
2621: case YV_NUMBER:
2622: return yv -> yv_number;
2623:
2624: case YV_STRING:
2625: yyerror ("need an integer, not a string");
2626:
2627: case YV_REAL:
2628: yyerror ("need an integer, not a real");
2629:
2630: case YV_IDEFINED:
2631: for (y = yp -> yp_value; y; y = y -> yv_next)
2632: if (y -> yv_code == YV_NUMBER
2633: && (y -> yv_flags & YV_NAMED)
2634: && strcmp (yv -> yv_identifier, y -> yv_named) == 0)
2635: return y -> yv_number;
2636: /* and fall */
2637:
2638: case YV_IDLIST:
2639: yyerror ("haven't written symbol table for values yet");
2640:
2641: case YV_NULL:
2642: yyerror ("need an integer, not NULL");
2643:
2644: default:
2645: myyerror ("unknown value: %d", yv -> yv_code);
2646: }
2647: /* NOTREACHED */
2648: }
2649:
2650: /* DEBUG */
2651:
2652: print_type (yp, level)
2653: register YP yp;
2654: register int level;
2655: {
2656: register YP y;
2657: register YV yv;
2658:
2659: if (yp == NULLYP)
2660: return;
2661:
2662: fprintf (stderr, "%*scode=0x%x flags=%s direction=0x%x\n", level * 4, "",
2663: yp -> yp_code, sprintb (yp -> yp_flags, YPBITS),
2664: yp -> yp_direction);
2665: fprintf (stderr,
2666: "%*sintexp=\"%s\" strexp=\"%s\" prfexp=0%o declexp=\"%s\" varexp=\"%s\"\n",
2667: level * 4, "", yp -> yp_intexp, yp -> yp_strexp, yp -> yp_prfexp,
2668: yp -> yp_declexp, yp -> yp_varexp);
2669: if (yp -> yp_param_type)
2670: fprintf (stderr, "%*sparameter type=\"%s\"\n", level * 4, "",
2671: yp -> yp_param_type);
2672: if (yp -> yp_action0)
2673: fprintf (stderr, "%*saction0 at line %d=\"%s\"\n", level * 4, "",
2674: yp -> yp_act0_lineno, yp -> yp_action0);
2675: if (yp -> yp_action05)
2676: fprintf (stderr, "%*saction05 at line %d=\"%s\"\n", level * 4, "",
2677: yp -> yp_act05_lineno, yp -> yp_action05);
2678: if (yp -> yp_action1)
2679: fprintf (stderr, "%*saction1 at line %d=\"%s\"\n", level * 4, "",
2680: yp -> yp_act1_lineno, yp -> yp_action1);
2681: if (yp -> yp_action2)
2682: fprintf (stderr, "%*saction2 at line %d=\"%s\"\n", level * 4, "",
2683: yp -> yp_act2_lineno, yp -> yp_action2);
2684: if (yp -> yp_action3)
2685: fprintf (stderr, "%*saction3 at line %d=\"%s\"\n", level * 4, "",
2686: yp -> yp_act3_lineno, yp -> yp_action3);
2687:
2688: if (yp -> yp_flags & YP_TAG) {
2689: fprintf (stderr, "%*stag class=0x%x value=0x%x\n", level * 4, "",
2690: yp -> yp_tag -> yt_class, yp -> yp_tag -> yt_value);
2691: print_value (yp -> yp_tag -> yt_value, level + 1);
2692: }
2693:
2694: if (yp -> yp_flags & YP_DEFAULT) {
2695: fprintf (stderr, "%*sdefault=0x%x\n", level * 4, "", yp -> yp_default);
2696: print_value (yp -> yp_default, level + 1);
2697: }
2698:
2699: if (yp -> yp_flags & YP_ID)
2700: fprintf (stderr, "%*sid=\"%s\"\n", level * 4, "", yp -> yp_id);
2701:
2702: if (yp -> yp_flags & YP_BOUND)
2703: fprintf (stderr, "%*sbound=\"%s\"\n", level * 4, "", yp -> yp_bound);
2704:
2705: if (yp -> yp_offset)
2706: fprintf (stderr, "%*soffset=\"%s\"\n", level * 4, "", yp -> yp_offset);
2707:
2708: switch (yp -> yp_code) {
2709: case YP_INTLIST:
2710: case YP_ENUMLIST:
2711: case YP_BITLIST:
2712: fprintf (stderr, "%*svalue=0x%x\n", level * 4, "", yp -> yp_value);
2713: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) {
2714: print_value (yv, level + 1);
2715: fprintf (stderr, "%*s----\n", (level + 1) * 4, "");
2716: }
2717: break;
2718:
2719: case YP_SEQTYPE:
2720: case YP_SEQLIST:
2721: case YP_SETTYPE:
2722: case YP_SETLIST:
2723: case YP_CHOICE:
2724: fprintf (stderr, "%*stype=0x%x\n", level * 4, "", yp -> yp_type);
2725: for (y = yp -> yp_type; y; y = y -> yp_next) {
2726: print_type (y, level + 1);
2727: fprintf (stderr, "%*s----\n", (level + 1) * 4, "");
2728: }
2729: break;
2730:
2731: case YP_IDEFINED:
2732: fprintf (stderr, "%*smodule=\"%s\" identifier=\"%s\"\n",
2733: level * 4, "", yp -> yp_module ? yp -> yp_module : "",
2734: yp -> yp_identifier);
2735: break;
2736:
2737: default:
2738: break;
2739: }
2740: }
2741:
2742: /* */
2743:
2744: static print_value (yv, level)
2745: register YV yv;
2746: register int level;
2747: {
2748: register YV y;
2749:
2750: if (yv == NULLYV)
2751: return;
2752:
2753: fprintf (stderr, "%*scode=0x%x flags=%s\n", level * 4, "",
2754: yv -> yv_code, sprintb (yv -> yv_flags, YVBITS));
2755:
2756: if (yv -> yv_action)
2757: fprintf (stderr, "%*saction at line %d=\"%s\"\n", level * 4, "",
2758: yv -> yv_act_lineno, yv -> yv_action);
2759:
2760: if (yv -> yv_flags & YV_ID)
2761: fprintf (stderr, "%*sid=\"%s\"\n", level * 4, "", yv -> yv_id);
2762:
2763: if (yv -> yv_flags & YV_NAMED)
2764: fprintf (stderr, "%*snamed=\"%s\"\n", level * 4, "", yv -> yv_named);
2765:
2766: if (yv -> yv_flags & YV_TYPE) {
2767: fprintf (stderr, "%*stype=0x%x\n", level * 4, "", yv -> yv_type);
2768: print_type (yv -> yv_type, level + 1);
2769: }
2770:
2771: switch (yv -> yv_code) {
2772: case YV_NUMBER:
2773: case YV_BOOL:
2774: fprintf (stderr, "%*snumber=0x%x\n", level * 4, "",
2775: yv -> yv_number);
2776: break;
2777:
2778: case YV_STRING:
2779: fprintf (stderr, "%*sstring=0x%x\n", level * 4, "",
2780: yv -> yv_string);
2781: break;
2782:
2783: case YV_IDEFINED:
2784: if (yv -> yv_flags & YV_BOUND)
2785: fprintf (stderr, "%*smodule=\"%s\" identifier=\"%s\"\n",
2786: level * 4, "", yv -> yv_module, yv -> yv_identifier);
2787: else
2788: fprintf (stderr, "%*sbound identifier=\"%s\"\n",
2789: level * 4, "", yv -> yv_identifier);
2790: break;
2791:
2792: case YV_IDLIST:
2793: case YV_VALIST:
2794: for (y = yv -> yv_idlist; y; y = y -> yv_next) {
2795: print_value (y, level + 1);
2796: fprintf (stderr, "%*s----\n", (level + 1) * 4, "");
2797: }
2798: break;
2799:
2800: default:
2801: break;
2802: }
2803: }
2804:
2805: /* SYMBOLS */
2806:
2807: static SY new_symbol (encpref, decpref, prfpref, mod, id, type)
2808: register char *encpref,
2809: *decpref,
2810: *prfpref,
2811: *mod,
2812: *id;
2813: register YP type;
2814: {
2815: register SY sy;
2816:
2817: if ((sy = (SY) calloc (1, sizeof *sy)) == NULLSY)
2818: yyerror ("out of memory");
2819: sy -> sy_encpref = encpref;
2820: sy -> sy_decpref = decpref;
2821: sy -> sy_prfpref = prfpref;
2822: sy -> sy_module = mod;
2823: sy -> sy_name = id;
2824: sy -> sy_type = type;
2825:
2826: return sy;
2827: }
2828:
2829:
2830: static SY add_symbol (s1, s2)
2831: register SY s1,
2832: s2;
2833: {
2834: register SY sy;
2835:
2836: if (s1 == NULLSY)
2837: return s2;
2838:
2839: for (sy = s1; sy -> sy_next; sy = sy -> sy_next)
2840: continue;
2841: sy -> sy_next = s2;
2842:
2843: return s1;
2844: }
2845:
2846: /* MODULES */
2847:
2848: static MD lookup_module (module)
2849: char *module;
2850: {
2851: register MD md;
2852:
2853: for (md = mymodules; md; md = md -> md_next)
2854: if (strcmp (md -> md_module, module) == 0)
2855: return md;
2856:
2857: if ((md = (MD) calloc (1, sizeof *md)) == NULLMD)
2858: yyerror ("out of memory");
2859: md -> md_module = new_string (module);
2860:
2861: if (mymodules != NULLMD)
2862: md -> md_next = mymodules;
2863: mymodules = md;
2864:
2865: return NULLMD;
2866: }
2867:
2868: /* TYPES */
2869:
2870: YP new_type (code)
2871: int code;
2872: {
2873: register YP yp;
2874:
2875: if ((yp = (YP) calloc (1, sizeof *yp)) == NULLYP)
2876: yyerror ("out of memory");
2877: yp -> yp_code = code;
2878:
2879: return yp;
2880: }
2881:
2882:
2883: YP add_type (y, z)
2884: register YP y,
2885: z;
2886: {
2887: register YP yp;
2888:
2889: for (yp = y; yp -> yp_next; yp = yp -> yp_next)
2890: continue;
2891: yp -> yp_next = z;
2892:
2893: return y;
2894: }
2895:
2896: /* */
2897:
2898: YP copy_type (yp)
2899: register YP yp;
2900: {
2901: register YP y;
2902:
2903: if (yp == NULLYP)
2904: return NULLYP;
2905:
2906: y = new_type (yp -> yp_code);
2907: y -> yp_direction = yp -> yp_direction;
2908:
2909: switch (yp -> yp_code) {
2910: case YP_IDEFINED:
2911: if (yp -> yp_module)
2912: y -> yp_module = new_string (yp -> yp_module);
2913: y -> yp_identifier = new_string (yp -> yp_identifier);
2914: y -> yp_modid = oid_cpy (yp -> yp_modid);
2915: break;
2916:
2917: case YP_SEQTYPE:
2918: case YP_SEQLIST:
2919: case YP_SETTYPE:
2920: case YP_SETLIST:
2921: case YP_CHOICE:
2922: y -> yp_type = copy_type (yp -> yp_type);
2923: break;
2924:
2925: case YP_INTLIST:
2926: case YP_ENUMLIST:
2927: case YP_BITLIST:
2928: y -> yp_value = copy_value (yp -> yp_value);
2929: break;
2930:
2931: default:
2932: break;
2933: }
2934:
2935: y -> yp_intexp = yp -> yp_intexp;
2936: y -> yp_strexp = yp -> yp_strexp;
2937: y -> yp_prfexp = yp -> yp_prfexp;
2938:
2939: y -> yp_declexp = yp -> yp_declexp;
2940: y -> yp_varexp = yp -> yp_varexp;
2941:
2942: if (yp -> yp_structname)
2943: y -> yp_structname = new_string (yp -> yp_structname);
2944: if (yp -> yp_ptrname)
2945: y -> yp_ptrname = new_string (yp -> yp_ptrname);
2946:
2947: if (yp -> yp_param_type)
2948: y -> yp_param_type = new_string (yp -> yp_param_type);
2949:
2950: if (yp -> yp_action0) {
2951: y -> yp_action0 = new_string (yp -> yp_action0);
2952: y -> yp_act0_lineno = yp -> yp_act0_lineno;
2953: }
2954:
2955: if (yp -> yp_action05) {
2956: y -> yp_action05 = new_string (yp -> yp_action05);
2957: y -> yp_act05_lineno = yp -> yp_act05_lineno;
2958: }
2959:
2960: if (yp -> yp_action1) {
2961: y -> yp_action1 = new_string (yp -> yp_action1);
2962: y -> yp_act1_lineno = yp -> yp_act1_lineno;
2963: }
2964:
2965: if (yp -> yp_action2) {
2966: y -> yp_action2 = new_string (yp -> yp_action2);
2967: y -> yp_act2_lineno = yp -> yp_act2_lineno;
2968: }
2969:
2970: if (yp -> yp_action3) {
2971: y -> yp_action3 = new_string (yp -> yp_action3);
2972: y -> yp_act3_lineno = yp -> yp_act3_lineno;
2973: }
2974:
2975: y -> yp_flags = yp -> yp_flags;
2976:
2977: if (yp -> yp_flags & YP_DEFAULT)
2978: y -> yp_default = copy_value (yp -> yp_default);
2979:
2980: if (yp -> yp_flags & YP_ID)
2981: y -> yp_id = new_string (yp -> yp_id);
2982:
2983: if (yp -> yp_flags & YP_TAG)
2984: y -> yp_tag = copy_tag (yp -> yp_tag);
2985:
2986: if (yp -> yp_flags & YP_BOUND)
2987: y -> yp_bound = new_string (yp -> yp_bound);
2988:
2989: if (yp -> yp_flags & YP_PARMVAL)
2990: y -> yp_parm = new_string (yp -> yp_parm);
2991:
2992: if (yp -> yp_flags & YP_CONTROLLED)
2993: y -> yp_control = new_string (yp -> yp_control);
2994:
2995: if (yp -> yp_flags & YP_OPTCONTROL)
2996: y -> yp_optcontrol = new_string (yp -> yp_optcontrol);
2997:
2998: if (yp -> yp_offset)
2999: y -> yp_offset = new_string (yp -> yp_offset);
3000:
3001: if (yp -> yp_next)
3002: y -> yp_next = copy_type (yp -> yp_next);
3003:
3004: return y;
3005: }
3006:
3007: /* VALUES */
3008:
3009: YV new_value (code)
3010: int code;
3011: {
3012: register YV yv;
3013:
3014: if ((yv = (YV) calloc (1, sizeof *yv)) == NULLYV)
3015: yyerror ("out of memory");
3016: yv -> yv_code = code;
3017:
3018: return yv;
3019: }
3020:
3021:
3022: YV add_value (y, z)
3023: register YV y,
3024: z;
3025: {
3026: register YV yv;
3027:
3028: for (yv = y; yv -> yv_next; yv = yv -> yv_next)
3029: continue;
3030: yv -> yv_next = z;
3031:
3032: return y;
3033: }
3034:
3035: /* */
3036:
3037: YV copy_value (yv)
3038: register YV yv;
3039: {
3040: register YV y;
3041:
3042: if (yv == NULLYV)
3043: return NULLYV;
3044:
3045: y = new_value (yv -> yv_code);
3046: y -> yv_flags = yv -> yv_flags;
3047:
3048: if (yv -> yv_action) {
3049: y -> yv_action = new_string (yv -> yv_action);
3050: y -> yv_act_lineno = yv -> yv_act_lineno;
3051: }
3052:
3053: if (yv -> yv_flags & YV_ID)
3054: y -> yv_id = new_string (yv -> yv_id);
3055:
3056: if (yv -> yv_flags & YV_NAMED)
3057: y -> yv_named = new_string (yv -> yv_named);
3058:
3059: if (yv -> yv_flags & YV_TYPE)
3060: y -> yv_type = copy_type (yv -> yv_type);
3061:
3062: switch (yv -> yv_code) {
3063: case YV_NUMBER:
3064: case YV_BOOL:
3065: y -> yv_number = yv -> yv_number;
3066: break;
3067:
3068: case YV_STRING:
3069: y -> yv_string = new_string (yv -> yv_string);
3070: break;
3071:
3072: case YV_IDEFINED:
3073: if (yv -> yv_module)
3074: y -> yv_module = new_string (yv -> yv_module);
3075: y -> yv_identifier = new_string (yv -> yv_identifier);
3076: break;
3077:
3078: case YV_IDLIST:
3079: case YV_VALIST:
3080: y -> yv_idlist = copy_value (yv -> yv_idlist);
3081: break;
3082:
3083: default:
3084: break;
3085: }
3086:
3087: if (yv -> yv_next)
3088: y -> yv_next = copy_value (yv -> yv_next);
3089:
3090: return y;
3091: }
3092:
3093: /* TAGS */
3094:
3095: YT new_tag (class)
3096: PElementClass class;
3097: {
3098: register YT yt;
3099:
3100: if ((yt = (YT) calloc (1, sizeof *yt)) == NULLYT)
3101: yyerror ("out of memory");
3102: yt -> yt_class = class;
3103:
3104: return yt;
3105: }
3106:
3107: /* */
3108:
3109: YT copy_tag (yt)
3110: register YT yt;
3111: {
3112: register YT y;
3113:
3114: if (yt == NULLYT)
3115: return NULLYT;
3116:
3117: y = new_tag (yt -> yt_class);
3118:
3119: y -> yt_value = copy_value (yt -> yt_value);
3120:
3121: return y;
3122: }
3123:
3124: /* STRINGS */
3125:
3126: char *new_string (s)
3127: register char *s;
3128: {
3129: register char *p;
3130:
3131: if ((p = malloc ((unsigned) (strlen (s) + 1))) == NULLCP)
3132: yyerror ("out of memory");
3133:
3134: (void) strcpy (p, s);
3135: return p;
3136: }
3137:
3138: /* SYMBOLS */
3139:
3140: static struct triple {
3141: char *t_name;
3142: PElementClass t_class;
3143: PElementID t_id;
3144: } triples[] = {
3145: "IA5String", PE_CLASS_UNIV, PE_DEFN_IA5S,
3146: "ISO646String", PE_CLASS_UNIV, PE_DEFN_IA5S,
3147: "NumericString", PE_CLASS_UNIV, PE_DEFN_NUMS,
3148: "PrintableString", PE_CLASS_UNIV, PE_DEFN_PRTS,
3149: "T61String", PE_CLASS_UNIV, PE_DEFN_T61S,
3150: "TeletexString", PE_CLASS_UNIV, PE_DEFN_T61S,
3151: "VideotexString", PE_CLASS_UNIV, PE_DEFN_VTXS,
3152: "GeneralizedTime", PE_CLASS_UNIV, PE_DEFN_GENT,
3153: "GeneralisedTime", PE_CLASS_UNIV, PE_DEFN_GENT,
3154: "UTCTime", PE_CLASS_UNIV, PE_DEFN_UTCT,
3155: "UniversalTime", PE_CLASS_UNIV, PE_DEFN_UTCT,
3156: "GraphicString", PE_CLASS_UNIV, PE_DEFN_GFXS,
3157: "VisibleString", PE_CLASS_UNIV, PE_DEFN_VISS,
3158: "GeneralString", PE_CLASS_UNIV, PE_DEFN_GENS,
3159: "EXTERNAL", PE_CLASS_UNIV, PE_CONS_EXTN,
3160: "ObjectDescriptor", PE_CLASS_UNIV, PE_PRIM_ODE,
3161:
3162: NULL
3163: };
3164:
3165: /* */
3166:
3167: static char *modsym (module, id, prefix)
3168: register char *module,
3169: *id;
3170: char *prefix;
3171: {
3172: char buf1[BUFSIZ],
3173: buf2[BUFSIZ],
3174: buf3[BUFSIZ];
3175: register struct triple *t;
3176: static char buffer[BUFSIZ];
3177:
3178: if (module == NULLCP)
3179: for (t = triples; t -> t_name; t++)
3180: if (strcmp (t -> t_name, id) == 0) {
3181: module = "UNIV";
3182: break;
3183: }
3184:
3185: if (prefix)
3186: modsym_aux (prefix, buf1);
3187: modsym_aux (module ? module : mymodule, buf2);
3188: modsym_aux (id, buf3);
3189: if (prefix)
3190: (void) sprintf (buffer, "%s_%s_%s", buf1, buf2, buf3);
3191: else
3192: (void) sprintf (buffer, "%s_%s", buf2, buf3);
3193:
3194: return buffer;
3195: }
3196:
3197:
3198: static modsym_aux (name, bp)
3199: register char *name,
3200: *bp;
3201: {
3202: register char c;
3203:
3204: while (c = *name++)
3205: switch (c) {
3206: case '-':
3207: *bp++ = '_';
3208: *bp++ = '_';
3209: break;
3210:
3211: default:
3212: *bp++ = c;
3213: break;
3214: }
3215:
3216: *bp = NULL;
3217: }
3218:
3219: /* */
3220:
3221: static char *gensym (s, a)
3222: char *s, *a;
3223: {
3224: int i;
3225: register char *p;
3226: char buffer[BUFSIZ];
3227: static int cP = 0;
3228: static int eP = 0;
3229: static int mP = 0;
3230:
3231: switch (*s) {
3232: case 'c':
3233: i = cP++;
3234: break;
3235: case 'e':
3236: i = eP++;
3237: break;
3238: case 'm':
3239: i = mP++;
3240: break;
3241:
3242: default:
3243: myyerror ("unknown gensym argument \"%s\"", s);
3244: /* NOTREACHED */
3245: }
3246: if (a)
3247: (void) sprintf (buffer, "%s_%s_%d[n_%s]", s, modulename, i, a);
3248: else
3249: (void) sprintf (buffer, "%s_%s_%d", s, modulename, i);
3250:
3251: if ((p = malloc ((unsigned) (strlen (buffer) + 11))) == NULLCP)
3252: yyerror ("out of memory");
3253:
3254: (void) strcpy (p, buffer);
3255: return p;
3256: }
3257:
3258: /* pepy compatible routines - you know how it is ... */
3259: init_new_file ()
3260: {
3261: ;
3262: }
3263:
3264: end_file ()
3265: {
3266: ;
3267: }
3268:
3269: static char *array (s, flg)
3270: char *s;
3271: int flg;
3272: {
3273: static char buf[BUFSIZ];
3274: char *p;
3275:
3276: if (!flg) return s;
3277:
3278: if (p = index (s, '[')) {
3279: (void) sprintf (buf, "%*.*s[1]", p - s, p - s, s);
3280: return buf;
3281: }
3282: return s;
3283: }
3284:
3285: static void prime_default (yp, level)
3286: YP yp;
3287: int level;
3288: {
3289: switch (yp -> yp_code) {
3290: case YP_BOOL:
3291: printf ("%*s%s = %d;\n", level * 4, "",
3292: SVAL (yp->yp_varexp),
3293: val2int (yp -> yp_default) ? 1 : 0);
3294: break;
3295:
3296: case YP_INT:
3297: printf ("%*s%s = %d;\n", level * 4, "",
3298: SVAL (yp -> yp_varexp), val2int (yp -> yp_default));
3299: break;
3300:
3301: case YP_INTLIST:
3302: case YP_ENUMLIST:
3303: printf ("%*s%s = %d;\n", level * 4, "",
3304: SVAL (yp -> yp_varexp), dfl2int (yp));
3305: break;
3306:
3307: case YP_REAL:
3308: printf ("%*s%s = %g;\n", level * 4, "",
3309: SVAL (yp -> yp_varexp),
3310: val2real (yp -> yp_default));
3311:
3312: default:
3313: break;
3314: }
3315: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.