On Sat, Oct 12, 2019 at 02:22:14PM +0200, Heinrich Schuchardt wrote: > On 10/11/19 9:41 AM, AKASHI Takahiro wrote: > >Imported from linux kernel v5.3. > > > >This host command will be used to create a ASN1 parser, for example, > >for pkcs7 or x509. > > > >Signed-off-by: AKASHI Takahiro <takahiro.aka...@linaro.org> > >--- > > cmd/Kconfig | 3 + > > include/linux/asn1.h | 65 ++ > > include/linux/asn1_ber_bytecode.h | 89 ++ > > include/linux/asn1_decoder.h | 20 + > > scripts/Makefile | 3 + > > scripts/asn1_compiler.c | 1611 +++++++++++++++++++++++++++++ > > Except for Makefile and Kconfig these are verbatime copies of the Linux > files. OK. > > > 6 files changed, 1791 insertions(+) > > create mode 100644 include/linux/asn1.h > > create mode 100644 include/linux/asn1_ber_bytecode.h > > create mode 100644 include/linux/asn1_decoder.h > > create mode 100644 scripts/asn1_compiler.c > > > >diff --git a/cmd/Kconfig b/cmd/Kconfig > >index 4e61565aab16..605dcfdf4282 100644 > >--- a/cmd/Kconfig > >+++ b/cmd/Kconfig > >@@ -184,6 +184,9 @@ endmenu > > config BUILD_BIN2C > > bool > > > >+config BUILD_ASN1 > >+ bool > >+ > > comment "Commands" > > > > menu "Info commands" > >diff --git a/include/linux/asn1.h b/include/linux/asn1.h > >new file mode 100644 > >index 000000000000..a4d0bdd10711 > >--- /dev/null > >+++ b/include/linux/asn1.h > >@@ -0,0 +1,65 @@ > >+/* SPDX-License-Identifier: GPL-2.0-or-later */ > >+/* ASN.1 BER/DER/CER encoding definitions > >+ * > >+ * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved. > >+ * Written by David Howells (dhowe...@redhat.com) > >+ */ > >+ > >+#ifndef _LINUX_ASN1_H > >+#define _LINUX_ASN1_H > >+ > >+/* Class */ > >+enum asn1_class { > >+ ASN1_UNIV = 0, /* Universal */ > >+ ASN1_APPL = 1, /* Application */ > >+ ASN1_CONT = 2, /* Context */ > >+ ASN1_PRIV = 3 /* Private */ > >+}; > >+#define ASN1_CLASS_BITS 0xc0 > >+ > >+ > >+enum asn1_method { > >+ ASN1_PRIM = 0, /* Primitive */ > >+ ASN1_CONS = 1 /* Constructed */ > >+}; > >+#define ASN1_CONS_BIT 0x20 > >+ > >+/* Tag */ > >+enum asn1_tag { > >+ ASN1_EOC = 0, /* End Of Contents or N/A */ > >+ ASN1_BOOL = 1, /* Boolean */ > >+ ASN1_INT = 2, /* Integer */ > >+ ASN1_BTS = 3, /* Bit String */ > >+ ASN1_OTS = 4, /* Octet String */ > >+ ASN1_NULL = 5, /* Null */ > >+ ASN1_OID = 6, /* Object Identifier */ > >+ ASN1_ODE = 7, /* Object Description */ > >+ ASN1_EXT = 8, /* External */ > >+ ASN1_REAL = 9, /* Real float */ > >+ ASN1_ENUM = 10, /* Enumerated */ > >+ ASN1_EPDV = 11, /* Embedded PDV */ > >+ ASN1_UTF8STR = 12, /* UTF8 String */ > >+ ASN1_RELOID = 13, /* Relative OID */ > >+ /* 14 - Reserved */ > >+ /* 15 - Reserved */ > >+ ASN1_SEQ = 16, /* Sequence and Sequence of */ > >+ ASN1_SET = 17, /* Set and Set of */ > >+ ASN1_NUMSTR = 18, /* Numerical String */ > >+ ASN1_PRNSTR = 19, /* Printable String */ > >+ ASN1_TEXSTR = 20, /* T61 String / Teletext String */ > >+ ASN1_VIDSTR = 21, /* Videotex String */ > >+ ASN1_IA5STR = 22, /* IA5 String */ > >+ ASN1_UNITIM = 23, /* Universal Time */ > >+ ASN1_GENTIM = 24, /* General Time */ > >+ ASN1_GRASTR = 25, /* Graphic String */ > >+ ASN1_VISSTR = 26, /* Visible String */ > >+ ASN1_GENSTR = 27, /* General String */ > >+ ASN1_UNISTR = 28, /* Universal String */ > >+ ASN1_CHRSTR = 29, /* Character String */ > >+ ASN1_BMPSTR = 30, /* BMP String */ > >+ ASN1_LONG_TAG = 31 /* Long form tag */ > >+}; > >+ > >+#define ASN1_INDEFINITE_LENGTH 0x80 > >+ > >+#endif /* _LINUX_ASN1_H */ > >diff --git a/include/linux/asn1_ber_bytecode.h > >b/include/linux/asn1_ber_bytecode.h > >new file mode 100644 > >index 000000000000..b38361953a48 > >--- /dev/null > >+++ b/include/linux/asn1_ber_bytecode.h > >@@ -0,0 +1,89 @@ > >+/* SPDX-License-Identifier: GPL-2.0-or-later */ > >+/* ASN.1 BER/DER/CER parsing state machine internal definitions > >+ * > >+ * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved. > >+ * Written by David Howells (dhowe...@redhat.com) > >+ */ > >+ > >+#ifndef _LINUX_ASN1_BER_BYTECODE_H > >+#define _LINUX_ASN1_BER_BYTECODE_H > >+ > >+#ifdef __KERNEL__ > >+#include <linux/types.h> > >+#endif > >+#include <linux/asn1.h> > >+ > >+typedef int (*asn1_action_t)(void *context, > >+ size_t hdrlen, /* In case of ANY type */ > >+ unsigned char tag, /* In case of ANY type */ > >+ const void *value, size_t vlen); > >+ > >+struct asn1_decoder { > >+ const unsigned char *machine; > >+ size_t machlen; > >+ const asn1_action_t *actions; > >+}; > >+ > >+enum asn1_opcode { > >+ /* The tag-matching ops come first and the odd-numbered slots > >+ * are for OR_SKIP ops. > >+ */ > >+#define ASN1_OP_MATCH__SKIP 0x01 > >+#define ASN1_OP_MATCH__ACT 0x02 > >+#define ASN1_OP_MATCH__JUMP 0x04 > >+#define ASN1_OP_MATCH__ANY 0x08 > >+#define ASN1_OP_MATCH__COND 0x10 > >+ > >+ ASN1_OP_MATCH = 0x00, > >+ ASN1_OP_MATCH_OR_SKIP = 0x01, > >+ ASN1_OP_MATCH_ACT = 0x02, > >+ ASN1_OP_MATCH_ACT_OR_SKIP = 0x03, > >+ ASN1_OP_MATCH_JUMP = 0x04, > >+ ASN1_OP_MATCH_JUMP_OR_SKIP = 0x05, > >+ ASN1_OP_MATCH_ANY = 0x08, > >+ ASN1_OP_MATCH_ANY_OR_SKIP = 0x09, > >+ ASN1_OP_MATCH_ANY_ACT = 0x0a, > >+ ASN1_OP_MATCH_ANY_ACT_OR_SKIP = 0x0b, > >+ /* Everything before here matches unconditionally */ > >+ > >+ ASN1_OP_COND_MATCH_OR_SKIP = 0x11, > >+ ASN1_OP_COND_MATCH_ACT_OR_SKIP = 0x13, > >+ ASN1_OP_COND_MATCH_JUMP_OR_SKIP = 0x15, > >+ ASN1_OP_COND_MATCH_ANY = 0x18, > >+ ASN1_OP_COND_MATCH_ANY_OR_SKIP = 0x19, > >+ ASN1_OP_COND_MATCH_ANY_ACT = 0x1a, > >+ ASN1_OP_COND_MATCH_ANY_ACT_OR_SKIP = 0x1b, > >+ > >+ /* Everything before here will want a tag from the data */ > >+#define ASN1_OP__MATCHES_TAG ASN1_OP_COND_MATCH_ANY_ACT_OR_SKIP > >+ > >+ /* These are here to help fill up space */ > >+ ASN1_OP_COND_FAIL = 0x1c, > >+ ASN1_OP_COMPLETE = 0x1d, > >+ ASN1_OP_ACT = 0x1e, > >+ ASN1_OP_MAYBE_ACT = 0x1f, > >+ > >+ /* The following eight have bit 0 -> SET, 1 -> OF, 2 -> ACT */ > >+ ASN1_OP_END_SEQ = 0x20, > >+ ASN1_OP_END_SET = 0x21, > >+ ASN1_OP_END_SEQ_OF = 0x22, > >+ ASN1_OP_END_SET_OF = 0x23, > >+ ASN1_OP_END_SEQ_ACT = 0x24, > >+ ASN1_OP_END_SET_ACT = 0x25, > >+ ASN1_OP_END_SEQ_OF_ACT = 0x26, > >+ ASN1_OP_END_SET_OF_ACT = 0x27, > >+#define ASN1_OP_END__SET 0x01 > >+#define ASN1_OP_END__OF 0x02 > >+#define ASN1_OP_END__ACT 0x04 > >+ > >+ ASN1_OP_RETURN = 0x28, > >+ > >+ ASN1_OP__NR > >+}; > >+ > >+#define _tag(CLASS, CP, TAG) ((ASN1_##CLASS << 6) | (ASN1_##CP << 5) | > >ASN1_##TAG) > >+#define _tagn(CLASS, CP, TAG) ((ASN1_##CLASS << 6) | (ASN1_##CP << 5) | TAG) > >+#define _jump_target(N) (N) > >+#define _action(N) (N) > >+ > >+#endif /* _LINUX_ASN1_BER_BYTECODE_H */ > >diff --git a/include/linux/asn1_decoder.h b/include/linux/asn1_decoder.h > >new file mode 100644 > >index 000000000000..83f9c6e1e5e9 > >--- /dev/null > >+++ b/include/linux/asn1_decoder.h > >@@ -0,0 +1,20 @@ > >+/* SPDX-License-Identifier: GPL-2.0-or-later */ > >+/* ASN.1 decoder > >+ * > >+ * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved. > >+ * Written by David Howells (dhowe...@redhat.com) > >+ */ > >+ > >+#ifndef _LINUX_ASN1_DECODER_H > >+#define _LINUX_ASN1_DECODER_H > >+ > >+#include <linux/asn1.h> > >+ > >+struct asn1_decoder; > >+ > >+extern int asn1_ber_decoder(const struct asn1_decoder *decoder, > >+ void *context, > >+ const unsigned char *data, > >+ size_t datalen); > >+ > >+#endif /* _LINUX_ASN1_DECODER_H */ > >diff --git a/scripts/Makefile b/scripts/Makefile > >index e7b353f77f43..c4e2ae5db2ea 100644 > >--- a/scripts/Makefile > >+++ b/scripts/Makefile > >@@ -5,6 +5,9 @@ > > # > > --------------------------------------------------------------------------- > > > > hostprogs-$(CONFIG_BUILD_BIN2C) += bin2c > >+hostprogs-$(CONFIG_BUILD_ASN1) += asn1_compiler > >+ > >+HOSTCFLAGS_asn1_compiler.o = -idirafter $(srctree)/include > > Which problems did you run into that make you use -idirafter here?
Without this directive, a compiler supersedes *host's* include over U-Boot's include in matching "linux/", then it will miss out include/linux/asn1_ber_bytecode.h. -Takahiro Akashi > Otherwise > > Reviewed-by: Heinrich Schuchardt <xypron.g...@gmx.de> > > > > > > always := $(hostprogs-y) > > > >diff --git a/scripts/asn1_compiler.c b/scripts/asn1_compiler.c > >new file mode 100644 > >index 000000000000..adabd4145264 > >--- /dev/null > >+++ b/scripts/asn1_compiler.c > >@@ -0,0 +1,1611 @@ > >+// SPDX-License-Identifier: GPL-2.0-or-later > >+/* Simplified ASN.1 notation parser > >+ * > >+ * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved. > >+ * Written by David Howells (dhowe...@redhat.com) > >+ */ > >+ > >+#include <stdarg.h> > >+#include <stdio.h> > >+#include <stdlib.h> > >+#include <stdint.h> > >+#include <stdbool.h> > >+#include <string.h> > >+#include <ctype.h> > >+#include <unistd.h> > >+#include <fcntl.h> > >+#include <sys/stat.h> > >+#include <linux/asn1_ber_bytecode.h> > >+ > >+enum token_type { > >+ DIRECTIVE_ABSENT, > >+ DIRECTIVE_ALL, > >+ DIRECTIVE_ANY, > >+ DIRECTIVE_APPLICATION, > >+ DIRECTIVE_AUTOMATIC, > >+ DIRECTIVE_BEGIN, > >+ DIRECTIVE_BIT, > >+ DIRECTIVE_BMPString, > >+ DIRECTIVE_BOOLEAN, > >+ DIRECTIVE_BY, > >+ DIRECTIVE_CHARACTER, > >+ DIRECTIVE_CHOICE, > >+ DIRECTIVE_CLASS, > >+ DIRECTIVE_COMPONENT, > >+ DIRECTIVE_COMPONENTS, > >+ DIRECTIVE_CONSTRAINED, > >+ DIRECTIVE_CONTAINING, > >+ DIRECTIVE_DEFAULT, > >+ DIRECTIVE_DEFINED, > >+ DIRECTIVE_DEFINITIONS, > >+ DIRECTIVE_EMBEDDED, > >+ DIRECTIVE_ENCODED, > >+ DIRECTIVE_ENCODING_CONTROL, > >+ DIRECTIVE_END, > >+ DIRECTIVE_ENUMERATED, > >+ DIRECTIVE_EXCEPT, > >+ DIRECTIVE_EXPLICIT, > >+ DIRECTIVE_EXPORTS, > >+ DIRECTIVE_EXTENSIBILITY, > >+ DIRECTIVE_EXTERNAL, > >+ DIRECTIVE_FALSE, > >+ DIRECTIVE_FROM, > >+ DIRECTIVE_GeneralString, > >+ DIRECTIVE_GeneralizedTime, > >+ DIRECTIVE_GraphicString, > >+ DIRECTIVE_IA5String, > >+ DIRECTIVE_IDENTIFIER, > >+ DIRECTIVE_IMPLICIT, > >+ DIRECTIVE_IMPLIED, > >+ DIRECTIVE_IMPORTS, > >+ DIRECTIVE_INCLUDES, > >+ DIRECTIVE_INSTANCE, > >+ DIRECTIVE_INSTRUCTIONS, > >+ DIRECTIVE_INTEGER, > >+ DIRECTIVE_INTERSECTION, > >+ DIRECTIVE_ISO646String, > >+ DIRECTIVE_MAX, > >+ DIRECTIVE_MIN, > >+ DIRECTIVE_MINUS_INFINITY, > >+ DIRECTIVE_NULL, > >+ DIRECTIVE_NumericString, > >+ DIRECTIVE_OBJECT, > >+ DIRECTIVE_OCTET, > >+ DIRECTIVE_OF, > >+ DIRECTIVE_OPTIONAL, > >+ DIRECTIVE_ObjectDescriptor, > >+ DIRECTIVE_PATTERN, > >+ DIRECTIVE_PDV, > >+ DIRECTIVE_PLUS_INFINITY, > >+ DIRECTIVE_PRESENT, > >+ DIRECTIVE_PRIVATE, > >+ DIRECTIVE_PrintableString, > >+ DIRECTIVE_REAL, > >+ DIRECTIVE_RELATIVE_OID, > >+ DIRECTIVE_SEQUENCE, > >+ DIRECTIVE_SET, > >+ DIRECTIVE_SIZE, > >+ DIRECTIVE_STRING, > >+ DIRECTIVE_SYNTAX, > >+ DIRECTIVE_T61String, > >+ DIRECTIVE_TAGS, > >+ DIRECTIVE_TRUE, > >+ DIRECTIVE_TeletexString, > >+ DIRECTIVE_UNION, > >+ DIRECTIVE_UNIQUE, > >+ DIRECTIVE_UNIVERSAL, > >+ DIRECTIVE_UTCTime, > >+ DIRECTIVE_UTF8String, > >+ DIRECTIVE_UniversalString, > >+ DIRECTIVE_VideotexString, > >+ DIRECTIVE_VisibleString, > >+ DIRECTIVE_WITH, > >+ NR__DIRECTIVES, > >+ TOKEN_ASSIGNMENT = NR__DIRECTIVES, > >+ TOKEN_OPEN_CURLY, > >+ TOKEN_CLOSE_CURLY, > >+ TOKEN_OPEN_SQUARE, > >+ TOKEN_CLOSE_SQUARE, > >+ TOKEN_OPEN_ACTION, > >+ TOKEN_CLOSE_ACTION, > >+ TOKEN_COMMA, > >+ TOKEN_NUMBER, > >+ TOKEN_TYPE_NAME, > >+ TOKEN_ELEMENT_NAME, > >+ NR__TOKENS > >+}; > >+ > >+static const unsigned char token_to_tag[NR__TOKENS] = { > >+ /* EOC goes first */ > >+ [DIRECTIVE_BOOLEAN] = ASN1_BOOL, > >+ [DIRECTIVE_INTEGER] = ASN1_INT, > >+ [DIRECTIVE_BIT] = ASN1_BTS, > >+ [DIRECTIVE_OCTET] = ASN1_OTS, > >+ [DIRECTIVE_NULL] = ASN1_NULL, > >+ [DIRECTIVE_OBJECT] = ASN1_OID, > >+ [DIRECTIVE_ObjectDescriptor] = ASN1_ODE, > >+ [DIRECTIVE_EXTERNAL] = ASN1_EXT, > >+ [DIRECTIVE_REAL] = ASN1_REAL, > >+ [DIRECTIVE_ENUMERATED] = ASN1_ENUM, > >+ [DIRECTIVE_EMBEDDED] = 0, > >+ [DIRECTIVE_UTF8String] = ASN1_UTF8STR, > >+ [DIRECTIVE_RELATIVE_OID] = ASN1_RELOID, > >+ /* 14 */ > >+ /* 15 */ > >+ [DIRECTIVE_SEQUENCE] = ASN1_SEQ, > >+ [DIRECTIVE_SET] = ASN1_SET, > >+ [DIRECTIVE_NumericString] = ASN1_NUMSTR, > >+ [DIRECTIVE_PrintableString] = ASN1_PRNSTR, > >+ [DIRECTIVE_T61String] = ASN1_TEXSTR, > >+ [DIRECTIVE_TeletexString] = ASN1_TEXSTR, > >+ [DIRECTIVE_VideotexString] = ASN1_VIDSTR, > >+ [DIRECTIVE_IA5String] = ASN1_IA5STR, > >+ [DIRECTIVE_UTCTime] = ASN1_UNITIM, > >+ [DIRECTIVE_GeneralizedTime] = ASN1_GENTIM, > >+ [DIRECTIVE_GraphicString] = ASN1_GRASTR, > >+ [DIRECTIVE_VisibleString] = ASN1_VISSTR, > >+ [DIRECTIVE_GeneralString] = ASN1_GENSTR, > >+ [DIRECTIVE_UniversalString] = ASN1_UNITIM, > >+ [DIRECTIVE_CHARACTER] = ASN1_CHRSTR, > >+ [DIRECTIVE_BMPString] = ASN1_BMPSTR, > >+}; > >+ > >+static const char asn1_classes[4][5] = { > >+ [ASN1_UNIV] = "UNIV", > >+ [ASN1_APPL] = "APPL", > >+ [ASN1_CONT] = "CONT", > >+ [ASN1_PRIV] = "PRIV" > >+}; > >+ > >+static const char asn1_methods[2][5] = { > >+ [ASN1_UNIV] = "PRIM", > >+ [ASN1_APPL] = "CONS" > >+}; > >+ > >+static const char *const asn1_universal_tags[32] = { > >+ "EOC", > >+ "BOOL", > >+ "INT", > >+ "BTS", > >+ "OTS", > >+ "NULL", > >+ "OID", > >+ "ODE", > >+ "EXT", > >+ "REAL", > >+ "ENUM", > >+ "EPDV", > >+ "UTF8STR", > >+ "RELOID", > >+ NULL, /* 14 */ > >+ NULL, /* 15 */ > >+ "SEQ", > >+ "SET", > >+ "NUMSTR", > >+ "PRNSTR", > >+ "TEXSTR", > >+ "VIDSTR", > >+ "IA5STR", > >+ "UNITIM", > >+ "GENTIM", > >+ "GRASTR", > >+ "VISSTR", > >+ "GENSTR", > >+ "UNISTR", > >+ "CHRSTR", > >+ "BMPSTR", > >+ NULL /* 31 */ > >+}; > >+ > >+static const char *filename; > >+static const char *grammar_name; > >+static const char *outputname; > >+static const char *headername; > >+ > >+static const char *const directives[NR__DIRECTIVES] = { > >+#define _(X) [DIRECTIVE_##X] = #X > >+ _(ABSENT), > >+ _(ALL), > >+ _(ANY), > >+ _(APPLICATION), > >+ _(AUTOMATIC), > >+ _(BEGIN), > >+ _(BIT), > >+ _(BMPString), > >+ _(BOOLEAN), > >+ _(BY), > >+ _(CHARACTER), > >+ _(CHOICE), > >+ _(CLASS), > >+ _(COMPONENT), > >+ _(COMPONENTS), > >+ _(CONSTRAINED), > >+ _(CONTAINING), > >+ _(DEFAULT), > >+ _(DEFINED), > >+ _(DEFINITIONS), > >+ _(EMBEDDED), > >+ _(ENCODED), > >+ [DIRECTIVE_ENCODING_CONTROL] = "ENCODING-CONTROL", > >+ _(END), > >+ _(ENUMERATED), > >+ _(EXCEPT), > >+ _(EXPLICIT), > >+ _(EXPORTS), > >+ _(EXTENSIBILITY), > >+ _(EXTERNAL), > >+ _(FALSE), > >+ _(FROM), > >+ _(GeneralString), > >+ _(GeneralizedTime), > >+ _(GraphicString), > >+ _(IA5String), > >+ _(IDENTIFIER), > >+ _(IMPLICIT), > >+ _(IMPLIED), > >+ _(IMPORTS), > >+ _(INCLUDES), > >+ _(INSTANCE), > >+ _(INSTRUCTIONS), > >+ _(INTEGER), > >+ _(INTERSECTION), > >+ _(ISO646String), > >+ _(MAX), > >+ _(MIN), > >+ [DIRECTIVE_MINUS_INFINITY] = "MINUS-INFINITY", > >+ [DIRECTIVE_NULL] = "NULL", > >+ _(NumericString), > >+ _(OBJECT), > >+ _(OCTET), > >+ _(OF), > >+ _(OPTIONAL), > >+ _(ObjectDescriptor), > >+ _(PATTERN), > >+ _(PDV), > >+ [DIRECTIVE_PLUS_INFINITY] = "PLUS-INFINITY", > >+ _(PRESENT), > >+ _(PRIVATE), > >+ _(PrintableString), > >+ _(REAL), > >+ [DIRECTIVE_RELATIVE_OID] = "RELATIVE-OID", > >+ _(SEQUENCE), > >+ _(SET), > >+ _(SIZE), > >+ _(STRING), > >+ _(SYNTAX), > >+ _(T61String), > >+ _(TAGS), > >+ _(TRUE), > >+ _(TeletexString), > >+ _(UNION), > >+ _(UNIQUE), > >+ _(UNIVERSAL), > >+ _(UTCTime), > >+ _(UTF8String), > >+ _(UniversalString), > >+ _(VideotexString), > >+ _(VisibleString), > >+ _(WITH) > >+}; > >+ > >+struct action { > >+ struct action *next; > >+ char *name; > >+ unsigned char index; > >+}; > >+ > >+static struct action *action_list; > >+static unsigned nr_actions; > >+ > >+struct token { > >+ unsigned short line; > >+ enum token_type token_type : 8; > >+ unsigned char size; > >+ struct action *action; > >+ char *content; > >+ struct type *type; > >+}; > >+ > >+static struct token *token_list; > >+static unsigned nr_tokens; > >+static bool verbose_opt; > >+static bool debug_opt; > >+ > >+#define verbose(fmt, ...) do { if (verbose_opt) printf(fmt, ## > >__VA_ARGS__); } while (0) > >+#define debug(fmt, ...) do { if (debug_opt) printf(fmt, ## __VA_ARGS__); } > >while (0) > >+ > >+static int directive_compare(const void *_key, const void *_pdir) > >+{ > >+ const struct token *token = _key; > >+ const char *const *pdir = _pdir, *dir = *pdir; > >+ size_t dlen, clen; > >+ int val; > >+ > >+ dlen = strlen(dir); > >+ clen = (dlen < token->size) ? dlen : token->size; > >+ > >+ //debug("cmp(%s,%s) = ", token->content, dir); > >+ > >+ val = memcmp(token->content, dir, clen); > >+ if (val != 0) { > >+ //debug("%d [cmp]\n", val); > >+ return val; > >+ } > >+ > >+ if (dlen == token->size) { > >+ //debug("0\n"); > >+ return 0; > >+ } > >+ //debug("%d\n", (int)dlen - (int)token->size); > >+ return dlen - token->size; /* shorter -> negative */ > >+} > >+ > >+/* > >+ * Tokenise an ASN.1 grammar > >+ */ > >+static void tokenise(char *buffer, char *end) > >+{ > >+ struct token *tokens; > >+ char *line, *nl, *start, *p, *q; > >+ unsigned tix, lineno; > >+ > >+ /* Assume we're going to have half as many tokens as we have > >+ * characters > >+ */ > >+ token_list = tokens = calloc((end - buffer) / 2, sizeof(struct token)); > >+ if (!tokens) { > >+ perror(NULL); > >+ exit(1); > >+ } > >+ tix = 0; > >+ > >+ lineno = 0; > >+ while (buffer < end) { > >+ /* First of all, break out a line */ > >+ lineno++; > >+ line = buffer; > >+ nl = memchr(line, '\n', end - buffer); > >+ if (!nl) { > >+ buffer = nl = end; > >+ } else { > >+ buffer = nl + 1; > >+ *nl = '\0'; > >+ } > >+ > >+ /* Remove "--" comments */ > >+ p = line; > >+ next_comment: > >+ while ((p = memchr(p, '-', nl - p))) { > >+ if (p[1] == '-') { > >+ /* Found a comment; see if there's a terminator > >*/ > >+ q = p + 2; > >+ while ((q = memchr(q, '-', nl - q))) { > >+ if (q[1] == '-') { > >+ /* There is - excise the > >comment */ > >+ q += 2; > >+ memmove(p, q, nl - q); > >+ goto next_comment; > >+ } > >+ q++; > >+ } > >+ *p = '\0'; > >+ nl = p; > >+ break; > >+ } else { > >+ p++; > >+ } > >+ } > >+ > >+ p = line; > >+ while (p < nl) { > >+ /* Skip white space */ > >+ while (p < nl && isspace(*p)) > >+ *(p++) = 0; > >+ if (p >= nl) > >+ break; > >+ > >+ tokens[tix].line = lineno; > >+ start = p; > >+ > >+ /* Handle string tokens */ > >+ if (isalpha(*p)) { > >+ const char **dir; > >+ > >+ /* Can be a directive, type name or element > >+ * name. Find the end of the name. > >+ */ > >+ q = p + 1; > >+ while (q < nl && (isalnum(*q) || *q == '-' || > >*q == '_')) > >+ q++; > >+ tokens[tix].size = q - p; > >+ p = q; > >+ > >+ tokens[tix].content = malloc(tokens[tix].size + > >1); > >+ if (!tokens[tix].content) { > >+ perror(NULL); > >+ exit(1); > >+ } > >+ memcpy(tokens[tix].content, start, > >tokens[tix].size); > >+ tokens[tix].content[tokens[tix].size] = 0; > >+ > >+ /* If it begins with a lowercase letter then > >+ * it's an element name > >+ */ > >+ if (islower(tokens[tix].content[0])) { > >+ tokens[tix++].token_type = > >TOKEN_ELEMENT_NAME; > >+ continue; > >+ } > >+ > >+ /* Otherwise we need to search the directive > >+ * table > >+ */ > >+ dir = bsearch(&tokens[tix], directives, > >+ sizeof(directives) / > >sizeof(directives[1]), > >+ sizeof(directives[1]), > >+ directive_compare); > >+ if (dir) { > >+ tokens[tix++].token_type = dir - > >directives; > >+ continue; > >+ } > >+ > >+ tokens[tix++].token_type = TOKEN_TYPE_NAME; > >+ continue; > >+ } > >+ > >+ /* Handle numbers */ > >+ if (isdigit(*p)) { > >+ /* Find the end of the number */ > >+ q = p + 1; > >+ while (q < nl && (isdigit(*q))) > >+ q++; > >+ tokens[tix].size = q - p; > >+ p = q; > >+ tokens[tix].content = malloc(tokens[tix].size + > >1); > >+ if (!tokens[tix].content) { > >+ perror(NULL); > >+ exit(1); > >+ } > >+ memcpy(tokens[tix].content, start, > >tokens[tix].size); > >+ tokens[tix].content[tokens[tix].size] = 0; > >+ tokens[tix++].token_type = TOKEN_NUMBER; > >+ continue; > >+ } > >+ > >+ if (nl - p >= 3) { > >+ if (memcmp(p, "::=", 3) == 0) { > >+ p += 3; > >+ tokens[tix].size = 3; > >+ tokens[tix].content = "::="; > >+ tokens[tix++].token_type = > >TOKEN_ASSIGNMENT; > >+ continue; > >+ } > >+ } > >+ > >+ if (nl - p >= 2) { > >+ if (memcmp(p, "({", 2) == 0) { > >+ p += 2; > >+ tokens[tix].size = 2; > >+ tokens[tix].content = "({"; > >+ tokens[tix++].token_type = > >TOKEN_OPEN_ACTION; > >+ continue; > >+ } > >+ if (memcmp(p, "})", 2) == 0) { > >+ p += 2; > >+ tokens[tix].size = 2; > >+ tokens[tix].content = "})"; > >+ tokens[tix++].token_type = > >TOKEN_CLOSE_ACTION; > >+ continue; > >+ } > >+ } > >+ > >+ if (nl - p >= 1) { > >+ tokens[tix].size = 1; > >+ switch (*p) { > >+ case '{': > >+ p += 1; > >+ tokens[tix].content = "{"; > >+ tokens[tix++].token_type = > >TOKEN_OPEN_CURLY; > >+ continue; > >+ case '}': > >+ p += 1; > >+ tokens[tix].content = "}"; > >+ tokens[tix++].token_type = > >TOKEN_CLOSE_CURLY; > >+ continue; > >+ case '[': > >+ p += 1; > >+ tokens[tix].content = "["; > >+ tokens[tix++].token_type = > >TOKEN_OPEN_SQUARE; > >+ continue; > >+ case ']': > >+ p += 1; > >+ tokens[tix].content = "]"; > >+ tokens[tix++].token_type = > >TOKEN_CLOSE_SQUARE; > >+ continue; > >+ case ',': > >+ p += 1; > >+ tokens[tix].content = ","; > >+ tokens[tix++].token_type = TOKEN_COMMA; > >+ continue; > >+ default: > >+ break; > >+ } > >+ } > >+ > >+ fprintf(stderr, "%s:%u: Unknown character in grammar: > >'%c'\n", > >+ filename, lineno, *p); > >+ exit(1); > >+ } > >+ } > >+ > >+ nr_tokens = tix; > >+ verbose("Extracted %u tokens\n", nr_tokens); > >+ > >+#if 0 > >+ { > >+ int n; > >+ for (n = 0; n < nr_tokens; n++) > >+ debug("Token %3u: '%s'\n", n, token_list[n].content); > >+ } > >+#endif > >+} > >+ > >+static void build_type_list(void); > >+static void parse(void); > >+static void dump_elements(void); > >+static void render(FILE *out, FILE *hdr); > >+ > >+/* > >+ * > >+ */ > >+int main(int argc, char **argv) > >+{ > >+ struct stat st; > >+ ssize_t readlen; > >+ FILE *out, *hdr; > >+ char *buffer, *p; > >+ char *kbuild_verbose; > >+ int fd; > >+ > >+ kbuild_verbose = getenv("KBUILD_VERBOSE"); > >+ if (kbuild_verbose) > >+ verbose_opt = atoi(kbuild_verbose); > >+ > >+ while (argc > 4) { > >+ if (strcmp(argv[1], "-v") == 0) > >+ verbose_opt = true; > >+ else if (strcmp(argv[1], "-d") == 0) > >+ debug_opt = true; > >+ else > >+ break; > >+ memmove(&argv[1], &argv[2], (argc - 2) * sizeof(char *)); > >+ argc--; > >+ } > >+ > >+ if (argc != 4) { > >+ fprintf(stderr, "Format: %s [-v] [-d] <grammar-file> <c-file> > ><hdr-file>\n", > >+ argv[0]); > >+ exit(2); > >+ } > >+ > >+ filename = argv[1]; > >+ outputname = argv[2]; > >+ headername = argv[3]; > >+ > >+ fd = open(filename, O_RDONLY); > >+ if (fd < 0) { > >+ perror(filename); > >+ exit(1); > >+ } > >+ > >+ if (fstat(fd, &st) < 0) { > >+ perror(filename); > >+ exit(1); > >+ } > >+ > >+ if (!(buffer = malloc(st.st_size + 1))) { > >+ perror(NULL); > >+ exit(1); > >+ } > >+ > >+ if ((readlen = read(fd, buffer, st.st_size)) < 0) { > >+ perror(filename); > >+ exit(1); > >+ } > >+ > >+ if (close(fd) < 0) { > >+ perror(filename); > >+ exit(1); > >+ } > >+ > >+ if (readlen != st.st_size) { > >+ fprintf(stderr, "%s: Short read\n", filename); > >+ exit(1); > >+ } > >+ > >+ p = strrchr(argv[1], '/'); > >+ p = p ? p + 1 : argv[1]; > >+ grammar_name = strdup(p); > >+ if (!p) { > >+ perror(NULL); > >+ exit(1); > >+ } > >+ p = strchr(grammar_name, '.'); > >+ if (p) > >+ *p = '\0'; > >+ > >+ buffer[readlen] = 0; > >+ tokenise(buffer, buffer + readlen); > >+ build_type_list(); > >+ parse(); > >+ dump_elements(); > >+ > >+ out = fopen(outputname, "w"); > >+ if (!out) { > >+ perror(outputname); > >+ exit(1); > >+ } > >+ > >+ hdr = fopen(headername, "w"); > >+ if (!hdr) { > >+ perror(headername); > >+ exit(1); > >+ } > >+ > >+ render(out, hdr); > >+ > >+ if (fclose(out) < 0) { > >+ perror(outputname); > >+ exit(1); > >+ } > >+ > >+ if (fclose(hdr) < 0) { > >+ perror(headername); > >+ exit(1); > >+ } > >+ > >+ return 0; > >+} > >+ > >+enum compound { > >+ NOT_COMPOUND, > >+ SET, > >+ SET_OF, > >+ SEQUENCE, > >+ SEQUENCE_OF, > >+ CHOICE, > >+ ANY, > >+ TYPE_REF, > >+ TAG_OVERRIDE > >+}; > >+ > >+struct element { > >+ struct type *type_def; > >+ struct token *name; > >+ struct token *type; > >+ struct action *action; > >+ struct element *children; > >+ struct element *next; > >+ struct element *render_next; > >+ struct element *list_next; > >+ uint8_t n_elements; > >+ enum compound compound : 8; > >+ enum asn1_class class : 8; > >+ enum asn1_method method : 8; > >+ uint8_t tag; > >+ unsigned entry_index; > >+ unsigned flags; > >+#define ELEMENT_IMPLICIT 0x0001 > >+#define ELEMENT_EXPLICIT 0x0002 > >+#define ELEMENT_TAG_SPECIFIED 0x0004 > >+#define ELEMENT_RENDERED 0x0008 > >+#define ELEMENT_SKIPPABLE 0x0010 > >+#define ELEMENT_CONDITIONAL 0x0020 > >+}; > >+ > >+struct type { > >+ struct token *name; > >+ struct token *def; > >+ struct element *element; > >+ unsigned ref_count; > >+ unsigned flags; > >+#define TYPE_STOP_MARKER 0x0001 > >+#define TYPE_BEGIN 0x0002 > >+}; > >+ > >+static struct type *type_list; > >+static struct type **type_index; > >+static unsigned nr_types; > >+ > >+static int type_index_compare(const void *_a, const void *_b) > >+{ > >+ const struct type *const *a = _a, *const *b = _b; > >+ > >+ if ((*a)->name->size != (*b)->name->size) > >+ return (*a)->name->size - (*b)->name->size; > >+ else > >+ return memcmp((*a)->name->content, (*b)->name->content, > >+ (*a)->name->size); > >+} > >+ > >+static int type_finder(const void *_key, const void *_ti) > >+{ > >+ const struct token *token = _key; > >+ const struct type *const *ti = _ti; > >+ const struct type *type = *ti; > >+ > >+ if (token->size != type->name->size) > >+ return token->size - type->name->size; > >+ else > >+ return memcmp(token->content, type->name->content, > >+ token->size); > >+} > >+ > >+/* > >+ * Build up a list of types and a sorted index to that list. > >+ */ > >+static void build_type_list(void) > >+{ > >+ struct type *types; > >+ unsigned nr, t, n; > >+ > >+ nr = 0; > >+ for (n = 0; n < nr_tokens - 1; n++) > >+ if (token_list[n + 0].token_type == TOKEN_TYPE_NAME && > >+ token_list[n + 1].token_type == TOKEN_ASSIGNMENT) > >+ nr++; > >+ > >+ if (nr == 0) { > >+ fprintf(stderr, "%s: No defined types\n", filename); > >+ exit(1); > >+ } > >+ > >+ nr_types = nr; > >+ types = type_list = calloc(nr + 1, sizeof(type_list[0])); > >+ if (!type_list) { > >+ perror(NULL); > >+ exit(1); > >+ } > >+ type_index = calloc(nr, sizeof(type_index[0])); > >+ if (!type_index) { > >+ perror(NULL); > >+ exit(1); > >+ } > >+ > >+ t = 0; > >+ types[t].flags |= TYPE_BEGIN; > >+ for (n = 0; n < nr_tokens - 1; n++) { > >+ if (token_list[n + 0].token_type == TOKEN_TYPE_NAME && > >+ token_list[n + 1].token_type == TOKEN_ASSIGNMENT) { > >+ types[t].name = &token_list[n]; > >+ type_index[t] = &types[t]; > >+ t++; > >+ } > >+ } > >+ types[t].name = &token_list[n + 1]; > >+ types[t].flags |= TYPE_STOP_MARKER; > >+ > >+ qsort(type_index, nr, sizeof(type_index[0]), type_index_compare); > >+ > >+ verbose("Extracted %u types\n", nr_types); > >+#if 0 > >+ for (n = 0; n < nr_types; n++) { > >+ struct type *type = type_index[n]; > >+ debug("- %*.*s\n", type->name->content); > >+ } > >+#endif > >+} > >+ > >+static struct element *parse_type(struct token **_cursor, struct token > >*stop, > >+ struct token *name); > >+ > >+/* > >+ * Parse the token stream > >+ */ > >+static void parse(void) > >+{ > >+ struct token *cursor; > >+ struct type *type; > >+ > >+ /* Parse one type definition statement at a time */ > >+ type = type_list; > >+ do { > >+ cursor = type->name; > >+ > >+ if (cursor[0].token_type != TOKEN_TYPE_NAME || > >+ cursor[1].token_type != TOKEN_ASSIGNMENT) > >+ abort(); > >+ cursor += 2; > >+ > >+ type->element = parse_type(&cursor, type[1].name, NULL); > >+ type->element->type_def = type; > >+ > >+ if (cursor != type[1].name) { > >+ fprintf(stderr, "%s:%d: Parse error at token '%s'\n", > >+ filename, cursor->line, cursor->content); > >+ exit(1); > >+ } > >+ > >+ } while (type++, !(type->flags & TYPE_STOP_MARKER)); > >+ > >+ verbose("Extracted %u actions\n", nr_actions); > >+} > >+ > >+static struct element *element_list; > >+ > >+static struct element *alloc_elem(struct token *type) > >+{ > >+ struct element *e = calloc(1, sizeof(*e)); > >+ if (!e) { > >+ perror(NULL); > >+ exit(1); > >+ } > >+ e->list_next = element_list; > >+ element_list = e; > >+ return e; > >+} > >+ > >+static struct element *parse_compound(struct token **_cursor, struct token > >*end, > >+ int alternates); > >+ > >+/* > >+ * Parse one type definition statement > >+ */ > >+static struct element *parse_type(struct token **_cursor, struct token *end, > >+ struct token *name) > >+{ > >+ struct element *top, *element; > >+ struct action *action, **ppaction; > >+ struct token *cursor = *_cursor; > >+ struct type **ref; > >+ char *p; > >+ int labelled = 0, implicit = 0; > >+ > >+ top = element = alloc_elem(cursor); > >+ element->class = ASN1_UNIV; > >+ element->method = ASN1_PRIM; > >+ element->tag = token_to_tag[cursor->token_type]; > >+ element->name = name; > >+ > >+ /* Extract the tag value if one given */ > >+ if (cursor->token_type == TOKEN_OPEN_SQUARE) { > >+ cursor++; > >+ if (cursor >= end) > >+ goto overrun_error; > >+ switch (cursor->token_type) { > >+ case DIRECTIVE_UNIVERSAL: > >+ element->class = ASN1_UNIV; > >+ cursor++; > >+ break; > >+ case DIRECTIVE_APPLICATION: > >+ element->class = ASN1_APPL; > >+ cursor++; > >+ break; > >+ case TOKEN_NUMBER: > >+ element->class = ASN1_CONT; > >+ break; > >+ case DIRECTIVE_PRIVATE: > >+ element->class = ASN1_PRIV; > >+ cursor++; > >+ break; > >+ default: > >+ fprintf(stderr, "%s:%d: Unrecognised tag class token > >'%s'\n", > >+ filename, cursor->line, cursor->content); > >+ exit(1); > >+ } > >+ > >+ if (cursor >= end) > >+ goto overrun_error; > >+ if (cursor->token_type != TOKEN_NUMBER) { > >+ fprintf(stderr, "%s:%d: Missing tag number '%s'\n", > >+ filename, cursor->line, cursor->content); > >+ exit(1); > >+ } > >+ > >+ element->tag &= ~0x1f; > >+ element->tag |= strtoul(cursor->content, &p, 10); > >+ element->flags |= ELEMENT_TAG_SPECIFIED; > >+ if (p - cursor->content != cursor->size) > >+ abort(); > >+ cursor++; > >+ > >+ if (cursor >= end) > >+ goto overrun_error; > >+ if (cursor->token_type != TOKEN_CLOSE_SQUARE) { > >+ fprintf(stderr, "%s:%d: Missing closing square bracket > >'%s'\n", > >+ filename, cursor->line, cursor->content); > >+ exit(1); > >+ } > >+ cursor++; > >+ if (cursor >= end) > >+ goto overrun_error; > >+ labelled = 1; > >+ } > >+ > >+ /* Handle implicit and explicit markers */ > >+ if (cursor->token_type == DIRECTIVE_IMPLICIT) { > >+ element->flags |= ELEMENT_IMPLICIT; > >+ implicit = 1; > >+ cursor++; > >+ if (cursor >= end) > >+ goto overrun_error; > >+ } else if (cursor->token_type == DIRECTIVE_EXPLICIT) { > >+ element->flags |= ELEMENT_EXPLICIT; > >+ cursor++; > >+ if (cursor >= end) > >+ goto overrun_error; > >+ } > >+ > >+ if (labelled) { > >+ if (!implicit) > >+ element->method |= ASN1_CONS; > >+ element->compound = implicit ? TAG_OVERRIDE : SEQUENCE; > >+ element->children = alloc_elem(cursor); > >+ element = element->children; > >+ element->class = ASN1_UNIV; > >+ element->method = ASN1_PRIM; > >+ element->tag = token_to_tag[cursor->token_type]; > >+ element->name = name; > >+ } > >+ > >+ /* Extract the type we're expecting here */ > >+ element->type = cursor; > >+ switch (cursor->token_type) { > >+ case DIRECTIVE_ANY: > >+ element->compound = ANY; > >+ cursor++; > >+ break; > >+ > >+ case DIRECTIVE_NULL: > >+ case DIRECTIVE_BOOLEAN: > >+ case DIRECTIVE_ENUMERATED: > >+ case DIRECTIVE_INTEGER: > >+ element->compound = NOT_COMPOUND; > >+ cursor++; > >+ break; > >+ > >+ case DIRECTIVE_EXTERNAL: > >+ element->method = ASN1_CONS; > >+ > >+ case DIRECTIVE_BMPString: > >+ case DIRECTIVE_GeneralString: > >+ case DIRECTIVE_GraphicString: > >+ case DIRECTIVE_IA5String: > >+ case DIRECTIVE_ISO646String: > >+ case DIRECTIVE_NumericString: > >+ case DIRECTIVE_PrintableString: > >+ case DIRECTIVE_T61String: > >+ case DIRECTIVE_TeletexString: > >+ case DIRECTIVE_UniversalString: > >+ case DIRECTIVE_UTF8String: > >+ case DIRECTIVE_VideotexString: > >+ case DIRECTIVE_VisibleString: > >+ case DIRECTIVE_ObjectDescriptor: > >+ case DIRECTIVE_GeneralizedTime: > >+ case DIRECTIVE_UTCTime: > >+ element->compound = NOT_COMPOUND; > >+ cursor++; > >+ break; > >+ > >+ case DIRECTIVE_BIT: > >+ case DIRECTIVE_OCTET: > >+ element->compound = NOT_COMPOUND; > >+ cursor++; > >+ if (cursor >= end) > >+ goto overrun_error; > >+ if (cursor->token_type != DIRECTIVE_STRING) > >+ goto parse_error; > >+ cursor++; > >+ break; > >+ > >+ case DIRECTIVE_OBJECT: > >+ element->compound = NOT_COMPOUND; > >+ cursor++; > >+ if (cursor >= end) > >+ goto overrun_error; > >+ if (cursor->token_type != DIRECTIVE_IDENTIFIER) > >+ goto parse_error; > >+ cursor++; > >+ break; > >+ > >+ case TOKEN_TYPE_NAME: > >+ element->compound = TYPE_REF; > >+ ref = bsearch(cursor, type_index, nr_types, > >sizeof(type_index[0]), > >+ type_finder); > >+ if (!ref) { > >+ fprintf(stderr, "%s:%d: Type '%s' undefined\n", > >+ filename, cursor->line, cursor->content); > >+ exit(1); > >+ } > >+ cursor->type = *ref; > >+ (*ref)->ref_count++; > >+ cursor++; > >+ break; > >+ > >+ case DIRECTIVE_CHOICE: > >+ element->compound = CHOICE; > >+ cursor++; > >+ element->children = parse_compound(&cursor, end, 1); > >+ break; > >+ > >+ case DIRECTIVE_SEQUENCE: > >+ element->compound = SEQUENCE; > >+ element->method = ASN1_CONS; > >+ cursor++; > >+ if (cursor >= end) > >+ goto overrun_error; > >+ if (cursor->token_type == DIRECTIVE_OF) { > >+ element->compound = SEQUENCE_OF; > >+ cursor++; > >+ if (cursor >= end) > >+ goto overrun_error; > >+ element->children = parse_type(&cursor, end, NULL); > >+ } else { > >+ element->children = parse_compound(&cursor, end, 0); > >+ } > >+ break; > >+ > >+ case DIRECTIVE_SET: > >+ element->compound = SET; > >+ element->method = ASN1_CONS; > >+ cursor++; > >+ if (cursor >= end) > >+ goto overrun_error; > >+ if (cursor->token_type == DIRECTIVE_OF) { > >+ element->compound = SET_OF; > >+ cursor++; > >+ if (cursor >= end) > >+ goto parse_error; > >+ element->children = parse_type(&cursor, end, NULL); > >+ } else { > >+ element->children = parse_compound(&cursor, end, 1); > >+ } > >+ break; > >+ > >+ default: > >+ fprintf(stderr, "%s:%d: Token '%s' does not introduce a type\n", > >+ filename, cursor->line, cursor->content); > >+ exit(1); > >+ } > >+ > >+ /* Handle elements that are optional */ > >+ if (cursor < end && (cursor->token_type == DIRECTIVE_OPTIONAL || > >+ cursor->token_type == DIRECTIVE_DEFAULT) > >+ ) { > >+ cursor++; > >+ top->flags |= ELEMENT_SKIPPABLE; > >+ } > >+ > >+ if (cursor < end && cursor->token_type == TOKEN_OPEN_ACTION) { > >+ cursor++; > >+ if (cursor >= end) > >+ goto overrun_error; > >+ if (cursor->token_type != TOKEN_ELEMENT_NAME) { > >+ fprintf(stderr, "%s:%d: Token '%s' is not an action > >function name\n", > >+ filename, cursor->line, cursor->content); > >+ exit(1); > >+ } > >+ > >+ action = malloc(sizeof(struct action)); > >+ if (!action) { > >+ perror(NULL); > >+ exit(1); > >+ } > >+ action->index = 0; > >+ action->name = cursor->content; > >+ > >+ for (ppaction = &action_list; > >+ *ppaction; > >+ ppaction = &(*ppaction)->next > >+ ) { > >+ int cmp = strcmp(action->name, (*ppaction)->name); > >+ if (cmp == 0) { > >+ free(action); > >+ action = *ppaction; > >+ goto found; > >+ } > >+ if (cmp < 0) { > >+ action->next = *ppaction; > >+ *ppaction = action; > >+ nr_actions++; > >+ goto found; > >+ } > >+ } > >+ action->next = NULL; > >+ *ppaction = action; > >+ nr_actions++; > >+ found: > >+ > >+ element->action = action; > >+ cursor->action = action; > >+ cursor++; > >+ if (cursor >= end) > >+ goto overrun_error; > >+ if (cursor->token_type != TOKEN_CLOSE_ACTION) { > >+ fprintf(stderr, "%s:%d: Missing close action, got > >'%s'\n", > >+ filename, cursor->line, cursor->content); > >+ exit(1); > >+ } > >+ cursor++; > >+ } > >+ > >+ *_cursor = cursor; > >+ return top; > >+ > >+parse_error: > >+ fprintf(stderr, "%s:%d: Unexpected token '%s'\n", > >+ filename, cursor->line, cursor->content); > >+ exit(1); > >+ > >+overrun_error: > >+ fprintf(stderr, "%s: Unexpectedly hit EOF\n", filename); > >+ exit(1); > >+} > >+ > >+/* > >+ * Parse a compound type list > >+ */ > >+static struct element *parse_compound(struct token **_cursor, struct token > >*end, > >+ int alternates) > >+{ > >+ struct element *children, **child_p = &children, *element; > >+ struct token *cursor = *_cursor, *name; > >+ > >+ if (cursor->token_type != TOKEN_OPEN_CURLY) { > >+ fprintf(stderr, "%s:%d: Expected compound to start with brace > >not '%s'\n", > >+ filename, cursor->line, cursor->content); > >+ exit(1); > >+ } > >+ cursor++; > >+ if (cursor >= end) > >+ goto overrun_error; > >+ > >+ if (cursor->token_type == TOKEN_OPEN_CURLY) { > >+ fprintf(stderr, "%s:%d: Empty compound\n", > >+ filename, cursor->line); > >+ exit(1); > >+ } > >+ > >+ for (;;) { > >+ name = NULL; > >+ if (cursor->token_type == TOKEN_ELEMENT_NAME) { > >+ name = cursor; > >+ cursor++; > >+ if (cursor >= end) > >+ goto overrun_error; > >+ } > >+ > >+ element = parse_type(&cursor, end, name); > >+ if (alternates) > >+ element->flags |= ELEMENT_SKIPPABLE | > >ELEMENT_CONDITIONAL; > >+ > >+ *child_p = element; > >+ child_p = &element->next; > >+ > >+ if (cursor >= end) > >+ goto overrun_error; > >+ if (cursor->token_type != TOKEN_COMMA) > >+ break; > >+ cursor++; > >+ if (cursor >= end) > >+ goto overrun_error; > >+ } > >+ > >+ children->flags &= ~ELEMENT_CONDITIONAL; > >+ > >+ if (cursor->token_type != TOKEN_CLOSE_CURLY) { > >+ fprintf(stderr, "%s:%d: Expected compound closure, got '%s'\n", > >+ filename, cursor->line, cursor->content); > >+ exit(1); > >+ } > >+ cursor++; > >+ > >+ *_cursor = cursor; > >+ return children; > >+ > >+overrun_error: > >+ fprintf(stderr, "%s: Unexpectedly hit EOF\n", filename); > >+ exit(1); > >+} > >+ > >+static void dump_element(const struct element *e, int level) > >+{ > >+ const struct element *c; > >+ const struct type *t = e->type_def; > >+ const char *name = e->name ? e->name->content : "."; > >+ const char *tname = t && t->name ? t->name->content : "."; > >+ char tag[32]; > >+ > >+ if (e->class == 0 && e->method == 0 && e->tag == 0) > >+ strcpy(tag, "<...>"); > >+ else if (e->class == ASN1_UNIV) > >+ sprintf(tag, "%s %s %s", > >+ asn1_classes[e->class], > >+ asn1_methods[e->method], > >+ asn1_universal_tags[e->tag]); > >+ else > >+ sprintf(tag, "%s %s %u", > >+ asn1_classes[e->class], > >+ asn1_methods[e->method], > >+ e->tag); > >+ > >+ printf("%c%c%c%c%c %c %*s[*] \e[33m%s\e[m %s %s \e[35m%s\e[m\n", > >+ e->flags & ELEMENT_IMPLICIT ? 'I' : '-', > >+ e->flags & ELEMENT_EXPLICIT ? 'E' : '-', > >+ e->flags & ELEMENT_TAG_SPECIFIED ? 'T' : '-', > >+ e->flags & ELEMENT_SKIPPABLE ? 'S' : '-', > >+ e->flags & ELEMENT_CONDITIONAL ? 'C' : '-', > >+ "-tTqQcaro"[e->compound], > >+ level, "", > >+ tag, > >+ tname, > >+ name, > >+ e->action ? e->action->name : ""); > >+ if (e->compound == TYPE_REF) > >+ dump_element(e->type->type->element, level + 3); > >+ else > >+ for (c = e->children; c; c = c->next) > >+ dump_element(c, level + 3); > >+} > >+ > >+static void dump_elements(void) > >+{ > >+ if (debug_opt) > >+ dump_element(type_list[0].element, 0); > >+} > >+ > >+static void render_element(FILE *out, struct element *e, struct element > >*tag); > >+static void render_out_of_line_list(FILE *out); > >+ > >+static int nr_entries; > >+static int render_depth = 1; > >+static struct element *render_list, **render_list_p = &render_list; > >+ > >+__attribute__((format(printf, 2, 3))) > >+static void render_opcode(FILE *out, const char *fmt, ...) > >+{ > >+ va_list va; > >+ > >+ if (out) { > >+ fprintf(out, "\t[%4d] =%*s", nr_entries, render_depth, ""); > >+ va_start(va, fmt); > >+ vfprintf(out, fmt, va); > >+ va_end(va); > >+ } > >+ nr_entries++; > >+} > >+ > >+__attribute__((format(printf, 2, 3))) > >+static void render_more(FILE *out, const char *fmt, ...) > >+{ > >+ va_list va; > >+ > >+ if (out) { > >+ va_start(va, fmt); > >+ vfprintf(out, fmt, va); > >+ va_end(va); > >+ } > >+} > >+ > >+/* > >+ * Render the grammar into a state machine definition. > >+ */ > >+static void render(FILE *out, FILE *hdr) > >+{ > >+ struct element *e; > >+ struct action *action; > >+ struct type *root; > >+ int index; > >+ > >+ fprintf(hdr, "/*\n"); > >+ fprintf(hdr, " * Automatically generated by asn1_compiler. Do not > >edit\n"); > >+ fprintf(hdr, " *\n"); > >+ fprintf(hdr, " * ASN.1 parser for %s\n", grammar_name); > >+ fprintf(hdr, " */\n"); > >+ fprintf(hdr, "#include <linux/asn1_decoder.h>\n"); > >+ fprintf(hdr, "\n"); > >+ fprintf(hdr, "extern const struct asn1_decoder %s_decoder;\n", > >grammar_name); > >+ if (ferror(hdr)) { > >+ perror(headername); > >+ exit(1); > >+ } > >+ > >+ fprintf(out, "/*\n"); > >+ fprintf(out, " * Automatically generated by asn1_compiler. Do not > >edit\n"); > >+ fprintf(out, " *\n"); > >+ fprintf(out, " * ASN.1 parser for %s\n", grammar_name); > >+ fprintf(out, " */\n"); > >+ fprintf(out, "#include <linux/asn1_ber_bytecode.h>\n"); > >+ fprintf(out, "#include \"%s.asn1.h\"\n", grammar_name); > >+ fprintf(out, "\n"); > >+ if (ferror(out)) { > >+ perror(outputname); > >+ exit(1); > >+ } > >+ > >+ /* Tabulate the action functions we might have to call */ > >+ fprintf(hdr, "\n"); > >+ index = 0; > >+ for (action = action_list; action; action = action->next) { > >+ action->index = index++; > >+ fprintf(hdr, > >+ "extern int %s(void *, size_t, unsigned char," > >+ " const void *, size_t);\n", > >+ action->name); > >+ } > >+ fprintf(hdr, "\n"); > >+ > >+ fprintf(out, "enum %s_actions {\n", grammar_name); > >+ for (action = action_list; action; action = action->next) > >+ fprintf(out, "\tACT_%s = %u,\n", > >+ action->name, action->index); > >+ fprintf(out, "\tNR__%s_actions = %u\n", grammar_name, nr_actions); > >+ fprintf(out, "};\n"); > >+ > >+ fprintf(out, "\n"); > >+ fprintf(out, "static const asn1_action_t > >%s_action_table[NR__%s_actions] = {\n", > >+ grammar_name, grammar_name); > >+ for (action = action_list; action; action = action->next) > >+ fprintf(out, "\t[%4u] = %s,\n", action->index, action->name); > >+ fprintf(out, "};\n"); > >+ > >+ if (ferror(out)) { > >+ perror(outputname); > >+ exit(1); > >+ } > >+ > >+ /* We do two passes - the first one calculates all the offsets */ > >+ verbose("Pass 1\n"); > >+ nr_entries = 0; > >+ root = &type_list[0]; > >+ render_element(NULL, root->element, NULL); > >+ render_opcode(NULL, "ASN1_OP_COMPLETE,\n"); > >+ render_out_of_line_list(NULL); > >+ > >+ for (e = element_list; e; e = e->list_next) > >+ e->flags &= ~ELEMENT_RENDERED; > >+ > >+ /* And then we actually render */ > >+ verbose("Pass 2\n"); > >+ fprintf(out, "\n"); > >+ fprintf(out, "static const unsigned char %s_machine[] = {\n", > >+ grammar_name); > >+ > >+ nr_entries = 0; > >+ root = &type_list[0]; > >+ render_element(out, root->element, NULL); > >+ render_opcode(out, "ASN1_OP_COMPLETE,\n"); > >+ render_out_of_line_list(out); > >+ > >+ fprintf(out, "};\n"); > >+ > >+ fprintf(out, "\n"); > >+ fprintf(out, "const struct asn1_decoder %s_decoder = {\n", > >grammar_name); > >+ fprintf(out, "\t.machine = %s_machine,\n", grammar_name); > >+ fprintf(out, "\t.machlen = sizeof(%s_machine),\n", grammar_name); > >+ fprintf(out, "\t.actions = %s_action_table,\n", grammar_name); > >+ fprintf(out, "};\n"); > >+} > >+ > >+/* > >+ * Render the out-of-line elements > >+ */ > >+static void render_out_of_line_list(FILE *out) > >+{ > >+ struct element *e, *ce; > >+ const char *act; > >+ int entry; > >+ > >+ while ((e = render_list)) { > >+ render_list = e->render_next; > >+ if (!render_list) > >+ render_list_p = &render_list; > >+ > >+ render_more(out, "\n"); > >+ e->entry_index = entry = nr_entries; > >+ render_depth++; > >+ for (ce = e->children; ce; ce = ce->next) > >+ render_element(out, ce, NULL); > >+ render_depth--; > >+ > >+ act = e->action ? "_ACT" : ""; > >+ switch (e->compound) { > >+ case SEQUENCE: > >+ render_opcode(out, "ASN1_OP_END_SEQ%s,\n", act); > >+ break; > >+ case SEQUENCE_OF: > >+ render_opcode(out, "ASN1_OP_END_SEQ_OF%s,\n", act); > >+ render_opcode(out, "_jump_target(%u),\n", entry); > >+ break; > >+ case SET: > >+ render_opcode(out, "ASN1_OP_END_SET%s,\n", act); > >+ break; > >+ case SET_OF: > >+ render_opcode(out, "ASN1_OP_END_SET_OF%s,\n", act); > >+ render_opcode(out, "_jump_target(%u),\n", entry); > >+ break; > >+ default: > >+ break; > >+ } > >+ if (e->action) > >+ render_opcode(out, "_action(ACT_%s),\n", > >+ e->action->name); > >+ render_opcode(out, "ASN1_OP_RETURN,\n"); > >+ } > >+} > >+ > >+/* > >+ * Render an element. > >+ */ > >+static void render_element(FILE *out, struct element *e, struct element > >*tag) > >+{ > >+ struct element *ec, *x; > >+ const char *cond, *act; > >+ int entry, skippable = 0, outofline = 0; > >+ > >+ if (e->flags & ELEMENT_SKIPPABLE || > >+ (tag && tag->flags & ELEMENT_SKIPPABLE)) > >+ skippable = 1; > >+ > >+ if ((e->type_def && e->type_def->ref_count > 1) || > >+ skippable) > >+ outofline = 1; > >+ > >+ if (e->type_def && out) { > >+ render_more(out, "\t// %s\n", e->type_def->name->content); > >+ } > >+ > >+ /* Render the operation */ > >+ cond = (e->flags & ELEMENT_CONDITIONAL || > >+ (tag && tag->flags & ELEMENT_CONDITIONAL)) ? "COND_" : ""; > >+ act = e->action ? "_ACT" : ""; > >+ switch (e->compound) { > >+ case ANY: > >+ render_opcode(out, "ASN1_OP_%sMATCH_ANY%s%s,", > >+ cond, act, skippable ? "_OR_SKIP" : ""); > >+ if (e->name) > >+ render_more(out, "\t\t// %s", e->name->content); > >+ render_more(out, "\n"); > >+ goto dont_render_tag; > >+ > >+ case TAG_OVERRIDE: > >+ render_element(out, e->children, e); > >+ return; > >+ > >+ case SEQUENCE: > >+ case SEQUENCE_OF: > >+ case SET: > >+ case SET_OF: > >+ render_opcode(out, "ASN1_OP_%sMATCH%s%s,", > >+ cond, > >+ outofline ? "_JUMP" : "", > >+ skippable ? "_OR_SKIP" : ""); > >+ break; > >+ > >+ case CHOICE: > >+ goto dont_render_tag; > >+ > >+ case TYPE_REF: > >+ if (e->class == ASN1_UNIV && e->method == ASN1_PRIM && e->tag > >== 0) > >+ goto dont_render_tag; > >+ default: > >+ render_opcode(out, "ASN1_OP_%sMATCH%s%s,", > >+ cond, act, > >+ skippable ? "_OR_SKIP" : ""); > >+ break; > >+ } > >+ > >+ x = tag ?: e; > >+ if (x->name) > >+ render_more(out, "\t\t// %s", x->name->content); > >+ render_more(out, "\n"); > >+ > >+ /* Render the tag */ > >+ if (!tag || !(tag->flags & ELEMENT_TAG_SPECIFIED)) > >+ tag = e; > >+ > >+ if (tag->class == ASN1_UNIV && > >+ tag->tag != 14 && > >+ tag->tag != 15 && > >+ tag->tag != 31) > >+ render_opcode(out, "_tag(%s, %s, %s),\n", > >+ asn1_classes[tag->class], > >+ asn1_methods[tag->method | e->method], > >+ asn1_universal_tags[tag->tag]); > >+ else > >+ render_opcode(out, "_tagn(%s, %s, %2u),\n", > >+ asn1_classes[tag->class], > >+ asn1_methods[tag->method | e->method], > >+ tag->tag); > >+ tag = NULL; > >+dont_render_tag: > >+ > >+ /* Deal with compound types */ > >+ switch (e->compound) { > >+ case TYPE_REF: > >+ render_element(out, e->type->type->element, tag); > >+ if (e->action) > >+ render_opcode(out, "ASN1_OP_%sACT,\n", > >+ skippable ? "MAYBE_" : ""); > >+ break; > >+ > >+ case SEQUENCE: > >+ if (outofline) { > >+ /* Render out-of-line for multiple use or > >+ * skipability */ > >+ render_opcode(out, "_jump_target(%u),", e->entry_index); > >+ if (e->type_def && e->type_def->name) > >+ render_more(out, "\t\t// --> %s", > >+ e->type_def->name->content); > >+ render_more(out, "\n"); > >+ if (!(e->flags & ELEMENT_RENDERED)) { > >+ e->flags |= ELEMENT_RENDERED; > >+ *render_list_p = e; > >+ render_list_p = &e->render_next; > >+ } > >+ return; > >+ } else { > >+ /* Render inline for single use */ > >+ render_depth++; > >+ for (ec = e->children; ec; ec = ec->next) > >+ render_element(out, ec, NULL); > >+ render_depth--; > >+ render_opcode(out, "ASN1_OP_END_SEQ%s,\n", act); > >+ } > >+ break; > >+ > >+ case SEQUENCE_OF: > >+ case SET_OF: > >+ if (outofline) { > >+ /* Render out-of-line for multiple use or > >+ * skipability */ > >+ render_opcode(out, "_jump_target(%u),", e->entry_index); > >+ if (e->type_def && e->type_def->name) > >+ render_more(out, "\t\t// --> %s", > >+ e->type_def->name->content); > >+ render_more(out, "\n"); > >+ if (!(e->flags & ELEMENT_RENDERED)) { > >+ e->flags |= ELEMENT_RENDERED; > >+ *render_list_p = e; > >+ render_list_p = &e->render_next; > >+ } > >+ return; > >+ } else { > >+ /* Render inline for single use */ > >+ entry = nr_entries; > >+ render_depth++; > >+ render_element(out, e->children, NULL); > >+ render_depth--; > >+ if (e->compound == SEQUENCE_OF) > >+ render_opcode(out, "ASN1_OP_END_SEQ_OF%s,\n", > >act); > >+ else > >+ render_opcode(out, "ASN1_OP_END_SET_OF%s,\n", > >act); > >+ render_opcode(out, "_jump_target(%u),\n", entry); > >+ } > >+ break; > >+ > >+ case SET: > >+ /* I can't think of a nice way to do SET support without having > >+ * a stack of bitmasks to make sure no element is repeated. > >+ * The bitmask has also to be checked that no non-optional > >+ * elements are left out whilst not preventing optional > >+ * elements from being left out. > >+ */ > >+ fprintf(stderr, "The ASN.1 SET type is not currently > >supported.\n"); > >+ exit(1); > >+ > >+ case CHOICE: > >+ for (ec = e->children; ec; ec = ec->next) > >+ render_element(out, ec, ec); > >+ if (!skippable) > >+ render_opcode(out, "ASN1_OP_COND_FAIL,\n"); > >+ if (e->action) > >+ render_opcode(out, "ASN1_OP_ACT,\n"); > >+ break; > >+ > >+ default: > >+ break; > >+ } > >+ > >+ if (e->action) > >+ render_opcode(out, "_action(ACT_%s),\n", e->action->name); > >+} > > > _______________________________________________ U-Boot mailing list U-Boot@lists.denx.de https://lists.denx.de/listinfo/u-boot