diff options
Diffstat (limited to 'libasn1parser/asn1p_y.c')
| -rw-r--r-- | libasn1parser/asn1p_y.c | 3484 |
1 files changed, 3484 insertions, 0 deletions
diff --git a/libasn1parser/asn1p_y.c b/libasn1parser/asn1p_y.c new file mode 100644 index 00000000..095c9041 --- /dev/null +++ b/libasn1parser/asn1p_y.c @@ -0,0 +1,3484 @@ + +/* A Bison parser, made from asn1p_y.y + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define yyparse asn1p_parse +#define yylex asn1p_lex +#define yyerror asn1p_error +#define yylval asn1p_lval +#define yychar asn1p_char +#define yydebug asn1p_debug +#define yynerrs asn1p_nerrs +#define TOK_PPEQ 257 +#define TOK_opaque 258 +#define TOK_bstring 259 +#define TOK_cstring 260 +#define TOK_hstring 261 +#define TOK_identifier 262 +#define TOK_number 263 +#define TOK_number_negative 264 +#define TOK_typereference 265 +#define TOK_objectclassreference 266 +#define TOK_typefieldreference 267 +#define TOK_valuefieldreference 268 +#define TOK_ABSENT 269 +#define TOK_ABSTRACT_SYNTAX 270 +#define TOK_ALL 271 +#define TOK_ANY 272 +#define TOK_APPLICATION 273 +#define TOK_AUTOMATIC 274 +#define TOK_BEGIN 275 +#define TOK_BIT 276 +#define TOK_BMPString 277 +#define TOK_BOOLEAN 278 +#define TOK_BY 279 +#define TOK_CHARACTER 280 +#define TOK_CHOICE 281 +#define TOK_CLASS 282 +#define TOK_COMPONENT 283 +#define TOK_COMPONENTS 284 +#define TOK_CONSTRAINED 285 +#define TOK_CONTAINING 286 +#define TOK_DEFAULT 287 +#define TOK_DEFINITIONS 288 +#define TOK_DEFINED 289 +#define TOK_EMBEDDED 290 +#define TOK_ENCODED 291 +#define TOK_END 292 +#define TOK_ENUMERATED 293 +#define TOK_EXPLICIT 294 +#define TOK_EXPORTS 295 +#define TOK_EXTENSIBILITY 296 +#define TOK_EXTERNAL 297 +#define TOK_FALSE 298 +#define TOK_FROM 299 +#define TOK_GeneralizedTime 300 +#define TOK_GeneralString 301 +#define TOK_GraphicString 302 +#define TOK_IA5String 303 +#define TOK_IDENTIFIER 304 +#define TOK_IMPLICIT 305 +#define TOK_IMPLIED 306 +#define TOK_IMPORTS 307 +#define TOK_INCLUDES 308 +#define TOK_INSTANCE 309 +#define TOK_INTEGER 310 +#define TOK_ISO646String 311 +#define TOK_MAX 312 +#define TOK_MIN 313 +#define TOK_MINUS_INFINITY 314 +#define TOK_NULL 315 +#define TOK_NumericString 316 +#define TOK_OBJECT 317 +#define TOK_ObjectDescriptor 318 +#define TOK_OCTET 319 +#define TOK_OF 320 +#define TOK_OPTIONAL 321 +#define TOK_PATTERN 322 +#define TOK_PDV 323 +#define TOK_PLUS_INFINITY 324 +#define TOK_PRESENT 325 +#define TOK_PrintableString 326 +#define TOK_PRIVATE 327 +#define TOK_REAL 328 +#define TOK_RELATIVE_OID 329 +#define TOK_SEQUENCE 330 +#define TOK_SET 331 +#define TOK_SIZE 332 +#define TOK_STRING 333 +#define TOK_SYNTAX 334 +#define TOK_T61String 335 +#define TOK_TAGS 336 +#define TOK_TeletexString 337 +#define TOK_TRUE 338 +#define TOK_TYPE_IDENTIFIER 339 +#define TOK_UNIQUE 340 +#define TOK_UNIVERSAL 341 +#define TOK_UniversalString 342 +#define TOK_UTCTime 343 +#define TOK_UTF8String 344 +#define TOK_VideotexString 345 +#define TOK_VisibleString 346 +#define TOK_WITH 347 +#define TOK_UNION 348 +#define TOK_INTERSECTION 349 +#define TOK_EXCEPT 350 +#define TOK_TwoDots 351 +#define TOK_ThreeDots 352 +#define TOK_tag 353 + +#line 1 "asn1p_y.y" + + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <errno.h> +#include <assert.h> + +#include "asn1parser.h" + +#define YYPARSE_PARAM param +#define YYERROR_VERBOSE + +int yylex(void); +int yyerror(const char *msg); +void asn1p_lexer_hack_push_opaque_state(void); +void asn1p_lexer_hack_enable_with_syntax(void); +#define yylineno asn1p_lineno +extern int asn1p_lineno; + + +static asn1p_value_t * + _convert_bitstring2binary(char *str, int base); + +#define checkmem(ptr) do { \ + if(!(ptr)) \ + return yyerror("Memory failure"); \ + } while(0) + +#define CONSTRAINT_INSERT(root, constr_type, arg1, arg2) do { \ + if(arg1->type != constr_type) { \ + int __ret; \ + root = asn1p_constraint_new(yylineno); \ + checkmem(root); \ + root->type = constr_type; \ + __ret = asn1p_constraint_insert(root, \ + arg1); \ + checkmem(__ret == 0); \ + } else { \ + root = arg1; \ + } \ + if(arg2) { \ + int __ret \ + = asn1p_constraint_insert(root, arg2); \ + checkmem(__ret == 0); \ + } \ + } while(0) + + +#line 57 "asn1p_y.y" +typedef union { + asn1p_t *a_grammar; + asn1p_module_flags_e a_module_flags; + asn1p_module_t *a_module; + asn1p_expr_type_e a_type; /* ASN.1 Type */ + asn1p_expr_t *a_expr; /* Constructed collection */ + asn1p_constraint_t *a_constr; /* Constraint */ + enum asn1p_constraint_type_e a_ctype;/* Constraint type */ + asn1p_xports_t *a_xports; /* IMports/EXports */ + asn1p_oid_t *a_oid; /* Object Identifier */ + asn1p_oid_arc_t a_oid_arc; /* Single OID's arc */ + struct asn1p_type_tag_s a_tag; /* A tag */ + asn1p_ref_t *a_ref; /* Reference to custom type */ + asn1p_wsyntx_t *a_wsynt; /* WITH SYNTAX contents */ + asn1p_wsyntx_chunk_t *a_wchunk; /* WITH SYNTAX chunk */ + struct asn1p_ref_component_s a_refcomp; /* Component of a reference */ + asn1p_value_t *a_value; /* Number, DefinedValue, etc */ + struct asn1p_param_s a_parg; /* A parameter argument */ + asn1p_paramlist_t *a_plist; /* A pargs list */ + enum asn1p_expr_marker_e a_marker; /* OPTIONAL/DEFAULT */ + enum asn1p_constr_pres_e a_pres; /* PRESENT/ABSENT/OPTIONAL */ + asn1_integer_t a_int; + char *tv_str; + struct { + char *buf; + int len; + } tv_opaque; + struct { + char *name; + struct asn1p_type_tag_s tag; + } tv_nametag; +} YYSTYPE; +#include <stdio.h> + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define YYFINAL 375 +#define YYFLAG -32768 +#define YYNTBASE 113 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 353 ? yytranslate[x] : 211) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 109, 2, 2, 2, 2, 2, 2, 104, + 105, 2, 2, 107, 2, 110, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 108, 106, 111, + 2, 2, 2, 112, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 96, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 102, 94, 103, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, 95, 97, 98, + 99, 100, 101 +}; + +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 2, 4, 7, 16, 17, 19, 23, 26, 28, + 31, 33, 38, 40, 41, 43, 45, 48, 51, 54, + 57, 60, 61, 63, 65, 68, 70, 72, 74, 76, + 78, 80, 84, 87, 89, 92, 97, 99, 103, 105, + 107, 111, 115, 118, 120, 124, 126, 128, 135, 137, + 139, 140, 142, 147, 152, 156, 163, 165, 169, 171, + 175, 179, 181, 185, 187, 189, 191, 195, 201, 202, + 204, 206, 210, 213, 217, 222, 223, 225, 226, 233, + 235, 238, 240, 242, 245, 247, 251, 253, 257, 261, + 263, 265, 267, 272, 274, 278, 280, 284, 288, 290, + 294, 296, 300, 302, 304, 306, 308, 313, 314, 318, + 320, 322, 324, 326, 328, 330, 334, 336, 339, 341, + 343, 345, 347, 350, 353, 355, 357, 360, 363, 365, + 367, 369, 371, 374, 376, 379, 381, 383, 385, 387, + 389, 391, 393, 395, 397, 399, 401, 403, 405, 407, + 412, 417, 422, 427, 432, 434, 439, 440, 442, 444, + 446, 448, 450, 452, 457, 459, 462, 466, 468, 472, + 478, 480, 484, 486, 488, 492, 494, 498, 500, 504, + 506, 510, 515, 517, 519, 521, 524, 527, 531, 533, + 535, 537, 539, 541, 543, 545, 547, 549, 555, 557, + 561, 563, 567, 568, 570, 572, 574, 576, 578, 580, + 584, 589, 591, 595, 598, 602, 604, 608, 609, 611, + 613, 616, 618, 620, 621, 625, 628, 632, 634, 638, + 640, 645, 650, 652, 654, 656, 658, 659, 661, 663, + 666, 669, 671, 673, 675, 677, 679 +}; + +static const short yyrhs[] = { 114, + 0, 115, 0, 114, 115, 0, 207, 116, 34, 120, + 3, 21, 123, 38, 0, 0, 117, 0, 102, 118, + 103, 0, 102, 103, 0, 119, 0, 118, 119, 0, + 209, 0, 209, 104, 9, 105, 0, 9, 0, 0, + 121, 0, 122, 0, 121, 122, 0, 40, 82, 0, + 51, 82, 0, 20, 82, 0, 42, 52, 0, 0, + 124, 0, 125, 0, 124, 125, 0, 126, 0, 131, + 0, 137, 0, 161, 0, 134, 0, 169, 0, 53, + 127, 106, 0, 53, 45, 0, 128, 0, 127, 128, + 0, 129, 45, 207, 116, 0, 130, 0, 129, 107, + 130, 0, 207, 0, 209, 0, 41, 132, 106, 0, + 41, 17, 106, 0, 41, 106, 0, 133, 0, 132, + 107, 133, 0, 207, 0, 209, 0, 207, 135, 3, + 102, 136, 103, 0, 156, 0, 166, 0, 0, 177, + 0, 207, 3, 205, 85, 0, 207, 3, 205, 153, + 0, 207, 3, 143, 0, 207, 102, 138, 103, 3, + 153, 0, 139, 0, 138, 107, 139, 0, 207, 0, + 207, 108, 209, 0, 166, 108, 209, 0, 141, 0, + 140, 107, 141, 0, 155, 0, 209, 0, 152, 0, + 142, 107, 152, 0, 28, 102, 145, 103, 147, 0, + 0, 86, 0, 146, 0, 145, 107, 146, 0, 159, + 197, 0, 159, 153, 144, 0, 159, 159, 197, 144, + 0, 0, 148, 0, 0, 93, 80, 102, 149, 150, + 103, 0, 151, 0, 150, 151, 0, 4, 0, 159, + 0, 210, 153, 0, 154, 0, 155, 171, 197, 0, + 100, 0, 100, 109, 164, 0, 100, 109, 204, 0, + 168, 0, 169, 0, 170, 0, 207, 102, 140, 103, + 0, 156, 0, 55, 66, 156, 0, 11, 0, 11, + 110, 207, 0, 11, 110, 209, 0, 208, 0, 208, + 110, 157, 0, 158, 0, 157, 110, 158, 0, 160, + 0, 160, 0, 13, 0, 14, 0, 209, 135, 3, + 162, 0, 0, 102, 163, 165, 0, 5, 0, 7, + 0, 6, 0, 204, 0, 164, 0, 209, 0, 207, + 110, 209, 0, 4, 0, 165, 4, 0, 24, 0, + 61, 0, 74, 0, 167, 0, 65, 79, 0, 63, + 50, 0, 75, 0, 43, 0, 36, 69, 0, 26, + 79, 0, 89, 0, 46, 0, 56, 0, 39, 0, + 22, 79, 0, 166, 0, 167, 201, 0, 23, 0, + 47, 0, 48, 0, 49, 0, 57, 0, 62, 0, + 72, 0, 81, 0, 83, 0, 88, 0, 90, 0, + 91, 0, 92, 0, 64, 0, 27, 102, 142, 103, + 0, 76, 102, 142, 103, 0, 77, 102, 142, 103, + 0, 76, 171, 66, 155, 0, 77, 171, 66, 155, + 0, 18, 0, 18, 35, 25, 209, 0, 0, 175, + 0, 94, 0, 95, 0, 96, 0, 97, 0, 98, + 0, 78, 104, 177, 105, 0, 176, 0, 175, 176, + 0, 104, 177, 105, 0, 178, 0, 178, 107, 100, + 0, 178, 107, 100, 107, 178, 0, 100, 0, 100, + 107, 178, 0, 179, 0, 180, 0, 179, 172, 180, + 0, 181, 0, 180, 173, 181, 0, 182, 0, 181, + 174, 182, 0, 185, 0, 185, 183, 185, 0, 184, + 104, 177, 105, 0, 191, 0, 186, 0, 99, 0, + 99, 111, 0, 111, 99, 0, 111, 99, 111, 0, + 78, 0, 45, 0, 204, 0, 209, 0, 6, 0, + 59, 0, 58, 0, 44, 0, 84, 0, 93, 30, + 102, 187, 103, 0, 188, 0, 187, 107, 188, 0, + 100, 0, 209, 171, 189, 0, 0, 190, 0, 71, + 0, 15, 0, 67, 0, 192, 0, 193, 0, 102, + 207, 103, 0, 192, 102, 194, 103, 0, 195, 0, + 194, 107, 195, 0, 112, 196, 0, 112, 110, 196, + 0, 209, 0, 196, 110, 209, 0, 0, 198, 0, + 67, 0, 33, 199, 0, 185, 0, 166, 0, 0, + 102, 200, 165, 0, 102, 103, 0, 102, 202, 103, + 0, 203, 0, 202, 107, 203, 0, 209, 0, 209, + 104, 204, 105, 0, 209, 104, 164, 105, 0, 204, + 0, 100, 0, 9, 0, 10, 0, 0, 206, 0, + 101, 0, 101, 51, 0, 101, 40, 0, 11, 0, + 12, 0, 12, 0, 8, 0, 209, 0, 209, 206, + 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 297, 303, 309, 325, 350, 352, 355, 359, 364, 371, + 379, 384, 388, 397, 399, 407, 411, 419, 423, 426, + 429, 437, 439, 448, 452, 477, 481, 490, 497, 510, + 521, 534, 541, 546, 552, 558, 567, 573, 579, 586, + 594, 598, 601, 608, 614, 620, 627, 636, 646, 654, + 662, 664, 676, 688, 695, 711, 721, 731, 741, 746, + 753, 763, 769, 775, 779, 791, 797, 803, 813, 815, + 818, 826, 832, 841, 846, 863, 865, 870, 874, 879, + 884, 890, 894, 919, 926, 931, 939, 948, 957, 968, + 972, 978, 986, 1010, 1017, 1031, 1040, 1050, 1060, 1068, + 1089, 1098, 1107, 1108, 1110, 1117, 1129, 1139, 1141, 1146, + 1150, 1154, 1158, 1161, 1166, 1178, 1194, 1205, 1219, 1221, + 1222, 1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 1231, + 1237, 1239, 1240, 1243, 1250, 1262, 1264, 1268, 1272, 1273, + 1274, 1275, 1276, 1280, 1281, 1282, 1283, 1287, 1288, 1291, + 1298, 1304, 1310, 1318, 1326, 1332, 1348, 1350, 1353, 1353, + 1354, 1354, 1355, 1357, 1370, 1373, 1378, 1384, 1388, 1395, + 1403, 1408, 1417, 1419, 1421, 1426, 1428, 1434, 1436, 1441, + 1448, 1455, 1463, 1466, 1471, 1473, 1474, 1475, 1478, 1482, + 1487, 1491, 1502, 1506, 1511, 1516, 1521, 1528, 1534, 1538, + 1543, 1549, 1561, 1563, 1566, 1570, 1573, 1578, 1582, 1590, + 1605, 1611, 1618, 1631, 1643, 1658, 1662, 1679, 1681, 1684, + 1688, 1694, 1697, 1699, 1699, 1719, 1724, 1729, 1735, 1741, + 1749, 1757, 1765, 1772, 1782, 1787, 1817, 1819, 1822, 1827, + 1831, 1837, 1842, 1848, 1855, 1862, 1867 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","TOK_PPEQ", +"TOK_opaque","TOK_bstring","TOK_cstring","TOK_hstring","TOK_identifier","TOK_number", +"TOK_number_negative","TOK_typereference","TOK_objectclassreference","TOK_typefieldreference", +"TOK_valuefieldreference","TOK_ABSENT","TOK_ABSTRACT_SYNTAX","TOK_ALL","TOK_ANY", +"TOK_APPLICATION","TOK_AUTOMATIC","TOK_BEGIN","TOK_BIT","TOK_BMPString","TOK_BOOLEAN", +"TOK_BY","TOK_CHARACTER","TOK_CHOICE","TOK_CLASS","TOK_COMPONENT","TOK_COMPONENTS", +"TOK_CONSTRAINED","TOK_CONTAINING","TOK_DEFAULT","TOK_DEFINITIONS","TOK_DEFINED", +"TOK_EMBEDDED","TOK_ENCODED","TOK_END","TOK_ENUMERATED","TOK_EXPLICIT","TOK_EXPORTS", +"TOK_EXTENSIBILITY","TOK_EXTERNAL","TOK_FALSE","TOK_FROM","TOK_GeneralizedTime", +"TOK_GeneralString","TOK_GraphicString","TOK_IA5String","TOK_IDENTIFIER","TOK_IMPLICIT", +"TOK_IMPLIED","TOK_IMPORTS","TOK_INCLUDES","TOK_INSTANCE","TOK_INTEGER","TOK_ISO646String", +"TOK_MAX","TOK_MIN","TOK_MINUS_INFINITY","TOK_NULL","TOK_NumericString","TOK_OBJECT", +"TOK_ObjectDescriptor","TOK_OCTET","TOK_OF","TOK_OPTIONAL","TOK_PATTERN","TOK_PDV", +"TOK_PLUS_INFINITY","TOK_PRESENT","TOK_PrintableString","TOK_PRIVATE","TOK_REAL", +"TOK_RELATIVE_OID","TOK_SEQUENCE","TOK_SET","TOK_SIZE","TOK_STRING","TOK_SYNTAX", +"TOK_T61String","TOK_TAGS","TOK_TeletexString","TOK_TRUE","TOK_TYPE_IDENTIFIER", +"TOK_UNIQUE","TOK_UNIVERSAL","TOK_UniversalString","TOK_UTCTime","TOK_UTF8String", +"TOK_VideotexString","TOK_VisibleString","TOK_WITH","'|'","TOK_UNION","'^'", +"TOK_INTERSECTION","TOK_EXCEPT","TOK_TwoDots","TOK_ThreeDots","TOK_tag","'{'", +"'}'","'('","')'","';'","','","':'","'!'","'.'","'<'","'@'","ParsedGrammar", +"ModuleList","ModuleSpecification","optObjectIdentifier","ObjectIdentifier", +"ObjectIdentifierBody","ObjectIdentifierElement","optModuleSpecificationFlags", +"ModuleSpecificationFlags","ModuleSpecificationFlag","optModuleSpecificationBody", +"ModuleSpecificationBody","ModuleSpecificationElement","ImportsDefinition","ImportsBundleSet", +"ImportsBundle","ImportsList","ImportsElement","ExportsDefinition","ExportsBody", +"ExportsElement","ValueSetDefinition","DefinedTypeRef","optValueSetBody","DataTypeReference", +"ParameterArgumentList","ParameterArgumentName","ActualParameterList","ActualParameter", +"ConstructedDataTypeDefinition","ClassDeclaration","optUnique","ClassFieldList", +"ClassField","optWithSyntax","WithSyntax","@1","WithSyntaxFormat","WithSyntaxFormatToken", +"DataTypeMember","ConstrainedTypeDeclaration","ExtensionAndException","TypeDeclaration", +"ComplexTypeReference","ComplexTypeReferenceAmpList","ComplexTypeReferenceElement", +"ClassFieldIdentifier","ClassFieldName","ValueDefinition","InlineOrDefinedValue", +"@2","DefinedValue","Opaque","BasicTypeId","BasicTypeId_UniverationCompatible", +"BasicType","BasicString","ConstructedType","optConstraints","Union","Intersection", +"Except","Constraints","SingleConstraint","ConstraintElementSet","ConstraintElement", +"ConstraintElementUnion","ConstraintElementIntersection","ConstraintElementException", +"ConstraintSubtypeElement","ConstraintRangeSpec","ConstraintSpec","ConstraintValue", +"WithComponents","WithComponentsList","WithComponentsElement","optPresenceConstraint", +"PresenceConstraint","TableConstraint","SimpleTableConstraint","ComponentRelationConstraint", +"AtNotationList","AtNotationElement","ComponentIdList","optMarker","Marker", +"DefaultValue","@3","UniverationDefinition","UniverationList","UniverationElement", +"SignedNumber","optTag","Tag","TypeRefName","ObjectClassReference","Identifier", +"TaggedIdentifier", NULL +}; +#endif + +static const short yyr1[] = { 0, + 113, 114, 114, 115, 116, 116, 117, 117, 118, 118, + 119, 119, 119, 120, 120, 121, 121, 122, 122, 122, + 122, 123, 123, 124, 124, 125, 125, 125, 125, 125, + 125, 126, 126, 127, 127, 128, 129, 129, 130, 130, + 131, 131, 131, 132, 132, 133, 133, 134, 135, 135, + 136, 136, 137, 137, 137, 137, 138, 138, 139, 139, + 139, 140, 140, 141, 141, 142, 142, 143, 144, 144, + 145, 145, 146, 146, 146, 147, 147, 149, 148, 150, + 150, 151, 151, 152, 152, 153, 154, 154, 154, 155, + 155, 155, 155, 155, 155, 156, 156, 156, 156, 156, + 157, 157, 158, 159, 160, 160, 161, 163, 162, 162, + 162, 162, 162, 162, 164, 164, 165, 165, 166, 166, + 166, 166, 166, 166, 166, 166, 166, 166, 166, 166, + 167, 167, 167, 168, 168, 169, 169, 169, 169, 169, + 169, 169, 169, 169, 169, 169, 169, 169, 169, 170, + 170, 170, 170, 170, 170, 170, 171, 171, 172, 172, + 173, 173, 174, 175, 175, 175, 176, 177, 177, 177, + 177, 177, 178, 179, 179, 180, 180, 181, 181, 182, + 182, 182, 182, 182, 183, 183, 183, 183, 184, 184, + 185, 185, 185, 185, 185, 185, 185, 186, 187, 187, + 188, 188, 189, 189, 190, 190, 190, 191, 191, 192, + 193, 194, 194, 195, 195, 196, 196, 197, 197, 198, + 198, 199, 199, 200, 199, 201, 201, 202, 202, 203, + 203, 203, 203, 203, 204, 204, 205, 205, 206, 206, + 206, 207, 207, 208, 209, 210, 210 +}; + +static const short yyr2[] = { 0, + 1, 1, 2, 8, 0, 1, 3, 2, 1, 2, + 1, 4, 1, 0, 1, 1, 2, 2, 2, 2, + 2, 0, 1, 1, 2, 1, 1, 1, 1, 1, + 1, 3, 2, 1, 2, 4, 1, 3, 1, 1, + 3, 3, 2, 1, 3, 1, 1, 6, 1, 1, + 0, 1, 4, 4, 3, 6, 1, 3, 1, 3, + 3, 1, 3, 1, 1, 1, 3, 5, 0, 1, + 1, 3, 2, 3, 4, 0, 1, 0, 6, 1, + 2, 1, 1, 2, 1, 3, 1, 3, 3, 1, + 1, 1, 4, 1, 3, 1, 3, 3, 1, 3, + 1, 3, 1, 1, 1, 1, 4, 0, 3, 1, + 1, 1, 1, 1, 1, 3, 1, 2, 1, 1, + 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, + 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, + 4, 4, 4, 4, 1, 4, 0, 1, 1, 1, + 1, 1, 1, 4, 1, 2, 3, 1, 3, 5, + 1, 3, 1, 1, 3, 1, 3, 1, 3, 1, + 3, 4, 1, 1, 1, 2, 2, 3, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 5, 1, 3, + 1, 3, 0, 1, 1, 1, 1, 1, 1, 3, + 4, 1, 3, 2, 3, 1, 3, 0, 1, 1, + 2, 1, 1, 0, 3, 2, 3, 1, 3, 1, + 4, 4, 1, 1, 1, 1, 0, 1, 1, 2, + 2, 1, 1, 1, 1, 1, 2 +}; + +static const short yydefact[] = { 0, + 242, 243, 1, 2, 5, 3, 0, 0, 6, 245, + 13, 8, 0, 9, 11, 14, 7, 10, 0, 0, + 0, 0, 0, 0, 15, 16, 0, 20, 18, 21, + 19, 0, 17, 12, 22, 136, 0, 137, 138, 139, + 0, 140, 141, 149, 142, 143, 144, 145, 146, 147, + 148, 0, 23, 24, 26, 27, 30, 28, 29, 31, + 0, 0, 0, 43, 0, 44, 46, 47, 33, 0, + 34, 0, 37, 39, 40, 4, 25, 237, 96, 244, + 0, 119, 0, 0, 132, 126, 130, 131, 120, 0, + 0, 121, 125, 129, 0, 0, 49, 50, 122, 99, + 0, 42, 41, 0, 32, 35, 0, 0, 0, 239, + 55, 0, 238, 0, 133, 128, 127, 124, 123, 0, + 57, 0, 59, 0, 0, 0, 45, 5, 38, 0, + 241, 240, 96, 244, 155, 0, 0, 157, 157, 53, + 54, 157, 94, 134, 122, 90, 91, 92, 0, 97, + 98, 0, 0, 0, 0, 51, 105, 106, 100, 101, + 103, 110, 112, 111, 235, 236, 108, 107, 114, 113, + 0, 115, 36, 0, 71, 218, 104, 0, 0, 0, + 0, 0, 0, 0, 158, 165, 0, 0, 218, 0, + 135, 0, 0, 58, 61, 60, 193, 196, 190, 195, + 194, 189, 197, 0, 171, 0, 0, 52, 168, 173, + 174, 176, 178, 0, 180, 184, 183, 208, 209, 191, + 192, 0, 0, 0, 76, 0, 0, 220, 69, 218, + 73, 219, 0, 87, 0, 66, 85, 246, 0, 95, + 0, 0, 0, 0, 166, 0, 0, 86, 234, 226, + 0, 228, 233, 230, 0, 62, 64, 65, 56, 0, + 0, 0, 48, 0, 159, 160, 0, 161, 162, 0, + 163, 0, 0, 185, 0, 0, 0, 102, 117, 109, + 116, 0, 68, 77, 72, 224, 223, 222, 221, 70, + 74, 69, 156, 0, 150, 0, 247, 84, 0, 151, + 167, 153, 152, 154, 227, 0, 0, 93, 0, 0, + 172, 210, 169, 175, 177, 179, 0, 186, 187, 181, + 0, 0, 212, 118, 0, 0, 75, 88, 89, 67, + 164, 229, 0, 0, 63, 201, 0, 199, 157, 0, + 182, 188, 0, 214, 216, 211, 0, 78, 225, 232, + 231, 198, 0, 203, 170, 215, 0, 213, 0, 200, + 206, 207, 205, 202, 204, 217, 82, 0, 80, 83, + 79, 81, 0, 0, 0 +}; + +static const short yydefgoto[] = { 373, + 3, 4, 8, 9, 13, 14, 24, 25, 26, 52, + 53, 54, 55, 70, 71, 72, 73, 56, 65, 66, + 57, 96, 207, 58, 120, 121, 255, 256, 235, 111, + 291, 174, 175, 283, 284, 359, 368, 369, 236, 141, + 237, 142, 143, 159, 160, 176, 177, 59, 168, 223, + 169, 280, 144, 145, 146, 147, 148, 184, 267, 270, + 272, 185, 186, 208, 209, 210, 211, 212, 213, 276, + 214, 215, 216, 337, 338, 364, 365, 217, 218, 219, + 322, 323, 344, 231, 232, 289, 326, 191, 251, 252, + 220, 112, 113, 149, 100, 221, 239 +}; + +static const short yypact[] = { 81, +-32768,-32768, 81,-32768, -45,-32768, 23, 70,-32768,-32768, +-32768,-32768, 47,-32768, 31, 190,-32768,-32768, 132, 61, + 69, 108, 86, 176, 190,-32768, 76,-32768,-32768,-32768, +-32768, 166,-32768,-32768, 442,-32768, 32,-32768,-32768,-32768, + 121,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768, 168, 442,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 179, 732, 103,-32768, 52,-32768,-32768,-32768,-32768, 39, +-32768, 16,-32768,-32768,-32768,-32768,-32768, -11, 111,-32768, + 150,-32768, 152, 142,-32768,-32768,-32768,-32768,-32768, 184, + 159,-32768,-32768,-32768, 748, 240,-32768,-32768,-32768, 135, + 243,-32768,-32768, 141,-32768,-32768, 81, 141, 145, 60, +-32768, 599,-32768, 141,-32768,-32768,-32768,-32768,-32768, -1, +-32768, 143, 144, 147, 206, 68,-32768, -45,-32768, 206, +-32768,-32768, -42, 148, 221, 161, 198, 40, 53,-32768, +-32768, -37,-32768,-32768, 163,-32768,-32768,-32768, 164,-32768, +-32768, 264, 748, 261, 261, 155,-32768,-32768, 160,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 162,-32768,-32768, 64,-32768, 524,-32768, 246, 21, 212, + 169, 21, 155, 208, 171,-32768, 21, 210, 2, 17, +-32768, 383, 674,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768, 247, 172, 81, 175,-32768, 173, 133, + 140, 185,-32768, 178, 35,-32768,-32768, 182,-32768,-32768, +-32768, 206, 281, 261, 193, 206, 301,-32768, 202, 2, +-32768,-32768, 261, 181, 66,-32768,-32768, 191, 674,-32768, + 155, 71, 186, 674,-32768, 89, 674,-32768,-32768,-32768, + 90,-32768,-32768, 189, 91,-32768,-32768,-32768,-32768, 192, + 309, 194,-32768, 196,-32768,-32768, 309,-32768,-32768, 309, +-32768, 309, 155, 187, 205, 78, 200,-32768,-32768, 297, +-32768, 225,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768, 202,-32768, 250,-32768, 21,-32768,-32768, 201,-32768, +-32768,-32768,-32768,-32768,-32768, 56, 250,-32768, 383, 25, +-32768,-32768, 209, 140, 185,-32768, 215,-32768, 211,-32768, + 6, 101,-32768,-32768, 219, 281,-32768,-32768,-32768,-32768, +-32768,-32768, 223, 224,-32768,-32768, 109,-32768, -37, 309, +-32768,-32768, 261, 203,-32768,-32768, 200,-32768, 297,-32768, +-32768,-32768, 25, 24,-32768, 203, 261,-32768, 126,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768, 9,-32768,-32768, +-32768,-32768, 324, 326,-32768 +}; + +static const short yypgoto[] = {-32768, +-32768, 327, 204,-32768,-32768, 318,-32768,-32768, 308,-32768, +-32768, 282,-32768,-32768, 268,-32768, 226,-32768,-32768, 235, +-32768, 279,-32768,-32768,-32768, 195,-32768, 33, -129,-32768, + 51,-32768, 123,-32768,-32768,-32768,-32768, -17, 59, -156, +-32768, -185, -52,-32768, 130, -173, -109,-32768,-32768,-32768, + -209, 30, -50, -43,-32768, 46,-32768, -137,-32768,-32768, +-32768,-32768, 180, -159, -246,-32768, 94, 88, 97,-32768, +-32768, -206,-32768,-32768, 10,-32768,-32768,-32768,-32768,-32768, +-32768, 26, 27, -141,-32768,-32768,-32768,-32768,-32768, 65, + -118,-32768, 134, 1,-32768, -7,-32768 +}; + + +#define YYLAST 837 + + +static const short yytable[] = { 15, + 5, 188, 230, 5, 189, 15, 257, 170, 97, 97, + 98, 98, 367, 10, 311, 161, 109, 99, 99, 229, + 288, 157, 158, 243, 10, 165, 166, 62, 10, 68, + 10, 11, 10, 75, 227, 61, 259, 67, 361, 10, + 181, 74, 1, 2, 122, 62, 10, 248, 63, 1, + 2, 99, 242, 61, 10, 11, 7, 246, 302, -242, + 107, 304, 75, 10, 165, 166, 183, 114, 228, 320, + 74, 253, 162, 163, 164, 10, 165, 166, 1, 2, + 60, 299, 298, 197, 328, 10, 165, 166, 292, 110, + 362, 1, 2, 355, 363, 123, 68, 333, 60, 131, + 75, 152, 122, 16, 67, 153, 151, 128, 74, 99, + 132, 371, 161, 317, 150, 343, 249, 181, 172, 250, + 234, 198, 108, 257, 336, 12, 171, 240, 10, 367, + 181, 1, 2, 274, 19, 200, 201, 64, 157, 158, + 27, 182, 28, 183, 105, 275, 195, 196, 10, 17, + 29, 1, 2, 123, 187, 249, 183, 103, 104, 30, + 197, 203, 10, 165, 166, 69, 225, 31, 295, 167, + 226, 238, 296, 300, 238, 329, 287, 296, 32, 238, + 34, 78, 254, 99, 258, 370, 35, 253, 334, 79, + 80, 303, 305, 308, 370, 296, 306, 309, 198, 199, + 81, 354, 82, 346, 83, 76, 262, 347, 102, 20, + 117, 352, 200, 201, 84, 353, 281, 85, 157, 158, + 114, 86, 79, 80, 87, 293, 265, 266, 115, 21, + 116, 22, 202, 118, 88, 268, 269, 119, 203, 89, + 23, 90, 124, 91, 125, 126, 130, 204, 156, -243, + 154, 155, 92, 93, 205, 178, 206, 10, 165, 166, + 1, 2, 179, 180, 190, 192, 193, 94, 10, 222, + 233, 224, 241, 244, 183, 247, 260, 263, 261, 264, + 95, 273, 271, 277, 279, 282, 172, 290, 238, 294, + 301, 110, 307, 310, 171, 313, 312, 318, 254, 172, + 324, 258, 339, 319, 325, 331, 197, 171, 10, 165, + 166, 321, 357, 345, 197, 340, 10, 165, 166, 341, + 348, 342, 81, 374, 82, 375, 83, 350, 351, 6, + 18, 173, 33, 129, 77, 345, 84, 106, 127, 85, + 101, 335, 327, 86, 198, 339, 87, 194, 285, 366, + 372, 278, 198, 199, 330, 349, 88, 315, 200, 201, + 314, 89, 360, 90, 245, 91, 200, 201, 316, 356, + 332, 297, 358, 0, 92, 93, 0, 0, 0, 0, + 0, 0, 0, 0, 203, 0, 202, 0, 0, 94, + 10, 0, 203, 133, 134, 0, 0, 0, 0, 0, + 135, 204, 286, 0, 81, 36, 82, 0, 83, 136, + 206, 0, 0, 0, 0, 0, 0, 0, 84, 0, + 0, 85, 0, 0, 0, 86, 0, 0, 87, 38, + 39, 40, 0, 0, 0, 0, 0, 137, 88, 42, + 0, 0, 0, 89, 43, 90, 44, 91, 0, 10, + 0, 0, 1, 2, 45, 0, 92, 93, 138, 139, + 0, 0, 0, 46, 36, 47, 0, 0, 0, 0, + 48, 94, 49, 50, 51, 0, 0, 0, 0, 0, + 0, 0, 37, 0, 0, 0, 0, 0, 38, 39, + 40, 0, 0, 0, 41, 0, 0, 0, 42, 0, + 0, 0, 0, 43, 0, 44, 0, 0, 0, 0, + 0, 0, 0, 45, 0, 0, 0, 0, 0, 0, + 0, 0, 46, 0, 47, 0, 0, 0, 0, 48, + 0, 49, 50, 51, 133, 134, 157, 158, 0, 0, + 0, 135, 0, 0, 0, 81, 36, 82, 0, 83, + 136, 0, 0, 0, 0, 0, 227, 0, 0, 84, + 0, 0, 85, 0, 0, 0, 86, 0, 0, 87, + 38, 39, 40, 0, 0, 0, 0, 0, 137, 88, + 42, 0, 0, 0, 89, 43, 90, 44, 91, 0, + 228, 0, 0, 0, 0, 45, 0, 92, 93, 138, + 139, 0, 0, 0, 46, 0, 47, 0, 0, 133, + 134, 48, 94, 49, 50, 51, 135, 0, 0, 0, + 81, 36, 82, 0, 83, 136, 0, 0, 0, 0, + 0, 0, 0, 0, 84, 0, 0, 85, 0, 0, + 0, 86, 0, 0, 87, 38, 39, 40, 0, 0, + 0, 0, 0, 137, 88, 42, 0, 0, 0, 89, + 43, 90, 44, 91, 0, 0, 0, 0, 0, 0, + 45, 0, 92, 93, 138, 139, 0, 0, 0, 46, + 0, 47, 0, 140, 133, 134, 48, 94, 49, 50, + 51, 135, 0, 0, 0, 81, 36, 82, 0, 83, + 136, 0, 0, 0, 0, 0, 0, 0, 0, 84, + 0, 0, 85, 0, 0, 0, 86, 0, 0, 87, + 38, 39, 40, 0, 0, 0, 0, 0, 137, 88, + 42, 0, 0, 0, 89, 43, 90, 44, 91, 0, + 0, 0, 79, 80, 0, 45, 0, 92, 93, 138, + 139, 0, 0, 81, 46, 82, 47, 83, 1, 2, + 0, 48, 94, 49, 50, 51, 0, 84, 0, 81, + 85, 82, 0, 83, 86, 0, 0, 87, 0, 0, + 0, 0, 0, 84, 0, 0, 85, 88, 0, 0, + 86, 0, 89, 87, 90, 0, 91, 0, 0, 0, + 0, 0, 0, 88, 0, 92, 93, 0, 89, 0, + 90, 0, 91, 0, 0, 0, 0, 0, 0, 0, + 94, 92, 93, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 94 +}; + +static const short yycheck[] = { 7, + 0, 139, 176, 3, 142, 13, 192, 126, 61, 62, + 61, 62, 4, 8, 261, 125, 28, 61, 62, 176, + 227, 13, 14, 183, 8, 9, 10, 35, 8, 37, + 8, 9, 8, 41, 33, 35, 193, 37, 15, 8, + 78, 41, 11, 12, 95, 53, 8, 189, 17, 11, + 12, 95, 182, 53, 8, 9, 102, 187, 244, 102, + 45, 247, 70, 8, 9, 10, 104, 110, 67, 276, + 70, 190, 5, 6, 7, 8, 9, 10, 11, 12, + 35, 241, 239, 6, 294, 8, 9, 10, 230, 101, + 67, 11, 12, 340, 71, 95, 104, 307, 53, 40, + 108, 103, 153, 34, 104, 107, 114, 107, 108, 153, + 51, 103, 222, 273, 114, 110, 100, 78, 126, 103, + 100, 44, 107, 309, 100, 103, 126, 180, 8, 4, + 78, 11, 12, 99, 104, 58, 59, 106, 13, 14, + 9, 102, 82, 104, 106, 111, 154, 155, 8, 103, + 82, 11, 12, 153, 102, 100, 104, 106, 107, 52, + 6, 84, 8, 9, 10, 45, 103, 82, 103, 102, + 107, 179, 107, 103, 182, 294, 227, 107, 3, 187, + 105, 3, 190, 227, 192, 359, 21, 306, 307, 11, + 12, 103, 103, 103, 368, 107, 107, 107, 44, 45, + 22, 339, 24, 103, 26, 38, 206, 107, 106, 20, + 69, 103, 58, 59, 36, 107, 224, 39, 13, 14, + 110, 43, 11, 12, 46, 233, 94, 95, 79, 40, + 79, 42, 78, 50, 56, 96, 97, 79, 84, 61, + 51, 63, 3, 65, 110, 3, 102, 93, 102, 102, + 108, 108, 74, 75, 100, 35, 102, 8, 9, 10, + 11, 12, 102, 66, 102, 102, 3, 89, 8, 110, + 25, 110, 104, 66, 104, 66, 30, 103, 107, 107, + 102, 104, 98, 102, 4, 93, 294, 86, 296, 109, + 105, 101, 104, 102, 294, 100, 103, 111, 306, 307, + 4, 309, 310, 99, 80, 105, 6, 307, 8, 9, + 10, 112, 110, 321, 6, 107, 8, 9, 10, 105, + 102, 111, 22, 0, 24, 0, 26, 105, 105, 3, + 13, 128, 25, 108, 53, 343, 36, 70, 104, 39, + 62, 309, 292, 43, 44, 353, 46, 153, 226, 357, + 368, 222, 44, 45, 296, 326, 56, 270, 58, 59, + 267, 61, 353, 63, 185, 65, 58, 59, 272, 343, + 306, 238, 347, -1, 74, 75, -1, -1, -1, -1, + -1, -1, -1, -1, 84, -1, 78, -1, -1, 89, + 8, -1, 84, 11, 12, -1, -1, -1, -1, -1, + 18, 93, 102, -1, 22, 23, 24, -1, 26, 27, + 102, -1, -1, -1, -1, -1, -1, -1, 36, -1, + -1, 39, -1, -1, -1, 43, -1, -1, 46, 47, + 48, 49, -1, -1, -1, -1, -1, 55, 56, 57, + -1, -1, -1, 61, 62, 63, 64, 65, -1, 8, + -1, -1, 11, 12, 72, -1, 74, 75, 76, 77, + -1, -1, -1, 81, 23, 83, -1, -1, -1, -1, + 88, 89, 90, 91, 92, -1, -1, -1, -1, -1, + -1, -1, 41, -1, -1, -1, -1, -1, 47, 48, + 49, -1, -1, -1, 53, -1, -1, -1, 57, -1, + -1, -1, -1, 62, -1, 64, -1, -1, -1, -1, + -1, -1, -1, 72, -1, -1, -1, -1, -1, -1, + -1, -1, 81, -1, 83, -1, -1, -1, -1, 88, + -1, 90, 91, 92, 11, 12, 13, 14, -1, -1, + -1, 18, -1, -1, -1, 22, 23, 24, -1, 26, + 27, -1, -1, -1, -1, -1, 33, -1, -1, 36, + -1, -1, 39, -1, -1, -1, 43, -1, -1, 46, + 47, 48, 49, -1, -1, -1, -1, -1, 55, 56, + 57, -1, -1, -1, 61, 62, 63, 64, 65, -1, + 67, -1, -1, -1, -1, 72, -1, 74, 75, 76, + 77, -1, -1, -1, 81, -1, 83, -1, -1, 11, + 12, 88, 89, 90, 91, 92, 18, -1, -1, -1, + 22, 23, 24, -1, 26, 27, -1, -1, -1, -1, + -1, -1, -1, -1, 36, -1, -1, 39, -1, -1, + -1, 43, -1, -1, 46, 47, 48, 49, -1, -1, + -1, -1, -1, 55, 56, 57, -1, -1, -1, 61, + 62, 63, 64, 65, -1, -1, -1, -1, -1, -1, + 72, -1, 74, 75, 76, 77, -1, -1, -1, 81, + -1, 83, -1, 85, 11, 12, 88, 89, 90, 91, + 92, 18, -1, -1, -1, 22, 23, 24, -1, 26, + 27, -1, -1, -1, -1, -1, -1, -1, -1, 36, + -1, -1, 39, -1, -1, -1, 43, -1, -1, 46, + 47, 48, 49, -1, -1, -1, -1, -1, 55, 56, + 57, -1, -1, -1, 61, 62, 63, 64, 65, -1, + -1, -1, 11, 12, -1, 72, -1, 74, 75, 76, + 77, -1, -1, 22, 81, 24, 83, 26, 11, 12, + -1, 88, 89, 90, 91, 92, -1, 36, -1, 22, + 39, 24, -1, 26, 43, -1, -1, 46, -1, -1, + -1, -1, -1, 36, -1, -1, 39, 56, -1, -1, + 43, -1, 61, 46, 63, -1, 65, -1, -1, -1, + -1, -1, -1, 56, -1, 74, 75, -1, 61, -1, + 63, -1, 65, -1, -1, -1, -1, -1, -1, -1, + 89, 74, 75, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 89 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/share/bison.simple" +/* This file comes from bison-1.28. */ + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define YYSTACK_USE_ALLOCA +#include <alloca.h> +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include <malloc.h> +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include <malloc.h> */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { yyerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX yylex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval, &yylloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +/* Define __yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (char *to, char *from, unsigned int count) +{ + register char *t = to; + register char *f = from; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 217 "/usr/share/bison.simple" + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +#ifdef YYPARSE_PARAM +int yyparse (void *); +#else +int yyparse (void); +#endif +#endif + +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +#define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + int yystacksize = YYINITDEPTH; + int yyfree_stacks = 0; + +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss - 1; + yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 2; + } + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; +#ifndef YYSTACK_USE_ALLOCA + yyfree_stacks = 1; +#endif + yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, + size * (unsigned int) sizeof (*yyssp)); + yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, + size * (unsigned int) sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, + size * (unsigned int) sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + + goto yybackup; + yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (yydebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + + switch (yyn) { + +case 1: +#line 298 "asn1p_y.y" +{ + *(void **)param = yyvsp[0].a_grammar; + ; + break;} +case 2: +#line 304 "asn1p_y.y" +{ + yyval.a_grammar = asn1p_new(); + checkmem(yyval.a_grammar); + TQ_ADD(&(yyval.a_grammar->modules), yyvsp[0].a_module, mod_next); + ; + break;} +case 3: +#line 309 "asn1p_y.y" +{ + yyval.a_grammar = yyvsp[-1].a_grammar; + TQ_ADD(&(yyval.a_grammar->modules), yyvsp[0].a_module, mod_next); + ; + break;} +case 4: +#line 330 "asn1p_y.y" +{ + + if(yyvsp[-1].a_module) { + yyval.a_module = yyvsp[-1].a_module; + } else { + /* There's a chance that a module is just plain empty */ + yyval.a_module = asn1p_module_new(); + } + checkmem(yyval.a_module); + + yyval.a_module->Identifier = yyvsp[-7].tv_str; + yyval.a_module->module_oid = yyvsp[-6].a_oid; + yyval.a_module->module_flags = yyvsp[-4].a_module_flags; + ; + break;} +case 5: +#line 351 "asn1p_y.y" +{ yyval.a_oid = 0; ; + break;} +case 6: +#line 352 "asn1p_y.y" +{ yyval.a_oid = yyvsp[0].a_oid; ; + break;} +case 7: +#line 356 "asn1p_y.y" +{ + yyval.a_oid = yyvsp[-1].a_oid; + ; + break;} +case 8: +#line 359 "asn1p_y.y" +{ + yyval.a_oid = 0; + ; + break;} +case 9: +#line 365 "asn1p_y.y" +{ + yyval.a_oid = asn1p_oid_new(); + asn1p_oid_add_arc(yyval.a_oid, &yyvsp[0].a_oid_arc); + if(yyvsp[0].a_oid_arc.name) + free(yyvsp[0].a_oid_arc.name); + ; + break;} +case 10: +#line 371 "asn1p_y.y" +{ + yyval.a_oid = yyvsp[-1].a_oid; + asn1p_oid_add_arc(yyval.a_oid, &yyvsp[0].a_oid_arc); + if(yyvsp[0].a_oid_arc.name) + free(yyvsp[0].a_oid_arc.name); + ; + break;} +case 11: +#line 380 "asn1p_y.y" +{ /* iso */ + yyval.a_oid_arc.name = yyvsp[0].tv_str; + yyval.a_oid_arc.number = -1; + ; + break;} +case 12: +#line 384 "asn1p_y.y" +{ /* iso(1) */ + yyval.a_oid_arc.name = yyvsp[-3].tv_str; + yyval.a_oid_arc.number = yyvsp[-1].a_int; + ; + break;} +case 13: +#line 388 "asn1p_y.y" +{ /* 1 */ + yyval.a_oid_arc.name = 0; + yyval.a_oid_arc.number = yyvsp[0].a_int; + ; + break;} +case 14: +#line 398 "asn1p_y.y" +{ yyval.a_module_flags = MSF_NOFLAGS; ; + break;} +case 15: +#line 399 "asn1p_y.y" +{ + yyval.a_module_flags = yyvsp[0].a_module_flags; + ; + break;} +case 16: +#line 408 "asn1p_y.y" +{ + yyval.a_module_flags = yyvsp[0].a_module_flags; + ; + break;} +case 17: +#line 411 "asn1p_y.y" +{ + yyval.a_module_flags = yyvsp[-1].a_module_flags | yyvsp[0].a_module_flags; + ; + break;} +case 18: +#line 420 "asn1p_y.y" +{ + yyval.a_module_flags = MSF_EXPLICIT_TAGS; + ; + break;} +case 19: +#line 423 "asn1p_y.y" +{ + yyval.a_module_flags = MSF_IMPLICIT_TAGS; + ; + break;} +case 20: +#line 426 "asn1p_y.y" +{ + yyval.a_module_flags = MSF_AUTOMATIC_TAGS; + ; + break;} +case 21: +#line 429 "asn1p_y.y" +{ + yyval.a_module_flags = MSF_EXTENSIBILITY_IMPLIED; + ; + break;} +case 22: +#line 438 "asn1p_y.y" +{ yyval.a_module = 0; ; + break;} +case 23: +#line 439 "asn1p_y.y" +{ + assert(yyvsp[0].a_module); + yyval.a_module = yyvsp[0].a_module; + ; + break;} +case 24: +#line 449 "asn1p_y.y" +{ + yyval.a_module = yyvsp[0].a_module; + ; + break;} +case 25: +#line 452 "asn1p_y.y" +{ + yyval.a_module = yyvsp[-1].a_module; + +#ifdef MY_IMPORT +#error MY_IMPORT DEFINED ELSEWHERE! +#endif +#define MY_IMPORT(foo,field) do { \ + if(TQ_FIRST(&(yyvsp[0].a_module->foo))) { \ + TQ_ADD(&(yyval.a_module->foo), \ + TQ_REMOVE(&(yyvsp[0].a_module->foo), field), \ + field); \ + assert(TQ_FIRST(&(yyvsp[0].a_module->foo)) == 0); \ + } } while(0) + + MY_IMPORT(imports, xp_next); + MY_IMPORT(exports, xp_next); + MY_IMPORT(members, next); +#undef MY_IMPORT + + ; + break;} +case 26: +#line 478 "asn1p_y.y" +{ + yyval.a_module = yyvsp[0].a_module; + ; + break;} +case 27: +#line 481 "asn1p_y.y" +{ + yyval.a_module = asn1p_module_new(); + checkmem(yyval.a_module); + if(yyvsp[0].a_xports) { + TQ_ADD(&(yyval.a_module->exports), yyvsp[0].a_xports, xp_next); + } else { + /* "EXPORTS ALL;" ? */ + } + ; + break;} +case 28: +#line 490 "asn1p_y.y" +{ + yyval.a_module = asn1p_module_new(); + checkmem(yyval.a_module); + assert(yyvsp[0].a_expr->expr_type != A1TC_INVALID); + assert(yyvsp[0].a_expr->meta_type != AMT_INVALID); + TQ_ADD(&(yyval.a_module->members), yyvsp[0].a_expr, next); + ; + break;} +case 29: +#line 497 "asn1p_y.y" +{ + yyval.a_module = asn1p_module_new(); + checkmem(yyval.a_module); + assert(yyvsp[0].a_expr->expr_type != A1TC_INVALID); + assert(yyvsp[0].a_expr->meta_type != AMT_INVALID); + TQ_ADD(&(yyval.a_module->members), yyvsp[0].a_expr, next); + ; + break;} +case 30: +#line 510 "asn1p_y.y" +{ + yyval.a_module = asn1p_module_new(); + checkmem(yyval.a_module); + assert(yyvsp[0].a_expr->expr_type != A1TC_INVALID); + assert(yyvsp[0].a_expr->meta_type != AMT_INVALID); + TQ_ADD(&(yyval.a_module->members), yyvsp[0].a_expr, next); + ; + break;} +case 31: +#line 521 "asn1p_y.y" +{ + return yyerror( + "Attempt to redefine a standard basic type, " + "use -ftypesXY to switch back " + "to older version of ASN.1 standard"); + ; + break;} +case 32: +#line 535 "asn1p_y.y" +{ + yyval.a_module = yyvsp[-1].a_module; + ; + break;} +case 33: +#line 541 "asn1p_y.y" +{ + return yyerror("Empty IMPORTS list"); + ; + break;} +case 34: +#line 547 "asn1p_y.y" +{ + yyval.a_module = asn1p_module_new(); + checkmem(yyval.a_module); + TQ_ADD(&(yyval.a_module->imports), yyvsp[0].a_xports, xp_next); + ; + break;} +case 35: +#line 552 "asn1p_y.y" +{ + yyval.a_module = yyvsp[-1].a_module; + TQ_ADD(&(yyval.a_module->imports), yyvsp[0].a_xports, xp_next); + ; + break;} +case 36: +#line 559 "asn1p_y.y" +{ + yyval.a_xports = yyvsp[-3].a_xports; + yyval.a_xports->from = yyvsp[-1].tv_str; + yyval.a_xports->from_oid = yyvsp[0].a_oid; + checkmem(yyval.a_xports); + ; + break;} +case 37: +#line 568 "asn1p_y.y" +{ + yyval.a_xports = asn1p_xports_new(); + checkmem(yyval.a_xports); + TQ_ADD(&(yyval.a_xports->members), yyvsp[0].a_expr, next); + ; + break;} +case 38: +#line 573 "asn1p_y.y" +{ + yyval.a_xports = yyvsp[-2].a_xports; + TQ_ADD(&(yyval.a_xports->members), yyvsp[0].a_expr, next); + ; + break;} +case 39: +#line 580 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(yylineno); + checkmem(yyval.a_expr); + yyval.a_expr->Identifier = yyvsp[0].tv_str; + yyval.a_expr->expr_type = A1TC_REFERENCE; + ; + break;} +case 40: +#line 586 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(yylineno); + checkmem(yyval.a_expr); + yyval.a_expr->Identifier = yyvsp[0].tv_str; + yyval.a_expr->expr_type = A1TC_REFERENCE; + ; + break;} +case 41: +#line 595 "asn1p_y.y" +{ + yyval.a_xports = yyvsp[-1].a_xports; + ; + break;} +case 42: +#line 598 "asn1p_y.y" +{ + yyval.a_xports = 0; + ; + break;} +case 43: +#line 601 "asn1p_y.y" +{ + /* Empty EXPORTS clause effectively prohibits export. */ + yyval.a_xports = asn1p_xports_new(); + checkmem(yyval.a_xports); + ; + break;} +case 44: +#line 609 "asn1p_y.y" +{ + yyval.a_xports = asn1p_xports_new(); + assert(yyval.a_xports); + TQ_ADD(&(yyval.a_xports->members), yyvsp[0].a_expr, next); + ; + break;} +case 45: +#line 614 "asn1p_y.y" +{ + yyval.a_xports = yyvsp[-2].a_xports; + TQ_ADD(&(yyval.a_xports->members), yyvsp[0].a_expr, next); + ; + break;} +case 46: +#line 621 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(yylineno); + checkmem(yyval.a_expr); + yyval.a_expr->Identifier = yyvsp[0].tv_str; + yyval.a_expr->expr_type = A1TC_EXPORTVAR; + ; + break;} +case 47: +#line 627 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(yylineno); + checkmem(yyval.a_expr); + yyval.a_expr->Identifier = yyvsp[0].tv_str; + yyval.a_expr->expr_type = A1TC_EXPORTVAR; + ; + break;} +case 48: +#line 637 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[-4].a_expr; + assert(yyval.a_expr->Identifier == 0); + yyval.a_expr->Identifier = yyvsp[-5].tv_str; + yyval.a_expr->meta_type = AMT_VALUESET; + // take care of optValueSetBody + ; + break;} +case 49: +#line 647 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(yylineno); + checkmem(yyval.a_expr); + yyval.a_expr->reference = yyvsp[0].a_ref; + yyval.a_expr->expr_type = A1TC_REFERENCE; + yyval.a_expr->meta_type = AMT_TYPEREF; + ; + break;} +case 50: +#line 654 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(yylineno); + checkmem(yyval.a_expr); + yyval.a_expr->expr_type = yyvsp[0].a_type; + yyval.a_expr->meta_type = AMT_TYPE; + ; + break;} +case 51: +#line 663 "asn1p_y.y" +{ ; + break;} +case 52: +#line 664 "asn1p_y.y" +{ + ; + break;} +case 53: +#line 680 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(yylineno); + checkmem(yyval.a_expr); + yyval.a_expr->Identifier = yyvsp[-3].tv_str; + yyval.a_expr->tag = yyvsp[-1].a_tag; + yyval.a_expr->expr_type = A1TC_TYPEID; + yyval.a_expr->meta_type = AMT_TYPE; + ; + break;} +case 54: +#line 688 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[0].a_expr; + yyval.a_expr->Identifier = yyvsp[-3].tv_str; + yyval.a_expr->tag = yyvsp[-1].a_tag; + assert(yyval.a_expr->expr_type); + assert(yyval.a_expr->meta_type); + ; + break;} +case 55: +#line 695 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[0].a_expr; + yyval.a_expr->Identifier = yyvsp[-2].tv_str; + assert(yyval.a_expr->expr_type == A1TC_CLASSDEF); + assert(yyval.a_expr->meta_type == AMT_OBJECT); + ; + break;} +case 56: +#line 712 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[0].a_expr; + assert(yyval.a_expr->Identifier == 0); + yyval.a_expr->Identifier = yyvsp[-5].tv_str; + yyval.a_expr->params = yyvsp[-3].a_plist; + yyval.a_expr->meta_type = AMT_PARAMTYPE; + ; + break;} +case 57: +#line 722 "asn1p_y.y" +{ + int ret; + yyval.a_plist = asn1p_paramlist_new(yylineno); + checkmem(yyval.a_plist); + ret = asn1p_paramlist_add_param(yyval.a_plist, yyvsp[0].a_parg.governor, yyvsp[0].a_parg.argument); + checkmem(ret == 0); + if(yyvsp[0].a_parg.governor) asn1p_ref_free(yyvsp[0].a_parg.governor); + if(yyvsp[0].a_parg.argument) free(yyvsp[0].a_parg.argument); + ; + break;} +case 58: +#line 731 "asn1p_y.y" +{ + int ret; + yyval.a_plist = yyvsp[-2].a_plist; + ret = asn1p_paramlist_add_param(yyval.a_plist, yyvsp[0].a_parg.governor, yyvsp[0].a_parg.argument); + checkmem(ret == 0); + if(yyvsp[0].a_parg.governor) asn1p_ref_free(yyvsp[0].a_parg.governor); + if(yyvsp[0].a_parg.argument) free(yyvsp[0].a_parg.argument); + ; + break;} +case 59: +#line 742 "asn1p_y.y" +{ + yyval.a_parg.governor = NULL; + yyval.a_parg.argument = yyvsp[0].tv_str; + ; + break;} +case 60: +#line 746 "asn1p_y.y" +{ + int ret; + yyval.a_parg.governor = asn1p_ref_new(yylineno); + ret = asn1p_ref_add_component(yyval.a_parg.governor, yyvsp[-2].tv_str, 0); + checkmem(ret == 0); + yyval.a_parg.argument = yyvsp[0].tv_str; + ; + break;} +case 61: +#line 753 "asn1p_y.y" +{ + int ret; + yyval.a_parg.governor = asn1p_ref_new(yylineno); + ret = asn1p_ref_add_component(yyval.a_parg.governor, + ASN_EXPR_TYPE2STR(yyvsp[-2].a_type), 1); + checkmem(ret == 0); + yyval.a_parg.argument = yyvsp[0].tv_str; + ; + break;} +case 62: +#line 764 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(yylineno); + checkmem(yyval.a_expr); + TQ_ADD(&(yyval.a_expr->members), yyvsp[0].a_expr, next); + ; + break;} +case 63: +#line 769 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[-2].a_expr; + TQ_ADD(&(yyval.a_expr->members), yyvsp[0].a_expr, next); + ; + break;} +case 64: +#line 776 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[0].a_expr; + ; + break;} +case 65: +#line 779 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(yylineno); + checkmem(yyval.a_expr); + yyval.a_expr->Identifier = yyvsp[0].tv_str; + yyval.a_expr->expr_type = A1TC_REFERENCE; + yyval.a_expr->meta_type = AMT_VALUE; + ; + break;} +case 66: +#line 792 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(yylineno); + checkmem(yyval.a_expr); + TQ_ADD(&(yyval.a_expr->members), yyvsp[0].a_expr, next); + ; + break;} +case 67: +#line 797 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[-2].a_expr; + TQ_ADD(&(yyval.a_expr->members), yyvsp[0].a_expr, next); + ; + break;} +case 68: +#line 804 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[-2].a_expr; + checkmem(yyval.a_expr); + yyval.a_expr->with_syntax = yyvsp[0].a_wsynt; + assert(yyval.a_expr->expr_type == A1TC_CLASSDEF); + assert(yyval.a_expr->meta_type == AMT_OBJECT); + ; + break;} +case 69: +#line 814 "asn1p_y.y" +{ yyval.a_int = 0; ; + break;} +case 70: +#line 815 "asn1p_y.y" +{ yyval.a_int = 1; ; + break;} +case 71: +#line 819 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(yylineno); + checkmem(yyval.a_expr); + yyval.a_expr->expr_type = A1TC_CLASSDEF; + yyval.a_expr->meta_type = AMT_OBJECT; + TQ_ADD(&(yyval.a_expr->members), yyvsp[0].a_expr, next); + ; + break;} +case 72: +#line 826 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[-2].a_expr; + TQ_ADD(&(yyval.a_expr->members), yyvsp[0].a_expr, next); + ; + break;} +case 73: +#line 833 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(yylineno); + checkmem(yyval.a_expr); + yyval.a_expr->Identifier = yyvsp[-1].a_refcomp.name; + yyval.a_expr->expr_type = A1TC_CLASSFIELD; + yyval.a_expr->meta_type = AMT_OBJECTFIELD; + yyval.a_expr->marker = yyvsp[0].a_marker; + ; + break;} +case 74: +#line 841 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[-1].a_expr; + yyval.a_expr->Identifier = yyvsp[-2].a_refcomp.name; + yyval.a_expr->unique = yyvsp[0].a_int; + ; + break;} +case 75: +#line 846 "asn1p_y.y" +{ + int ret; + yyval.a_expr = asn1p_expr_new(yylineno); + checkmem(yyval.a_expr); + yyval.a_expr->Identifier = yyvsp[-3].a_refcomp.name; + yyval.a_expr->reference = asn1p_ref_new(yylineno); + checkmem(yyval.a_expr->reference); + ret = asn1p_ref_add_component(yyval.a_expr->reference, + yyvsp[-2].a_refcomp.name, yyvsp[-2].a_refcomp.lex_type); + checkmem(ret == 0); + yyval.a_expr->expr_type = A1TC_CLASSFIELD; + yyval.a_expr->meta_type = AMT_OBJECTFIELD; + yyval.a_expr->marker = yyvsp[-1].a_marker; + yyval.a_expr->unique = yyvsp[0].a_int; + ; + break;} +case 76: +#line 864 "asn1p_y.y" +{ yyval.a_wsynt = 0; ; + break;} +case 77: +#line 865 "asn1p_y.y" +{ + yyval.a_wsynt = yyvsp[0].a_wsynt; + ; + break;} +case 78: +#line 872 "asn1p_y.y" +{ asn1p_lexer_hack_enable_with_syntax(); ; + break;} +case 79: +#line 874 "asn1p_y.y" +{ + yyval.a_wsynt = yyvsp[-1].a_wsynt; + ; + break;} +case 80: +#line 880 "asn1p_y.y" +{ + yyval.a_wsynt = asn1p_wsyntx_new(); + TQ_ADD(&(yyval.a_wsynt->chunks), yyvsp[0].a_wchunk, next); + ; + break;} +case 81: +#line 884 "asn1p_y.y" +{ + yyval.a_wsynt = yyvsp[-1].a_wsynt; + TQ_ADD(&(yyval.a_wsynt->chunks), yyvsp[0].a_wchunk, next); + ; + break;} +case 82: +#line 891 "asn1p_y.y" +{ + yyval.a_wchunk = asn1p_wsyntx_chunk_frombuf(yyvsp[0].tv_opaque.buf, yyvsp[0].tv_opaque.len, 0); + ; + break;} +case 83: +#line 894 "asn1p_y.y" +{ + asn1p_ref_t *ref; + int ret; + ref = asn1p_ref_new(yylineno); + checkmem(ref); + ret = asn1p_ref_add_component(ref, yyvsp[0].a_refcomp.name, yyvsp[0].a_refcomp.lex_type); + checkmem(ret == 0); + yyval.a_wchunk = asn1p_wsyntx_chunk_fromref(ref, 0); + ; + break;} +case 84: +#line 920 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[0].a_expr; + assert(yyval.a_expr->Identifier == 0); + yyval.a_expr->Identifier = yyvsp[-1].tv_nametag.name; + yyval.a_expr->tag = yyvsp[-1].tv_nametag.tag; + ; + break;} +case 85: +#line 926 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[0].a_expr; + ; + break;} +case 86: +#line 932 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[-2].a_expr; + yyval.a_expr->constraints = yyvsp[-1].a_constr; + yyval.a_expr->marker = yyvsp[0].a_marker; + ; + break;} +case 87: +#line 940 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(asn1p_lineno); + checkmem(yyval.a_expr); + yyval.a_expr->Identifier = strdup("..."); + checkmem(yyval.a_expr->Identifier); + yyval.a_expr->expr_type = A1TC_EXTENSIBLE; + yyval.a_expr->meta_type = AMT_TYPE; + ; + break;} +case 88: +#line 948 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(asn1p_lineno); + checkmem(yyval.a_expr); + yyval.a_expr->Identifier = strdup("..."); + checkmem(yyval.a_expr->Identifier); + yyval.a_expr->value = yyvsp[0].a_value; + yyval.a_expr->expr_type = A1TC_EXTENSIBLE; + yyval.a_expr->meta_type = AMT_TYPE; + ; + break;} +case 89: +#line 957 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(asn1p_lineno); + checkmem(yyval.a_expr); + yyval.a_expr->Identifier = strdup("..."); + yyval.a_expr->value = yyvsp[0].a_value; + checkmem(yyval.a_expr->Identifier); + yyval.a_expr->expr_type = A1TC_EXTENSIBLE; + yyval.a_expr->meta_type = AMT_TYPE; + ; + break;} +case 90: +#line 969 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[0].a_expr; + ; + break;} +case 91: +#line 972 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(yylineno); + checkmem(yyval.a_expr); + yyval.a_expr->expr_type = yyvsp[0].a_type; + yyval.a_expr->meta_type = AMT_TYPE; + ; + break;} +case 92: +#line 978 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[0].a_expr; + checkmem(yyval.a_expr); + assert(yyval.a_expr->meta_type); + ; + break;} +case 93: +#line 986 "asn1p_y.y" +{ + int ret; + yyval.a_expr = yyvsp[-1].a_expr; + assert(yyval.a_expr->expr_type == 0); + assert(yyval.a_expr->meta_type == 0); + assert(yyval.a_expr->reference == 0); + yyval.a_expr->reference = asn1p_ref_new(yylineno); + checkmem(yyval.a_expr->reference); + ret = asn1p_ref_add_component(yyval.a_expr->reference, yyvsp[-3].tv_str, RLT_UNKNOWN); + checkmem(ret == 0); + free(yyvsp[-3].tv_str); + yyval.a_expr->expr_type = A1TC_PARAMETRIZED; + yyval.a_expr->meta_type = AMT_TYPE; + ; + break;} +case 94: +#line 1010 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(yylineno); + checkmem(yyval.a_expr); + yyval.a_expr->reference = yyvsp[0].a_ref; + yyval.a_expr->expr_type = A1TC_REFERENCE; + yyval.a_expr->meta_type = AMT_TYPEREF; + ; + break;} +case 95: +#line 1017 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(yylineno); + checkmem(yyval.a_expr); + yyval.a_expr->reference = yyvsp[0].a_ref; + yyval.a_expr->expr_type = A1TC_INSTANCE; + yyval.a_expr->meta_type = AMT_TYPE; + ; + break;} +case 96: +#line 1032 "asn1p_y.y" +{ + int ret; + yyval.a_ref = asn1p_ref_new(yylineno); + checkmem(yyval.a_ref); + ret = asn1p_ref_add_component(yyval.a_ref, yyvsp[0].tv_str, RLT_UNKNOWN); + checkmem(ret == 0); + free(yyvsp[0].tv_str); + ; + break;} +case 97: +#line 1040 "asn1p_y.y" +{ + int ret; + yyval.a_ref = asn1p_ref_new(yylineno); + checkmem(yyval.a_ref); + ret = asn1p_ref_add_component(yyval.a_ref, yyvsp[-2].tv_str, RLT_UNKNOWN); + checkmem(ret == 0); + ret = asn1p_ref_add_component(yyval.a_ref, yyvsp[0].tv_str, RLT_UNKNOWN); + checkmem(ret == 0); + free(yyvsp[-2].tv_str); + ; + break;} +case 98: +#line 1050 "asn1p_y.y" +{ + int ret; + yyval.a_ref = asn1p_ref_new(yylineno); + checkmem(yyval.a_ref); + ret = asn1p_ref_add_component(yyval.a_ref, yyvsp[-2].tv_str, RLT_UNKNOWN); + checkmem(ret == 0); + ret = asn1p_ref_add_component(yyval.a_ref, yyvsp[0].tv_str, RLT_lowercase); + checkmem(ret == 0); + free(yyvsp[-2].tv_str); + ; + break;} +case 99: +#line 1060 "asn1p_y.y" +{ + int ret; + yyval.a_ref = asn1p_ref_new(yylineno); + checkmem(yyval.a_ref); + ret = asn1p_ref_add_component(yyval.a_ref, yyvsp[0].tv_str, RLT_CAPITALS); + free(yyvsp[0].tv_str); + checkmem(ret == 0); + ; + break;} +case 100: +#line 1068 "asn1p_y.y" +{ + int ret; + yyval.a_ref = yyvsp[0].a_ref; + ret = asn1p_ref_add_component(yyval.a_ref, yyvsp[-2].tv_str, RLT_CAPITALS); + free(yyvsp[-2].tv_str); + checkmem(ret == 0); + /* + * Move the last element infront. + */ + { + struct asn1p_ref_component_s tmp_comp; + tmp_comp = yyval.a_ref->components[yyval.a_ref->comp_count-1]; + memmove(&yyval.a_ref->components[1], + &yyval.a_ref->components[0], + sizeof(yyval.a_ref->components[0]) + * (yyval.a_ref->comp_count - 1)); + yyval.a_ref->components[0] = tmp_comp; + } + ; + break;} +case 101: +#line 1090 "asn1p_y.y" +{ + int ret; + yyval.a_ref = asn1p_ref_new(yylineno); + checkmem(yyval.a_ref); + ret = asn1p_ref_add_component(yyval.a_ref, yyvsp[0].a_refcomp.name, yyvsp[0].a_refcomp.lex_type); + free(yyvsp[0].a_refcomp.name); + checkmem(ret == 0); + ; + break;} +case 102: +#line 1098 "asn1p_y.y" +{ + int ret; + yyval.a_ref = yyvsp[-2].a_ref; + ret = asn1p_ref_add_component(yyval.a_ref, yyvsp[0].a_refcomp.name, yyvsp[0].a_refcomp.lex_type); + free(yyvsp[0].a_refcomp.name); + checkmem(ret == 0); + ; + break;} +case 105: +#line 1112 "asn1p_y.y" +{ + yyval.a_refcomp.lex_type = RLT_AmpUppercase; + yyval.a_refcomp.name = yyvsp[0].tv_str; + ; + break;} +case 106: +#line 1117 "asn1p_y.y" +{ + yyval.a_refcomp.lex_type = RLT_Amplowercase; + yyval.a_refcomp.name = yyvsp[0].tv_str; + ; + break;} +case 107: +#line 1130 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[-2].a_expr; + assert(yyval.a_expr->Identifier == NULL); + yyval.a_expr->Identifier = yyvsp[-3].tv_str; + yyval.a_expr->meta_type = AMT_VALUE; + yyval.a_expr->value = yyvsp[0].a_value; + ; + break;} +case 108: +#line 1140 "asn1p_y.y" +{ asn1p_lexer_hack_push_opaque_state(); ; + break;} +case 109: +#line 1141 "asn1p_y.y" +{ + yyval.a_value = asn1p_value_frombuf(yyvsp[0].tv_opaque.buf, yyvsp[0].tv_opaque.len, 0); + checkmem(yyval.a_value); + yyval.a_value->type = ATV_UNPARSED; + ; + break;} +case 110: +#line 1146 "asn1p_y.y" +{ + yyval.a_value = _convert_bitstring2binary(yyvsp[0].tv_str, 'B'); + checkmem(yyval.a_value); + ; + break;} +case 111: +#line 1150 "asn1p_y.y" +{ + yyval.a_value = _convert_bitstring2binary(yyvsp[0].tv_str, 'H'); + checkmem(yyval.a_value); + ; + break;} +case 112: +#line 1154 "asn1p_y.y" +{ + yyval.a_value = asn1p_value_frombuf(yyvsp[0].tv_opaque.buf, yyvsp[0].tv_opaque.len, 0); + checkmem(yyval.a_value); + ; + break;} +case 113: +#line 1158 "asn1p_y.y" +{ + yyval.a_value = yyvsp[0].a_value; + ; + break;} +case 114: +#line 1161 "asn1p_y.y" +{ + yyval.a_value = yyvsp[0].a_value; + ; + break;} +case 115: +#line 1167 "asn1p_y.y" +{ + asn1p_ref_t *ref; + int ret; + ref = asn1p_ref_new(yylineno); + checkmem(ref); + ret = asn1p_ref_add_component(ref, yyvsp[0].tv_str, RLT_lowercase); + checkmem(ret == 0); + yyval.a_value = asn1p_value_fromref(ref, 0); + checkmem(yyval.a_value); + free(yyvsp[0].tv_str); + ; + break;} +case 116: +#line 1178 "asn1p_y.y" +{ + asn1p_ref_t *ref; + int ret; + ref = asn1p_ref_new(yylineno); + checkmem(ref); + ret = asn1p_ref_add_component(ref, yyvsp[-2].tv_str, RLT_UNKNOWN); + checkmem(ret == 0); + ret = asn1p_ref_add_component(ref, yyvsp[0].tv_str, RLT_lowercase); + checkmem(ret == 0); + yyval.a_value = asn1p_value_fromref(ref, 0); + checkmem(yyval.a_value); + free(yyvsp[-2].tv_str); + free(yyvsp[0].tv_str); + ; + break;} +case 117: +#line 1195 "asn1p_y.y" +{ + yyval.tv_opaque.len = yyvsp[0].tv_opaque.len + 2; + yyval.tv_opaque.buf = malloc(yyval.tv_opaque.len + 1); + checkmem(yyval.tv_opaque.buf); + yyval.tv_opaque.buf[0] = '{'; + yyval.tv_opaque.buf[1] = ' '; + memcpy(yyval.tv_opaque.buf + 2, yyvsp[0].tv_opaque.buf, yyvsp[0].tv_opaque.len); + yyval.tv_opaque.buf[yyval.tv_opaque.len] = '\0'; + free(yyvsp[0].tv_opaque.buf); + ; + break;} +case 118: +#line 1205 "asn1p_y.y" +{ + int newsize = yyvsp[-1].tv_opaque.len + yyvsp[0].tv_opaque.len; + char *p = malloc(newsize + 1); + checkmem(p); + memcpy(p , yyvsp[-1].tv_opaque.buf, yyvsp[-1].tv_opaque.len); + memcpy(p + yyvsp[-1].tv_opaque.len, yyvsp[0].tv_opaque.buf, yyvsp[0].tv_opaque.len); + p[newsize] = '\0'; + free(yyvsp[-1].tv_opaque.buf); + free(yyvsp[0].tv_opaque.buf); + yyval.tv_opaque.buf = p; + yyval.tv_opaque.len = newsize; + ; + break;} +case 119: +#line 1220 "asn1p_y.y" +{ yyval.a_type = ASN_BASIC_BOOLEAN; ; + break;} +case 120: +#line 1221 "asn1p_y.y" +{ yyval.a_type = ASN_BASIC_NULL; ; + break;} +case 121: +#line 1222 "asn1p_y.y" +{ yyval.a_type = ASN_BASIC_REAL; ; + break;} +case 122: +#line 1223 "asn1p_y.y" +{ yyval.a_type = yyvsp[0].a_type; ; + break;} +case 123: +#line 1224 "asn1p_y.y" +{ yyval.a_type = ASN_BASIC_OCTET_STRING; ; + break;} +case 124: +#line 1225 "asn1p_y.y" +{ yyval.a_type = ASN_BASIC_OBJECT_IDENTIFIER; ; + break;} +case 125: +#line 1226 "asn1p_y.y" +{ yyval.a_type = ASN_BASIC_RELATIVE_OID; ; + break;} +case 126: +#line 1227 "asn1p_y.y" +{ yyval.a_type = ASN_BASIC_EXTERNAL; ; + break;} +case 127: +#line 1228 "asn1p_y.y" +{ yyval.a_type = ASN_BASIC_EMBEDDED_PDV; ; + break;} +case 128: +#line 1229 "asn1p_y.y" +{ yyval.a_type = ASN_BASIC_CHARACTER_STRING; ; + break;} +case 129: +#line 1230 "asn1p_y.y" +{ yyval.a_type = ASN_BASIC_UTCTime; ; + break;} +case 130: +#line 1231 "asn1p_y.y" +{ yyval.a_type = ASN_BASIC_GeneralizedTime; ; + break;} +case 131: +#line 1238 "asn1p_y.y" +{ yyval.a_type = ASN_BASIC_INTEGER; ; + break;} +case 132: +#line 1239 "asn1p_y.y" +{ yyval.a_type = ASN_BASIC_ENUMERATED; ; + break;} +case 133: +#line 1240 "asn1p_y.y" +{ yyval.a_type = ASN_BASIC_BIT_STRING; ; + break;} +case 134: +#line 1244 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(asn1p_lineno); + checkmem(yyval.a_expr); + yyval.a_expr->expr_type = yyvsp[0].a_type; + yyval.a_expr->meta_type = AMT_TYPE; + ; + break;} +case 135: +#line 1250 "asn1p_y.y" +{ + if(yyvsp[0].a_expr) { + yyval.a_expr = yyvsp[0].a_expr; + } else { + yyval.a_expr = asn1p_expr_new(asn1p_lineno); + checkmem(yyval.a_expr); + } + yyval.a_expr->expr_type = yyvsp[-1].a_type; + yyval.a_expr->meta_type = AMT_TYPE; + ; + break;} +case 136: +#line 1263 "asn1p_y.y" +{ yyval.a_type = ASN_STRING_BMPString; ; + break;} +case 137: +#line 1264 "asn1p_y.y" +{ + yyval.a_type = ASN_STRING_GeneralString; + return yyerror("GeneralString is not supported"); + ; + break;} +case 138: +#line 1268 "asn1p_y.y" +{ + yyval.a_type = ASN_STRING_GraphicString; + return yyerror("GraphicString is not supported"); + ; + break;} +case 139: +#line 1272 "asn1p_y.y" +{ yyval.a_type = ASN_STRING_IA5String; ; + break;} +case 140: +#line 1273 "asn1p_y.y" +{ yyval.a_type = ASN_STRING_ISO646String; ; + break;} +case 141: +#line 1274 "asn1p_y.y" +{ yyval.a_type = ASN_STRING_NumericString; ; + break;} +case 142: +#line 1275 "asn1p_y.y" +{ yyval.a_type = ASN_STRING_PrintableString; ; + break;} +case 143: +#line 1276 "asn1p_y.y" +{ + yyval.a_type = ASN_STRING_T61String; + return yyerror("T61String not implemented yet"); + ; + break;} +case 144: +#line 1280 "asn1p_y.y" +{ yyval.a_type = ASN_STRING_TeletexString; ; + break;} +case 145: +#line 1281 "asn1p_y.y" +{ yyval.a_type = ASN_STRING_UniversalString; ; + break;} +case 146: +#line 1282 "asn1p_y.y" +{ yyval.a_type = ASN_STRING_UTF8String; ; + break;} +case 147: +#line 1283 "asn1p_y.y" +{ + yyval.a_type = ASN_STRING_VideotexString; + return yyerror("VideotexString is no longer supported"); + ; + break;} +case 148: +#line 1287 "asn1p_y.y" +{ yyval.a_type = ASN_STRING_VisibleString; ; + break;} +case 149: +#line 1288 "asn1p_y.y" +{ yyval.a_type = ASN_STRING_ObjectDescriptor; ; + break;} +case 150: +#line 1292 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[-1].a_expr; + assert(yyval.a_expr->expr_type == A1TC_INVALID); + yyval.a_expr->expr_type = ASN_CONSTR_CHOICE; + yyval.a_expr->meta_type = AMT_TYPE; + ; + break;} +case 151: +#line 1298 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[-1].a_expr; + assert(yyval.a_expr->expr_type == A1TC_INVALID); + yyval.a_expr->expr_type = ASN_CONSTR_SEQUENCE; + yyval.a_expr->meta_type = AMT_TYPE; + ; + break;} +case 152: +#line 1304 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[-1].a_expr; + assert(yyval.a_expr->expr_type == A1TC_INVALID); + yyval.a_expr->expr_type = ASN_CONSTR_SET; + yyval.a_expr->meta_type = AMT_TYPE; + ; + break;} +case 153: +#line 1310 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(asn1p_lineno); + checkmem(yyval.a_expr); + yyval.a_expr->constraints = yyvsp[-2].a_constr; + yyval.a_expr->expr_type = ASN_CONSTR_SEQUENCE_OF; + yyval.a_expr->meta_type = AMT_TYPE; + TQ_ADD(&(yyval.a_expr->members), yyvsp[0].a_expr, next); + ; + break;} +case 154: +#line 1318 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(asn1p_lineno); + checkmem(yyval.a_expr); + yyval.a_expr->constraints = yyvsp[-2].a_constr; + yyval.a_expr->expr_type = ASN_CONSTR_SET_OF; + yyval.a_expr->meta_type = AMT_TYPE; + TQ_ADD(&(yyval.a_expr->members), yyvsp[0].a_expr, next); + ; + break;} +case 155: +#line 1326 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(asn1p_lineno); + checkmem(yyval.a_expr); + yyval.a_expr->expr_type = ASN_CONSTR_ANY; + yyval.a_expr->meta_type = AMT_TYPE; + ; + break;} +case 156: +#line 1332 "asn1p_y.y" +{ + int ret; + yyval.a_expr = asn1p_expr_new(asn1p_lineno); + checkmem(yyval.a_expr); + yyval.a_expr->reference = asn1p_ref_new(yylineno); + ret = asn1p_ref_add_component(yyval.a_expr->reference, + yyvsp[0].tv_str, RLT_lowercase); + checkmem(ret == 0); + yyval.a_expr->expr_type = ASN_CONSTR_ANY; + yyval.a_expr->meta_type = AMT_TYPE; + ; + break;} +case 157: +#line 1349 "asn1p_y.y" +{ yyval.a_constr = 0; ; + break;} +case 158: +#line 1350 "asn1p_y.y" +{ yyval.a_constr = yyvsp[0].a_constr; ; + break;} +case 164: +#line 1358 "asn1p_y.y" +{ + /* + * This is a special case, for compatibility purposes. + * It goes without parenthesis. + */ + int ret; + yyval.a_constr = asn1p_constraint_new(yylineno); + checkmem(yyval.a_constr); + yyval.a_constr->type = ACT_CT_SIZE; + ret = asn1p_constraint_insert(yyval.a_constr, yyvsp[-1].a_constr); + checkmem(ret == 0); + ; + break;} +case 165: +#line 1370 "asn1p_y.y" +{ + CONSTRAINT_INSERT(yyval.a_constr, ACT_CA_SET, yyvsp[0].a_constr, 0); + ; + break;} +case 166: +#line 1373 "asn1p_y.y" +{ + CONSTRAINT_INSERT(yyval.a_constr, ACT_CA_SET, yyvsp[-1].a_constr, yyvsp[0].a_constr); + ; + break;} +case 167: +#line 1379 "asn1p_y.y" +{ + yyval.a_constr = yyvsp[-1].a_constr; + ; + break;} +case 168: +#line 1385 "asn1p_y.y" +{ + yyval.a_constr = yyvsp[0].a_constr; + ; + break;} +case 169: +#line 1388 "asn1p_y.y" +{ + asn1p_constraint_t *ct; + ct = asn1p_constraint_new(yylineno); + checkmem(ct); + ct->type = ACT_EL_EXT; + CONSTRAINT_INSERT(yyval.a_constr, ACT_CA_CSV, yyvsp[-2].a_constr, ct); + ; + break;} +case 170: +#line 1395 "asn1p_y.y" +{ + asn1p_constraint_t *ct; + ct = asn1p_constraint_new(yylineno); + checkmem(ct); + ct->type = ACT_EL_EXT; + CONSTRAINT_INSERT(yyval.a_constr, ACT_CA_CSV, yyvsp[-4].a_constr, ct); + CONSTRAINT_INSERT(yyval.a_constr, ACT_CA_CSV, yyvsp[-4].a_constr, yyvsp[0].a_constr); + ; + break;} +case 171: +#line 1403 "asn1p_y.y" +{ + yyval.a_constr = asn1p_constraint_new(yylineno); + checkmem(yyval.a_constr); + yyval.a_constr->type = ACT_EL_EXT; + ; + break;} +case 172: +#line 1408 "asn1p_y.y" +{ + asn1p_constraint_t *ct; + ct = asn1p_constraint_new(yylineno); + checkmem(ct); + ct->type = ACT_EL_EXT; + CONSTRAINT_INSERT(yyval.a_constr, ACT_CA_CSV, ct, yyvsp[0].a_constr); + ; + break;} +case 173: +#line 1417 "asn1p_y.y" +{ yyval.a_constr = yyvsp[0].a_constr; ; + break;} +case 174: +#line 1420 "asn1p_y.y" +{ yyval.a_constr = yyvsp[0].a_constr; ; + break;} +case 175: +#line 1421 "asn1p_y.y" +{ + CONSTRAINT_INSERT(yyval.a_constr, ACT_CA_UNI, yyvsp[-2].a_constr, yyvsp[0].a_constr); + ; + break;} +case 176: +#line 1427 "asn1p_y.y" +{ yyval.a_constr = yyvsp[0].a_constr; ; + break;} +case 177: +#line 1429 "asn1p_y.y" +{ + CONSTRAINT_INSERT(yyval.a_constr, ACT_CA_INT, yyvsp[-2].a_constr, yyvsp[0].a_constr); + ; + break;} +case 178: +#line 1435 "asn1p_y.y" +{ yyval.a_constr = yyvsp[0].a_constr; ; + break;} +case 179: +#line 1436 "asn1p_y.y" +{ + CONSTRAINT_INSERT(yyval.a_constr, ACT_CA_EXC, yyvsp[-2].a_constr, yyvsp[0].a_constr); + ; + break;} +case 180: +#line 1442 "asn1p_y.y" +{ + yyval.a_constr = asn1p_constraint_new(yylineno); + checkmem(yyval.a_constr); + yyval.a_constr->type = ACT_EL_VALUE; + yyval.a_constr->value = yyvsp[0].a_value; + ; + break;} +case 181: +#line 1448 "asn1p_y.y" +{ + yyval.a_constr = asn1p_constraint_new(yylineno); + checkmem(yyval.a_constr); + yyval.a_constr->type = yyvsp[-1].a_ctype; + yyval.a_constr->range_start = yyvsp[-2].a_value; + yyval.a_constr->range_stop = yyvsp[0].a_value; + ; + break;} +case 182: +#line 1455 "asn1p_y.y" +{ + int ret; + yyval.a_constr = asn1p_constraint_new(yylineno); + checkmem(yyval.a_constr); + yyval.a_constr->type = yyvsp[-3].a_ctype; + ret = asn1p_constraint_insert(yyval.a_constr, yyvsp[-1].a_constr); + checkmem(ret == 0); + ; + break;} +case 183: +#line 1463 "asn1p_y.y" +{ + yyval.a_constr = yyvsp[0].a_constr; + ; + break;} +case 184: +#line 1466 "asn1p_y.y" +{ + yyval.a_constr = yyvsp[0].a_constr; + ; + break;} +case 185: +#line 1472 "asn1p_y.y" +{ yyval.a_ctype = ACT_EL_RANGE; ; + break;} +case 186: +#line 1473 "asn1p_y.y" +{ yyval.a_ctype = ACT_EL_RLRANGE; ; + break;} +case 187: +#line 1474 "asn1p_y.y" +{ yyval.a_ctype = ACT_EL_LLRANGE; ; + break;} +case 188: +#line 1475 "asn1p_y.y" +{ yyval.a_ctype = ACT_EL_ULRANGE; ; + break;} +case 189: +#line 1479 "asn1p_y.y" +{ + yyval.a_ctype = ACT_CT_SIZE; + ; + break;} +case 190: +#line 1482 "asn1p_y.y" +{ + yyval.a_ctype = ACT_CT_FROM; + ; + break;} +case 191: +#line 1488 "asn1p_y.y" +{ + yyval.a_value = yyvsp[0].a_value; + ; + break;} +case 192: +#line 1491 "asn1p_y.y" +{ + asn1p_ref_t *ref; + int ret; + ref = asn1p_ref_new(yylineno); + checkmem(ref); + ret = asn1p_ref_add_component(ref, yyvsp[0].tv_str, RLT_lowercase); + checkmem(ret == 0); + yyval.a_value = asn1p_value_fromref(ref, 0); + checkmem(yyval.a_value); + free(yyvsp[0].tv_str); + ; + break;} +case 193: +#line 1502 "asn1p_y.y" +{ + yyval.a_value = asn1p_value_frombuf(yyvsp[0].tv_opaque.buf, yyvsp[0].tv_opaque.len, 0); + checkmem(yyval.a_value); + ; + break;} +case 194: +#line 1506 "asn1p_y.y" +{ + yyval.a_value = asn1p_value_fromint(123); + checkmem(yyval.a_value); + yyval.a_value->type = ATV_MIN; + ; + break;} +case 195: +#line 1511 "asn1p_y.y" +{ + yyval.a_value = asn1p_value_fromint(321); + checkmem(yyval.a_value); + yyval.a_value->type = ATV_MAX; + ; + break;} +case 196: +#line 1516 "asn1p_y.y" +{ + yyval.a_value = asn1p_value_fromint(0); + checkmem(yyval.a_value); + yyval.a_value->type = ATV_FALSE; + ; + break;} +case 197: +#line 1521 "asn1p_y.y" +{ + yyval.a_value = asn1p_value_fromint(1); + checkmem(yyval.a_value); + yyval.a_value->type = ATV_TRUE; + ; + break;} +case 198: +#line 1529 "asn1p_y.y" +{ + CONSTRAINT_INSERT(yyval.a_constr, ACT_CT_WCOMPS, yyvsp[-1].a_constr, 0); + ; + break;} +case 199: +#line 1535 "asn1p_y.y" +{ + yyval.a_constr = yyvsp[0].a_constr; + ; + break;} +case 200: +#line 1538 "asn1p_y.y" +{ + CONSTRAINT_INSERT(yyval.a_constr, ACT_CT_WCOMPS, yyvsp[-2].a_constr, yyvsp[0].a_constr); + ; + break;} +case 201: +#line 1544 "asn1p_y.y" +{ + yyval.a_constr = asn1p_constraint_new(yylineno); + checkmem(yyval.a_constr); + yyval.a_constr->type = ACT_EL_EXT; + ; + break;} +case 202: +#line 1549 "asn1p_y.y" +{ + yyval.a_constr = asn1p_constraint_new(yylineno); + checkmem(yyval.a_constr); + yyval.a_constr->type = ACT_EL_VALUE; + yyval.a_constr->value = asn1p_value_frombuf(yyvsp[-2].tv_str, strlen(yyvsp[-2].tv_str), 0); + yyval.a_constr->presence = yyvsp[0].a_pres; + ; + break;} +case 203: +#line 1562 "asn1p_y.y" +{ yyval.a_pres = ACPRES_DEFAULT; ; + break;} +case 204: +#line 1563 "asn1p_y.y" +{ yyval.a_pres = yyvsp[0].a_pres; ; + break;} +case 205: +#line 1567 "asn1p_y.y" +{ + yyval.a_pres = ACPRES_PRESENT; + ; + break;} +case 206: +#line 1570 "asn1p_y.y" +{ + yyval.a_pres = ACPRES_ABSENT; + ; + break;} +case 207: +#line 1573 "asn1p_y.y" +{ + yyval.a_pres = ACPRES_OPTIONAL; + ; + break;} +case 208: +#line 1579 "asn1p_y.y" +{ + yyval.a_constr = yyvsp[0].a_constr; + ; + break;} +case 209: +#line 1582 "asn1p_y.y" +{ + yyval.a_constr = yyvsp[0].a_constr; + ; + break;} +case 210: +#line 1591 "asn1p_y.y" +{ + asn1p_ref_t *ref = asn1p_ref_new(yylineno); + asn1p_constraint_t *ct; + int ret; + ret = asn1p_ref_add_component(ref, yyvsp[-1].tv_str, 0); + checkmem(ret == 0); + ct = asn1p_constraint_new(yylineno); + checkmem(yyval.a_constr); + ct->type = ACT_EL_VALUE; + ct->value = asn1p_value_fromref(ref, 0); + CONSTRAINT_INSERT(yyval.a_constr, ACT_CA_CRC, ct, 0); + ; + break;} +case 211: +#line 1606 "asn1p_y.y" +{ + CONSTRAINT_INSERT(yyval.a_constr, ACT_CA_CRC, yyvsp[-3].a_constr, yyvsp[-1].a_constr); + ; + break;} +case 212: +#line 1612 "asn1p_y.y" +{ + yyval.a_constr = asn1p_constraint_new(yylineno); + checkmem(yyval.a_constr); + yyval.a_constr->type = ACT_EL_VALUE; + yyval.a_constr->value = asn1p_value_fromref(yyvsp[0].a_ref, 0); + ; + break;} +case 213: +#line 1618 "asn1p_y.y" +{ + asn1p_constraint_t *ct; + ct = asn1p_constraint_new(yylineno); + checkmem(ct); + ct->type = ACT_EL_VALUE; + ct->value = asn1p_value_fromref(yyvsp[0].a_ref, 0); + CONSTRAINT_INSERT(yyval.a_constr, ACT_CA_CSV, yyvsp[-2].a_constr, ct); + ; + break;} +case 214: +#line 1632 "asn1p_y.y" +{ + char *p = malloc(strlen(yyvsp[0].tv_str) + 2); + int ret; + *p = '@'; + strcpy(p + 1, yyvsp[0].tv_str); + yyval.a_ref = asn1p_ref_new(yylineno); + ret = asn1p_ref_add_component(yyval.a_ref, p, 0); + checkmem(ret == 0); + free(p); + free(yyvsp[0].tv_str); + ; + break;} +case 215: +#line 1643 "asn1p_y.y" +{ + char *p = malloc(strlen(yyvsp[0].tv_str) + 3); + int ret; + p[0] = '@'; + p[1] = '.'; + strcpy(p + 2, yyvsp[0].tv_str); + yyval.a_ref = asn1p_ref_new(yylineno); + ret = asn1p_ref_add_component(yyval.a_ref, p, 0); + checkmem(ret == 0); + free(p); + free(yyvsp[0].tv_str); + ; + break;} +case 216: +#line 1659 "asn1p_y.y" +{ + yyval.tv_str = yyvsp[0].tv_str; + ; + break;} +case 217: +#line 1662 "asn1p_y.y" +{ + int l1 = strlen(yyvsp[-2].tv_str); + int l3 = strlen(yyvsp[0].tv_str); + yyval.tv_str = malloc(l1 + 1 + l3 + 1); + memcpy(yyval.tv_str, yyvsp[-2].tv_str, l1); + yyval.tv_str[l1] = '.'; + memcpy(yyval.tv_str + l1 + 1, yyvsp[0].tv_str, l3); + yyval.tv_str[l1 + 1 + l3] = '\0'; + ; + break;} +case 218: +#line 1680 "asn1p_y.y" +{ yyval.a_marker = EM_NOMARK; ; + break;} +case 219: +#line 1681 "asn1p_y.y" +{ yyval.a_marker = yyvsp[0].a_marker; ; + break;} +case 220: +#line 1685 "asn1p_y.y" +{ + yyval.a_marker = EM_OPTIONAL; + ; + break;} +case 221: +#line 1688 "asn1p_y.y" +{ + yyval.a_marker = EM_DEFAULT; + /* FIXME: store DefaultValue somewhere */ + ; + break;} +case 222: +#line 1695 "asn1p_y.y" +{ + ; + break;} +case 223: +#line 1697 "asn1p_y.y" +{ + ; + break;} +case 224: +#line 1699 "asn1p_y.y" +{ asn1p_lexer_hack_push_opaque_state(); ; + break;} +case 225: +#line 1699 "asn1p_y.y" +{ + ; + break;} +case 226: +#line 1720 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(asn1p_lineno); + checkmem(yyval.a_expr); + ; + break;} +case 227: +#line 1724 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[-1].a_expr; + ; + break;} +case 228: +#line 1730 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(asn1p_lineno); + checkmem(yyval.a_expr); + TQ_ADD(&(yyval.a_expr->members), yyvsp[0].a_expr, next); + ; + break;} +case 229: +#line 1735 "asn1p_y.y" +{ + yyval.a_expr = yyvsp[-2].a_expr; + TQ_ADD(&(yyval.a_expr->members), yyvsp[0].a_expr, next); + ; + break;} +case 230: +#line 1742 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(asn1p_lineno); + checkmem(yyval.a_expr); + yyval.a_expr->expr_type = A1TC_UNIVERVAL; + yyval.a_expr->meta_type = AMT_VALUE; + yyval.a_expr->Identifier = yyvsp[0].tv_str; + ; + break;} +case 231: +#line 1749 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(asn1p_lineno); + checkmem(yyval.a_expr); + yyval.a_expr->expr_type = A1TC_UNIVERVAL; + yyval.a_expr->meta_type = AMT_VALUE; + yyval.a_expr->Identifier = yyvsp[-3].tv_str; + yyval.a_expr->value = yyvsp[-1].a_value; + ; + break;} +case 232: +#line 1757 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(asn1p_lineno); + checkmem(yyval.a_expr); + yyval.a_expr->expr_type = A1TC_UNIVERVAL; + yyval.a_expr->meta_type = AMT_VALUE; + yyval.a_expr->Identifier = yyvsp[-3].tv_str; + yyval.a_expr->value = yyvsp[-1].a_value; + ; + break;} +case 233: +#line 1765 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(asn1p_lineno); + checkmem(yyval.a_expr); + yyval.a_expr->expr_type = A1TC_UNIVERVAL; + yyval.a_expr->meta_type = AMT_VALUE; + yyval.a_expr->value = yyvsp[0].a_value; + ; + break;} +case 234: +#line 1772 "asn1p_y.y" +{ + yyval.a_expr = asn1p_expr_new(asn1p_lineno); + checkmem(yyval.a_expr); + yyval.a_expr->Identifier = strdup("..."); + checkmem(yyval.a_expr->Identifier); + yyval.a_expr->expr_type = A1TC_EXTENSIBLE; + yyval.a_expr->meta_type = AMT_VALUE; + ; + break;} +case 235: +#line 1783 "asn1p_y.y" +{ + yyval.a_value = asn1p_value_fromint(yyvsp[0].a_int); + checkmem(yyval.a_value); + ; + break;} +case 236: +#line 1787 "asn1p_y.y" +{ + yyval.a_value = asn1p_value_fromint(yyvsp[0].a_int); + checkmem(yyval.a_value); + ; + break;} +case 237: +#line 1818 "asn1p_y.y" +{ memset(&yyval.a_tag, 0, sizeof(yyval.a_tag)); ; + break;} +case 238: +#line 1819 "asn1p_y.y" +{ yyval.a_tag = yyvsp[0].a_tag; ; + break;} +case 239: +#line 1823 "asn1p_y.y" +{ + yyval.a_tag = yyvsp[0].a_tag; + yyval.a_tag.tag_mode = TM_DEFAULT; + ; + break;} +case 240: +#line 1827 "asn1p_y.y" +{ + yyval.a_tag = yyvsp[-1].a_tag; + yyval.a_tag.tag_mode = TM_IMPLICIT; + ; + break;} +case 241: +#line 1831 "asn1p_y.y" +{ + yyval.a_tag = yyvsp[-1].a_tag; + yyval.a_tag.tag_mode = TM_EXPLICIT; + ; + break;} +case 242: +#line 1838 "asn1p_y.y" +{ + checkmem(yyvsp[0].tv_str); + yyval.tv_str = yyvsp[0].tv_str; + ; + break;} +case 243: +#line 1842 "asn1p_y.y" +{ + checkmem(yyvsp[0].tv_str); + yyval.tv_str = yyvsp[0].tv_str; + ; + break;} +case 244: +#line 1849 "asn1p_y.y" +{ + checkmem(yyvsp[0].tv_str); + yyval.tv_str = yyvsp[0].tv_str; + ; + break;} +case 245: +#line 1856 "asn1p_y.y" +{ + checkmem(yyvsp[0].tv_str); + yyval.tv_str = yyvsp[0].tv_str; + ; + break;} +case 246: +#line 1863 "asn1p_y.y" +{ + memset(&yyval.tv_nametag, 0, sizeof(yyval.tv_nametag)); + yyval.tv_nametag.name = yyvsp[0].tv_str; + ; + break;} +case 247: +#line 1867 "asn1p_y.y" +{ + yyval.tv_nametag.name = yyvsp[-1].tv_str; + yyval.tv_nametag.tag = yyvsp[0].a_tag; + ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/share/bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; + } + } + yyerror(msg); + free(msg); + } + else + yyerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror("parse error"); + } + + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; + + yyacceptlab: + /* YYACCEPT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 0; + + yyabortlab: + /* YYABORT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 1; +} +#line 1874 "asn1p_y.y" + + + +/* + * Convert Xstring ('0101'B or '5'H) to the binary vector. + */ +static asn1p_value_t * +_convert_bitstring2binary(char *str, int base) { + asn1p_value_t *val; + int slen; + int memlen; + int baselen; + int bits; + uint8_t *binary_vector; + uint8_t *bv_ptr; + uint8_t cur_val; + + assert(str); + assert(str[0] == '\''); + + switch(base) { + case 'B': + baselen = 1; + break; + case 'H': + baselen = 4; + break; + default: + assert(base == 'B' || base == 'H'); + errno = EINVAL; + return NULL; + } + + slen = strlen(str); + assert(str[slen - 1] == base); + assert(str[slen - 2] == '\''); + + memlen = slen / (8 / baselen); /* Conservative estimate */ + + bv_ptr = binary_vector = malloc(memlen + 1); + if(bv_ptr == NULL) + /* ENOMEM */ + return NULL; + + cur_val = 0; + bits = 0; + while(*(++str) != '\'') { + switch(baselen) { + case 1: + switch(*str) { + case '1': + cur_val |= 1 << (7 - (bits % 8)); + case '0': + break; + default: + assert(!"_y UNREACH1"); + case ' ': case '\r': case '\n': + continue; + } + break; + case 4: + switch(*str) { + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + cur_val |= (*str - '0') << (4 - (bits % 8)); + break; + case 'A': case 'B': case 'C': + case 'D': case 'E': case 'F': + cur_val |= ((*str - 'A') + 10) + << (4 - (bits % 8)); + break; + default: + assert(!"_y UNREACH2"); + case ' ': case '\r': case '\n': + continue; + } + break; + } + + bits += baselen; + if((bits % 8) == 0) { + *bv_ptr++ = cur_val; + cur_val = 0; + } + } + + *bv_ptr = cur_val; + assert((bv_ptr - binary_vector) <= memlen); + + val = asn1p_value_frombits(binary_vector, bits, 0); + if(val == NULL) { + free(binary_vector); + } + + return val; +} + +extern char *asn1p_text; + +int +yyerror(const char *msg) { + fprintf(stderr, + "ASN.1 grammar parse error " + "near line %d (token \"%s\"): %s\n", + asn1p_lineno, asn1p_text, msg); + return -1; +} + + |