![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pass2.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 / pepsy|
Return to pass2.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / pepsy |
1.1 root 1: /* pass2.c */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/pepsy/RCS/pass2.c,v 7.2 90/07/27 08:49:22 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/pepsy/RCS/pass2.c,v 7.2 90/07/27 08:49:22 mrose Exp $
9: *
10: *
11: * $Log: pass2.c,v $
12: * Revision 7.2 90/07/27 08:49:22 mrose
13: * update
14: *
15: * Revision 7.1 90/07/01 20:00:32 mrose
16: * update
17: *
18: */
19:
20: /*
21: * NOTICE
22: *
23: * Acquisition, use, and distribution of this module and related
24: * materials are subject to the restrictions of a license agreement.
25: * Consult the Preface in the User's Manual for the full terms of
26: * this agreement.
27: *
28: */
29:
30:
31: #include <stdio.h>
32: #include <ctype.h>
33: #include "pepsydefs.h"
34: #include "pass2.h"
35: #include "mine.h"
36: #include "sym.h"
37:
38: extern int doexternals;
39: extern int sflag;
40:
41: #if 0
42: extern int hflag;
43: extern int bwidth;
44:
45: #endif
46: extern char *eval;
47:
48: #if 0
49: extern char *yyprefix;
50:
51: #endif
52: extern int Aflag;
53: extern SY mysymbols;
54: extern char *modsym();
55: extern char *my_strcat();
56: extern char *notidtoid();
57:
58: FILE *fptab, *ffopen();
59:
60: peri_pass2()
61: {
62:
63: int nentries;
64: int encflag = 1, decflag = 1, prntflag = 1;
65: char *buf, *inc, *tab, *act;
66: SY sy;
67: YP yp;
68: FILE *fph, *fphh, *fpe, *fpd, *fpp;
69: FILE *fpa;
70:
71: if (!sflag)
72: (void) fflush(stderr);
73:
74: if (bflag) {
75: register int i, j;
76:
77: i = 2, j = 10;
78: for (sy = mysymbols; sy; sy = sy->sy_next)
79: if (!(sy->sy_type->yp_flags & YP_IMPORTED))
80: if (++i >= j)
81: j *= 10;
82: }
83: if (strcmp(mymodule, "UNIV"))
84: (void) lookup_module("UNIV", NULLOID);
85:
86: fph = ffopen(my_strcat(mymodule, HFILE1));
87: inc = my_strcat (mymodule, HFILE2);
88: (void) fprintf (fph, "#ifndef\tPEPYPATH\n");
89: (void) fprintf (fph, "#include <isode/pepsy/%s>\n", inc);
90: (void) fprintf (fph, "#else\n");
91: (void) fprintf (fph, "#include \"%s\"\n", inc);
92: (void) fprintf (fph, "#endif\n\n\n");
93:
94: #ifdef ACT_CODE
95: act = my_strcat(mymodule, ACTIONDEFS);
96:
97: fpe = ffopen(my_strcat(mymodule, ENCFILENAME));
98: file_header(fpe, act);
99: fpd = ffopen(my_strcat(mymodule, DECFILENAME));
100: file_header(fpd, act);
101: fpp = ffopen(my_strcat(mymodule, PRNTFILENAME));
102: file_header(fpp, act);
103: fpa = ffopen(act);
104: #endif
105: tab = notidtoid(mymodule);
106: for (sy = mysymbols; sy; sy = sy->sy_next) {
107: eval = sy->sy_name;
108: yp = sy->sy_type;
109:
110: if (sy->sy_module == NULLCP)
111: yyerror("no module name associated with symbol");
112: if (yp->yp_flags & YP_IMPORTED)
113: continue;
114: if (strcmp(sy->sy_module, mymodule)) {
115: fprintf(stderr, "mymodule unsuitable for module name e.g %s and %s(mymodule)\n", sy->sy_module, mymodule);
116: exit(1);
117: }
118: if (yp->yp_direction & YP_ENCODER || Aflag) {
119: buf = modsym (sy -> sy_module, sy -> sy_name, yyencdflt);
120: fprintf(fph, "#define %s", buf);
121: fprintf(fph, "(pe, top, len, buffer, parm) \\\n");
122: fprintf(fph, " %s(%s%s, ", ENCFNCNAME, PREFIX, proc_name(sy->sy_name, 1));
123: fprintf(fph, "&%s%s%s, ", PREFIX, tab, MODTYP_SUFFIX);
124: fprintf(fph, "pe, top, len, buffer, (char *) parm)\n\n");
125: #ifdef ACT_CODE
126: if (encflag) {
127: fprintf(fpe, "%s%s", ENC_FNCNAME, tab);
128: open_func(fpe);
129: encflag--;
130: }
131: #endif
132: if (bflag)
133: init_new_file();
134: if (bflag)
135: end_file();
136: }
137: if (yp->yp_direction & YP_DECODER || Aflag) {
138: buf = modsym (sy -> sy_module, sy -> sy_name, yydecdflt);
139: if (bflag)
140: init_new_file();
141: fprintf(fph, "#define %s", buf);
142: fprintf(fph, "(pe, top, len, buffer, parm) \\\n");
143: fprintf(fph, " %s(%s%s, ", DECFNCNAME, PREFIX, proc_name(sy->sy_name, 1));
144: fprintf(fph, "&%s%s%s, ", PREFIX, tab, MODTYP_SUFFIX);
145: fprintf(fph, "pe, top, len, buffer, (char **) parm)\n\n");
146: #if ACT_CODE
147: if (decflag) {
148: fprintf(fpd, "%s%s", DEC_FNCNAME, tab);
149: open_func(fpd);
150: decflag--;
151: }
152: #endif
153: if (bflag)
154: end_file();
155: }
156: if (yp->yp_direction & YP_PRINTER || Aflag) {
157: buf = modsym (sy -> sy_module, sy -> sy_name, yyprfdflt);
158: if (bflag)
159: init_new_file();
160: fprintf(fph, "#define %s", buf);
161: fprintf(fph, "(pe, top, len, buffer, parm) \\\n");
162: fprintf(fph, " %s(%s%s, ", PRNTFNCNAME, PREFIX, proc_name(sy->sy_name, 1));
163: fprintf(fph, "&%s%s%s, ", PREFIX, tab, MODTYP_SUFFIX);
164: #if 0
165: /* no parm arguement to prnt_f now */
166: fprintf(fph, "pe, top, len, buffer, (char *) parm)\n");
167: #endif
168: fprintf(fph, "pe, top, len, buffer)\n");
169: fprintf(fph, "#define %s_P", buf);
170: fprintf(fph, " %s%s, ", PREFIX,
171: proc_name(sy->sy_name, 1));
172: fprintf(fph, "&%s%s%s\n\n", PREFIX, tab, MODTYP_SUFFIX);
173: #ifdef ACT_CODE
174: if (prntflag) {
175: fprintf(fpp, "%s%s", PRNT_FNCNAME, tab);
176: open_func(fpp);
177: prntflag--;
178: }
179: #endif
180: if (bflag)
181: end_file();
182: }
183: if (!bflag && ferror(stdout))
184: myyerror("write error - %s", sys_errname(errno));
185: }
186:
187: #ifdef ACT_CODE
188: if (!encflag) {
189: close_func(fpe);
190: }
191: if (!decflag) {
192: close_func(fpd);
193: }
194: if (!prntflag) {
195: close_func(fpp);
196: }
197: #endif
198:
199: close(fph);
200: #ifdef ACT_CODE
201: close(fpe);
202: close(fpd);
203: close(fpp);
204: close(fpa);
205: #endif
206:
207: fptab = ffopen(my_strcat(mymodule, TBLNAME));
208:
209: /* Only need two files <stdio.h> and our types file which includes
210: * everything else we need
211: * Assumption. types file in the same directory as the _tables
212: */
213: fprintf(fptab, "#include <stdio.h>\n");
214: fprintf(fptab, "#include \"%s%s\"\n\n", mymodule, GENTYPES);
215:
216:
217: #if 0
218: {
219: #define NFILES 5
220: char *files[NFILES];
221: char buf[BUFSIZ];
222: int last = 0; /* next free slot in files */
223:
224: strncpy(buf, mymodule, BUFSIZ);
225: strncat(buf, GENTYPES, BUFSIZ);
226:
227: files[last++] = buf;
228: files[last++] = inc;
229: files[last++] = (char *)0;
230:
231: fprintf(fptab, "#include <stdio.h>\n");
232: doincl(fptab, files);
233:
234: #undef NFILES
235: }
236:
237: /* already done in our types.h file */
238: proc_extmod(fptab); /* process the external modules here as well */
239: #endif
240:
241: #if 0
242: fprintf(fptab, "#include \"%s%s\"\n", mymodule, GENTYPES);
243: fprintf(fptab, "#include \"%s\"\n", inc);
244: #endif
245: #ifdef ACT_CODE
246: fprintf(fptab, "#include \"%s\"\n", act);
247: #endif
248: /*
249: * loop through and generate all the default values definitions
250: */
251: for (sy = mysymbols; sy; sy = sy->sy_next) {
252: yp = sy->sy_type;
253: if (yp->yp_flags & YP_IMPORTED)
254: continue;
255: if (yp->yp_direction & (YP_ENCODER | YP_DECODER | YP_PRINTER)
256: || Aflag) {
257: gen_dflts(sy->sy_type, sy->sy_name);
258: }
259: }
260: fprintf(fptab, "\n#define OFFSET(t,f)\t((int ) &(((t *)0)->f))\n\n");
261: nentries = 0;
262: head = NULL;
263: for (sy = mysymbols; sy; sy = sy->sy_next) {
264: yp = sy->sy_type;
265: if (yp->yp_flags & YP_IMPORTED)
266: continue;
267: if (yp->yp_direction & YP_ENCODER || Aflag) {
268: nentries++;
269: gen_enctbl(sy);
270: }
271: }
272: head = NULL;
273: for (sy = mysymbols; sy; sy = sy->sy_next) {
274: yp = sy->sy_type;
275: if (yp->yp_flags & YP_IMPORTED)
276: continue;
277: if (yp->yp_direction & YP_DECODER || Aflag)
278: gen_dectbl(sy);
279: }
280:
281: head = NULL;
282: for (sy = mysymbols; sy; sy = sy->sy_next) {
283: yp = sy->sy_type;
284: if (yp->yp_flags & YP_IMPORTED)
285: continue;
286: if (yp->yp_direction & YP_PRINTER || Aflag)
287: gen_prnttbl(sy);
288: }
289:
290: fphh = ffopen(inc);
291: fprintf(fphh, "\nextern modtyp %s%s%s;\n",
292: PREFIX, tab, MODTYP_SUFFIX);
293: out_final_defs(fphh);
294: close(fphh);
295:
296: gen_tpe();
297: gen_modtype(tab, nentries, encflag, decflag, prntflag);
298:
299: #if 0
300: write_ph_file();
301: print_list();
302: #endif
303:
304: gen_lint(fptab);
305:
306: fclose(fptab);
307: }
308:
309: gen_enctbl(sy)
310: SY sy;
311: {
312: fprintf(fptab, "static tpe %s%s[] = {\n", ETABLE, proc_name(sy->sy_name, 0));
313: fprintf(fptab, "\t{ PE_START, 0, 0, 0 },\n");
314: gen_enctbl_rest(sy->sy_type, sy->sy_name);
315: fprintf(fptab, "\t{ PE_END, 0, 0, 0 }\n");
316: fprintf(fptab, "\t};\n");
317: fprintf(fptab, "\n");
318: }
319:
320: gen_dectbl(sy)
321: SY sy;
322: {
323: fprintf(fptab, "static tpe %s%s[] = {\n", DTABLE, proc_name(sy->sy_name, 0));
324: fprintf(fptab, "\t{ PE_START, 0, 0, 0 },\n");
325: gen_dectbl_rest(sy->sy_type, sy->sy_name);
326: fprintf(fptab, "\t{ PE_END, 0, 0, 0 }\n");
327: fprintf(fptab, "\t};\n");
328: fprintf(fptab, "\n");
329: }
330:
331:
332: gen_prnttbl(sy)
333: SY sy;
334: {
335: fprintf(fptab, "static ptpe %s%s[] = {\n", PTABLE, proc_name(sy->sy_name, 0));
336: fprintf(fptab, "\t{ PE_START, 0, 0, 0, \"%s\" },\n", sy->sy_name);
337: gen_prnttbl_rest(sy->sy_type, sy->sy_name);
338: fprintf(fptab, "\t{ PE_END, 0, 0, 0, NULL }\n");
339: fprintf(fptab, "\t};\n");
340: fprintf(fptab, "\n");
341: }
342:
343:
344: gen_enctbl_rest(yp, id)
345: YP yp;
346: char *id;
347: {
348: int i;
349:
350: i = tenc_typ(yp, id, NULL);
351: }
352:
353: gen_dectbl_rest(yp, id)
354: YP yp;
355: char *id;
356: {
357: int i;
358:
359: i = tdec_typ(yp, id, NULL);
360: }
361:
362: gen_prnttbl_rest(yp, id)
363: YP yp;
364: char *id;
365: {
366: int i;
367:
368: i = tprnt_typ(yp, id, NULL);
369: }
370:
371:
372: /*
373: * define the tpe index tables and the pointer table
374: */
375: gen_tpe()
376: {
377: SY sy;
378:
379: fprintf(fptab, "static tpe *etabl[] = {\n");
380: for (sy = mysymbols; sy; sy = sy->sy_next) {
381: if (sy->sy_type->yp_flags & YP_IMPORTED)
382: continue;
383: if (sy->sy_type->yp_direction & YP_ENCODER || Aflag)
384: fprintf(fptab, "\t%s%s,\n", ETABLE, proc_name(sy->sy_name, 0));
385: }
386: fprintf(fptab, "\t};\n\n");
387:
388: fprintf(fptab, "static tpe *dtabl[] = {\n");
389: for (sy = mysymbols; sy; sy = sy->sy_next) {
390: if (sy->sy_type->yp_flags & YP_IMPORTED)
391: continue;
392: if (sy->sy_type->yp_direction & YP_DECODER || Aflag)
393: fprintf(fptab, "\t%s%s,\n", DTABLE, proc_name(sy->sy_name, 0));
394: }
395: fprintf(fptab, "\t};\n\n");
396:
397: fprintf(fptab, "static ptpe *ptabl[] = {\n");
398: for (sy = mysymbols; sy; sy = sy->sy_next) {
399: if (sy->sy_type->yp_flags & YP_IMPORTED)
400: continue;
401: if (sy->sy_type->yp_direction & YP_PRINTER || Aflag)
402: fprintf(fptab, "\t%s%s,\n", PTABLE, proc_name(sy->sy_name, 0));
403: }
404: fprintf(fptab, "\t};\n\n");
405:
406: /* produce pointer table */
407: dump_ptrtab(fptab);
408: }
409:
410: /*
411: * output the module structure for this module
412: */
413: gen_modtype(tab, no, f1, f2, f3)
414: char *tab;
415: int no;
416: int f1, f2, f3;
417: {
418: if (!f1)
419: fprintf(fptab, "extern PE\t%s%s();\n", ENC_FNCNAME, tab);
420: if (!f2)
421: fprintf(fptab, "extern PE\t%s%s();\n", DEC_FNCNAME, tab);
422: if (!f3)
423: fprintf(fptab, "extern PE\t%s%s();\n", PRNT_FNCNAME, tab);
424: fprintf(fptab, "\n");
425: fprintf(fptab, "modtyp %s%s%s = {\n", PREFIX, tab, MODTYP_SUFFIX);
426: fprintf(fptab, "\t\"%s\",\n", mymodule); /* name */
427: fprintf(fptab, "\t%d,\n", no); /* number of entries */
428: /* coding tables */
429: fprintf(fptab, "\tetabl,\n");
430: fprintf(fptab, "\tdtabl,\n");
431: fprintf(fptab, "\tptabl,\n");
432: /* action tables - may disappear */
433: fprintf(fptab, "\t0,\n"); /* no action code */
434: fprintf(fptab, "\t0,\n");
435: fprintf(fptab, "\t0,\n");
436:
437: fprintf(fptab, "\t%s%s%s,\n", PREFIX, PTR_TABNAME, tab);
438: fprintf(fptab, "\t};\n\n");
439: }
440:
441: /*
442: * open a file called name
443: */
444: FILE *
445: ffopen(name)
446: char *name;
447: {
448: FILE *fp;
449:
450: if ((fp = fopen(name, "w")) == NULL) {
451: fprintf(stderr, "Can't create the file %s", name);
452: exit(1);
453: }
454: return fp;
455: }
456:
457: #ifdef ACT_CODE
458: /*
459: * output the file prologue to the file specified by fp
460: */
461: file_header(fp, act)
462: FILE *fp;
463: char *act;
464: {
465: fprintf(fp, "#include %s\n", PSAP_DOT_H);
466: fprintf(fp, "#include \"%s\"\n", INCFILE1);
467: fprintf(fp, "#include \"%s\"\n", act);
468: fprintf(fp, "#include \"%s%s\"\n\n", mymodule, GENTYPES);
469: fprintf(fp, "#ifndef PEPYPARM\n");
470: fprintf(fp, "#define PEPYPARM char *\n");
471: fprintf(fp, "#endif\n");
472: fprintf(fp, "extern PEPYPARM NullParm;\n\n");
473: }
474:
475: #endif
476:
477: /*
478: * output the function prologue to the file specified by fp
479: */
480: open_func(fp)
481: FILE *fp;
482: {
483:
484: fprintf(fp, "(pe, parm, p, mod)\n");
485: fprintf(fp, "PE\tpe;\n");
486: fprintf(fp, "PEPYPARM\tparm;\n");
487: fprintf(fp, "tpe\t*p;\n");
488: fprintf(fp, "modtyp\t*mod;\n");
489: fprintf(fp, "{\n");
490: /* action 0 ???? */
491: fprintf(fp, "\tswitch (p->pe_ucode) {\n");
492: }
493:
494: /*
495: * output the function epilogue to the file specified by fp
496: */
497: close_func(fp)
498: FILE *fp;
499: {
500: fprintf(fp, "\t\tdefault:\n");
501: fprintf(fp, "\t\t\tbreak;\n");
502: fprintf(fp, "\t}\n");
503: fprintf(fp, "\treturn OK;\n}\n\n");
504: }
505:
506: /*
507: * print the table id_table
508: */
509: print_table()
510: {
511: int i;
512: id_entry *t;
513:
514: for (i = 0; i < TABLESIZE; i++) {
515: for (t = id_table[i]; t != NULL; t = t->next)
516: printf("%s(%d) --> ", t->r_value, t->def_value);
517: if (id_table[i] != NULL)
518: printf("NULL -- %d\n", i);
519: }
520: }
521:
522: static struct univ_typ univ_tab[] = {
523: {"EXTERNAL", "struct type_UNIV_EXTERNAL *", "EXTERNAL", 8, 0,
524: "UNIV", UNF_EXTMOD, YP_UNDF, },
525: {"GeneralString", "struct qbuf *", "OCTETSTRING", 27, 0,
526: "UNIV", 0, YP_OCT, },
527: {"GeneralisedTime", "struct qbuf *", "OCTETSTRING", 24, 0,
528: "UNIV", 0, YP_OCT, },
529: {"GeneralizedTime", "struct qbuf *", "OCTETSTRING", 24, 0,
530: "UNIV", 0, YP_OCT, },
531: {"GraphicString", "struct qbuf *", "OCTETSTRING", 25, 0,
532: "UNIV", 0, YP_OCT, },
533: {"IA5String", "struct qbuf *", "OCTETSTRING", 22, 0,
534: "UNIV", 0, YP_OCT, },
535: {"ISO646String", "struct qbuf *", "OCTETSTRING", 26, 0,
536: "UNIV", 0, YP_OCT, },
537: {"NumericString", "struct qbuf *", "OCTETSTRING", 18, 0,
538: "UNIV", 0, YP_OCT, },
539: {"PrintableString", "struct qbuf *", "OCTETSTRING", 19, 0,
540: "UNIV", 0, YP_OCT, },
541: {"TeletexString", "struct qbuf *", "OCTETSTRING", 20, 0,
542: "UNIV", 0, YP_OCT, },
543: {"T61String", "struct qbuf *", "OCTETSTRING", 20, 0,
544: "UNIV", 0, YP_OCT, },
545: {"UTCTime", "struct qbuf *", "OCTETSTRING", 23, 0,
546: "UNIV", 0, YP_OCT, },
547: {"UniversalTime", "struct qbuf *", "OCTETSTRING", 23, 0,
548: "UNIV", 0, YP_OCT, },
549: {"VideotexString", "struct qbuf *", "OCTETSTRING", 21, 0,
550: "UNIV", 0, YP_OCT, },
551: {"VisibleString", "struct qbuf *", "OCTETSTRING", 26, 0,
552: "UNIV", 0, YP_OCT, },
553: };
554:
555: extern struct univ_typ *simptyp();
556:
557: /*
558: * Determine wether the type name matches one of the Universal types
559: * which are to be treated specially. If so return a pointer to the
560: * data structure which contains the parameters describing how it
561: * should be processed
562: */
563: struct univ_typ *
564: univtyp(name)
565: char *name;
566: {
567: int low, high, i;
568: struct univ_typ *p;
569:
570: low = 0;
571: high = NENTRIES(univ_tab) - 1;
572: while (low <= high) {
573: p = univ_tab + (low + high) / 2;
574: if ((i = scmp(name, p->univ_name)) == 0)
575: return (p);
576: if (low == high)
577: return (NULL);
578: if (i < 0)
579: high = p - univ_tab - 1;
580: else
581: low = p - univ_tab + 1;
582: }
583:
584: #if OPTIMISED
585: if ((p = simptyp(name)) == NULL)
586: return (p);
587: #endif
588:
589: return (NULL);
590: }
591:
592: /*
593: * Compare two strings returning a number representing the character
594: * where they differ or 0 if are the same - I wrote this because I
595: * couldn't trust strcmp to work the same way between numbers and
596: * letters everywhere. longer strings are greater shorter strings
597: * numbers are greater then all letters lower case are greater then
598: * upper case There must be a better way !
599: */
600: scmp(s1, s2)
601: char *s1, *s2;
602: {
603: while (*s1 == *s2 && *s2)
604: s1++, s2++;
605: if (*s1 == '\0' && *s2 == '\0')
606: return (0);
607: if (*s1 == '\0')
608: return (-1);
609: if (*s2 == '\0')
610: return (1);
611: if (isalpha(*s1) && isalpha(*s2)) {
612: if (isupper(*s1) && isupper(*s2))
613: return (*s1 - *s2);
614: if (islower(*s1) && islower(*s1))
615: return (*s1 - *s2);
616: if (isupper(*s1))
617: return (-1);
618: if (islower(*s1))
619: return (1);
620: }
621: if (isdigit(*s1) && isdigit(*s2))
622: return (*s1 - *s2);
623: if (isdigit(*s1))
624: return (1);
625: if (isdigit(*s2))
626: return (-1);
627: return (*s1 - *s2);
628: }
629:
630: /*
631: * lookup a symbol and return a pointer to it
632: */
633: SY
634: syfind(name)
635: char *name;
636: {
637: SY sy;
638:
639: for (sy = mysymbols; sy; sy = sy->sy_next) {
640: if (sy->sy_type->yp_flags & YP_IMPORTED)
641: continue;
642: if (strcmp(name, sy->sy_name) == 0)
643: return (sy);
644: }
645: return (NULL);
646: }
647: /*
648: * determine if the symbol is a simple type that is optimised
649: */
650: struct univ_typ *
651: simptyp(yp)
652: YP yp;
653: {
654: struct univ_typ *p;
655: YP y;
656:
657: static struct univ_typ bitstring =
658: {"Bitstring", "struct PElement *", "BITSTRING", 3, 0},
659: octetstring =
660: {"GeneralString", "struct qbuf *", "OCTETSTRING", 4, 0},
661: oid =
662: {"Object Identifier", "struct OIDentifier *", "OBJIDENT", 6, 0},
663: obj =
664: {"Module", "struct OIDentifier *",
665: "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", 27, 0};
666:
667: #define MSTRING 30 /* number of Xs in the above string */
668:
669: switch (yp->yp_code) {
670: case YP_BIT:
671: case YP_BITLIST:
672: return (&bitstring);
673:
674: case YP_SEQ:
675: case YP_SET:
676: case YP_ANY:
677: return (&bitstring);
678:
679: case YP_OCT:
680: return (&octetstring);
681:
682: case YP_OID:
683: return (&oid);
684:
685: case YP_IDEFINED:
686: strncpy(p->univ_tab, yp->yp_identifier, MSTRING);
687: return (&obj);
688:
689:
690: case YP_SEQLIST:
691: case YP_SETLIST:
692: case YP_CHOICE:
693: #if 0
694: if (hflag && (y = yp->yp_type) && !y->yp_next) {
695: ferr(1, "simtyp: -h flag not implemented\n");
696: return (NULL);
697: }
698: #endif
699:
700: default:
701: return (NULL);
702: }
703: }
704:
705: /*
706: * Generate function definitions for all the macros so that lint
707: * can type check all thier uses
708: */
709: gen_lint(fp)
710: FILE *fp;
711: {
712: char *buf, *tab;
713: SY sy;
714: YP yp;
715:
716: fprintf(fp, "\n#ifdef\tlint\n");
717: tab = notidtoid(mymodule);
718: for (sy = mysymbols; sy; sy = sy->sy_next) {
719: eval = sy->sy_name;
720: yp = sy->sy_type;
721:
722: if (sy->sy_module == NULLCP)
723: yyerror("no module name associated with symbol");
724: if (yp->yp_flags & YP_IMPORTED)
725: continue;
726: if (strcmp(sy->sy_module, mymodule)) {
727: fprintf(stderr,
728: "mymodule unsuitable for module name e.g %s and %s(mymodule)\n",
729: sy->sy_module, mymodule);
730: exit(1);
731: }
732: /* Encoding routine */
733: buf = modsym (sy -> sy_module, sy -> sy_name, yyencdflt);
734: fprintf(fp, "\n#undef %s\n", buf);
735: fprintf(fp, "int %s", buf);
736: fprintf(fp, "(pe, top, len, buffer, parm)\n");
737: fprintf(fp, "PE *pe;\n");
738: fprintf(fp, "int top,\n\tlen;\n");
739: fprintf(fp, "char buffer;\n");
740: fprintf(fp, "struct %s parm;\n",
741: modsym(sy->sy_module, sy->sy_name, "type"));
742: fprintf(fp, "{\n return (%s(%s%s, ",
743: ENCFNCNAME, PREFIX, proc_name(sy->sy_name, 1));
744: fprintf(fp, "&%s%s%s, ", PREFIX, tab, MODTYP_SUFFIX);
745: fprintf(fp, "pe, top, len, buffer, (char *) parm)\n}\n");
746:
747: /* Decoding routine */
748: buf = modsym (sy -> sy_module, sy -> sy_name, yydecdflt);
749: fprintf(fp, "\n#undef %s\n", buf);
750: fprintf(fp, "int %s", buf);
751: fprintf(fp, "(pe, top, len, buffer, parm)\n");
752: fprintf(fp, "PE pe;\n");
753: fprintf(fp, "int top,\n\t*len;\n");
754: fprintf(fp, "char *buffer;\n");
755: fprintf(fp, "struct %s parm;\n",
756: modsym(sy->sy_module, sy->sy_name, "type"));
757: fprintf(fp, "{\n return (%s(%s%s, ",
758: DECFNCNAME, PREFIX, proc_name(sy->sy_name, 1));
759: fprintf(fp, "&%s%s%s, ", PREFIX, tab, MODTYP_SUFFIX);
760: fprintf(fp, "pe, top, len, buffer, (char *) parm)\n}\n");
761:
762:
763: /* Printing routine */
764: buf = modsym (sy -> sy_module, sy -> sy_name, yyprfdflt);
765: fprintf(fp, "\n#undef %s\n", buf);
766: fprintf(fp, "int %s", buf);
767: fprintf(fp, "(pe, top, len, buffer, parm)\n");
768: fprintf(fp, "PE pe;\n");
769: fprintf(fp, "int top,\n\t*len;\n");
770: fprintf(fp, "char *buffer;\n");
771: fprintf(fp, "struct %s parm;\n",
772: modsym(sy->sy_module, sy->sy_name, "type"));
773: fprintf(fp, "{\n return (%s(%s%s, ",
774: PRNTFNCNAME, PREFIX, proc_name(sy->sy_name, 1));
775: fprintf(fp, "&%s%s%s, ", PREFIX, tab, MODTYP_SUFFIX);
776: fprintf(fp, "pe, top, len, buffer, (char *) parm)\n}\n");
777:
778: if (ferror(fp))
779: myyerror("write error - %s", sys_errname(errno));
780: }
781: fprintf(fp, "\n#endif\t/* lint */\n");
782: }
783:
784: /*
785: * pointer table support routines
786: */
787: static char *ptr_tab[MAXPTRS]; /* reference of the pointer */
788: static int ptr_cnt = 0;
789:
790: /*
791: * add the given pointer to the pointer table and return its index
792: */
793: addptr(p)
794: char *p;
795: {
796: int ind;
797: register int i;
798: register char *s;
799:
800: /*
801: * try to eliminate common pointers by returning a ponter if it matches
802: * previously
803: */
804: for (i = 0; i < ptr_cnt; i++)
805: if (strcmp(p, ptr_tab[i]) == 0)
806: return (i);
807:
808: if (ptr_cnt >= MAXPTRS) {
809: fprintf(stderr, "\npointer table overflow %d\n", ptr_cnt);
810: exit(1);
811: }
812:
813: if ((s = malloc ((unsigned) (strlen (p) + 1))) == NULLCP) {
814: fprintf(stderr, "\naddptr:out of memory\n");
815: exit(1);
816: }
817: (void) strcpy (s, p);
818:
819: ptr_tab[ind = ptr_cnt++] = s;
820:
821: return (ind);
822: }
823:
824:
825: dump_ptrtab(fp)
826: FILE *fp;
827: {
828: char *tab;
829: int i;
830:
831: tab = notidtoid(mymodule);
832:
833: fprintf(fp, "\n/* Pointer table %d entries */\n", ptr_cnt);
834: fprintf(fp, "static caddr_t %s%s%s[] = {\n", PREFIX, PTR_TABNAME, tab);
835:
836: for (i = 0; i < ptr_cnt; i++)
837: fprintf(fp, " (caddr_t ) %s,\n", ptr_tab[i]);
838:
839: if (ptr_cnt <= 0)
840: fprintf(fp, " (caddr_t ) 0,\n"); /* for fussy C compilers */
841:
842: fprintf(fp, "};\n");
843: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.