1
%% ``The contents of this file are subject to the Erlang Public License,
2
%% Version 1.1, (the "License"); you may not use this file except in
3
%% compliance with the License. You should have received a copy of the
4
%% Erlang Public License along with this software. If not, it can be
5
%% retrieved via the world wide web at http://www.erlang.org/.
7
%% Software distributed under the License is distributed on an "AS IS"
8
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
9
%% the License for the specific language governing rights and limitations
12
%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
13
%% Portions created by Ericsson are Copyright 2000, Ericsson Utvecklings
14
%% AB. All Rights Reserved.''
16
%% $Id: asn1ct_parser2.erl,v 1.1 2008/12/17 09:53:30 mikpe Exp $
18
-module(asn1ct_parser2).
21
-include("asn1_records.hrl").
23
%% parse all types in module
25
case catch parse_ModuleDefinition(Tokens) of
27
{error,{{undefined,get(asn1_module),
28
[internal,error,'when',parsing,module,definition,Reason]},
30
{asn1_error,Reason} ->
31
{error,{Reason,hd(Tokens)}};
32
{ModuleDefinition,Rest1} ->
33
{Types,Rest2} = parse_AssignmentList(Rest1),
36
{ok,ModuleDefinition#module{typeorval = Types}};
38
{error,{{get_line(hd(Rest2)),get(asn1_module),
39
[got,get_token(hd(Rest2)),expected,'END']},
44
parse_ModuleDefinition([{typereference,L1,ModuleIdentifier}|Rest0]) ->
45
put(asn1_module,ModuleIdentifier),
46
{_DefinitiveIdentifier,Rest02} =
49
parse_ObjectIdentifierValue(Rest0);
54
[{'DEFINITIONS',_}|Rest03] ->
57
throw({asn1_error,{get_line(hd(Rest02)),get(asn1_module),
58
[got,get_token(hd(Rest02)),
59
expected,'DEFINITIONS']}})
63
[{'EXPLICIT',_L3},{'TAGS',_L4}|Rest1] ->
64
put(tagdefault,'EXPLICIT'), {'EXPLICIT',Rest1};
65
[{'IMPLICIT',_L3},{'TAGS',_L4}|Rest1] ->
66
put(tagdefault,'IMPLICIT'), {'IMPLICIT',Rest1};
67
[{'AUTOMATIC',_L3},{'TAGS',_L4}|Rest1] ->
68
put(tagdefault,'AUTOMATIC'), {'AUTOMATIC',Rest1};
70
put(tagdefault,'EXPLICIT'), {'EXPLICIT',Rest1} % The default
72
{ExtensionDefault,Rest3} =
74
[{'EXTENSIBILITY',_L5}, {'IMPLIED',_L6}|Rest21] ->
79
[{'::=',_L7}, {'BEGIN',_L8}|Rest4] ->
80
{Exports, Rest5} = parse_Exports(Rest4),
81
{Imports, Rest6} = parse_Imports(Rest5),
83
name = ModuleIdentifier,
84
defid = [], % fix this
85
tagdefault = TagDefault,
86
extensiondefault = ExtensionDefault,
88
imports = Imports},Rest6};
89
_ -> throw({asn1_error,{get_line(hd(Rest3)),get(asn1_module),
90
[got,get_token(hd(Rest3)),expected,"::= BEGIN"]}})
92
parse_ModuleDefinition(Tokens) ->
93
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
94
[got,get_token(hd(Tokens)),expected,typereference]}}).
96
parse_Exports([{'EXPORTS',_L1},{';',_L2}|Rest]) ->
98
parse_Exports([{'EXPORTS',_L1}|Rest]) ->
99
{SymbolList,Rest2} = parse_SymbolList(Rest),
102
{{exports,SymbolList},Rest3};
104
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
105
[got,get_token(hd(Rest2)),expected,';']}})
107
parse_Exports(Rest) ->
108
{{exports,all},Rest}.
110
parse_SymbolList(Tokens) ->
111
parse_SymbolList(Tokens,[]).
113
parse_SymbolList(Tokens,Acc) ->
114
{Symbol,Rest} = parse_Symbol(Tokens),
117
parse_SymbolList(Rest2,[Symbol|Acc]);
119
{lists:reverse([Symbol|Acc]),Rest2}
122
parse_Symbol(Tokens) ->
123
parse_Reference(Tokens).
125
parse_Reference([{typereference,L1,TrefName},{'{',_L2},{'}',_L3}|Rest]) ->
127
{tref2Exttref(L1,TrefName),Rest};
128
parse_Reference([Tref1 = {typereference,_,_},{'.',_},Tref2 = {typereference,_,_},
129
{'{',_L2},{'}',_L3}|Rest]) ->
130
% {{Tref1,Tref2},Rest};
131
{{tref2Exttref(Tref1),tref2Exttref(Tref2)},Rest};
132
parse_Reference([Tref = {typereference,_L1,_TrefName}|Rest]) ->
133
{tref2Exttref(Tref),Rest};
134
parse_Reference([Vref = {identifier,_L1,_VName}|Rest]) ->
135
{identifier2Extvalueref(Vref),Rest};
136
parse_Reference(Tokens) ->
137
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
138
[got,get_token(hd(Tokens)),expected,
139
[typereference,identifier]]}}).
141
parse_Imports([{'IMPORTS',_L1},{';',_L2}|Rest]) ->
143
parse_Imports([{'IMPORTS',_L1}|Rest]) ->
144
{SymbolsFromModuleList,Rest2} = parse_SymbolsFromModuleList(Rest),
147
{{imports,SymbolsFromModuleList},Rest3};
149
throw({asn1_error,{get_line(hd(Rest3)),get(asn1_module),
150
[got,get_token(hd(Rest3)),expected,';']}})
152
parse_Imports(Tokens) ->
153
{{imports,[]},Tokens}.
155
parse_SymbolsFromModuleList(Tokens) ->
156
parse_SymbolsFromModuleList(Tokens,[]).
158
parse_SymbolsFromModuleList(Tokens,Acc) ->
159
{SymbolsFromModule,Rest} = parse_SymbolsFromModule(Tokens),
160
case (catch parse_SymbolsFromModule(Rest)) of
161
{Sl,_Rest2} when record(Sl,'SymbolsFromModule') ->
162
parse_SymbolsFromModuleList(Rest,[SymbolsFromModule|Acc]);
164
{lists:reverse([SymbolsFromModule|Acc]),Rest}
167
parse_SymbolsFromModule(Tokens) ->
170
fun(X) when record(X,'Externaltypereference')->
171
X#'Externaltypereference'{module=N};
172
(X) when record(X,'Externalvaluereference')->
173
X#'Externalvaluereference'{module=N}
176
{SymbolList,Rest} = parse_SymbolList(Tokens),
178
%%How does this case correspond to x.680 ?
179
[{'FROM',_L1},Tref = {typereference,_,_},Ref={identifier,_L2,_Id},C={',',_}|Rest2] ->
180
{#'SymbolsFromModule'{symbols=SymbolList,
181
module=tref2Exttref(Tref)},[Ref,C|Rest2]};
182
%%How does this case correspond to x.680 ?
183
[{'FROM',_L1},Tref = {typereference,_,_},{identifier,_L2,_Id}|Rest2] ->
184
{#'SymbolsFromModule'{symbols=SymbolList,
185
module=tref2Exttref(Tref)},Rest2};
186
[{'FROM',_L1},Tref = {typereference,_,Name},Brace = {'{',_}|Rest2] ->
187
{_ObjIdVal,Rest3} = parse_ObjectIdentifierValue([Brace|Rest2]), % value not used yet, fix me
188
NewSymbolList = lists:map(SetRefModuleName(Name),SymbolList),
189
{#'SymbolsFromModule'{symbols=NewSymbolList,
190
module=tref2Exttref(Tref)},Rest3};
191
[{'FROM',_L1},Tref = {typereference,_,Name}|Rest2] ->
192
NewSymbolList = lists:map(SetRefModuleName(Name),SymbolList),
193
{#'SymbolsFromModule'{symbols=NewSymbolList,
194
module=tref2Exttref(Tref)},Rest2};
196
throw({asn1_error,{get_line(hd(Rest)),get(asn1_module),
197
[got,get_token(hd(Rest)),expected,
198
['FROM typerefernece identifier ,',
199
'FROM typereference identifier',
200
'FROM typereference {',
201
'FROM typereference']]}})
204
parse_ObjectIdentifierValue([{'{',_}|Rest]) ->
205
parse_ObjectIdentifierValue(Rest,[]).
207
parse_ObjectIdentifierValue([{number,_,Num}|Rest],Acc) ->
208
parse_ObjectIdentifierValue(Rest,[Num|Acc]);
209
parse_ObjectIdentifierValue([{identifier,_,Id},{'(',_}, {number,_,Num}, {')',_}|Rest],Acc) ->
210
parse_ObjectIdentifierValue(Rest,[{'NamedNumber',Id,Num}|Acc]);
211
parse_ObjectIdentifierValue([{identifier,_,Id},{'(',_}, {identifier,_,Id2}, {')',_}|Rest],Acc) ->
212
parse_ObjectIdentifierValue(Rest,[{'NamedNumber',Id,Id2}|Acc]);
213
parse_ObjectIdentifierValue([{identifier,_,Id},{'(',_}, {typereference,_,Tref},{'.',_},{identifier,_,Id2}, {')',_}|Rest],Acc) ->
214
parse_ObjectIdentifierValue(Rest,[{'NamedNumber',Id,{'ExternalValue',Tref,Id2}}|Acc]);
215
parse_ObjectIdentifierValue([Id = {identifier,_,_}|Rest],Acc) ->
216
parse_ObjectIdentifierValue(Rest,[identifier2Extvalueref(Id)|Acc]);
217
parse_ObjectIdentifierValue([{'}',_}|Rest],Acc) ->
218
{lists:reverse(Acc),Rest};
219
parse_ObjectIdentifierValue([H|_T],_Acc) ->
220
throw({asn1_error,{get_line(H),get(asn1_module),
221
[got,get_token(H),expected,
222
['{ some of the following }',number,'identifier ( number )',
223
'identifier ( identifier )',
224
'identifier ( typereference.identifier)',identifier]]}}).
226
parse_AssignmentList(Tokens = [{'END',_}|_Rest]) ->
228
parse_AssignmentList(Tokens = [{'$end',_}|_Rest]) ->
230
parse_AssignmentList(Tokens) ->
231
parse_AssignmentList(Tokens,[]).
233
parse_AssignmentList(Tokens= [{'END',_}|_Rest],Acc) ->
234
{lists:reverse(Acc),Tokens};
235
parse_AssignmentList(Tokens= [{'$end',_}|_Rest],Acc) ->
236
{lists:reverse(Acc),Tokens};
237
parse_AssignmentList(Tokens,Acc) ->
238
case (catch parse_Assignment(Tokens)) of
243
throw({error,{R,hd(Tokens)}});
245
parse_AssignmentList(Rest,[Assignment|Acc])
248
parse_Assignment(Tokens) ->
249
Flist = [fun parse_TypeAssignment/1,
250
fun parse_ValueAssignment/1,
251
fun parse_ObjectClassAssignment/1,
252
fun parse_ObjectAssignment/1,
253
fun parse_ObjectSetAssignment/1,
254
fun parse_ParameterizedAssignment/1,
255
fun parse_ValueSetTypeAssignment/1],
256
case (catch parse_or(Tokens,Flist)) of
259
AsnErr = {asn1_error,_} ->
261
{asn1_assignment_error,Reason} ->
262
throw({asn1_error,Reason});
268
parse_or(Tokens,Flist) ->
269
parse_or(Tokens,Flist,[]).
271
parse_or(_Tokens,[],ErrList) ->
274
throw({asn1_error,{parse_or,ErrList}});
276
%%% throw({asn1_error,{parse_or,hd(lists:reverse(ErrList))}});
277
%% chose to throw 1) the error with the highest line no,
278
%% 2) the last error which is not a asn1_assignment_error or
279
%% 3) the last error.
280
throw(prioritize_error(ErrList));
282
throw({asn1_error,{parse_or,Other}})
284
parse_or(Tokens,[Fun|Frest],ErrList) ->
285
case (catch Fun(Tokens)) of
286
Exit = {'EXIT',_Reason} ->
287
parse_or(Tokens,Frest,[Exit|ErrList]);
288
AsnErr = {asn1_error,_} ->
289
parse_or(Tokens,Frest,[AsnErr|ErrList]);
290
AsnAssErr = {asn1_assignment_error,_} ->
291
parse_or(Tokens,Frest,[AsnAssErr|ErrList]);
292
Result = {_,L} when list(L) ->
297
parse_or(Tokens,Frest,[Error|ErrList])
300
parse_TypeAssignment([{typereference,L1,Tref},{'::=',_}|Rest]) ->
301
{Type,Rest2} = parse_Type(Rest),
302
{#typedef{pos=L1,name=Tref,typespec=Type},Rest2};
303
parse_TypeAssignment([H1,H2|_Rest]) ->
304
throw({asn1_assignment_error,{get_line(H1),get(asn1_module),
305
[got,[get_token(H1),get_token(H2)], expected,
306
typereference,'::=']}});
307
parse_TypeAssignment([H|_T]) ->
308
throw({asn1_assignment_error,{get_line(H),get(asn1_module),
309
[got,get_token(H),expected,
312
parse_Type(Tokens) ->
313
{Tag,Rest3} = case Tokens of
314
[Lbr= {'[',_}|Rest] ->
315
parse_Tag([Lbr|Rest]);
318
{Tag2,Rest4} = case Rest3 of
319
[{'IMPLICIT',_}|Rest31] when record(Tag,tag)->
320
{[Tag#tag{type='IMPLICIT'}],Rest31};
321
[{'EXPLICIT',_}|Rest31] when record(Tag,tag)->
322
{[Tag#tag{type='EXPLICIT'}],Rest31};
323
Rest31 when record(Tag,tag) ->
324
{[Tag#tag{type={default,get(tagdefault)}}],Rest31};
328
Flist = [fun parse_BuiltinType/1,fun parse_ReferencedType/1,fun parse_TypeWithConstraint/1],
329
{Type,Rest5} = case (catch parse_or(Rest4,Flist)) of
332
AsnErr = {asn1_error,_Reason} ->
339
{Constraints,Rest6} = parse_Constraints(Rest5),
340
if record(Type,type) ->
341
{Type#type{constraint=merge_constraints(Constraints),
344
{#type{def=Type,constraint=merge_constraints(Constraints),
348
if record(Type,type) ->
349
{Type#type{tag=Tag2},Rest5};
351
{#type{def=Type,tag=Tag2},Rest5}
355
parse_BuiltinType([{'BIT',_},{'STRING',_}|Rest]) ->
358
{NamedNumberList,Rest3} = parse_NamedNumberList(Rest2),
361
{#type{def={'BIT STRING',NamedNumberList}},Rest4};
363
throw({asn1_error,{get_line(hd(Rest3)),get(asn1_module),
364
[got,get_token(hd(Rest3)),expected,'}']}})
367
{{'BIT STRING',[]},Rest}
369
parse_BuiltinType([{'BOOLEAN',_}|Rest]) ->
370
{#type{def='BOOLEAN'},Rest};
371
%% CharacterStringType ::= RestrictedCharacterStringType |
372
%% UnrestrictedCharacterStringType
373
parse_BuiltinType([{restrictedcharacterstringtype,_,StringName}|Rest]) ->
374
{#type{def=StringName},Rest};
375
parse_BuiltinType([{'CHARACTER',_},{'STRING',_}|Rest]) ->
376
{#type{def='CHARACTER STRING'},Rest};
378
parse_BuiltinType([{'CHOICE',_},{'{',_}|Rest]) ->
379
{AlternativeTypeLists,Rest2} = parse_AlternativeTypeLists(Rest),
382
{#type{def={'CHOICE',AlternativeTypeLists}},Rest3};
384
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
385
[got,get_token(hd(Rest2)),expected,'}']}})
387
parse_BuiltinType([{'EMBEDDED',_},{'PDV',_}|Rest]) ->
388
{#type{def='EMBEDDED PDV'},Rest};
389
parse_BuiltinType([{'ENUMERATED',_},{'{',_}|Rest]) ->
390
{Enumerations,Rest2} = parse_Enumerations(Rest),
393
{#type{def={'ENUMERATED',Enumerations}},Rest3};
395
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
396
[got,get_token(hd(Rest2)),expected,'}']}})
398
parse_BuiltinType([{'EXTERNAL',_}|Rest]) ->
399
{#type{def='EXTERNAL'},Rest};
402
parse_BuiltinType([{'INSTANCE',_},{'OF',_}|Rest]) ->
403
{DefinedObjectClass,Rest2} = parse_DefinedObjectClass(Rest),
406
{Constraint,Rest3} = parse_Constraint(Rest2),
407
{#type{def={'INSTANCE OF',DefinedObjectClass,Constraint}},Rest3};
409
{#type{def={'INSTANCE OF',DefinedObjectClass,[]}},Rest2}
412
% parse_BuiltinType(Tokens) ->
414
parse_BuiltinType([{'INTEGER',_}|Rest]) ->
417
{NamedNumberList,Rest3} = parse_NamedNumberList(Rest2),
420
{#type{def={'INTEGER',NamedNumberList}},Rest4};
422
throw({asn1_error,{get_line(hd(Rest3)),get(asn1_module),
423
[got,get_token(hd(Rest3)),expected,'}']}})
426
{#type{def='INTEGER'},Rest}
428
parse_BuiltinType([{'NULL',_}|Rest]) ->
429
{#type{def='NULL'},Rest};
431
% ObjectClassFieldType fix me later
433
parse_BuiltinType([{'OBJECT',_},{'IDENTIFIER',_}|Rest]) ->
434
{#type{def='OBJECT IDENTIFIER'},Rest};
435
parse_BuiltinType([{'OCTET',_},{'STRING',_}|Rest]) ->
436
{#type{def='OCTET STRING'},Rest};
437
parse_BuiltinType([{'REAL',_}|Rest]) ->
438
{#type{def='REAL'},Rest};
439
parse_BuiltinType([{'SEQUENCE',_},{'{',_},{'...',Line},{'}',_}|Rest]) ->
440
{#type{def=#'SEQUENCE'{components=[{'EXTENSIONMARK',Line,undefined}]}},
442
parse_BuiltinType([{'SEQUENCE',_},{'{',_},{'...',Line},{'!',_}|Rest]) ->
443
{ExceptionIdentification,Rest2} = parse_ExceptionIdentification(Rest),
446
{#type{def=#'SEQUENCE'{components=[{'EXTENSIONMARK',
448
ExceptionIdentification}]}},
451
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
452
[got,get_token(hd(Rest2)),expected,'}']}})
454
parse_BuiltinType([{'SEQUENCE',_},{'{',_}|Rest]) ->
455
{ComponentTypeLists,Rest2} = parse_ComponentTypeLists(Rest),
458
{#type{def=#'SEQUENCE'{components=ComponentTypeLists}},Rest3};
460
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
461
[got,get_token(hd(Rest2)),expected,'}']}})
463
parse_BuiltinType([{'SEQUENCE',_},{'OF',_}|Rest]) ->
464
{Type,Rest2} = parse_Type(Rest),
465
{#type{def={'SEQUENCE OF',Type}},Rest2};
468
parse_BuiltinType([{'SET',_},{'{',_},{'...',Line},{'}',_}|Rest]) ->
469
{#type{def=#'SET'{components=[{'EXTENSIONMARK',Line,undefined}]}},Rest};
470
parse_BuiltinType([{'SET',_},{'{',_},{'...',Line},{'!',_}|Rest]) ->
471
{ExceptionIdentification,Rest2} = parse_ExceptionIdentification(Rest),
474
{#type{def=#'SET'{components=
475
[{'EXTENSIONMARK',Line,ExceptionIdentification}]}},
478
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
479
[got,get_token(hd(Rest2)),expected,'}']}})
481
parse_BuiltinType([{'SET',_},{'{',_}|Rest]) ->
482
{ComponentTypeLists,Rest2} = parse_ComponentTypeLists(Rest),
485
{#type{def=#'SET'{components=ComponentTypeLists}},Rest3};
487
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
488
[got,get_token(hd(Rest2)),expected,'}']}})
490
parse_BuiltinType([{'SET',_},{'OF',_}|Rest]) ->
491
{Type,Rest2} = parse_Type(Rest),
492
{#type{def={'SET OF',Type}},Rest2};
494
%% The so called Useful types
495
parse_BuiltinType([{'GeneralizedTime',_}|Rest]) ->
496
{#type{def='GeneralizedTime'},Rest};
497
parse_BuiltinType([{'UTCTime',_}|Rest]) ->
498
{#type{def='UTCTime'},Rest};
499
parse_BuiltinType([{'ObjectDescriptor',_}|Rest]) ->
500
{#type{def='ObjectDescriptor'},Rest};
502
%% For compatibility with old standard
503
parse_BuiltinType([{'ANY',_},{'DEFINED',_},{'BY',_},{identifier,_,Id}|Rest]) ->
504
{#type{def={'ANY_DEFINED_BY',Id}},Rest};
505
parse_BuiltinType([{'ANY',_}|Rest]) ->
506
{#type{def='ANY'},Rest};
508
parse_BuiltinType(Tokens) ->
509
parse_ObjectClassFieldType(Tokens).
510
% throw({asn1_error,unhandled_type}).
513
parse_TypeWithConstraint([{'SEQUENCE',_},Lpar = {'(',_}|Rest]) ->
514
{Constraint,Rest2} = parse_Constraint([Lpar|Rest]),
517
{Type,Rest4} = parse_Type(Rest3),
518
{#type{def = {'SEQUENCE OF',Type}, constraint = merge_constraints([Constraint])},Rest4};
520
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
521
[got,get_token(hd(Rest2)),expected,'OF']}})
523
parse_TypeWithConstraint([{'SEQUENCE',_},{'SIZE',_},Lpar = {'(',_}|Rest]) ->
524
{Constraint,Rest2} = parse_Constraint([Lpar|Rest]),
528
Constraint#constraint{c={'SizeConstraint',C}};
533
{Type,Rest4} = parse_Type(Rest3),
534
{#type{def = {'SEQUENCE OF',Type}, constraint = merge_constraints([Constraint2])},Rest4};
536
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
537
[got,get_token(hd(Rest2)),expected,'OF']}})
539
parse_TypeWithConstraint([{'SET',_},Lpar = {'(',_}|Rest]) ->
540
{Constraint,Rest2} = parse_Constraint([Lpar|Rest]),
543
{Type,Rest4} = parse_Type(Rest3),
544
{#type{def = {'SET OF',Type}, constraint = merge_constraints([Constraint])},Rest4};
546
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
547
[got,get_token(hd(Rest2)),expected,'OF']}})
549
parse_TypeWithConstraint([{'SET',_},{'SIZE',_},Lpar = {'(',_}|Rest]) ->
550
{Constraint,Rest2} = parse_Constraint([Lpar|Rest]),
554
Constraint#constraint{c={'SizeConstraint',C}};
559
{Type,Rest4} = parse_Type(Rest3),
560
{#type{def = {'SET OF',Type}, constraint = merge_constraints([Constraint2])},Rest4};
562
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
563
[got,get_token(hd(Rest2)),expected,'OF']}})
565
parse_TypeWithConstraint(Tokens) ->
566
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
567
[got,get_token(hd(Tokens)),expected,
568
['SEQUENCE','SEQUENCE SIZE','SET','SET SIZE'],
569
followed,by,a,constraint]}}).
572
%% --------------------------
574
parse_ReferencedType(Tokens) ->
575
Flist = [fun parse_DefinedType/1,
576
fun parse_SelectionType/1,
577
fun parse_TypeFromObject/1,
578
fun parse_ValueSetFromObjects/1],
579
case (catch parse_or(Tokens,Flist)) of
582
AsnErr = {asn1_error,_} ->
588
parse_DefinedType(Tokens=[{typereference,_,_},{'{',_}|_Rest]) ->
589
parse_ParameterizedType(Tokens);
590
parse_DefinedType(Tokens=[{typereference,L1,TypeName},
591
T2={typereference,_,_},T3={'{',_}|Rest]) ->
592
case (catch parse_ParameterizedType(Tokens)) of
594
Rest2 = [T2,T3|Rest],
595
{#type{def = #'Externaltypereference'{pos=L1,
596
module=get(asn1_module),
597
type=TypeName}},Rest2};
599
Rest2 = [T2,T3|Rest],
600
{#type{def = #'Externaltypereference'{pos=L1,
601
module=get(asn1_module),
602
type=TypeName}},Rest2};
606
parse_DefinedType([{typereference,L1,Module},{'.',_},{typereference,_,TypeName}|Rest]) ->
607
{#type{def = #'Externaltypereference'{pos=L1,module=Module,type=TypeName}},Rest};
608
parse_DefinedType([{typereference,L1,TypeName}|Rest]) ->
609
{#type{def = #'Externaltypereference'{pos=L1,module=get(asn1_module),
610
type=TypeName}},Rest};
611
parse_DefinedType(Tokens) ->
612
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
613
[got,get_token(hd(Tokens)),expected,
614
[typereference,'typereference.typereference',
615
'typereference typereference']]}}).
617
parse_SelectionType([{identifier,_,Name},{'<',_}|Rest]) ->
618
{Type,Rest2} = parse_Type(Rest),
619
{{'SelectionType',Name,Type},Rest2};
620
parse_SelectionType(Tokens) ->
621
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
622
[got,get_token(hd(Tokens)),expected,'identifier <']}}).
625
%% --------------------------
628
%% This should probably be removed very soon
629
% parse_ConstrainedType(Tokens) ->
630
% case (catch parse_TypeWithConstraint(Tokens)) of
632
% {Type,Rest} = parse_Type(Tokens),
633
% {Constraint,Rest2} = parse_Constraint(Rest),
634
% {Type#type{constraint=Constraint},Rest2};
635
% {asn1_error,Reason2} ->
636
% {Type,Rest} = parse_Type(Tokens),
637
% {Constraint,Rest2} = parse_Constraint(Rest),
638
% {Type#type{constraint=Constraint},Rest2};
643
parse_Constraints(Tokens) ->
644
parse_Constraints(Tokens,[]).
646
parse_Constraints(Tokens,Acc) ->
647
{Constraint,Rest} = parse_Constraint(Tokens),
650
parse_Constraints(Rest,[Constraint|Acc]);
652
{lists:reverse([Constraint|Acc]),Rest}
655
parse_Constraint([{'(',_}|Rest]) ->
656
{Constraint,Rest2} = parse_ConstraintSpec(Rest),
657
{Exception,Rest3} = parse_ExceptionSpec(Rest2),
660
{#constraint{c=Constraint,e=Exception},Rest4};
662
throw({asn1_error,{get_line(H),get(asn1_module),
663
[got,get_token(H),expected,')']}})
665
parse_Constraint(Tokens) ->
666
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
667
[got,get_token(hd(Tokens)),expected,'(']}}).
669
parse_ConstraintSpec(Tokens) ->
670
Flist = [fun parse_GeneralConstraint/1,
671
fun parse_SubtypeConstraint/1],
672
case (catch parse_or(Tokens,Flist)) of
675
{asn1_error,Reason2} ->
676
throw({asn1_error,Reason2});
681
parse_ExceptionSpec([LPar={')',_}|Rest]) ->
682
{undefined,[LPar|Rest]};
683
parse_ExceptionSpec([{'!',_}|Rest]) ->
684
parse_ExceptionIdentification(Rest);
685
parse_ExceptionSpec(Tokens) ->
686
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
687
[got,get_token(hd(Tokens)),expected,[')','!']]}}).
689
parse_ExceptionIdentification(Tokens) ->
690
Flist = [fun parse_SignedNumber/1,
691
fun parse_DefinedValue/1,
692
fun parse_TypeColonValue/1],
693
case (catch parse_or(Tokens,Flist)) of
696
{asn1_error,Reason2} ->
697
throw({asn1_error,Reason2});
702
parse_TypeColonValue(Tokens) ->
703
{Type,Rest} = parse_Type(Tokens),
706
{Value,Rest3} = parse_Value(Rest2),
707
{{Type,Value},Rest3};
709
throw({asn1_error,{get_line(H),get(asn1_module),
710
[got,get_token(H),expected,':']}})
713
parse_SubtypeConstraint(Tokens) ->
714
parse_ElementSetSpecs(Tokens).
716
parse_ElementSetSpecs([{'...',_}|Rest]) ->
717
{Elements,Rest2} = parse_ElementSetSpec(Rest),
718
{{[],Elements},Rest2};
719
parse_ElementSetSpecs(Tokens) ->
720
{RootElems,Rest} = parse_ElementSetSpec(Tokens),
722
[{',',_},{'...',_},{',',_}|Rest2] ->
723
{AdditionalElems,Rest3} = parse_ElementSetSpec(Rest2),
724
{{RootElems,AdditionalElems},Rest3};
725
[{',',_},{'...',_}|Rest2] ->
726
{{RootElems,[]},Rest2};
731
parse_ElementSetSpec([{'ALL',_},{'EXCEPT',_}|Rest]) ->
732
{Exclusions,Rest2} = parse_Elements(Rest),
733
{{'ALL',{'EXCEPT',Exclusions}},Rest2};
734
parse_ElementSetSpec(Tokens) ->
735
parse_Unions(Tokens).
738
parse_Unions(Tokens) ->
739
{InterSec,Rest} = parse_Intersections(Tokens),
740
{Unions,Rest2} = parse_UnionsRec(Rest),
741
case {InterSec,Unions} of
744
{{'SingleValue',V1},{'SingleValue',V2}} ->
745
{{'SingleValue',ordsets:union(to_set(V1),to_set(V2))},Rest2};
746
{V1,V2} when list(V2) ->
747
{[V1] ++ [union|V2],Rest2};
749
{[V1,union,V2],Rest2}
754
parse_UnionsRec([{'|',_}|Rest]) ->
755
{InterSec,Rest2} = parse_Intersections(Rest),
756
{URec,Rest3} = parse_UnionsRec(Rest2),
757
case {InterSec,URec} of
760
{{'SingleValue',V1},{'SingleValue',V2}} ->
761
{{'SingleValue',ordsets:union(to_set(V1),to_set(V2))},Rest3};
762
{V1,V2} when list(V2) ->
767
parse_UnionsRec([{'UNION',_}|Rest]) ->
768
{InterSec,Rest2} = parse_Intersections(Rest),
769
{URec,Rest3} = parse_UnionsRec(Rest2),
770
case {InterSec,URec} of
773
{{'SingleValue',V1},{'SingleValue',V2}} ->
774
{{'SingleValue',ordsets:union(to_set(V1),to_set(V2))},Rest3};
775
{V1,V2} when list(V2) ->
780
parse_UnionsRec(Tokens) ->
783
parse_Intersections(Tokens) ->
784
{InterSec,Rest} = parse_IntersectionElements(Tokens),
785
{IRec,Rest2} = parse_IElemsRec(Rest),
786
case {InterSec,IRec} of
789
{{'SingleValue',V1},{'SingleValue',V2}} ->
791
ordsets:intersection(to_set(V1),to_set(V2))},Rest2};
792
{V1,V2} when list(V2) ->
793
{[V1] ++ [intersection|V2],Rest2};
795
{[V1,intersection,V2],Rest2};
797
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
798
[got,get_token(hd(Tokens)),expected,'a Union']}})
801
parse_IElemsRec([{'^',_}|Rest]) ->
802
{InterSec,Rest2} = parse_IntersectionElements(Rest),
803
{IRec,Rest3} = parse_IElemsRec(Rest2),
804
case {InterSec,IRec} of
805
{{'SingleValue',V1},{'SingleValue',V2}} ->
807
ordsets:intersection(to_set(V1),to_set(V2))},Rest3};
810
{V1,V2} when list(V2) ->
815
throw({asn1_error,{get_line(hd(Rest)),get(asn1_module),
816
[got,get_token(hd(Rest)),expected,'an Intersection']}})
818
parse_IElemsRec([{'INTERSECTION',_}|Rest]) ->
819
{InterSec,Rest2} = parse_IntersectionElements(Rest),
820
{IRec,Rest3} = parse_IElemsRec(Rest2),
821
case {InterSec,IRec} of
822
{{'SingleValue',V1},{'SingleValue',V2}} ->
824
ordsets:intersection(to_set(V1),to_set(V2))},Rest3};
827
{V1,V2} when list(V2) ->
832
throw({asn1_error,{get_line(hd(Rest)),get(asn1_module),
833
[got,get_token(hd(Rest)),expected,'an Intersection']}})
835
parse_IElemsRec(Tokens) ->
838
parse_IntersectionElements(Tokens) ->
839
{InterSec,Rest} = parse_Elements(Tokens),
841
[{'EXCEPT',_}|Rest2] ->
842
{Exclusion,Rest3} = parse_Elements(Rest2),
843
{{InterSec,{'EXCEPT',Exclusion}},Rest3};
848
parse_Elements([{'(',_}|Rest]) ->
849
{Elems,Rest2} = parse_ElementSetSpec(Rest),
854
throw({asn1_error,{get_line(H),get(asn1_module),
855
[got,get_token(H),expected,')']}})
857
parse_Elements(Tokens) ->
858
Flist = [fun parse_SubtypeElements/1,
859
fun parse_ObjectSetElements/1],
860
case (catch parse_or(Tokens,Flist)) of
863
Err = {asn1_error,_} ->
872
%% --------------------------
874
parse_DefinedObjectClass([{typereference,_,_ModName},{'.',_},Tr={typereference,_,_ObjClName}|Rest]) ->
875
%% {{objectclassname,ModName,ObjClName},Rest};
876
% {{objectclassname,tref2Exttref(Tr)},Rest};
877
{tref2Exttref(Tr),Rest};
878
parse_DefinedObjectClass([Tr={typereference,_,_ObjClName}|Rest]) ->
879
% {{objectclassname,tref2Exttref(Tr)},Rest};
880
{tref2Exttref(Tr),Rest};
881
parse_DefinedObjectClass([{'TYPE-IDENTIFIER',_}|Rest]) ->
882
{'TYPE-IDENTIFIER',Rest};
883
parse_DefinedObjectClass([{'ABSTRACT-SYNTAX',_}|Rest]) ->
884
{'ABSTRACT-SYNTAX',Rest};
885
parse_DefinedObjectClass(Tokens) ->
886
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
887
[got,get_token(hd(Tokens)),expected,
888
['typereference . typereference',
891
'ABSTRACT-SYNTAX']]}}).
893
parse_ObjectClassAssignment([{typereference,L1,ObjClName},{'::=',_}|Rest]) ->
894
{Type,Rest2} = parse_ObjectClass(Rest),
895
{#classdef{pos=L1,name=ObjClName,typespec=Type},Rest2};
896
parse_ObjectClassAssignment(Tokens) ->
897
throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
898
[got,get_token(hd(Tokens)),expected,
899
'typereference ::=']}}).
901
parse_ObjectClass(Tokens) ->
902
Flist = [fun parse_DefinedObjectClass/1,
903
fun parse_ObjectClassDefn/1,
904
fun parse_ParameterizedObjectClass/1],
905
case (catch parse_or(Tokens,Flist)) of
908
{asn1_error,Reason2} ->
909
throw({asn1_error,Reason2});
914
parse_ObjectClassDefn([{'CLASS',_},{'{',_}|Rest]) ->
915
{Type,Rest2} = parse_FieldSpec(Rest),
916
{WithSyntaxSpec,Rest3} = parse_WithSyntaxSpec(Rest2),
917
{#objectclass{fields=Type,syntax=WithSyntaxSpec},Rest3};
918
parse_ObjectClassDefn(Tokens) ->
919
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
920
[got,get_token(hd(Tokens)),expected,'CLASS {']}}).
922
parse_FieldSpec(Tokens) ->
923
parse_FieldSpec(Tokens,[]).
925
parse_FieldSpec(Tokens,Acc) ->
926
Flist = [fun parse_FixedTypeValueFieldSpec/1,
927
fun parse_VariableTypeValueFieldSpec/1,
928
fun parse_ObjectFieldSpec/1,
929
fun parse_FixedTypeValueSetFieldSpec/1,
930
fun parse_VariableTypeValueSetFieldSpec/1,
931
fun parse_TypeFieldSpec/1,
932
fun parse_ObjectSetFieldSpec/1],
933
case (catch parse_or(Tokens,Flist)) of
936
AsnErr = {asn1_error,_} ->
938
{Type,[{'}',_}|Rest]} ->
939
{lists:reverse([Type|Acc]),Rest};
940
{Type,[{',',_}|Rest2]} ->
941
parse_FieldSpec(Rest2,[Type|Acc]);
943
throw({asn1_error,{get_line(H),get(asn1_module),
944
[got,get_token(H),expected,'}']}})
947
parse_PrimitiveFieldName([{typefieldreference,_,FieldName}|Rest]) ->
948
{{typefieldreference,FieldName},Rest};
949
parse_PrimitiveFieldName([{valuefieldreference,_,FieldName}|Rest]) ->
950
{{valuefieldreference,FieldName},Rest};
951
parse_PrimitiveFieldName(Tokens) ->
952
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
953
[got,get_token(hd(Tokens)),expected,
954
[typefieldreference,valuefieldreference]]}}).
956
parse_FieldName(Tokens) ->
957
{Field,Rest} = parse_PrimitiveFieldName(Tokens),
958
parse_FieldName(Rest,[Field]).
960
parse_FieldName([{'.',_}|Rest],Acc) ->
961
case (catch parse_PrimitiveFieldName(Rest)) of
964
AsnErr = {asn1_error,_} ->
967
parse_FieldName(Rest2,[FieldName|Acc])
969
parse_FieldName(Tokens,Acc) ->
970
{lists:reverse(Acc),Tokens}.
972
parse_FixedTypeValueFieldSpec([{valuefieldreference,L1,VFieldName}|Rest]) ->
973
{Type,Rest2} = parse_Type(Rest),
976
[{'UNIQUE',_}|Rest4] ->
981
{OptionalitySpec,Rest5} = parse_ValueOptionalitySpec(Rest3),
984
case OptionalitySpec of
987
{L1,get(asn1_module),
988
['UNIQUE and DEFAULT in same field',VFieldName]}});
990
{{fixedtypevaluefield,VFieldName,Type,Unique,OptionalitySpec},Rest5}
993
{{object_or_fixedtypevalue_field,VFieldName,Type,Unique,OptionalitySpec},Rest5}
995
parse_FixedTypeValueFieldSpec(Tokens) ->
996
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
997
[got,get_token(hd(Tokens)),expected,valuefieldreference]}}).
999
parse_VariableTypeValueFieldSpec([{valuefieldreference,_,VFieldName}|Rest]) ->
1000
{FieldRef,Rest2} = parse_FieldName(Rest),
1001
{OptionalitySpec,Rest3} = parse_ValueOptionalitySpec(Rest2),
1002
{{variabletypevaluefield,VFieldName,FieldRef,OptionalitySpec},Rest3};
1003
parse_VariableTypeValueFieldSpec(Tokens) ->
1004
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1005
[got,get_token(hd(Tokens)),expected,valuefieldreference]}}).
1007
parse_ObjectFieldSpec([{valuefieldreference,_,VFieldName}|Rest]) ->
1008
{Class,Rest2} = parse_DefinedObjectClass(Rest),
1009
{OptionalitySpec,Rest3} = parse_ObjectOptionalitySpec(Rest2),
1010
{{objectfield,VFieldName,Class,OptionalitySpec},Rest3};
1011
parse_ObjectFieldSpec(Tokens) ->
1012
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1013
[got,get_token(hd(Tokens)),expected,valuefieldreference]}}).
1015
parse_TypeFieldSpec([{typefieldreference,_,TFieldName}|Rest]) ->
1016
{OptionalitySpec,Rest2} = parse_TypeOptionalitySpec(Rest),
1017
{{typefield,TFieldName,OptionalitySpec},Rest2};
1018
parse_TypeFieldSpec(Tokens) ->
1019
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1020
[got,get_token(hd(Tokens)),expected,typefieldreference]}}).
1022
parse_FixedTypeValueSetFieldSpec([{typefieldreference,_,TFieldName}|Rest]) ->
1023
{Type,Rest2} = parse_Type(Rest),
1024
{OptionalitySpec,Rest3} = parse_ValueSetOptionalitySpec(Rest2),
1025
{{objectset_or_fixedtypevalueset_field,TFieldName,Type,
1026
OptionalitySpec},Rest3};
1027
parse_FixedTypeValueSetFieldSpec(Tokens) ->
1028
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1029
[got,get_token(hd(Tokens)),expected,typefieldreference]}}).
1031
parse_VariableTypeValueSetFieldSpec([{typefieldreference,_,TFieldName}|Rest]) ->
1032
{FieldRef,Rest2} = parse_FieldName(Rest),
1033
{OptionalitySpec,Rest3} = parse_ValueSetOptionalitySpec(Rest2),
1034
{{variabletypevaluesetfield,TFieldName,FieldRef,OptionalitySpec},Rest3};
1035
parse_VariableTypeValueSetFieldSpec(Tokens) ->
1036
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1037
[got,get_token(hd(Tokens)),expected,typefieldreference]}}).
1039
parse_ObjectSetFieldSpec([{typefieldreference,_,TFieldName}|Rest]) ->
1040
{Class,Rest2} = parse_DefinedObjectClass(Rest),
1041
{OptionalitySpec,Rest3} = parse_ObjectSetOptionalitySpec(Rest2),
1042
{{objectsetfield,TFieldName,Class,OptionalitySpec},Rest3};
1043
parse_ObjectSetFieldSpec(Tokens) ->
1044
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1045
[got,get_token(hd(Tokens)),expected,typefieldreference]}}).
1047
parse_ValueOptionalitySpec(Tokens)->
1049
[{'OPTIONAL',_}|Rest] -> {'OPTIONAL',Rest};
1050
[{'DEFAULT',_}|Rest] ->
1051
{Value,Rest2} = parse_Value(Rest),
1052
{{'DEFAULT',Value},Rest2};
1053
_ -> {'MANDATORY',Tokens}
1056
parse_ObjectOptionalitySpec(Tokens) ->
1058
[{'OPTIONAL',_}|Rest] -> {'OPTIONAL',Rest};
1059
[{'DEFAULT',_}|Rest] ->
1060
{Object,Rest2} = parse_Object(Rest),
1061
{{'DEFAULT',Object},Rest2};
1062
_ -> {'MANDATORY',Tokens}
1065
parse_TypeOptionalitySpec(Tokens) ->
1067
[{'OPTIONAL',_}|Rest] -> {'OPTIONAL',Rest};
1068
[{'DEFAULT',_}|Rest] ->
1069
{Type,Rest2} = parse_Type(Rest),
1070
{{'DEFAULT',Type},Rest2};
1071
_ -> {'MANDATORY',Tokens}
1074
parse_ValueSetOptionalitySpec(Tokens) ->
1076
[{'OPTIONAL',_}|Rest] -> {'OPTIONAL',Rest};
1077
[{'DEFAULT',_}|Rest] ->
1078
{ValueSet,Rest2} = parse_ValueSet(Rest),
1079
{{'DEFAULT',ValueSet},Rest2};
1080
_ -> {'MANDATORY',Tokens}
1083
parse_ObjectSetOptionalitySpec(Tokens) ->
1085
[{'OPTIONAL',_}|Rest] -> {'OPTIONAL',Rest};
1086
[{'DEFAULT',_}|Rest] ->
1087
{ObjectSet,Rest2} = parse_ObjectSet(Rest),
1088
{{'DEFAULT',ObjectSet},Rest2};
1089
_ -> {'MANDATORY',Tokens}
1092
parse_WithSyntaxSpec([{'WITH',_},{'SYNTAX',_}|Rest]) ->
1093
{SyntaxList,Rest2} = parse_SyntaxList(Rest),
1094
{{'WITH SYNTAX',SyntaxList},Rest2};
1095
parse_WithSyntaxSpec(Tokens) ->
1098
parse_SyntaxList([{'{',_},{'}',_}|Rest]) ->
1100
parse_SyntaxList([{'{',_}|Rest]) ->
1101
parse_SyntaxList(Rest,[]);
1102
parse_SyntaxList(Tokens) ->
1103
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1104
[got,get_token(hd(Tokens)),expected,['{}','{']]}}).
1106
parse_SyntaxList(Tokens,Acc) ->
1107
{SyntaxList,Rest} = parse_TokenOrGroupSpec(Tokens),
1110
{lists:reverse([SyntaxList|Acc]),Rest2};
1112
parse_SyntaxList(Rest,[SyntaxList|Acc])
1115
parse_TokenOrGroupSpec(Tokens) ->
1116
Flist = [fun parse_RequiredToken/1,
1117
fun parse_OptionalGroup/1],
1118
case (catch parse_or(Tokens,Flist)) of
1121
AsnErr = {asn1_error,_} ->
1127
parse_RequiredToken([{typereference,L1,WordName}|Rest]) ->
1128
case is_word(WordName) of
1130
throw({asn1_error,{L1,get(asn1_module),
1131
[got,WordName,expected,a,'Word']}});
1135
parse_RequiredToken([{',',L1}|Rest]) ->
1137
parse_RequiredToken([{WordName,L1}|Rest]) ->
1138
case is_word(WordName) of
1140
throw({asn1_error,{L1,get(asn1_module),
1141
[got,WordName,expected,a,'Word']}});
1145
parse_RequiredToken(Tokens) ->
1146
parse_PrimitiveFieldName(Tokens).
1148
parse_OptionalGroup([{'[',_}|Rest]) ->
1149
{Spec,Rest2} = parse_TokenOrGroupSpec(Rest),
1150
{SpecList,Rest3} = parse_OptionalGroup(Rest2,[Spec]),
1153
parse_OptionalGroup([{']',_}|Rest],Acc) ->
1154
{lists:reverse(Acc),Rest};
1155
parse_OptionalGroup(Tokens,Acc) ->
1156
{Spec,Rest} = parse_TokenOrGroupSpec(Tokens),
1157
parse_OptionalGroup(Rest,[Spec|Acc]).
1159
parse_DefinedObject([Id={identifier,_,_ObjName}|Rest]) ->
1160
{{object,identifier2Extvalueref(Id)},Rest};
1161
parse_DefinedObject([{typereference,L1,ModName},{'.',_},{identifier,_,ObjName}|Rest]) ->
1162
{{object, #'Externaltypereference'{pos=L1,module=ModName,type=ObjName}},Rest};
1163
parse_DefinedObject(Tokens) ->
1164
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1165
[got,get_token(hd(Tokens)),expected,
1166
[identifier,'typereference.identifier']]}}).
1168
parse_ObjectAssignment([{identifier,L1,ObjName}|Rest]) ->
1169
{Class,Rest2} = parse_DefinedObjectClass(Rest),
1171
[{'::=',_}|Rest3] ->
1172
{Object,Rest4} = parse_Object(Rest3),
1173
{#typedef{pos=L1,name=ObjName,
1174
typespec=#'Object'{classname=Class,def=Object}},Rest4};
1176
throw({asn1_error,{get_line(H),get(asn1_module),
1177
[got,get_token(H),expected,'::=']}});
1179
throw({asn1_error,{L1,get(asn1_module),
1180
[got,Other,expected,'::=']}})
1182
parse_ObjectAssignment(Tokens) ->
1183
throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
1184
[got,get_token(hd(Tokens)),expected,identifier]}}).
1186
parse_Object(Tokens) ->
1187
Flist=[fun parse_ObjectDefn/1,
1188
fun parse_ObjectFromObject/1,
1189
fun parse_ParameterizedObject/1,
1190
fun parse_DefinedObject/1],
1191
case (catch parse_or(Tokens,Flist)) of
1194
AsnErr = {asn1_error,_} ->
1200
parse_ObjectDefn(Tokens) ->
1201
Flist=[fun parse_DefaultSyntax/1,
1202
fun parse_DefinedSyntax/1],
1203
case (catch parse_or(Tokens,Flist)) of
1206
AsnErr = {asn1_error,_} ->
1212
parse_DefaultSyntax([{'{',_},{'}',_}|Rest]) ->
1213
{{object,defaultsyntax,[]},Rest};
1214
parse_DefaultSyntax([{'{',_}|Rest]) ->
1215
parse_DefaultSyntax(Rest,[]);
1216
parse_DefaultSyntax(Tokens) ->
1217
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1218
[got,get_token(hd(Tokens)),expected,['{}','{']]}}).
1220
parse_DefaultSyntax(Tokens,Acc) ->
1221
{Setting,Rest} = parse_FieldSetting(Tokens),
1224
parse_DefaultSyntax(Rest2,[Setting|Acc]);
1226
{{object,defaultsyntax,lists:reverse([Setting|Acc])},Rest3};
1228
throw({asn1_error,{get_line(H),get(asn1_module),
1229
[got,get_token(H),expected,[',','}']]}})
1232
parse_FieldSetting(Tokens) ->
1233
{{_,PrimFieldName},Rest} = parse_PrimitiveFieldName(Tokens),
1234
{Setting,Rest2} = parse_Setting(Rest),
1235
{{PrimFieldName,Setting},Rest2}.
1237
parse_DefinedSyntax([{'{',_}|Rest]) ->
1238
parse_DefinedSyntax(Rest,[]).
1240
parse_DefinedSyntax(Tokens,Acc) ->
1243
{{object,definedsyntax,lists:reverse(Acc)},Rest2};
1245
{DefSynTok,Rest3} = parse_DefinedSyntaxToken(Tokens),
1246
parse_DefinedSyntax(Rest3,[DefSynTok|Acc])
1249
parse_DefinedSyntaxToken([{',',L1}|Rest]) ->
1251
parse_DefinedSyntaxToken([{typereference,L1,Name}|Rest]) ->
1252
case is_word(Name) of
1254
{{setting,L1,Name},Rest};
1256
{{word_or_setting,L1,Name},Rest}
1258
parse_DefinedSyntaxToken(Tokens) ->
1259
case catch parse_Setting(Tokens) of
1268
parse_Word([{Name,Pos}|Rest]) ->
1269
case is_word(Name) of
1271
throw({asn1_error,{Pos,get(asn1_module),
1272
[got,Name, expected,a,'Word']}});
1274
{{word_or_setting,Pos,Name},Rest}
1277
parse_Setting(Tokens) ->
1278
Flist = [fun parse_Type/1,
1281
fun parse_ObjectSet/1],
1282
case (catch parse_or(Tokens,Flist)) of
1285
AsnErr = {asn1_error,_} ->
1291
parse_DefinedObjectSet([{typereference,L1,ModuleName},{'.',_},
1292
{typereference,L2,ObjSetName}|Rest]) ->
1293
{{objectset,L1,#'Externaltypereference'{pos=L2,module=ModuleName,
1294
type=ObjSetName}},Rest};
1295
parse_DefinedObjectSet([{typereference,L1,ObjSetName}|Rest]) ->
1296
{{objectset,L1,#'Externaltypereference'{pos=L1,module=get(asn1_module),
1297
type=ObjSetName}},Rest};
1298
parse_DefinedObjectSet(Tokens) ->
1299
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1300
[got,get_token(hd(Tokens)),expected,
1301
[typereference,'typereference.typereference']]}}).
1303
parse_ObjectSetAssignment([{typereference,L1,ObjSetName}|Rest]) ->
1304
{Class,Rest2} = parse_DefinedObjectClass(Rest),
1306
[{'::=',_}|Rest3] ->
1307
{ObjectSet,Rest4} = parse_ObjectSet(Rest3),
1308
{#typedef{pos=L1,name=ObjSetName,
1309
typespec=#'ObjectSet'{class=Class,
1310
set=ObjectSet}},Rest4};
1312
throw({asn1_error,{get_line(H),get(asn1_module),
1313
[got,get_token(H),expected,'::=']}})
1317
parse_ObjectSetAssignment(Tokens) ->
1318
throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
1319
[got,get_token(hd(Tokens)),expected,
1322
parse_ObjectSet([{'{',_}|Rest]) ->
1323
{ObjSetSpec,Rest2} = parse_ObjectSetSpec(Rest),
1328
throw({asn1_error,{get_line(H),get(asn1_module),
1329
[got,get_token(H),expected,'}']}})
1331
parse_ObjectSet(Tokens) ->
1332
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1333
[got,get_token(hd(Tokens)),expected,'{']}}).
1335
parse_ObjectSetSpec([{'...',_}|Rest]) ->
1336
{['EXTENSIONMARK'],Rest};
1337
parse_ObjectSetSpec(Tokens) ->
1338
parse_ElementSetSpecs(Tokens).
1340
parse_ObjectSetElements(Tokens) ->
1341
Flist = [fun parse_Object/1,
1342
fun parse_DefinedObjectSet/1,
1343
fun parse_ObjectSetFromObjects/1,
1344
fun parse_ParameterizedObjectSet/1],
1345
case (catch parse_or(Tokens,Flist)) of
1348
AsnErr = {asn1_error,_} ->
1354
parse_ObjectClassFieldType(Tokens) ->
1355
{Class,Rest} = parse_DefinedObjectClass(Tokens),
1358
{FieldName,Rest3} = parse_FieldName(Rest2),
1359
OCFT = #'ObjectClassFieldType'{
1361
class=Class,fieldname=FieldName},
1362
{#type{def=OCFT},Rest3};
1364
throw({asn1_error,{get_line(H),get(asn1_module),
1365
[got,get_token(H),expected,'.']}})
1370
%parse_ObjectClassFieldValue(Tokens) ->
1371
% Flist = [fun parse_OpenTypeFieldVal/1,
1372
% fun parse_FixedTypeFieldVal/1],
1373
% case (catch parse_or(Tokens,Flist)) of
1374
% {'EXIT',Reason} ->
1376
% AsnErr = {asn1_error,_} ->
1382
parse_ObjectClassFieldValue(Tokens) ->
1383
parse_OpenTypeFieldVal(Tokens).
1385
parse_OpenTypeFieldVal(Tokens) ->
1386
{Type,Rest} = parse_Type(Tokens),
1389
{Value,Rest3} = parse_Value(Rest2),
1390
{{opentypefieldvalue,Type,Value},Rest3};
1392
throw({asn1_error,{get_line(H),get(asn1_module),
1393
[got,get_token(H),expected,':']}})
1396
% parse_FixedTypeFieldVal(Tokens) ->
1397
% parse_Value(Tokens).
1399
% parse_InformationFromObjects(Tokens) ->
1400
% Flist = [fun parse_ValueFromObject/1,
1401
% fun parse_ValueSetFromObjects/1,
1402
% fun parse_TypeFromObject/1,
1403
% fun parse_ObjectFromObject/1],
1404
% case (catch parse_or(Tokens,Flist)) of
1405
% {'EXIT',Reason} ->
1407
% AsnErr = {asn1_error,_} ->
1413
parse_ReferencedObjects(Tokens) ->
1414
Flist = [fun parse_DefinedObject/1,
1415
fun parse_DefinedObjectSet/1,
1416
fun parse_ParameterizedObject/1,
1417
fun parse_ParameterizedObjectSet/1],
1418
case (catch parse_or(Tokens,Flist)) of
1421
AsnErr = {asn1_error,_} ->
1427
parse_ValueFromObject(Tokens) ->
1428
{Objects,Rest} = parse_ReferencedObjects(Tokens),
1431
{Name,Rest3} = parse_FieldName(Rest2),
1432
case lists:last(Name) of
1433
{valuefieldreference,_} ->
1434
{{'ValueFromObject',Objects,Name},Rest3};
1436
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1437
[got,typefieldreference,expected,
1438
valuefieldreference]}})
1441
throw({asn1_error,{get_line(H),get(asn1_module),
1442
[got,get_token(H),expected,'.']}})
1444
%%% throw({asn1_error,{got,Other,expected,'.'}})
1447
parse_ValueSetFromObjects(Tokens) ->
1448
{Objects,Rest} = parse_ReferencedObjects(Tokens),
1451
{Name,Rest3} = parse_FieldName(Rest2),
1452
case lists:last(Name) of
1453
{typefieldreference,_FieldName} ->
1454
{{'ValueSetFromObjects',Objects,Name},Rest3};
1456
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
1457
[got,get_token(hd(Rest2)),expected,
1458
typefieldreference]}})
1461
throw({asn1_error,{get_line(H),get(asn1_module),
1462
[got,get_token(H),expected,'.']}})
1464
%%% throw({asn1_error,{got,Other,expected,'.'}})
1467
parse_TypeFromObject(Tokens) ->
1468
{Objects,Rest} = parse_ReferencedObjects(Tokens),
1471
{Name,Rest3} = parse_FieldName(Rest2),
1472
case lists:last(Name) of
1473
{typefieldreference,_FieldName} ->
1474
{{'TypeFromObject',Objects,Name},Rest3};
1476
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
1477
[got,get_token(hd(Rest2)),expected,
1478
typefieldreference]}})
1481
throw({asn1_error,{get_line(H),get(asn1_module),
1482
[got,get_token(H),expected,'.']}})
1484
%%% throw({asn1_error,{got,Other,expected,'.'}})
1487
parse_ObjectFromObject(Tokens) ->
1488
{Objects,Rest} = parse_ReferencedObjects(Tokens),
1491
{Name,Rest3} = parse_FieldName(Rest2),
1492
{{'ObjectFromObject',Objects,Name},Rest3};
1494
throw({asn1_error,{get_line(H),get(asn1_module),
1495
[got,get_token(H),expected,'.']}})
1497
%%% throw({asn1_error,{got,Other,expected,'.'}})
1500
parse_ObjectSetFromObjects(Tokens) ->
1501
{Objects,Rest} = parse_ReferencedObjects(Tokens),
1504
{Name,Rest3} = parse_FieldName(Rest2),
1505
{{'ObjectSetFromObjects',Objects,Name},Rest3};
1507
throw({asn1_error,{get_line(H),get(asn1_module),
1508
[got,get_token(H),expected,'.']}})
1510
%%% throw({asn1_error,{got,Other,expected,'.'}})
1513
% parse_InstanceOfType([{'INSTANCE',_},{'OF',_}|Rest]) ->
1514
% {Class,Rest2} = parse_DefinedObjectClass(Rest),
1515
% {{'InstanceOfType',Class},Rest2}.
1517
% parse_InstanceOfValue(Tokens) ->
1518
% parse_Value(Tokens).
1522
%% X.682 constraint specification
1524
parse_GeneralConstraint(Tokens) ->
1525
Flist = [fun parse_UserDefinedConstraint/1,
1526
fun parse_TableConstraint/1],
1527
case (catch parse_or(Tokens,Flist)) of
1530
AsnErr = {asn1_error,_} ->
1536
parse_UserDefinedConstraint([{'CONSTRAINED',_},{'BY',_},{'{',_},{'}',_}|Rest])->
1537
{{constrained_by,[]},Rest};
1538
parse_UserDefinedConstraint([{'CONSTRAINED',_},
1541
{Param,Rest2} = parse_UserDefinedConstraintParameter(Rest),
1544
{{constrained_by,Param},Rest3};
1546
throw({asn1_error,{get_line(H),get(asn1_module),
1547
[got,get_token(H),expected,'}']}})
1549
parse_UserDefinedConstraint(Tokens) ->
1550
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1551
[got,get_token(hd(Tokens)),expected,
1552
['CONSTRAINED BY {}','CONSTRAINED BY {']]}}).
1554
parse_UserDefinedConstraintParameter(Tokens) ->
1555
parse_UserDefinedConstraintParameter(Tokens,[]).
1556
parse_UserDefinedConstraintParameter(Tokens,Acc) ->
1557
Flist = [fun parse_GovernorAndActualParameter/1,
1558
fun parse_ActualParameter/1],
1559
case (catch parse_or(Tokens,Flist)) of
1562
AsnErr = {asn1_error,_} ->
1567
parse_UserDefinedConstraintParameter(Tokens,[Result|Acc]);
1569
{lists:reverse([Result|Acc]),Rest}
1573
parse_GovernorAndActualParameter(Tokens) ->
1574
{Governor,Rest} = parse_Governor(Tokens),
1577
{Params,Rest3} = parse_ActualParameter(Rest2),
1578
{{'Governor_Params',Governor,Params},Rest3};
1580
throw({asn1_error,{get_line(H),get(asn1_module),
1581
[got,get_token(H),expected,':']}})
1584
parse_TableConstraint(Tokens) ->
1585
Flist = [fun parse_ComponentRelationConstraint/1,
1586
fun parse_SimpleTableConstraint/1],
1587
case (catch parse_or(Tokens,Flist)) of
1590
AsnErr = {asn1_error,_} ->
1596
parse_SimpleTableConstraint(Tokens) ->
1597
{ObjectSet,Rest} = parse_ObjectSet(Tokens),
1598
{{simpletable,ObjectSet},Rest}.
1600
parse_ComponentRelationConstraint([{'{',_}|Rest]) ->
1601
{ObjectSet,Rest2} = parse_DefinedObjectSet(Rest),
1603
[{'}',_},{'{',_}|Rest3] ->
1604
{AtNot,Rest4} = parse_AtNotationList(Rest3,[]),
1607
{{componentrelation,ObjectSet,AtNot},Rest5};
1609
throw({asn1_error,{get_line(H),get(asn1_module),
1610
[got,get_token(H),expected,'}']}})
1613
throw({asn1_error,{get_line(H),get(asn1_module),
1614
[got,get_token(H),expected,
1615
'ComponentRelationConstraint',ended,with,'}']}})
1619
parse_ComponentRelationConstraint(Tokens) ->
1620
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1621
[got,get_token(hd(Tokens)),expected,'{']}}).
1623
parse_AtNotationList(Tokens,Acc) ->
1624
{AtNot,Rest} = parse_AtNotation(Tokens),
1627
parse_AtNotationList(Rest2,[AtNot|Acc]);
1629
{lists:reverse([AtNot|Acc]),Rest}
1632
parse_AtNotation([{'@',_},{'.',_}|Rest]) ->
1633
{CIdList,Rest2} = parse_ComponentIdList(Rest),
1634
{{innermost,CIdList},Rest2};
1635
parse_AtNotation([{'@',_}|Rest]) ->
1636
{CIdList,Rest2} = parse_ComponentIdList(Rest),
1637
{{outermost,CIdList},Rest2};
1638
parse_AtNotation(Tokens) ->
1639
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1640
[got,get_token(hd(Tokens)),expected,['@','@.']]}}).
1642
parse_ComponentIdList(Tokens) ->
1643
parse_ComponentIdList(Tokens,[]).
1645
parse_ComponentIdList([Id = {identifier,_,_},{'.',_}|Rest],Acc) ->
1646
parse_ComponentIdList(Rest,[identifier2Extvalueref(Id)|Acc]);
1647
parse_ComponentIdList([Id = {identifier,_,_}|Rest],Acc) ->
1648
{lists:reverse([identifier2Extvalueref(Id)|Acc]),Rest};
1649
parse_ComponentIdList(Tokens,_) ->
1650
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1651
[got,get_token(hd(Tokens)),expected,
1652
[identifier,'identifier.']]}}).
1658
% X.683 Parameterization of ASN.1 specifications
1660
parse_Governor(Tokens) ->
1661
Flist = [fun parse_Type/1,
1662
fun parse_DefinedObjectClass/1],
1663
case (catch parse_or(Tokens,Flist)) of
1666
AsnErr = {asn1_error,_} ->
1672
parse_ActualParameter(Tokens) ->
1673
Flist = [fun parse_Type/1,
1675
fun parse_ValueSet/1,
1676
fun parse_DefinedObjectClass/1,
1678
fun parse_ObjectSet/1],
1679
case (catch parse_or(Tokens,Flist)) of
1682
AsnErr = {asn1_error,_} ->
1688
parse_ParameterizedAssignment(Tokens) ->
1689
Flist = [fun parse_ParameterizedTypeAssignment/1,
1690
fun parse_ParameterizedValueAssignment/1,
1691
fun parse_ParameterizedValueSetTypeAssignment/1,
1692
fun parse_ParameterizedObjectClassAssignment/1,
1693
fun parse_ParameterizedObjectAssignment/1,
1694
fun parse_ParameterizedObjectSetAssignment/1],
1695
case (catch parse_or(Tokens,Flist)) of
1698
AsnErr = {asn1_error,_} ->
1700
AsnAssErr = {asn1_assignment_error,_} ->
1706
parse_ParameterizedTypeAssignment([{typereference,L1,Name}|Rest]) ->
1707
{ParameterList,Rest2} = parse_ParameterList(Rest),
1709
[{'::=',_}|Rest3] ->
1710
{Type,Rest4} = parse_Type(Rest3),
1711
{#ptypedef{pos=L1,name=Name,args=ParameterList,typespec=Type},
1714
throw({asn1_error,{get_line(H),get(asn1_module),
1715
[got,get_token(H),expected,'::=']}})
1717
parse_ParameterizedTypeAssignment(Tokens) ->
1718
throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
1719
[got,get_token(hd(Tokens)),expected,
1722
parse_ParameterizedValueAssignment([{identifier,L1,Name}|Rest]) ->
1723
{ParameterList,Rest2} = parse_ParameterList(Rest),
1724
{Type,Rest3} = parse_Type(Rest2),
1726
[{'::=',_}|Rest4] ->
1727
{Value,Rest5} = parse_Value(Rest4),
1728
{#pvaluedef{pos=L1,name=Name,args=ParameterList,type=Type,
1729
value=Value},Rest5};
1731
throw({asn1_error,{get_line(H),get(asn1_module),
1732
[got,get_token(H),expected,'::=']}})
1734
parse_ParameterizedValueAssignment(Tokens) ->
1735
throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
1736
[got,get_token(hd(Tokens)),expected,identifier]}}).
1738
parse_ParameterizedValueSetTypeAssignment([{typereference,L1,Name}|Rest]) ->
1739
{ParameterList,Rest2} = parse_ParameterList(Rest),
1740
{Type,Rest3} = parse_Type(Rest2),
1742
[{'::=',_}|Rest4] ->
1743
{ValueSet,Rest5} = parse_ValueSet(Rest4),
1744
{#pvaluesetdef{pos=L1,name=Name,args=ParameterList,
1745
type=Type,valueset=ValueSet},Rest5};
1747
throw({asn1_error,{get_line(H),get(asn1_module),
1748
[got,get_token(H),expected,'::=']}})
1750
parse_ParameterizedValueSetTypeAssignment(Tokens) ->
1751
throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
1752
[got,get_token(hd(Tokens)),expected,
1755
parse_ParameterizedObjectClassAssignment([{typereference,L1,Name}|Rest]) ->
1756
{ParameterList,Rest2} = parse_ParameterList(Rest),
1758
[{'::=',_}|Rest3] ->
1759
{Class,Rest4} = parse_ObjectClass(Rest3),
1760
{#ptypedef{pos=L1,name=Name,args=ParameterList,typespec=Class},
1763
throw({asn1_error,{get_line(H),get(asn1_module),
1764
[got,get_token(H),expected,'::=']}})
1766
parse_ParameterizedObjectClassAssignment(Tokens) ->
1767
throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
1768
[got,get_token(hd(Tokens)),expected,
1771
parse_ParameterizedObjectAssignment([{identifier,L1,Name}|Rest]) ->
1772
{ParameterList,Rest2} = parse_ParameterList(Rest),
1773
{Class,Rest3} = parse_DefinedObjectClass(Rest2),
1775
[{'::=',_}|Rest4] ->
1776
{Object,Rest5} = parse_Object(Rest4),
1777
{#pobjectdef{pos=L1,name=Name,args=ParameterList,
1778
class=Class,def=Object},Rest5};
1780
throw({asn1_error,{get_line(H),get(asn1_module),
1781
[got,get_token(H),expected,'::=']}})
1785
parse_ParameterizedObjectAssignment(Tokens) ->
1786
throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
1787
[got,get_token(hd(Tokens)),expected,identifier]}}).
1789
parse_ParameterizedObjectSetAssignment([{typereference,L1,Name}|Rest]) ->
1790
{ParameterList,Rest2} = parse_ParameterList(Rest),
1791
{Class,Rest3} = parse_DefinedObjectClass(Rest2),
1793
[{'::=',_}|Rest4] ->
1794
{ObjectSet,Rest5} = parse_ObjectSet(Rest4),
1795
{#pobjectsetdef{pos=L1,name=Name,args=ParameterList,
1796
class=Class,def=ObjectSet},Rest5};
1798
throw({asn1_error,{get_line(H),get(asn1_module),
1799
[got,get_token(H),expected,'::=']}})
1803
parse_ParameterizedObjectSetAssignment(Tokens) ->
1804
throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
1805
[got,get_token(hd(Tokens)),expected,
1808
parse_ParameterList([{'{',_}|Rest]) ->
1809
parse_ParameterList(Rest,[]);
1810
parse_ParameterList(Tokens) ->
1811
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1812
[got,get_token(hd(Tokens)),expected,'{']}}).
1814
parse_ParameterList(Tokens,Acc) ->
1815
{Parameter,Rest} = parse_Parameter(Tokens),
1818
parse_ParameterList(Rest2,[Parameter|Acc]);
1820
{lists:reverse([Parameter|Acc]),Rest3};
1822
throw({asn1_error,{get_line(H),get(asn1_module),
1823
[got,get_token(H),expected,[',','}']]}})
1826
parse_Parameter(Tokens) ->
1827
Flist = [fun parse_ParamGovAndRef/1,
1828
fun parse_Reference/1],
1829
case (catch parse_or(Tokens,Flist)) of
1832
AsnErr = {asn1_error,_} ->
1838
parse_ParamGovAndRef(Tokens) ->
1839
{ParamGov,Rest} = parse_ParamGovernor(Tokens),
1842
{Ref,Rest3} = parse_Reference(Rest2),
1843
{{ParamGov,Ref},Rest3};
1845
throw({asn1_error,{get_line(H),get(asn1_module),
1846
[got,get_token(H),expected,':']}})
1849
parse_ParamGovernor(Tokens) ->
1850
Flist = [fun parse_Governor/1,
1851
fun parse_Reference/1],
1852
case (catch parse_or(Tokens,Flist)) of
1855
AsnErr = {asn1_error,_} ->
1861
% parse_ParameterizedReference(Tokens) ->
1862
% {Ref,Rest} = parse_Reference(Tokens),
1864
% [{'{',_},{'}',_}|Rest2] ->
1865
% {{ptref,Ref},Rest2};
1867
% {{ptref,Ref},Rest}
1870
parse_SimpleDefinedType([{typereference,L1,ModuleName},{'.',_},
1871
{typereference,_,TypeName}|Rest]) ->
1872
{#'Externaltypereference'{pos=L1,module=ModuleName,
1873
type=TypeName},Rest};
1874
parse_SimpleDefinedType([Tref={typereference,_,_}|Rest]) ->
1875
% {#'Externaltypereference'{pos=L2,module=get(asn1_module),
1876
% type=TypeName},Rest};
1877
{tref2Exttref(Tref),Rest};
1878
parse_SimpleDefinedType(Tokens) ->
1879
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1880
[got,get_token(hd(Tokens)),expected,
1881
[typereference,'typereference.typereference']]}}).
1883
parse_SimpleDefinedValue([{typereference,L1,ModuleName},{'.',_},
1884
{identifier,_,Value}|Rest]) ->
1885
{{simpledefinedvalue,#'Externalvaluereference'{pos=L1,module=ModuleName,
1886
value=Value}},Rest};
1887
parse_SimpleDefinedValue([{identifier,L2,Value}|Rest]) ->
1888
{{simpledefinedvalue,L2,Value},Rest};
1889
parse_SimpleDefinedValue(Tokens) ->
1890
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1891
[got,get_token(hd(Tokens)),expected,
1892
['typereference.identifier',identifier]]}}).
1894
parse_ParameterizedType(Tokens) ->
1895
{Type,Rest} = parse_SimpleDefinedType(Tokens),
1896
{Params,Rest2} = parse_ActualParameterList(Rest),
1897
{{pt,Type,Params},Rest2}.
1899
parse_ParameterizedValue(Tokens) ->
1900
{Value,Rest} = parse_SimpleDefinedValue(Tokens),
1901
{Params,Rest2} = parse_ActualParameterList(Rest),
1902
{{pv,Value,Params},Rest2}.
1904
parse_ParameterizedObjectClass(Tokens) ->
1905
{Type,Rest} = parse_DefinedObjectClass(Tokens),
1906
{Params,Rest2} = parse_ActualParameterList(Rest),
1907
{{poc,Type,Params},Rest2}.
1909
parse_ParameterizedObjectSet(Tokens) ->
1910
{ObjectSet,Rest} = parse_DefinedObjectSet(Tokens),
1911
{Params,Rest2} = parse_ActualParameterList(Rest),
1912
{{pos,ObjectSet,Params},Rest2}.
1914
parse_ParameterizedObject(Tokens) ->
1915
{Object,Rest} = parse_DefinedObject(Tokens),
1916
{Params,Rest2} = parse_ActualParameterList(Rest),
1917
{{po,Object,Params},Rest2}.
1919
parse_ActualParameterList([{'{',_}|Rest]) ->
1920
parse_ActualParameterList(Rest,[]);
1921
parse_ActualParameterList(Tokens) ->
1922
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
1923
[got,get_token(hd(Tokens)),expected,'{']}}).
1925
parse_ActualParameterList(Tokens,Acc) ->
1926
{Parameter,Rest} = parse_ActualParameter(Tokens),
1929
parse_ActualParameterList(Rest2,[Parameter|Acc]);
1931
{lists:reverse([Parameter|Acc]),Rest3};
1933
throw({asn1_error,{get_line(H),get(asn1_module),
1934
[got,get_token(H),expected,[',','}']]}})
1945
%-------------------------
1948
case not_allowed_word(Token) of
1953
Item = atom_to_list(Token),
1955
list(Token), length(Token) == 1 ->
1956
check_one_char_word(Token);
1959
case check_first(A) of
1968
not_allowed_word(Name) ->
1969
lists:member(Name,["BIT",
1992
check_one_char_word([A]) when $A =< A, $Z >= A ->
1994
check_one_char_word([_]) ->
1995
false. %% unknown item in SyntaxList
1997
check_first(A) when $A =< A, $Z >= A ->
2000
false. %% unknown item in SyntaxList
2002
check_rest([R,R|_Rs]) when $- == R ->
2003
false; %% two consecutive hyphens are not allowed in a word
2004
check_rest([R]) when $- == R ->
2005
false; %% word cannot end with hyphen
2006
check_rest([R|Rs]) when $A=<R, $Z>=R; $-==R ->
2014
to_set(V) when list(V) ->
2015
ordsets:list_to_set(V);
2017
ordsets:list_to_set([V]).
2020
parse_AlternativeTypeLists(Tokens) ->
2021
{AlternativeTypeList,Rest1} = parse_AlternativeTypeList(Tokens),
2022
{ExtensionAndException,Rest2} =
2024
[{',',_},{'...',L1},{'!',_}|Rest12] ->
2025
{_,Rest13} = parse_ExceptionIdentification(Rest12),
2026
%% Exception info is currently thrown away
2027
{[#'EXTENSIONMARK'{pos=L1}],Rest13};
2028
[{',',_},{'...',L1}|Rest12] ->
2029
{[#'EXTENSIONMARK'{pos=L1}],Rest12};
2033
case ExtensionAndException of
2035
{AlternativeTypeList,Rest2};
2037
{ExtensionAddition,Rest3} =
2040
parse_ExtensionAdditionAlternativeList(Rest23);
2044
{OptionalExtensionMarker,Rest4} =
2046
[{',',_},{'...',L3}|Rest31] ->
2047
{[#'EXTENSIONMARK'{pos=L3}],Rest31};
2051
{AlternativeTypeList ++ ExtensionAndException ++ ExtensionAddition ++ OptionalExtensionMarker, Rest4}
2055
parse_AlternativeTypeList(Tokens) ->
2056
parse_AlternativeTypeList(Tokens,[]).
2058
parse_AlternativeTypeList(Tokens,Acc) ->
2059
{NamedType,Rest} = parse_NamedType(Tokens),
2061
[{',',_},Id = {identifier,_,_}|Rest2] ->
2062
parse_AlternativeTypeList([Id|Rest2],[NamedType|Acc]);
2064
{lists:reverse([NamedType|Acc]),Rest}
2069
parse_ExtensionAdditionAlternativeList(Tokens) ->
2070
parse_ExtensionAdditionAlternativeList(Tokens,[]).
2072
parse_ExtensionAdditionAlternativeList(Tokens,Acc) ->
2075
[{identifier,_,_}|_Rest] ->
2076
parse_NamedType(Tokens);
2078
parse_ExtensionAdditionAlternatives(Tokens)
2082
parse_ExtensionAdditionAlternativeList(Rest01,[Element|Acc]);
2084
{lists:reverse([Element|Acc]),Rest0}
2087
parse_ExtensionAdditionAlternatives([{'[[',_}|Rest]) ->
2088
parse_ExtensionAdditionAlternatives(Rest,[]);
2089
parse_ExtensionAdditionAlternatives(Tokens) ->
2090
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2091
[got,get_token(hd(Tokens)),expected,'[[']}}).
2093
parse_ExtensionAdditionAlternatives([Id = {identifier,_,_}|Rest],Acc) ->
2094
{NamedType, Rest2} = parse_NamedType([Id|Rest]),
2097
parse_ExtensionAdditionAlternatives(Rest21,[NamedType|Acc]);
2098
[{']]',_}|Rest21] ->
2099
{lists:reverse(Acc),Rest21};
2101
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
2102
[got,get_token(hd(Rest2)),expected,[',',']]']]}})
2105
parse_NamedType([{identifier,L1,Idname}|Rest]) ->
2106
{Type,Rest2} = parse_Type(Rest),
2107
{#'ComponentType'{pos=L1,name=Idname,typespec=Type,prop=mandatory},Rest2};
2108
parse_NamedType(Tokens) ->
2109
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2110
[got,get_token(hd(Tokens)),expected,identifier]}}).
2113
parse_ComponentTypeLists(Tokens) ->
2114
% Resulting tuple {ComponentTypeList,Rest1} is returned
2116
[{identifier,_,_}|_Rest0] ->
2117
{Clist,Rest01} = parse_ComponentTypeList(Tokens),
2120
parse_ComponentTypeLists(Rest02,Clist);
2124
[{'COMPONENTS',_},{'OF',_}|_Rest] ->
2125
{Clist,Rest01} = parse_ComponentTypeList(Tokens),
2128
parse_ComponentTypeLists(Rest02,Clist);
2133
parse_ComponentTypeLists(Tokens,[])
2136
parse_ComponentTypeLists([{'...',L1},{'!',_}|Rest],Clist1) ->
2137
{_,Rest2} = parse_ExceptionIdentification(Rest),
2138
%% Exception info is currently thrown away
2139
parse_ComponentTypeLists2(Rest2,Clist1++[#'EXTENSIONMARK'{pos=L1}]);
2140
parse_ComponentTypeLists([{'...',L1}|Rest],Clist1) ->
2141
parse_ComponentTypeLists2(Rest,Clist1++[#'EXTENSIONMARK'{pos=L1}]);
2142
parse_ComponentTypeLists(Tokens,Clist1) ->
2146
parse_ComponentTypeLists2(Tokens,Clist1) ->
2147
{ExtensionAddition,Rest2} =
2150
parse_ExtensionAdditionList(Rest1);
2154
{OptionalExtensionMarker,Rest3} =
2156
[{',',_},{'...',L2}|Rest21] ->
2157
{[#'EXTENSIONMARK'{pos=L2}],Rest21};
2161
{RootComponentTypeList,Rest4} =
2164
parse_ComponentTypeList(Rest31);
2168
{Clist1 ++ ExtensionAddition ++ OptionalExtensionMarker ++ RootComponentTypeList, Rest4}.
2171
parse_ComponentTypeList(Tokens) ->
2172
parse_ComponentTypeList(Tokens,[]).
2174
parse_ComponentTypeList(Tokens,Acc) ->
2175
{ComponentType,Rest} = parse_ComponentType(Tokens),
2177
[{',',_},Id = {identifier,_,_}|Rest2] ->
2178
parse_ComponentTypeList([Id|Rest2],[ComponentType|Acc]);
2179
[{',',_},C1={'COMPONENTS',_},C2={'OF',_}|Rest2] ->
2180
parse_ComponentTypeList([C1,C2|Rest2],[ComponentType|Acc]);
2182
% {lists:reverse([ComponentType|Acc]),Rest}
2184
{lists:reverse([ComponentType|Acc]),Rest};
2185
[{',',_},{'...',_}|_] ->
2186
{lists:reverse([ComponentType|Acc]),Rest};
2189
{get_line(hd(Tokens)),get(asn1_module),
2190
[got,[get_token(hd(Rest)),get_token(hd(tl(Rest)))],
2191
expected,['}',', identifier']]}})
2195
parse_ExtensionAdditionList(Tokens) ->
2196
parse_ExtensionAdditionList(Tokens,[]).
2198
parse_ExtensionAdditionList(Tokens,Acc) ->
2201
[{identifier,_,_}|_Rest] ->
2202
parse_ComponentType(Tokens);
2204
parse_ExtensionAdditions(Tokens);
2206
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2207
[got,get_token(hd(Tokens)),expected,
2208
[identifier,'[[']]}})
2212
parse_ExtensionAdditionList(Rest01,[Element|Acc]);
2214
{lists:reverse([Element|Acc]),Rest0}
2217
parse_ExtensionAdditions([{'[[',_}|Rest]) ->
2218
parse_ExtensionAdditions(Rest,[]);
2219
parse_ExtensionAdditions(Tokens) ->
2220
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2221
[got,get_token(hd(Tokens)),expected,'[[']}}).
2223
parse_ExtensionAdditions([Id = {identifier,_,_}|Rest],Acc) ->
2224
{ComponentType, Rest2} = parse_ComponentType([Id|Rest]),
2227
parse_ExtensionAdditions(Rest21,[ComponentType|Acc]);
2228
[{']]',_}|Rest21] ->
2229
{lists:reverse(Acc),Rest21};
2231
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
2232
[got,get_token(hd(Rest2)),expected,[',',']]']]}})
2234
parse_ExtensionAdditions(Tokens,_) ->
2235
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2236
[got,get_token(hd(Tokens)),expected,identifier]}}).
2238
parse_ComponentType([{'COMPONENTS',_},{'OF',_}|Rest]) ->
2239
{Type,Rest2} = parse_Type(Rest),
2240
{{'COMPONENTS OF',Type},Rest2};
2241
parse_ComponentType(Tokens) ->
2242
{NamedType,Rest} = parse_NamedType(Tokens),
2244
[{'OPTIONAL',_}|Rest2] ->
2245
{NamedType#'ComponentType'{prop='OPTIONAL'},Rest2};
2246
[{'DEFAULT',_}|Rest2] ->
2247
{Value,Rest21} = parse_Value(Rest2),
2248
{NamedType#'ComponentType'{prop={'DEFAULT',Value}},Rest21};
2255
parse_SignedNumber([{number,_,Value}|Rest]) ->
2257
parse_SignedNumber([{'-',_},{number,_,Value}|Rest]) ->
2259
parse_SignedNumber(Tokens) ->
2260
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2261
[got,get_token(hd(Tokens)),expected,
2262
[number,'-number']]}}).
2264
parse_Enumerations(Tokens=[{identifier,_,_}|_Rest]) ->
2265
parse_Enumerations(Tokens,[]);
2266
parse_Enumerations([H|_T]) ->
2267
throw({asn1_error,{get_line(H),get(asn1_module),
2268
[got,get_token(H),expected,identifier]}}).
2270
parse_Enumerations(Tokens = [{identifier,_,_},{'(',_}|_Rest], Acc) ->
2271
{NamedNumber,Rest2} = parse_NamedNumber(Tokens),
2274
parse_Enumerations(Rest3,[NamedNumber|Acc]);
2276
{lists:reverse([NamedNumber|Acc]),Rest2}
2278
parse_Enumerations([{identifier,_,Id}|Rest], Acc) ->
2281
parse_Enumerations(Rest2,[Id|Acc]);
2283
{lists:reverse([Id|Acc]),Rest}
2285
parse_Enumerations([{'...',_}|Rest], Acc) ->
2288
parse_Enumerations(Rest2,['EXTENSIONMARK'|Acc]);
2290
{lists:reverse(['EXTENSIONMARK'|Acc]),Rest}
2292
parse_Enumerations([H|_T],_) ->
2293
throw({asn1_error,{get_line(H),get(asn1_module),
2294
[got,get_token(H),expected,identifier]}}).
2296
parse_NamedNumberList(Tokens) ->
2297
parse_NamedNumberList(Tokens,[]).
2299
parse_NamedNumberList(Tokens,Acc) ->
2300
{NamedNum,Rest} = parse_NamedNumber(Tokens),
2303
parse_NamedNumberList(Rest2,[NamedNum|Acc]);
2305
{lists:reverse([NamedNum|Acc]),Rest}
2308
parse_NamedNumber([{identifier,_,Name},{'(',_}|Rest]) ->
2309
Flist = [fun parse_SignedNumber/1,
2310
fun parse_DefinedValue/1],
2311
case (catch parse_or(Rest,Flist)) of
2314
AsnErr = {asn1_error,_} ->
2316
{NamedNum,[{')',_}|Rest2]} ->
2317
{{'NamedNumber',Name,NamedNum},Rest2};
2319
throw({asn1_error,{get_line(hd(Rest)),get(asn1_module),
2320
[got,get_token(hd(Rest)),expected,'NamedNumberList']}})
2322
parse_NamedNumber(Tokens) ->
2323
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2324
[got,get_token(hd(Tokens)),expected,identifier]}}).
2327
parse_Tag([{'[',_}|Rest]) ->
2328
{Class,Rest2} = parse_Class(Rest),
2329
{ClassNumber,Rest3} =
2331
[{number,_,Num}|Rest21] ->
2334
parse_DefinedValue(Rest2)
2338
{#tag{class=Class,number=ClassNumber},Rest4};
2340
throw({asn1_error,{get_line(hd(Rest3)),get(asn1_module),
2341
[got,get_token(hd(Rest3)),expected,']']}})
2343
parse_Tag(Tokens) ->
2344
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2345
[got,get_token(hd(Tokens)),expected,'[']}}).
2347
parse_Class([{'UNIVERSAL',_}|Rest]) ->
2349
parse_Class([{'APPLICATION',_}|Rest]) ->
2350
{'APPLICATION',Rest};
2351
parse_Class([{'PRIVATE',_}|Rest]) ->
2353
parse_Class(Tokens) ->
2356
parse_Value(Tokens) ->
2357
Flist = [fun parse_BuiltinValue/1,
2358
fun parse_ValueFromObject/1,
2359
fun parse_DefinedValue/1],
2361
case (catch parse_or(Tokens,Flist)) of
2364
AsnErr = {asn1_error,_} ->
2370
parse_BuiltinValue([{bstring,_,Bstr}|Rest]) ->
2371
{{bstring,Bstr},Rest};
2372
parse_BuiltinValue([{hstring,_,Hstr}|Rest]) ->
2373
{{hstring,Hstr},Rest};
2374
parse_BuiltinValue([{'{',_},{'}',_}|Rest]) ->
2376
parse_BuiltinValue(Tokens = [{'{',_}|_Rest]) ->
2378
fun parse_SequenceOfValue/1,
2379
fun parse_SequenceValue/1,
2380
fun parse_ObjectIdentifierValue/1],
2381
case (catch parse_or(Tokens,Flist)) of
2384
AsnErr = {asn1_error,_} ->
2389
parse_BuiltinValue([{identifier,_,IdName},{':',_}|Rest]) ->
2390
{Value,Rest2} = parse_Value(Rest),
2391
{{'CHOICE',{IdName,Value}},Rest2};
2392
parse_BuiltinValue([{'NULL',_}|Rest]) ->
2394
parse_BuiltinValue([{'TRUE',_}|Rest]) ->
2396
parse_BuiltinValue([{'FALSE',_}|Rest]) ->
2398
parse_BuiltinValue([{'PLUS-INFINITY',_}|Rest]) ->
2399
{'PLUS-INFINITY',Rest};
2400
parse_BuiltinValue([{'MINUS-INFINITY',_}|Rest]) ->
2401
{'MINUS-INFINITY',Rest};
2402
parse_BuiltinValue([{cstring,_,Cstr}|Rest]) ->
2404
parse_BuiltinValue([{number,_,Num}|Rest]) ->
2406
parse_BuiltinValue([{'-',_},{number,_,Num}|Rest]) ->
2408
parse_BuiltinValue(Tokens) ->
2409
parse_ObjectClassFieldValue(Tokens).
2411
%% Externalvaluereference
2412
parse_DefinedValue([{typereference,L1,Tname},{'.',_},{identifier,_,Idname}|Rest]) ->
2413
{#'Externalvaluereference'{pos=L1,module=Tname,value=Idname},Rest};
2415
parse_DefinedValue([Id = {identifier,_,_}|Rest]) ->
2416
{identifier2Extvalueref(Id),Rest};
2417
%% ParameterizedValue
2418
parse_DefinedValue(Tokens) ->
2419
parse_ParameterizedValue(Tokens).
2422
parse_SequenceValue([{'{',_}|Tokens]) ->
2423
parse_SequenceValue(Tokens,[]);
2424
parse_SequenceValue(Tokens) ->
2425
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2426
[got,get_token(hd(Tokens)),expected,'{']}}).
2428
parse_SequenceValue([{identifier,_,IdName}|Rest],Acc) ->
2429
{Value,Rest2} = parse_Value(Rest),
2432
parse_SequenceValue(Rest3,[{IdName,Value}|Acc]);
2434
{lists:reverse([{IdName,Value}|Acc]),Rest3};
2436
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
2437
[got,get_token(hd(Rest2)),expected,'}']}})
2439
parse_SequenceValue(Tokens,_Acc) ->
2440
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2441
[got,get_token(hd(Tokens)),expected,identifier]}}).
2443
parse_SequenceOfValue([{'{',_}|Tokens]) ->
2444
parse_SequenceOfValue(Tokens,[]);
2445
parse_SequenceOfValue(Tokens) ->
2446
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2447
[got,get_token(hd(Tokens)),expected,'{']}}).
2449
parse_SequenceOfValue(Tokens,Acc) ->
2450
{Value,Rest2} = parse_Value(Tokens),
2453
parse_SequenceOfValue(Rest3,[Value|Acc]);
2455
{lists:reverse([Value|Acc]),Rest3};
2457
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
2458
[got,get_token(hd(Rest2)),expected,'}']}})
2461
parse_ValueSetTypeAssignment([{typereference,L1,Name}|Rest]) ->
2462
{Type,Rest2} = parse_Type(Rest),
2464
[{'::=',_}|Rest3] ->
2465
{ValueSet,Rest4} = parse_ValueSet(Rest3),
2466
{#valuedef{pos=L1,name=Name,type=Type,value=ValueSet},Rest4};
2468
throw({asn1_error,{get_line(L1),get(asn1_module),
2469
[got,get_token(H),expected,'::=']}})
2471
parse_ValueSetTypeAssignment(Tokens) ->
2472
throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
2473
[got,get_token(hd(Tokens)),expected,
2476
parse_ValueSet([{'{',_}|Rest]) ->
2477
{Elems,Rest2} = parse_ElementSetSpecs(Rest),
2480
{{valueset,Elems},Rest3};
2482
throw({asn1_error,{get_line(H),get(asn1_module),
2483
[got,get_token(H),expected,'}']}})
2485
parse_ValueSet(Tokens) ->
2486
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2487
[got,get_token(hd(Tokens)),expected,'{']}}).
2489
parse_ValueAssignment([{identifier,L1,IdName}|Rest]) ->
2490
{Type,Rest2} = parse_Type(Rest),
2492
[{'::=',_}|Rest3] ->
2493
{Value,Rest4} = parse_Value(Rest3),
2494
case lookahead_assignment(Rest4) of
2496
{#valuedef{pos=L1,name=IdName,type=Type,value=Value},Rest4};
2498
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
2499
[got,get_token(hd(Rest2)),expected,'::=']}})
2502
throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
2503
[got,get_token(hd(Rest2)),expected,'::=']}})
2505
parse_ValueAssignment(Tokens) ->
2506
throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
2507
[got,get_token(hd(Tokens)),expected,identifier]}}).
2510
parse_SubtypeElements([{'SIZE',_}|Tokens]) ->
2511
{Constraint,Rest} = parse_Constraint(Tokens),
2512
{{'SizeConstraint',Constraint#constraint.c},Rest};
2513
%% PermittedAlphabet
2514
parse_SubtypeElements([{'FROM',_}|Tokens]) ->
2515
{Constraint,Rest} = parse_Constraint(Tokens),
2516
{{'PermittedAlphabet',Constraint#constraint.c},Rest};
2517
%% InnerTypeConstraints
2518
parse_SubtypeElements([{'WITH',_},{'COMPONENT',_}|Tokens]) ->
2519
{Constraint,Rest} = parse_Constraint(Tokens),
2520
{{'WITH COMPONENT',Constraint},Rest};
2521
parse_SubtypeElements([{'WITH',_},{'COMPONENTS',_},{'{',_},{'...',_},{',',_}|Tokens]) ->
2522
{Constraint,Rest} = parse_TypeConstraints(Tokens),
2525
{{'WITH COMPONENTS',{'PartialSpecification',Constraint}},Rest2};
2527
throw({asn1_error,{get_line(hd(Rest)),get(asn1_module),
2528
[got,get_token(hd(Rest)),expected,'}']}})
2530
parse_SubtypeElements([{'WITH',_},{'COMPONENTS',_},{'{',_}|Tokens]) ->
2531
{Constraint,Rest} = parse_TypeConstraints(Tokens),
2534
{{'WITH COMPONENTS',{'FullSpecification',Constraint}},Rest2};
2536
throw({asn1_error,{get_line(hd(Rest)),get(asn1_module),
2537
[got,get_token(hd(Rest)),expected,'}']}})
2543
parse_SubtypeElements(Tokens) ->
2544
Flist = [fun parse_ContainedSubtype/1,
2546
fun([{'MIN',_}|T]) -> {'MIN',T} end,
2548
case (catch parse_or(Tokens,Flist)) of
2551
{asn1_error,Reason} ->
2553
Result = {Val,_} when record(Val,type) ->
2555
{Lower,[{'..',_}|Rest]} ->
2556
{Upper,Rest2} = parse_UpperEndpoint(Rest),
2557
{{'ValueRange',{Lower,Upper}},Rest2};
2558
{Lower,[{'<',_},{'..',_}|Rest]} ->
2559
{Upper,Rest2} = parse_UpperEndpoint(Rest),
2560
{{'ValueRange',{{gt,Lower},Upper}},Rest2};
2561
{Res={'ContainedSubtype',_Type},Rest} ->
2564
{{'SingleValue',Value},Rest}
2567
parse_ContainedSubtype([{'INCLUDES',_}|Rest]) ->
2568
{Type,Rest2} = parse_Type(Rest),
2569
{{'ContainedSubtype',Type},Rest2};
2570
parse_ContainedSubtype(Tokens) ->
2571
throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2572
[got,get_token(hd(Tokens)),expected,'INCLUDES']}}).
2573
%%parse_ContainedSubtype(Tokens) -> %this option is moved to parse_SubtypeElements
2574
%% parse_Type(Tokens).
2576
parse_UpperEndpoint([{'<',_}|Rest]) ->
2577
parse_UpperEndpoint(lt,Rest);
2578
parse_UpperEndpoint(Tokens) ->
2579
parse_UpperEndpoint(false,Tokens).
2581
parse_UpperEndpoint(Lt,Tokens) ->
2582
Flist = [ fun([{'MAX',_}|T]) -> {'MAX',T} end,
2584
case (catch parse_or(Tokens,Flist)) of
2587
AsnErr = {asn1_error,_} ->
2589
{Value,Rest2} when Lt == lt ->
2595
parse_TypeConstraints(Tokens) ->
2596
parse_TypeConstraints(Tokens,[]).
2598
parse_TypeConstraints([{identifier,_,_}|Rest],Acc) ->
2599
{ComponentConstraint,Rest2} = parse_ComponentConstraint(Rest),
2602
parse_TypeConstraints(Rest3,[ComponentConstraint|Acc]);
2604
{lists:reverse([ComponentConstraint|Acc]),Rest2}
2606
parse_TypeConstraints([H|_T],_) ->
2607
throw({asn1_error,{get_line(H),get(asn1_module),
2608
[got,get_token(H),expected,identifier]}}).
2610
parse_ComponentConstraint(Tokens = [{'(',_}|_Rest]) ->
2611
{ValueConstraint,Rest2} = parse_Constraint(Tokens),
2612
{PresenceConstraint,Rest3} = parse_PresenceConstraint(Rest2),
2613
{{ValueConstraint,PresenceConstraint},Rest3};
2614
parse_ComponentConstraint(Tokens) ->
2615
{PresenceConstraint,Rest} = parse_PresenceConstraint(Tokens),
2616
{{asn1_empty,PresenceConstraint},Rest}.
2618
parse_PresenceConstraint([{'PRESENT',_}|Rest]) ->
2620
parse_PresenceConstraint([{'ABSENT',_}|Rest]) ->
2622
parse_PresenceConstraint([{'OPTIONAL',_}|Rest]) ->
2624
parse_PresenceConstraint(Tokens) ->
2625
{asn1_empty,Tokens}.
2628
merge_constraints({Rlist,ExtList}) -> % extensionmarker in constraint
2629
{merge_constraints(Rlist,[],[]),
2630
merge_constraints(ExtList,[],[])};
2632
merge_constraints(Clist) ->
2633
merge_constraints(Clist, [], []).
2635
merge_constraints([Ch|Ct],Cacc, Eacc) ->
2636
NewEacc = case Ch#constraint.e of
2640
merge_constraints(Ct,[fixup_constraint(Ch#constraint.c)|Cacc],NewEacc);
2642
merge_constraints([],Cacc,[]) ->
2643
%% lists:flatten(Cacc);
2644
lists:reverse(Cacc);
2645
merge_constraints([],Cacc,Eacc) ->
2646
%% lists:flatten(Cacc) ++ [{'Errors',Eacc}].
2647
lists:reverse(Cacc) ++ [{'Errors',Eacc}].
2649
fixup_constraint(C) ->
2651
{'SingleValue',SubType} when element(1,SubType) == 'ContainedSubtype' ->
2653
{'SingleValue',V} when list(V) ->
2655
%% [C,{'ValueRange',{lists:min(V),lists:max(V)}}];
2656
%% bug, turns wrong when an element in V is a reference to a defined value
2657
{'PermittedAlphabet',{'SingleValue',V}} when list(V) ->
2658
%%sort and remove duplicates
2659
V2 = {'SingleValue',
2660
ordsets:list_to_set(lists:flatten(V))},
2661
{'PermittedAlphabet',V2};
2662
{'PermittedAlphabet',{'SingleValue',V}} ->
2663
V2 = {'SingleValue',[V]},
2664
{'PermittedAlphabet',V2};
2665
{'SizeConstraint',Sc} ->
2666
{'SizeConstraint',fixup_size_constraint(Sc)};
2668
List when list(List) -> %% In This case maybe a union or intersection
2669
[fixup_constraint(Xc)||Xc <- List];
2674
fixup_size_constraint({'ValueRange',{Lb,Ub}}) ->
2676
fixup_size_constraint({{'ValueRange',R},[]}) ->
2678
fixup_size_constraint({[],{'ValueRange',R}}) ->
2680
fixup_size_constraint({{'ValueRange',R1},{'ValueRange',R2}}) ->
2682
fixup_size_constraint({'SingleValue',[Sv]}) ->
2683
fixup_size_constraint({'SingleValue',Sv});
2684
fixup_size_constraint({'SingleValue',L}) when list(L) ->
2685
ordsets:list_to_set(L);
2686
fixup_size_constraint({'SingleValue',L}) ->
2688
fixup_size_constraint({C1,C2}) ->
2689
{fixup_size_constraint(C1), fixup_size_constraint(C2)}.
2691
get_line({_,Pos,Token}) when integer(Pos),atom(Token) ->
2693
get_line({Token,Pos}) when integer(Pos),atom(Token) ->
2698
get_token({_,Pos,Token}) when integer(Pos),atom(Token) ->
2700
get_token({'$end',Pos}) when integer(Pos) ->
2702
get_token({Token,Pos}) when integer(Pos),atom(Token) ->
2707
prioritize_error(ErrList) ->
2708
case lists:keymember(asn1_error,1,ErrList) of
2709
false -> % only asn1_assignment_error -> take the last
2710
lists:last(ErrList);
2711
true -> % contains errors from deeper in a Type
2712
NewErrList = [_Err={_,_}|_RestErr] =
2713
lists:filter(fun({asn1_error,_})->true;(_)->false end,
2716
lists:splitwith(fun({_,X})->
2717
case element(1,X) of
2718
Int when integer(Int) -> true;
2724
{[],UndefPosErrs} -> % if no error with Positon exists
2725
lists:last(UndefPosErrs);
2727
IntPosReasons = lists:map(fun(X)->element(2,X) end,IntPosErrs),
2728
SortedReasons = lists:keysort(1,IntPosReasons),
2729
{asn1_error,lists:last(SortedReasons)}
2733
%% most_prio_error([H={_,Reason}|T],Atom,Err) when atom(Atom) ->
2734
%% most_prio_error(T,element(1,Reason),H);
2735
%% most_prio_error([H={_,Reason}|T],Greatest,Err) ->
2736
%% case element(1,Reason) of
2737
%% Pos when integer(Pos),Pos>Greatest ->
2741
tref2Exttref(#typereference{pos=Pos,val=Name}) ->
2742
#'Externaltypereference'{pos=Pos,
2743
module=get(asn1_module),
2746
tref2Exttref(Pos,Name) ->
2747
#'Externaltypereference'{pos=Pos,
2748
module=get(asn1_module),
2751
identifier2Extvalueref(#identifier{pos=Pos,val=Name}) ->
2752
#'Externalvaluereference'{pos=Pos,
2753
module=get(asn1_module),
2756
%% lookahead_assignment/1 checks that the next sequence of tokens
2757
%% in Token contain a valid assignment or the
2758
%% 'END' token. Otherwise an exception is thrown.
2759
lookahead_assignment([{'END',_}|_Rest]) ->
2761
lookahead_assignment(Tokens) ->
2762
parse_Assignment(Tokens),
added
removed
lib/dialyzer/test/r9c_tests_SUITE_data/src/asn1/asn1ct_parser2.erl
