1 #include "asn1fix_internal.h"
2
_compare_value(asn1p_expr_t * expr1,asn1p_expr_t * expr2)3 static int _compare_value(asn1p_expr_t *expr1, asn1p_expr_t *expr2) {
4 if(expr2->value->type == ATV_INTEGER
5 && expr1->value->type == ATV_INTEGER) {
6 return expr2->value->value.v_integer
7 - expr1->value->value.v_integer;
8 } else {
9 return -1;
10 }
11 }
12
13 /*
14 * Check the validity of an INTEGER type.
15 */
16 int
asn1f_fix_integer(arg_t * arg)17 asn1f_fix_integer(arg_t *arg) {
18 asn1p_expr_t *expr = arg->expr;
19 asn1p_expr_t *iv;
20 int rvalue = 0;
21 int ret;
22
23 if(expr->expr_type != ASN_BASIC_INTEGER)
24 return 0; /* Just ignore it */
25
26 DEBUG("(\"%s\", %x) for line %d",
27 expr->Identifier, expr->expr_type, expr->_lineno);
28
29 /*
30 * Scan the integer values in search for inconsistencies.
31 */
32 TQ_FOR(iv, &(expr->members), next) {
33
34 DEBUG("\tItem %s(%s)", iv->Identifier,
35 asn1f_printable_value(iv->value));
36
37 /*
38 * Found "...", check correctness.
39 */
40 if(iv->expr_type == A1TC_EXTENSIBLE) {
41 FATAL("INTEGER %s at line %d: "
42 "Extension marker is not allowed",
43 expr->Identifier,
44 iv->_lineno);
45 rvalue = -1;
46 continue;
47 }
48
49 if(iv->Identifier == NULL
50 || iv->expr_type != A1TC_UNIVERVAL) {
51 FATAL("INTEGER %s at line %d: "
52 "Unsupported enumeration element %s",
53 expr->Identifier,
54 iv->_lineno,
55 iv->Identifier?iv->Identifier:"<Anonymous>"
56 );
57 rvalue = -1;
58 continue;
59 }
60
61 if(iv->value == NULL) {
62 FATAL("INTEGER %s at line %d: "
63 "Value for the identifier %s "
64 "must be set explicitly",
65 expr->Identifier,
66 iv->_lineno,
67 iv->Identifier
68 );
69 rvalue = -1;
70 continue;
71 } else if(iv->value->type == ATV_REFERENCED) {
72 /*
73 * Resolve the value, once and for all.
74 */
75 if(asn1f_value_resolve(arg, iv, 0)) {
76 /* This function will emit messages */
77 rvalue = -1;
78 continue;
79 }
80 }
81
82 if(iv->value->type != ATV_INTEGER) {
83 FATAL("INTEGER %s at line %d: "
84 "Value for the identifier %s "
85 "is not compatible with INTEGER type",
86 expr->Identifier,
87 iv->_lineno);
88 rvalue = -1;
89 continue;
90 }
91
92 /*
93 * Check that all identifiers are distinct.
94 */
95 ret = asn1f_check_unique_expr_child(arg, iv, 0, "identifier");
96 RET2RVAL(ret, rvalue);
97 /*
98 * Check that all values are distinct.
99 */
100 ret = asn1f_check_unique_expr_child(arg, iv,
101 _compare_value, "value");
102 RET2RVAL(ret, rvalue);
103 }
104
105
106 return rvalue;
107 }
108
109 #if 0
110 static int
111 _asn1f_make_sure_type_is(arg_t *arg, asn1p_expr_t *expr, asn1p_expr_type_e type) {
112 asn1p_expr_t *next_expr;
113 asn1p_expr_type_e expr_type;
114 int ret;
115
116 expr_type = expr->expr_type;
117
118 /*
119 * Here we're trying to make sure that the type of the given
120 * expression is really what is expected.
121 * This is ensured in two ways.
122 * First, if the immediate type matches the provided one,
123 * this is a clear hit.
124 */
125 if(expr_type == type)
126 return 0;
127
128 /*
129 * Otherwise, it must be either a reference or a different type.
130 */
131 if(expr_type != A1TC_REFERENCE) {
132 errno = EPERM;
133 return -1;
134 }
135
136 assert(expr_type == A1TC_REFERENCE);
137 assert(expr->reference);
138
139 /*
140 * Then, it is a reference. For a reference, try to resolve type
141 * and try again.
142 */
143 next_expr = asn1f_lookup_symbol(arg, expr->module,
144 expr->rhs_pspecs, expr->reference);
145 if(next_expr == NULL) {
146 errno = ESRCH;
147 return -1;
148 }
149
150 /*
151 * If symbol is here, recursively check that it conforms to the type.
152 */
153 WITH_MODULE(next_expr->module,
154 ret = _asn1f_make_sure_type_is(arg, next_expr, type));
155
156 return ret;
157 }
158 #endif
159
160
161