1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
|
#include "asn1fix_internal.h"
typedef enum field_category {
OFC_INVALID, /* Invalid object field category */
OFC_TYPE,
OFC_FIXED_TYPE_VALUE,
OFC_VARIABLE_TYPE_VALUE,
OFC_FIXED_TYPE_VALUE_SET,
OFC_VARIABLE_TYPE_VALUE_SET,
OFC_INFORMATION_OBJECT,
OFC_INFORMATION_OBJECT_SET,
} field_category_e;
typedef enum object_category {
OC_INVALID,
OC_OBJECT,
OC_OBJECTSET,
} object_category_e;
static field_category_e asn1f_class_field_category(asn1p_expr_t *ofield);
static object_category_e asn1f_class_object_category(asn1p_expr_t *expr);
static asn1p_expr_t *
asn1f_class_dot_lookup(arg_t *arg, asn1p_expr_t *obj, asn1p_ref_t *ref);
asn1p_expr_t *
asn1f_class_access(arg_t *arg, asn1p_module_t *mod, asn1p_ref_t *ref) {
asn1p_expr_t *obj; /* Information Object or Object Set */
object_category_e obj_cat; /* Object category */
//field_category_e field_cat; /* Field category */
asn1p_expr_t *result;
asn1p_ref_t tmpref;
assert(ref->comp_count > 1);
DEBUG("%s(%s) for line %d", __func__,
asn1f_printable_reference(ref),
ref->_lineno);
/*
* Fetch the first part of the reference (OBJECT or ObjectSet).
* OBJECT.&<something>...
* ObjectSet.&<something>...
*/
assert(isupper(ref->components[0].name[0]));
tmpref = *ref;
tmpref.comp_count = 1;
obj = asn1f_lookup_symbol(arg, mod, &tmpref);
if(obj == NULL) {
errno = ESRCH;
return NULL;
}
/*
* Make sure the symbol lexical property (upper-case, lower-case)
* corresponds to the type of the expression returned by
* lookup_symbol().
*/
obj_cat = asn1f_class_object_category(obj);
switch(obj_cat) {
case OC_OBJECT:
case OC_OBJECTSET:
if(ref->components[0].lex_type
== (obj_cat==OC_OBJECT)
? RLT_CAPITALS
: RLT_Uppercase)
break;
/* Fall through */
case OC_INVALID:
WARNING("Symbol \"%s\" is not compatible "
"with referenced expression \"%s\" at line %d",
ref->components[0].name,
obj->Identifier, obj->_lineno);
errno = EPERM;
return NULL;
}
/*
* Find the specified field within the object.
*/
result = asn1f_class_dot_lookup(arg, obj, ref);
if(result == NULL) {
return NULL;
}
//field_cat = asn1f_class_field_category(result);
DEBUG("FILLME: %s", result->Identifier);
return result;
}
static object_category_e
asn1f_class_object_category(asn1p_expr_t *expr) {
switch(expr->meta_type) {
case AMT_OBJECT:
return OC_OBJECT;
case AMT_OBJECTSET:
return OC_OBJECTSET;
case AMT_VALUESET:
if(expr->expr_type == A1TC_REFERENCE
&& expr->reference
&& expr->reference->comp_count == 1
&& expr->reference->components[0].lex_type == RLT_CAPITALS)
{
/* FIXME: use find_terminal_type instead! */
return OC_OBJECTSET;
}
break;
default:
break;
}
return OC_INVALID;
}
static field_category_e
asn1f_class_field_category(asn1p_expr_t *ofield) {
if(ofield->Identifier[0] != '&') {
assert(ofield->Identifier[0] == '&');
return OFC_INVALID;
}
if(isupper(ofield->Identifier[1])) {
if(ofield->reference) {
enum asn1p_ref_lex_type_e lex_type
= ofield->reference->components[0].lex_type;
switch(lex_type) {
case RLT_CAPITALS:
return OFC_INFORMATION_OBJECT_SET;
case RLT_Uppercase:
return OFC_FIXED_TYPE_VALUE_SET;
case RLT_AmpUppercase:
return OFC_VARIABLE_TYPE_VALUE_SET;
default:
break;
}
} else {
if(ofield->expr_type == A1TC_CLASSFIELD)
return OFC_TYPE;
switch(ofield->meta_type) {
case AMT_TYPE:
case AMT_TYPEREF:
return OFC_FIXED_TYPE_VALUE_SET;
default:
break;
}
}
} else {
if(ofield->reference) {
enum asn1p_ref_lex_type_e lex_type
= ofield->reference->components[0].lex_type;
switch(lex_type) {
case RLT_CAPITALS:
return OFC_INFORMATION_OBJECT;
case RLT_Uppercase:
return OFC_FIXED_TYPE_VALUE;
case RLT_AmpUppercase:
return OFC_VARIABLE_TYPE_VALUE;
default:
break;
}
} else {
switch(ofield->meta_type) {
case AMT_TYPE:
case AMT_TYPEREF:
return OFC_FIXED_TYPE_VALUE;
default:
break;
}
}
}
return OFC_INVALID;
}
static asn1p_expr_t *
asn1f_class_dot_lookup(arg_t *arg, asn1p_expr_t *obj, asn1p_ref_t *ref) {
asn1p_expr_t *ofield = NULL; /* Information Object's Field */
field_category_e field_cat; /* Field category */
int comp;
assert(ref->comp_count >= 2);
for(comp = 1 /* sic! */; comp < ref->comp_count; comp++) {
int is_last_component = (comp + 1 == ref->comp_count);
char *comp_name = ref->components[comp].name;
ofield = asn1f_lookup_child(obj, comp_name);
if(ofield == NULL) {
DEBUG("Cannot find field \"%s\" in \"%s\" at line %d",
ref->components[1].name,
obj->Identifier,
obj->_lineno);
}
/*
* Compute the category of the field of
* the information object class.
*/
field_cat = asn1f_class_field_category(ofield);
switch(field_cat) {
case OFC_INVALID:
WARNING("Invalid field category of \"%s\" at line %d",
ofield->Identifier, ofield->_lineno);
errno = EPERM;
return NULL;
case OFC_TYPE:
case OFC_FIXED_TYPE_VALUE:
case OFC_VARIABLE_TYPE_VALUE:
case OFC_FIXED_TYPE_VALUE_SET:
case OFC_VARIABLE_TYPE_VALUE_SET:
if(!is_last_component) {
FATAL("Field name component \"%s\" at line %d "
"specifies non-dereferenceable thing",
comp_name, ref->_lineno);
errno = EPERM;
return NULL;
}
break;
case OFC_INFORMATION_OBJECT:
case OFC_INFORMATION_OBJECT_SET:
obj = ofield;
break;
}
}
assert(ofield);
return ofield;
}
|
