![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to etabs.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 etabs.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / pepsy |
1.1 root 1: /* etabs.c */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/pepsy/RCS/etabs.c,v 7.2 90/07/27 08:49:15 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/pepsy/RCS/etabs.c,v 7.2 90/07/27 08:49:15 mrose Exp $
9: *
10: *
11: * $Log: etabs.c,v $
12: * Revision 7.2 90/07/27 08:49:15 mrose
13: * update
14: *
15: * Revision 7.1 90/07/09 14:52:33 mrose
16: * sync
17: *
18: * Revision 7.0 90/07/01 19:54:18 mrose
19: * *** empty log message ***
20: *
21: */
22:
23: /*
24: * NOTICE
25: *
26: * Acquisition, use, and distribution of this module and related
27: * materials are subject to the restrictions of a license agreement.
28: * Consult the Preface in the User's Manual for the full terms of
29: * this agreement.
30: *
31: */
32:
33:
34: #include <stdio.h>
35: #include <ctype.h>
36: #include "pepsydefs.h"
37: #include "sym.h"
38: #include "pass2.h"
39: #include "mine.h"
40:
41: s_table *head;
42:
43: extern s_table *lookup_list(), *proc_def();
44:
45: extern FILE *fptab;
46: extern char *c_tag(), *c_class();
47: extern char *ec_tag(), *ec_class();
48: extern char *strip_last();
49: extern char *get_val(), *get_comp(), *get_string();
50: extern s_table *get_offset();
51: extern char *my_strcat(), *strp2name();
52: extern char *my_new_str();
53: extern char *mymodule;
54: extern char *modsym();
55: extern char *concat();
56: extern char *genlabel();
57: extern char *notidtoid();
58: extern YV calc_yv();
59: extern SY syfind();
60: static s_table *en_ptr;
61: extern s_table *ptr;
62:
63: static int cons_type = 0;
64: /* int explicit; */
65:
66: s_table *save_ptr;
67:
68: #define WORDSIZE 20
69: #define MAXNAME 256 /* maximum size of a identifier */
70:
71: #ifdef DEBUG
72: char *str_yp_code[] = {
73: "Undefined", "Boolean", "Integer", "Named number list", "Bitstring",
74: "Named Bitstring list", "Octet String", "Null", "Sequence",
75: "Sequence of", "Sequence list", "Set", "Set of", "Set list",
76: "Choice", "Any", "Object Identifier",
77: "", "", "", "", "", "", "", "",
78: "", "", "", "", "", "", "", "Identifier",
79:
80: };
81:
82: #endif
83:
84: /*
85: * table encode a type. generate tables for the encoding of a type
86: */
87: tenc_typ(yp, id, type)
88: YP yp;
89: char *id;
90: char *type;
91: {
92:
93: char *t, *f;
94: char *p1;
95: char *s1, *s2, *s3;
96: char *s;
97: s_table *ptr1, *ptr2;
98: YP y;
99:
100:
101: if (yp->yp_code < 0 || yp->yp_code > YP_REAL)
102: ferrd(1, "tdec_typ: unimplemented type %d\n", yp->yp_code);
103:
104: if (yp == NULL) {
105: ferr(0, "tenc_typ:NULL argument\n");
106: return;
107: }
108: if (yp->yp_flags & YP_DEFAULT)
109: gdflt(yp, G_ENC);
110:
111: if (yp->yp_flags & YP_TAG && !(yp->yp_flags & YP_IMPLICIT)) {
112: (void) fprintf(fptab, "\t{ ETAG, 0, ");
113: (void) fprintf(fptab, "%s, %s },\n", ec_tag(yp), ec_class(yp));
114: }
115: /* Preserve the type of the containing object */
116: if (type)
117: t = type;
118: else
119: t = my_strcat("struct ", modsym(mymodule, id, "type"));
120: f = yp->yp_varexp;
121: switch (yp->yp_code) {
122:
123: case YP_UNDF:
124: ferr(1, "tenc_typ:Undefined type\n");
125:
126: case YP_BOOL:
127: p1 = "BOOLEAN";
128: if (yp->yp_varexp) {
129: } else
130: t = NULL;
131: break;
132:
133: case YP_INTLIST:
134:
135: case YP_INT:
136:
137: case YP_ENUMLIST:
138: if (yp->yp_varexp) {
139: p1 = "INTEGER";
140: break;
141: }
142: t = NULL;
143: p1 = NULL;
144: (void) fprintf(fptab, "\t{ SINTEGER, 0, %s, %s },\n",
145: c_tag(yp), c_class(yp));
146: break;
147:
148: case YP_REAL:
149: if (yp->yp_varexp) {
150: p1 = "REALTYPE";
151: break;
152: }
153: t = NULL;
154: p1 = NULL;
155: (void) fprintf(fptab, "\t{ SREALTYPE, 0, %s, %s },\n",
156: c_tag(yp), c_class(yp));
157: break;
158:
159: case YP_BIT:
160: case YP_BITLIST:
161: if (yp->yp_varexp) {
162: p1 = "BITSTRING";
163: break;
164: }
165: t = NULL;
166: p1 = NULL;
167: (void) fprintf(fptab, "\t{ SBITSTRING, 0, %s, %s },\n",
168: c_tag(yp), c_class(yp));
169: break;
170:
171: case YP_OCT:
172: if (yp->yp_varexp) {
173: p1 = "OCTETSTRING";
174: break;
175: }
176: t = NULL;
177: p1 = NULL;
178: (void) fprintf(fptab, "\t{ SOCTETSTRING, 0, %s, %s },\n",
179: c_tag(yp), c_class(yp));
180: break;
181:
182: case YP_OID:
183: if (yp->yp_varexp) {
184: p1 = "OBJID";
185: break;
186: }
187: t = NULL;
188: p1 = NULL;
189: (void) fprintf(fptab, "\t{ SOBJID, 0, %s, %s },\n",
190: c_tag(yp), c_class(yp));
191: break;
192:
193:
194: case YP_SEQ:
195: case YP_SET:
196: case YP_ANY:
197: if (yp->yp_varexp) {
198: p1 = "ANY";
199: break;
200: }
201: t = NULL;
202: p1 = NULL;
203: (void) fprintf(fptab, "\t{ SANY, 0, %s, %s },\n",
204: c_tag(yp), c_class(yp));
205: break;
206:
207: case YP_NULL:
208: p1 = "T_NULL";
209: t = NULL;
210: break;
211:
212: case YP_IDEFINED:
213: p1 = NULL;
214: {
215: /* Predefined Universal Type */
216: struct univ_typ *p, *univtyp();
217:
218: if ((p = univtyp(yp->yp_identifier))) {
219: if (p->univ_flags & UNF_EXTMOD) {
220: yp->yp_module = p->univ_mod;
221: goto do_obj;
222: }
223: if (f == NULL) {/* No offset type */
224: if (yp->yp_flags & YP_TAG
225: && yp->yp_flags & YP_IMPLICIT)
226: (void) fprintf(fptab, "\t{ S%s, 0, %d, %s },\n",
227: p->univ_tab,
228: yp->yp_tag->yt_value->yv_number,
229: c_flags(yp, yp->yp_tag->yt_class));
230: else
231: (void) fprintf(fptab, "\t{ S%s, 0, %d, %s },\n",
232: p->univ_tab, p->univ_id,
233: c_flags(yp, p->univ_class));
234: break;
235: }
236: if (yp->yp_flags & YP_TAG && yp->yp_flags & YP_IMPLICIT)
237: (void) fprintf(fptab, "\t{ %s, OFFSET(%s, %s), %d, %s },\n",
238: p->univ_tab, t, f,
239: yp->yp_tag->yt_value->yv_number,
240: c_flags(yp, yp->yp_tag->yt_class));
241: else
242: (void) fprintf(fptab, "\t{ %s, OFFSET(%s, %s), %d, %s },\n",
243: p->univ_tab, t, f, p->univ_id,
244: c_flags(yp, p->univ_class));
245: break;
246: }
247: }
248: do_obj:
249: if (yp->yp_flags & YP_TAG && yp->yp_flags & YP_IMPLICIT)
250: (void) fprintf(fptab, "\t{ IMP_OBJ, 0, %s, %s },\n", c_tag(yp), c_class(yp));
251: if (yp->yp_parm) {
252: ferr(1, "tenc_typ:YP_IDEFINED:yp_parm found\n");
253: }
254: if (yp->yp_module == NULL
255: || strcmp(yp->yp_module, mymodule) == 0) {
256: if (f == NULL) { /* No offset type */
257: (void) fprintf(fptab, "\t{ SOBJECT, 0, _Z%s, %s },\n",
258: proc_name(yp->yp_identifier, 0), c_class(yp));
259: } else
260: (void) fprintf(fptab,
261: "\t{ OBJECT, OFFSET(%s, %s), _Z%s, %s },\n",
262: t, f, proc_name(yp->yp_identifier, 0), c_class(yp));
263: } else {
264: if (f == NULL) { /* No offset type */
265: (void) fprintf(fptab, "\t{ SEXTOBJ, 0, _Z%s, %s },\n",
266: strp2name(yp->yp_identifier, yp->yp_module),
267: c_class(yp));
268: } else
269: (void) fprintf(fptab,
270: "\t{ EXTOBJ, OFFSET(%s, %s), _Z%s, %s },\n",
271: t, f, strp2name(yp->yp_identifier, yp->yp_module),
272: c_class(yp));
273:
274: (void) fprintf(fptab, "\t{ EXTMOD, %d, 0, 0 },\n",
275: gen_modref(yp->yp_module));
276: }
277: break;
278:
279: case YP_SEQLIST:
280: p1 = NULL;
281: /* support for -h flag */
282: #if 0
283: if (hflag && (y = yp->yp_type) && !y->yp_next) {
284: tenc_typ(y, id, yp->yp_structname);
285: break;
286: }
287: #endif
288: cons_type++;
289: save_ptr = en_ptr;
290: if (yp->yp_varexp == NULL && type != NULL)
291: ferr(1, "tenc_typ:YP_SEQLIST:NULL varexp pointer\n");
292: if (type != NULL)
293: (void) fprintf(fptab, "\t{ SEQ_START, OFFSET(%s, %s), %s, %s },\n",
294: t, f, c_tag(yp), c_class(yp));
295: else
296: (void) fprintf(fptab, "\t{ SEQ_START, 0, %s, %s },\n",
297: c_tag(yp), c_class(yp));
298: if (y = yp->yp_type) {
299: if (type) {
300: if (yp->yp_declexp == NULL)
301: ferr(1, "tenc_typ:YP_SEQLIST:no declexp\n");
302: yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
303: } else
304: yp->yp_structname = t;
305: if (optfield(y)) {
306: (void) fprintf(fptab,
307: "\t{ OPTL, OFFSET(%s, optionals), 0, 0 },\n",
308: yp->yp_structname);
309: }
310: tenc_loop(y, id, yp->yp_structname);
311: }
312: (void) fprintf(fptab, "\t{ PE_END, 0, 0, 0 },\n");
313: en_ptr = save_ptr;
314: cons_type--;
315: break;
316:
317: case YP_SETLIST:
318: p1 = NULL;
319: /* support for -h flag */
320: #if 0
321: if (hflag && (y = yp->yp_type) && !y->yp_next) {
322: tenc_typ(y, id, yp->yp_structname);
323: break;
324: }
325: #endif
326: cons_type++;
327: if (yp->yp_varexp == NULL && type != NULL)
328: ferr(1, "tenc_typ:YP_SETLIST:NULL varexp pointer\n");
329: if (type != NULL)
330: (void) fprintf(fptab, "\t{ SET_START, OFFSET(%s, %s), %s, %s },\n",
331: t, f, c_tag(yp), c_class(yp));
332: else
333: (void) fprintf(fptab, "\t{ SET_START, 0, %s, %s },\n",
334: c_tag(yp), c_class(yp));
335: if (y = yp->yp_type) {
336: if (type) {
337: if (yp->yp_declexp == NULL)
338: ferr(1, "tenc_typ:YP_SETLIST:no declexp\n");
339: yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
340: } else
341: yp->yp_structname = t;
342: if (optfield(y)) {
343: (void) fprintf(fptab,
344: "\t{ OPTL, OFFSET(%s, optionals), 0, 0 },\n",
345: yp->yp_structname);
346: }
347: tenc_loop(y, id, yp->yp_structname);
348: }
349: (void) fprintf(fptab, "\t{ PE_END, 0, 0, 0 },\n");
350: en_ptr = save_ptr;
351: cons_type--;
352: break;
353:
354: case YP_SEQTYPE:
355: p1 = NULL;
356: cons_type++;
357: save_ptr = en_ptr;
358: if (type != NULL)
359: (void) fprintf(fptab, "\t{ SEQOF_START, OFFSET(%s, %s), %s, %s },\n",
360: t, f, c_tag(yp), c_class(yp));
361: else
362: (void) fprintf(fptab, "\t{ SEQOF_START, 0, %s, %s },\n",
363: c_tag(yp), c_class(yp));
364: if (y = yp->yp_type) {
365: if (type) {
366: if (yp->yp_declexp == NULL)
367: ferr(1, "tenc_typ:YP_SEQTYPE:no declexp\n");
368: yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
369: } else
370: yp->yp_structname = t;
371: tenc_loop(y, id, yp->yp_structname);
372: }
373: if (yp->yp_structname != NULL)
374: (void) fprintf(fptab, "\t{ PE_END, OFFSET(%s, next), 0, 0 },\n",
375: yp->yp_structname);
376: else
377: (void) fprintf(fptab, "\t{ PE_END, 0, 0, 0 },\n");
378: en_ptr = save_ptr;
379: cons_type--;
380: break;
381:
382: case YP_SETTYPE:
383: p1 = NULL;
384: cons_type++;
385: save_ptr = en_ptr;
386: if (type != NULL)
387: (void) fprintf(fptab, "\t{ SETOF_START, OFFSET(%s, %s), %s, %s },\n",
388: t, f, c_tag(yp), c_class(yp));
389: else
390: (void) fprintf(fptab, "\t{ SETOF_START, 0, %s, %s },\n",
391: c_tag(yp), c_class(yp));
392:
393: if (y = yp->yp_type) {
394: if (type) {
395: if (yp->yp_declexp == NULL)
396: ferr(1, "tenc_typ:YP_SETTYPE:no declexp\n");
397: yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
398: } else
399: yp->yp_structname = t;
400: tenc_loop(y, id, yp->yp_structname);
401: }
402: if (yp->yp_structname != NULL)
403: (void) fprintf(fptab, "\t{ PE_END, OFFSET(%s, next), 0, 0 },\n",
404: yp->yp_structname);
405: else
406: (void) fprintf(fptab, "\t{ PE_END, 0, 0, 0 },\n");
407: en_ptr = save_ptr;
408: cons_type--;
409: break;
410:
411: case YP_CHOICE:
412: p1 = NULL;
413: /* support for -h flag */
414: if (hflag && (y = yp->yp_type) && !y->yp_next) {
415: tenc_typ(y, id, yp->yp_structname);
416: break;
417: }
418: cons_type++;
419: save_ptr = en_ptr;
420: if (type != NULL)
421: (void) fprintf(fptab, "\t{ CHOICE_START, OFFSET(%s, %s), 0, %s },\n",
422: t, f, c_class(yp));
423: else
424: (void) fprintf(fptab, "\t{ CHOICE_START, 0, 0, 0 },\n");
425: if (y = yp->yp_type) {
426: if (type) {
427: if (yp->yp_declexp == NULL)
428: ferr(1, "tenc_typ:YP_CHOICE:no declexp\n");
429: yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
430: } else
431: yp->yp_structname = t;
432: (void) fprintf(fptab, "\t{ SCTRL, OFFSET(%s, offset), 0, 0 },\n",
433: yp->yp_structname);
434: tenc_loop(y, id, yp->yp_structname);
435: }
436: (void) fprintf(fptab, "\t{ PE_END, 0, 0, 0 },\n");
437: en_ptr = save_ptr;
438: cons_type--;
439: break;
440:
441: default:
442: ferrd(1, "tenc_typ: yp_code = %d not implemented\n", yp->yp_code);
443: }
444:
445: if (p1 != NULL)
446: if (t != NULL)
447: (void) fprintf(fptab, "\t{ %s, OFFSET(%s, %s), %s, %s },\n",
448: p1, t, f, c_tag(yp), c_class(yp));
449: else
450: (void) fprintf(fptab, "\t{ %s, 0, %s, %s },\n",
451: p1, c_tag(yp), c_class(yp));
452: }
453:
454: static int fflags[] = {
455: 0, 1, 2, 2, 3, 3, 4, 5, 16, 16, 16, 17, 17, 17,
456: 0, -1, 6, 0, 10, 9};
457:
458: /*
459: * calculate the tag string of the given type and return it
460: */
461: char *
462: c_tag(yp)
463: YP yp;
464: {
465: static char buf[WORDSIZE];
466: int i;
467:
468: if (yp->yp_flags & YP_TAG && yp->yp_flags & YP_IMPLICIT) {
469: i = yp->yp_tag->yt_value->yv_number;
470: } else {
471: if (yp->yp_code < 0 || yp->yp_code > YP_REAL
472: || yp->yp_code == YP_CHOICE)
473: i = 0;
474: else
475: i = fflags[yp->yp_code];
476: /* Choice now legal argument - to allow prte_* routines to work */
477: if (i == 0 && yp->yp_code != YP_CHOICE)
478: ferrd (1, "c_tag:Unknown Tag %d", yp->yp_code);
479: }
480:
481: (void) sprintf(buf, "%d", i);
482:
483: return (buf);
484: }
485:
486: /*
487: * calculate the tag string of the explicit tag and return it
488: */
489: char *
490: ec_tag(yp)
491: YP yp;
492: {
493: static char buf[WORDSIZE];
494: int i;
495:
496: if (!(yp->yp_flags & YP_TAG) || yp->yp_flags & YP_IMPLICIT)
497: ferr(1, "ec_tag:internal error:called with out explicit tag\n");
498:
499: i = yp->yp_tag->yt_value->yv_number;
500:
501: (void) sprintf(buf, "%d", i);
502:
503: return (buf);
504: }
505:
506: /*
507: * produce a string that represents the class/flags field for a given
508: * yp entry taking the class to be that given in cl
509: */
510: char *
511: c_flags(yp, cl)
512: YP yp;
513: int cl;
514: {
515: char *p1;
516: static char buf[STRSIZE];
517:
518: switch (yp->yp_code) {
519: case YP_IDEFINED:
520: case YP_CHOICE:
521: if (yp->yp_flags & YP_TAG)
522: break;
523: if (yp->yp_flags & YP_OPTIONAL) {
524: p1 = "FL_OPTIONAL";
525: } else if (yp->yp_flags & YP_DEFAULT) {
526: p1 = "FL_DEFAULT";
527: } else
528: p1 = "0";
529: return (p1);
530:
531: default:
532: break;
533: }
534: switch (cl) {
535: case PE_CLASS_UNIV:
536: p1 = "FL_UNIVERSAL";
537: break;
538:
539: case PE_CLASS_APPL:
540: p1 = "FL_APPLICATION";
541: break;
542:
543: case PE_CLASS_PRIV:
544: p1 = "FL_PRIVATE";
545: break;
546:
547: case PE_CLASS_CONT:
548: p1 = "FL_CONTEXT";
549: break;
550:
551: default:
552: ferrd(1, "c_flags: illegal class found %d\n", cl);
553:
554: }
555: if (yp->yp_flags & YP_OPTIONAL) {
556: strncpy(buf, p1, STRSIZE);
557: p1 = strncat(buf, "|FL_OPTIONAL", STRSIZE);
558: } else if (yp->yp_flags & YP_DEFAULT) {
559: strncpy(buf, p1, STRSIZE);
560: p1 = strncat(buf, "|FL_DEFAULT", STRSIZE);
561: }
562: return (p1);
563: }
564: /*
565: * calculate a string specifying the class for the given type and
566: * return it
567: */
568: char *
569: c_class(yp)
570: YP yp;
571: {
572: int i;
573:
574: if (yp->yp_flags & YP_TAG && yp->yp_flags & YP_IMPLICIT) {
575: i = yp->yp_tag->yt_class;
576: } else {
577: i = PE_CLASS_UNIV;
578: }
579: return (c_flags(yp, i));
580:
581: }
582: /*
583: * calculate a string specifying the class for the explicit tag and
584: * return it
585: */
586: char *
587: ec_class(yp)
588: YP yp;
589: {
590: int i;
591: char *p1;
592: static char buf[STRSIZE];
593:
594: if (!(yp->yp_flags & YP_TAG) || yp->yp_flags & YP_IMPLICIT)
595: ferr(1, "ec_class:internal error:called with out explicit tag\n");
596: switch (yp->yp_code) {
597: case YP_IDEFINED:
598: case YP_CHOICE:
599: if (yp->yp_flags & YP_TAG)
600: break;
601: if (yp->yp_flags & YP_OPTIONAL) {
602: p1 = "FL_OPTIONAL";
603: } else if (yp->yp_flags & YP_DEFAULT) {
604: p1 = "FL_DEFAULT";
605: } else
606: p1 = "0";
607: return (p1);
608:
609: default:
610: break;
611: }
612:
613: i = yp->yp_tag->yt_class;
614:
615: switch (i) {
616: case PE_CLASS_UNIV:
617: p1 = "FL_UNIVERSAL";
618: break;
619:
620: case PE_CLASS_APPL:
621: p1 = "FL_APPLICATION";
622: break;
623:
624: case PE_CLASS_PRIV:
625: p1 = "FL_PRIVATE";
626: break;
627:
628: case PE_CLASS_CONT:
629: p1 = "FL_CONTEXT";
630: break;
631:
632: default:
633: ferrd(1, "c_class: illegal class found %d\n", i);
634:
635: }
636: if (yp->yp_flags & YP_OPTIONAL) {
637: strncpy(buf, p1, STRSIZE);
638: p1 = strncat(buf, "|FL_OPTIONAL", STRSIZE);
639: } else if (yp->yp_flags & YP_DEFAULT) {
640: strncpy(buf, p1, STRSIZE);
641: p1 = strncat(buf, "|FL_DEFAULT", STRSIZE);
642: }
643: return (p1);
644: }
645:
646: /*
647: * generate tables for encoding a contructed type
648: */
649: tenc_loop(yp, id, type)
650: YP yp;
651: char *id;
652: char *type;
653: {
654: for (; yp != NULL; yp = yp->yp_next) {
655: tenc_typ(yp, id, type);
656: }
657: }
658:
659: /*
660: * Print the string and exit if argument greater than zero
661: */
662: ferr(i, s)
663: int i;
664: char *s;
665: {
666: (void) fprintf(stderr, "%s", s);
667: if (i > 0)
668: exit(i);
669: }
670:
671: /*
672: * Print the integer and exit if argument greater than zero
673: */
674: ferrd(i, s, d)
675: int i;
676: char *s;
677: int d;
678: {
679: (void) fprintf(stderr, s, d);
680: if (i > 0)
681: exit(i);
682: }
683:
684: /*
685: * Print the string and exit if argument greater than zero
686: */
687: ferrs(i, s, d)
688: int i;
689: char *s;
690: char *d;
691: {
692: (void) fprintf(stderr, s, d);
693: if (i > 0)
694: exit(i);
695: }
696:
697: /*
698: * return a copy of the string s minus its last character
699: */
700: char *
701: strip_last(s)
702: char *s;
703: {
704: char *t, *r;
705:
706: if (s) {
707: t = new_string(s);
708: for (r = t; *r != '\0'; r++);
709: ;
710: *--r = '\0';
711: return t;
712: } else
713: return NULL;
714: }
715:
716: /*
717: * add the declaration specified by the strings type and id to the
718: * start of the declaration list
719: */
720: add_list(type, id)
721: char *type, *id;
722: {
723:
724: s_table *prev;
725:
726: if ((prev = (s_table *) malloc(sizeof(s_table))) == NULL)
727: ferr(1, "add_list: Out of memory\n");
728: prev->type = type;
729: prev->name = id;
730: prev->parent = NULL;
731: prev->defined = 0;
732: prev->next = head;
733: head = prev;
734: }
735:
736: #if 0
737: /*
738: * return the element in the declaration list whose name field is id
739: */
740: s_table *
741: lookup_list(id)
742: char *id;
743: {
744: s_table *prev;
745:
746: for (prev = head; prev != NULL; prev = prev->next)
747: if (!strcmp(prev->name, id))
748: return prev;
749: return (NULL);
750: /* ferrs(1, "lookup_list: the id %s is not present\n",id); */
751: }
752: #endif
753:
754: /*
755: * print the declaration list
756: */
757: print_list()
758: {
759: s_table *prev;
760:
761: for (prev = head; prev != NULL; prev = prev->next) {
762: (void) printf("type is %s\n", prev->type);
763: (void) printf("name is %s\n", prev->name);
764: (void) printf("\n");
765: }
766: }
767:
768: /*
769: * parse the declaration in the string s returning the type in v1 and
770: * the name in v2
771: */
772: parse_decl(s, v1, v2)
773: char **s, **v1, **v2;
774: {
775: char *t;
776:
777: for (t = *s; *t != '\0' && !(isalnum(*t) || *t == '_'); t++);
778:
779: *s = t;
780: if (*t != '\0') {
781: for (; *t != '*'; t++);
782: *t = '\0';
783: *v1 = my_strcat(*s, "*");
784: Printf(3, ("the type is %s\n", *v1));
785: if (*++t == '*')
786: t++;
787: for (*s = t; isalnum(*t) || *t == '_'; t++);
788: if (*t != '\0') {
789: *t = '\0';
790: t++;
791: }
792: *v2 = new_string(*s); /* don't really need new_string */
793: Printf(2, ("the name is %s\n", *v2));
794: *s = t;
795: }
796: }
797:
798: /*
799: * return the next identifier in the string s
800: */
801: char *
802: get_val(s)
803: char **s;
804: {
805: char *t, *r;
806:
807: for (t = *s; *t != '\0' && !(isalnum(*t) || *t == '_' || *t == '.'); t++);
808:
809: if (*t != '\0') {
810: for (*s = t; isalnum(*t) || *t == '_' || *t == '.'; t++);
811: *t = '\0';
812: r = *s;
813: Printf(3, ("arg is |%s|\n", r));
814: *s = ++t;
815: return r;
816: } else
817: return NULL;
818: }
819:
820: #if 0
821: /*
822: * add the definition contained in s to the start of the declaration
823: * list
824: */
825: s_table *
826: proc_def(s)
827: char *s;
828: {
829: char *s1, *s2, *s3;
830: s_table *ptr1, *ptr2;
831:
832: s1 = get_val(&s);
833: ptr1 = lookup_list(s1);
834: if (!ptr1->defined) {
835: s2 = get_val(&s);
836: ptr2 = lookup_list(s2);
837: ptr1->parent = ptr2;
838: s3 = get_val(&s);
839: ptr1->field = s3;
840: ptr1->defined++;
841: }
842: return ptr1;
843: }
844: #endif
845:
846: /*
847: * return the next component (sequence of characters up to the next
848: * ';' or '\0') of the string s
849: */
850: char *
851: get_comp(s)
852: char **s;
853: {
854: char *t, *r;
855:
856: for (t = *s; *t != '\0' && !(isalnum(*t) || *t == '_' || *t == ';'); t++);
857:
858: if (*t != '\0') {
859: for (*s = t; *t != '\0' && *t != ';'; t++);
860: *t = '\0';
861: r = *s;
862: Printf(3, ("component is |%s|\n", r));
863: *s = ++t;
864: return r;
865: } else
866: return NULL;
867: }
868:
869: #if 0
870: /*
871: * work out what the offset for the type yp should be and return a
872: * pointer to the element in the declaration list which can be used
873: * to calculate the offset
874: */
875: s_table *
876: get_offset(yp, level)
877: YP yp;
878: int level;
879: {
880: char *s, *s1;
881: s_table *ptr1;
882:
883: switch (yp->yp_code) {
884:
885: case YP_UNDF:
886: ferr(1, "get_offset: Undefined type\n");
887: break;
888:
889: case YP_BOOL:
890: case YP_INT:
891: case YP_INTLIST:
892: case YP_NULL:
893: if (yp->yp_varexp) {
894: s = new_string(yp->yp_intexp);
895: s1 = get_val(&s);
896: ptr1 = lookup_list(s1);
897: return ptr1;
898: } else {
899: ferr(0, "get_offset: No intexp\n");
900: return NULL;
901: }
902: break;
903:
904: case YP_BIT:
905: case YP_BITLIST:
906: if (yp->yp_direction & YP_DECODER)
907: if (yp->yp_action2) {
908: s = new_string(yp->yp_action2);
909: s1 = get_val(&s);
910: if (strcmp(s1, "if"))
911: ferrs(1, "get_offset: What to do, action2 = %s\n", yp->yp_action2);
912: else {
913: s1 = get_val(&s);
914: ptr1 = lookup_list(s1);
915: return ptr1;
916: }
917: } else
918: return NULL;
919: else if (yp->yp_varexp) {
920: s = new_string(yp->yp_varexp);
921: s1 = get_val(&s);
922: s1 = get_val(&s);
923: ptr1 = lookup_list(s1);
924: return ptr1;
925: } else {
926: ferr(0, "get_offset: No strexp (BIT)\n");
927: return NULL;
928: }
929: break;
930: case YP_OCT:
931: case YP_OID:
932: case YP_SEQ:
933: case YP_SET:
934: case YP_ANY:
935: if (yp->yp_varexp) {
936: s = new_string(yp->yp_varexp);
937: s1 = get_val(&s);
938: ptr1 = lookup_list(s1);
939: return ptr1;
940: } else {
941: ferr(0, "get_offset: No strexp\n");
942: return NULL;
943: }
944: break;
945:
946: case YP_IDEFINED:
947: if (yp->yp_parm) {
948: s = new_string(yp->yp_parm);
949: s1 = get_val(&s);
950: ptr1 = lookup_list(s1);
951: return ptr1;
952: } else {
953: ferr(0, "get_offset: No parm\n");
954: return NULL;
955: }
956: break;
957:
958: case YP_SEQLIST:
959: case YP_SETLIST:
960: case YP_CHOICE:
961: if (yp->yp_action1) {
962: s = get_string(yp->yp_action1, yp->yp_direction);
963: while ((s1 = get_comp(&s)) != NULL)
964: (void) proc_def(s1);
965: }
966: if (yp->yp_type == NULL) {
967: if (level > 0)
968: ferr(0, "get_offset: There exists an embeded empty SEQUENCE/SET/CHOICE\n");
969: return (yp->yp_direction & YP_ENCODER ? en_ptr : ptr);
970: }
971: if ((ptr1 = get_offset(yp->yp_type, level + 1)) != NULL)
972: if (ptr1->parent != NULL && level > 0)
973: return ptr1->parent;
974: else
975: return ptr1;
976: else {
977: ferr(0, "get_offset: returning NULL (SEQLIST/SETLIST/CHOICE)\n");
978: return NULL;
979: }
980: break;
981:
982: case YP_SEQTYPE:
983: case YP_SETTYPE:
984: if (yp->yp_action3) {
985: s = get_string(yp->yp_action3, yp->yp_direction);
986: while ((s1 = get_comp(&s)) != NULL)
987: (void) proc_def(s1);
988: }
989: if ((ptr1 = get_offset(yp->yp_type, level + 1)) != NULL)
990: if (ptr1->parent != NULL && level > 0)
991: return ptr1->parent;
992: else
993: return ptr1;
994: else {
995: ferr(0, "get_offset: returning NULL (SEQTYPE/SETTYPE)\n");
996: return NULL;
997: }
998: break;
999:
1000: default:
1001: ferrd(1, "get_offset: yp_code = %d not implemented\n", yp->yp_code);
1002: return NULL;
1003: break;
1004: }
1005: }
1006: #endif
1007:
1008: /*
1009: * return a copy of that part of the string s which may contain
1010: * definitions for the variables generated by posy
1011: */
1012: char *
1013: get_string(s, direction)
1014: char *s;
1015: int direction;
1016: {
1017: char *t, *t1;
1018:
1019: if (direction & YP_ENCODER)
1020: return new_string(s);
1021: if (direction & YP_DECODER) {
1022: t = new_string(s);
1023: for (t1 = t; !(isalnum(*t1) || *t1 == '_'); t1++);
1024: if (*t1 == 'i' && *++t1 == 'f' && *++t1 == ' ') { /* MALLOC code */
1025: for (; *t1 != '}'; t1++) /* skip MALLOC code */
1026: ;
1027: t1++;
1028: Printf(4, ("returning the string %s\n", t1));
1029: return t1;
1030: } else
1031: return t;
1032: }
1033: }
1034:
1035: #if 0
1036: c_type(yp)
1037: YP yp;
1038: {
1039: switch (yp->yp_code) {
1040:
1041: case YP_IDEFINED:
1042: return T_OBJ;
1043: break;
1044:
1045:
1046: default:
1047: return T_PRIM;
1048: break;
1049: }
1050: }
1051:
1052: #endif
1053: /*
1054: * Determine wether this list contains any items that will generate
1055: * an optional field. If so return non zero
1056: */
1057: optfield(yp)
1058: YP yp;
1059: {
1060: for (; yp; yp = yp->yp_next) {
1061: if (yp->yp_flags & YP_OPTIONAL)
1062: switch (yp->yp_code) {
1063: case YP_BOOL:
1064: case YP_INT:
1065: case YP_INTLIST:
1066: case YP_ENUMLIST:
1067: case YP_NULL:
1068: return (1);
1069: }
1070: }
1071: return (0);
1072: }
1073:
1074: gen_dflts(yp, type)
1075: YP yp;
1076: char *type;
1077: {
1078: YP y;
1079:
1080: if (yp == NULL)
1081: return;
1082: switch (yp->yp_code) {
1083: case YP_IDEFINED:
1084: #if 0
1085: if (yp->yp_module == NULL
1086: || strcmp(yp->yp_module, mymodule) == 0)
1087: break;
1088: if (lookup_list(yp->yp_module))
1089: break; /* already done */
1090: /* Got an external reference */
1091: (void) fprintf(fptab, "#include \"%s%s\"\n", yp->yp_module, HFILE2);
1092: add_list("module", yp->yp_module);
1093: #endif
1094: break;
1095:
1096: case YP_CHOICE:
1097: case YP_SEQTYPE:
1098: case YP_SETTYPE:
1099: case YP_SEQLIST:
1100: case YP_SETLIST:
1101: for (y = yp->yp_type; y != NULL; y = y->yp_next) {
1102: gen_dflts(y, type);
1103: }
1104: break;
1105:
1106: default:
1107: break;
1108: }
1109: /* Output definitions for default entries */
1110: if (yp->yp_flags & YP_DEFAULT)
1111: defdflt(yp, type);
1112: }
1113: /*
1114: * Compute the concatenation into a temporary buffer of two strings
1115: * after having run notid on them first
1116: */
1117: char *
1118: strp2name(s1, s2)
1119: char *s1, *s2;
1120: {
1121: char *p;
1122: static char buf[STRSIZE * 2 + 5];
1123:
1124: if (strlen(s1) > STRSIZE || strlen(s2) > STRSIZE)
1125: ferr(1, "strp2name:string to big\n");
1126: strcpy(buf, p = notidtoid(s1));
1127: free(p);
1128: strcat(buf, p = notidtoid(s2));
1129: free(p);
1130:
1131: return (buf);
1132: }
1133:
1134: /*
1135: * Output the definitions for default entries and initialise the yp's
1136: * to have pointers which reference these definitions for use by
1137: * gdflt routine.
1138: */
1139: defdflt(yp, name)
1140: YP yp;
1141: char *name;
1142: {
1143: YV yv;
1144: YV yv1;
1145: SY sy;
1146: YP yp1;
1147: int size, i;
1148: char *str;
1149: char *label;
1150: struct univ_typ *p;
1151: int code;
1152:
1153: if ((yp->yp_flags & YP_DEFAULT) == 0)
1154: ferrd(1, "defdflt:called with out a default code = %d\n", yp->yp_code);
1155: yv = yp->yp_default;
1156:
1157: yp1 = yp;
1158:
1159: /* Find the bottom definition */
1160: code = yp1->yp_code;
1161: while (code == YP_IDEFINED) {
1162: if ((sy = syfind(yp1->yp_identifier)) == NULL) {
1163: if ((p = univtyp(yp1->yp_identifier)) == NULL
1164: || p->univ_type <= YP_UNDF)
1165: ferrs(1,
1166: "defdflt:IDEFINED:cannot find definition of symbol %s\n",
1167: yp1->yp_identifier);
1168: code = p->univ_type;
1169: break;
1170:
1171: }
1172: yp1 = sy->sy_type;
1173: code = yp1->yp_code;
1174: }
1175:
1176: switch (code) {
1177: case YP_BOOL:
1178: case YP_INT:
1179: case YP_INTLIST:
1180: case YP_ENUMLIST:
1181: switch (yv->yv_code) {
1182: case YV_NUMBER:
1183: case YV_BOOL:
1184: /* None needed */
1185: break;
1186:
1187: case YV_IDEFINED:
1188: if ((yv1 = calc_yv(yp1, yv->yv_identifier)) == NULL) {
1189: ferrs(1, "defdflt:BOOL/INT:cannot find definition of %s\n",
1190: yv->yv_identifier);
1191: }
1192: /* None Needed */
1193: break;
1194:
1195: default:
1196: ferrd(1, "defdflt:INT/BOOL:unimplemented value code = %d\n",
1197: yv->yv_code);
1198: }
1199: break;
1200:
1201: case YP_REAL:
1202: switch (yv->yv_code) {
1203: case YV_REAL:
1204: yv1 = yv;
1205: goto dumpdef3;
1206:
1207: case YV_IDEFINED:
1208: if ((yv1 = calc_yv(yp1, yv->yv_identifier)) == NULL) {
1209: ferrs(1, "defdflt:REAL:cannot find definition of %s\n",
1210: yv->yv_identifier);
1211: }
1212: goto dumpdef3;
1213: break;
1214:
1215: default:
1216: ferrd(1, "defdflt:REAL:unimplemented value code = %d\n",
1217: yv->yv_code);
1218: }
1219: break;
1220:
1221: case YP_BIT:
1222: case YP_BITLIST:
1223: switch (yv->yv_code) {
1224: /*
1225: * This is an illegal value for a bit string ! - BUT ACSE
1226: * uses it !
1227: */
1228: /* gdflt also patched to support it */
1229: case YV_IDEFINED:
1230: ferrs(0,
1231: "warning:bitstring default specified illegally with identifier %s\n",
1232: yv->yv_identifier);
1233: if ((yv1 = calc_yv(yp1, yv->yv_identifier)) == NULL) {
1234: ferrs(1, "defdflt:BIT:cannot find definition of %s\n",
1235: yv->yv_identifier);
1236: }
1237: /* doesn't work fix posy-yacc.y */
1238: size = numtobstr(yv1, &str);
1239: goto dumpdef1;
1240:
1241: case YV_NUMBER:
1242: /* doesn't work fix posy-yacc.y */
1243: size = numtobstr(yv, &str);
1244: goto dumpdef1;
1245:
1246: case YV_VALIST:
1247: if ((size = valisttobs(yp1, yv, &str)) < 0) {
1248: ferrs(1, "defdflt:bad default value for bistring %s\n",
1249: yp->yp_flags & YP_ID ? yp->yp_identifier : "");
1250: }
1251: goto dumpdef1;
1252:
1253: default:
1254: /* Could be a syntax error */
1255: ferrd(1, "defdflt:BIT:illegal value code = %d\n", yv->yv_code);
1256: }
1257: break;
1258:
1259: case YP_IDEFINED:
1260: ferrs(1, "defdflt:IDEFINED:internal error on symbol %s\n",
1261: yp1->yp_identifier);
1262: break;
1263:
1264: case YP_OCT:
1265: switch (yv->yv_code) {
1266: case YV_NUMBER:
1267: /* doesn't work fix posy-yacc.y */
1268: size = numtobstr(yv, &str);
1269: goto dumpdef2;
1270:
1271: case YV_STRING:
1272: str = yv->yv_string;
1273: size = strlen(str);
1274: goto dumpdef2;
1275:
1276: default:
1277: /* Could be a syntax error */
1278: ferrd(1, "defdflt:OCT:illegal value code = %d\n", yv->yv_code);
1279: }
1280: break;
1281:
1282: case YP_NULL:
1283: case YP_SEQ:
1284: case YP_SEQTYPE:
1285: case YP_SEQLIST:
1286: case YP_SET:
1287: case YP_SETTYPE:
1288: case YP_SETLIST:
1289: case YP_CHOICE:
1290: case YP_ANY:
1291: case YP_OID:
1292: /* None yet */
1293: break;
1294:
1295: default:
1296: ferrd(1, "defdflt:unknown type %d\n", code);
1297: }
1298:
1299: return;
1300:
1301: dumpdef1: /* Bitstrings */
1302: label = genlabel(name, yp);
1303: yp->yp_action0 = label;
1304: yp->yp_act0_lineno = size;
1305: i = (size + NBPC - 1) / NBPC;
1306: (void) fprintf(fptab, "\nstatic char %s[] = ", label);
1307: if (printable(str, i))
1308: prstr(fptab, str, i);
1309: else
1310: prhstr(fptab, str, i);
1311: (void) fprintf(fptab, ";\n");
1312: return;
1313:
1314: dumpdef2: /* Octet strings (and aliases) */
1315: label = genlabel(name, yp);
1316: yp->yp_action0 = label;
1317: yp->yp_act0_lineno = size;
1318: (void) fprintf(fptab, "\nstatic char %s[] = ", label);
1319: if (printable(str, size))
1320: prstr(fptab, str, size);
1321: else
1322: prhstr(fptab, str, size);
1323: (void) fprintf(fptab, ";\n");
1324: return;
1325:
1326: dumpdef3: /* Reals */
1327: label = genlabel(name, yp);
1328: yp->yp_action0 = label;
1329: (void) fprintf(fptab, "\nstatic double %s = %f;\n", label, yv1->yv_real);
1330: return;
1331:
1332: }
1333: /*
1334: * generate the default entry for encoding/decoding fields. This
1335: * should contain the default value which the encoder will know means
1336: * default encoding
1337: */
1338: gdflt(yp, which)
1339: YP yp;
1340: int which; /* Which type of entries to generate
1341: * G_ENC encode G_DEC decode */
1342: {
1343: YV yv;
1344: YV yv1;
1345: SY sy;
1346: YP yp1;
1347: int size;
1348: char *str;
1349:
1350: char *ndflt;
1351: struct univ_typ *p;
1352: int code;
1353:
1354:
1355: if (which == G_ENC)
1356: ndflt = "DFLT_F";
1357: else
1358: ndflt = "DFLT_B";
1359:
1360: if ((yp->yp_flags & YP_DEFAULT) == 0)
1361: ferrd(1, "gdflt:called with out a default code = %d\n", yp->yp_code);
1362: yv = yp->yp_default;
1363:
1364: yp1 = yp;
1365:
1366: /* Find the bottom definition */
1367: code = yp1->yp_code;
1368: while (code == YP_IDEFINED) {
1369: if ((sy = syfind(yp1->yp_identifier)) == NULL) {
1370: if ((p = univtyp(yp1->yp_identifier)) == NULL
1371: || p->univ_type <= YP_UNDF)
1372: ferrs(1,
1373: "gdflt:IDEFINED:cannot find definition of symbol %s\n",
1374: yp1->yp_identifier);
1375: code = p->univ_type;
1376: break;
1377:
1378: }
1379: yp1 = sy->sy_type;
1380: code = yp1->yp_code;
1381: }
1382:
1383: switch (code) {
1384: case YP_BOOL:
1385: case YP_INT:
1386: case YP_INTLIST:
1387: case YP_ENUMLIST:
1388: switch (yv->yv_code) {
1389: case YV_NUMBER:
1390: case YV_BOOL:
1391: (void) fprintf(fptab, "\t{ %s, %d, 0, 0 },\n", ndflt,
1392: yp->yp_default->yv_number);
1393: break;
1394:
1395: case YV_IDEFINED:
1396: if ((yv1 = calc_yv(yp1, yv->yv_identifier)) == NULL) {
1397: ferrs(1, "gdflt:BOOL/INT:cannot find definition of %s\n",
1398: yv->yv_identifier);
1399: }
1400: (void) fprintf(fptab, "\t{ %s, %d, 0, 0 },\n", ndflt,
1401: yv1->yv_number);
1402: break;
1403:
1404: default:
1405: ferrd(1, "gdflt:INT/BOOL:unimplemented value code = %d\n",
1406: yv->yv_code);
1407: }
1408: break;
1409:
1410: case YP_BIT:
1411: case YP_BITLIST:
1412: switch (yv->yv_code) {
1413: #ifdef ILLEGAL_DEFAULTS
1414: case YV_IDEFINED: /* supporting illegal default
1415: * specification */
1416: #endif
1417: case YV_NUMBER:
1418: case YV_VALIST:
1419: (void) fprintf(fptab, "\t{ %s, %d, %d, 0 },\n", ndflt,
1420: yp->yp_act0_lineno, addptr(yp->yp_action0));
1421: break;
1422:
1423: default:
1424: /* Could be a syntax error */
1425: ferrd(1, "gdflt:BIT:illegal value code = %d\n", yv->yv_code);
1426: }
1427: break;
1428:
1429: case YP_IDEFINED:
1430: ferrs(1, "gdflt:IDEFINED:internal error on symbol %s\n",
1431: yp1->yp_identifier);
1432: break;
1433:
1434: case YP_REAL:
1435: switch (yv->yv_code) {
1436: #ifdef ILLEGAL_DEFAULTS
1437: case YV_IDEFINED: /* Illegal according to ASN.1 but we can do it
1438: * so why not support it
1439: */
1440: #endif
1441: case YV_REAL:
1442: (void) fprintf(fptab, "\t{ %s, 0, %d, 0 },\n", ndflt,
1443: addptr(concat("&", yp->yp_action0)));
1444: break;
1445:
1446: default:
1447: /* Could be a syntax error */
1448: ferrd(1, "gdflt:REAL:illegal value code = %d\n", yv->yv_code);
1449: }
1450: break;
1451:
1452: case YP_OCT:
1453: switch (yv->yv_code) {
1454: case YV_NUMBER:
1455: case YV_STRING:
1456: (void) fprintf(fptab, "\t{ %s, %d, %d, 0 },\n", ndflt,
1457: yp->yp_act0_lineno, addptr(yp->yp_action0));
1458: break;
1459:
1460: default:
1461: /* Could be a syntax error */
1462: ferrd(1, "gdflt:OCT:illegal value code = %d\n", yv->yv_code);
1463: }
1464: break;
1465:
1466: case YP_NULL:
1467: case YP_SEQ:
1468: case YP_SEQTYPE:
1469: case YP_SEQLIST:
1470: case YP_SET:
1471: case YP_SETTYPE:
1472: case YP_SETLIST:
1473: case YP_CHOICE:
1474: case YP_ANY:
1475: case YP_OID:
1476: (void) fprintf(fptab, "\t{ %s, 0, 0, 0 },\n", ndflt);
1477: break;
1478:
1479: default:
1480: ferrd(1, "gdflt:unknown type %d\n", yp->yp_code);
1481: }
1482:
1483: }
1484: /*
1485: * Calculate the value associated with the given identifier id by
1486: * looking at the value definitions associated with type definition
1487: * yp. Returns the value definition if found or NULL if not.
1488: */
1489: YV
1490: calc_yv(yp, id)
1491: YP yp;
1492: char *id;
1493: {
1494: YV yv;
1495:
1496: for (yv = yp->yp_value; yv != NULL; yv = yv->yv_next) {
1497: if (yv->yv_flags & YV_NAMED && strcmp(yv->yv_named, id) == 0)
1498: return (yv);
1499: }
1500:
1501: return (NULL);
1502: }
1503:
1504: /*
1505: * ******* This does not work. posy needs to be fixed for case of
1506: * '01'b ***** Turn a Literal number value in yv into a bistring
1507: * initialisation. Return the length of the bit string or less than
1508: * zero on error. Set the (char *) pointer, whose address is in
1509: * ppstr, to point to a string containing the a reference to a
1510: * character array which contains the bits.
1511: */
1512:
1513: numtobstr(yv, ppstr)
1514: YV yv;
1515: char **ppstr;
1516: {
1517:
1518: int ibits, lastb, i;
1519: char *buf;
1520:
1521: buf = malloc(NBPI / NBPC + 1);
1522: bzero(buf, NBPI / NBPC + 1);
1523: lastb = -1;
1524: ibits = yv->yv_number;
1525: for (i = 0; i < NBPI; i++) {
1526: if ((1 << i) & ibits) {
1527: buf[i / NBPC] |= 1 << (NBPC - 1 - (i % NBPC));
1528: lastb = i;
1529: }
1530: }
1531:
1532: *ppstr = buf;
1533: return (lastb + 1);
1534: }
1535: #define ROUNDUP 10
1536: /*
1537: * Take a list of Values (YV_VALIST) which should contain a list of
1538: * bits and convert them into a bitstring initialisation. As in
1539: * numtobstr return the size of the bit string or a negative number
1540: * if there is an error. Put a reference to a character array which
1541: * contains the definition of the bits in the character pointer whose
1542: * address is in ppstr. yp is the definition of the type which
1543: * contains the names of all the defined bits.
1544: */
1545: valisttobs(yp, yv, ppstr)
1546: YP yp;
1547: YV yv;
1548: char **ppstr;
1549: {
1550:
1551: YV yv1, yv2;
1552: int lastb, val, nsize, size;
1553: char *buf;
1554:
1555: lastb = -1;
1556: size = ROUNDUP;
1557: if ((buf = malloc(size)) == NULL) {
1558: ferrd(1, "valisttobs:malloc:failed on %d\n", size);
1559: }
1560: bzero(buf, size);
1561: for (yv1 = yv->yv_idlist; yv1 != NULL; yv1 = yv1->yv_next) {
1562: if ((yv2 = calc_yv(yp, yv1->yv_identifier)) == NULL) {
1563: return (-1);
1564: }
1565: val = yv2->yv_number;
1566: /* Bug here probably */
1567: if (size < val / NBPC) {
1568: nsize = val / NBPC + ROUNDUP;
1569: if ((buf = realloc(buf, nsize)) == NULL) {
1570: ferrd(1, "valisttobs:realloc:failed on %d\n", nsize);
1571: }
1572: bzero(buf + size, nsize - size);
1573: size = nsize;
1574: }
1575: buf[val / NBPC] |= 1 << (NBPC - 1 - (val % NBPC));
1576: if (val > lastb)
1577: lastb = val;
1578: }
1579: *ppstr = buf;
1580: return (lastb + 1);
1581: }
1582: /*
1583: * Print the string out in a format acceptable as a quoted string in
1584: * a C program including the quotes. Using \ escapes for unprintable
1585: * characters
1586: */
1587: prstr(fp, str, len)
1588: FILE *fp;
1589: char *str;
1590: int len;
1591: {
1592: (void) fputc('"', fp);
1593: while (len-- > 0) {
1594: if (isprint(*str & 0xff)) {
1595: (void) fputc(*str & 0xff, fptab);
1596: str++;
1597: continue;
1598: }
1599: (void) fprintf(fptab, "\\%0o", *str);
1600: }
1601: (void) fputc('"', fp);
1602: #define MAXPLINE 16
1603: }
1604: /*
1605: * output a initialisation for a character array as unsigned hex
1606: * numbers
1607: */
1608: prhstr(fptab, str, len)
1609: FILE *fptab;
1610: char *str;
1611: int len;
1612: {
1613: int npline; /* number on this line */
1614:
1615: (void) fprintf(fptab, "{\n");
1616: npline = 0;
1617: while (len > 0) {
1618: if (npline >= MAXPLINE) {
1619: (void) fputc('\n', fptab);
1620: npline = 0;
1621: }
1622: npline++;
1623: (void) fprintf(fptab, " 0x%02x,", *str++ & 0xff);
1624: len--;
1625: }
1626: (void) fprintf(fptab, "}");
1627: }
1628: /*
1629: * determine if the string is printable i.e. only sensible to be read
1630: * as a character string. 1 (true) if it is 0, if it isn't
1631: */
1632: printable(str, i)
1633: char *str;
1634: int i;
1635: {
1636: while (i-- > 0) {
1637: if (!isprint(*str & 0xff))
1638: return (0); /* look for the first non printable
1639: * character */
1640: }
1641: return (1);
1642: }
1643: /*
1644: * generate a unique identifier using the name given and the name if
1645: * present in yp. Return a pointer to it in a space malloc'ed out
1646: */
1647: char *
1648: genlabel(name, yp)
1649: char *name;
1650: YP yp;
1651: {
1652: char buf[MAXNAME];
1653: static int cnt;
1654: char *p1, *p2;
1655:
1656: p1 = notidtoid(name);
1657: if (yp->yp_flags & YP_ID) {
1658: p2 = notidtoid(yp->yp_id);
1659: (void) sprintf(buf, "L%s_%s_%d", p1, p2, cnt++);
1660: free(p2);
1661: } else
1662: (void) sprintf(buf, "L%s_X_%d", p1, cnt++);
1663: free(p1);
1664:
1665: return (my_new_str(buf));
1666: }
1667: /*
1668: * generate a ptr table reference for the given module table entry
1669: */
1670: gen_modref(mod)
1671: char *mod;
1672: {
1673: char buf[BUFSIZ];
1674: char *p1;
1675: int ind;
1676:
1677: p1 = notidtoid(mod);
1678: (void) sprintf(buf, "&%s%s%s", PREFIX, p1, MODTYP_SUFFIX);
1679: ind = addptr(buf);
1680: free(p1);
1681:
1682: return (ind);
1683: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.