![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to yacc.y.gnrc 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 yacc.y.gnrc CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / pepsy |
1.1 root 1: /* yacc.y - yacc ASN.1 parser */
2: /* %WARNING% */
3:
4: %{
5: #ifndef lint
6: static char *rcsid = "$Header: /f/osi/pepsy/RCS/yacc.y.gnrc,v 7.0 90/07/01 19:54:39 mrose Exp $";
7: #endif
8:
9: /*
10: * $Header: /f/osi/pepsy/RCS/yacc.y.gnrc,v 7.0 90/07/01 19:54:39 mrose Exp $
11: *
12: *
13: * $Log: yacc.y.gnrc,v $
14: * Revision 7.0 90/07/01 19:54:39 mrose
15: * *** empty log message ***
16: *
17: * Revision 7.1 90/05/21 17:08:28 mrose
18: * yyporting
19: *
20: * Revision 7.0 89/11/23 22:12:10 mrose
21: * Release 6.0
22: *
23: */
24:
25: /*
26: * NOTICE
27: *
28: * Acquisition, use, and distribution of this module and related
29: * materials are subject to the restrictions of a license agreement.
30: * Consult the Preface in the User's Manual for the full terms of
31: * this agreement.
32: *
33: */
34:
35:
36: #include <stdio.h>
37: #include <ctype.h>
38: %BEGIN(PEPSY)%
39: #include "pepsydefs.h"
40: %END(PEPSY)%
41: %BEGIN(PEPY)%
42: #include "pepy.h"
43: %END(PEPY)%
44: %BEGIN(ROSY)%
45: #include "rosy-defs.h"
46: %END(ROSY)%
47: %BEGIN(MOSY)%
48: #include "mosy-defs.h"
49: %END(MOSY)%
50:
51: #define YYSTYPE YYSTKTYPE
52:
53:
54: #define YYDEBUG 1
55:
56: extern int pepydebug;
57: extern int doexternals;
58:
59: int tagcontrol = TAG_UNKNOWN;
60: static int tagdefault;
61: static int listtype;
62: static OID modid;
63:
64: static int yyporting = 0;
65:
66: typedef struct ypa {
67: char *ya_text;
68: int ya_lineno;
69: } ypa, *YA;
70: #define NULLYA ((YA) 0)
71: extern double pow ();
72:
73: static YA new_action (text, lineno)
74: char *text;
75: int lineno;
76: {
77: register YA ya;
78:
79: if ((ya = (YA) calloc (1, sizeof *ya)) == NULLYA)
80: yyerror ("out of memory");
81:
82: ya -> ya_text = text;
83: ya -> ya_lineno = lineno;
84:
85: return ya;
86: }
87: #define free_action(ya) (void) free ((char *) (ya))
88:
89: typedef struct {
90: char *ys_structname;
91: char *ys_ptrname;
92: } ysa, *YS;
93: #define NULLYS ((YS) 0)
94:
95: static YS new_ys (str)
96: char *str;
97: {
98: register YS ys;
99: register char *p, *q;
100: char c;
101:
102: if((ys = (YS) malloc (sizeof *ys)) == NULLYS)
103: yyerror ("out of memory");
104: q = str;
105: while (isspace (*q)) q++;
106: for (p = q; isalnum(*p) || *p == '_'; p++)
107: continue;
108: if (*p != '\0') {
109: c = *p;
110: *p = '\0';
111: ys -> ys_structname = new_string (q);
112: *p = c;
113: }
114: else {
115: ys -> ys_structname = new_string (q);
116: ys -> ys_ptrname = NULLCP;
117: free (str);
118: return ys;
119: }
120: for (q = p; *q != '$'; q++)
121: if (! *q) {
122: free (str);
123: ys -> ys_ptrname = NULLCP;
124: return ys;
125: }
126: q++;
127: while (isspace (*q)) q++;
128: for (p = q; isalnum(*p) || *p == '_'; p++)
129: continue;
130: *p = '\0';
131: ys -> ys_ptrname = new_string (q);
132: free (str);
133: return ys;
134: }
135: #define free_ys(ys) (void) free ((char *) (ys))
136:
137: static int final_actions = 0;
138: %}
139:
140: %start ModuleDefinition
141:
142:
143: %union {
144: int yy_number;
145: char *yy_string;
146: YP yy_type;
147: YV yy_value;
148: YT yy_tag;
149: YA yy_action;
150: OID yy_oid;
151: YS yy_sctrl;
152: double yy_real;
153: }
154:
155:
156: %token ABSENT ACTION ANY APPLICATION BAR BGIN BIT BITSTRING BOOLEAN
157: BY CCE CHOICE COMMA COMPONENT COMPONENTS COMPONENTSOF CONTROL
158: DECODER DEFAULT DEFINED DEFINITIONS DOT DOTDOT DOTDOTDOT
159: ENCODER ENCRYPTED END ENUMERATED EXPORTS EXPLICIT FALSE FROM
160: ID IDENTIFIER IMPLICIT IMPORTS INCLUDES INTEGER LANGLE LBRACE
161: LBRACKET LITNUMBER LITSTRING LPAREN MIN MAX NAME NIL OBJECT
162: OCTET OCTETSTRING OF OPTIONAL PARAMETERTYPE PREFIXES PRESENT
163: PRINTER PRIVATE RBRACE RBRACKET REAL RPAREN SECTIONS SEMICOLON
164: SEQUENCE SEQUENCEOF SET SETOF SIZE STRING TAGS TRUE UNIVERSAL
165: VALA VALB VALI VALS VALP VALO VALOID VALR VALQ VALX VLENGTH
166: WITH SCTRL PLUSINFINITY MINUSINFINITY
167: %BEGIN(ROSY)%
168: OPERATION ARGUMENT RESULT ERRORS LINKED ERROR PARAMETER
169: /* new stuff */
170: ABSTRACT OPERATIONS CONSUMER SUPPLIER INVOKES PORT PORTS
171: OBJECTCONSUMER OBJECTSUPPLIER REFINE AS RECURRING VISIBLE
172: PAIRED BIND UNBIND
173: /* end new stuff */
174: %END(ROSY)%
175: %BEGIN(MOSY)%
176: OBJECTYPE SYNTAX ACCESS STATUS
177: %END(MOSY)%
178:
179: %type <yy_number> LITNUMBER
180: %type <yy_real> RealValue NumericRealValue SpecialRealValue
181: %type <yy_string> ID NAME LITSTRING VALA VALB VALI VALS VALP VALQ
182: VALR VALO VALX VLENGTH VALOID CONTROL PARAMETERTYPE
183: ParameterType Control ValParameter String
184: PassInt PassBool PassOid PassAny PassReal
185: ModuleIdentifier Symbol SymbolList
186: SCTRL
187: %type <yy_type> Type BuiltinType DefinedType PassValue PassBit
188: PassString NullPass ElementTypes OptionalTypeList
189: OptionalType NamedType ComponentsOf AlternativeTypeList
190: MemberTypes SubType
191: %BEGIN(ROSY)%
192: Argument Result Parameter
193: %END(ROSY)%
194: %type <yy_value> NamedNumberList NamedNumber NumericValue
195: Value BuiltinValue DefinedValue IdentifierList
196: Values NamedValueList NamedValue NNlist
197: %BEGIN(ROSY)%
198: Errors ErrorNames
199: LinkedOperations LinkedOperationNames
200: %END(ROSY)%
201: %BEGIN(MOSY)%
202: ObjectID ObjectIDComponentList ObjectSubID
203: %END(MOSY)%
204: %type <yy_tag> Tag Class
205: %type <yy_action> ACTION Action
206: %type <yy_oid> ObjIdComponentList ObjectIdentifierValue
207: ObjIdComponent NumberForm NameAndNumberForm
208: %type <yy_sctrl> Sctrl
209: %%
210:
211: ModuleDefinition: ModuleIdentifier DEFINITIONS TagDefault CCE
212: {
213: mymodule = $1;
214: mymoduleid = modid;
215: pass1 ();
216: }
217: ModuleActions ModulePrefixes
218: BGIN ModuleBody END { pass2 (); final_actions++; }
219: ModuleActions
220: ;
221:
222: TagDefault: EXPLICIT TAGS {
223: tagdefault = 0;
224: tagcontrol = TAG_EXPLICIT;
225: }
226: | IMPLICIT TAGS {
227: tagdefault = YP_IMPLICIT;
228: tagcontrol = TAG_IMPLICIT;
229: }
230: | empty {
231: tagdefault = 0;
232: tagcontrol = TAG_UNKNOWN;
233: }
234: ;
235:
236: ModuleIdentifier: ID AssignedIdentifier { $$ = $1; }
237: ;
238:
239: AssignedIdentifier: ObjectIdentifierValue { modid = $1; }
240: | empty
241: ;
242:
243: ModuleActions: ACTION {
244: %BEGIN(PEPSY)%
245: if (bflag) {
246: if (final_actions)
247: init_new_file ();
248: else {
249: module_actions = $1 -> ya_text;
250: free_action ($1);
251: break;
252: }
253: }
254: %END(PEPSY)%
255: %BEGIN(PEPY)%
256: if (bflag) {
257: if (final_actions)
258: init_new_file ();
259: else {
260: module_actions = $1 -> ya_text;
261: free_action ($1);
262: break;
263: }
264: }
265: %END(PEPY)%
266: if (!dflag) {
267: if (Cflag > 0) {
268: if (!Pflag && *sysin)
269: printf ("# line %d \"%s\"\n",
270: $1 -> ya_lineno, sysin);
271: fputs ($1 -> ya_text, stdout);
272: }
273: else {
274: printf ("%%{\n#include \"%s-types.h\"\n",
275: mymodule);
276: printf ("%s%%}\n", $1 -> ya_text);
277: Cflag = -1;
278: }
279: }
280: free_action ($1);
281: %BEGIN(PEPSY)%
282: if (bflag)
283: end_file ();
284: %END(PEPSY)%
285: %BEGIN(PEPY)%
286: if (bflag)
287: end_file ();
288: %END(PEPY)%
289: }
290: | empty
291: ;
292: ModulePrefixes:
293: PREFIXES String String String
294: {
295: yyencdflt = $2;
296: yydecdflt = $3;
297: yyprfdflt = $4;
298: }
299: | empty
300: ;
301: ModuleBody: Exports Imports AssignmentList
302: ;
303:
304: Exports: EXPORTS { listtype = TBL_EXPORT; doexternals = 0;
305: yyporting = 1; }
306: SymbolsExported SEMICOLON {
307: yyporting = 0;
308: if (mymoduleid == NULLOID)
309: warning ("EXPORTS but no ModuleIdentifier");
310:
311: }
312: | empty
313: ;
314:
315: SymbolsExported: SymbolList
316: | empty
317: ;
318:
319: Imports: IMPORTS { listtype = TBL_IMPORT; yyporting = 1; }
320: SymbolsImported SEMICOLON {
321: yyporting = 0;
322: if (mymoduleid == NULLOID)
323: warning ("IMPORTS but no ModuleIdentifier");
324: }
325:
326: | empty
327: ;
328:
329: SymbolsImported: SymbolsFromModuleList
330: | empty
331: ;
332:
333: SymbolsFromModuleList: SymbolsFromModuleList SymbolsFromModule
334: | SymbolsFromModule
335: ;
336:
337: SymbolsFromModule: SymbolList FROM ModuleIdentifier
338: {
339: addtableref ($3, modid, listtype);
340: }
341: ;
342:
343: SymbolList: SymbolList COMMA Symbol { addtable($3, listtype); }
344: | Symbol { addtable ($1, listtype); }
345: ;
346:
347: Symbol: ID
348: | NAME
349: ;
350:
351: AssignmentList: AssignmentList Section Assignment
352: | empty
353: ;
354:
355: Section: ENCODER String
356: { yysection = YP_ENCODER; yyencpref = $2;
357: yyprint (NULLCP, 0, 1); }
358: | DECODER String
359: { yysection = YP_DECODER; yydecpref = $2;
360: yyprint (NULLCP, 0, 1); }
361: | PRINTER String
362: { yysection = YP_PRINTER; yyprfpref = $2;
363: yyprint (NULLCP, 0, 1); }
364: | SECTIONS String String String
365: {
366: yysection = NULL;
367: if (strcmp (yyencpref = $2, "none"))
368: yysection |= YP_ENCODER;
369: if (strcmp (yydecpref = $3, "none"))
370: yysection |= YP_DECODER;
371: if (strcmp (yyprfpref = $4, "none"))
372: yysection |= YP_PRINTER;
373: yyprint (NULLCP, 0, 1);
374: }
375: | empty
376: ;
377:
378: String: ID { $$ = $1; }
379: | NAME { $$ = $1; }
380: ;
381:
382: Assignment: Typeassignment
383: %BEGIN(ROSY)%
384: | OperationDefinition
385: | ErrorDefinition
386: /* new stuff */
387: | PortDefinition
388: | ObjectDefinition
389: /* | RefineDefinition -- impossible!!!! (JPO) */
390: /* | BindDefinition -- lacking defs... */
391: /* | UnBindDefinition -- ditto */
392: /* end new stuff */
393: %END(ROSY)%
394: %BEGIN(MOSY)%
395: | ObjectTypeDefinition
396: | ObjectIDefinition
397: %END(MOSY)%
398: | Valueassignment
399: ;
400:
401: %BEGIN(ROSY)%
402: OperationDefinition: NAME OPERATION Argument Result Errors LinkedOperations
403: CCE LITNUMBER {
404: pass1_op (mymodule, $1, $3, $4, $5, $6, $8);
405: }
406: ;
407:
408: Argument: ARGUMENT NamedType { $$ = $2; }
409: | empty { $$ = NULLYP; }
410: ;
411:
412: Result: RESULT NamedType { $$ = $2; }
413: | empty { $$ = NULLYP; }
414: ;
415:
416: Errors: ERRORS LBRACE ErrorNames RBRACE { $$ = $3; }
417: | empty { $$ = NULLYV; }
418:
419: LinkedOperations: LINKED LBRACE LinkedOperationNames RBRACE { $$ = $3; }
420: | empty { $$ = NULLYV; }
421:
422:
423: ErrorNames: NamedValueList {
424: $$ = new_value (YV_VALIST);
425: $$ -> yv_idlist = $1;
426: }
427: | empty { $$ = NULLYV; }
428:
429:
430: LinkedOperationNames: NamedValueList {
431: $$ = new_value (YV_VALIST);
432: $$ -> yv_idlist = $1;
433: }
434: | empty { $$ = NULLYV; }
435:
436:
437: ErrorDefinition: NAME ERROR Parameter CCE LITNUMBER {
438: pass1_err (mymodule, $1, $3, $5);
439: }
440: ;
441:
442: Parameter: PARAMETER NamedType { $$ = $2; }
443: | empty { $$ = NULLYP; }
444: ;
445:
446: /* new stuff start */
447: PortDefinition: NAME PORT PortOperations CCE PortValue
448: ;
449:
450: PortValue: ObjectIdentifierValue
451: | NAME
452: ;
453:
454: PortOperations: PortSymmetrical
455: | PortAsymetrical
456: | empty
457:
458: PortSymmetrical: ABSTRACT OPERATIONS LBRACE PortOperationList RBRACE
459: ;
460:
461: PortAsymetrical: PortOneSided
462: | PortTwoSided
463: ;
464:
465: PortOneSided: PortConsumer
466: | PortSupplier
467: ;
468:
469: PortTwoSided: PortConsumer PortSupplier
470: | PortSupplier PortConsumer
471: ;
472:
473: PortConsumer: CONSUMER INVOKES LBRACE PortOperationList RBRACE
474: ;
475:
476: PortSupplier: SUPPLIER INVOKES LBRACE PortOperationList RBRACE
477: ;
478:
479: PortOperationList: OperationValue
480: | OperationValue COMMA PortOperationList
481: ;
482:
483: OperationValue: NAME
484: | ID
485: | LITNUMBER
486: | ObjectIdentifierValue
487: ;
488:
489: ObjectDefinition: NAME OBJECT ObjectType CCE PortValue
490: ;
491:
492: ObjectType: PORTS LBRACE ObjectPortList RBRACE
493: | empty
494: ;
495:
496: ObjectPortList: ObjectPort COMMA ObjectPortList
497: | ObjectPort
498: ;
499:
500: ObjectPort: PortValue ObjectPortType
501: ;
502:
503: ObjectPortType: ObjectSymetric
504: | ObjectAsymetric
505: ;
506:
507: ObjectSymetric: empty
508: ;
509:
510: ObjectAsymetric: OBJECTCONSUMER
511: | OBJECTSUPPLIER
512: ;
513:
514: /* New stuff end */
515: %END(ROSY)%
516:
517: %BEGIN(MOSY)%
518: ObjectTypeDefinition: NAME OBJECTYPE SYNTAX NamedType ACCESS NAME
519: STATUS NAME CCE ObjectID {
520: pass1_obj (mymodule, $1, $4, $10, $6, $8);
521: }
522: ;
523:
524: ObjectIDefinition: NAME OBJECT IDENTIFIER CCE ObjectID {
525: pass1_oid (mymodule, $1, $5);
526: }
527: ;
528:
529: ObjectID: NAME {
530: $$ = new_value (YV_OIDLIST);
531: $$ -> yv_idlist = new_value (YV_IDEFINED);
532: $$ -> yv_idlist -> yv_identifier = $1;
533: $$ -> yv_idlist -> yv_flags |= YV_BOUND;
534: }
535: | LBRACE ObjectIDComponentList RBRACE {
536: $$ = new_value (YV_OIDLIST);
537: $$ -> yv_idlist = $2;
538: }
539: ;
540: ObjectIDComponentList: ObjectSubID { $$ = $1; }
541: | ObjectIDComponentList ObjectSubID {
542: $$ = add_value ($1, $2);
543: }
544: ;
545: ObjectSubID: LITNUMBER {
546: $$ = new_value (YV_NUMBER);
547: $$ -> yv_number = $1;
548: }
549: | NAME {
550: $$ = new_value (YV_IDEFINED);
551: $$ -> yv_identifier = $1;
552: $$ -> yv_flags |= YV_BOUND;
553: }
554: | NAME LPAREN LITNUMBER RPAREN {
555: $$ = new_value (YV_NUMBER);
556: $$ -> yv_number = $3;
557: $$ -> yv_named = $1;
558: $$ -> yv_flags |= YV_NAMED;
559: }
560: ;
561: %END(MOSY)%
562:
563: Typeassignment: ID ParameterType Action CCE Action Type {
564: if ($2)
565: $6 -> yp_param_type = $2;
566: if ($3) {
567: $6 -> yp_action0 = $3 -> ya_text;
568: $6 -> yp_act0_lineno= $3 -> ya_lineno;
569: free_action ($3);
570: }
571: if ($5) {
572: if ($6 -> yp_action05 == NULLCP) {
573: $6 -> yp_action05 = $5 -> ya_text;
574: $6 -> yp_act05_lineno= $5 -> ya_lineno;
575: free_action ($5);
576: }
577: else
578: yyerror("too many preliminary actions associated with type");
579: }
580: pass1_type (yyencpref, yydecpref, yyprfpref,
581: mymodule, $1, $6);
582: } ;
583:
584: Type: BuiltinType Action {
585: $$ = $1;
586: $$ -> yp_direction = yysection;
587: if ($2) {
588: $$ -> yp_action2 = $2 -> ya_text;
589: $$ -> yp_act2_lineno= $2 -> ya_lineno;
590: free_action ($2);
591: }
592: }
593: | DefinedType Action {
594: $$ = $1;
595: $$ -> yp_direction = yysection;
596: if ($2) {
597: $$ -> yp_action2 = $2 -> ya_text;
598: $$ -> yp_act2_lineno= $2 -> ya_lineno;
599: free_action ($2);
600: }
601: }
602: | SubType Action {
603: $$ = $1;
604: $$ -> yp_direction = yysection;
605: if ($2) {
606: $$ -> yp_action2 = $2 -> ya_text;
607: $$ -> yp_act2_lineno = $2 -> ya_lineno;
608: free_action ($2);
609: }
610: }
611: ;
612:
613: Action: ACTION
614: | empty { $$ = NULLYA; }
615: ;
616:
617: Control: CONTROL
618: | empty { $$ = NULLCP; }
619: ;
620:
621: ParameterType: PARAMETERTYPE
622: | empty { $$ = NULLCP; }
623: ;
624:
625: BuiltinType: BOOLEAN PassBool {
626: $$ = new_type (YP_BOOL);
627: $$ -> yp_intexp = $2;
628: }
629: | INTEGER PassInt NNlist {
630: $$ = new_type ($3 ? YP_INTLIST : YP_INT);
631: $$ -> yp_intexp = $2;
632: if ($3)
633: $$ -> yp_value = $3;
634: }
635: | ENUMERATED PassInt LBRACE NamedNumberList RBRACE {
636: $$ = new_type (YP_ENUMLIST);
637: $$ -> yp_intexp = $2;
638: $$ -> yp_value = $4;
639: }
640:
641: | Bitstring PassBit NNlist {
642: $$ = $2;
643: $$ -> yp_code = $3 ? YP_BITLIST: YP_BIT;
644: if ($3)
645: $$ -> yp_value = $3;
646: }
647: | Octetstring PassString {
648: $$ = $2;
649: $$ -> yp_code = YP_OCT;
650: }
651: | NIL { $$ = new_type (YP_NULL); }
652: | SEQUENCE Sctrl PassAny {
653: $$ = new_type (YP_SEQ);
654: $$ -> yp_strexp = $3;
655: }
656: | SequenceOf Sctrl Action Control Type {
657: $$ = new_type (YP_SEQTYPE);
658: $$ -> yp_type = $5;
659: if ($2) {
660: $$ -> yp_structname = $2 -> ys_structname;
661: $$ -> yp_ptrname = $2 -> ys_ptrname;
662: free_ys ($2);
663: }
664: if ($4) {
665: $$ -> yp_control = $4;
666: $$ -> yp_flags |= YP_CONTROLLED;
667: }
668: if ($3) {
669: $$ -> yp_action3 = $3 -> ya_text;
670: $$ -> yp_act3_lineno = $3 -> ya_lineno;
671: free_action ($3);
672: }
673: }
674: | SEQUENCE Sctrl Action LBRACE ElementTypes RBRACE {
675: $$ = new_type (YP_SEQLIST);
676: $$ -> yp_type = $5;
677: if ($2) {
678: $$ -> yp_structname = $2 -> ys_structname;
679: $$ -> yp_ptrname = $2 -> ys_ptrname;
680: free_ys ($2);
681: }
682: if ($3 && $$ -> yp_action1 == NULLCP) {
683: $$ -> yp_action1 = $3 -> ya_text;
684: $$ -> yp_act1_lineno = $3 -> ya_lineno;
685: free_action ($3);
686: }
687: else if ($3)
688: yyerror("too many actions associated with SEQUENCE");
689: }
690: | SET Sctrl PassAny {
691: $$ = new_type (YP_SET);
692: $$ -> yp_strexp = $3;
693: }
694: | SetOf Sctrl Action Control Type {
695: $$ = new_type (YP_SETTYPE);
696: $$ -> yp_type = $5;
697: if ($2) {
698: $$ -> yp_structname = $2 -> ys_structname;
699: $$ -> yp_ptrname = $2 -> ys_ptrname;
700: free_ys ($2);
701: }
702: if ($4) {
703: $$ -> yp_control = $4;
704: $$ -> yp_flags |= YP_CONTROLLED;
705: }
706: if ($3) {
707: $$ -> yp_action3 = $3 -> ya_text;
708: $$ -> yp_act3_lineno = $3 -> ya_lineno;
709: free_action ($3);
710: }
711: }
712:
713: | SET Sctrl Action LBRACE MemberTypes RBRACE {
714: $$ = new_type (YP_SETLIST);
715: $$ -> yp_type = $5;
716: if ($2) {
717: $$ -> yp_structname = $2 -> ys_structname;
718: $$ -> yp_ptrname = $2 -> ys_ptrname;
719: free_ys ($2);
720: }
721: if ($3 && $$ -> yp_action1 == NULLCP) {
722: $$ -> yp_action1 = $3 -> ya_text;
723: $$ -> yp_act1_lineno = $3 -> ya_lineno;
724: free_action ($3);
725: }
726: else if ($3)
727: yyerror("too many actions associated with SET");
728: }
729: | Tag Action IMPLICIT Type {
730: $$ = $4;
731: $$ -> yp_tag = $1;
732: if ($2 && $$ -> yp_action1 == NULLCP) {
733: $$ -> yp_action1 = $2 -> ya_text;
734: $$ -> yp_act1_lineno= $2 -> ya_lineno;
735: free_action ($2);
736: }
737: else if ($2)
738: yyerror("too many actions associated with tagged type");
739: $$ -> yp_flags |= YP_IMPLICIT | YP_TAG;
740: }
741: | Tag Action EXPLICIT Type {
742: $$ = $4;
743: $$ -> yp_tag = $1;
744: if ($2 && $$ -> yp_action1 == NULLCP) {
745: $$ -> yp_action1 = $2 -> ya_text;
746: $$ -> yp_act1_lineno= $2 -> ya_lineno;
747: free_action ($2);
748: }
749: else if ($2)
750: yyerror("too many actions associated with tagged type");
751: $$ -> yp_flags |= YP_TAG;
752: }
753: | Tag Action Type {
754: $$ = $3;
755: $$ -> yp_tag = $1;
756: if ($2 && $$ -> yp_action1 == NULLCP) {
757: $$ -> yp_action1 = $2 -> ya_text;
758: $$ -> yp_act1_lineno= $2 -> ya_lineno;
759: free_action ($2);
760: }
761: else if ($2)
762: yyerror("too many actions associated with tagged type");
763: $$ -> yp_flags |= (YP_TAG | tagdefault);
764: }
765: | CHOICE Sctrl Action Control LBRACE
766: AlternativeTypeList RBRACE {
767: $$ = new_type (YP_CHOICE);
768: $$ -> yp_type = $6;
769: if ($2) {
770: $$ -> yp_structname = $2 -> ys_structname;
771: $$ -> yp_ptrname = $2 -> ys_ptrname;
772: free_ys ($2);
773: }
774: if ($4) {
775: $$ -> yp_control = $4;
776: $$ -> yp_flags |= YP_CONTROLLED;
777: }
778: if ($$ -> yp_action1 == NULLCP && $3) {
779: $$ -> yp_action1 = $3 -> ya_text;
780: $$ -> yp_act1_lineno = $3 -> ya_lineno;
781: free_action ($3);
782: }
783: else if ($3)
784: yyerror("too many actions associated with CHOICE");
785: }
786: | NAME LANGLE Type {
787: $$ = $3;
788: $$ -> yp_bound = $1;
789: $$ -> yp_flags |= YP_BOUND;
790: }
791: | AnyType PassAny {
792: $$ = new_type (YP_ANY);
793: $$ -> yp_strexp = $2;
794: }
795: | OBJECT IDENTIFIER PassOid {
796: $$ = new_type (YP_OID);
797: $$ -> yp_strexp = $3;
798: }
799: | ENCRYPTED Type {
800: $$ = $2;
801: $$ -> yp_tag = new_tag (PE_CLASS_UNIV);
802: $$ -> yp_tag -> yt_value = new_value(YV_NUMBER);
803: $$ -> yp_tag -> yt_value -> yv_number = PE_PRIM_ENCR;
804: $$ -> yp_flags |=
805: (YP_ENCRYPTED | YP_TAG | YP_IMPLICIT);
806: }
807: | REAL PassReal {
808: $$ = new_type(YP_REAL);
809: $$ -> yp_strexp = $2;
810: }
811: ;
812:
813: NNlist: LBRACE NamedNumberList RBRACE { $$ = $2; }
814: | empty { $$ = NULL; }
815: ;
816: DefinedType: ID PassValue ValParameter {
817: $$ = $2;
818: $$ -> yp_code = YP_IDEFINED;
819: $$ -> yp_identifier = $1;
820: if ($3) {
821: $$ -> yp_parm = $3;
822: $$ -> yp_flags |= YP_PARMVAL;
823: }
824: check_impexp ($$);
825: }
826: | ID DOT ID PassValue ValParameter {
827: $$ = $4;
828: $$ -> yp_code = YP_IDEFINED;
829: $$ -> yp_identifier = $3;
830: $$ -> yp_module = $1;
831: if ($5) {
832: $$ -> yp_parm = $5;
833: $$ -> yp_flags |= YP_PARMVAL;
834: }
835: }
836: ;
837:
838: PassValue: VALA {
839: $$ = new_type (YP_UNDF);
840: $$ -> yp_intexp = NULLCP;
841: $$ -> yp_strexp = $1;
842: $$ -> yp_prfexp = 'a';
843: }
844: | VALB {
845: $$ = new_type (YP_UNDF);
846: $$ -> yp_intexp = $1;
847: $$ -> yp_strexp = NULLCP;
848: $$ -> yp_prfexp = 'b';
849: }
850: | VALI {
851: $$ = new_type (YP_UNDF);
852: $$ -> yp_intexp = $1;
853: $$ -> yp_strexp = NULLCP;
854: $$ -> yp_prfexp = 'i';
855: }
856: | VALX VLENGTH {
857: $$ = new_type (YP_UNDF);
858: $$ -> yp_intexp = $2;
859: $$ -> yp_strexp = $1;
860: $$ -> yp_prfexp = 'x';
861: }
862: | VALOID {
863: $$ = new_type (YP_UNDF);
864: $$ -> yp_intexp = NULLCP;
865: $$ -> yp_strexp = $1;
866: $$ -> yp_prfexp = 'O';
867: }
868: | PassString
869: ;
870:
871: AnyType: ANY
872: | ANY DEFINED BY NAME
873: ;
874:
875: PassOid: VALOID
876: | empty { $$ = NULLCP; }
877: ;
878:
879: PassAny: VALA
880: | empty { $$ = NULLCP; }
881: ;
882:
883: PassBool: VALB
884: | empty { $$ = NULLCP; }
885: ;
886:
887: PassInt: VALI
888: | empty { $$ = NULLCP; }
889: ;
890:
891: PassBit: VALX VLENGTH {
892: $$ = new_type (YP_UNDF);
893: $$ -> yp_intexp = $2;
894: $$ -> yp_strexp = $1;
895: }
896: | NullPass
897: ;
898:
899: PassString: VALS {
900: $$ = new_type (YP_UNDF);
901: $$ -> yp_intexp = NULLCP;
902: $$ -> yp_strexp = $1;
903: $$ -> yp_prfexp = 's';
904: }
905: | VALO VLENGTH {
906: $$ = new_type (YP_UNDF);
907: $$ -> yp_intexp = $2;
908: $$ -> yp_strexp = $1;
909: $$ -> yp_prfexp = 'o';
910: }
911: | VALQ {
912: $$ = new_type (YP_UNDF);
913: $$ -> yp_intexp = NULLCP;
914: $$ -> yp_strexp = $1;
915: $$ -> yp_prfexp = 'q';
916: }
917: | NullPass
918: ;
919:
920: PassReal: VALR
921: | empty { $$ = NULLCP; }
922: ;
923:
924: NullPass: empty {
925: $$ = new_type (YP_UNDF);
926: $$ -> yp_intexp = NULLCP;
927: $$ -> yp_strexp = NULLCP;
928: }
929: ;
930:
931: ValParameter: VALP
932: | empty { $$ = NULLCP; }
933: ;
934:
935: NamedNumberList: NamedNumber { $$ = $1; }
936: | NamedNumberList COMMA NamedNumber {
937: $$ = add_value ($1, $3);
938: }
939: ;
940: NamedNumber: NAME LPAREN NumericValue RPAREN Action {
941: $$ = $3;
942: $$ -> yv_named = $1;
943: $$ -> yv_flags |= YV_NAMED;
944: if ($5) {
945: $$ -> yv_action = $5 -> ya_text;
946: $$ -> yv_act_lineno = $5 -> ya_lineno;
947: free_action ($5);
948: }
949: }
950: ;
951: NumericValue: LITNUMBER {
952: $$ = new_value (YV_NUMBER);
953: $$ -> yv_number = $1;
954: }
955: | DefinedValue
956: ;
957:
958: ElementTypes: OptionalTypeList { $$ = $1; }
959: | empty { $$ = NULLYP; }
960: ;
961: MemberTypes: OptionalTypeList { $$ = $1; }
962:
963: | empty { $$ = NULLYP; }
964: ;
965: OptionalTypeList: OptionalType { $$ = $1; }
966: | OptionalTypeList COMMA OptionalType {
967: $$ = add_type ($1, $3);
968: }
969: ;
970: OptionalType: NamedType { $$ = $1; }
971: | NamedType OPTIONAL Control {
972: $$ = $1;
973: $$ -> yp_flags |= YP_OPTIONAL;
974: if ($3) {
975: $$ -> yp_optcontrol = $3;
976: $$ -> yp_flags |= YP_OPTCONTROL;
977: }
978: }
979: | NamedType DEFAULT Value Control {
980: $$ = $1;
981: $$ -> yp_default = $3;
982: $$ -> yp_flags |= YP_DEFAULT;
983: if ($4) {
984: $$ -> yp_optcontrol = $4;
985: $$ -> yp_flags |= YP_OPTCONTROL;
986: }
987: }
988: | ComponentsOf { $$ = $1; }
989: | NAME ComponentsOf { $$ = $2; $$->yp_id = $1; }
990: ;
991: NamedType: NAME Action Type {
992: $$ = $3;
993: $$ -> yp_id = $1;
994: if ($$ -> yp_action1 == NULLCP && $2) {
995: $$ -> yp_action1 = $2 -> ya_text;
996: $$ -> yp_act1_lineno = $2 -> ya_lineno;
997: free_action ($2);
998: }
999: $$ -> yp_flags |= YP_ID;
1000: }
1001: | Type { $$ = $1; }
1002: ;
1003: ComponentsOf: Components Type {
1004: $$ = $2;
1005: $$ -> yp_flags |= YP_COMPONENTS;
1006: }
1007: ;
1008: AlternativeTypeList: NamedType { $$ = $1; }
1009: | AlternativeTypeList COMMA NamedType {
1010: $$ = add_type ($1, $3);
1011: }
1012: ;
1013:
1014: Tag: LBRACKET Class NumericValue RBRACKET {
1015: $$ = $2;
1016: $$ -> yt_value = $3;
1017: }
1018: ;
1019: Class: UNIVERSAL { $$ = new_tag (PE_CLASS_UNIV); }
1020: | APPLICATION { $$ = new_tag (PE_CLASS_APPL); }
1021: | PRIVATE { $$ = new_tag (PE_CLASS_PRIV); }
1022: | empty { $$ = new_tag (PE_CLASS_CONT); }
1023: ;
1024:
1025:
1026: Valueassignment: NAME Type CCE Value
1027: ;
1028:
1029: Value: BuiltinValue
1030: | DefinedValue
1031: ;
1032: BuiltinValue: TRUE {
1033: $$ = new_value (YV_BOOL);
1034: $$ -> yv_number = 1;
1035: }
1036: | FALSE {
1037: $$ = new_value (YV_BOOL);
1038: $$ -> yv_number = 0;
1039: }
1040: | LITNUMBER {
1041: $$ = new_value (YV_NUMBER);
1042: $$ -> yv_number = $1;
1043: }
1044: | LBRACE ID IdentifierList RBRACE {
1045: $$ = new_value (YV_IDLIST);
1046: $$ -> yv_idlist = new_value (YV_IDEFINED);
1047: $$ -> yv_idlist -> yv_identifier = $2;
1048: if ($3)
1049: $$ = add_value ($$, $3);
1050: }
1051: | LITSTRING {
1052: $$ = new_value (YV_STRING);
1053: $$ -> yv_string = $1;
1054: }
1055: | NIL { $$ = new_value (YV_NULL); }
1056: | LBRACE Values RBRACE {
1057: $$ = new_value (YV_VALIST);
1058: $$ -> yv_idlist = $2;
1059: }
1060: | NAME Value {
1061: $$ = $2;
1062: $$ -> yv_id = $1;
1063: $$ -> yv_flags |= YV_ID;
1064: }
1065: | Type Value {
1066: $$ = $2;
1067: $$ -> yv_type = $1;
1068: $$ -> yv_flags |= YV_TYPE;
1069: }
1070: | RealValue {
1071: $$ = new_value (YV_REAL);
1072: $$ -> yv_real = $1;
1073: }
1074: ;
1075:
1076: RealValue: NumericRealValue
1077: | SpecialRealValue
1078: ;
1079:
1080: SpecialRealValue: PLUSINFINITY { $$ = PE_REAL_INFINITY;}
1081: | MINUSINFINITY { $$ = - PE_REAL_INFINITY; }
1082: ;
1083:
1084: NumericRealValue: LBRACE LITNUMBER COMMA LITNUMBER COMMA
1085: LITNUMBER RBRACE {
1086: if ($4 != 2 && $4 != 10)
1087: myyerror ("Illegal base value %d", $4);
1088: $$ = $2 * pow ((double)$4, (double)$6);
1089: }
1090: ;
1091:
1092: DefinedValue: ID {
1093: $$ = new_value (YV_IDEFINED);
1094: $$ -> yv_identifier = $1;
1095: }
1096: | NAME { /* XXX */
1097: $$ = new_value (YV_IDEFINED);
1098: $$ -> yv_identifier = $1;
1099: $$ -> yv_flags |= YV_BOUND;
1100: }
1101: | ID DOT ID {
1102: $$ = new_value (YV_IDEFINED);
1103: $$ -> yv_identifier = $3;
1104: $$ -> yv_module = $1;
1105: }
1106: ;
1107:
1108: IdentifierList: IdentifierList COMMA ID {
1109: $$ = new_value (YV_IDEFINED);
1110: $$ -> yv_identifier = $3;
1111: if ($1)
1112: $$ = add_value ($1, $$);
1113: }
1114: | empty { $$ = NULLYV; }
1115: ;
1116:
1117: Values: NamedValueList { $$ = $1; }
1118: | empty { $$ = NULLYV; }
1119: ;
1120: NamedValueList: NamedValue { $$ = $1; }
1121: | NamedValueList COMMA NamedValue {
1122: $$ = add_value ($1, $3);
1123: }
1124: ;
1125: NamedValue: Value { $$ = $1; }
1126: ;
1127:
1128: empty: ;
1129:
1130: Octetstring: OCTET STRING
1131: | OCTETSTRING
1132: ;
1133:
1134: Bitstring: BITSTRING
1135: | BIT STRING
1136: ;
1137:
1138: SequenceOf: SEQUENCEOF
1139: | SEQUENCE OF
1140: ;
1141: SetOf: SETOF
1142: | SET OF
1143: ;
1144: Components: COMPONENTSOF
1145: | COMPONENTS OF
1146: ;
1147:
1148: ObjectIdentifierValue: LBRACE ObjIdComponentList RBRACE
1149: { $$ = $2; }
1150: ;
1151:
1152: ObjIdComponentList: ObjIdComponent
1153: | ObjIdComponentList ObjIdComponent
1154: {
1155: $$ = addoid($1, $2);
1156: oid_free ($1);
1157: oid_free ($2);
1158: }
1159: ;
1160:
1161: ObjIdComponent: NumberForm
1162: | NameAndNumberForm
1163: ;
1164:
1165: NumberForm: LITNUMBER { $$ = int2oid ($1); }
1166: | DefinedValue {
1167: $$ = oidlookup($1->yv_identifier);
1168: free((char *)$1);
1169: }
1170: ;
1171:
1172: NameAndNumberForm: NAME LPAREN NumberForm RPAREN {
1173: free ($1);
1174: $$ = $3;
1175: }
1176: ;
1177:
1178: SubType: Type SubtypeSpec
1179: | SET SizeConstraint OF Sctrl Action Control Type {
1180: $$ = new_type (YP_SETTYPE);
1181: $$ -> yp_type = $7;
1182: if ($4) {
1183: $$ -> yp_structname = $4 -> ys_structname;
1184: $$ -> yp_ptrname = $4 -> ys_ptrname;
1185: free_ys ($4);
1186: }
1187: if ($6) {
1188: $$ -> yp_control = $6;
1189: $$ -> yp_flags |= YP_CONTROLLED;
1190: }
1191: if ($5) {
1192: $$ -> yp_action3 = $5 -> ya_text;
1193: $$ -> yp_act2_lineno = $5 -> ya_lineno;
1194: free_action ($5);
1195: }
1196: }
1197:
1198: | SEQUENCE SizeConstraint OF Sctrl Action Control Type {
1199: $$ = new_type (YP_SEQTYPE);
1200: $$ -> yp_type = $7;
1201: if ($4) {
1202: $$ -> yp_structname = $4 -> ys_structname;
1203: $$ -> yp_ptrname = $4 -> ys_ptrname;
1204: free_ys ($4);
1205: }
1206: if ($6) {
1207: $$ -> yp_control = $6;
1208: $$ -> yp_flags |= YP_CONTROLLED;
1209: }
1210: if ($5) {
1211: $$ -> yp_action3 = $5 -> ya_text;
1212: $$ -> yp_act3_lineno = $5 -> ya_lineno;
1213: free_action ($5);
1214: }
1215: }
1216: ;
1217:
1218: SubtypeSpec: LPAREN SubtypeAlternative SubtypeAlternativeList RPAREN
1219: ;
1220:
1221: SubtypeAlternative: SubtypeValueSet
1222: | SubtypeConstraint
1223: ;
1224:
1225: SubtypeAlternativeList: BAR SubtypeAlternative SubtypeAlternativeList
1226: | empty
1227: ;
1228:
1229: SubtypeValueSet: Value
1230: | ContainedSubType
1231: | ValueRange
1232: | PermittedAlphabet
1233: ;
1234:
1235: SubtypeConstraint: SizeConstraint
1236: | InnerTypeConstraint
1237: ;
1238:
1239: ContainedSubType: INCLUDES Type ;
1240:
1241: ValueRange: LowerEndPoint DOTDOT UpperEndpoint
1242: ;
1243:
1244: LowerEndPoint: LowerEndValue
1245: | LowerEndValue LANGLE
1246: ;
1247:
1248: UpperEndpoint: UpperEndValue
1249: | LANGLE UpperEndValue
1250: ;
1251:
1252: LowerEndValue: Value
1253: | MIN
1254: ;
1255:
1256: UpperEndValue: Value
1257: | MAX
1258: ;
1259:
1260: SizeConstraint: SIZE SubtypeSpec
1261: ;
1262:
1263: PermittedAlphabet: FROM SubtypeSpec
1264: ;
1265:
1266: InnerTypeConstraint: WITH COMPONENT SingleTypeConstraint
1267: | WITH COMPONENTS MultipleTypeConstraints
1268: ;
1269:
1270: SingleTypeConstraint: SubtypeSpec
1271: ;
1272:
1273: MultipleTypeConstraints:FullSpecification
1274: | PartialSpecification
1275: ;
1276:
1277: FullSpecification: LBRACE TypeConstraints RBRACE
1278: ;
1279:
1280: PartialSpecification: LBRACE DOTDOTDOT COMMA TypeConstraints RBRACE
1281: ;
1282:
1283: TypeConstraints: NamedConstraint
1284: | NamedConstraint COMMA TypeConstraints
1285: ;
1286:
1287: NamedConstraint: NAME Constraint
1288: | Constraint
1289: ;
1290:
1291: Constraint: ValueConstraint
1292: | PresenceConstraint
1293: | empty
1294: ;
1295:
1296: ValueConstraint: SubtypeSpec
1297: ;
1298:
1299: PresenceConstraint: PRESENT
1300: | ABSENT
1301: ;
1302:
1303: Sctrl: SCTRL { $$ = new_ys ($1); }
1304: | empty { $$ = NULLYS; }
1305: ;
1306: %%
1307:
1308: #ifdef HPUX
1309: #define uchar Uchar
1310: #endif
1311: #include "lex.c"
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.