~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/scripts/asn1_compiler.c

Version: ~ [ linux-5.9-rc6 ] ~ [ linux-5.8.10 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.66 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.146 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.198 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.236 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.236 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-or-later
  2 /* Simplified ASN.1 notation parser
  3  *
  4  * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
  5  * Written by David Howells (dhowells@redhat.com)
  6  */
  7 
  8 #include <stdarg.h>
  9 #include <stdio.h>
 10 #include <stdlib.h>
 11 #include <stdint.h>
 12 #include <stdbool.h>
 13 #include <string.h>
 14 #include <ctype.h>
 15 #include <unistd.h>
 16 #include <fcntl.h>
 17 #include <sys/stat.h>
 18 #include <linux/asn1_ber_bytecode.h>
 19 
 20 enum token_type {
 21         DIRECTIVE_ABSENT,
 22         DIRECTIVE_ALL,
 23         DIRECTIVE_ANY,
 24         DIRECTIVE_APPLICATION,
 25         DIRECTIVE_AUTOMATIC,
 26         DIRECTIVE_BEGIN,
 27         DIRECTIVE_BIT,
 28         DIRECTIVE_BMPString,
 29         DIRECTIVE_BOOLEAN,
 30         DIRECTIVE_BY,
 31         DIRECTIVE_CHARACTER,
 32         DIRECTIVE_CHOICE,
 33         DIRECTIVE_CLASS,
 34         DIRECTIVE_COMPONENT,
 35         DIRECTIVE_COMPONENTS,
 36         DIRECTIVE_CONSTRAINED,
 37         DIRECTIVE_CONTAINING,
 38         DIRECTIVE_DEFAULT,
 39         DIRECTIVE_DEFINED,
 40         DIRECTIVE_DEFINITIONS,
 41         DIRECTIVE_EMBEDDED,
 42         DIRECTIVE_ENCODED,
 43         DIRECTIVE_ENCODING_CONTROL,
 44         DIRECTIVE_END,
 45         DIRECTIVE_ENUMERATED,
 46         DIRECTIVE_EXCEPT,
 47         DIRECTIVE_EXPLICIT,
 48         DIRECTIVE_EXPORTS,
 49         DIRECTIVE_EXTENSIBILITY,
 50         DIRECTIVE_EXTERNAL,
 51         DIRECTIVE_FALSE,
 52         DIRECTIVE_FROM,
 53         DIRECTIVE_GeneralString,
 54         DIRECTIVE_GeneralizedTime,
 55         DIRECTIVE_GraphicString,
 56         DIRECTIVE_IA5String,
 57         DIRECTIVE_IDENTIFIER,
 58         DIRECTIVE_IMPLICIT,
 59         DIRECTIVE_IMPLIED,
 60         DIRECTIVE_IMPORTS,
 61         DIRECTIVE_INCLUDES,
 62         DIRECTIVE_INSTANCE,
 63         DIRECTIVE_INSTRUCTIONS,
 64         DIRECTIVE_INTEGER,
 65         DIRECTIVE_INTERSECTION,
 66         DIRECTIVE_ISO646String,
 67         DIRECTIVE_MAX,
 68         DIRECTIVE_MIN,
 69         DIRECTIVE_MINUS_INFINITY,
 70         DIRECTIVE_NULL,
 71         DIRECTIVE_NumericString,
 72         DIRECTIVE_OBJECT,
 73         DIRECTIVE_OCTET,
 74         DIRECTIVE_OF,
 75         DIRECTIVE_OPTIONAL,
 76         DIRECTIVE_ObjectDescriptor,
 77         DIRECTIVE_PATTERN,
 78         DIRECTIVE_PDV,
 79         DIRECTIVE_PLUS_INFINITY,
 80         DIRECTIVE_PRESENT,
 81         DIRECTIVE_PRIVATE,
 82         DIRECTIVE_PrintableString,
 83         DIRECTIVE_REAL,
 84         DIRECTIVE_RELATIVE_OID,
 85         DIRECTIVE_SEQUENCE,
 86         DIRECTIVE_SET,
 87         DIRECTIVE_SIZE,
 88         DIRECTIVE_STRING,
 89         DIRECTIVE_SYNTAX,
 90         DIRECTIVE_T61String,
 91         DIRECTIVE_TAGS,
 92         DIRECTIVE_TRUE,
 93         DIRECTIVE_TeletexString,
 94         DIRECTIVE_UNION,
 95         DIRECTIVE_UNIQUE,
 96         DIRECTIVE_UNIVERSAL,
 97         DIRECTIVE_UTCTime,
 98         DIRECTIVE_UTF8String,
 99         DIRECTIVE_UniversalString,
100         DIRECTIVE_VideotexString,
101         DIRECTIVE_VisibleString,
102         DIRECTIVE_WITH,
103         NR__DIRECTIVES,
104         TOKEN_ASSIGNMENT = NR__DIRECTIVES,
105         TOKEN_OPEN_CURLY,
106         TOKEN_CLOSE_CURLY,
107         TOKEN_OPEN_SQUARE,
108         TOKEN_CLOSE_SQUARE,
109         TOKEN_OPEN_ACTION,
110         TOKEN_CLOSE_ACTION,
111         TOKEN_COMMA,
112         TOKEN_NUMBER,
113         TOKEN_TYPE_NAME,
114         TOKEN_ELEMENT_NAME,
115         NR__TOKENS
116 };
117 
118 static const unsigned char token_to_tag[NR__TOKENS] = {
119         /* EOC goes first */
120         [DIRECTIVE_BOOLEAN]             = ASN1_BOOL,
121         [DIRECTIVE_INTEGER]             = ASN1_INT,
122         [DIRECTIVE_BIT]                 = ASN1_BTS,
123         [DIRECTIVE_OCTET]               = ASN1_OTS,
124         [DIRECTIVE_NULL]                = ASN1_NULL,
125         [DIRECTIVE_OBJECT]              = ASN1_OID,
126         [DIRECTIVE_ObjectDescriptor]    = ASN1_ODE,
127         [DIRECTIVE_EXTERNAL]            = ASN1_EXT,
128         [DIRECTIVE_REAL]                = ASN1_REAL,
129         [DIRECTIVE_ENUMERATED]          = ASN1_ENUM,
130         [DIRECTIVE_EMBEDDED]            = 0,
131         [DIRECTIVE_UTF8String]          = ASN1_UTF8STR,
132         [DIRECTIVE_RELATIVE_OID]        = ASN1_RELOID,
133         /* 14 */
134         /* 15 */
135         [DIRECTIVE_SEQUENCE]            = ASN1_SEQ,
136         [DIRECTIVE_SET]                 = ASN1_SET,
137         [DIRECTIVE_NumericString]       = ASN1_NUMSTR,
138         [DIRECTIVE_PrintableString]     = ASN1_PRNSTR,
139         [DIRECTIVE_T61String]           = ASN1_TEXSTR,
140         [DIRECTIVE_TeletexString]       = ASN1_TEXSTR,
141         [DIRECTIVE_VideotexString]      = ASN1_VIDSTR,
142         [DIRECTIVE_IA5String]           = ASN1_IA5STR,
143         [DIRECTIVE_UTCTime]             = ASN1_UNITIM,
144         [DIRECTIVE_GeneralizedTime]     = ASN1_GENTIM,
145         [DIRECTIVE_GraphicString]       = ASN1_GRASTR,
146         [DIRECTIVE_VisibleString]       = ASN1_VISSTR,
147         [DIRECTIVE_GeneralString]       = ASN1_GENSTR,
148         [DIRECTIVE_UniversalString]     = ASN1_UNITIM,
149         [DIRECTIVE_CHARACTER]           = ASN1_CHRSTR,
150         [DIRECTIVE_BMPString]           = ASN1_BMPSTR,
151 };
152 
153 static const char asn1_classes[4][5] = {
154         [ASN1_UNIV]     = "UNIV",
155         [ASN1_APPL]     = "APPL",
156         [ASN1_CONT]     = "CONT",
157         [ASN1_PRIV]     = "PRIV"
158 };
159 
160 static const char asn1_methods[2][5] = {
161         [ASN1_UNIV]     = "PRIM",
162         [ASN1_APPL]     = "CONS"
163 };
164 
165 static const char *const asn1_universal_tags[32] = {
166         "EOC",
167         "BOOL",
168         "INT",
169         "BTS",
170         "OTS",
171         "NULL",
172         "OID",
173         "ODE",
174         "EXT",
175         "REAL",
176         "ENUM",
177         "EPDV",
178         "UTF8STR",
179         "RELOID",
180         NULL,           /* 14 */
181         NULL,           /* 15 */
182         "SEQ",
183         "SET",
184         "NUMSTR",
185         "PRNSTR",
186         "TEXSTR",
187         "VIDSTR",
188         "IA5STR",
189         "UNITIM",
190         "GENTIM",
191         "GRASTR",
192         "VISSTR",
193         "GENSTR",
194         "UNISTR",
195         "CHRSTR",
196         "BMPSTR",
197         NULL            /* 31 */
198 };
199 
200 static const char *filename;
201 static const char *grammar_name;
202 static const char *outputname;
203 static const char *headername;
204 
205 static const char *const directives[NR__DIRECTIVES] = {
206 #define _(X) [DIRECTIVE_##X] = #X
207         _(ABSENT),
208         _(ALL),
209         _(ANY),
210         _(APPLICATION),
211         _(AUTOMATIC),
212         _(BEGIN),
213         _(BIT),
214         _(BMPString),
215         _(BOOLEAN),
216         _(BY),
217         _(CHARACTER),
218         _(CHOICE),
219         _(CLASS),
220         _(COMPONENT),
221         _(COMPONENTS),
222         _(CONSTRAINED),
223         _(CONTAINING),
224         _(DEFAULT),
225         _(DEFINED),
226         _(DEFINITIONS),
227         _(EMBEDDED),
228         _(ENCODED),
229         [DIRECTIVE_ENCODING_CONTROL] = "ENCODING-CONTROL",
230         _(END),
231         _(ENUMERATED),
232         _(EXCEPT),
233         _(EXPLICIT),
234         _(EXPORTS),
235         _(EXTENSIBILITY),
236         _(EXTERNAL),
237         _(FALSE),
238         _(FROM),
239         _(GeneralString),
240         _(GeneralizedTime),
241         _(GraphicString),
242         _(IA5String),
243         _(IDENTIFIER),
244         _(IMPLICIT),
245         _(IMPLIED),
246         _(IMPORTS),
247         _(INCLUDES),
248         _(INSTANCE),
249         _(INSTRUCTIONS),
250         _(INTEGER),
251         _(INTERSECTION),
252         _(ISO646String),
253         _(MAX),
254         _(MIN),
255         [DIRECTIVE_MINUS_INFINITY] = "MINUS-INFINITY",
256         [DIRECTIVE_NULL] = "NULL",
257         _(NumericString),
258         _(OBJECT),
259         _(OCTET),
260         _(OF),
261         _(OPTIONAL),
262         _(ObjectDescriptor),
263         _(PATTERN),
264         _(PDV),
265         [DIRECTIVE_PLUS_INFINITY] = "PLUS-INFINITY",
266         _(PRESENT),
267         _(PRIVATE),
268         _(PrintableString),
269         _(REAL),
270         [DIRECTIVE_RELATIVE_OID] = "RELATIVE-OID",
271         _(SEQUENCE),
272         _(SET),
273         _(SIZE),
274         _(STRING),
275         _(SYNTAX),
276         _(T61String),
277         _(TAGS),
278         _(TRUE),
279         _(TeletexString),
280         _(UNION),
281         _(UNIQUE),
282         _(UNIVERSAL),
283         _(UTCTime),
284         _(UTF8String),
285         _(UniversalString),
286         _(VideotexString),
287         _(VisibleString),
288         _(WITH)
289 };
290 
291 struct action {
292         struct action   *next;
293         char            *name;
294         unsigned char   index;
295 };
296 
297 static struct action *action_list;
298 static unsigned nr_actions;
299 
300 struct token {
301         unsigned short  line;
302         enum token_type token_type : 8;
303         unsigned char   size;
304         struct action   *action;
305         char            *content;
306         struct type     *type;
307 };
308 
309 static struct token *token_list;
310 static unsigned nr_tokens;
311 static bool verbose_opt;
312 static bool debug_opt;
313 
314 #define verbose(fmt, ...) do { if (verbose_opt) printf(fmt, ## __VA_ARGS__); } while (0)
315 #define debug(fmt, ...) do { if (debug_opt) printf(fmt, ## __VA_ARGS__); } while (0)
316 
317 static int directive_compare(const void *_key, const void *_pdir)
318 {
319         const struct token *token = _key;
320         const char *const *pdir = _pdir, *dir = *pdir;
321         size_t dlen, clen;
322         int val;
323 
324         dlen = strlen(dir);
325         clen = (dlen < token->size) ? dlen : token->size;
326 
327         //debug("cmp(%s,%s) = ", token->content, dir);
328 
329         val = memcmp(token->content, dir, clen);
330         if (val != 0) {
331                 //debug("%d [cmp]\n", val);
332                 return val;
333         }
334 
335         if (dlen == token->size) {
336                 //debug("\n");
337                 return 0;
338         }
339         //debug("%d\n", (int)dlen - (int)token->size);
340         return dlen - token->size; /* shorter -> negative */
341 }
342 
343 /*
344  * Tokenise an ASN.1 grammar
345  */
346 static void tokenise(char *buffer, char *end)
347 {
348         struct token *tokens;
349         char *line, *nl, *start, *p, *q;
350         unsigned tix, lineno;
351 
352         /* Assume we're going to have half as many tokens as we have
353          * characters
354          */
355         token_list = tokens = calloc((end - buffer) / 2, sizeof(struct token));
356         if (!tokens) {
357                 perror(NULL);
358                 exit(1);
359         }
360         tix = 0;
361 
362         lineno = 0;
363         while (buffer < end) {
364                 /* First of all, break out a line */
365                 lineno++;
366                 line = buffer;
367                 nl = memchr(line, '\n', end - buffer);
368                 if (!nl) {
369                         buffer = nl = end;
370                 } else {
371                         buffer = nl + 1;
372                         *nl = '\0';
373                 }
374 
375                 /* Remove "--" comments */
376                 p = line;
377         next_comment:
378                 while ((p = memchr(p, '-', nl - p))) {
379                         if (p[1] == '-') {
380                                 /* Found a comment; see if there's a terminator */
381                                 q = p + 2;
382                                 while ((q = memchr(q, '-', nl - q))) {
383                                         if (q[1] == '-') {
384                                                 /* There is - excise the comment */
385                                                 q += 2;
386                                                 memmove(p, q, nl - q);
387                                                 goto next_comment;
388                                         }
389                                         q++;
390                                 }
391                                 *p = '\0';
392                                 nl = p;
393                                 break;
394                         } else {
395                                 p++;
396                         }
397                 }
398 
399                 p = line;
400                 while (p < nl) {
401                         /* Skip white space */
402                         while (p < nl && isspace(*p))
403                                 *(p++) = 0;
404                         if (p >= nl)
405                                 break;
406 
407                         tokens[tix].line = lineno;
408                         start = p;
409 
410                         /* Handle string tokens */
411                         if (isalpha(*p)) {
412                                 const char **dir;
413 
414                                 /* Can be a directive, type name or element
415                                  * name.  Find the end of the name.
416                                  */
417                                 q = p + 1;
418                                 while (q < nl && (isalnum(*q) || *q == '-' || *q == '_'))
419                                         q++;
420                                 tokens[tix].size = q - p;
421                                 p = q;
422 
423                                 tokens[tix].content = malloc(tokens[tix].size + 1);
424                                 if (!tokens[tix].content) {
425                                         perror(NULL);
426                                         exit(1);
427                                 }
428                                 memcpy(tokens[tix].content, start, tokens[tix].size);
429                                 tokens[tix].content[tokens[tix].size] = 0;
430                                 
431                                 /* If it begins with a lowercase letter then
432                                  * it's an element name
433                                  */
434                                 if (islower(tokens[tix].content[0])) {
435                                         tokens[tix++].token_type = TOKEN_ELEMENT_NAME;
436                                         continue;
437                                 }
438 
439                                 /* Otherwise we need to search the directive
440                                  * table
441                                  */
442                                 dir = bsearch(&tokens[tix], directives,
443                                               sizeof(directives) / sizeof(directives[1]),
444                                               sizeof(directives[1]),
445                                               directive_compare);
446                                 if (dir) {
447                                         tokens[tix++].token_type = dir - directives;
448                                         continue;
449                                 }
450 
451                                 tokens[tix++].token_type = TOKEN_TYPE_NAME;
452                                 continue;
453                         }
454 
455                         /* Handle numbers */
456                         if (isdigit(*p)) {
457                                 /* Find the end of the number */
458                                 q = p + 1;
459                                 while (q < nl && (isdigit(*q)))
460                                         q++;
461                                 tokens[tix].size = q - p;
462                                 p = q;
463                                 tokens[tix].content = malloc(tokens[tix].size + 1);
464                                 if (!tokens[tix].content) {
465                                         perror(NULL);
466                                         exit(1);
467                                 }
468                                 memcpy(tokens[tix].content, start, tokens[tix].size);
469                                 tokens[tix].content[tokens[tix].size] = 0;
470                                 tokens[tix++].token_type = TOKEN_NUMBER;
471                                 continue;
472                         }
473 
474                         if (nl - p >= 3) {
475                                 if (memcmp(p, "::=", 3) == 0) {
476                                         p += 3;
477                                         tokens[tix].size = 3;
478                                         tokens[tix].content = "::=";
479                                         tokens[tix++].token_type = TOKEN_ASSIGNMENT;
480                                         continue;
481                                 }
482                         }
483 
484                         if (nl - p >= 2) {
485                                 if (memcmp(p, "({", 2) == 0) {
486                                         p += 2;
487                                         tokens[tix].size = 2;
488                                         tokens[tix].content = "({";
489                                         tokens[tix++].token_type = TOKEN_OPEN_ACTION;
490                                         continue;
491                                 }
492                                 if (memcmp(p, "})", 2) == 0) {
493                                         p += 2;
494                                         tokens[tix].size = 2;
495                                         tokens[tix].content = "})";
496                                         tokens[tix++].token_type = TOKEN_CLOSE_ACTION;
497                                         continue;
498                                 }
499                         }
500 
501                         if (nl - p >= 1) {
502                                 tokens[tix].size = 1;
503                                 switch (*p) {
504                                 case '{':
505                                         p += 1;
506                                         tokens[tix].content = "{";
507                                         tokens[tix++].token_type = TOKEN_OPEN_CURLY;
508                                         continue;
509                                 case '}':
510                                         p += 1;
511                                         tokens[tix].content = "}";
512                                         tokens[tix++].token_type = TOKEN_CLOSE_CURLY;
513                                         continue;
514                                 case '[':
515                                         p += 1;
516                                         tokens[tix].content = "[";
517                                         tokens[tix++].token_type = TOKEN_OPEN_SQUARE;
518                                         continue;
519                                 case ']':
520                                         p += 1;
521                                         tokens[tix].content = "]";
522                                         tokens[tix++].token_type = TOKEN_CLOSE_SQUARE;
523                                         continue;
524                                 case ',':
525                                         p += 1;
526                                         tokens[tix].content = ",";
527                                         tokens[tix++].token_type = TOKEN_COMMA;
528                                         continue;
529                                 default:
530                                         break;
531                                 }
532                         }
533 
534                         fprintf(stderr, "%s:%u: Unknown character in grammar: '%c'\n",
535                                 filename, lineno, *p);
536                         exit(1);
537                 }
538         }
539 
540         nr_tokens = tix;
541         verbose("Extracted %u tokens\n", nr_tokens);
542 
543 #if 0
544         {
545                 int n;
546                 for (n = 0; n < nr_tokens; n++)
547                         debug("Token %3u: '%s'\n", n, token_list[n].content);
548         }
549 #endif
550 }
551 
552 static void build_type_list(void);
553 static void parse(void);
554 static void dump_elements(void);
555 static void render(FILE *out, FILE *hdr);
556 
557 /*
558  *
559  */
560 int main(int argc, char **argv)
561 {
562         struct stat st;
563         ssize_t readlen;
564         FILE *out, *hdr;
565         char *buffer, *p;
566         char *kbuild_verbose;
567         int fd;
568 
569         kbuild_verbose = getenv("KBUILD_VERBOSE");
570         if (kbuild_verbose)
571                 verbose_opt = atoi(kbuild_verbose);
572 
573         while (argc > 4) {
574                 if (strcmp(argv[1], "-v") == 0)
575                         verbose_opt = true;
576                 else if (strcmp(argv[1], "-d") == 0)
577                         debug_opt = true;
578                 else
579                         break;
580                 memmove(&argv[1], &argv[2], (argc - 2) * sizeof(char *));
581                 argc--;
582         }
583 
584         if (argc != 4) {
585                 fprintf(stderr, "Format: %s [-v] [-d] <grammar-file> <c-file> <hdr-file>\n",
586                         argv[0]);
587                 exit(2);
588         }
589 
590         filename = argv[1];
591         outputname = argv[2];
592         headername = argv[3];
593 
594         fd = open(filename, O_RDONLY);
595         if (fd < 0) {
596                 perror(filename);
597                 exit(1);
598         }
599 
600         if (fstat(fd, &st) < 0) {
601                 perror(filename);
602                 exit(1);
603         }
604 
605         if (!(buffer = malloc(st.st_size + 1))) {
606                 perror(NULL);
607                 exit(1);
608         }
609 
610         if ((readlen = read(fd, buffer, st.st_size)) < 0) {
611                 perror(filename);
612                 exit(1);
613         }
614 
615         if (close(fd) < 0) {
616                 perror(filename);
617                 exit(1);
618         }
619 
620         if (readlen != st.st_size) {
621                 fprintf(stderr, "%s: Short read\n", filename);
622                 exit(1);
623         }
624 
625         p = strrchr(argv[1], '/');
626         p = p ? p + 1 : argv[1];
627         grammar_name = strdup(p);
628         if (!p) {
629                 perror(NULL);
630                 exit(1);
631         }
632         p = strchr(grammar_name, '.');
633         if (p)
634                 *p = '\0';
635 
636         buffer[readlen] = 0;
637         tokenise(buffer, buffer + readlen);
638         build_type_list();
639         parse();
640         dump_elements();
641 
642         out = fopen(outputname, "w");
643         if (!out) {
644                 perror(outputname);
645                 exit(1);
646         }
647 
648         hdr = fopen(headername, "w");
649         if (!hdr) {
650                 perror(headername);
651                 exit(1);
652         }
653 
654         render(out, hdr);
655 
656         if (fclose(out) < 0) {
657                 perror(outputname);
658                 exit(1);
659         }
660 
661         if (fclose(hdr) < 0) {
662                 perror(headername);
663                 exit(1);
664         }
665 
666         return 0;
667 }
668 
669 enum compound {
670         NOT_COMPOUND,
671         SET,
672         SET_OF,
673         SEQUENCE,
674         SEQUENCE_OF,
675         CHOICE,
676         ANY,
677         TYPE_REF,
678         TAG_OVERRIDE
679 };
680 
681 struct element {
682         struct type     *type_def;
683         struct token    *name;
684         struct token    *type;
685         struct action   *action;
686         struct element  *children;
687         struct element  *next;
688         struct element  *render_next;
689         struct element  *list_next;
690         uint8_t         n_elements;
691         enum compound   compound : 8;
692         enum asn1_class class : 8;
693         enum asn1_method method : 8;
694         uint8_t         tag;
695         unsigned        entry_index;
696         unsigned        flags;
697 #define ELEMENT_IMPLICIT        0x0001
698 #define ELEMENT_EXPLICIT        0x0002
699 #define ELEMENT_TAG_SPECIFIED   0x0004
700 #define ELEMENT_RENDERED        0x0008
701 #define ELEMENT_SKIPPABLE       0x0010
702 #define ELEMENT_CONDITIONAL     0x0020
703 };
704 
705 struct type {
706         struct token    *name;
707         struct token    *def;
708         struct element  *element;
709         unsigned        ref_count;
710         unsigned        flags;
711 #define TYPE_STOP_MARKER        0x0001
712 #define TYPE_BEGIN              0x0002
713 };
714 
715 static struct type *type_list;
716 static struct type **type_index;
717 static unsigned nr_types;
718 
719 static int type_index_compare(const void *_a, const void *_b)
720 {
721         const struct type *const *a = _a, *const *b = _b;
722 
723         if ((*a)->name->size != (*b)->name->size)
724                 return (*a)->name->size - (*b)->name->size;
725         else
726                 return memcmp((*a)->name->content, (*b)->name->content,
727                               (*a)->name->size);
728 }
729 
730 static int type_finder(const void *_key, const void *_ti)
731 {
732         const struct token *token = _key;
733         const struct type *const *ti = _ti;
734         const struct type *type = *ti;
735 
736         if (token->size != type->name->size)
737                 return token->size - type->name->size;
738         else
739                 return memcmp(token->content, type->name->content,
740                               token->size);
741 }
742 
743 /*
744  * Build up a list of types and a sorted index to that list.
745  */
746 static void build_type_list(void)
747 {
748         struct type *types;
749         unsigned nr, t, n;
750 
751         nr = 0;
752         for (n = 0; n < nr_tokens - 1; n++)
753                 if (token_list[n + 0].token_type == TOKEN_TYPE_NAME &&
754                     token_list[n + 1].token_type == TOKEN_ASSIGNMENT)
755                         nr++;
756 
757         if (nr == 0) {
758                 fprintf(stderr, "%s: No defined types\n", filename);
759                 exit(1);
760         }
761 
762         nr_types = nr;
763         types = type_list = calloc(nr + 1, sizeof(type_list[0]));
764         if (!type_list) {
765                 perror(NULL);
766                 exit(1);
767         }
768         type_index = calloc(nr, sizeof(type_index[0]));
769         if (!type_index) {
770                 perror(NULL);
771                 exit(1);
772         }
773 
774         t = 0;
775         types[t].flags |= TYPE_BEGIN;
776         for (n = 0; n < nr_tokens - 1; n++) {
777                 if (token_list[n + 0].token_type == TOKEN_TYPE_NAME &&
778                     token_list[n + 1].token_type == TOKEN_ASSIGNMENT) {
779                         types[t].name = &token_list[n];
780                         type_index[t] = &types[t];
781                         t++;
782                 }
783         }
784         types[t].name = &token_list[n + 1];
785         types[t].flags |= TYPE_STOP_MARKER;
786 
787         qsort(type_index, nr, sizeof(type_index[0]), type_index_compare);
788 
789         verbose("Extracted %u types\n", nr_types);
790 #if 0
791         for (n = 0; n < nr_types; n++) {
792                 struct type *type = type_index[n];
793                 debug("- %*.*s\n", type->name->content);
794         }
795 #endif
796 }
797 
798 static struct element *parse_type(struct token **_cursor, struct token *stop,
799                                   struct token *name);
800 
801 /*
802  * Parse the token stream
803  */
804 static void parse(void)
805 {
806         struct token *cursor;
807         struct type *type;
808 
809         /* Parse one type definition statement at a time */
810         type = type_list;
811         do {
812                 cursor = type->name;
813 
814                 if (cursor[0].token_type != TOKEN_TYPE_NAME ||
815                     cursor[1].token_type != TOKEN_ASSIGNMENT)
816                         abort();
817                 cursor += 2;
818 
819                 type->element = parse_type(&cursor, type[1].name, NULL);
820                 type->element->type_def = type;
821 
822                 if (cursor != type[1].name) {
823                         fprintf(stderr, "%s:%d: Parse error at token '%s'\n",
824                                 filename, cursor->line, cursor->content);
825                         exit(1);
826                 }
827 
828         } while (type++, !(type->flags & TYPE_STOP_MARKER));
829 
830         verbose("Extracted %u actions\n", nr_actions);
831 }
832 
833 static struct element *element_list;
834 
835 static struct element *alloc_elem(struct token *type)
836 {
837         struct element *e = calloc(1, sizeof(*e));
838         if (!e) {
839                 perror(NULL);
840                 exit(1);
841         }
842         e->list_next = element_list;
843         element_list = e;
844         return e;
845 }
846 
847 static struct element *parse_compound(struct token **_cursor, struct token *end,
848                                       int alternates);
849 
850 /*
851  * Parse one type definition statement
852  */
853 static struct element *parse_type(struct token **_cursor, struct token *end,
854                                   struct token *name)
855 {
856         struct element *top, *element;
857         struct action *action, **ppaction;
858         struct token *cursor = *_cursor;
859         struct type **ref;
860         char *p;
861         int labelled = 0, implicit = 0;
862 
863         top = element = alloc_elem(cursor);
864         element->class = ASN1_UNIV;
865         element->method = ASN1_PRIM;
866         element->tag = token_to_tag[cursor->token_type];
867         element->name = name;
868 
869         /* Extract the tag value if one given */
870         if (cursor->token_type == TOKEN_OPEN_SQUARE) {
871                 cursor++;
872                 if (cursor >= end)
873                         goto overrun_error;
874                 switch (cursor->token_type) {
875                 case DIRECTIVE_UNIVERSAL:
876                         element->class = ASN1_UNIV;
877                         cursor++;
878                         break;
879                 case DIRECTIVE_APPLICATION:
880                         element->class = ASN1_APPL;
881                         cursor++;
882                         break;
883                 case TOKEN_NUMBER:
884                         element->class = ASN1_CONT;
885                         break;
886                 case DIRECTIVE_PRIVATE:
887                         element->class = ASN1_PRIV;
888                         cursor++;
889                         break;
890                 default:
891                         fprintf(stderr, "%s:%d: Unrecognised tag class token '%s'\n",
892                                 filename, cursor->line, cursor->content);
893                         exit(1);
894                 }
895 
896                 if (cursor >= end)
897                         goto overrun_error;
898                 if (cursor->token_type != TOKEN_NUMBER) {
899                         fprintf(stderr, "%s:%d: Missing tag number '%s'\n",
900                                 filename, cursor->line, cursor->content);
901                         exit(1);
902                 }
903 
904                 element->tag &= ~0x1f;
905                 element->tag |= strtoul(cursor->content, &p, 10);
906                 element->flags |= ELEMENT_TAG_SPECIFIED;
907                 if (p - cursor->content != cursor->size)
908                         abort();
909                 cursor++;
910 
911                 if (cursor >= end)
912                         goto overrun_error;
913                 if (cursor->token_type != TOKEN_CLOSE_SQUARE) {
914                         fprintf(stderr, "%s:%d: Missing closing square bracket '%s'\n",
915                                 filename, cursor->line, cursor->content);
916                         exit(1);
917                 }
918                 cursor++;
919                 if (cursor >= end)
920                         goto overrun_error;
921                 labelled = 1;
922         }
923 
924         /* Handle implicit and explicit markers */
925         if (cursor->token_type == DIRECTIVE_IMPLICIT) {
926                 element->flags |= ELEMENT_IMPLICIT;
927                 implicit = 1;
928                 cursor++;
929                 if (cursor >= end)
930                         goto overrun_error;
931         } else if (cursor->token_type == DIRECTIVE_EXPLICIT) {
932                 element->flags |= ELEMENT_EXPLICIT;
933                 cursor++;
934                 if (cursor >= end)
935                         goto overrun_error;
936         }
937 
938         if (labelled) {
939                 if (!implicit)
940                         element->method |= ASN1_CONS;
941                 element->compound = implicit ? TAG_OVERRIDE : SEQUENCE;
942                 element->children = alloc_elem(cursor);
943                 element = element->children;
944                 element->class = ASN1_UNIV;
945                 element->method = ASN1_PRIM;
946                 element->tag = token_to_tag[cursor->token_type];
947                 element->name = name;
948         }
949 
950         /* Extract the type we're expecting here */
951         element->type = cursor;
952         switch (cursor->token_type) {
953         case DIRECTIVE_ANY:
954                 element->compound = ANY;
955                 cursor++;
956                 break;
957 
958         case DIRECTIVE_NULL:
959         case DIRECTIVE_BOOLEAN:
960         case DIRECTIVE_ENUMERATED:
961         case DIRECTIVE_INTEGER:
962                 element->compound = NOT_COMPOUND;
963                 cursor++;
964                 break;
965 
966         case DIRECTIVE_EXTERNAL:
967                 element->method = ASN1_CONS;
968 
969         case DIRECTIVE_BMPString:
970         case DIRECTIVE_GeneralString:
971         case DIRECTIVE_GraphicString:
972         case DIRECTIVE_IA5String:
973         case DIRECTIVE_ISO646String:
974         case DIRECTIVE_NumericString:
975         case DIRECTIVE_PrintableString:
976         case DIRECTIVE_T61String:
977         case DIRECTIVE_TeletexString:
978         case DIRECTIVE_UniversalString:
979         case DIRECTIVE_UTF8String:
980         case DIRECTIVE_VideotexString:
981         case DIRECTIVE_VisibleString:
982         case DIRECTIVE_ObjectDescriptor:
983         case DIRECTIVE_GeneralizedTime:
984         case DIRECTIVE_UTCTime:
985                 element->compound = NOT_COMPOUND;
986                 cursor++;
987                 break;
988 
989         case DIRECTIVE_BIT:
990         case DIRECTIVE_OCTET:
991                 element->compound = NOT_COMPOUND;
992                 cursor++;
993                 if (cursor >= end)
994                         goto overrun_error;
995                 if (cursor->token_type != DIRECTIVE_STRING)
996                         goto parse_error;
997                 cursor++;
998                 break;
999 
1000         case DIRECTIVE_OBJECT:
1001                 element->compound = NOT_COMPOUND;
1002                 cursor++;
1003                 if (cursor >= end)
1004                         goto overrun_error;
1005                 if (cursor->token_type != DIRECTIVE_IDENTIFIER)
1006                         goto parse_error;
1007                 cursor++;
1008                 break;
1009 
1010         case TOKEN_TYPE_NAME:
1011                 element->compound = TYPE_REF;
1012                 ref = bsearch(cursor, type_index, nr_types, sizeof(type_index[0]),
1013                               type_finder);
1014                 if (!ref) {
1015                         fprintf(stderr, "%s:%d: Type '%s' undefined\n",
1016                                 filename, cursor->line, cursor->content);
1017                         exit(1);
1018                 }
1019                 cursor->type = *ref;
1020                 (*ref)->ref_count++;
1021                 cursor++;
1022                 break;
1023 
1024         case DIRECTIVE_CHOICE:
1025                 element->compound = CHOICE;
1026                 cursor++;
1027                 element->children = parse_compound(&cursor, end, 1);
1028                 break;
1029 
1030         case DIRECTIVE_SEQUENCE:
1031                 element->compound = SEQUENCE;
1032                 element->method = ASN1_CONS;
1033                 cursor++;
1034                 if (cursor >= end)
1035                         goto overrun_error;
1036                 if (cursor->token_type == DIRECTIVE_OF) {
1037                         element->compound = SEQUENCE_OF;
1038                         cursor++;
1039                         if (cursor >= end)
1040                                 goto overrun_error;
1041                         element->children = parse_type(&cursor, end, NULL);
1042                 } else {
1043                         element->children = parse_compound(&cursor, end, 0);
1044                 }
1045                 break;
1046 
1047         case DIRECTIVE_SET:
1048                 element->compound = SET;
1049                 element->method = ASN1_CONS;
1050                 cursor++;
1051                 if (cursor >= end)
1052                         goto overrun_error;
1053                 if (cursor->token_type == DIRECTIVE_OF) {
1054                         element->compound = SET_OF;
1055                         cursor++;
1056                         if (cursor >= end)
1057                                 goto parse_error;
1058                         element->children = parse_type(&cursor, end, NULL);
1059                 } else {
1060                         element->children = parse_compound(&cursor, end, 1);
1061                 }
1062                 break;
1063 
1064         default:
1065                 fprintf(stderr, "%s:%d: Token '%s' does not introduce a type\n",
1066                         filename, cursor->line, cursor->content);
1067                 exit(1);
1068         }
1069 
1070         /* Handle elements that are optional */
1071         if (cursor < end && (cursor->token_type == DIRECTIVE_OPTIONAL ||
1072                              cursor->token_type == DIRECTIVE_DEFAULT)
1073             ) {
1074                 cursor++;
1075                 top->flags |= ELEMENT_SKIPPABLE;
1076         }
1077 
1078         if (cursor < end && cursor->token_type == TOKEN_OPEN_ACTION) {
1079                 cursor++;
1080                 if (cursor >= end)
1081                         goto overrun_error;
1082                 if (cursor->token_type != TOKEN_ELEMENT_NAME) {
1083                         fprintf(stderr, "%s:%d: Token '%s' is not an action function name\n",
1084                                 filename, cursor->line, cursor->content);
1085                         exit(1);
1086                 }
1087 
1088                 action = malloc(sizeof(struct action));
1089                 if (!action) {
1090                         perror(NULL);
1091                         exit(1);
1092                 }
1093                 action->index = 0;
1094                 action->name = cursor->content;
1095 
1096                 for (ppaction = &action_list;
1097                      *ppaction;
1098                      ppaction = &(*ppaction)->next
1099                      ) {
1100                         int cmp = strcmp(action->name, (*ppaction)->name);
1101                         if (cmp == 0) {
1102                                 free(action);
1103                                 action = *ppaction;
1104                                 goto found;
1105                         }
1106                         if (cmp < 0) {
1107                                 action->next = *ppaction;
1108                                 *ppaction = action;
1109                                 nr_actions++;
1110                                 goto found;
1111                         }
1112                 }
1113                 action->next = NULL;
1114                 *ppaction = action;
1115                 nr_actions++;
1116         found:
1117 
1118                 element->action = action;
1119                 cursor->action = action;
1120                 cursor++;
1121                 if (cursor >= end)
1122                         goto overrun_error;
1123                 if (cursor->token_type != TOKEN_CLOSE_ACTION) {
1124                         fprintf(stderr, "%s:%d: Missing close action, got '%s'\n",
1125                                 filename, cursor->line, cursor->content);
1126                         exit(1);
1127                 }
1128                 cursor++;
1129         }
1130 
1131         *_cursor = cursor;
1132         return top;
1133 
1134 parse_error:
1135         fprintf(stderr, "%s:%d: Unexpected token '%s'\n",
1136                 filename, cursor->line, cursor->content);
1137         exit(1);
1138 
1139 overrun_error:
1140         fprintf(stderr, "%s: Unexpectedly hit EOF\n", filename);
1141         exit(1);
1142 }
1143 
1144 /*
1145  * Parse a compound type list
1146  */
1147 static struct element *parse_compound(struct token **_cursor, struct token *end,
1148                                       int alternates)
1149 {
1150         struct element *children, **child_p = &children, *element;
1151         struct token *cursor = *_cursor, *name;
1152 
1153         if (cursor->token_type != TOKEN_OPEN_CURLY) {
1154                 fprintf(stderr, "%s:%d: Expected compound to start with brace not '%s'\n",
1155                         filename, cursor->line, cursor->content);
1156                 exit(1);
1157         }
1158         cursor++;
1159         if (cursor >= end)
1160                 goto overrun_error;
1161 
1162         if (cursor->token_type == TOKEN_OPEN_CURLY) {
1163                 fprintf(stderr, "%s:%d: Empty compound\n",
1164                         filename, cursor->line);
1165                 exit(1);
1166         }
1167 
1168         for (;;) {
1169                 name = NULL;
1170                 if (cursor->token_type == TOKEN_ELEMENT_NAME) {
1171                         name = cursor;
1172                         cursor++;
1173                         if (cursor >= end)
1174                                 goto overrun_error;
1175                 }
1176 
1177                 element = parse_type(&cursor, end, name);
1178                 if (alternates)
1179                         element->flags |= ELEMENT_SKIPPABLE | ELEMENT_CONDITIONAL;
1180 
1181                 *child_p = element;
1182                 child_p = &element->next;
1183 
1184                 if (cursor >= end)
1185                         goto overrun_error;
1186                 if (cursor->token_type != TOKEN_COMMA)
1187                         break;
1188                 cursor++;
1189                 if (cursor >= end)
1190                         goto overrun_error;
1191         }
1192 
1193         children->flags &= ~ELEMENT_CONDITIONAL;
1194 
1195         if (cursor->token_type != TOKEN_CLOSE_CURLY) {
1196                 fprintf(stderr, "%s:%d: Expected compound closure, got '%s'\n",
1197                         filename, cursor->line, cursor->content);
1198                 exit(1);
1199         }
1200         cursor++;
1201 
1202         *_cursor = cursor;
1203         return children;
1204 
1205 overrun_error:
1206         fprintf(stderr, "%s: Unexpectedly hit EOF\n", filename);
1207         exit(1);
1208 }
1209 
1210 static void dump_element(const struct element *e, int level)
1211 {
1212         const struct element *c;
1213         const struct type *t = e->type_def;
1214         const char *name = e->name ? e->name->content : ".";
1215         const char *tname = t && t->name ? t->name->content : ".";
1216         char tag[32];
1217 
1218         if (e->class == 0 && e->method == 0 && e->tag == 0)
1219                 strcpy(tag, "<...>");
1220         else if (e->class == ASN1_UNIV)
1221                 sprintf(tag, "%s %s %s",
1222                         asn1_classes[e->class],
1223                         asn1_methods[e->method],
1224                         asn1_universal_tags[e->tag]);
1225         else
1226                 sprintf(tag, "%s %s %u",
1227                         asn1_classes[e->class],
1228                         asn1_methods[e->method],
1229                         e->tag);
1230 
1231         printf("%c%c%c%c%c %c %*s[*] \e[33m%s\e[m %s %s \e[35m%s\e[m\n",
1232                e->flags & ELEMENT_IMPLICIT ? 'I' : '-',
1233                e->flags & ELEMENT_EXPLICIT ? 'E' : '-',
1234                e->flags & ELEMENT_TAG_SPECIFIED ? 'T' : '-',
1235                e->flags & ELEMENT_SKIPPABLE ? 'S' : '-',
1236                e->flags & ELEMENT_CONDITIONAL ? 'C' : '-',
1237                "-tTqQcaro"[e->compound],
1238                level, "",
1239                tag,
1240                tname,
1241                name,
1242                e->action ? e->action->name : "");
1243         if (e->compound == TYPE_REF)
1244                 dump_element(e->type->type->element, level + 3);
1245         else
1246                 for (c = e->children; c; c = c->next)
1247                         dump_element(c, level + 3);
1248 }
1249 
1250 static void dump_elements(void)
1251 {
1252         if (debug_opt)
1253                 dump_element(type_list[0].element, 0);
1254 }
1255 
1256 static void render_element(FILE *out, struct element *e, struct element *tag);
1257 static void render_out_of_line_list(FILE *out);
1258 
1259 static int nr_entries;
1260 static int render_depth = 1;
1261 static struct element *render_list, **render_list_p = &render_list;
1262 
1263 __attribute__((format(printf, 2, 3)))
1264 static void render_opcode(FILE *out, const char *fmt, ...)
1265 {
1266         va_list va;
1267 
1268         if (out) {
1269                 fprintf(out, "\t[%4d] =%*s", nr_entries, render_depth, "");
1270                 va_start(va, fmt);
1271                 vfprintf(out, fmt, va);
1272                 va_end(va);
1273         }
1274         nr_entries++;
1275 }
1276 
1277 __attribute__((format(printf, 2, 3)))
1278 static void render_more(FILE *out, const char *fmt, ...)
1279 {
1280         va_list va;
1281 
1282         if (out) {
1283                 va_start(va, fmt);
1284                 vfprintf(out, fmt, va);
1285                 va_end(va);
1286         }
1287 }
1288 
1289 /*
1290  * Render the grammar into a state machine definition.
1291  */
1292 static void render(FILE *out, FILE *hdr)
1293 {
1294         struct element *e;
1295         struct action *action;
1296         struct type *root;
1297         int index;
1298 
1299         fprintf(hdr, "/*\n");
1300         fprintf(hdr, " * Automatically generated by asn1_compiler.  Do not edit\n");
1301         fprintf(hdr, " *\n");
1302         fprintf(hdr, " * ASN.1 parser for %s\n", grammar_name);
1303         fprintf(hdr, " */\n");
1304         fprintf(hdr, "#include <linux/asn1_decoder.h>\n");
1305         fprintf(hdr, "\n");
1306         fprintf(hdr, "extern const struct asn1_decoder %s_decoder;\n", grammar_name);
1307         if (ferror(hdr)) {
1308                 perror(headername);
1309                 exit(1);
1310         }
1311 
1312         fprintf(out, "/*\n");
1313         fprintf(out, " * Automatically generated by asn1_compiler.  Do not edit\n");
1314         fprintf(out, " *\n");
1315         fprintf(out, " * ASN.1 parser for %s\n", grammar_name);
1316         fprintf(out, " */\n");
1317         fprintf(out, "#include <linux/asn1_ber_bytecode.h>\n");
1318         fprintf(out, "#include \"%s.asn1.h\"\n", grammar_name);
1319         fprintf(out, "\n");
1320         if (ferror(out)) {
1321                 perror(outputname);
1322                 exit(1);
1323         }
1324 
1325         /* Tabulate the action functions we might have to call */
1326         fprintf(hdr, "\n");
1327         index = 0;
1328         for (action = action_list; action; action = action->next) {
1329                 action->index = index++;
1330                 fprintf(hdr,
1331                         "extern int %s(void *, size_t, unsigned char,"
1332                         " const void *, size_t);\n",
1333                         action->name);
1334         }
1335         fprintf(hdr, "\n");
1336 
1337         fprintf(out, "enum %s_actions {\n", grammar_name);
1338         for (action = action_list; action; action = action->next)
1339                 fprintf(out, "\tACT_%s = %u,\n",
1340                         action->name, action->index);
1341         fprintf(out, "\tNR__%s_actions = %u\n", grammar_name, nr_actions);
1342         fprintf(out, "};\n");
1343 
1344         fprintf(out, "\n");
1345         fprintf(out, "static const asn1_action_t %s_action_table[NR__%s_actions] = {\n",
1346                 grammar_name, grammar_name);
1347         for (action = action_list; action; action = action->next)
1348                 fprintf(out, "\t[%4u] = %s,\n", action->index, action->name);
1349         fprintf(out, "};\n");
1350 
1351         if (ferror(out)) {
1352                 perror(outputname);
1353                 exit(1);
1354         }
1355 
1356         /* We do two passes - the first one calculates all the offsets */
1357         verbose("Pass 1\n");
1358         nr_entries = 0;
1359         root = &type_list[0];
1360         render_element(NULL, root->element, NULL);
1361         render_opcode(NULL, "ASN1_OP_COMPLETE,\n");
1362         render_out_of_line_list(NULL);
1363 
1364         for (e = element_list; e; e = e->list_next)
1365                 e->flags &= ~ELEMENT_RENDERED;
1366 
1367         /* And then we actually render */
1368         verbose("Pass 2\n");
1369         fprintf(out, "\n");
1370         fprintf(out, "static const unsigned char %s_machine[] = {\n",
1371                 grammar_name);
1372 
1373         nr_entries = 0;
1374         root = &type_list[0];
1375         render_element(out, root->element, NULL);
1376         render_opcode(out, "ASN1_OP_COMPLETE,\n");
1377         render_out_of_line_list(out);
1378 
1379         fprintf(out, "};\n");
1380 
1381         fprintf(out, "\n");
1382         fprintf(out, "const struct asn1_decoder %s_decoder = {\n", grammar_name);
1383         fprintf(out, "\t.machine = %s_machine,\n", grammar_name);
1384         fprintf(out, "\t.machlen = sizeof(%s_machine),\n", grammar_name);
1385         fprintf(out, "\t.actions = %s_action_table,\n", grammar_name);
1386         fprintf(out, "};\n");
1387 }
1388 
1389 /*
1390  * Render the out-of-line elements
1391  */
1392 static void render_out_of_line_list(FILE *out)
1393 {
1394         struct element *e, *ce;
1395         const char *act;
1396         int entry;
1397 
1398         while ((e = render_list)) {
1399                 render_list = e->render_next;
1400                 if (!render_list)
1401                         render_list_p = &render_list;
1402 
1403                 render_more(out, "\n");
1404                 e->entry_index = entry = nr_entries;
1405                 render_depth++;
1406                 for (ce = e->children; ce; ce = ce->next)
1407                         render_element(out, ce, NULL);
1408                 render_depth--;
1409 
1410                 act = e->action ? "_ACT" : "";
1411                 switch (e->compound) {
1412                 case SEQUENCE:
1413                         render_opcode(out, "ASN1_OP_END_SEQ%s,\n", act);
1414                         break;
1415                 case SEQUENCE_OF:
1416                         render_opcode(out, "ASN1_OP_END_SEQ_OF%s,\n", act);
1417                         render_opcode(out, "_jump_target(%u),\n", entry);
1418                         break;
1419                 case SET:
1420                         render_opcode(out, "ASN1_OP_END_SET%s,\n", act);
1421                         break;
1422                 case SET_OF:
1423                         render_opcode(out, "ASN1_OP_END_SET_OF%s,\n", act);
1424                         render_opcode(out, "_jump_target(%u),\n", entry);
1425                         break;
1426                 default:
1427                         break;
1428                 }
1429                 if (e->action)
1430                         render_opcode(out, "_action(ACT_%s),\n",
1431                                       e->action->name);
1432                 render_opcode(out, "ASN1_OP_RETURN,\n");
1433         }
1434 }
1435 
1436 /*
1437  * Render an element.
1438  */
1439 static void render_element(FILE *out, struct element *e, struct element *tag)
1440 {
1441         struct element *ec, *x;
1442         const char *cond, *act;
1443         int entry, skippable = 0, outofline = 0;
1444 
1445         if (e->flags & ELEMENT_SKIPPABLE ||
1446             (tag && tag->flags & ELEMENT_SKIPPABLE))
1447                 skippable = 1;
1448 
1449         if ((e->type_def && e->type_def->ref_count > 1) ||
1450             skippable)
1451                 outofline = 1;
1452 
1453         if (e->type_def && out) {
1454                 render_more(out, "\t// %s\n", e->type_def->name->content);
1455         }
1456 
1457         /* Render the operation */
1458         cond = (e->flags & ELEMENT_CONDITIONAL ||
1459                 (tag && tag->flags & ELEMENT_CONDITIONAL)) ? "COND_" : "";
1460         act = e->action ? "_ACT" : "";
1461         switch (e->compound) {
1462         case ANY:
1463                 render_opcode(out, "ASN1_OP_%sMATCH_ANY%s%s,",
1464                               cond, act, skippable ? "_OR_SKIP" : "");
1465                 if (e->name)
1466                         render_more(out, "\t\t// %s", e->name->content);
1467                 render_more(out, "\n");
1468                 goto dont_render_tag;
1469 
1470         case TAG_OVERRIDE:
1471                 render_element(out, e->children, e);
1472                 return;
1473 
1474         case SEQUENCE:
1475         case SEQUENCE_OF:
1476         case SET:
1477         case SET_OF:
1478                 render_opcode(out, "ASN1_OP_%sMATCH%s%s,",
1479                               cond,
1480                               outofline ? "_JUMP" : "",
1481                               skippable ? "_OR_SKIP" : "");
1482                 break;
1483 
1484         case CHOICE:
1485                 goto dont_render_tag;
1486 
1487         case TYPE_REF:
1488                 if (e->class == ASN1_UNIV && e->method == ASN1_PRIM && e->tag == 0)
1489                         goto dont_render_tag;
1490         default:
1491                 render_opcode(out, "ASN1_OP_%sMATCH%s%s,",
1492                               cond, act,
1493                               skippable ? "_OR_SKIP" : "");
1494                 break;
1495         }
1496 
1497         x = tag ?: e;
1498         if (x->name)
1499                 render_more(out, "\t\t// %s", x->name->content);
1500         render_more(out, "\n");
1501 
1502         /* Render the tag */
1503         if (!tag || !(tag->flags & ELEMENT_TAG_SPECIFIED))
1504                 tag = e;
1505 
1506         if (tag->class == ASN1_UNIV &&
1507             tag->tag != 14 &&
1508             tag->tag != 15 &&
1509             tag->tag != 31)
1510                 render_opcode(out, "_tag(%s, %s, %s),\n",
1511                               asn1_classes[tag->class],
1512                               asn1_methods[tag->method | e->method],
1513                               asn1_universal_tags[tag->tag]);
1514         else
1515                 render_opcode(out, "_tagn(%s, %s, %2u),\n",
1516                               asn1_classes[tag->class],
1517                               asn1_methods[tag->method | e->method],
1518                               tag->tag);
1519         tag = NULL;
1520 dont_render_tag:
1521 
1522         /* Deal with compound types */
1523         switch (e->compound) {
1524         case TYPE_REF:
1525                 render_element(out, e->type->type->element, tag);
1526                 if (e->action)
1527                         render_opcode(out, "ASN1_OP_%sACT,\n",
1528                                       skippable ? "MAYBE_" : "");
1529                 break;
1530 
1531         case SEQUENCE:
1532                 if (outofline) {
1533                         /* Render out-of-line for multiple use or
1534                          * skipability */
1535                         render_opcode(out, "_jump_target(%u),", e->entry_index);
1536                         if (e->type_def && e->type_def->name)
1537                                 render_more(out, "\t\t// --> %s",
1538                                             e->type_def->name->content);
1539                         render_more(out, "\n");
1540                         if (!(e->flags & ELEMENT_RENDERED)) {
1541                                 e->flags |= ELEMENT_RENDERED;
1542                                 *render_list_p = e;
1543                                 render_list_p = &e->render_next;
1544                         }
1545                         return;
1546                 } else {
1547                         /* Render inline for single use */
1548                         render_depth++;
1549                         for (ec = e->children; ec; ec = ec->next)
1550                                 render_element(out, ec, NULL);
1551                         render_depth--;
1552                         render_opcode(out, "ASN1_OP_END_SEQ%s,\n", act);
1553                 }
1554                 break;
1555 
1556         case SEQUENCE_OF:
1557         case SET_OF:
1558                 if (outofline) {
1559                         /* Render out-of-line for multiple use or
1560                          * skipability */
1561                         render_opcode(out, "_jump_target(%u),", e->entry_index);
1562                         if (e->type_def && e->type_def->name)
1563                                 render_more(out, "\t\t// --> %s",
1564                                             e->type_def->name->content);
1565                         render_more(out, "\n");
1566                         if (!(e->flags & ELEMENT_RENDERED)) {
1567                                 e->flags |= ELEMENT_RENDERED;
1568                                 *render_list_p = e;
1569                                 render_list_p = &e->render_next;
1570                         }
1571                         return;
1572                 } else {
1573                         /* Render inline for single use */
1574                         entry = nr_entries;
1575                         render_depth++;
1576                         render_element(out, e->children, NULL);
1577                         render_depth--;
1578                         if (e->compound == SEQUENCE_OF)
1579                                 render_opcode(out, "ASN1_OP_END_SEQ_OF%s,\n", act);
1580                         else
1581                                 render_opcode(out, "ASN1_OP_END_SET_OF%s,\n", act);
1582                         render_opcode(out, "_jump_target(%u),\n", entry);
1583                 }
1584                 break;
1585 
1586         case SET:
1587                 /* I can't think of a nice way to do SET support without having
1588                  * a stack of bitmasks to make sure no element is repeated.
1589                  * The bitmask has also to be checked that no non-optional
1590                  * elements are left out whilst not preventing optional
1591                  * elements from being left out.
1592                  */
1593                 fprintf(stderr, "The ASN.1 SET type is not currently supported.\n");
1594                 exit(1);
1595 
1596         case CHOICE:
1597                 for (ec = e->children; ec; ec = ec->next)
1598                         render_element(out, ec, ec);
1599                 if (!skippable)
1600                         render_opcode(out, "ASN1_OP_COND_FAIL,\n");
1601                 if (e->action)
1602                         render_opcode(out, "ASN1_OP_ACT,\n");
1603                 break;
1604 
1605         default:
1606                 break;
1607         }
1608 
1609         if (e->action)
1610                 render_opcode(out, "_action(ACT_%s),\n", e->action->name);
1611 }
1612 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp