Initial revision
diff --git a/libasn1compiler/Makefile.am b/libasn1compiler/Makefile.am
new file mode 100644
index 0000000..6b2babd
--- /dev/null
+++ b/libasn1compiler/Makefile.am
@@ -0,0 +1,28 @@
+
+AM_CPPFLAGS = \
+ -I${top_srcdir}/libasn1parser \
+ -I${top_srcdir}/libasn1fix
+
+noinst_LTLIBRARIES = libasn1compiler.la
+
+libasn1compiler_la_LDFLAGS = -all-static
+libasn1compiler_la_SOURCES = \
+ asn1compiler.c asn1compiler.h \
+ asn1c_misc.c asn1c_misc.h \
+ asn1c_out.c asn1c_out.h \
+ asn1c_lang.c asn1c_lang.h \
+ asn1c_save.c asn1c_save.h \
+ asn1c_C.c asn1c_C.h \
+ asn1c_internal.h
+
+libasn1compiler_la_LIBADD = \
+ ${top_builddir}/libasn1parser/libasn1parser.la \
+ ${top_builddir}/libasn1fix/libasn1fix.la
+
+check_PROGRAMS = check_compiler
+
+TESTS = ${check_PROGRAMS}
+
+LDADD = ${noinst_LTLIBRARIES} ${libasn1compiler_la_LIBADD}
+DEPENDENCIES = ${LDADD}
+
diff --git a/libasn1compiler/Makefile.in b/libasn1compiler/Makefile.in
new file mode 100644
index 0000000..3869df3
--- /dev/null
+++ b/libasn1compiler/Makefile.in
@@ -0,0 +1,424 @@
+# Makefile.in generated automatically by automake 1.5 from Makefile.am.
+
+# Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
+# Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+SHELL = @SHELL@
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+
+bindir = @bindir@
+sbindir = @sbindir@
+libexecdir = @libexecdir@
+datadir = @datadir@
+sysconfdir = @sysconfdir@
+sharedstatedir = @sharedstatedir@
+localstatedir = @localstatedir@
+libdir = @libdir@
+infodir = @infodir@
+mandir = @mandir@
+includedir = @includedir@
+oldincludedir = /usr/include
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+top_builddir = ..
+
+ACLOCAL = @ACLOCAL@
+AUTOCONF = @AUTOCONF@
+AUTOMAKE = @AUTOMAKE@
+AUTOHEADER = @AUTOHEADER@
+
+INSTALL = @INSTALL@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = @program_transform_name@
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_alias = @build_alias@
+build_triplet = @build@
+host_alias = @host_alias@
+host_triplet = @host@
+target_alias = @target_alias@
+target_triplet = @target@
+ADD_CFLAGS = @ADD_CFLAGS@
+AMTAR = @AMTAR@
+AR = @AR@
+AS = @AS@
+AWK = @AWK@
+CC = @CC@
+CONFIGURE_DEPENDS = @CONFIGURE_DEPENDS@
+CPP = @CPP@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+EXEEXT = @EXEEXT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LEX = @LEX@
+LIBTOOL = @LIBTOOL@
+LN_S = @LN_S@
+MAINT = @MAINT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+PACKAGE = @PACKAGE@
+PATH = @PATH@
+RANLIB = @RANLIB@
+VERSION = @VERSION@
+YACC = @YACC@
+am__include = @am__include@
+am__quote = @am__quote@
+install_sh = @install_sh@
+
+AM_CPPFLAGS = \
+ -I${top_srcdir}/libasn1parser \
+ -I${top_srcdir}/libasn1fix
+
+
+noinst_LTLIBRARIES = libasn1compiler.la
+
+libasn1compiler_la_LDFLAGS = -all-static
+libasn1compiler_la_SOURCES = \
+ asn1compiler.c asn1compiler.h \
+ asn1c_misc.c asn1c_misc.h \
+ asn1c_out.c asn1c_out.h \
+ asn1c_lang.c asn1c_lang.h \
+ asn1c_save.c asn1c_save.h \
+ asn1c_C.c asn1c_C.h \
+ asn1c_internal.h
+
+
+libasn1compiler_la_LIBADD = \
+ ${top_builddir}/libasn1parser/libasn1parser.la \
+ ${top_builddir}/libasn1fix/libasn1fix.la
+
+
+check_PROGRAMS = check_compiler
+
+TESTS = ${check_PROGRAMS}
+
+LDADD = ${noinst_LTLIBRARIES} ${libasn1compiler_la_LIBADD}
+DEPENDENCIES = ${LDADD}
+subdir = libasn1compiler
+mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+LTLIBRARIES = $(noinst_LTLIBRARIES)
+
+libasn1compiler_la_DEPENDENCIES = \
+ ${top_builddir}/libasn1parser/libasn1parser.la \
+ ${top_builddir}/libasn1fix/libasn1fix.la
+am_libasn1compiler_la_OBJECTS = asn1compiler.lo asn1c_misc.lo \
+ asn1c_out.lo asn1c_lang.lo asn1c_save.lo asn1c_C.lo
+libasn1compiler_la_OBJECTS = $(am_libasn1compiler_la_OBJECTS)
+check_PROGRAMS = check_compiler$(EXEEXT)
+check_compiler_SOURCES = check_compiler.c
+check_compiler_OBJECTS = check_compiler.$(OBJEXT)
+check_compiler_LDADD = $(LDADD)
+check_compiler_DEPENDENCIES = libasn1compiler.la \
+ ${top_builddir}/libasn1parser/libasn1parser.la \
+ ${top_builddir}/libasn1fix/libasn1fix.la
+check_compiler_LDFLAGS =
+
+DEFS = @DEFS@
+DEFAULT_INCLUDES = -I. -I$(srcdir) -I$(top_builddir)
+CPPFLAGS = @CPPFLAGS@
+LDFLAGS = @LDFLAGS@
+LIBS = @LIBS@
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+@AMDEP_TRUE@DEP_FILES = $(DEPDIR)/asn1c_C.Plo $(DEPDIR)/asn1c_lang.Plo \
+@AMDEP_TRUE@ $(DEPDIR)/asn1c_misc.Plo $(DEPDIR)/asn1c_out.Plo \
+@AMDEP_TRUE@ $(DEPDIR)/asn1c_save.Plo $(DEPDIR)/asn1compiler.Plo \
+@AMDEP_TRUE@ $(DEPDIR)/check_compiler.Po
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) \
+ $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+ $(AM_LDFLAGS) $(LDFLAGS) -o $@
+CFLAGS = @CFLAGS@
+DIST_SOURCES = $(libasn1compiler_la_SOURCES) check_compiler.c
+DIST_COMMON = Makefile.am Makefile.in
+SOURCES = $(libasn1compiler_la_SOURCES) check_compiler.c
+
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+distclean-libtool:
+ -rm -f libtool
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4)
+ cd $(top_srcdir) && \
+ $(AUTOMAKE) --gnu libasn1compiler/Makefile
+Makefile: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.in $(top_builddir)/config.status
+ cd $(top_builddir) && \
+ CONFIG_HEADERS= CONFIG_LINKS= \
+ CONFIG_FILES=$(subdir)/$@ $(SHELL) ./config.status
+
+clean-noinstLTLIBRARIES:
+ -test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES)
+libasn1compiler.la: $(libasn1compiler_la_OBJECTS) $(libasn1compiler_la_DEPENDENCIES)
+ $(LINK) $(libasn1compiler_la_LDFLAGS) $(libasn1compiler_la_OBJECTS) $(libasn1compiler_la_LIBADD) $(LIBS)
+
+clean-checkPROGRAMS:
+ -test -z "$(check_PROGRAMS)" || rm -f $(check_PROGRAMS)
+check_compiler$(EXEEXT): $(check_compiler_OBJECTS) $(check_compiler_DEPENDENCIES)
+ @rm -f check_compiler$(EXEEXT)
+ $(LINK) $(check_compiler_LDFLAGS) $(check_compiler_OBJECTS) $(check_compiler_LDADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT) core *.core
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@$(DEPDIR)/asn1c_C.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@$(DEPDIR)/asn1c_lang.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@$(DEPDIR)/asn1c_misc.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@$(DEPDIR)/asn1c_out.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@$(DEPDIR)/asn1c_save.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@$(DEPDIR)/asn1compiler.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@$(DEPDIR)/check_compiler.Po@am__quote@
+
+distclean-depend:
+ -rm -rf $(DEPDIR)
+
+.c.o:
+@AMDEP_TRUE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@ depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+ $(COMPILE) -c `test -f $< || echo '$(srcdir)/'`$<
+
+.c.obj:
+@AMDEP_TRUE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@ depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+ $(COMPILE) -c `cygpath -w $<`
+
+.c.lo:
+@AMDEP_TRUE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@ depfile='$(DEPDIR)/$*.Plo' tmpdepfile='$(DEPDIR)/$*.TPlo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+ $(LTCOMPILE) -c -o $@ `test -f $< || echo '$(srcdir)/'`$<
+CCDEPMODE = @CCDEPMODE@
+uninstall-info-am:
+
+tags: TAGS
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+ list='$(SOURCES) $(HEADERS) $(TAGS_FILES)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | \
+ $(AWK) ' { files[$$0] = 1; } \
+ END { for (i in files) print i; }'`; \
+ mkid -fID $$unique $(LISP)
+
+TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
+ $(TAGS_FILES) $(LISP)
+ tags=; \
+ here=`pwd`; \
+ list='$(SOURCES) $(HEADERS) $(TAGS_FILES)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | \
+ $(AWK) ' { files[$$0] = 1; } \
+ END { for (i in files) print i; }'`; \
+ test -z "$(ETAGS_ARGS)$$unique$(LISP)$$tags" \
+ || etags $(ETAGS_ARGS) $$tags $$unique $(LISP)
+
+GTAGS:
+ here=`CDPATH=: && cd $(top_builddir) && pwd` \
+ && cd $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) $$here
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH
+
+check-TESTS: $(TESTS)
+ @failed=0; all=0; xfail=0; xpass=0; \
+ srcdir=$(srcdir); export srcdir; \
+ list='$(TESTS)'; \
+ if test -n "$$list"; then \
+ for tst in $$list; do \
+ if test -f ./$$tst; then dir=./; \
+ elif test -f $$tst; then dir=; \
+ else dir="$(srcdir)/"; fi; \
+ if $(TESTS_ENVIRONMENT) $${dir}$$tst; then \
+ all=`expr $$all + 1`; \
+ case " $(XFAIL_TESTS) " in \
+ *" $$tst "*) \
+ xpass=`expr $$xpass + 1`; \
+ failed=`expr $$failed + 1`; \
+ echo "XPASS: $$tst"; \
+ ;; \
+ *) \
+ echo "PASS: $$tst"; \
+ ;; \
+ esac; \
+ elif test $$? -ne 77; then \
+ all=`expr $$all + 1`; \
+ case " $(XFAIL_TESTS) " in \
+ *" $$tst "*) \
+ xfail=`expr $$xfail + 1`; \
+ echo "XFAIL: $$tst"; \
+ ;; \
+ *) \
+ failed=`expr $$failed + 1`; \
+ echo "FAIL: $$tst"; \
+ ;; \
+ esac; \
+ fi; \
+ done; \
+ if test "$$failed" -eq 0; then \
+ if test "$$xfail" -eq 0; then \
+ banner="All $$all tests passed"; \
+ else \
+ banner="All $$all tests behaved as expected ($$xfail expected failures)"; \
+ fi; \
+ else \
+ if test "$$xpass" -eq 0; then \
+ banner="$$failed of $$all tests failed"; \
+ else \
+ banner="$$failed of $$all tests did not behave as expected ($$xpass unexpected passes)"; \
+ fi; \
+ fi; \
+ dashes=`echo "$$banner" | sed s/./=/g`; \
+ echo "$$dashes"; \
+ echo "$$banner"; \
+ echo "$$dashes"; \
+ test "$$failed" -eq 0; \
+ fi
+
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+
+top_distdir = ..
+distdir = $(top_distdir)/$(PACKAGE)-$(VERSION)
+
+distdir: $(DISTFILES)
+ @for file in $(DISTFILES); do \
+ if test -f $$file; then d=.; else d=$(srcdir); fi; \
+ dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test "$$dir" != "$$file" && test "$$dir" != "."; then \
+ $(mkinstalldirs) "$(distdir)/$$dir"; \
+ fi; \
+ if test -d $$d/$$file; then \
+ cp -pR $$d/$$file $(distdir) \
+ || exit 1; \
+ else \
+ test -f $(distdir)/$$file \
+ || cp -p $$d/$$file $(distdir)/$$file \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+ $(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS)
+ $(MAKE) $(AM_MAKEFLAGS) check-TESTS
+check: check-am
+all-am: Makefile $(LTLIBRARIES)
+
+installdirs:
+
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ `test -z '$(STRIP)' || \
+ echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -rm -f Makefile $(CONFIG_CLEAN_FILES) stamp-h stamp-h[0-9]*
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-checkPROGRAMS clean-generic clean-libtool \
+ clean-noinstLTLIBRARIES mostlyclean-am
+
+distclean: distclean-am
+
+distclean-am: clean-am distclean-compile distclean-depend \
+ distclean-generic distclean-libtool distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-exec-am:
+
+install-info: install-info-am
+
+install-man:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+uninstall-am: uninstall-info-am
+
+.PHONY: GTAGS all all-am check check-TESTS check-am clean \
+ clean-checkPROGRAMS clean-generic clean-libtool \
+ clean-noinstLTLIBRARIES distclean distclean-compile \
+ distclean-depend distclean-generic distclean-libtool \
+ distclean-tags distdir dvi dvi-am info info-am install \
+ install-am install-data install-data-am install-exec \
+ install-exec-am install-info install-info-am install-man \
+ install-strip installcheck installcheck-am installdirs \
+ maintainer-clean maintainer-clean-generic mostlyclean \
+ mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
+ tags uninstall uninstall-am uninstall-info-am
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/libasn1compiler/asn1c_C.c b/libasn1compiler/asn1c_C.c
new file mode 100644
index 0000000..8ec476c
--- /dev/null
+++ b/libasn1compiler/asn1c_C.c
@@ -0,0 +1,2021 @@
+/*
+ * Don't look into this file. First, because it's a mess, and second, because
+ * it's a brain of the compiler, and you don't wanna mess with brains do you? ;)
+ */
+#include "asn1c_internal.h"
+#include "asn1c_C.h"
+#include <asn1fix_export.h> /* exportable stuff from libasn1fix */
+
+static int asn1c_lang_C_type_SEQUENCE_def(arg_t *arg);
+static int asn1c_lang_C_type_SET_def(arg_t *arg);
+static int asn1c_lang_C_type_CHOICE_def(arg_t *arg);
+static int asn1c_lang_C_type_SEx_OF_def(arg_t *arg, int seq_of);
+static int _print_tag(arg_t *arg, asn1p_expr_t *expr, struct asn1p_type_tag_s *tag_p);
+static int emit_constraint_checking_code(arg_t *arg);
+static int emit_single_constraint_check(arg_t *arg, asn1p_constraint_t *ct, int mode);
+static int emit_alphabet_tables(arg_t *arg, asn1p_constraint_t *ct, int *table);
+static int emit_alphabet_check_cycle(arg_t *arg);
+static int check_constraint_type_presence(asn1p_constraint_t *ct, enum asn1p_constraint_type_e type);
+static asn1p_expr_type_e _find_terminal_type(arg_t *arg);
+static int emit_value_determination_code(arg_t *arg);
+static int emit_size_determination_code(arg_t *arg);
+static long compute_min_size(arg_t *arg);
+static long compute_max_size(arg_t *arg);
+static long compute_xxx_size(arg_t *arg, int _max);
+
+typedef struct tag2el_s {
+ struct asn1p_type_tag_s el_tag;
+ int el_no;
+ asn1p_expr_t *from_expr;
+} tag2el_t;
+
+static int _fill_tag2el_map(arg_t *arg, tag2el_t **tag2el, int *count, int el_no);
+static int _add_tag2el_member(arg_t *arg, tag2el_t **tag2el, int *count, int el_no);
+
+#define C99_MODE (arg->flags & A1C_NO_C99)
+#define UNNAMED_UNIONS (arg->flags & A1C_UNNAMED_UNIONS)
+
+#define PCTX_DEF INDENTED( \
+ OUT("\n"); \
+ OUT("/* Context for parsing across buffer boundaries */\n"); \
+ OUT("ber_dec_ctx_t _ber_dec_ctx;\n"));
+
+#define DEPENDENCIES do { \
+ int saved_target = arg->target->target; \
+ int saved_indent = arg->indent_level; \
+ int comment_printed = 0; \
+ REDIR(OT_DEPS); \
+ arg->indent_level = 0; \
+ TQ_FOR(v, &(expr->members), next) { \
+ if((!(v->expr_type & ASN_CONSTR_MASK) \
+ && v->expr_type > ASN_CONSTR_MASK) \
+ || v->meta_type == AMT_TYPEREF) { \
+ if(!comment_printed++) \
+ OUT("/* Dependencies for %s */\n", \
+ asn1c_type_name(arg, expr, TNF_UNMODIFIED)); \
+ OUT("#include <%s.h>\n", \
+ asn1c_type_name(arg, v, TNF_INCLUDE)); \
+ } \
+ } \
+ if(expr->expr_type == ASN_CONSTR_SET_OF) \
+ OUT("#include <asn_SET_OF.h>\n"); \
+ if(expr->expr_type == ASN_CONSTR_SEQUENCE_OF) \
+ OUT("#include <asn_SEQUENCE_OF.h>\n"); \
+ OUT("\n"); \
+ REDIR(saved_target); \
+ INDENT(saved_indent); \
+ } while(0)
+
+#define MKID(id) asn1c_make_identifier(0, (id), 0)
+
+int
+asn1c_lang_C_type_ENUMERATED(arg_t *arg) {
+ asn1p_expr_t *expr = arg->expr;
+ asn1p_expr_t *v;
+
+ REDIR(OT_DEPS);
+
+ OUT("typedef enum %s {\n", MKID(expr->Identifier));
+ TQ_FOR(v, &(expr->members), next) {
+ switch(v->expr_type) {
+ case A1TC_UNIVERVAL:
+ OUT("\t%s\t= %lld,\n",
+ asn1c_make_identifier(0,
+ expr->Identifier,
+ v->Identifier, 0),
+ v->value->value.v_integer);
+ break;
+ case A1TC_EXTENSIBLE:
+ OUT("\t/*\n");
+ OUT("\t * Enumeration is extensible\n");
+ OUT("\t */\n");
+ break;
+ default:
+ return -1;
+ }
+ }
+ OUT("} %s_e;\n", MKID(expr->Identifier));
+
+ return asn1c_lang_C_type_SIMPLE_TYPE(arg);
+}
+
+
+int
+asn1c_lang_C_type_INTEGER(arg_t *arg) {
+ asn1p_expr_t *expr = arg->expr;
+ asn1p_expr_t *v;
+
+ REDIR(OT_DEPS);
+
+ if(TQ_FIRST(&(expr->members))) {
+ OUT("typedef enum %s {\n", MKID(expr->Identifier));
+ TQ_FOR(v, &(expr->members), next) {
+ switch(v->expr_type) {
+ case A1TC_UNIVERVAL:
+ OUT("\t%s\t= %lld,\n",
+ asn1c_make_identifier(0,
+ expr->Identifier,
+ v->Identifier, 0),
+ v->value->value.v_integer);
+ break;
+ default:
+ return -1;
+ }
+ }
+ OUT("} %s_e;\n", MKID(expr->Identifier));
+ }
+
+ return asn1c_lang_C_type_SIMPLE_TYPE(arg);
+}
+
+int
+asn1c_lang_C_type_SEQUENCE(arg_t *arg) {
+ asn1p_expr_t *expr = arg->expr;
+ asn1p_expr_t *v;
+ int comp_mode = 0; /* {root,ext=1,root,root,...} */
+
+ DEPENDENCIES;
+
+ if(arg->embed) {
+ OUT("struct %s {\n",
+ MKID(expr->Identifier));
+ } else {
+ OUT("typedef struct %s {\n",
+ MKID(expr->Identifier));
+ }
+
+ TQ_FOR(v, &(expr->members), next) {
+ if(v->expr_type == A1TC_EXTENSIBLE) {
+ if(comp_mode < 3) comp_mode++;
+ }
+ if(comp_mode == 1 && !v->marker)
+ v->marker = EM_OPTIONAL;
+ EMBED(v);
+ }
+
+ PCTX_DEF;
+ OUT("} %s%s", expr->marker?"*":"",
+ MKID(expr->Identifier));
+ if(arg->embed) OUT(";\n"); else OUT("_t;\n");
+
+ return asn1c_lang_C_type_SEQUENCE_def(arg);
+}
+
+static int
+asn1c_lang_C_type_SEQUENCE_def(arg_t *arg) {
+ asn1p_expr_t *expr = arg->expr;
+ asn1p_expr_t *v;
+ int elements; /* Number of elements */
+ int tags_impl_skip = 0;
+ int comp_mode = 0; /* {root,ext=1,root,root,...} */
+ int ext_start = -1;
+ int ext_stop = -1;
+ char *p;
+
+ REDIR(OT_STAT_DEFS);
+
+ OUT("#include <constr_SEQUENCE.h>\n");
+ OUT("\n");
+
+ /*
+ * Print out the table according to which the parsing is performed.
+ */
+ p = MKID(expr->Identifier);
+ OUT("static asn1_SEQUENCE_element_t asn1_DEF_%s_elements[] = {\n", p);
+
+ elements = 0;
+ INDENTED(TQ_FOR(v, &(expr->members), next) {
+ if(v->expr_type == A1TC_EXTENSIBLE) {
+ if((++comp_mode) == 1)
+ ext_start = elements - 1;
+ else
+ ext_stop = elements - 1;
+ continue;
+ }
+ OUT("{ ");
+ elements++;
+ OUT("offsetof(struct %s, ", MKID(expr->Identifier));
+ OUT("%s), ", MKID(v->Identifier));
+ if(v->marker) {
+ asn1p_expr_t *tv;
+ int opts = 0;
+ for(tv = v; tv && tv->marker;
+ tv = TQ_NEXT(tv, next), opts++) {
+ if(tv->expr_type == A1TC_EXTENSIBLE)
+ opts--;
+ }
+ OUT("%d,", opts);
+ } else {
+ OUT("0,");
+ }
+ OUT("\n");
+ INDENT(+1);
+ if(C99_MODE) OUT(".tag = ");
+ _print_tag(arg, v, NULL);
+ OUT(",\n");
+ if(C99_MODE) OUT(".tag_mode = ");
+ if(v->tag.tag_class) {
+ if(v->tag.tag_mode == TM_IMPLICIT)
+ OUT("-1,\t/* IMPLICIT tag at current level */\n");
+ else
+ OUT("+1,\t/* EXPLICIT tag at current level */\n");
+ } else {
+ OUT("0,\n");
+ }
+ if(C99_MODE) OUT(".type = ");
+ OUT("(void *)&asn1_DEF_%s,\n",
+ asn1c_type_name(arg, v, TNF_SAFE));
+ if(C99_MODE) OUT(".name = ");
+ OUT("\"%s\"\n", v->Identifier);
+ OUT("},\n");
+ INDENT(-1);
+ });
+ OUT("};\n");
+
+ p = MKID(expr->Identifier);
+ OUT("static ber_tlv_tag_t asn1_DEF_%s_tags[] = {\n", p);
+ INDENTED(
+ if(expr->tag.tag_class) {
+ _print_tag(arg, expr, &expr->tag);
+ if(expr->tag.tag_mode != TM_EXPLICIT)
+ tags_impl_skip++;
+ }
+ if(!expr->tag.tag_class
+ || (expr->meta_type == AMT_TYPE
+ && expr->tag.tag_mode == TM_EXPLICIT)) {
+ struct asn1p_type_tag_s tag;
+ if(expr->tag.tag_class)
+ OUT(",\n");
+ tag.tag_class = TC_UNIVERSAL;
+ tag.tag_mode = TM_IMPLICIT;
+ tag.tag_value = expr_type2uclass_value[expr->expr_type];
+ _print_tag(arg, expr, &tag);
+ }
+ OUT("\n");
+ );
+ OUT("};\n");
+
+ OUT("static asn1_SEQUENCE_specifics_t asn1_DEF_%s_specs = {\n", p);
+ INDENTED(
+ OUT("sizeof(struct %s),\n", p);
+ OUT("offsetof(struct %s, _ber_dec_ctx),\n", p);
+ OUT("asn1_DEF_%s_elements,\n", p);
+ OUT("%d,\t/* Elements count */\n", elements);
+ OUT("%d,\t/* Start extensions */\n",
+ ext_start);
+ OUT("%d\t/* Stop extensions */\n",
+ (ext_stop<ext_start)?elements+1:ext_stop, ext_stop);
+ );
+ OUT("};\n");
+ OUT("asn1_TYPE_descriptor_t asn1_DEF_%s = {\n", p);
+ INDENTED(
+ OUT("\"%s\",\n", expr->Identifier);
+ OUT("SEQUENCE_constraint,\n");
+ OUT("SEQUENCE_decode_ber,\n");
+ OUT("SEQUENCE_encode_der,\n");
+ OUT("SEQUENCE_print,\n");
+ OUT("SEQUENCE_free,\n");
+ OUT("0,\t/* Use generic outmost tag fetcher */\n");
+ OUT("asn1_DEF_%s_tags,\n", p);
+ OUT("sizeof(asn1_DEF_%s_tags)\n", p);
+ OUT("\t/sizeof(asn1_DEF_%s_tags[0]),\n", p);
+ OUT("%d,\t/* Tags to skip */\n", tags_impl_skip);
+ OUT("%d,\t/* Whether CONSTRUCTED */\n", 1);
+ OUT("&asn1_DEF_%s_specs\t/* Additional specs */\n", p);
+ );
+ OUT("};\n");
+ OUT("\n");
+
+ REDIR(OT_DEPS);
+ OUT("#include <constr_SEQUENCE.h>\n");
+ OUT("\n");
+ if(!arg->embed)
+ OUT("extern asn1_TYPE_descriptor_t asn1_DEF_%s;\n", p);
+ REDIR(OT_TYPE_DECLS);
+
+ return 0;
+}
+
+int
+asn1c_lang_C_type_SEQUENCE_OF(arg_t *arg) {
+ asn1p_expr_t *expr = arg->expr;
+ asn1p_expr_t *v;
+
+ DEPENDENCIES;
+
+ if(arg->embed) {
+ OUT("struct %s {\n", MKID(expr->Identifier));
+ } else {
+ OUT("typedef struct %s {\n", MKID(expr->Identifier));
+ }
+
+ TQ_FOR(v, &(expr->members), next) {
+ INDENTED(OUT("A_SEQUENCE_OF(%s) list;\n",
+ asn1c_type_name(arg, v, TNF_RSAFE)));
+ }
+
+ PCTX_DEF;
+ OUT("} %s%s", expr->marker?"*":"", MKID(expr->Identifier));
+ if(arg->embed) OUT(";\n"); else OUT("_t;\n");
+
+ /*
+ * SET OF/SEQUENCE OF definition, SEQUENCE OF mode.
+ */
+ return asn1c_lang_C_type_SEx_OF_def(arg, 1);
+}
+
+int
+asn1c_lang_C_type_SET(arg_t *arg) {
+ asn1p_expr_t *expr = arg->expr;
+ asn1p_expr_t *v;
+ long mcount;
+ char *id;
+ int comp_mode = 0; /* {root,ext=1,root,root,...} */
+
+ DEPENDENCIES;
+
+ REDIR(OT_DEPS);
+
+ OUT("\n");
+ OUT("/*\n");
+ OUT(" * Method of determining the components presence\n");
+ OUT(" */\n");
+ mcount = 0;
+ OUT("enum %s_PR_e {\n", MKID(expr->Identifier));
+ TQ_FOR(v, &(expr->members), next) {
+ if(v->expr_type == A1TC_EXTENSIBLE) continue;
+ INDENTED(
+ id = MKID(expr->Identifier);
+ OUT("%s_PR_", id);
+ id = MKID(v->Identifier);
+ OUT("%s,\t/* Member %s is present */\n",
+ id, id)
+ );
+ mcount++;
+ }
+ OUT("};\n");
+
+ REDIR(OT_TYPE_DECLS);
+
+ if(arg->embed) {
+ OUT("struct %s {\n", MKID(expr->Identifier));
+ } else {
+ OUT("typedef struct %s {\n", MKID(expr->Identifier));
+ }
+
+ TQ_FOR(v, &(expr->members), next) {
+ if(v->expr_type == A1TC_EXTENSIBLE) {
+ if(comp_mode < 3) comp_mode++;
+ }
+ if(comp_mode == 1 && !v->marker)
+ v->marker = EM_OPTIONAL;
+ EMBED(v);
+ }
+
+ INDENTED(
+ id = MKID(expr->Identifier);
+ OUT("\n");
+ OUT("/* Presence bitmask: ASN_SET_ISPRESENT(p%s, %s_PR_x) */\n",
+ id, id);
+ OUT("unsigned int _presence_map\n");
+ OUT("\t[((%ld+(8*sizeof(unsigned int))-1)/(8*sizeof(unsigned int)))];\n", mcount);
+ );
+
+ PCTX_DEF;
+ OUT("} %s%s", expr->marker?"*":"", MKID(expr->Identifier));
+ if(arg->embed) OUT(";\n"); else OUT("_t;\n");
+
+ return asn1c_lang_C_type_SET_def(arg);
+}
+
+/*
+ * Compare tags according to their canonical order.
+ * Canonical order: [UNIVERSAL] [APPLICATION] [] [PRIVATE]
+ * As you see, the class is encoded using the two lowest bits.
+ */
+static arg_t *_ctc_arg;
+static int _canonical_tags_cmp(const void *ap, const void *bp)
+ __attribute__ ((unused));
+static int
+_canonical_tags_cmp(const void *ap, const void *bp) {
+ asn1p_expr_t *a, *b;
+ struct asn1p_type_tag_s ta, tb;
+
+ (const asn1p_expr_t *)a = *(const asn1p_expr_t * const *)ap;
+ (const asn1p_expr_t *)b = *(const asn1p_expr_t * const *)bp;
+
+ if(asn1f_fetch_tag(_ctc_arg->asn, _ctc_arg->mod, a, &ta)
+ || asn1f_fetch_tag(_ctc_arg->asn, _ctc_arg->mod, b, &tb))
+ return 0;
+
+ if(ta.tag_class == tb.tag_class) {
+ if(ta.tag_value == tb.tag_value)
+ return 0;
+ else if(ta.tag_value < tb.tag_value)
+ return -1;
+ else
+ return 1;
+ } else if(ta.tag_class < tb.tag_class) {
+ return -1;
+ } else {
+ return 1;
+ }
+}
+
+static int
+_tag2el_cmp(const void *ap, const void *bp) {
+ const tag2el_t *a = ap;
+ const tag2el_t *b = bp;
+ const struct asn1p_type_tag_s *ta = &a->el_tag;
+ const struct asn1p_type_tag_s *tb = &b->el_tag;
+
+ if(ta->tag_class == tb->tag_class) {
+ if(ta->tag_value == tb->tag_value)
+ return 0;
+ else if(ta->tag_value < tb->tag_value)
+ return -1;
+ else
+ return 1;
+ } else if(ta->tag_class < tb->tag_class) {
+ return -1;
+ } else {
+ return 1;
+ }
+}
+
+static int
+asn1c_lang_C_type_SET_def(arg_t *arg) {
+ asn1p_expr_t *expr = arg->expr;
+ asn1p_expr_t *v;
+ int elements;
+ int tags_impl_skip = 0;
+ int comp_mode = 0; /* {root,ext=1,root,root,...} */
+ int extensible = 0;
+ tag2el_t *tag2el = NULL;
+ int tag2el_count = 0;
+ char *p;
+
+ /*
+ * Fetch every inner tag from the tag to elements map.
+ */
+ if(_fill_tag2el_map(arg, &tag2el, &tag2el_count, -1)) {
+ if(tag2el) free(tag2el);
+ return -1;
+ } else {
+ /*
+ * Sort the map according to canonical order of their tags.
+ */
+ _ctc_arg = arg;
+ qsort(tag2el, tag2el_count, sizeof(*tag2el), _tag2el_cmp);
+ }
+
+
+ REDIR(OT_STAT_DEFS);
+
+ OUT("#include <constr_SET.h>\n");
+ OUT("\n");
+
+ /*
+ * Print out the table according to which the parsing is performed.
+ */
+ p = MKID(expr->Identifier);
+ OUT("static asn1_SET_element_t asn1_DEF_%s_elements[] = {\n", p);
+
+ elements = 0;
+ INDENTED(TQ_FOR(v, &(expr->members), next) {
+ if(v->expr_type != A1TC_EXTENSIBLE) {
+ if(comp_mode == 1)
+ v->marker = EM_OPTIONAL;
+ elements++;
+ } else {
+ if(comp_mode < 3) comp_mode++;
+ continue;
+ }
+ OUT("{ ");
+ p = MKID(expr->Identifier);
+ OUT("offsetof(struct %s, ", p);
+ p = MKID(v->Identifier);
+ OUT("%s), ", p);
+ if(v->marker) {
+ OUT("1, /* Optional element */\n");
+ } else {
+ OUT("0,\n");
+ }
+ INDENT(+1);
+ if(C99_MODE) OUT(".tag = ");
+ _print_tag(arg, v, NULL);
+ OUT(",\n");
+ if(C99_MODE) OUT(".tag_mode = ");
+ if(v->tag.tag_class) {
+ if(v->tag.tag_mode == TM_IMPLICIT)
+ OUT("-1,\t/* IMPLICIT tag at current level */\n");
+ else
+ OUT("+1,\t/* EXPLICIT tag at current level */\n");
+ } else {
+ OUT("0,\n");
+ }
+ if(C99_MODE) OUT(".type = ");
+ OUT("(void *)&asn1_DEF_%s,\n",
+ asn1c_type_name(arg, v, TNF_SAFE));
+ if(C99_MODE) OUT(".name = ");
+ OUT("\"%s\"\n", v->Identifier);
+ OUT("},\n");
+ INDENT(-1);
+ });
+ OUT("};\n");
+
+ p = MKID(expr->Identifier);
+ OUT("static ber_tlv_tag_t asn1_DEF_%s_tags[] = {\n", p);
+ INDENTED(
+ if(expr->tag.tag_class) {
+ _print_tag(arg, expr, &expr->tag);
+ if(expr->tag.tag_mode != TM_EXPLICIT)
+ tags_impl_skip++;
+ }
+ if(!expr->tag.tag_class
+ || (expr->meta_type == AMT_TYPE
+ && expr->tag.tag_mode == TM_EXPLICIT)) {
+ struct asn1p_type_tag_s tag;
+ if(expr->tag.tag_class)
+ OUT(",\n");
+ tag.tag_class = TC_UNIVERSAL;
+ tag.tag_mode = TM_IMPLICIT;
+ tag.tag_value = expr_type2uclass_value[expr->expr_type];
+ _print_tag(arg, expr, &tag);
+ }
+ OUT("\n");
+ );
+ OUT("};\n");
+
+ /*
+ * Tags to elements map.
+ */
+ p = MKID(expr->Identifier);
+ OUT("static asn1_SET_tag2member_t asn1_DEF_%s_tag2el[] = {\n", p);
+ if(tag2el_count) {
+ int i;
+ for(i = 0; i < tag2el_count; i++) {
+ OUT(" { ");
+ _print_tag(arg, expr, &tag2el[i].el_tag);
+ OUT(", ");
+ OUT("%d ", tag2el[i].el_no);
+ OUT("}, /* %s at %d */\n",
+ tag2el[i].from_expr->Identifier,
+ tag2el[i].from_expr->_lineno
+ );
+ }
+ }
+ OUT("};\n");
+
+ /*
+ * Emit a map of mandatory elements.
+ */
+ OUT("static uint8_t asn1_DEF_%s_mmap", p);
+ OUT("[(%d + (8 * sizeof(unsigned int)) - 1) / 8]", elements);
+ OUT(" = {\n", p);
+ INDENTED(
+ if(elements) {
+ int delimit = 0;
+ int el = 0;
+ TQ_FOR(v, &(expr->members), next) {
+ if(v->expr_type == A1TC_EXTENSIBLE) continue;
+ if(delimit) {
+ OUT(",\n");
+ delimit = 0;
+ } else if(el) {
+ OUT(" | ");
+ }
+ OUT("(%d << %d)", v->marker?0:1, 7 - (el % 8));
+ if(el && (el % 8) == 0)
+ delimit = 1;
+ el++;
+ }
+ } else {
+ OUT("0");
+ }
+ );
+ OUT("\n");
+ OUT("};\n");
+
+ OUT("static asn1_SET_specifics_t asn1_DEF_%s_specs = {\n", p);
+ INDENTED(
+ OUT("sizeof(struct %s),\n", p);
+ OUT("offsetof(struct %s, _ber_dec_ctx),\n", p);
+ OUT("offsetof(struct %s, _presence_map),\n", p);
+ OUT("asn1_DEF_%s_elements,\n", p);
+ OUT("%d,\t/* Elements count */\n", elements);
+ OUT("asn1_DEF_%s_tag2el,\n", p);
+ OUT("%d,\t/* Count of tags in the map */\n", tag2el_count);
+ OUT("%d,\t/* Whether extensible */\n", extensible);
+ OUT("(unsigned int *)asn1_DEF_%s_mmap\t/* Mandatory elements map */\n", p);
+ );
+ OUT("};\n");
+ OUT("asn1_TYPE_descriptor_t asn1_DEF_%s = {\n", p);
+ INDENTED(
+ OUT("\"%s\",\n", expr->Identifier);
+ OUT("SET_constraint,\n");
+ OUT("SET_decode_ber,\n");
+ OUT("SET_encode_der,\n");
+ OUT("SET_print,\n");
+ OUT("SET_free,\n");
+ OUT("0,\t/* Use generic outmost tag fetcher */\n");
+ OUT("asn1_DEF_%s_tags,\n", p);
+ OUT("sizeof(asn1_DEF_%s_tags)\n", p);
+ OUT("\t/sizeof(asn1_DEF_%s_tags[0]),\n", p);
+ OUT("%d,\t/* Tags to skip */\n", tags_impl_skip);
+ OUT("%d,\t/* Whether CONSTRUCTED */\n", 1);
+ OUT("&asn1_DEF_%s_specs\t/* Additional specs */\n", p);
+ );
+ OUT("};\n");
+ OUT("\n");
+
+ REDIR(OT_DEPS);
+ OUT("#include <constr_SET.h>\n");
+ OUT("\n");
+ if(!arg->embed)
+ OUT("extern asn1_TYPE_descriptor_t asn1_DEF_%s;\n", p);
+ REDIR(OT_TYPE_DECLS);
+
+ return 0;
+}
+
+int
+asn1c_lang_C_type_SET_OF(arg_t *arg) {
+ asn1p_expr_t *expr = arg->expr;
+ asn1p_expr_t *v;
+
+ DEPENDENCIES;
+
+ if(arg->embed) {
+ OUT("struct %s {\n", MKID(expr->Identifier));
+ } else {
+ OUT("typedef struct %s {\n",
+ MKID(expr->Identifier));
+ }
+
+ TQ_FOR(v, &(expr->members), next) {
+ INDENTED(OUT("A_SET_OF(%s) list;\n",
+ asn1c_type_name(arg, v, TNF_RSAFE)));
+ }
+
+ PCTX_DEF;
+ OUT("} %s%s", expr->marker?"*":"", MKID(expr->Identifier));
+ if(arg->embed) OUT(";\n"); else OUT("_t;\n");
+
+ /*
+ * SET OF/SEQUENCE OF definition, SET OF mode.
+ */
+ return asn1c_lang_C_type_SEx_OF_def(arg, 0);
+}
+
+static int
+asn1c_lang_C_type_SEx_OF_def(arg_t *arg, int seq_of) {
+ asn1p_expr_t *expr = arg->expr;
+ asn1p_expr_t *v;
+ int tags_impl_skip = 0;
+ char *p;
+
+ REDIR(OT_DEPS);
+
+ if(seq_of) {
+ OUT("#include <constr_SEQUENCE_OF.h>\n");
+ } else {
+ OUT("#include <constr_SET_OF.h>\n");
+ OUT("\n");
+ }
+
+ REDIR(OT_STAT_DEFS);
+
+ /*
+ * Print out the table according to which the parsing is performed.
+ */
+ p = MKID(expr->Identifier);
+ OUT("static asn1_SET_OF_element_t asn1_DEF_%s_elements[] = {\n", p);
+
+ INDENTED(OUT("{ ");
+ v = TQ_FIRST(&(expr->members));
+ INDENT(+1);
+ if(C99_MODE) OUT(".tag = ");
+ _print_tag(arg, v, NULL);
+ OUT(",\n");
+ if(C99_MODE) OUT(".type = ");
+ OUT("(void *)&asn1_DEF_%s",
+ asn1c_type_name(arg, v, TNF_SAFE));
+ OUT(" ");
+ OUT("},\n");
+ INDENT(-1);
+ );
+ OUT("};\n");
+
+ p = MKID(expr->Identifier);
+ OUT("static ber_tlv_tag_t asn1_DEF_%s_tags[] = {\n", p);
+ INDENTED(
+ if(expr->tag.tag_class) {
+ _print_tag(arg, expr, &expr->tag);
+ if(expr->tag.tag_mode != TM_EXPLICIT)
+ tags_impl_skip++;
+ }
+ if(!expr->tag.tag_class
+ || (expr->meta_type == AMT_TYPE
+ && expr->tag.tag_mode == TM_EXPLICIT)) {
+ struct asn1p_type_tag_s tag;
+ if(expr->tag.tag_class)
+ OUT(",\n");
+ tag.tag_class = TC_UNIVERSAL;
+ tag.tag_mode = TM_IMPLICIT;
+ tag.tag_value = expr_type2uclass_value[expr->expr_type];
+ _print_tag(arg, expr, &tag);
+ }
+ OUT("\n");
+ );
+ OUT("};\n");
+
+ OUT("static asn1_SET_OF_specifics_t asn1_DEF_%s_specs = {\n", p);
+ INDENTED(
+ OUT("sizeof(struct %s),\n", p);
+ OUT("offsetof(struct %s, _ber_dec_ctx),\n", p);
+ OUT("asn1_DEF_%s_elements\n", p);
+ );
+ OUT("};\n");
+ OUT("asn1_TYPE_descriptor_t asn1_DEF_%s = {\n", p);
+ INDENTED(
+ OUT("\"%s\",\n", expr->Identifier);
+ if(seq_of) {
+ OUT("SEQUENCE_OF_constraint,\n");
+ OUT("SEQUENCE_OF_decode_ber,\n");
+ OUT("SEQUENCE_OF_encode_der,\n");
+ OUT("SEQUENCE_OF_print,\n");
+ OUT("SEQUENCE_OF_free,\n");
+ } else {
+ OUT("SET_OF_constraint,\n");
+ OUT("SET_OF_decode_ber,\n");
+ OUT("SET_OF_encode_der,\n");
+ OUT("SET_OF_print,\n");
+ OUT("SET_OF_free,\n");
+ }
+ OUT("0,\t/* Use generic outmost tag fetcher */\n");
+ OUT("asn1_DEF_%s_tags,\n", p);
+ OUT("sizeof(asn1_DEF_%s_tags)\n", p);
+ OUT("\t/sizeof(asn1_DEF_%s_tags[0]),\n", p);
+ OUT("%d,\t/* Tags to skip */\n", tags_impl_skip);
+ OUT("%d,\t/* Whether CONSTRUCTED */\n", 1);
+ OUT("&asn1_DEF_%s_specs\t/* Additional specs */\n", p);
+ );
+ OUT("};\n");
+ OUT("\n");
+
+ REDIR(OT_DEPS);
+ if(!arg->embed)
+ OUT("extern asn1_TYPE_descriptor_t asn1_DEF_%s;\n", p);
+ REDIR(OT_TYPE_DECLS);
+
+ return 0;
+}
+
+int
+asn1c_lang_C_type_CHOICE(arg_t *arg) {
+ asn1p_expr_t *expr = arg->expr;
+ asn1p_expr_t *v;
+ char *p;
+
+ DEPENDENCIES;
+
+ p = MKID(expr->Identifier);
+
+ if(arg->embed) {
+ OUT("struct %s {\n", p);
+ } else {
+ OUT("typedef struct %s {\n", p);
+ }
+
+ INDENTED(
+ OUT("enum {\n");
+ INDENTED(
+ OUT("%s_PR_NOTHING,\t"
+ "/* No components present */\n", p);
+ TQ_FOR(v, &(expr->members), next) {
+ if(v->expr_type == A1TC_EXTENSIBLE) continue;
+ p = MKID(expr->Identifier);
+ OUT("%s_PR_", p);
+ p = MKID(v->Identifier);
+ OUT("%s,\n", p, p);
+ }
+ );
+ OUT("} present;\n");
+
+ OUT("union {\n", p);
+ TQ_FOR(v, &(expr->members), next) {
+ EMBED(v);
+ }
+ if(UNNAMED_UNIONS) OUT("};\n");
+ else OUT("} choice;\n");
+ );
+
+ PCTX_DEF;
+ OUT("} %s%s", expr->marker?"*":"", MKID(expr->Identifier));
+ if(arg->embed) OUT(";\n"); else OUT("_t;\n");
+
+ return asn1c_lang_C_type_CHOICE_def(arg);
+}
+
+static int
+asn1c_lang_C_type_CHOICE_def(arg_t *arg) {
+ asn1p_expr_t *expr = arg->expr;
+ asn1p_expr_t *v;
+ int elements; /* Number of elements */
+ int tags_impl_skip = 0;
+ int comp_mode = 0; /* {root,ext=1,root,root,...} */
+ int extensible = 0;
+ tag2el_t *tag2el = NULL;
+ int tag2el_count = 0;
+ char *p;
+
+ /*
+ * Fetch every inner tag from the tag to elements map.
+ */
+ if(_fill_tag2el_map(arg, &tag2el, &tag2el_count, -1)) {
+ if(tag2el) free(tag2el);
+ return -1;
+ } else {
+ /*
+ * Sort the map according to canonical order of their tags.
+ */
+ _ctc_arg = arg;
+ qsort(tag2el, tag2el_count, sizeof(*tag2el), _tag2el_cmp);
+ }
+
+ REDIR(OT_STAT_DEFS);
+
+ OUT("#include <constr_CHOICE.h>\n");
+ OUT("\n");
+
+ /*
+ * Print out the table according to which the parsing is performed.
+ */
+ p = MKID(expr->Identifier);
+ OUT("static asn1_CHOICE_element_t asn1_DEF_%s_elements[] = {\n", p);
+
+ elements = 0;
+ INDENTED(TQ_FOR(v, &(expr->members), next) {
+ if(v->expr_type != A1TC_EXTENSIBLE) {
+ if(comp_mode == 1)
+ v->marker = EM_OPTIONAL;
+ elements++;
+ } else {
+ if(comp_mode < 3) comp_mode++;
+ continue;
+ }
+ OUT("{ ");
+ p = MKID(expr->Identifier);
+ OUT("offsetof(struct %s, ", p);
+ p = MKID(v->Identifier);
+ if(!UNNAMED_UNIONS) OUT("choice.");
+ OUT("%s), ", p);
+ if(v->marker) {
+ OUT("1, /* Optional element */\n");
+ } else {
+ OUT("0,\n");
+ }
+ INDENT(+1);
+ if(C99_MODE) OUT(".tag = ");
+ _print_tag(arg, v, NULL);
+ OUT(",\n");
+ if(C99_MODE) OUT(".tag_mode = ");
+ if(v->tag.tag_class) {
+ if(v->tag.tag_mode == TM_IMPLICIT)
+ OUT("-1,\t/* IMPLICIT tag at current level */\n");
+ else
+ OUT("+1,\t/* EXPLICIT tag at current level */\n");
+ } else {
+ OUT("0,\n");
+ }
+ if(C99_MODE) OUT(".type = ");
+ OUT("(void *)&asn1_DEF_%s,\n",
+ asn1c_type_name(arg, v, TNF_SAFE));
+ if(C99_MODE) OUT(".name = ");
+ OUT("\"%s\"\n", v->Identifier);
+ OUT("},\n");
+ INDENT(-1);
+ });
+ OUT("};\n");
+
+ p = MKID(expr->Identifier);
+ OUT("static ber_tlv_tag_t asn1_DEF_%s_tags[] = {\n", p);
+ if(arg->embed) {
+ /*
+ * Our parent structure has already taken this into account.
+ */
+ } else {
+ INDENTED(
+ if(expr->tag.tag_class) {
+ _print_tag(arg, expr, &expr->tag);
+ if(expr->tag.tag_mode != TM_EXPLICIT)
+ tags_impl_skip++;
+ }
+ OUT("\n");
+ );
+ }
+ OUT("};\n");
+
+ /*
+ * Tags to elements map.
+ */
+ p = MKID(expr->Identifier);
+ OUT("static asn1_CHOICE_tag2member_t asn1_DEF_%s_tag2el[] = {\n", p);
+ if(tag2el_count) {
+ int i;
+ for(i = 0; i < tag2el_count; i++) {
+ OUT(" { ");
+ _print_tag(arg, expr, &tag2el[i].el_tag);
+ OUT(", ");
+ OUT("%d ", tag2el[i].el_no);
+ OUT("}, /* %s at %d */\n",
+ tag2el[i].from_expr->Identifier,
+ tag2el[i].from_expr->_lineno
+ );
+ }
+ }
+ OUT("};\n");
+
+ OUT("static asn1_CHOICE_specifics_t asn1_DEF_%s_specs = {\n", p);
+ INDENTED(
+ OUT("sizeof(struct %s),\n", p);
+ OUT("offsetof(struct %s, _ber_dec_ctx),\n", p);
+ OUT("offsetof(struct %s, present),\n", p);
+ OUT("sizeof(((struct %s *)0)->present),\n", p);
+ OUT("asn1_DEF_%s_elements,\n", p);
+ OUT("%d,\t/* Elements count */\n", elements);
+ OUT("asn1_DEF_%s_tag2el,\n", p);
+ OUT("%d,\t/* Count of tags in the map */\n", tag2el_count);
+ OUT("%d\t/* Whether extensible */\n", extensible);
+ );
+ OUT("};\n");
+ OUT("asn1_TYPE_descriptor_t asn1_DEF_%s = {\n", p);
+ INDENTED(
+ OUT("\"%s\",\n", expr->Identifier);
+ OUT("CHOICE_constraint,\n");
+ OUT("CHOICE_decode_ber,\n");
+ OUT("CHOICE_encode_der,\n");
+ OUT("CHOICE_print,\n");
+ OUT("CHOICE_free,\n");
+ OUT("CHOICE_outmost_tag,\n");
+ OUT("asn1_DEF_%s_tags,\n", p);
+ OUT("sizeof(asn1_DEF_%s_tags)\n", p);
+ OUT("\t/sizeof(asn1_DEF_%s_tags[0]),\n", p);
+ OUT("%d,\t/* Tags to skip */\n", tags_impl_skip);
+ OUT("%d,\t/* Whether CONSTRUCTED */\n", 1);
+ OUT("&asn1_DEF_%s_specs\t/* Additional specs */\n", p);
+ );
+ OUT("};\n");
+ OUT("\n");
+
+ REDIR(OT_DEPS);
+ if(!arg->embed)
+ OUT("extern asn1_TYPE_descriptor_t asn1_DEF_%s;\n", p);
+ REDIR(OT_TYPE_DECLS);
+
+ return 0;
+}
+
+int
+asn1c_lang_C_type_REFERENCE(arg_t *arg) {
+ asn1p_ref_t *ref;
+
+ ref = arg->expr->reference;
+ if(ref->components[ref->comp_count-1].name[0] == '&') {
+ asn1p_module_t *mod;
+ asn1p_expr_t *extract;
+ arg_t tmp;
+ int ret;
+
+ extract = asn1f_class_access_ex(arg->asn, arg->mod, arg->expr,
+ ref, &mod);
+ if(extract == NULL)
+ return -1;
+
+ extract = asn1p_expr_clone(extract);
+ if(extract) {
+ if(extract->Identifier)
+ free(extract->Identifier);
+ extract->Identifier = strdup(arg->expr->Identifier);
+ if(extract->Identifier == NULL) {
+ asn1p_expr_free(extract);
+ return -1;
+ }
+ } else {
+ return -1;
+ }
+
+ tmp = *arg;
+ tmp.asn = arg->asn;
+ tmp.mod = mod;
+ tmp.expr = extract;
+
+ ret = arg->default_cb(&tmp);
+
+ asn1p_expr_free(extract);
+
+ return ret;
+ }
+
+
+ return asn1c_lang_C_type_SIMPLE_TYPE(arg);
+}
+
+int
+asn1c_lang_C_type_SIMPLE_TYPE(arg_t *arg) {
+ asn1p_expr_t *expr = arg->expr;
+ int tags_impl_skip = 0;
+ char *p;
+
+ if(arg->embed) {
+ REDIR(OT_TYPE_DECLS);
+
+ OUT("%s\t", asn1c_type_name(arg, arg->expr,
+ expr->marker?TNF_RSAFE:TNF_CTYPE));
+ OUT("%s", expr->marker?"*":" ");
+ OUT("%s;", MKID(expr->Identifier));
+ if(expr->marker) OUT("\t/* %s */",
+ (expr->marker==EM_OPTIONAL)?"OPTIONAL":"DEFAULT");
+ OUT("\n");
+ return 0;
+ }
+
+ REDIR(OT_DEPS);
+
+ OUT("#include <%s.h>\n", asn1c_type_name(arg, expr, TNF_INCLUDE));
+
+ REDIR(OT_TYPE_DECLS);
+
+ OUT("typedef %s\t", asn1c_type_name(arg, arg->expr, TNF_CTYPE));
+ OUT("%s", expr->marker?"*":" ");
+ OUT("%s_t;\n", MKID(expr->Identifier));
+ OUT("\n");
+
+ REDIR(OT_STAT_DEFS);
+
+ p = MKID(expr->Identifier);
+ OUT("static ber_tlv_tag_t asn1_DEF_%s_tags[] = {\n", p);
+ INDENTED(
+ if(expr->tag.tag_class) {
+ _print_tag(arg, expr, &expr->tag);
+ if(expr->tag.tag_mode != TM_EXPLICIT)
+ tags_impl_skip++;
+ }
+ if(!expr->tag.tag_class
+ || (expr->meta_type == AMT_TYPE
+ && expr->tag.tag_mode == TM_EXPLICIT)) {
+ struct asn1p_type_tag_s tag;
+ if(expr->tag.tag_class)
+ OUT(",\n");
+ tag.tag_class = TC_UNIVERSAL;
+ tag.tag_mode = TM_IMPLICIT;
+ tag.tag_value = expr_type2uclass_value[expr->expr_type];
+ _print_tag(arg, expr, &tag);
+ }
+ OUT("\n");
+ );
+ OUT("};\n");
+
+ OUT("asn1_TYPE_descriptor_t asn1_DEF_%s = {\n", p);
+ INDENTED(
+ OUT("\"%s\",\n", expr->Identifier);
+ OUT("%s_constraint,\n", p);
+ OUT("%s_decode_ber,\n", p);
+ OUT("%s_encode_der,\n", p);
+ OUT("%s_print,\n", p);
+ OUT("%s_free,\n", p);
+ OUT("0,\t/* Use generic outmost tag fetcher */\n");
+ OUT("asn1_DEF_%s_tags,\n", p);
+ OUT("sizeof(asn1_DEF_%s_tags)\n", p);
+ OUT("\t/sizeof(asn1_DEF_%s_tags[0]),\n", p);
+ OUT("%d,\t/* Tags to skip */\n", tags_impl_skip);
+ OUT("-0\t/* Unknown yet */\n");
+ );
+ OUT("};\n");
+ OUT("\n");
+
+ /*
+ * Constraint checking.
+ */
+ if(expr->constraints) /* Emit tables with FROM() constraints */
+ emit_alphabet_tables(arg, expr->constraints, 0);
+ p = MKID(expr->Identifier);
+ OUT("int\n");
+ OUT("%s_constraint(asn1_TYPE_descriptor_t *td, const void *sptr,\n", p);
+ INDENTED(
+ OUT("\t\tasn_app_consume_bytes_f *app_errlog, void *app_key) {\n");
+ OUT("\n");
+ if(expr->constraints) {
+
+ emit_constraint_checking_code(arg);
+
+ OUT("/* Check the constraints of the underlying type */\n");
+ OUT("return asn1_DEF_%s.check_constraints\n",
+ asn1c_type_name(arg, expr, TNF_SAFE));
+ OUT("\t(td, sptr, app_errlog, app_key);\n");
+ } else {
+ OUT("/* Make the underlying type checker permanent */\n");
+ OUT("td->check_constraints = asn1_DEF_%s.check_constraints;\n",
+ asn1c_type_name(arg, expr, TNF_SAFE));
+ OUT("return td->check_constraints\n");
+ OUT("\t(td, sptr, app_errlog, app_key);\n");
+ }
+ );
+ OUT("}\n");
+ OUT("\n");
+
+ /*
+ * Emit suicidal functions.
+ */
+
+ {
+ /*
+ * This function replaces certain fields from the definition
+ * of a type with the corresponding fields from the basic type
+ * (from which the current type is inherited).
+ */
+ char *type_name = asn1c_type_name(arg, expr, TNF_SAFE);
+ OUT("/*\n");
+ OUT(" * This type is implemented using %s,\n", type_name);
+ OUT(" * so adjust the DEF appropriately.\n");
+ OUT(" */\n");
+ OUT("static void\n");
+ OUT("inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) {\n");
+ INDENT(+1);
+ OUT("td->ber_decoder = asn1_DEF_%s.ber_decoder;\n", type_name);
+ OUT("td->der_encoder = asn1_DEF_%s.der_encoder;\n", type_name);
+ OUT("td->free_struct = asn1_DEF_%s.free_struct;\n", type_name);
+ OUT("td->print_struct = asn1_DEF_%s.print_struct;\n", type_name);
+ OUT("td->last_tag_form = asn1_DEF_%s.last_tag_form;\n", type_name);
+ OUT("td->specifics = asn1_DEF_%s.specifics;\n", type_name);
+ INDENT(-1);
+ OUT("}\n");
+ OUT("\n");
+ }
+
+ p = MKID(expr->Identifier);
+ OUT("ber_dec_rval_t\n");
+ OUT("%s_decode_ber(asn1_TYPE_descriptor_t *td,\n", p);
+ INDENTED(
+ OUT("\tvoid **structure, void *bufptr, size_t size, int tag_mode) {\n");
+ OUT("inherit_TYPE_descriptor(td);\n");
+ OUT("return td->ber_decoder(td, structure,\n");
+ OUT("\tbufptr, size, tag_mode);\n");
+ );
+ OUT("}\n");
+ OUT("\n");
+
+ p = MKID(expr->Identifier);
+ OUT("der_enc_rval_t\n");
+ OUT("%s_encode_der(asn1_TYPE_descriptor_t *td,\n", p);
+ INDENTED(
+ OUT("\tvoid *structure, int tag_mode, ber_tlv_tag_t tag,\n");
+ OUT("\tasn_app_consume_bytes_f *cb, void *app_key) {\n");
+ OUT("inherit_TYPE_descriptor(td);\n");
+ OUT("return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);\n");
+ );
+ OUT("}\n");
+ OUT("\n");
+
+ p = MKID(expr->Identifier);
+ OUT("int\n");
+ OUT("%s_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr,\n", p);
+ INDENTED(
+ OUT("\tint ilevel, asn_app_consume_bytes_f *cb, void *app_key) {\n");
+ OUT("inherit_TYPE_descriptor(td);\n");
+ OUT("return td->print_struct(td, struct_ptr, ilevel, cb, app_key);\n");
+ );
+ OUT("}\n");
+ OUT("\n");
+
+ p = MKID(expr->Identifier);
+ OUT("void\n");
+ OUT("%s_free(asn1_TYPE_descriptor_t *td,\n", p);
+ INDENTED(
+ OUT("\tvoid *struct_ptr, int contents_only) {\n");
+ OUT("inherit_TYPE_descriptor(td);\n");
+ OUT("td->free_struct(td, struct_ptr, contents_only);\n");
+ );
+ OUT("}\n");
+ OUT("\n");
+
+ REDIR(OT_FUNC_DECLS);
+
+ p = MKID(expr->Identifier);
+ OUT("extern asn1_TYPE_descriptor_t asn1_DEF_%s;\n", p);
+ OUT("asn_constr_check_f %s_constraint;\n", p);
+ OUT("ber_type_decoder_f %s_decode_ber;\n", p);
+ OUT("der_type_encoder_f %s_encode_der;\n", p);
+ OUT("asn_struct_print_f %s_print;\n", p);
+ OUT("asn_struct_free_f %s_free;\n", p);
+
+ return 0;
+}
+
+int
+asn1c_lang_C_type_EXTENSIBLE(arg_t *arg) {
+
+ OUT("/*\n");
+ OUT(" * This type is extensible,\n");
+ OUT(" * possible extensions are below.\n");
+ OUT(" */\n");
+
+ return 0;
+}
+
+static int
+_print_tag(arg_t *arg, asn1p_expr_t *expr, struct asn1p_type_tag_s *tag_p) {
+ struct asn1p_type_tag_s tag;
+
+ if(tag_p) {
+ tag = *tag_p;
+ } else {
+ if(asn1f_fetch_tag(arg->asn, arg->mod, expr, &tag)) {
+ OUT("-1 /* Ambiguous tag (CHOICE?) */");
+ return 0;
+ }
+ }
+
+ OUT("(");
+ switch(tag.tag_class) {
+ case TC_UNIVERSAL: OUT("ASN_TAG_CLASS_UNIVERSAL"); break;
+ case TC_APPLICATION: OUT("ASN_TAG_CLASS_APPLICATION"); break;
+ case TC_CONTEXT_SPECIFIC: OUT("ASN_TAG_CLASS_CONTEXT"); break;
+ case TC_PRIVATE: OUT("ASN_TAG_CLASS_PRIVATE"); break;
+ case TC_NOCLASS:
+ break;
+ }
+ OUT(" | (%lld << 2))", tag.tag_value);
+
+ return 0;
+}
+
+/*
+ * For constructed types, number of external tags may be greater than
+ * number of elements in the type because of CHOICE type.
+ * T ::= SET { -- Three possible tags:
+ * a INTEGER, -- One tag is here...
+ * b Choice1 -- ... and two more tags are there.
+ * }
+ * Choice1 ::= CHOICE {
+ * s1 IA5String,
+ * s2 ObjectDescriptor
+ * }
+ */
+static int
+_fill_tag2el_map(arg_t *arg, tag2el_t **tag2el, int *count, int el_no) {
+ asn1p_expr_t *expr = arg->expr;
+ arg_t tmparg = *arg;
+ asn1p_expr_t *v;
+ int element = 0;
+
+ TQ_FOR(v, &(expr->members), next) {
+ if(v->expr_type == A1TC_EXTENSIBLE)
+ continue;
+
+ tmparg.expr = v;
+
+ if(_add_tag2el_member(&tmparg, tag2el, count,
+ (el_no==-1)?element:el_no)) {
+ return -1;
+ }
+
+ element++;
+ }
+
+ return 0;
+}
+
+static int
+_add_tag2el_member(arg_t *arg, tag2el_t **tag2el, int *count, int el_no) {
+ struct asn1p_type_tag_s tag;
+ int ret;
+
+ assert(el_no >= 0);
+
+ ret = asn1f_fetch_tag(arg->asn, arg->mod, arg->expr, &tag);
+ if(ret == 0) {
+ void *p;
+ p = realloc(*tag2el, sizeof(tag2el_t) * ((*count) + 1));
+ if(p) *tag2el = p;
+ else return -1;
+
+ DEBUG("Found tag for %s: %ld",
+ arg->expr->Identifier,
+ (long)tag.tag_value);
+
+ (*tag2el)[*count].el_tag = tag;
+ (*tag2el)[*count].el_no = el_no;
+ (*tag2el)[*count].from_expr = arg->expr;
+ (*count)++;
+ return 0;
+ }
+
+ DEBUG("Searching tag in complex expression %s:%x at line %d",
+ arg->expr->Identifier,
+ arg->expr->expr_type,
+ arg->expr->_lineno);
+
+ /*
+ * Iterate over members of CHOICE type.
+ */
+ if(arg->expr->expr_type == ASN_CONSTR_CHOICE) {
+ return _fill_tag2el_map(arg, tag2el, count, el_no);
+ }
+
+ if(arg->expr->expr_type == A1TC_REFERENCE) {
+ arg_t tmp = *arg;
+ asn1p_expr_t *expr;
+ expr = asn1f_lookup_symbol_ex(tmp.asn, &tmp.mod, tmp.expr,
+ arg->expr->reference);
+ if(expr) {
+ tmp.expr = expr;
+ return _add_tag2el_member(&tmp, tag2el, count, el_no);
+ } else {
+ FATAL("Cannot dereference %s at line %d",
+ arg->expr->Identifier,
+ arg->expr->_lineno);
+ return -1;
+ }
+ }
+
+ DEBUG("No tag for %s at line %d",
+ arg->expr->Identifier,
+ arg->expr->_lineno);
+
+ return -1;
+}
+
+static int
+emit_constraint_checking_code(arg_t *arg) {
+ asn1p_expr_t *expr = arg->expr;
+ asn1p_expr_type_e etype;
+ int size_present, value_present;
+
+ if(expr->constraints == NULL)
+ return 0; /* No constraints defined */
+
+ etype = _find_terminal_type(arg);
+
+ size_present = check_constraint_type_presence(expr->constraints,
+ ACT_CT_SIZE);
+ value_present = check_constraint_type_presence(expr->constraints,
+ ACT_EL_VALUE);
+
+ if(size_present || value_present) {
+ OUT("%s_t *st = sptr;\n", MKID(arg->expr->Identifier));
+ if(size_present) {
+ OUT("size_t size;\n");
+ OUT("size_t min_size __attribute__ ((unused)) = %ld;\n",
+ compute_min_size(arg));
+ OUT("size_t max_size __attribute__ ((unused)) = %ld;\n",
+ compute_max_size(arg));
+ }
+ if(value_present)
+ switch(etype) {
+ case ASN_BASIC_INTEGER:
+ case ASN_BASIC_ENUMERATED:
+ OUT("long value;\n");
+ break;
+ case ASN_BASIC_BOOLEAN:
+ OUT("int value;\n");
+ break;
+ default:
+ break;
+ }
+ OUT("\n");
+ }
+
+ OUT("if(!sptr) {\n");
+ INDENT(+1);
+ OUT("_ASN_ERRLOG(\"%%s: value not given\", td->name);\n");
+ OUT("return -1;\n");
+ INDENT(-1);
+ OUT("}\n");
+ OUT("\n");
+
+ if(size_present)
+ emit_size_determination_code(arg);
+ if(value_present)
+ emit_value_determination_code(arg);
+
+ OUT("\n");
+ OUT("if(\n");
+ emit_single_constraint_check(arg, expr->constraints, 0);
+ OUT(") {\n");
+ INDENTED(OUT("/* Constraint check succeeded */\n"));
+ OUT("} else {\n");
+ INDENT(+1);
+ OUT("_ASN_ERRLOG(\"%%s: constraint failed\", td->name);\n");
+ OUT("return -1;\n");
+ INDENT(-1);
+ OUT("}\n");
+
+ return 0;
+}
+
+static int
+emit_single_constraint_check(arg_t *arg, asn1p_constraint_t *ct, int mode) {
+ char *s_v;
+ int el;
+
+ assert(arg && ct);
+
+ switch(ct->type) {
+ case ACT_INVALID:
+ assert(ct->type != ACT_INVALID);
+ OUT("-1 /* Invalid constraint at line %d */\n", ct->_lineno);
+ break;
+ case ACT_EL_VALUE:
+ OUT("(");
+ if(mode == ACT_CT_SIZE) s_v = "size";
+ else s_v = "value";
+ OUT("%s", s_v);
+ if(ct->value->type != ATV_TRUE)
+ OUT(" == ");
+ switch(ct->value->type) {
+ case ATV_INTEGER: OUT("%lld",
+ (long long)ct->value->value.v_integer); break;
+ case ATV_MIN: OUT("min_%s", s_v); break;
+ case ATV_MAX: OUT("max_%s", s_v); break;
+ case ATV_FALSE: OUT("0"); break;
+ case ATV_TRUE: break;
+ default:
+ break;
+ }
+ OUT(")\n");
+ break;
+ case ACT_EL_RANGE:
+ case ACT_EL_LLRANGE:
+ case ACT_EL_RLRANGE:
+ case ACT_EL_ULRANGE:
+ if(mode == ACT_CT_SIZE) {
+ s_v = "size";
+ } else {
+ s_v = "value";
+ }
+ OUT("((%s", s_v);
+ switch(ct->type) {
+ case ACT_EL_RANGE:
+ case ACT_EL_RLRANGE:
+ OUT(" >= "); break;
+ case ACT_EL_LLRANGE:
+ case ACT_EL_ULRANGE:
+ OUT(" > "); break;
+ default: break;
+ }
+ switch(ct->range_start->type) {
+ case ATV_INTEGER: OUT("%lld",
+ (long long)ct->range_start->value.v_integer); break;
+ case ATV_MIN: OUT("min_%s", s_v); break;
+ case ATV_MAX: OUT("max_%s", s_v); break;
+ case ATV_FALSE: OUT("0"); break;
+ case ATV_TRUE: break;
+ default:
+ break;
+ }
+ OUT(") && (%s", s_v);
+ switch(ct->type) {
+ case ACT_EL_RANGE:
+ case ACT_EL_LLRANGE:
+ OUT(" <= "); break;
+ case ACT_EL_RLRANGE:
+ case ACT_EL_ULRANGE:
+ OUT(" < "); break;
+ default: break;
+ }
+ switch(ct->range_stop->type) {
+ case ATV_INTEGER: OUT("%lld",
+ (long long)ct->range_stop->value.v_integer); break;
+ case ATV_MIN: OUT("min_%s", s_v); break;
+ case ATV_MAX: OUT("max_%s", s_v); break;
+ case ATV_FALSE: OUT("0"); break;
+ case ATV_TRUE: break;
+ default:
+ break;
+ }
+ OUT("))\n");
+ break;
+ case ACT_EL_EXT:
+ OUT("0 /* Extensible (...), but not defined herein */\n");
+ break;
+ case ACT_CT_SIZE:
+ if(mode) {
+ OUT("0 /* Invalid constraint at line %d */\n",
+ ct->_lineno);
+ return -1;
+ }
+ assert(ct->el_count == 1);
+ return emit_single_constraint_check(arg,
+ ct->elements[0], ACT_CT_SIZE);
+ case ACT_CT_FROM:
+ if(mode) {
+ OUT("0 /* Invalid constraint at line %d */\n",
+ ct->_lineno);
+ return -1;
+ }
+ OUT("check_alphabet_%x(sptr)\n", ct);
+ break;
+ case ACT_CT_WCOMP:
+ case ACT_CT_WCOMPS:
+ OUT("%d /* Unsupported constraint at line %d */\n",
+ ct->type, ct->_lineno);
+ return -1;
+ break;
+ case ACT_CA_SET:
+ OUT("(\n");
+ INDENT(+1);
+ for(el = 0; el < ct->el_count; el++) {
+ if(el) OUT("&& ");
+ emit_single_constraint_check(arg,
+ ct->elements[el], mode);
+ }
+ INDENT(-1);
+ OUT(")\n");
+ break;
+ case ACT_CA_CSV:
+ OUT("(\n");
+ INDENT(+1);
+ for(el = 0; el < ct->el_count; el++) {
+ if(el) OUT("|| ");
+ emit_single_constraint_check(arg,
+ ct->elements[el], mode);
+ }
+ INDENT(-1);
+ OUT(")\n");
+ break;
+ case ACT_CA_UNI:
+ OUT("(\n");
+ INDENT(+1);
+ for(el = 0; el < ct->el_count; el++) {
+ if(el) OUT("|| ");
+ emit_single_constraint_check(arg,
+ ct->elements[el], mode);
+ }
+ INDENT(-1);
+ OUT(")\n");
+ break;
+ case ACT_CA_INT:
+ OUT("(\n");
+ INDENT(+1);
+ for(el = 0; el < ct->el_count; el++) {
+ if(el) OUT("&& ");
+ emit_single_constraint_check(arg,
+ ct->elements[el], mode);
+ }
+ INDENT(-1);
+ OUT(")\n");
+ break;
+ case ACT_CA_CRC:
+ WARNING("Unsupported component relation constraint at line %d",
+ ct->_lineno);
+ OUT("%d /* Unsupported component relation constraint "
+ "at line %d */\n",
+ ct->type, ct->_lineno);
+ return -1;
+ case ACT_CA_EXC:
+ WARNING("Unsupported EXCEPT constraint at line %d",
+ ct->_lineno);
+ OUT("%d /* Unsupported EXCEPT constraint at line %d */\n",
+ ct->type, ct->_lineno);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+check_constraint_type_presence(asn1p_constraint_t *ct, enum asn1p_constraint_type_e type) {
+ int el;
+
+ if(ct == NULL) return 0;
+
+ if(ct->type == type) return 1;
+
+ if(type == ACT_EL_VALUE) {
+ if(ct->type >= ACT_CT_SIZE
+ && ct->type <= ACT_CT_WCOMPS)
+ /* Values defined further
+ * are not really value's values */
+ return 0;
+ if(ct->type > ACT_EL_VALUE && ct->type < ACT_CT_SIZE)
+ return 1; /* Also values */
+ }
+
+ for(el = 0; el < ct->el_count; el++) {
+ if(check_constraint_type_presence(ct->elements[el], type))
+ return 1;
+ }
+
+ return 0;
+}
+
+static int
+emit_alphabet_tables(arg_t *arg, asn1p_constraint_t *ct, int *table) {
+ int ch = 0;
+ int ch_start = 0;
+ int ch_stop = 0;
+ int el = 0;
+
+ assert(arg && ct);
+
+ switch(ct->type) {
+ case ACT_INVALID:
+ break;
+ case ACT_EL_VALUE:
+ if(!table) break;
+
+ switch(ct->value->type) {
+ case ATV_INTEGER:
+ if(ct->value->value.v_integer < 0
+ || ct->value->value.v_integer > 255) {
+ OUT("\n");
+ OUT("#error Value %lld out of range "
+ "for alphabet character at line %d\n",
+ (long long)ct->value->value.v_integer,
+ ct->_lineno);
+ break;
+ } else {
+ ch = ct->value->value.v_integer;
+ table[ch] = 1;
+ }
+ break;
+ case ATV_STRING:
+ for(ch = 0; ch < ct->value->value.string.size; ch++)
+ table[ct->value->value.string.buf[ch]] = 1;
+ break;
+ default:
+ OUT("\n");
+ WARNING("Invalid alphabet character specification "
+ "at line %d", ct->_lineno);
+ OUT("#error Invalid alphabet character specification "
+ "at line %d\n", ct->_lineno);
+ break;
+ }
+ break;
+ case ACT_EL_RANGE:
+ case ACT_EL_LLRANGE:
+ case ACT_EL_RLRANGE:
+ case ACT_EL_ULRANGE:
+ if(!table) break;
+
+ ch_start = 0;
+ ch_stop = 255;
+
+ switch(ct->range_start->type) {
+ case ATV_INTEGER:
+ ch_start = ct->range_start->value.v_integer; break;
+ case ATV_MIN: ch_start = 0; break;
+ case ATV_MAX: ch_start = 255; break;
+ case ATV_STRING:
+ if(ct->range_start->value.string.size == 1) {
+ ch_start = ct->range_start->value.string.buf[0];
+ break;
+ }
+ /* Fall through */
+ default:
+ OUT("\n");
+ FATAL("Invalid alphabet range constraint "
+ "at line %d\n", ct->_lineno);
+ OUT("#error Invalid alphabet range constraint "
+ "at line %d\n", ct->_lineno);
+ return -1;
+ }
+
+ switch(ct->range_stop->type) {
+ case ATV_INTEGER:
+ ch_stop = ct->range_stop->value.v_integer; break;
+ case ATV_MIN: ch_stop = 0; break;
+ case ATV_MAX: ch_stop = 255; break;
+ case ATV_STRING:
+ if(ct->range_stop->value.string.size == 1) {
+ ch_stop = ct->range_stop->value.string.buf[0];
+ break;
+ }
+ /* Fall through */
+ default:
+ OUT("\n");
+ FATAL("Invalid alphabet range constraint "
+ "at line %d\n", ct->_lineno);
+ OUT("#error Invalid alphabet range constraint "
+ "at line %d\n", ct->_lineno);
+ break;
+ }
+
+ switch(ct->type) {
+ case ACT_EL_RANGE: break;
+ case ACT_EL_RLRANGE: ch_stop--; break;
+ case ACT_EL_LLRANGE: ch_start++; break;
+ case ACT_EL_ULRANGE: ch_start++; ch_stop--; break;
+ default: break;
+ }
+
+ if(ch_start > ch_stop) {
+ WARNING("Empty character range "
+ "alphabet constraint at line %d", ct->_lineno);
+ OUT("#warning Empty character range "
+ "alphabet constraint at line %d\n", ct->_lineno);
+ break;
+ }
+
+ for(ch = ch_start; ch <= ch_stop; ch++) {
+ if(ch < 0 || ch > 255) continue;
+ table[ch] = 1;
+ }
+
+ break;
+ case ACT_EL_EXT:
+ break;
+ case ACT_CT_SIZE:
+ break;
+ case ACT_CT_FROM:
+ if(table) {
+ OUT("#error Nested FROM in subtype constraints\n");
+ return -1;
+ } else {
+ table = alloca(256 * sizeof(table[0]));
+ memset(table, 0, 256 * sizeof(table[0]));
+
+ for(el = 0; el < ct->el_count; el++) {
+ emit_alphabet_tables(arg, ct->elements[el],
+ table);
+ }
+ OUT("static int alphabet_table_%x[256] = {\n", ct);
+ for(ch = 0; ch < 256; ch++) {
+ OUT("%d,", table[ch]?1:0);
+ if(!((ch+1) % 16)) {
+ if(ch) {
+ int c;
+ OUT("\t/* ");
+ for(c = ch - 16; c < ch; c++) {
+ if(table[c]) {
+ if(c > 0x20
+ && c < 0x80)
+ OUT("%c", c);
+ else
+ OUT(".", c);
+ } else {
+ OUT(" ");
+ }
+ }
+ OUT(" */");
+ }
+ OUT("\n");
+ }
+ }
+ OUT("};\n");
+ OUT("static int check_alphabet_%x(void *sptr) {\n", ct);
+ INDENT(+1);
+ OUT("int *table = alphabet_table_%x;\n", ct);
+ emit_alphabet_check_cycle(arg);
+ OUT("return 1;\n");
+ INDENT(-1);
+ OUT("};\n");
+ }
+ break;
+ case ACT_CT_WCOMP:
+ case ACT_CT_WCOMPS:
+ break;
+ case ACT_CA_CRC:
+ break;
+ case ACT_CA_SET:
+ case ACT_CA_CSV:
+ case ACT_CA_UNI:
+ for(el = 0; el < ct->el_count; el++)
+ emit_alphabet_tables(arg, ct->elements[el], table);
+ break;
+ case ACT_CA_INT:
+ if(table) {
+ int table2[256];
+
+ assert(ct->el_count >= 1);
+ emit_alphabet_tables(arg, ct->elements[0], table);
+ for(el = 1; el < ct->el_count; el++) {
+ memset(table2, 0, sizeof(table2));
+ emit_alphabet_tables(arg,
+ ct->elements[el], table2);
+ /* Intersection */
+ for(ch = 0; ch < 256; ch++) {
+ if(table2[ch] == 0)
+ table[ch] = 0;
+ }
+ }
+ } else {
+ for(el = 0; el < ct->el_count; el++)
+ emit_alphabet_tables(arg, ct->elements[el], 0);
+ }
+
+ break;
+ case ACT_CA_EXC:
+ OUT("EXC\n");
+ if(table) {
+ int table2[256];
+
+ assert(ct->el_count >= 1);
+ emit_alphabet_tables(arg, ct->elements[0], table);
+ for(el = 1; el < ct->el_count; el++) {
+ memset(table2, 0, sizeof(table2));
+ emit_alphabet_tables(arg,
+ ct->elements[el], table2);
+ /* Exclusion */
+ for(ch = 0; ch < 256; ch++) {
+ if(table2[ch])
+ table[ch] = 0;
+ }
+ }
+ } else {
+ for(el = 0; el < ct->el_count; el++)
+ emit_alphabet_tables(arg, ct->elements[el], 0);
+ }
+ break;
+ }
+
+ return 0;
+}
+
+static int
+emit_alphabet_check_cycle(arg_t *arg) {
+ asn1p_expr_type_e etype;
+
+ etype = _find_terminal_type(arg);
+ if(!(etype & ASN_STRING_MASK)
+ && !(etype == ASN_BASIC_OCTET_STRING)) {
+ OUT("#error Cannot apply FROM constraint to ASN.1 type %s\n",
+ ASN_EXPR_TYPE2STR(etype));
+ return -1;
+ }
+
+ OUT("/* The underlying type is %s */\n",
+ ASN_EXPR_TYPE2STR(etype));
+ OUT("%s_t *st = sptr;\n", MKID(arg->expr->Identifier));
+
+ switch(etype) {
+ case ASN_STRING_UTF8String:
+ OUT("uint8_t *ch = st->buf;\n");
+ OUT("uint8_t *end = ch + st->size;\n");
+ OUT("\n");
+ OUT("for(; ch < end; ch++) {\n");
+ INDENT(+1);
+ OUT("if(*ch >= 0x80 || !table[*ch]) return 0;\n");
+ INDENT(-1);
+ OUT("}\n");
+ break;
+ case ASN_STRING_UniversalString:
+ OUT("uint32_t *ch = st->buf;\n");
+ OUT("uint32_t *end = ch + st->size;\n");
+ OUT("\n");
+ OUT("for(; ch < end; ch++) {\n");
+ INDENT(+1);
+ OUT("uint32_t wc = (((uint8_t *)ch)[0] << 24)\n");
+ OUT("\t\t| (((uint8_t *)ch)[1] << 16)\n");
+ OUT("\t\t| (((uint8_t *)ch)[2] << 8)\n");
+ OUT("\t\t| ((uint8_t *)ch)[3]\n");
+ OUT("if(wc > 255 || !table[wc]) return 0;\n");
+ INDENT(-1);
+ OUT("}\n");
+ OUT("if(ch != end) return 0; /* (size%4)! */\n");
+ break;
+ case ASN_STRING_BMPString:
+ OUT("uint16_t *ch = st->buf;\n");
+ OUT("uint16_t *end = ch + st->size;\n");
+ OUT("\n");
+ OUT("for(; ch < end; ch++) {\n");
+ INDENT(+1);
+ OUT("uint16_t wc = (((uint8_t *)ch)[0] << 8)\n");
+ OUT("\t\t| ((uint8_t *)ch)[1];\n");
+ OUT("if(wc > 255 || !table[wc]) return 0;\n");
+ INDENT(-1);
+ OUT("}\n");
+ OUT("if(ch != end) return 0; /* (size%2)! */\n");
+ break;
+ case ASN_BASIC_OCTET_STRING:
+ default:
+ OUT("uint8_t *ch = st->buf;\n");
+ OUT("uint8_t *end = ch + st->size;\n");
+ OUT("\n");
+ OUT("for(; ch < end; ch++) {\n");
+ INDENT(+1);
+ OUT("if(!table[*ch]) return 0;\n");
+ INDENT(-1);
+ OUT("}\n");
+ break;
+ }
+
+ return 0;
+}
+
+static int
+emit_size_determination_code(arg_t *arg) {
+ asn1p_expr_type_e etype = _find_terminal_type(arg);
+
+ switch(etype) {
+ case ASN_BASIC_BIT_STRING:
+ OUT("if(st->size > 0) {\n");
+ OUT("\t/* Size in bits */\n");
+ OUT("\tsize = (st->size - 1) - (st->buf[0] & 0x7);\n");
+ OUT("} else {\n");
+ OUT("\tsize = 0;\n");
+ OUT("}\n");
+ break;
+ case ASN_STRING_UniversalString:
+ OUT("size = st->size >> 2;\t/* 4 byte per character */\n");
+ break;
+ case ASN_STRING_BMPString:
+ OUT("size = st->size >> 1;\t/* 2 byte per character */\n");
+ break;
+ case ASN_STRING_UTF8String:
+ OUT("size = UTF8String_length(st, td->name, app_errlog, app_key);\n");
+ OUT("if(size == (size_t)-1) return -1;\n");
+ break;
+ default:
+ if((etype & ASN_STRING_MASK)
+ || etype == ASN_BASIC_OCTET_STRING) {
+ OUT("size = st->size;\n");
+ break;
+ } else {
+ WARNING("Size operation is not defined for %s",
+ ASN_EXPR_TYPE2STR(etype));
+ OUT("#warning Size operation not defined!\n");
+ OUT("size = st->size;\n");
+ }
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+emit_value_determination_code(arg_t *arg) {
+ asn1p_expr_type_e etype = _find_terminal_type(arg);
+
+ switch(etype) {
+ case ASN_BASIC_INTEGER:
+ case ASN_BASIC_ENUMERATED:
+ OUT("if(asn1_INTEGER2long(st, &value)) {\n");
+ INDENT(+1);
+ OUT("_ASN_ERRLOG(\"%%s: value too large\", td->name);\n");
+ OUT("return -1;\n");
+ INDENT(-1);
+ OUT("}\n");
+ break;
+ case ASN_BASIC_BOOLEAN:
+ OUT("value = st->value;\n");
+ break;
+ default:
+ WARNING("Value cannot be determined "
+ "for constraint check for %s at line %d\n",
+ arg->expr->Identifier, arg->expr->_lineno);
+ OUT("#error Value cannot be determined for %s at %d\n",
+ arg->expr->Identifier, arg->expr->_lineno);
+ break;
+ }
+
+ return 0;
+}
+
+static long compute_min_size(arg_t *arg) { return compute_xxx_size(arg, 0); }
+static long compute_max_size(arg_t *arg) { return compute_xxx_size(arg, 1); }
+
+static long compute_xxx_size(arg_t *arg, int _max) {
+ asn1p_expr_type_e etype;
+ long basic_max = 0x7fffffff;
+ long basic_min = 0x80000000;
+ long svalue = 0;
+
+ etype = _find_terminal_type(arg);
+ switch(etype) {
+ case ASN_BASIC_BIT_STRING:
+ svalue = _max?basic_max/8:0;
+ break;
+ case ASN_STRING_UTF8String:
+ svalue = _max?basic_max/6:0;
+ break;
+ case ASN_STRING_UniversalString:
+ svalue = _max?basic_max/4:0;
+ break;
+ case ASN_STRING_BMPString:
+ svalue = _max?basic_max/2:0;
+ break;
+ case ASN_BASIC_OCTET_STRING:
+ svalue = _max?basic_max:0;
+ break;
+ default:
+ if((etype & ASN_STRING_MASK)) {
+ svalue = _max?basic_max:0;
+ break;
+ }
+ svalue = _max?basic_max:basic_min;
+ break;
+ }
+
+ return svalue;
+}
+
+static asn1p_expr_type_e
+_find_terminal_type(arg_t *arg) {
+ asn1p_expr_t *expr;
+ expr = asn1f_find_terminal_type_ex(arg->asn, arg->mod, arg->expr, NULL);
+ assert(expr);
+ return expr->expr_type;
+}
diff --git a/libasn1compiler/asn1c_C.h b/libasn1compiler/asn1c_C.h
new file mode 100644
index 0000000..643d629
--- /dev/null
+++ b/libasn1compiler/asn1c_C.h
@@ -0,0 +1,69 @@
+#ifndef ASN1_COMPILER_LANGUAGE_C_H
+#define ASN1_COMPILER_LANGUAGE_C_H
+
+#include "asn1c_lang.h"
+
+int asn1c_lang_C_type_REFERENCE(arg_t *);
+int asn1c_lang_C_type_EXTENSIBLE(arg_t *);
+
+int asn1c_lang_C_type_SEQUENCE(arg_t *);
+int asn1c_lang_C_type_SEQUENCE_OF(arg_t *);
+int asn1c_lang_C_type_SET(arg_t *);
+int asn1c_lang_C_type_SET_OF(arg_t *);
+int asn1c_lang_C_type_CHOICE(arg_t *);
+
+int asn1c_lang_C_type_INTEGER(arg_t *);
+int asn1c_lang_C_type_ENUMERATED(arg_t *);
+int asn1c_lang_C_type_SIMPLE_TYPE(arg_t *);
+
+static asn1_language_map_t asn1_lang_C[] __attribute__ ((unused)) = {
+ { AMT_TYPE, A1TC_REFERENCE, asn1c_lang_C_type_REFERENCE },
+ { AMT_TYPEREF, A1TC_REFERENCE, asn1c_lang_C_type_REFERENCE },
+ { AMT_TYPE, A1TC_EXTENSIBLE, asn1c_lang_C_type_EXTENSIBLE },
+ /*
+ * Constructed types
+ */
+ { AMT_TYPE, ASN_CONSTR_SEQUENCE, asn1c_lang_C_type_SEQUENCE },
+ { AMT_TYPE, ASN_CONSTR_SEQUENCE_OF, asn1c_lang_C_type_SEQUENCE_OF },
+ { AMT_TYPEREF, ASN_CONSTR_SEQUENCE_OF, asn1c_lang_C_type_SEQUENCE_OF },
+ { AMT_TYPE, ASN_CONSTR_SET, asn1c_lang_C_type_SET },
+ { AMT_TYPE, ASN_CONSTR_SET_OF, asn1c_lang_C_type_SET_OF },
+ { AMT_TYPEREF, ASN_CONSTR_SET_OF, asn1c_lang_C_type_SET_OF },
+ { AMT_TYPE, ASN_CONSTR_CHOICE, asn1c_lang_C_type_CHOICE },
+ /*
+ * Basic types
+ */
+ { AMT_TYPE, ASN_BASIC_BOOLEAN, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_BASIC_NULL, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_BASIC_INTEGER, asn1c_lang_C_type_INTEGER },
+ /* [Skipped REAL] */
+ { AMT_TYPE, ASN_BASIC_ENUMERATED, asn1c_lang_C_type_ENUMERATED },
+ { AMT_TYPE, ASN_BASIC_BIT_STRING, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_BASIC_OCTET_STRING, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_BASIC_OBJECT_IDENTIFIER,asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_BASIC_RELATIVE_OID, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_BASIC_CHARACTER_STRING, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_BASIC_UTCTime, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_BASIC_GeneralizedTime, asn1c_lang_C_type_SIMPLE_TYPE },
+ /*
+ * String types
+ */
+ { AMT_TYPE, ASN_STRING_BMPString, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_STRING_GeneralString, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_STRING_GraphicString, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_STRING_IA5String, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_STRING_ISO646String, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_STRING_NumericString, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_STRING_PrintableString,asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_STRING_TeletexString, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_STRING_T61String, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_STRING_UniversalString,asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_STRING_UTF8String, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_STRING_VideotexString,asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_STRING_VisibleString, asn1c_lang_C_type_SIMPLE_TYPE },
+ { AMT_TYPE, ASN_STRING_ObjectDescriptor,asn1c_lang_C_type_SIMPLE_TYPE },
+ { 0, 0, 0 }
+};
+
+
+#endif /* ASN1_COMPILER_LANGUAGE_C_H */
diff --git a/libasn1compiler/asn1c_internal.h b/libasn1compiler/asn1c_internal.h
new file mode 100644
index 0000000..91772cd
--- /dev/null
+++ b/libasn1compiler/asn1c_internal.h
@@ -0,0 +1,81 @@
+#ifndef _ASN1_COMPILER_INTERNAL_H_
+#define _ASN1_COMPILER_INTERNAL_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h> /* for fstat(2) */
+#include <unistd.h> /* for unlink(2) */
+#include <fcntl.h> /* for open(2) */
+#include <glob.h> /* for glob(3) */
+#include <libgen.h> /* for basename(3) */
+#include <string.h>
+#include <ctype.h> /* for isalnum(3) */
+#include <stdarg.h>
+#include <errno.h>
+#include <assert.h>
+
+#include "asn1compiler.h"
+
+typedef struct arg_s {
+
+ enum asn1c_flags flags;
+
+ void (*logger_cb)(int _severity, const char *fmt, ...);
+
+ int (*default_cb)(struct arg_s *);
+
+ struct compiler_streams *target;
+
+ asn1p_t *asn;
+ asn1p_module_t *mod;
+ asn1p_expr_t *expr;
+
+ int indent_level;
+ int indented;
+ int embed;
+} arg_t;
+
+#include "asn1c_lang.h" /* Target language initialization */
+#include "asn1c_misc.h" /* Miscellaneous functions */
+#include "asn1c_out.h" /* Handle output during compilation */
+#include "asn1c_save.h" /* Save compiled output */
+
+#define INDENT(val) arg->indent_level += (val)
+#define INDENTED(code) do { \
+ INDENT(+1); \
+ do { code; } while(0); \
+ INDENT(-1); \
+ } while(0)
+#define FLAT(code) do { \
+ int _il = arg->indent_level; \
+ arg->indent_level = 0; \
+ do { code; } while(0); \
+ arg->indent_level = _il; \
+ } while(0)
+#define EMBED(ev) do { \
+ REDIR(OT_TYPE_DECLS); \
+ arg->embed++; \
+ INDENTED(arg_t _tmp = *arg; \
+ _tmp.expr = ev; \
+ _tmp.default_cb(&_tmp); \
+ ); \
+ arg->embed--; \
+ } while(0)
+#define OUT(fmt, args...) asn1c_compiled_output(arg, fmt, ##args)
+
+#define REDIR(foo) do { arg->target->target = foo; } while(0)
+
+/*
+ * Logging.
+ */
+#define LOG(ll, fmt, args...) do { \
+ arg->logger_cb(ll, fmt, ##args); \
+ } while(0)
+#define DEBUG(fmt, args...) do { \
+ if(arg->flags & A1C_DEBUG) \
+ LOG(-1, fmt, ##args); \
+ } while(0)
+#define WARNING(fmt, args...) LOG(0, fmt, ##args);
+#define FATAL(fmt, args...) LOG(1, fmt, ##args);
+
+#endif /* _ASN1_COMPILER_INTERNAL_H_ */
diff --git a/libasn1compiler/asn1c_lang.c b/libasn1compiler/asn1c_lang.c
new file mode 100644
index 0000000..fa07540
--- /dev/null
+++ b/libasn1compiler/asn1c_lang.c
@@ -0,0 +1,32 @@
+#include "asn1c_internal.h"
+#include "asn1c_C.h"
+
+asn1_language_map_t asn1_lang_map[AMT_EXPR_META_MAX][ASN_EXPR_TYPE_MAX];
+
+int
+asn1c_with_language(asn1c_target_language_e lang) {
+ asn1_language_map_t *lptr;
+ int lsize;
+ if(lang != ASN1C_LANGUAGE_C) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ lptr = asn1_lang_C;
+ lsize = sizeof(asn1_lang_C)/sizeof(asn1_lang_C[0]);
+
+ memset(asn1_lang_map, 0, sizeof(asn1_lang_map));
+
+ for(; lsize && lptr->expr_match; lsize--, lptr++) {
+ assert(lptr->meta_match > 0);
+ assert(lptr->meta_match < AMT_EXPR_META_MAX);
+ assert(lptr->expr_match > 0);
+ assert(lptr->expr_match < ASN_EXPR_TYPE_MAX);
+
+ asn1_lang_map[lptr->meta_match][lptr->expr_match]
+ = *lptr;
+ }
+
+ return 0;
+}
+
diff --git a/libasn1compiler/asn1c_lang.h b/libasn1compiler/asn1c_lang.h
new file mode 100644
index 0000000..8c9a6ea
--- /dev/null
+++ b/libasn1compiler/asn1c_lang.h
@@ -0,0 +1,28 @@
+#ifndef ASN1_COMPILER_LANGUAGE_H
+#define ASN1_COMPILER_LANGUAGE_H
+
+struct arg_s;
+
+typedef struct asn1_language_map_s {
+ asn1p_expr_meta_e meta_match; /* meta_type */
+ asn1p_expr_type_e expr_match; /* expr_type */
+ /*
+ * A callback that would create a language-specific type declaration.
+ */
+ int (*type_cb)(struct arg_s *arg);
+} asn1_language_map_t;
+
+
+extern asn1_language_map_t asn1_lang_map[AMT_EXPR_META_MAX][ASN_EXPR_TYPE_MAX];
+
+
+typedef enum asn1c_target_language {
+ ASN1C_LANGUAGE_C,
+} asn1c_target_language_e;
+
+/*
+ * Initialize the compiler to generate specified target language.
+ */
+int asn1c_with_language(asn1c_target_language_e lang);
+
+#endif /* ASN1_COMPILER_LANGUAGE_H */
diff --git a/libasn1compiler/asn1c_misc.c b/libasn1compiler/asn1c_misc.c
new file mode 100644
index 0000000..b464b64
--- /dev/null
+++ b/libasn1compiler/asn1c_misc.c
@@ -0,0 +1,232 @@
+#include "asn1c_internal.h"
+#include <asn1fix_export.h>
+
+#ifndef DEFFILEMODE /* Normally in <sys/stat.h> */
+#define DEFFILEMODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)
+#endif
+
+/*
+ * Construct identifier from multiple parts.
+ * Convert unsafe characters to underscores.
+ */
+char *
+asn1c_make_identifier(int unsafe_only_spaces, char *arg1, ...) {
+ static char *storage;
+ static int storage_size;
+ int nodelimiter = 0;
+ va_list ap;
+ char *str;
+ int size;
+ char *p;
+
+ if(arg1 == NULL)
+ return NULL;
+
+ /*
+ * Estimate the necessary storage size
+ */
+ size = strlen(arg1);
+ va_start(ap, arg1);
+ while((str = va_arg(ap, char *)))
+ size += 1 + strlen(str);
+ va_end(ap);
+
+ /*
+ * Make sure we have this amount of storage.
+ */
+ if(storage_size <= size) {
+ if(storage) free(storage);
+ storage = malloc(size + 1);
+ if(storage) {
+ storage_size = size;
+ } else {
+ storage_size = 0;
+ return NULL;
+ }
+ }
+
+ /*
+ * Fill-in the storage.
+ */
+ va_start(ap, arg1);
+ str = arg1;
+ p = storage;
+ for(str = arg1; str; str = va_arg(ap, char *)) {
+ int subst_made = 0;
+
+ if(str[0] == ' ' && str[1] == '\0') {
+ *p++ = ' ';
+ nodelimiter = 1; /* No delimiter */
+ continue;
+ }
+
+ if(str != arg1 && !nodelimiter)
+ *p++ = '_'; /* Delimiter between tokens */
+ nodelimiter = 0;
+
+ for(; *str; str++) {
+ if(isalnum(*str)) {
+ *p++ = *str;
+ subst_made = 0;
+ } else if(!subst_made++) {
+ if(unsafe_only_spaces && !isspace(*str)) {
+ *p ++ = *str;
+ } else {
+ *p++ = '_';
+ }
+ }
+ }
+ }
+ va_end(ap);
+ *p = '\0';
+
+ assert((p - storage) <= storage_size);
+
+ return storage;
+}
+
+FILE *
+asn1c_open_file(arg_t *arg, const char *name, const char *ext) {
+ int created = 1;
+ struct stat sb;
+ char *fname;
+ int len;
+ FILE *fp;
+ int fd;
+
+ /*
+ * Compute filenames.
+ */
+ len = strlen(name) + strlen(ext) + 1;
+ fname = alloca(len);
+ snprintf(fname, len, "%s%s", name, ext);
+
+ /*
+ * Create files.
+ */
+ fd = open(fname, O_CREAT | O_EXCL | O_WRONLY, DEFFILEMODE);
+ if(fd == -1 && errno == EEXIST) {
+ fd = open(fname, O_WRONLY, DEFFILEMODE);
+ created = 0;
+ }
+ if(fd == -1) {
+ perror(fname);
+ return NULL;
+ }
+
+ /*
+ * Check sanity.
+ */
+ if(fstat(fd, &sb) || !S_ISREG(sb.st_mode)) {
+ fprintf(stderr, "%s: Not a regular file\n", fname);
+ if(created) unlink(fname);
+ close(fd);
+ return NULL;
+ }
+
+ (void)ftruncate(fd, 0);
+
+ /*
+ * Convert file descriptor into file pointer.
+ */
+ fp = fdopen(fd, "w");
+ if(fp == NULL) {
+ if(created) unlink(fname);
+ close(fd);
+ }
+ return fp;
+}
+
+char *
+asn1c_type_name(arg_t *arg, asn1p_expr_t *expr, enum tnfmt _format) {
+ char *typename;
+
+ switch(expr->expr_type) {
+ case A1TC_REFERENCE:
+ typename = expr->reference->components[
+ expr->reference->comp_count-1].name;
+ if(typename[0] == '&') {
+ arg_t tmp = *arg;
+
+ /*
+ * This is a reference to a type defined in a class.
+ * Resolve it and use instead.
+ */
+ tmp.expr = asn1f_class_access_ex(arg->asn, arg->mod,
+ arg->expr, expr->reference, &tmp.mod);
+ if(tmp.expr) return NULL;
+
+ return asn1c_type_name(&tmp, tmp.expr, _format);
+ } else if(_format == TNF_RSAFE) {
+ /*
+ * The recursion-safe format is requested.
+ * The problem here is that only constructed types
+ * might be referenced with "struct".
+ * Change RSAFE to CTYPE if the terminal type
+ * is primitive.
+ */
+ asn1p_expr_t *terminal;
+ terminal = asn1f_find_terminal_type_ex(
+ arg->asn, arg->mod, arg->expr, NULL);
+ if(terminal
+ && (terminal->expr_type
+ & (ASN_BASIC_MASK | ASN_STRING_MASK)))
+ _format = TNF_CTYPE;
+ }
+ break;
+ case ASN_CONSTR_SEQUENCE_OF:
+ case ASN_CONSTR_SET_OF:
+ if(expr->Identifier) {
+ typename = expr->Identifier;
+ } else {
+ asn1p_expr_t *child;
+ child = TQ_FIRST(&(expr->members));
+ typename = asn1c_type_name(arg, child, _format);
+ if(typename)
+ return typename;
+ _format = TNF_SAFE;
+ typename = child->Identifier;
+ }
+ break;
+ case ASN_BASIC_INTEGER:
+ case ASN_BASIC_ENUMERATED:
+ if((arg->flags & A1C_USE_NATIVE_INTEGERS)) {
+ switch(_format) {
+ case TNF_CTYPE:
+ case TNF_RSAFE:
+ return "int";
+ default:
+ if(expr->expr_type == ASN_BASIC_INTEGER)
+ return "NativeInteger";
+ else
+ return "NativeEnumerated";
+ }
+ }
+ /* Fall through */
+ default:
+ if(expr->expr_type & (ASN_BASIC_MASK | ASN_STRING_MASK)) {
+ if(_format == TNF_RSAFE)
+ _format = TNF_CTYPE;
+ typename = ASN_EXPR_TYPE2STR(expr->expr_type);
+ } else {
+ _format = TNF_SAFE;
+ typename = expr->Identifier;
+ }
+ }
+
+ switch(_format) {
+ case TNF_UNMODIFIED:
+ case TNF_INCLUDE:
+ return asn1c_make_identifier(1, typename, 0);
+ case TNF_SAFE:
+ return asn1c_make_identifier(0, typename, 0);
+ case TNF_CTYPE:
+ return asn1c_make_identifier(0, typename, "t", 0);
+ case TNF_RSAFE:
+ return asn1c_make_identifier(0, "struct", " ", typename, 0);
+ }
+
+ assert("!unreachable");
+ return typename;
+}
+
diff --git a/libasn1compiler/asn1c_misc.h b/libasn1compiler/asn1c_misc.h
new file mode 100644
index 0000000..2f82b0b
--- /dev/null
+++ b/libasn1compiler/asn1c_misc.h
@@ -0,0 +1,28 @@
+#ifndef _ASN1_COMPILER_MISC_H_
+#define _ASN1_COMPILER_MISC_H_
+
+/*
+ * Make the target language identifier out of one or more names.
+ * The function will concatenate the names and replace unsafe characters
+ * with safe ones.
+ */
+char *asn1c_make_identifier(int unsafe_only_spaces, char *arg1, ...);
+
+/*
+ * Return the type name of the specified expression.
+ */
+enum tnfmt {
+ TNF_UNMODIFIED, /* Return unmodified type name */
+ TNF_INCLUDE, /* Format for #include <> */
+ TNF_CTYPE, /* Format as normal C-ish type (append "_t") */
+ TNF_SAFE, /* Replace unsafe characters with _ */
+ TNF_RSAFE, /* Recursion-safe C type format */
+};
+char *asn1c_type_name(arg_t *arg, asn1p_expr_t *expr, enum tnfmt _format);
+
+/*
+ * Open the arbitrary file by its base name and extension.
+ */
+FILE *asn1c_open_file(arg_t *arg, const char *base_part, const char *extension);
+
+#endif /* _ASN1_COMPILER_MISC_H_ */
diff --git a/libasn1compiler/asn1c_out.c b/libasn1compiler/asn1c_out.c
new file mode 100644
index 0000000..a643241
--- /dev/null
+++ b/libasn1compiler/asn1c_out.c
@@ -0,0 +1,75 @@
+#include "asn1c_internal.h"
+
+/*
+ * Add an elementary chunk of target language text
+ * into appropriate output stream.
+ */
+int
+asn1c_compiled_output(arg_t *arg, const char *fmt, ...) {
+ const char *p;
+ int lf_found;
+ va_list ap;
+ out_chunk_t *m;
+ char *buf;
+ int ret;
+
+ /*
+ * Make sure the output has a single LF and only at the end.
+ */
+ for(lf_found = 0, p = fmt; *p; p++) {
+ if(*p == '\n') {
+ lf_found++;
+ assert(p[1] == '\0');
+ }
+ }
+ assert(lf_found <= 1);
+
+ /*
+ * Print out the indentation.
+ */
+ if(arg->indented == 0) {
+ int i = arg->indent_level;
+ arg->indented = 1;
+ while(i--) {
+ ret = asn1c_compiled_output(arg, "\t");
+ if(ret == -1) return -1;
+ }
+ }
+
+ /*
+ * Estimate necessary size.
+ */
+ buf = "";
+ va_start(ap, fmt);
+ ret = vsnprintf(buf, 0, fmt, ap);
+ va_end(ap);
+ assert(ret >= 0);
+
+ /*
+ * Allocate buffer.
+ */
+ m = calloc(1, sizeof(out_chunk_t));
+ if(m == NULL) return -1;
+ m->len = ret + 1;
+ m->buf = malloc(ret + 1);
+ if(m->buf == NULL) {
+ free(m);
+ return -1;
+ }
+
+ /*
+ * Fill the buffer.
+ */
+ va_start(ap, fmt);
+ ret = vsnprintf(m->buf, m->len, fmt, ap);
+ assert(ret < m->len);
+ m->len = ret;
+ va_end(ap);
+
+ TQ_ADD(&(arg->target->targets[arg->target->target]), m, next);
+
+ if(lf_found)
+ arg->indented = 0;
+
+ return 0;
+}
diff --git a/libasn1compiler/asn1c_out.h b/libasn1compiler/asn1c_out.h
new file mode 100644
index 0000000..2267d5d
--- /dev/null
+++ b/libasn1compiler/asn1c_out.h
@@ -0,0 +1,31 @@
+#ifndef _ASN1_COMPILED_OUTPUT_H_
+#define _ASN1_COMPILED_OUTPUT_H_
+
+/*
+ * An elementary chunk of target language text.
+ */
+typedef struct out_chunk {
+ char *buf;
+ int len;
+
+ TQ_ENTRY(struct out_chunk) next;
+} out_chunk_t;
+
+typedef struct compiler_streams {
+ enum {
+ OT_DEPS, /* Dependencies */
+ OT_TYPE_DECLS, /* Type declarations */
+ OT_FUNC_DECLS, /* Function declarations */
+ OT_STAT_DEFS, /* Static definitions */
+ OT_CODE, /* Some code */
+ OT_MAX
+ } target;
+ TQ_HEAD(out_chunk_t) targets[OT_MAX];
+} compiler_streams_t;
+
+static char *_compiler_stream2str[] __attribute__ ((unused))
+ = { "DEPS", "TYPE-DECLS", "FUNC-DECLS", "STAT-DEFS", "CODE" };
+
+int asn1c_compiled_output(arg_t *arg, const char *fmt, ...);
+
+#endif /* _ASN1_COMPILED_OUTPUT_H_ */
diff --git a/libasn1compiler/asn1c_save.c b/libasn1compiler/asn1c_save.c
new file mode 100644
index 0000000..0e5b0fb
--- /dev/null
+++ b/libasn1compiler/asn1c_save.c
@@ -0,0 +1,225 @@
+#include "asn1c_internal.h"
+
+static int asn1c_dump_streams(arg_t *arg);
+static int asn1c_print_streams(arg_t *arg);
+static int asn1c_save_streams(arg_t *arg);
+static int asn1c_copy_over(arg_t *arg, char *path);
+
+int
+asn1c_save_compiled_output(arg_t *arg, const char *datadir) {
+
+ (void)datadir;
+
+ TQ_FOR(arg->mod, &(arg->asn->modules), mod_next) {
+ TQ_FOR(arg->expr, &(arg->mod->members), next) {
+ if(asn1_lang_map[arg->expr->meta_type]
+ [arg->expr->expr_type].type_cb) {
+ if(asn1c_dump_streams(arg))
+ return -1;
+ }
+ }
+ }
+
+ /*
+ * Dump out the Makefile template and the rest of the support code.
+ */
+ if((arg->flags & A1C_PRINT_COMPILED) == 0
+ && (arg->flags & A1C_OMIT_SUPPORT_CODE) == 0) {
+ glob_t pg;
+ FILE *mkf;
+ char *p;
+ int i;
+
+ i = strlen(datadir) + sizeof("/*.[ch]");
+ p = alloca(i);
+ snprintf(p, i, "%s/*.[ch]", datadir);
+
+ memset(&pg, 0, sizeof(pg));
+ if(glob(p, GLOB_ERR
+#ifdef GLOB_TILDE
+ | GLOB_TILDE
+#endif /* GLOB_TILDE */
+ , NULL, &pg)) {
+ fprintf(stderr,
+ "Bad skeletons directory (-S) %s: %s\n",
+ datadir, strerror(errno));
+ return -1;
+ }
+
+ mkf = asn1c_open_file(arg, "Makefile.am", ".sample");
+ if(mkf == NULL) {
+ globfree(&pg);
+ perror("Makefile.am.sample");
+ return -1;
+ }
+
+ fprintf(mkf, "ASN_SRCS=");
+ TQ_FOR(arg->mod, &(arg->asn->modules), mod_next) {
+ TQ_FOR(arg->expr, &(arg->mod->members), next) {
+ if(asn1_lang_map[arg->expr->meta_type]
+ [arg->expr->expr_type].type_cb) {
+ fprintf(mkf, "\t\\\n\t%s.c %s.h",
+ arg->expr->Identifier,
+ arg->expr->Identifier);
+ }
+ }
+ }
+
+ for(i = 0; i < pg.gl_pathc; i++) {
+ if(asn1c_copy_over(arg, pg.gl_pathv[i])) {
+ fprintf(mkf, ">>>ABORTED<<<");
+ fclose(mkf);
+ globfree(&pg);
+ return -1;
+ } else {
+ fprintf(mkf, "\t\\\n\t%s",
+ basename(pg.gl_pathv[i]));
+ }
+ }
+
+ fprintf(mkf, "\n\n");
+ fprintf(mkf, "lib_LTLIBRARIES=libsomething.la\n");
+ fprintf(mkf, "libsomething_la_SOURCES=${ASN_SRCS}\n");
+ fclose(mkf);
+ fprintf(stderr, "Generated Makefile.am.sample\n");
+ globfree(&pg);
+ }
+
+ return 0;
+}
+
+/*
+ * Dump the streams.
+ */
+static int
+asn1c_dump_streams(arg_t *arg) {
+ if(arg->flags & A1C_PRINT_COMPILED) {
+ return asn1c_print_streams(arg);
+ } else {
+ return asn1c_save_streams(arg);
+ }
+}
+
+static int
+asn1c_print_streams(arg_t *arg) {
+ compiler_streams_t *cs = arg->expr->data;
+ asn1p_expr_t *expr = arg->expr;
+ int i;
+
+ for(i = 0; i < OT_MAX; i++) {
+ out_chunk_t *ot;
+ if(TQ_FIRST(&cs->targets[i]) == NULL)
+ continue;
+
+ printf("\n/*** <<< %s [%s] >>> ***/\n\n",
+ _compiler_stream2str[i],
+ expr->Identifier);
+
+ TQ_FOR(ot, &(cs->targets[i]), next) {
+ fwrite(ot->buf, ot->len, 1, stdout);
+ }
+ }
+
+ return 0;
+}
+
+static int
+asn1c_save_streams(arg_t *arg) {
+ asn1p_expr_t *expr = arg->expr;
+ compiler_streams_t *cs = expr->data;
+ out_chunk_t *ot;
+ FILE *fp_c, *fp_h;
+ char *header_id;
+
+ if(cs == NULL) {
+ fprintf(stderr, "Cannot compile %s at line %d\n",
+ expr->Identifier, expr->_lineno);
+ return -1;
+ }
+
+ fp_c = asn1c_open_file(arg, expr->Identifier, ".c");
+ fp_h = asn1c_open_file(arg, expr->Identifier, ".h");
+ if(fp_c == NULL || fp_h == NULL) {
+ if(fp_c) fclose(fp_c); /* lacks unlink() */
+ if(fp_h) fclose(fp_h); /* lacks unlink() */
+ return -1;
+ }
+
+ header_id = alloca(strlen(expr->Identifier) + 1);
+ if(1) {
+ char *src, *dst;
+ for(src = expr->Identifier, dst = header_id;
+ (*dst=*src); src++, dst++)
+ if(!isalnum(*src)) *dst = '_';
+ *dst = '\0';
+ }
+
+ fprintf(fp_h,
+ "#ifndef\t_%s_H_\n"
+ "#define\t_%s_H_\n"
+ "\n", header_id, header_id);
+
+ fprintf(fp_h, "#include <constr_TYPE.h>\n\n");
+
+ TQ_FOR(ot, &(cs->targets[OT_DEPS]), next)
+ fwrite(ot->buf, ot->len, 1, fp_h);
+ fprintf(fp_h, "\n");
+ TQ_FOR(ot, &(cs->targets[OT_TYPE_DECLS]), next)
+ fwrite(ot->buf, ot->len, 1, fp_h);
+ fprintf(fp_h, "\n");
+ TQ_FOR(ot, &(cs->targets[OT_FUNC_DECLS]), next)
+ fwrite(ot->buf, ot->len, 1, fp_h);
+
+ fprintf(fp_c, "#include <%s.h>\n\n", expr->Identifier);
+ TQ_FOR(ot, &(cs->targets[OT_STAT_DEFS]), next)
+ fwrite(ot->buf, ot->len, 1, fp_c);
+ TQ_FOR(ot, &(cs->targets[OT_CODE]), next)
+ fwrite(ot->buf, ot->len, 1, fp_c);
+
+ assert(OT_MAX == 5);
+
+ fprintf(fp_h, "\n#endif\t/* _%s_H_ */\n", header_id);
+
+ fclose(fp_c);
+ fclose(fp_h);
+ fprintf(stderr, "Compiled %s.c\n", expr->Identifier);
+ fprintf(stderr, "Compiled %s.h\n", expr->Identifier);
+ return 0;
+}
+
+static int
+asn1c_copy_over(arg_t *arg, char *path) {
+ char *fname = basename(path);
+
+ if(symlink(path, fname)) {
+ if(errno == EEXIST) {
+ struct stat sb1, sb2;
+ if(stat(path, &sb1) == 0
+ && stat(fname, &sb2) == 0
+ && sb1.st_dev == sb2.st_dev
+ && sb1.st_ino == sb2.st_ino) {
+ /*
+ * Nothing to do.
+ */
+ fprintf(stderr,
+ "File %s is already here as %s\n",
+ path, fname);
+ return 0;
+ } else {
+ fprintf(stderr,
+ "Retaining local %s (%s suggested)\n",
+ fname, path);
+ return 0;
+ }
+ } else {
+ fprintf(stderr, "Symlink %s -> %s failed: %s\n",
+ path, fname, strerror(errno));
+ return -1;
+ }
+ }
+
+ fprintf(stderr, "Symlinked %s\t-> %s\n", path, fname);
+
+ return 0;
+}
+
diff --git a/libasn1compiler/asn1c_save.h b/libasn1compiler/asn1c_save.h
new file mode 100644
index 0000000..487e625
--- /dev/null
+++ b/libasn1compiler/asn1c_save.h
@@ -0,0 +1,6 @@
+#ifndef _ASN1_SAVE_H_
+#define _ASN1_SAVE_H_
+
+int asn1c_save_compiled_output(arg_t *arg, const char *datadir);
+
+#endif /* _ASN1_SAVE_H_ */
diff --git a/libasn1compiler/asn1compiler.c b/libasn1compiler/asn1compiler.c
new file mode 100644
index 0000000..d647c05
--- /dev/null
+++ b/libasn1compiler/asn1compiler.c
@@ -0,0 +1,160 @@
+#include "asn1c_internal.h"
+
+static void default_logger_cb(int, const char *fmt, ...);
+static int asn1c_compile_expr(arg_t *arg);
+static int asn1c_attach_streams(asn1p_expr_t *expr);
+
+int
+asn1_compile(asn1p_t *asn, const char *datadir, enum asn1c_flags flags) {
+ arg_t arg_s;
+ arg_t *arg = &arg_s;
+ int ret;
+
+ /*
+ * Initialize target language.
+ */
+ ret = asn1c_with_language(ASN1C_LANGUAGE_C);
+ assert(ret == 0);
+
+ memset(arg, 0, sizeof(*arg));
+ arg->default_cb = asn1c_compile_expr;
+ arg->logger_cb = default_logger_cb;
+ arg->flags = flags;
+ arg->asn = asn;
+
+ /*
+ * Compile each individual top level structure.
+ */
+ TQ_FOR(arg->mod, &(asn->modules), mod_next) {
+ TQ_FOR(arg->expr, &(arg->mod->members), next) {
+ compiler_streams_t *cs = NULL;
+
+ if(asn1c_attach_streams(arg->expr))
+ return -1;
+
+ cs = arg->expr->data;
+ cs->target = OT_TYPE_DECLS;
+ arg->target = cs;
+
+ ret = asn1c_compile_expr(arg);
+ if(ret) {
+ FATAL("Cannot compile %s (%x:%x) at line %d",
+ arg->expr->Identifier,
+ arg->expr->expr_type,
+ arg->expr->meta_type,
+ arg->expr->_lineno);
+ return ret;
+ }
+ }
+ }
+
+ DEBUG("Saving compiled data");
+
+ /*
+ * Save or print out the compiled result.
+ */
+ if(asn1c_save_compiled_output(arg, datadir))
+ return -1;
+
+ return 0;
+}
+
+static int
+asn1c_compile_expr(arg_t *arg) {
+ asn1p_expr_t *expr = arg->expr;
+ int (*type_cb)(arg_t *);
+ int ret;
+
+ assert(expr->meta_type >= AMT_INVALID);
+ assert(expr->meta_type < AMT_EXPR_META_MAX);
+ assert(expr->expr_type >= A1TC_INVALID);
+ assert(expr->expr_type < ASN_EXPR_TYPE_MAX);
+
+ type_cb = asn1_lang_map[expr->meta_type][expr->expr_type].type_cb;
+ if(type_cb) {
+
+ if(arg->indent_level == 0)
+ OUT("\n");
+
+ DEBUG("Compiling %s at line %d",
+ expr->Identifier,
+ expr->_lineno);
+
+ ret = type_cb(arg);
+ } else {
+ ret = -1;
+ /*
+ * Even if the target language compiler does not know
+ * how to compile the given expression, we know that
+ * certain expressions need not to be compiled at all.
+ */
+ switch(expr->meta_type) {
+ case AMT_PARAMTYPE:
+ case AMT_OBJECT:
+ case AMT_OBJECTSET:
+ case AMT_VALUE:
+ case AMT_VALUESET:
+ ret = 0;
+ break;
+ default:
+ break;
+ }
+
+ switch(expr->expr_type) {
+ case A1TC_TYPEID:
+ ret = 0; /* TYPE-IDENTIFIER is a CLASS */
+ default:
+ break;
+ }
+ }
+
+ if(ret == -1) {
+ OUT("#error Cannot compile \"%s\" (%x/%x) at line %d\n",
+ arg->expr->Identifier,
+ arg->expr->meta_type,
+ arg->expr->expr_type,
+ arg->expr->_lineno
+ );
+ }
+
+ return ret;
+}
+
+static int
+asn1c_attach_streams(asn1p_expr_t *expr) {
+ compiler_streams_t *cs;
+ int i;
+
+ if(expr->data)
+ return 0; /* Already attached? */
+
+ expr->data = calloc(1, sizeof(compiler_streams_t));
+ if(expr->data == NULL)
+ return -1;
+
+ cs = expr->data;
+ for(i = 0; i < OT_MAX; i++) {
+ TQ_INIT(&(cs->targets[i]));
+ }
+
+ return 0;
+}
+
+static void
+default_logger_cb(int _severity, const char *fmt, ...) {
+ va_list ap;
+ char *pfx = "";
+
+ switch(_severity) {
+ case -1: pfx = "DEBUG: "; break;
+ case 0: pfx = "WARNING: "; break;
+ case 1: pfx = "FATAL: "; break;
+ }
+
+ fprintf(stderr, "%s", pfx);
+ va_start(ap, fmt);
+ vfprintf(stderr, fmt, ap);
+ va_end(ap);
+ fprintf(stderr, "\n");
+}
+
diff --git a/libasn1compiler/asn1compiler.h b/libasn1compiler/asn1compiler.h
new file mode 100644
index 0000000..d104dc9
--- /dev/null
+++ b/libasn1compiler/asn1compiler.h
@@ -0,0 +1,41 @@
+#ifndef ASN1_COMPILER_H
+#define ASN1_COMPILER_H
+
+#include <asn1parser.h>
+
+enum asn1c_flags {
+ A1C_NOFLAGS,
+ /*
+ * Debug the compiler.
+ */
+ A1C_DEBUG = 0x0001,
+ /*
+ * Do not split the target output in several files, just print it.
+ * (Note: the output is not likely to be compilable in this case).
+ */
+ A1C_PRINT_COMPILED = 0x0002,
+ /*
+ * Generate only the tables for ASN.1 types,
+ * do not emit ASN.1 parsing support code.
+ */
+ A1C_OMIT_SUPPORT_CODE = 0x0004,
+ /*
+ * Use native integers instead of INTEGER_t and ENUMERATED_t types.
+ */
+ A1C_USE_NATIVE_INTEGERS = 0x0008,
+ /*
+ * Do not use C99 extensions.
+ */
+ A1C_NO_C99 = 0x0010,
+ /*
+ * Enable use of unnamed unions (non-portable feature).
+ */
+ A1C_UNNAMED_UNIONS = 0x0020,
+};
+
+/*
+ * Compile the ASN.1 specification.
+ */
+int asn1_compile(asn1p_t *asn, const char *datadir, enum asn1c_flags);
+
+#endif /* ASN1_COMPILER_H */
diff --git a/libasn1compiler/check_compiler.c b/libasn1compiler/check_compiler.c
new file mode 100644
index 0000000..1da6902
--- /dev/null
+++ b/libasn1compiler/check_compiler.c
@@ -0,0 +1,7 @@
+#include "asn1compiler.h"
+
+int
+main(int ac, char **av) {
+ return 0;
+}
+