← Back to branch summary

~ubuntu-branches/ubuntu/trusty/erlang/trusty

« back to all changes in this revision

Viewing changes to lib/asn1/src/asn1ct_parser2.erl

  • Committer: Bazaar Package Importer
  • Author(s): Clint Byrum
  • Date: 2011-05-05 15:48:43 UTC
  • mfrom: (3.5.13 sid)
  • Revision ID: james.westby@ubuntu.com-20110505154843-0om6ekzg6m7ugj27
Tags: 1:14.b.2-dfsg-3ubuntu1
* Merge from debian unstable.  Remaining changes:
  - Drop libwxgtk2.8-dev build dependency. Wx isn't in main, and not
    supposed to.
  - Drop erlang-wx binary.
  - Drop erlang-wx dependency from -megaco, -common-test, and -reltool, they
    do not really need wx. Also drop it from -debugger; the GUI needs wx,
    but it apparently has CLI bits as well, and is also needed by -megaco,
    so let's keep the package for now.
  - debian/patches/series: Do what I meant, and enable build-options.patch
    instead.
* Additional changes:
  - Drop erlang-wx from -et
* Dropped Changes:
  - patches/pcre-crash.patch: CVE-2008-2371: outer level option with
    alternatives caused crash. (Applied Upstream)
  - fix for ssl certificate verification in newSSL: 
    ssl_cacertfile_fix.patch (Applied Upstream)
  - debian/patches/series: Enable native.patch again, to get stripped beam
    files and reduce the package size again. (build-options is what
    actually accomplished this)
  - Remove build-options.patch on advice from upstream and because it caused
    odd build failures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/asn1/src/asn1ct_parser2.erl
1
1
%%
2
2
%% %CopyrightBegin%
3
 
%% 
4
 
%% Copyright Ericsson AB 2000-2009. All Rights Reserved.
5
 
%% 
 
3
%%
 
4
%% Copyright Ericsson AB 2000-2010. All Rights Reserved.
 
5
%%
6
6
%% The contents of this file are subject to the Erlang Public License,
7
7
%% Version 1.1, (the "License"); you may not use this file except in
8
8
%% compliance with the License. You should have received a copy of the
9
9
%% Erlang Public License along with this software. If not, it can be
10
10
%% retrieved online at http://www.erlang.org/.
11
 
%% 
 
11
%%
12
12
%% Software distributed under the License is distributed on an "AS IS"
13
13
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
14
14
%% the License for the specific language governing rights and limitations
15
15
%% under the License.
16
 
%% 
 
16
%%
17
17
%% %CopyrightEnd%
18
18
%%
19
19
%%
74
74
    {ExtensionDefault,Rest3} = 
75
75
        case Rest2 of
76
76
            [{'EXTENSIBILITY',_L5}, {'IMPLIED',_L6}|Rest21] -> 
77
 
                {'IMPLIED',Rest21};
78
 
            _  -> {false,Rest2}
 
77
                put(extensiondefault,'IMPLIED'),{'IMPLIED',Rest21};
 
78
            _  -> 
 
79
                put(extensiondefault,undefined),{undefined,Rest2}
79
80
        end,
80
81
    case Rest3 of
81
82
        [{'::=',_L7}, {'BEGIN',_L8}|Rest4] ->
417
418
 
418
419
parse_BuiltinType([{'CHOICE',_},{'{',_}|Rest]) ->
419
420
    {AlternativeTypeLists,Rest2} = parse_AlternativeTypeLists(Rest),
 
421
    AlternativeTypeLists1 =
 
422
        lists:filter(fun(#'ExtensionAdditionGroup'{}) -> false;
 
423
                        ('ExtensionAdditionGroupEnd') -> false;
 
424
                        (_) -> true
 
425
                     end,AlternativeTypeLists),
420
426
    case Rest2 of
421
427
        [{'}',_}|Rest3] ->
422
 
            {#type{def={'CHOICE',AlternativeTypeLists}},Rest3};
 
428
            AlternativeTypeLists2 =
 
429
                case {[Ext||Ext = #'EXTENSIONMARK'{} <- AlternativeTypeLists1],
 
430
                      get(extensiondefault)} of
 
431
                    {[],'IMPLIED'} ->  AlternativeTypeLists1 ++ [#'EXTENSIONMARK'{}];
 
432
                    _ -> AlternativeTypeLists1
 
433
                end,
 
434
 
 
435
            {#type{def={'CHOICE',AlternativeTypeLists2}},Rest3};
423
436
        _  ->
424
437
            throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
425
438
                               [got,get_token(hd(Rest2)),expected,'}']}})
427
440
parse_BuiltinType([{'EMBEDDED',_},{'PDV',_}|Rest]) ->
428
441
    {#type{def='EMBEDDED PDV'},Rest};
429
442
parse_BuiltinType([{'ENUMERATED',_},{'{',_}|Rest]) ->
430
 
    {Enumerations,Rest2} = parse_Enumerations(Rest),
 
443
    {Enumerations,Rest2} = parse_Enumerations(Rest,get(extensiondefault)),
431
444
    case Rest2 of
432
445
        [{'}',_}|Rest3] ->
433
446
            {#type{def={'ENUMERATED',Enumerations}},Rest3};
478
491
    {#type{def='REAL'},Rest};
479
492
parse_BuiltinType([{'RELATIVE-OID',_}|Rest]) ->
480
493
    {#type{def='RELATIVE-OID'},Rest};
 
494
parse_BuiltinType([{'SEQUENCE',_},{'{',_},{'}',_}|Rest]) ->
 
495
    {#type{def=#'SEQUENCE'{components=[]}},
 
496
     Rest};
481
497
parse_BuiltinType([{'SEQUENCE',_},{'{',_},{'...',Line},{'}',_}|Rest]) ->
482
 
    {#type{def=#'SEQUENCE'{components=[{'EXTENSIONMARK',Line,undefined}]}},
483
 
     Rest};
 
498
    {#type{def=#'SEQUENCE'{components=[#'EXTENSIONMARK'{pos = Line}]}},Rest};
484
499
parse_BuiltinType([{'SEQUENCE',_},{'{',_},{'...',Line},{'!',_}|Rest]) ->
485
500
    {ExceptionIdentification,Rest2} = parse_ExceptionIdentification(Rest),
486
501
    case Rest2 of
487
502
        [{'}',_}|Rest3] ->
488
 
            {#type{def=#'SEQUENCE'{components=[{'EXTENSIONMARK',
489
 
                                                Line,
490
 
                                                ExceptionIdentification}]}},
 
503
            {#type{def=#'SEQUENCE'{
 
504
                     components=[#'EXTENSIONMARK'{
 
505
                                    pos = Line,
 
506
                                    val = ExceptionIdentification}]}},
491
507
             Rest3};
492
508
        _ ->
493
 
            {ComponentTypeLists,Rest3}=parse_ComponentTypeLists2(Rest2,[#'EXTENSIONMARK'{pos=Line}]),
 
509
            {ComponentTypeLists,Rest3}=
 
510
                parse_ComponentTypeLists2(Rest2,[#'EXTENSIONMARK'{pos=Line}]),
494
511
            case Rest3 of
495
512
                [{'}',_}|Rest4] ->
496
513
            {#type{def=#'SEQUENCE'{components=ComponentTypeLists}},Rest4};
506
523
    {ComponentTypeLists,Rest2} = parse_ComponentTypeLists(Rest),
507
524
    case Rest2  of
508
525
        [{'}',_}|Rest3] ->
509
 
            {#type{def=#'SEQUENCE'{components=ComponentTypeLists}},Rest3};
 
526
            ComponentTypeLists2 =
 
527
                case {[Ext||Ext = #'EXTENSIONMARK'{} <- ComponentTypeLists],
 
528
                      get(extensiondefault)} of
 
529
                    {[],'IMPLIED'} ->  ComponentTypeLists ++ [#'EXTENSIONMARK'{}];
 
530
                    _ -> ComponentTypeLists
 
531
                end,
 
532
            {#type{def=#'SEQUENCE'{components = ComponentTypeLists2}},
 
533
             Rest3};
510
534
        _ ->
511
535
            throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
512
536
                               [got,get_token(hd(Rest2)),expected,'}']}})
513
537
    end;
 
538
 
 
539
parse_BuiltinType([{'SEQUENCE',_},{'OF',_},Id={identifier,_,_},Lt={'<',_}|Rest]) ->
 
540
%% TODO: take care of the identifier for something useful
 
541
    {Type,Rest2} = parse_SelectionType([Id,Lt|Rest]),
 
542
    {#type{def={'SEQUENCE OF',#type{def=Type,tag=[]}}},Rest2};
 
543
 
 
544
parse_BuiltinType([{'SEQUENCE',_},{'OF',_},{identifier,_,_} |Rest]) ->
 
545
%% TODO: take care of the identifier for something useful
 
546
    {Type,Rest2} = parse_Type(Rest),
 
547
    {#type{def={'SEQUENCE OF',Type}},Rest2};
 
548
 
514
549
parse_BuiltinType([{'SEQUENCE',_},{'OF',_}|Rest]) ->
515
550
    {Type,Rest2} = parse_Type(Rest),
516
551
    {#type{def={'SEQUENCE OF',Type}},Rest2};
517
552
 
518
553
 
519
554
parse_BuiltinType([{'SET',_},{'{',_},{'...',Line},{'}',_}|Rest]) ->
520
 
    {#type{def=#'SET'{components=[{'EXTENSIONMARK',Line,undefined}]}},Rest};
 
555
    {#type{def=#'SET'{components=[#'EXTENSIONMARK'{pos = Line}]}},Rest};
521
556
parse_BuiltinType([{'SET',_},{'{',_},{'...',Line},{'!',_}|Rest]) ->
522
557
    {ExceptionIdentification,Rest2} = parse_ExceptionIdentification(Rest),
523
558
    case Rest2 of
524
559
        [{'}',_}|Rest3] ->
525
560
            {#type{def=#'SET'{components=
526
 
                              [{'EXTENSIONMARK',Line,ExceptionIdentification}]}},
 
561
                              [#'EXTENSIONMARK'{pos = Line,
 
562
                                                val = ExceptionIdentification}]}},
527
563
             Rest3};
528
564
        _ ->
529
565
            throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
533
569
    {ComponentTypeLists,Rest2} = parse_ComponentTypeLists(Rest),
534
570
    case Rest2  of
535
571
        [{'}',_}|Rest3] ->
536
 
            {#type{def=#'SET'{components=ComponentTypeLists}},Rest3};
 
572
            ComponentTypeLists2 =
 
573
                case {[Ext||Ext = #'EXTENSIONMARK'{} <- ComponentTypeLists],
 
574
                      get(extensiondefault)} of
 
575
                    {[],'IMPLIED'} ->  ComponentTypeLists ++ [#'EXTENSIONMARK'{}];
 
576
                    _ -> ComponentTypeLists
 
577
                end,
 
578
            {#type{def=#'SET'{components = ComponentTypeLists2}},
 
579
             Rest3};
537
580
        _ ->
538
581
            throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
539
582
                               [got,get_token(hd(Rest2)),expected,'}']}})
540
583
    end;
 
584
 
 
585
parse_BuiltinType([{'SET',_},{'OF',_},Id={identifier,_,_},Lt={'<',_}|Rest]) ->
 
586
%% TODO: take care of the identifier for something useful
 
587
    {Type,Rest2} = parse_SelectionType([Id,Lt|Rest]),
 
588
    {#type{def={'SET OF',#type{def=Type,tag=[]}}},Rest2};
 
589
 
 
590
 
 
591
parse_BuiltinType([{'SET',_},{'OF',_},{identifier,_,_}|Rest]) ->
 
592
%%TODO: take care of the identifier for something useful
 
593
    {Type,Rest2} = parse_Type(Rest),
 
594
    {#type{def={'SET OF',Type}},Rest2};
 
595
 
541
596
parse_BuiltinType([{'SET',_},{'OF',_}|Rest]) ->
542
597
    {Type,Rest2} = parse_Type(Rest),
543
598
    {#type{def={'SET OF',Type}},Rest2};
563
618
 
564
619
parse_TypeWithConstraint([{'SEQUENCE',_},Lpar = {'(',_}|Rest]) ->
565
620
    {Constraint,Rest2} = parse_Constraint([Lpar|Rest]),
566
 
    case Rest2 of
567
 
        [{'OF',_}|Rest3] ->
568
 
            {Type,Rest4} = parse_Type(Rest3),
569
 
            {#type{def = {'SEQUENCE OF',Type}, constraint = merge_constraints([Constraint])},Rest4};
570
 
        _ ->
571
 
            throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
572
 
                               [got,get_token(hd(Rest2)),expected,'OF']}})
573
 
    end;
 
621
    Rest4 = case Rest2 of
 
622
                [{'OF',_}, {identifier,_,_Id}|Rest3] ->
 
623
%%% TODO: make some use of the identifier, maybe useful in the XML mapping
 
624
                    Rest3;
 
625
                [{'OF',_}|Rest3] ->
 
626
                    Rest3;
 
627
                _ ->
 
628
                    throw({asn1_error,
 
629
                           {get_line(hd(Rest2)),get(asn1_module),
 
630
                            [got,get_token(hd(Rest2)),expected,'OF']}})
 
631
            end,
 
632
    {Type,Rest5} = parse_Type(Rest4),
 
633
    {#type{def = {'SEQUENCE OF',Type},
 
634
           constraint = merge_constraints([Constraint])},Rest5};
 
635
 
574
636
parse_TypeWithConstraint([{'SEQUENCE',_},{'SIZE',_},Lpar = {'(',_}|Rest]) ->
575
637
    {Constraint,Rest2} = parse_Constraint([Lpar|Rest]),
576
638
    #constraint{c=C} = Constraint,
577
639
    Constraint2 = Constraint#constraint{c={'SizeConstraint',C}},
578
 
    case Rest2 of
579
 
        [{'OF',_}|Rest3] ->
580
 
            {Type,Rest4} = parse_Type(Rest3),
581
 
            {#type{def = {'SEQUENCE OF',Type}, constraint = merge_constraints([Constraint2])},Rest4};
582
 
        _ ->
583
 
            throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
584
 
                               [got,get_token(hd(Rest2)),expected,'OF']}})
585
 
    end;
 
640
    Rest4 = case Rest2 of
 
641
                [{'OF',_}, {identifier,_,_Id}|Rest3] ->
 
642
%%% TODO: make some use of the identifier, maybe useful in the XML mapping
 
643
                    Rest3;
 
644
                [{'OF',_}|Rest3] ->
 
645
                    Rest3;
 
646
                _ ->
 
647
                    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
 
648
                                       [got,get_token(hd(Rest2)),expected,'OF']}})
 
649
            end,
 
650
    {Type,Rest5} = parse_Type(Rest4),
 
651
    {#type{def = {'SEQUENCE OF',Type}, constraint = merge_constraints([Constraint2])},Rest5};
 
652
 
586
653
parse_TypeWithConstraint([{'SET',_},Lpar = {'(',_}|Rest]) ->
587
654
    {Constraint,Rest2} = parse_Constraint([Lpar|Rest]),
588
 
    case Rest2 of
589
 
        [{'OF',_}|Rest3] ->
590
 
            {Type,Rest4} = parse_Type(Rest3),
591
 
            {#type{def = {'SET OF',Type}, constraint = merge_constraints([Constraint])},Rest4};
592
 
        _ ->
593
 
            throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
594
 
                               [got,get_token(hd(Rest2)),expected,'OF']}})
595
 
    end;
 
655
    Rest4 = case Rest2 of
 
656
                [{'OF',_}, {identifier,_,_Id}|Rest3] ->
 
657
%%% TODO: make some use of the identifier, maybe useful in the XML mapping
 
658
                    Rest3;
 
659
                [{'OF',_}|Rest3] ->
 
660
                    Rest3;
 
661
                _ ->
 
662
                    throw({asn1_error,
 
663
                           {get_line(hd(Rest2)),get(asn1_module),
 
664
                            [got,get_token(hd(Rest2)),expected,'OF']}})
 
665
            end,
 
666
    {Type,Rest5} = parse_Type(Rest4),
 
667
    {#type{def = {'SET OF',Type},
 
668
           constraint = merge_constraints([Constraint])},Rest5};
 
669
 
596
670
parse_TypeWithConstraint([{'SET',_},{'SIZE',_},Lpar = {'(',_}|Rest]) ->
597
671
    {Constraint,Rest2} = parse_Constraint([Lpar|Rest]),
598
672
    #constraint{c=C} = Constraint,
599
673
    Constraint2 = Constraint#constraint{c={'SizeConstraint',C}},
600
 
    case Rest2 of
601
 
        [{'OF',_}|Rest3] ->
602
 
            {Type,Rest4} = parse_Type(Rest3),
603
 
            {#type{def = {'SET OF',Type}, constraint = merge_constraints([Constraint2])},Rest4};
604
 
        _ ->
605
 
            throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
606
 
                               [got,get_token(hd(Rest2)),expected,'OF']}})
607
 
    end;
 
674
    Rest4 = case Rest2 of
 
675
                [{'OF',_}, {identifier,_,_Id}|Rest3] ->
 
676
%%% TODO: make some use of the identifier, maybe useful in the XML mapping
 
677
                    Rest3;
 
678
                [{'OF',_}|Rest3] ->
 
679
                    Rest3;
 
680
                _ ->
 
681
                    throw({asn1_error,
 
682
                           {get_line(hd(Rest2)),get(asn1_module),
 
683
                            [got,get_token(hd(Rest2)),expected,'OF']}})
 
684
            end,
 
685
    {Type,Rest5} = parse_Type(Rest4),
 
686
    {#type{def = {'SET OF',Type},
 
687
           constraint = merge_constraints([Constraint2])},Rest5};
 
688
 
608
689
parse_TypeWithConstraint(Tokens) ->
609
690
    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
610
691
                       [got,get_token(hd(Tokens)),expected,
2258
2339
to_set(V) ->
2259
2340
        ordsets:from_list([V]).
2260
2341
 
2261
 
 
2262
2342
parse_AlternativeTypeLists(Tokens) ->
2263
 
    {AlternativeTypeList,Rest1} = parse_AlternativeTypeList(Tokens),
2264
 
    {ExtensionAndException,Rest2} = 
2265
 
        case Rest1 of
2266
 
            [{',',_},{'...',L1},{'!',_}|Rest12] ->
2267
 
                {_,Rest13} = parse_ExceptionIdentification(Rest12),
2268
 
                %% Exception info is currently thrown away
2269
 
                {[#'EXTENSIONMARK'{pos=L1}],Rest13};
2270
 
            [{',',_},{'...',L1}|Rest12] ->
2271
 
                {[#'EXTENSIONMARK'{pos=L1}],Rest12};
2272
 
            _ ->
2273
 
                {[],Rest1}
2274
 
        end,
2275
 
    case ExtensionAndException of
2276
 
        [] ->
2277
 
            {AlternativeTypeList,Rest2};
 
2343
    parse_AlternativeTypeLists(Tokens,[]).
 
2344
 
 
2345
parse_AlternativeTypeLists(Tokens = [{identifier,_,_}|_Rest0],Clist) ->
 
2346
    {CompList,Rest1} = parse_AlternativeTypeList(Tokens,[]),
 
2347
    parse_AlternativeTypeLists(Rest1,Clist++CompList);
 
2348
parse_AlternativeTypeLists([{'...',L1},{'!',_}|Rest02],Clist0) ->
 
2349
    {_,Rest03} = parse_ExceptionIdentification(Rest02),
 
2350
    %% Exception info is currently thrown away
 
2351
    parse_AlternativeTypeLists2(Rest03,Clist0++[#'EXTENSIONMARK'{pos=L1}]);
 
2352
parse_AlternativeTypeLists([{',',L1},{'...',_},{'!',_}|Rest02],Clist0) when Clist0 =/= []->
 
2353
    {_,Rest03} = parse_ExceptionIdentification(Rest02),
 
2354
    %% Exception info is currently thrown away
 
2355
    parse_AlternativeTypeLists2(Rest03,Clist0++[#'EXTENSIONMARK'{pos=L1}]);
 
2356
 
 
2357
parse_AlternativeTypeLists([{',',_},{'...',L1}|Rest02],Clist0) when Clist0 =/= []->
 
2358
    parse_AlternativeTypeLists2(Rest02,Clist0++[#'EXTENSIONMARK'{pos=L1}]);
 
2359
parse_AlternativeTypeLists([{'...',L1}|Rest02],Clist0) ->
 
2360
    parse_AlternativeTypeLists2(Rest02,Clist0++[#'EXTENSIONMARK'{pos=L1}]);
 
2361
parse_AlternativeTypeLists(Tokens = [{'}',_L1}|_Rest02],Clist0) ->
 
2362
    {Clist0,Tokens}.
 
2363
 
 
2364
parse_AlternativeTypeLists2(Tokens,Clist) ->
 
2365
    {ExtAdd,Rest} = parse_ExtensionAdditionAlternatives(Tokens,Clist),
 
2366
    {Clist2,Rest2} = parse_OptionalExtensionMarker(Rest,lists:flatten(ExtAdd)),
 
2367
    case Rest2 of
 
2368
        [{',',_}|Rest3] ->
 
2369
            {CompList,Rest4} = parse_AlternativeTypeList(Rest3,[]),
 
2370
            {Clist2 ++ CompList,Rest4};
2278
2371
        _ ->
2279
 
            {ExtensionAddition,Rest3} = 
2280
 
                case Rest2 of
2281
 
                    [{',',_}|Rest23] ->
2282
 
                        parse_ExtensionAdditionAlternativeList(Rest23);
2283
 
                    _ ->
2284
 
                        {[],Rest2}
2285
 
                end,
2286
 
            {OptionalExtensionMarker,Rest4} =
2287
 
                case Rest3 of
2288
 
                    [{',',_},{'...',L3}|Rest31] ->
2289
 
                        {[#'EXTENSIONMARK'{pos=L3}],Rest31};
2290
 
                    _ ->
2291
 
                        {[],Rest3}
2292
 
                end,
2293
 
            {AlternativeTypeList ++ ExtensionAndException ++ ExtensionAddition ++ OptionalExtensionMarker, Rest4}
 
2372
            {Clist2,Rest2}
2294
2373
    end.
2295
 
    
2296
 
 
2297
 
parse_AlternativeTypeList(Tokens) ->
2298
 
    parse_AlternativeTypeList(Tokens,[]).
2299
 
 
2300
 
parse_AlternativeTypeList(Tokens,Acc) ->
2301
 
    {NamedType,Rest} = parse_NamedType(Tokens),
 
2374
 
 
2375
 
 
2376
 
 
2377
parse_AlternativeTypeList([{',',_},Id = {identifier,_,_}|Rest],Acc) when Acc =/= [] ->
 
2378
    {AlternativeType,Rest2} = parse_NamedType([Id|Rest]),
 
2379
    parse_AlternativeTypeList(Rest2,[AlternativeType|Acc]);
 
2380
parse_AlternativeTypeList(Tokens = [{'}',_}|_],Acc) ->
 
2381
    {lists:reverse(Acc),Tokens};
 
2382
parse_AlternativeTypeList(Tokens = [{']',_},{']',_}|_],Acc) ->
 
2383
    {lists:reverse(Acc),Tokens};
 
2384
parse_AlternativeTypeList(Tokens = [{',',_},{'...',_}|_],Acc) ->
 
2385
    {lists:reverse(Acc),Tokens};
 
2386
parse_AlternativeTypeList(Tokens,[]) ->
 
2387
    {AlternativeType,Rest} = parse_NamedType(Tokens),
 
2388
    parse_AlternativeTypeList(Rest,[AlternativeType]);
 
2389
parse_AlternativeTypeList(Tokens,_) ->
 
2390
    throw({asn1_error,
 
2391
           {get_line(hd(Tokens)),get(asn1_module),
 
2392
            [got,[get_token(hd(Tokens)),get_token(hd(tl(Tokens)))],
 
2393
             expected,['}',', identifier']]}}).
 
2394
 
 
2395
parse_ExtensionAdditionAlternatives(Tokens =[{',',_}|_],Clist) ->
 
2396
    {ExtAddList,Rest2} = parse_ExtensionAdditionAlternativesList(Tokens,[]),
 
2397
    {Clist++lists:flatten(ExtAddList),Rest2};
 
2398
parse_ExtensionAdditionAlternatives(Tokens,Clist) ->
 
2399
    %% Empty
 
2400
    {Clist,Tokens}.
 
2401
 
 
2402
parse_ExtensionAdditionAlternativesList([{',',_},Id = {identifier,_,_}|Rest],Acc) ->
 
2403
    {AlternativeType,Rest2} = parse_NamedType([Id|Rest]),
 
2404
    parse_ExtensionAdditionAlternativesList(Rest2,[AlternativeType|Acc]);
 
2405
parse_ExtensionAdditionAlternativesList([{',',_},C1 = {'[',_},C2 = {'[',_}|Rest],Acc) ->
 
2406
    {ExtAddGroup,Rest2} = parse_ExtensionAdditionAlternativesGroup([C1,C2|Rest],[]),
 
2407
    parse_ExtensionAdditionAlternativesList(Rest2,[ExtAddGroup|Acc]);
 
2408
parse_ExtensionAdditionAlternativesList(Tokens = [{'}',_}|_],Acc) ->
 
2409
    {lists:reverse(Acc),Tokens};
 
2410
parse_ExtensionAdditionAlternativesList(Tokens = [{',',_},{'...',_}|_],Acc) ->
 
2411
    {lists:reverse(Acc),Tokens};
 
2412
parse_ExtensionAdditionAlternativesList(Tokens,_) ->
 
2413
    throw({asn1_error,
 
2414
           {get_line(hd(Tokens)),get(asn1_module),
 
2415
            [got,[get_token(hd(Tokens)),get_token(hd(tl(Tokens)))],
 
2416
             expected,['}',', identifier']]}}).
 
2417
 
 
2418
 
 
2419
parse_ExtensionAdditionAlternativesGroup([ {'[',_},{'[',_},_VsnNr = {number,_,Num},{':',_}|Rest],[]) ->
 
2420
    parse_ExtensionAdditionAlternativesGroup2(Rest,Num);
 
2421
parse_ExtensionAdditionAlternativesGroup([ {'[',_},{'[',_}|Rest],[]) ->
 
2422
    parse_ExtensionAdditionAlternativesGroup2(Rest,undefined);
 
2423
parse_ExtensionAdditionAlternativesGroup(Tokens,_) ->
 
2424
    throw({asn1_error,
 
2425
           {get_line(hd(Tokens)),get(asn1_module),
 
2426
            [got,[get_token(hd(Tokens)),get_token(hd(tl(Tokens)))],
 
2427
             expected,['[[']]}}).
 
2428
 
 
2429
 
 
2430
parse_ExtensionAdditionAlternativesGroup2(Tokens,Num) ->
 
2431
    {CompTypeList,Rest} = parse_AlternativeTypeList(Tokens,[]),
2302
2432
    case Rest of
2303
 
        [{',',_},Id = {identifier,_,_}|Rest2] ->
2304
 
            parse_AlternativeTypeList([Id|Rest2],[NamedType|Acc]);
2305
 
        _ ->
2306
 
            {lists:reverse([NamedType|Acc]),Rest}
2307
 
    end.
2308
 
 
2309
 
    
2310
 
 
2311
 
parse_ExtensionAdditionAlternativeList(Tokens) ->
2312
 
    parse_ExtensionAdditionAlternativeList(Tokens,[]).
2313
 
    
2314
 
parse_ExtensionAdditionAlternativeList(Tokens,Acc) ->
2315
 
    {Element,Rest0} =
2316
 
        case Tokens of
2317
 
            [{identifier,_,_}|_Rest] ->
2318
 
                parse_NamedType(Tokens);
2319
 
            [{'[',_},{'[',_}|_] ->
2320
 
                parse_ExtensionAdditionAlternatives(Tokens)
2321
 
        end,
2322
 
    case Rest0 of
2323
 
        [{',',_}|Rest01] ->
2324
 
            parse_ExtensionAdditionAlternativeList(Rest01,[Element|Acc]);
2325
 
        _  ->
2326
 
            {lists:reverse([Element|Acc]),Rest0}
2327
 
    end.
2328
 
 
2329
 
parse_ExtensionAdditionAlternatives([{'[',_},{'[',_}|Rest]) ->
2330
 
    parse_ExtensionAdditionAlternatives(Rest,[]);
2331
 
parse_ExtensionAdditionAlternatives(Tokens) ->
2332
 
    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2333
 
                       [got,get_token(hd(Tokens)),expected,'[[']}}).
2334
 
 
2335
 
parse_ExtensionAdditionAlternatives([Id = {identifier,_,_}|Rest],Acc) ->
2336
 
    {NamedType, Rest2} = parse_NamedType([Id|Rest]),
2337
 
    case Rest2 of
2338
 
        [{',',_}|Rest21] ->
2339
 
            parse_ExtensionAdditionAlternatives(Rest21,[NamedType|Acc]);
2340
 
        [{']',_},{']',_}|Rest21] ->
2341
 
            {lists:reverse(Acc),Rest21};
2342
 
        _ ->
2343
 
            throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
2344
 
                               [got,get_token(hd(Rest2)),expected,[',',']]']]}})
2345
 
    end.
 
2433
        [{']',_},{']',_}|Rest2] ->
 
2434
            {[{'ExtensionAdditionGroup',Num}|CompTypeList] ++
 
2435
                ['ExtensionAdditionGroupEnd'],Rest2};
 
2436
        _ ->
 
2437
            throw({asn1_error,{get_line(hd(Rest)),get(asn1_module),
 
2438
                               [got,get_token(hd(Rest)),expected,[']]']]}})
 
2439
    end.
 
2440
 
 
2441
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
2442
 
 
2443
%% parse_AlternativeTypeLists(Tokens,ExtensionDefault) ->
 
2444
%%     {AltTypeList,Rest1} = parse_AlternativeTypeList(Tokens),
 
2445
%%     {ExtensionAndException,Rest2} =
 
2446
%%      case Rest1 of
 
2447
%%          [{',',_},{'...',L1},{'!',_}|Rest12] ->
 
2448
%%              {_,Rest13} = parse_ExceptionIdentification(Rest12),
 
2449
%%              %% Exception info is currently thrown away
 
2450
%%              {[#'EXTENSIONMARK'{pos=L1}],Rest13};
 
2451
%%          [{',',_},{'...',L1}|Rest12] ->
 
2452
%%              {[#'EXTENSIONMARK'{pos=L1}],Rest12};
 
2453
%%          _ ->
 
2454
%%              {[],Rest1}
 
2455
%%      end,
 
2456
%%     {AltTypeList2,Rest5} =
 
2457
%%      case ExtensionAndException of
 
2458
%%          [] ->
 
2459
%%              {AltTypeList,Rest2};
 
2460
%%          _ ->
 
2461
%%              {ExtensionAddition,Rest3} =
 
2462
%%                  case Rest2 of
 
2463
%%                      [{',',_}|Rest23] ->
 
2464
%%                          parse_ExtensionAdditionAlternativeList(Rest23);
 
2465
%%                      _ ->
 
2466
%%                          {[],Rest2}
 
2467
%%                  end,
 
2468
%%              {OptionalExtensionMarker,Rest4} =
 
2469
%%                  case Rest3 of
 
2470
%%                      [{',',_},{'...',L3}|Rest31] ->
 
2471
%%                          {[#'EXTENSIONMARK'{pos=L3}],Rest31};
 
2472
%%                      _ ->
 
2473
%%                          {[],Rest3}
 
2474
%%                  end,
 
2475
%%              {AltTypeList ++ ExtensionAndException ++
 
2476
%%               ExtensionAddition ++ OptionalExtensionMarker, Rest4}
 
2477
%%      end,
 
2478
%%     AltTypeList3 =
 
2479
%%      case [X || X=#'EXTENSIONMARK'{} <- AltTypeList2] of
 
2480
%%          [] when ExtensionDefault == 'IMPLIED' ->
 
2481
%%              AltTypeList2 ++ [#'EXTENSIONMARK'{}];
 
2482
%%          _ ->
 
2483
%%              AltTypeList2
 
2484
%%      end,
 
2485
%%     {AltTypeList3,Rest5}.
 
2486
    
 
2487
 
 
2488
%% parse_AlternativeTypeList(Tokens) ->
 
2489
%%     parse_AlternativeTypeList(Tokens,[]).
 
2490
 
 
2491
%% parse_AlternativeTypeList(Tokens,Acc) ->
 
2492
%%     {NamedType,Rest} = parse_NamedType(Tokens),
 
2493
%%     case Rest of
 
2494
%%      [{',',_},Id = {identifier,_,_}|Rest2] ->
 
2495
%%          parse_AlternativeTypeList([Id|Rest2],[NamedType|Acc]);
 
2496
%%      _ ->
 
2497
%%          {lists:reverse([NamedType|Acc]),Rest}
 
2498
%%     end.
 
2499
 
 
2500
    
 
2501
 
 
2502
%% parse_ExtensionAdditionAlternativeList(Tokens) ->
 
2503
%%     parse_ExtensionAdditionAlternativeList(Tokens,[]).
 
2504
 
 
2505
%% parse_ExtensionAdditionAlternativeList([{'[[',_}|Rest],Acc) ->
 
2506
%%     parse_ExtensionAdditionAlternativeList(Rest,Acc);
 
2507
%% parse_ExtensionAdditionAlternativeList(Tokens = [{identifier,_,_}|_Rest],Acc) ->
 
2508
%%     {Element,Rest0} = parse_NamedType(Tokens);
 
2509
%%     case Rest0 of
 
2510
%%      [{',',_}|Rest01] ->
 
2511
%%          parse_ExtensionAdditionAlternativeList(Rest01,[Element|Acc]);
 
2512
%%      _  ->
 
2513
%%          {lists:reverse([Element|Acc]),Rest0}
 
2514
%%     end.
 
2515
 
 
2516
%% parse_ExtensionAdditionAlternatives([{'[[',_}|Rest]) ->
 
2517
%%     parse_ExtensionAdditionAlternatives(Rest,[]);
 
2518
%% parse_ExtensionAdditionAlternatives(Tokens) ->
 
2519
%%     throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
 
2520
%%                     [got,get_token(hd(Tokens)),expected,'[[']}}).
 
2521
 
 
2522
%% parse_ExtensionAdditionAlternatives([Id = {identifier,_,_}|Rest],Acc) ->
 
2523
%%     {NamedType, Rest2} = parse_NamedType([Id|Rest]),
 
2524
%%     case Rest2 of
 
2525
%%      [{',',_}|Rest21] ->
 
2526
%%          parse_ExtensionAdditionAlternatives(Rest21,[NamedType|Acc]);
 
2527
%%      [{']]',_}|Rest21] ->
 
2528
%%          {lists:reverse(Acc),Rest21};
 
2529
%%      _ ->
 
2530
%%          throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
 
2531
%%                             [got,get_token(hd(Rest2)),expected,[',',']]']]}})
 
2532
%%     end.
2346
2533
 
2347
2534
parse_NamedType([{identifier,L1,Idname}|Rest]) ->
2348
2535
    {Type,Rest2} = parse_Type(Rest),
2353
2540
 
2354
2541
 
2355
2542
parse_ComponentTypeLists(Tokens) ->
2356
 
%    Resulting tuple {ComponentTypeList,Rest1} is returned
2357
 
    case Tokens of 
2358
 
        [{identifier,_,_}|_Rest0] ->
2359
 
            {Clist,Rest01} = parse_ComponentTypeList(Tokens),
2360
 
            case Rest01 of
2361
 
                [{',',_}|Rest02] -> 
2362
 
                    parse_ComponentTypeLists(Rest02,Clist); % 5 - 13
2363
 
                _ ->
2364
 
                    {Clist,Rest01}
2365
 
            end;
2366
 
        [{'COMPONENTS',_},{'OF',_}|_Rest] ->
2367
 
            {Clist,Rest01} = parse_ComponentTypeList(Tokens),
2368
 
            case Rest01 of
2369
 
                [{',',_}|Rest02] -> 
2370
 
                    parse_ComponentTypeLists(Rest02,Clist);
2371
 
                _ ->
2372
 
                    {Clist,Rest01}
2373
 
            end;
 
2543
    parse_ComponentTypeLists(Tokens,[]).
 
2544
 
 
2545
parse_ComponentTypeLists(Tokens = [{identifier,_,_}|_Rest0],Clist) ->
 
2546
    {CompList,Rest1} = parse_ComponentTypeList(Tokens,[]),
 
2547
    parse_ComponentTypeLists(Rest1,Clist++CompList);
 
2548
parse_ComponentTypeLists(Tokens = [{'COMPONENTS',_},{'OF',_}|_Rest],Clist) ->
 
2549
    {CompList,Rest1} = parse_ComponentTypeList(Tokens,[]),
 
2550
    parse_ComponentTypeLists(Rest1,Clist++CompList);
 
2551
parse_ComponentTypeLists([{'...',L1},{'!',_}|Rest02],Clist0) ->
 
2552
    {_,Rest03} = parse_ExceptionIdentification(Rest02),
 
2553
    %% Exception info is currently thrown away
 
2554
    parse_ComponentTypeLists2(Rest03,Clist0++[#'EXTENSIONMARK'{pos=L1}]);
 
2555
parse_ComponentTypeLists([{',',L1},{'...',_},{'!',_}|Rest02],Clist0) when Clist0 =/= []->
 
2556
    {_,Rest03} = parse_ExceptionIdentification(Rest02),
 
2557
    %% Exception info is currently thrown away
 
2558
    parse_ComponentTypeLists2(Rest03,Clist0++[#'EXTENSIONMARK'{pos=L1}]);
 
2559
 
 
2560
 parse_ComponentTypeLists([{',',_},{'...',L1}|Rest02],Clist0) when Clist0 =/= []->
 
2561
    parse_ComponentTypeLists2(Rest02,Clist0++[#'EXTENSIONMARK'{pos=L1}]);
 
2562
parse_ComponentTypeLists([{'...',L1}|Rest02],Clist0) ->
 
2563
    parse_ComponentTypeLists2(Rest02,Clist0++[#'EXTENSIONMARK'{pos=L1}]);
 
2564
parse_ComponentTypeLists(Tokens = [{'}',_L1}|_Rest02],Clist0) ->
 
2565
    {Clist0,Tokens}.
 
2566
 
 
2567
parse_ComponentTypeLists2(Tokens,Clist) ->
 
2568
    {ExtAdd,Rest} = parse_ExtensionAdditions(Tokens,Clist),
 
2569
    {Clist2,Rest2} = parse_OptionalExtensionMarker(Rest,lists:flatten(ExtAdd)),
 
2570
    case Rest2 of
 
2571
        [{',',_}|Rest3] ->
 
2572
            {CompList,Rest4} = parse_ComponentTypeList(Rest3,[]),
 
2573
            {Clist2 ++ CompList,Rest4};
2374
2574
        _ ->
2375
 
            parse_ComponentTypeLists(Tokens,[])
 
2575
            {Clist2,Rest2}
2376
2576
    end.
2377
2577
 
2378
 
parse_ComponentTypeLists([{'...',L1},{'!',_}|Rest],Clist1) ->
2379
 
    {_,Rest2} = parse_ExceptionIdentification(Rest),
2380
 
    %% Exception info is currently thrown away
2381
 
    parse_ComponentTypeLists2(Rest2,Clist1++[#'EXTENSIONMARK'{pos=L1}]);
2382
 
parse_ComponentTypeLists([{'...',L1}|Rest],Clist1) -> %% first Extensionmark
2383
 
    parse_ComponentTypeLists2(Rest,Clist1++[#'EXTENSIONMARK'{pos=L1}]);
2384
 
parse_ComponentTypeLists(Tokens,Clist1) ->
2385
 
    {Clist1,Tokens}.
2386
 
 
2387
 
 
2388
 
parse_ComponentTypeLists2(Tokens,Clist1) ->
2389
 
    {ExtensionAddition,Rest2} = 
2390
 
        case Tokens of
2391
 
            [{',',_}|Rest1] ->
2392
 
                parse_ExtensionAdditionList(Rest1);
2393
 
            _ ->
2394
 
                {[],Tokens}
2395
 
        end,
2396
 
    {OptionalExtensionMarker,Rest3} =
2397
 
        case Rest2 of
2398
 
            [{',',_},{'...',L2}|Rest21] ->
2399
 
                {[#'EXTENSIONMARK'{pos=L2}],Rest21};
2400
 
            _ ->
2401
 
                {[],Rest2}
2402
 
        end,
2403
 
    {RootComponentTypeList,Rest4} =
2404
 
        case Rest3 of
2405
 
            [{',',_}|Rest31] ->
2406
 
                parse_ComponentTypeList(Rest31);
2407
 
            _ ->
2408
 
                {[],Rest3}
2409
 
        end,
2410
 
    {Clist1 ++ ExtensionAddition ++ OptionalExtensionMarker ++ RootComponentTypeList, Rest4}.
2411
 
    
2412
 
 
2413
 
parse_ComponentTypeList(Tokens) ->
2414
 
    parse_ComponentTypeList(Tokens,[]).
2415
 
 
2416
 
parse_ComponentTypeList(Tokens,Acc) ->
 
2578
parse_OptionalExtensionMarker([{',',_},{'...',L1}|Rest],Clist)->
 
2579
    {Clist++[#'EXTENSIONMARK'{pos=L1}],Rest};
 
2580
parse_OptionalExtensionMarker(Tokens,Clist) ->
 
2581
    {Clist,Tokens}.
 
2582
 
 
2583
 
 
2584
parse_ComponentTypeList([{',',_},Id = {identifier,_,_}|Rest],Acc) when Acc =/= [] ->
 
2585
    {ComponentType,Rest2} = parse_ComponentType([Id|Rest]),
 
2586
    parse_ComponentTypeList(Rest2,[ComponentType|Acc]);
 
2587
parse_ComponentTypeList([{',',_},C1={'COMPONENTS',_},C2={'OF',_}|Rest],Acc) when Acc =/= [] ->
 
2588
    {ComponentType,Rest2} = parse_ComponentType([C1,C2|Rest]),
 
2589
    parse_ComponentTypeList(Rest2,[ComponentType|Acc]);
 
2590
parse_ComponentTypeList(Tokens = [{'}',_}|_],Acc) ->
 
2591
    {lists:reverse(Acc),Tokens};
 
2592
parse_ComponentTypeList(Tokens = [{']',_},{']',_}|_],Acc) ->
 
2593
    {lists:reverse(Acc),Tokens};
 
2594
parse_ComponentTypeList(Tokens = [{',',_},{'...',_}|_],Acc) ->
 
2595
    {lists:reverse(Acc),Tokens};
 
2596
parse_ComponentTypeList(Tokens,[]) ->
2417
2597
    {ComponentType,Rest} = parse_ComponentType(Tokens),
 
2598
    parse_ComponentTypeList(Rest,[ComponentType]);
 
2599
parse_ComponentTypeList(Tokens,_) ->
 
2600
    throw({asn1_error,
 
2601
           {get_line(hd(Tokens)),get(asn1_module),
 
2602
            [got,[get_token(hd(Tokens)),get_token(hd(tl(Tokens)))],
 
2603
             expected,['}',', identifier']]}}).
 
2604
 
 
2605
parse_ExtensionAdditions(Tokens=[{',',_}|_],Clist) ->
 
2606
    {ExtAddList,Rest2} = parse_ExtensionAdditionList(Tokens,[]),
 
2607
    {Clist++ExtAddList,Rest2};
 
2608
parse_ExtensionAdditions(Tokens,Clist) ->
 
2609
    %% Empty
 
2610
    {Clist,Tokens}.
 
2611
 
 
2612
parse_ExtensionAdditionList([{',',_},Id = {identifier,_,_}|Rest],Acc) ->
 
2613
    {ComponentType,Rest2} = parse_ComponentType([Id|Rest]),
 
2614
    parse_ExtensionAdditionList(Rest2,[ComponentType|Acc]);
 
2615
parse_ExtensionAdditionList([{',',_},C1={'COMPONENTS',_},C2={'OF',_}|Rest],Acc) ->
 
2616
    {ComponentType,Rest2} = parse_ComponentType([C1,C2|Rest]),
 
2617
    parse_ExtensionAdditionList(Rest2,[ComponentType|Acc]);
 
2618
parse_ExtensionAdditionList([{',',_},C1 = {'[',_},C2 = {'[',_}|Rest],Acc) ->
 
2619
    {ExtAddGroup,Rest2} = parse_ExtensionAdditionGroup([C1,C2|Rest],[]),
 
2620
    parse_ExtensionAdditionList(Rest2,[ExtAddGroup|Acc]);
 
2621
parse_ExtensionAdditionList(Tokens = [{'}',_}|_],Acc) ->
 
2622
    {lists:reverse(Acc),Tokens};
 
2623
parse_ExtensionAdditionList(Tokens = [{',',_},{'...',_}|_],Acc) ->
 
2624
    {lists:reverse(Acc),Tokens};
 
2625
parse_ExtensionAdditionList(Tokens,_) ->
 
2626
    throw({asn1_error,
 
2627
           {get_line(hd(Tokens)),get(asn1_module),
 
2628
            [got,[get_token(hd(Tokens)),get_token(hd(tl(Tokens)))],
 
2629
             expected,['}',', identifier']]}}).
 
2630
 
 
2631
 
 
2632
parse_ExtensionAdditionGroup([ {'[',_},{'[',_},_VsnNr = {number,_,Num},{':',_}|Rest],[]) ->
 
2633
    parse_ExtensionAdditionGroup2(Rest,Num);
 
2634
parse_ExtensionAdditionGroup([ {'[',_},{'[',_}|Rest],[]) ->
 
2635
    parse_ExtensionAdditionGroup2(Rest,undefined);
 
2636
parse_ExtensionAdditionGroup(Tokens,_) ->
 
2637
    throw({asn1_error,
 
2638
           {get_line(hd(Tokens)),get(asn1_module),
 
2639
            [got,[get_token(hd(Tokens)),get_token(hd(tl(Tokens)))],
 
2640
             expected,['[[']]}}).
 
2641
 
 
2642
 
 
2643
parse_ExtensionAdditionGroup2(Tokens,Num) ->
 
2644
    {CompTypeList,Rest} = parse_ComponentTypeList(Tokens,[]),
2418
2645
    case Rest of
2419
 
        [{',',_},Id = {identifier,_,_}|Rest2] ->
2420
 
            parse_ComponentTypeList([Id|Rest2],[ComponentType|Acc]);
2421
 
        [{',',_},C1={'COMPONENTS',_},C2={'OF',_}|Rest2] ->
2422
 
            parse_ComponentTypeList([C1,C2|Rest2],[ComponentType|Acc]);
2423
 
%       _ ->
2424
 
%           {lists:reverse([ComponentType|Acc]),Rest}
2425
 
        [{'}',_}|_] ->
2426
 
            {lists:reverse([ComponentType|Acc]),Rest};
2427
 
%       [{',',_},{'...',_},{'}',_}|_] ->
2428
 
%           {lists:reverse([ComponentType|Acc]),Rest};
2429
 
        [{',',_},{'...',_}|_] ->%% here comes the dubble ellipse
2430
 
            {lists:reverse([ComponentType|Acc]),Rest};
2431
 
        _ ->
2432
 
            throw({asn1_error,
2433
 
                   {get_line(hd(Tokens)),get(asn1_module),
2434
 
                    [got,[get_token(hd(Rest)),get_token(hd(tl(Rest)))],
2435
 
                     expected,['}',', identifier']]}})
2436
 
    end.
2437
 
 
2438
 
    
2439
 
parse_ExtensionAdditionList(Tokens) ->
2440
 
    parse_ExtensionAdditionList(Tokens,[]).
2441
 
    
2442
 
parse_ExtensionAdditionList(Tokens,Acc) ->
2443
 
    {Element,Rest0} =
2444
 
        case Tokens of
2445
 
            [{identifier,_,_}|_Rest] ->
2446
 
                parse_ComponentType(Tokens);
2447
 
            [{'[',_},{'[',_}|_] ->
2448
 
                parse_ExtensionAdditions(Tokens);
2449
 
            [{'...',L1}|_Rest] ->
2450
 
                {#'EXTENSIONMARK'{pos=L1},Tokens};
2451
 
            _ ->
2452
 
                throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2453
 
                                   [got,get_token(hd(Tokens)),expected,
2454
 
                                    [identifier,'[[']]}})
2455
 
        end,
2456
 
    case Rest0 of
2457
 
        [{',',_}|Rest01] ->
2458
 
            parse_ExtensionAdditionList(Rest01,[Element|Acc]);
2459
 
        [{'...',_}|Rest01] ->
2460
 
            {lists:reverse([Element|Acc]),Rest01};
2461
 
        _  ->
2462
 
            {lists:reverse([Element|Acc]),Rest0}
2463
 
    end.
2464
 
 
2465
 
parse_ExtensionAdditions([{'[',_},{'[',_}|Rest]) ->
2466
 
    parse_ExtensionAdditions(Rest,[]);
2467
 
parse_ExtensionAdditions(Tokens) ->
2468
 
    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2469
 
                       [got,get_token(hd(Tokens)),expected,'[[']}}).
2470
 
 
2471
 
parse_ExtensionAdditions([_VsnNr = {number,_,_},{':',_}|Rest],Acc) ->
2472
 
    %% ignor version number for now
2473
 
    parse_ExtensionAdditions(Rest,Acc);
2474
 
parse_ExtensionAdditions([Id = {identifier,_,_}|Rest],Acc) ->
2475
 
    {ComponentType, Rest2} = parse_ComponentType([Id|Rest]),
2476
 
    case Rest2 of
2477
 
        [{',',_}|Rest21] ->
2478
 
            parse_ExtensionAdditions(Rest21,[ComponentType|Acc]);
2479
 
        [{']',_},{']',_}|Rest21] ->
2480
 
            {lists:reverse(Acc),Rest21};
2481
 
        _ ->
2482
 
            throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
2483
 
                               [got,get_token(hd(Rest2)),expected,[',',']]']]}})
2484
 
    end;
2485
 
parse_ExtensionAdditions(Tokens,_) ->
2486
 
    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
2487
 
                       [got,get_token(hd(Tokens)),expected,identifier]}}).
 
2646
        [{']',_},{']',_}|Rest2] ->
 
2647
            {[{'ExtensionAdditionGroup',Num}|CompTypeList] ++
 
2648
                ['ExtensionAdditionGroupEnd'],Rest2};
 
2649
        _ ->
 
2650
            throw({asn1_error,{get_line(hd(Rest)),get(asn1_module),
 
2651
                               [got,get_token(hd(Rest)),expected,[']]']]}})
 
2652
    end.
 
2653
 
2488
2654
 
2489
2655
parse_ComponentType([{'COMPONENTS',_},{'OF',_}|Rest]) ->
2490
2656
    {Type,Rest2} = parse_Type(Rest),
2491
2657
    {{'COMPONENTS OF',Type},Rest2};
2492
2658
parse_ComponentType(Tokens) ->
2493
 
    {NamedType,Rest} = parse_NamedType(Tokens),
 
2659
    Result = {NamedType,Rest} = parse_NamedType(Tokens),
2494
2660
    case Rest of
2495
2661
        [{'OPTIONAL',_}|Rest2] ->
2496
2662
            {NamedType#'ComponentType'{prop='OPTIONAL'},Rest2};
2498
2664
            {Value,Rest21} = parse_Value(Rest2),
2499
2665
            {NamedType#'ComponentType'{prop={'DEFAULT',Value}},Rest21};
2500
2666
        _ ->
2501
 
            {NamedType,Rest}
 
2667
            Result
2502
2668
    end.
2503
2669
 
2504
2670
            
2512
2678
                       [got,get_token(hd(Tokens)),expected,
2513
2679
                        [number,'-number']]}}).
2514
2680
 
2515
 
parse_Enumerations(Tokens=[{identifier,_,_}|_Rest]) ->
2516
 
    parse_Enumerations(Tokens,[]);
2517
 
parse_Enumerations([H|_T]) ->
 
2681
parse_Enumerations(Tokens=[{identifier,_,_}|_Rest],ExtensionDefault) ->
 
2682
    parse_Enumerations(Tokens,[],ExtensionDefault);
 
2683
parse_Enumerations([H|_T],_) ->
2518
2684
    throw({asn1_error,{get_line(H),get(asn1_module),
2519
2685
                       [got,get_token(H),expected,identifier]}}).
2520
2686
 
2521
 
parse_Enumerations(Tokens = [{identifier,_,_},{'(',_}|_Rest], Acc) ->
 
2687
parse_Enumerations(Tokens = [{identifier,_,_},{'(',_}|_Rest], Acc, ExtensionDefault) ->
2522
2688
    {NamedNumber,Rest2} = parse_NamedNumber(Tokens),
2523
2689
    case Rest2 of
2524
2690
        [{',',_}|Rest3] ->
2525
 
            parse_Enumerations(Rest3,[NamedNumber|Acc]);
 
2691
            parse_Enumerations(Rest3,[NamedNumber|Acc], ExtensionDefault);
 
2692
        _ when ExtensionDefault == 'IMPLIED'->
 
2693
            {lists:reverse(['EXTENSIONMARK',NamedNumber|Acc]),Rest2};
2526
2694
        _ ->
2527
2695
            {lists:reverse([NamedNumber|Acc]),Rest2}
2528
2696
    end;
2529
 
parse_Enumerations([{identifier,_,Id}|Rest], Acc) ->
 
2697
parse_Enumerations([{identifier,_,Id}|Rest], Acc, ExtensionDefault) ->
2530
2698
    case Rest of
2531
2699
        [{',',_}|Rest2] ->
2532
 
            parse_Enumerations(Rest2,[Id|Acc]);
 
2700
            parse_Enumerations(Rest2,[Id|Acc], ExtensionDefault);
 
2701
        _ when ExtensionDefault == 'IMPLIED' ->
 
2702
            {lists:reverse(['EXTENSIONMARK', Id |Acc]),Rest};
2533
2703
        _ ->
2534
2704
            {lists:reverse([Id|Acc]),Rest}
2535
2705
    end;
2536
 
parse_Enumerations([{'...',_}|Rest], Acc) ->
 
2706
parse_Enumerations([{'...',_}|Rest], Acc, _ExtensionDefault) ->
2537
2707
    case Rest of
2538
2708
        [{',',_}|Rest2] ->
2539
 
            parse_Enumerations(Rest2,['EXTENSIONMARK'|Acc]);
 
2709
            parse_Enumerations(Rest2,['EXTENSIONMARK'|Acc],undefined);
2540
2710
        _ ->
2541
2711
            {lists:reverse(['EXTENSIONMARK'|Acc]),Rest}
2542
2712
    end;
2543
 
parse_Enumerations([H|_T],_) ->
 
2713
parse_Enumerations([H|_T],_,_) ->
2544
2714
    throw({asn1_error,{get_line(H),get(asn1_module),
2545
2715
                       [got,get_token(H),expected,identifier]}}).
2546
2716
 
2915
3085
%%    lists:flatten(Cacc) ++ [{'Errors',Eacc}].
2916
3086
    lists:reverse(Cacc) ++ [{'Errors',Eacc}].
2917
3087
 
 
3088
 
2918
3089
fixup_constraint(C) ->
2919
3090
    case C of
2920
3091
        {'SingleValue',SubType} when element(1,SubType) == 'ContainedSubtype' ->