osmocom
/
asn1c
mirror of https://gerrit.osmocom.org/asn1c
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

automatic dependency tracking 

git-svn-id: https://asn1c.svn.sourceforge.net/svnroot/asn1c/trunk@975 59561ff5-6e30-0410-9f3c-9617f08c8826
This commit is contained in:
vlm 2005-08-18 13:38:19 +00:00
parent 7c05fdf1f4
commit 6c4a850514
18 changed files with 2411 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ChangeLog
View File

@ -1,7 +1,9 @@
0.9.19: 2005-Aug-16
0.9.19: 2005-Aug-18
* asn1c's -findirect-choice flag generates less dependent code.
* A proper solution to circular references. No kludge flags
should be necessary anymore to produce reference-free code:
recursive dependencies are resolved automatically.
* Test cases 73 & 92 keep track of various circular references.
0.9.18: 2005-Aug-14

24
asn1c/tests/check-92.c Normal file
View File

@ -0,0 +1,24 @@
#undef NDEBUG
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <assert.h>
#include <Everything.h>
int
main(int ac, char **av) {
Everything_t t;
(void)ac; /* Unused argument */
(void)av; /* Unused argument */
memset(&t, 0, sizeof(t));
/*
* No plans to fill it up: just checking whether it compiles or not.
*/
return 0;
}

302
libasn1compiler/asn1c_C.c
View File

@ -42,6 +42,9 @@ static int expr_elements_count(arg_t *arg, asn1p_expr_t *expr);
static int emit_member_table(arg_t *arg, asn1p_expr_t *expr);
static int emit_tag2member_map(arg_t *arg, tag2el_t *tag2el, int tag2el_count, const char *opt_modifier);
static int emit_include_dependencies(arg_t *arg);
static asn1p_expr_t *terminal_structable(arg_t *arg, asn1p_expr_t *expr);
static int expr_defined_recursively(arg_t *arg, asn1p_expr_t *expr);
static int asn1c_recurse(arg_t *arg, asn1p_expr_t *expr, int (*callback)(arg_t *arg, void *key), void *key);
enum tvm_compat {
_TVM_SAME = 0, /* tags and all_tags are same */
@ -274,7 +277,7 @@ asn1c_lang_C_type_SEQUENCE(arg_t *arg) {
if(v->expr_type == A1TC_EXTENSIBLE)
if(comp_mode < 3) comp_mode++;
if(comp_mode == 1)
v->marker.flags |= EM_INDIRECT;
v->marker.flags |= EM_OMITABLE;
EMBED(v);
}
@ -335,7 +338,7 @@ asn1c_lang_C_type_SEQUENCE_def(arg_t *arg) {
continue;
}
if(comp_mode == 1)
v->marker.flags |= EM_INDIRECT;
v->marker.flags |= EM_OMITABLE;
emit_member_table(arg, v);
elements++;
});
@ -435,7 +438,7 @@ asn1c_lang_C_type_SET(arg_t *arg) {
if(comp_mode < 3) comp_mode++;
}
if(comp_mode == 1)
v->marker.flags |= EM_INDIRECT;
v->marker.flags |= EM_OMITABLE;
EMBED(v);
}
@ -509,7 +512,7 @@ asn1c_lang_C_type_SET_def(arg_t *arg) {
if(comp_mode < 3) comp_mode++;
} else {
if(comp_mode == 1)
v->marker.flags |= EM_INDIRECT;
v->marker.flags |= EM_OMITABLE;
emit_member_table(arg, v);
elements++;
}
@ -552,7 +555,7 @@ asn1c_lang_C_type_SET_def(arg_t *arg) {
OUT(" | ");
}
OUT("(%d << %d)",
v->marker.flags?0:1,
(v->marker.flags & EM_OMITABLE) != EM_OMITABLE,
7 - (el % 8));
if(el && (el % 8) == 0)
delimit = 1;
@ -943,7 +946,6 @@ asn1c_lang_C_type_REFERENCE(arg_t *arg) {
tmp = *arg;
tmp.asn = arg->asn;
tmp.mod = extract->module;
tmp.expr = extract;
ret = arg->default_cb(&tmp);
@ -975,10 +977,7 @@ asn1c_lang_C_type_SIMPLE_TYPE(arg_t *arg) {
* as it may recursively include the current structure.
*/
if(expr->marker.flags & (EM_INDIRECT | EM_UNRECURSE)) {
asn1p_expr_t *terminal;
terminal = asn1f_find_terminal_type_ex(arg->asn, expr);
if(terminal
&& (terminal->expr_type & ASN_CONSTR_MASK)) {
if(terminal_structable(arg, expr)) {
tnfmt = TNF_RSAFE;
REDIR(OT_FWD_DECLS);
OUT("%s;\n",
@ -1462,10 +1461,9 @@ _add_tag2el_member(arg_t *arg, tag2el_t **tag2el, int *count, int el_no, fte_e f
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,
expr = asn1f_lookup_symbol_ex(tmp.asn, tmp.expr,
arg->expr->reference);
if(expr) {
tmp.mod = expr->module;
tmp.expr = expr;
return _add_tag2el_member(&tmp, tag2el, count, el_no, flags);
} else {
@ -1612,106 +1610,6 @@ expr_elements_count(arg_t *arg, asn1p_expr_t *expr) {
return elements;
}
static int
emit_include_dependencies(arg_t *arg) {
asn1p_expr_t *expr = arg->expr;
asn1p_expr_t *memb;
TQ_FOR(memb, &(expr->members), next) {
/* Avoid recursive definitions. */
expr_break_recursion(arg, memb);
if(memb->marker.flags & (EM_INDIRECT | EM_UNRECURSE)) {
asn1p_expr_t *terminal;
terminal = asn1f_find_terminal_type_ex(arg->asn, memb);
if(terminal
&& !terminal->parent_expr
&& (terminal->expr_type & ASN_CONSTR_MASK)) {
int saved_target = arg->target->target;
REDIR(OT_FWD_DECLS);
OUT("%s;\n",
asn1c_type_name(arg, memb, TNF_RSAFE));
REDIR(saved_target);
}
}
if((!(memb->expr_type & ASN_CONSTR_MASK)
&& memb->expr_type > ASN_CONSTR_MASK)
|| memb->meta_type == AMT_TYPEREF) {
if(memb->marker.flags & EM_UNRECURSE) {
GEN_POSTINCLUDE(asn1c_type_name(arg,
memb, TNF_INCLUDE));
} else {
GEN_INCLUDE(asn1c_type_name(arg,
memb, TNF_INCLUDE));
}
}
}
return 0;
}
/*
* Check if it is better to make this type indirectly accessed via
* a pointer.
* This may be the case for the following recursive definition:
* Type ::= CHOICE { member Type };
*/
static int
expr_break_recursion(arg_t *arg, asn1p_expr_t *expr) {
asn1p_expr_t *top_parent;
asn1p_expr_t *terminal;
if(expr->marker.flags & EM_UNRECURSE)
return 1; /* Already broken */
terminal = asn1f_find_terminal_type_ex(arg->asn, expr);
/* -findirect-choice compiles members of CHOICE as indirect pointers */
if((arg->flags & A1C_INDIRECT_CHOICE)
&& arg->expr->expr_type == ASN_CONSTR_CHOICE
&& terminal
&& (terminal->expr_type & ASN_CONSTR_MASK)
) {
/* Break cross-reference */
expr->marker.flags |= EM_INDIRECT | EM_UNRECURSE;
return 1;
}
if((expr->marker.flags & EM_INDIRECT)
|| arg->expr->expr_type == ASN_CONSTR_SET_OF
|| arg->expr->expr_type == ASN_CONSTR_SEQUENCE_OF) {
if(terminal
&& !terminal->parent_expr
&& (terminal->expr_type & ASN_CONSTR_MASK)) {
expr->marker.flags |= EM_UNRECURSE;
if(arg->expr->expr_type == ASN_CONSTR_SET_OF
|| arg->expr->expr_type == ASN_CONSTR_SEQUENCE_OF) {
/* Don't put EM_INDIRECT even if recursion */
return 1;
}
/* Fall through */
}
}
/* Look for recursive back-references */
top_parent = expr->parent_expr;
if(top_parent) {
while(top_parent->parent_expr)
top_parent = top_parent->parent_expr;
if(top_parent == terminal) {
/* Explicitly break the recursion */
expr->marker.flags |= EM_INDIRECT | EM_UNRECURSE;
return 1;
}
}
return 0;
}
static int
emit_member_table(arg_t *arg, asn1p_expr_t *expr) {
int save_target;
@ -1734,10 +1632,11 @@ emit_member_table(arg_t *arg, asn1p_expr_t *expr) {
OUT("ATF_OPEN_TYPE | ");
OUT("%s, ",
(expr->marker.flags & EM_INDIRECT)?"ATF_POINTER":"ATF_NOFLAGS");
if((expr->marker.flags & EM_OPTIONAL) == EM_OPTIONAL) {
if((expr->marker.flags & EM_OMITABLE) == EM_OMITABLE) {
asn1p_expr_t *tv;
int opts = 0;
for(tv = expr; tv && tv->marker.flags;
for(tv = expr;
tv && (tv->marker.flags & EM_OMITABLE) == EM_OMITABLE;
tv = TQ_NEXT(tv, next), opts++) {
if(tv->expr_type == A1TC_EXTENSIBLE)
opts--;
@ -2018,3 +1917,178 @@ out_name_chain(arg_t *arg, enum onc_flags onc_flags) {
return 0;
}
static int
emit_include_dependencies(arg_t *arg) {
asn1p_expr_t *expr = arg->expr;
asn1p_expr_t *memb;
/* Avoid recursive definitions. */
TQ_FOR(memb, &(expr->members), next) {
expr_break_recursion(arg, memb);
}
TQ_FOR(memb, &(expr->members), next) {
if(memb->marker.flags & (EM_INDIRECT | EM_UNRECURSE)) {
if(terminal_structable(arg, memb)) {
int saved_target = arg->target->target;
REDIR(OT_FWD_DECLS);
OUT("%s;\n",
asn1c_type_name(arg, memb, TNF_RSAFE));
REDIR(saved_target);
}
}
if((!(memb->expr_type & ASN_CONSTR_MASK)
&& memb->expr_type > ASN_CONSTR_MASK)
|| memb->meta_type == AMT_TYPEREF) {
if(memb->marker.flags & EM_UNRECURSE) {
GEN_POSTINCLUDE(asn1c_type_name(arg,
memb, TNF_INCLUDE));
} else {
GEN_INCLUDE(asn1c_type_name(arg,
memb, TNF_INCLUDE));
}
}
}
return 0;
}
/*
* Check if it is better to make this type indirectly accessed via
* a pointer.
* This may be the case for the following recursive definition:
* Type ::= CHOICE { member Type };
*/
static int
expr_break_recursion(arg_t *arg, asn1p_expr_t *expr) {
asn1p_expr_t *terminal;
int ret;
if(expr->marker.flags & EM_UNRECURSE)
return 1; /* Already broken */
terminal = asn1f_find_terminal_type_ex(arg->asn, expr);
/* -findirect-choice compiles members of CHOICE as indirect pointers */
if((arg->flags & A1C_INDIRECT_CHOICE)
&& arg->expr->expr_type == ASN_CONSTR_CHOICE
&& terminal
&& (terminal->expr_type & ASN_CONSTR_MASK)
) {
/* Break cross-reference */
expr->marker.flags |= EM_INDIRECT | EM_UNRECURSE;
return 1;
}
if((expr->marker.flags & EM_INDIRECT)
|| arg->expr->expr_type == ASN_CONSTR_SET_OF
|| arg->expr->expr_type == ASN_CONSTR_SEQUENCE_OF) {
if(terminal_structable(arg, expr)) {
expr->marker.flags |= EM_UNRECURSE;
if(arg->expr->expr_type == ASN_CONSTR_SET_OF
|| arg->expr->expr_type == ASN_CONSTR_SEQUENCE_OF) {
/* Don't put EM_INDIRECT even if recursion */
return 1;
}
/* Fall through */
}
}
/* Look for recursive back-references */
ret = expr_defined_recursively(arg, expr);
switch(ret) {
case 2: /* Explicitly break the recursion */
case 1: /* Use safer typing */
expr->marker.flags |= EM_INDIRECT;
expr->marker.flags |= EM_UNRECURSE;
break;
}
return 0;
}
/*
* Check if the type can be represented using simple `struct TYPE`.
*/
static asn1p_expr_t *
terminal_structable(arg_t *arg, asn1p_expr_t *expr) {
asn1p_expr_t *terminal = asn1f_find_terminal_type_ex(arg->asn, expr);
if(terminal
&& !terminal->parent_expr
&& (terminal->expr_type & ASN_CONSTR_MASK)) {
return terminal;
}
return 0;
}
static int
asn1c_recurse(arg_t *arg, asn1p_expr_t *expr, int (*callback)(arg_t *arg, void *key), void *key) {
arg_t tmp = *arg;
int maxret = 0;
int ret;
if(expr->_mark) return 0;
expr->_mark |= TM_RECURSION;
/* Invoke callback for every type going into recursion */
tmp.expr = expr;
maxret = callback(&tmp, key);
if(maxret <= 1) {
/*
* Recursively invoke myself and the callbacks.
*/
TQ_FOR(tmp.expr, &(expr->members), next) {
ret = asn1c_recurse(&tmp, tmp.expr, callback, key);
if(ret > maxret)
maxret = ret;
if(maxret > 1) break;
}
}
expr->_mark &= ~TM_RECURSION;
return maxret;
}
static int
check_is_refer_to(arg_t *arg, void *key) {
asn1p_expr_t *terminal = terminal_structable(arg, arg->expr);
if(terminal == key) {
if(arg->expr->marker.flags & EM_INDIRECT)
return 1; /* This is almost safe indirection */
return 2;
} else if(terminal) {
/* This might be N-step circular loop. Dive into it. */
return asn1c_recurse(arg, terminal, check_is_refer_to, key);
}
return 0;
}
/*
* Check if the possibly inner expression defined recursively.
*/
static int
expr_defined_recursively(arg_t *arg, asn1p_expr_t *expr) {
asn1p_expr_t *terminal;
asn1p_expr_t *topmost;
/* If expression is top-level, there's no way it can be recursive. */
if(expr->parent_expr == 0) return 0;
if(expr->expr_type != A1TC_REFERENCE)
return 0; /* Basic types are never recursive */
terminal = terminal_structable(arg, expr);
if(!terminal) return 0; /* Terminal cannot be indirected */
/* Search for the parent container for the given expression */
topmost = expr;
while(topmost->parent_expr)
topmost = topmost->parent_expr;
/* Look inside the terminal type if it mentions the parent expression */
return asn1c_recurse(arg, terminal, check_is_refer_to, topmost);
}

4
libasn1compiler/asn1c_constraint.c
View File

@ -609,13 +609,13 @@ emit_value_determination_code(arg_t *arg, asn1p_expr_type_e etype, asn1cnst_rang
default:
WARNING("%s:%d: Value cannot be determined "
"for constraint check for %s",
arg->mod->source_file_name,
arg->expr->module->source_file_name,
arg->expr->_lineno,
arg->expr->Identifier
);
OUT_NOINDENT(
"#error %s:%d: Value of %s cannot be determined\n",
arg->mod->source_file_name,
arg->expr->module->source_file_name,
arg->expr->_lineno,
arg->expr->Identifier
);

2
libasn1compiler/asn1c_internal.h
View File

@ -51,7 +51,7 @@ typedef struct arg_s {
struct compiler_streams *target;
asn1p_t *asn;
asn1p_module_t *mod;
//asn1p_module_t *mod;
asn1p_expr_t *expr;
int embed;

5
libasn1compiler/asn1c_misc.c
View File

@ -142,11 +142,10 @@ asn1c_type_name(arg_t *arg, asn1p_expr_t *expr, enum tnfmt _format) {
* 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.expr = asn1f_class_access_ex(arg->asn,
arg->expr->module, arg->expr, expr->reference);
if(tmp.expr) return NULL;
tmp.mod = tmp.expr->module;
return asn1c_type_name(&tmp, tmp.expr, _format);
}

21
libasn1compiler/asn1c_save.c
View File

@ -17,6 +17,7 @@ asn1c_save_compiled_output(arg_t *arg, const char *datadir,
int argc, char **argv) {
asn1c_fdeps_t *deps = 0;
asn1c_fdeps_t *dlist;
asn1p_module_t *mod;
FILE *mkf;
int i;
@ -26,8 +27,8 @@ asn1c_save_compiled_output(arg_t *arg, const char *datadir,
"from %s\n", datadir);
}
TQ_FOR(arg->mod, &(arg->asn->modules), mod_next) {
TQ_FOR(arg->expr, &(arg->mod->members), next) {
TQ_FOR(mod, &(arg->asn->modules), mod_next) {
TQ_FOR(arg->expr, &(mod->members), next) {
if(asn1_lang_map[arg->expr->meta_type]
[arg->expr->expr_type].type_cb) {
if(asn1c_dump_streams(arg, deps))
@ -51,8 +52,8 @@ asn1c_save_compiled_output(arg_t *arg, const char *datadir,
}
fprintf(mkf, "ASN_MODULE_SOURCES=");
TQ_FOR(arg->mod, &(arg->asn->modules), mod_next) {
TQ_FOR(arg->expr, &(arg->mod->members), next) {
TQ_FOR(mod, &(arg->asn->modules), mod_next) {
TQ_FOR(arg->expr, &(mod->members), next) {
if(asn1_lang_map[arg->expr->meta_type]
[arg->expr->expr_type].type_cb) {
fprintf(mkf, "\t\\\n\t%s.c",
@ -61,8 +62,8 @@ asn1c_save_compiled_output(arg_t *arg, const char *datadir,
}
}
fprintf(mkf, "\n\nASN_MODULE_HEADERS=");
TQ_FOR(arg->mod, &(arg->asn->modules), mod_next) {
TQ_FOR(arg->expr, &(arg->mod->members), next) {
TQ_FOR(mod, &(arg->asn->modules), mod_next) {
TQ_FOR(arg->expr, &(mod->members), next) {
if(asn1_lang_map[arg->expr->meta_type]
[arg->expr->expr_type].type_cb) {
fprintf(mkf, "\t\\\n\t%s.h",
@ -208,8 +209,8 @@ asn1c_save_streams(arg_t *arg, asn1c_fdeps_t *deps) {
" * From ASN.1 module \"%s\"\n"
" * \tfound in \"%s\"\n"
" */\n\n",
arg->mod->ModuleName,
arg->mod->source_file_name
expr->module->ModuleName,
expr->module->source_file_name
);
fprintf(fp_h,
"/*\n"
@ -217,8 +218,8 @@ asn1c_save_streams(arg_t *arg, asn1c_fdeps_t *deps) {
" * From ASN.1 module \"%s\"\n"
" * \tfound in \"%s\"\n"
" */\n\n",
arg->mod->ModuleName,
arg->mod->source_file_name
expr->module->ModuleName,
expr->module->source_file_name
);
header_id = asn1c_make_identifier(0, expr->Identifier, NULL);

5
libasn1compiler/asn1compiler.c
View File

@ -12,6 +12,7 @@ asn1_compile(asn1p_t *asn, const char *datadir, enum asn1c_flags flags,
int argc, char **argv) {
arg_t arg_s;
arg_t *arg = &arg_s;
asn1p_module_t *mod;
int ret;
/*
@ -29,8 +30,8 @@ asn1_compile(asn1p_t *asn, const char *datadir, enum asn1c_flags flags,
/*
* Compile each individual top level structure.
*/
TQ_FOR(arg->mod, &(asn->modules), mod_next) {
TQ_FOR(arg->expr, &(arg->mod->members), next) {
TQ_FOR(mod, &(asn->modules), mod_next) {
TQ_FOR(arg->expr, &(mod->members), next) {
compiler_streams_t *cs = NULL;
if(asn1c_attach_streams(arg->expr))

5
libasn1fix/asn1fix_export.c
View File

@ -7,7 +7,6 @@ extern arg_t a1f_replace_me_with_proper_interface_arg;
asn1p_expr_t *
asn1f_lookup_symbol_ex(
asn1p_t *asn,
asn1p_module_t *mod,
asn1p_expr_t *expr,
asn1p_ref_t *ref) {
arg_t arg;
@ -15,13 +14,13 @@ asn1f_lookup_symbol_ex(
memset(&arg, 0, sizeof(arg));
arg.asn = asn;
arg.mod = mod;
arg.mod = expr->module;
arg.expr = expr;
arg.eh = a1f_replace_me_with_proper_interface_arg.eh;
arg.debug = a1f_replace_me_with_proper_interface_arg.debug;
return asn1f_lookup_symbol(&arg, mod, ref);
return asn1f_lookup_symbol(&arg, expr->module, ref);
}
asn1p_expr_t *

1
libasn1fix/asn1fix_export.h
View File

@ -18,7 +18,6 @@ char const *asn1f_printable_value(asn1p_value_t *value);
*/
asn1p_expr_t *asn1f_lookup_symbol_ex(
asn1p_t *asn,
asn1p_module_t *mod,
asn1p_expr_t *expr,
asn1p_ref_t *ref);

11
libasn1parser/asn1p_expr.h
View File

@ -174,11 +174,12 @@ typedef struct asn1p_expr_s {
struct asn1p_expr_marker_s {
enum asn1p_expr_marker_e {
EM_NOMARK,
EM_INDIRECT = 0x01, /* 0001: Represent as pointer */
EM_OPTIONAL = 0x03, /* 0011: Optional member */
EM_DEFAULT = 0x07, /* 0111: default_value */
EM_UNRECURSE = 0x08, /* 1000: Use safe naming */
EM_NOMARK,
EM_INDIRECT = 0x01, /* 00001 Represent as pointer */
EM_OMITABLE = 0x03, /* 00011 May be absent in encoding */
EM_OPTIONAL = 0x07, /* 00111 Optional member */
EM_DEFAULT = 0x0F, /* 01111 default_value */
EM_UNRECURSE = 0x10, /* 10000 Use safe naming */
} flags;
asn1p_value_t *default_value; /* For EM_DEFAULT case */
} marker;

2
tests/30-set-OK.asn1.-P
View File

@ -58,7 +58,7 @@ static asn_TYPE_member_t asn_MBR_T_1[] = {
.memb_constraints = 0, /* Defer constraints checking to the member type */
.name = "s"
},
{ ATF_POINTER, 0, offsetof(struct T, b),
{ ATF_POINTER, 1, offsetof(struct T, b),
.tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
.type = (void *)&asn_DEF_BOOLEAN,

2
tests/31-set-of-OK.asn1.-P
View File

@ -423,7 +423,7 @@ static asn_TYPE_member_t asn_MBR_Stuff_1[] = {
.memb_constraints = 0, /* Defer constraints checking to the member type */
.name = "anything"
},
{ ATF_POINTER, 0, offsetof(struct Stuff, other),
{ ATF_POINTER, 1, offsetof(struct Stuff, other),
.tag = -1 /* Ambiguous tag (CHOICE?) */,
.tag_mode = 0,
.type = (void *)&asn_DEF_other_9,

4
tests/70-xer-test-OK.asn1.-P
View File

@ -542,7 +542,7 @@ static asn_TYPE_member_t asn_MBR_ExtensibleSet_1[] = {
.memb_constraints = 0, /* Defer constraints checking to the member type */
.name = "string"
},
{ ATF_POINTER, 0, offsetof(struct ExtensibleSet, Enum),
{ ATF_POINTER, 1, offsetof(struct ExtensibleSet, Enum),
.tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
.type = (void *)&asn_DEF_enum_4,
@ -637,7 +637,7 @@ static asn_TYPE_member_t asn_MBR_ExtensibleSequence_1[] = {
.memb_constraints = 0, /* Defer constraints checking to the member type */
.name = "integer"
},
{ ATF_POINTER, 0, offsetof(struct ExtensibleSequence, gtime),
{ ATF_POINTER, 1, offsetof(struct ExtensibleSequence, gtime),
.tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
.type = (void *)&asn_DEF_GeneralizedTime,

13
tests/73-circular-OK.asn1.-P
View File

@ -379,7 +379,6 @@ asn_TYPE_descriptor_t asn_DEF_Epyt = {
/*** <<< INCLUDES [Ypet] >>> ***/
#include <Epyt.h>
#include <INTEGER.h>
#include <IA5String.h>
#include <EnumType.h>
@ -401,10 +400,14 @@ typedef enum Ypet_PR {
Ypet_PR_patest2, /* Member patest2 is present */
} Ypet_PR;
/*** <<< FWD-DECLS [Ypet] >>> ***/
struct Epyt;
/*** <<< TYPE-DECLS [Ypet] >>> ***/
typedef struct Ypet {
Epyt_t epyt;
struct Epyt *epyt;
INTEGER_t *plain /* DEFAULT 7 */;
struct senums {
A_SET_OF(EnumType_t) list;
@ -427,6 +430,10 @@ typedef struct Ypet {
extern asn_TYPE_descriptor_t asn_DEF_Ypet;
/*** <<< POST-INCLUDE [Ypet] >>> ***/
#include <Epyt.h>
/*** <<< CTABLES [Ypet] >>> ***/
static int check_permitted_alphabet_6(const void *sptr) {
@ -550,7 +557,7 @@ asn_TYPE_descriptor_t asn_DEF_senums_4 = {
};
static asn_TYPE_member_t asn_MBR_Ypet_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct Ypet, epyt),
{ ATF_POINTER, 0, offsetof(struct Ypet, epyt),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
.tag_mode = 0,
.type = (void *)&asn_DEF_Epyt,

43
tests/92-circular-loops-OK.asn1
View File

@ -14,7 +14,14 @@ BEGIN
Everything ::= SEQUENCE {
ch1 Choice1,
ch2 Choice2,
set Set
ch3 Choice3,
set Set,
a Alpha,
b Beta,
g Gamma,
ot OneTwo,
tt TwoThree,
to ThreeOne
}
-- This type refers to the type directly containing itself.
@ -25,10 +32,19 @@ BEGIN
}
Choice2 ::= CHOICE {
typeref TypeRef,
...,
some3 Everything
}
Choice3 ::= CHOICE {
a SEQUENCE {
aa Everything
},
b Everything,
c SEQUENCE OF Choice3
}
Set ::= SET OF SEQUENCE {
int INTEGER,
set Set,
@ -46,4 +62,29 @@ BEGIN
set Set OPTIONAL
}
TypeRef ::= Sequence
Alpha ::= SEQUENCE {
a Beta,
b SEQUENCE {
b Beta OPTIONAL
}
}
Beta ::= SEQUENCE {
b Alpha OPTIONAL,
g Gamma OPTIONAL
}
Gamma ::= SEQUENCE {
o TwoThree,
a Alpha, -- expected inline
b Beta -- expected inline
}
-- This is a true superdependency.
OneTwo ::= SET { m12 TwoThree }
TwoThree ::= SET { m23 ThreeOne }
ThreeOne ::= SET { m31 OneTwo, g Gamma }
END

1103
tests/92-circular-loops-OK.asn1.-P
View File

File diff suppressed because it is too large Load Diff

1076
tests/92-circular-loops-OK.asn1.-Pfindirect-choice
View File

File diff suppressed because it is too large Load Diff