← Back to branch summary

~rdoering/ubuntu/karmic/erlang/fix-535090

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Sergei Golovan
  • Date: 2009-02-15 16:42:52 UTC
  • mfrom: (3.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090215164252-q5x4rcf8a5pbesb1
Tags: 1:12.b.5-dfsg-2
Upload to unstable after lenny is released.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/asn1/src/asn1ct_gen_per.erl
1
 
%% ``The contents of this file are subject to the Erlang Public License,
 
1
%%<copyright>
 
2
%% <year>1997-2008</year>
 
3
%% <holder>Ericsson AB, All Rights Reserved</holder>
 
4
%%</copyright>
 
5
%%<legalnotice>
 
6
%% The contents of this file are subject to the Erlang Public License,
2
7
%% Version 1.1, (the "License"); you may not use this file except in
3
8
%% compliance with the License. You should have received a copy of the
4
9
%% Erlang Public License along with this software. If not, it can be
5
 
%% retrieved via the world wide web at http://www.erlang.org/.
6
 
%% 
 
10
%% retrieved online at http://www.erlang.org/.
 
11
%%
7
12
%% Software distributed under the License is distributed on an "AS IS"
8
13
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
9
14
%% the License for the specific language governing rights and limitations
10
15
%% under the License.
11
 
%% 
12
 
%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
13
 
%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
14
 
%% AB. All Rights Reserved.''
15
 
%% 
16
 
%%     $Id$
 
16
%%
 
17
%% The Initial Developer of the Original Code is Ericsson AB.
 
18
%%</legalnotice>
17
19
%%
18
20
-module(asn1ct_gen_per).
19
21
 
152
154
            NewC = [{'ValueRange',{0,length(Nlist1)-1}}],
153
155
            emit(["case (case ",Value," of {_,_}->element(2,",Value,");_->",
154
156
                  Value," end) of",nl]),
155
 
            emit_enc_enumerated_cases(NewC, NewList++[{asn1_enum,length(Nlist1)-1}], 0);
 
157
            emit_enc_enumerated_cases(Erules,NewC, NewList++[{asn1_enum,length(Nlist1)-1}], 0);
156
158
        {'ENUMERATED',NamedNumberList} ->
157
159
            NewList = [X||{X,_} <- NamedNumberList],
158
160
            NewC = [{'ValueRange',{0,length(NewList)-1}}],
159
161
            emit(["case (case ",Value," of {_,_}->element(2,",Value,");_->",
160
162
                  Value," end) of",nl]),
161
 
            emit_enc_enumerated_cases(NewC, NewList, 0);
 
163
            emit_enc_enumerated_cases(Erules,NewC, NewList, 0);
162
164
        
163
165
        'REAL' ->
164
166
            emit({"?RT_PER:encode_real(",Value,")"});
171
173
            emit({"?RT_PER:encode_null(",Value,")"});
172
174
        'OBJECT IDENTIFIER' ->
173
175
            emit({"?RT_PER:encode_object_identifier(",Value,")"});
 
176
        'RELATIVE-OID' ->
 
177
            emit({"?RT_PER:encode_relative_oid(",Value,")"});
174
178
        'ObjectDescriptor' ->
175
179
            emit({"?RT_PER:encode_ObjectDescriptor(",{asis,Constraint},
176
180
                  ",",Value,")"});
180
184
            emit({"?RT_PER:encode_octet_string(",{asis,Constraint},",",Value,")"});
181
185
        'NumericString' ->
182
186
            emit({"?RT_PER:encode_NumericString(",{asis,Constraint},",",Value,")"});
183
 
        'TeletexString' ->
 
187
        TString when TString == 'TeletexString';
 
188
                     TString == 'T61String' ->
184
189
            emit({"?RT_PER:encode_TeletexString(",{asis,Constraint},",",Value,")"});
185
190
        'VideotexString' ->
186
191
            emit({"?RT_PER:encode_VideotexString(",{asis,Constraint},",",Value,")"});
235
240
            exit({asn1_error,nyi,XX})
236
241
    end.
237
242
 
238
 
emit_enc_enumerated_cases(C, [H], Count) ->
239
 
    emit_enc_enumerated_case(C, H, Count),
 
243
emit_enc_enumerated_cases(Erule,C, [H], Count) ->
 
244
    emit_enc_enumerated_case(Erule,C, H, Count),
240
245
    emit([";",nl,"EnumVal -> exit({error,{asn1, {enumerated_not_in_range, EnumVal}}})"]),
241
246
    emit([nl,"end"]);
242
 
emit_enc_enumerated_cases(C, ['EXT_MARK'|T], _Count) ->
243
 
    emit_enc_enumerated_cases(C, T, 0);
244
 
emit_enc_enumerated_cases(C, [H1,H2|T], Count) ->
245
 
    emit_enc_enumerated_case(C, H1, Count),
 
247
emit_enc_enumerated_cases(Erule, C, ['EXT_MARK'|T], _Count) ->
 
248
    emit_enc_enumerated_cases(Erule, C, T, 0);
 
249
emit_enc_enumerated_cases(Erule, C, [H1,H2|T], Count) ->
 
250
    emit_enc_enumerated_case(Erule, C, H1, Count),
246
251
    emit([";",nl]),
247
 
    emit_enc_enumerated_cases(C, [H2|T], Count+1).
 
252
    emit_enc_enumerated_cases(Erule, C, [H2|T], Count+1).
248
253
    
249
254
 
250
255
 
251
 
emit_enc_enumerated_case(_C, {asn1_enum,High}, _) ->
 
256
emit_enc_enumerated_case(uper_bin,_C, {asn1_enum,High}, _) ->
 
257
    emit([
 
258
          "{asn1_enum,EnumV} when integer(EnumV), EnumV > ",High," -> ",
 
259
          "[<<1:1>>,?RT_PER:encode_small_number(EnumV)]"]);
 
260
emit_enc_enumerated_case(_Per,_C, {asn1_enum,High}, _) ->
252
261
    emit([
253
262
          "{asn1_enum,EnumV} when integer(EnumV), EnumV > ",High," -> ",
254
263
          "[{bit,1},?RT_PER:encode_small_number(EnumV)]"]);
255
 
emit_enc_enumerated_case(_C, 'EXT_MARK', _Count) ->
 
264
emit_enc_enumerated_case(_Erule, _C, 'EXT_MARK', _Count) ->
256
265
    true;
257
 
emit_enc_enumerated_case(_C, {1,EnumName}, Count) ->
 
266
emit_enc_enumerated_case(uper_bin,_C, {1,EnumName}, Count) ->
 
267
    emit(["'",EnumName,"' -> [<<1:1>>,?RT_PER:encode_small_number(",Count,")]"]);
 
268
emit_enc_enumerated_case(_Per,_C, {1,EnumName}, Count) ->
258
269
    emit(["'",EnumName,"' -> [{bit,1},?RT_PER:encode_small_number(",Count,")]"]);
259
 
emit_enc_enumerated_case(C, {0,EnumName}, Count) ->
 
270
emit_enc_enumerated_case(uper_bin,C, {0,EnumName}, Count) ->
 
271
    emit(["'",EnumName,"' -> [<<0:1>>,?RT_PER:encode_integer(",{asis,C},", ",Count,")]"]);
 
272
emit_enc_enumerated_case(_Per,C, {0,EnumName}, Count) ->
260
273
    emit(["'",EnumName,"' -> [{bit,0},?RT_PER:encode_integer(",{asis,C},", ",Count,")]"]);
261
 
emit_enc_enumerated_case(C, EnumName, Count) ->
 
274
emit_enc_enumerated_case(_Erule, C, EnumName, Count) ->
262
275
    emit(["'",EnumName,"' -> ?RT_PER:encode_integer(",{asis,C},", ",Count,")"]).
263
276
 
264
277
%% effective_constraint(Type,C)
288
301
effective_constr('SingleValue',List) ->
289
302
    SVList = lists:flatten(lists:map(fun(X)->element(2,X)end,List)),
290
303
    % sort and remove duplicates
291
 
%    SortedSVList = lists:sort(SVList),
 
304
    SortedSVList = lists:sort(SVList),
292
305
    RemoveDup = fun([],_) ->[];
293
306
                   ([H],_) -> [H];
294
307
                   ([H,H|T],F) -> F([H|T],F);
295
308
                   ([H|T],F) -> [H|F(T,F)]
296
309
                end,
297
310
    
298
 
    case RemoveDup(SVList,RemoveDup) of
 
311
    case RemoveDup(SortedSVList,RemoveDup) of
299
312
        [N] ->
300
313
            [{'SingleValue',N}];
301
314
        L when list(L) -> 
311
324
    VR;
312
325
greatest_common_range(SV,[]) ->
313
326
    SV;
314
 
greatest_common_range([{_,Int}],[{_,{'MIN',Ub}}]) when integer(Int),
 
327
greatest_common_range(SV,VR) ->
 
328
    greatest_common_range2(mk_vr(SV),mk_vr(VR)).
 
329
greatest_common_range2({_,Int},{'MIN',Ub}) when integer(Int),
315
330
                                                       Int > Ub ->
316
331
    [{'ValueRange',{'MIN',Int}}];
317
 
greatest_common_range([{_,Int}],[{_,{Lb,Ub}}]) when integer(Int),
 
332
greatest_common_range2({_,Int},{Lb,Ub}) when integer(Int),
318
333
                                                    Int < Lb ->
319
334
    [{'ValueRange',{Int,Ub}}];
320
 
greatest_common_range([{_,Int}],VR=[{_,{_Lb,_Ub}}]) when integer(Int) ->
321
 
    VR;
322
 
greatest_common_range([{_,L}],[{_,{Lb,Ub}}]) when list(L) ->
 
335
greatest_common_range2({_,Int},VR={_Lb,_Ub}) when integer(Int) ->
 
336
    [{'ValueRange',VR}];
 
337
greatest_common_range2({_,L},{Lb,Ub}) when list(L) ->
323
338
    Min = least_Lb([Lb|L]),
324
339
    Max = greatest_Ub([Ub|L]),
325
340
    [{'ValueRange',{Min,Max}}].
326
 
    
 
341
 
 
342
mk_vr([{Type,I}]) when is_atom(Type), is_integer(I) ->
 
343
    {I,I};
 
344
mk_vr([{Type,{Lb,Ub}}]) when is_atom(Type) ->
 
345
    {Lb,Ub};
 
346
mk_vr(Other) ->
 
347
    Other.
327
348
 
328
349
least_Lb(L) ->
329
350
    case lists:member('MIN',L) of
370
391
    emit({nl,"%%  ",ObjName}),
371
392
    emit({nl,"%%================================",nl}),
372
393
    EncConstructed =
373
 
        gen_encode_objectfields(ClassName,get_class_fields(Class),
 
394
        gen_encode_objectfields(Erules, ClassName,get_class_fields(Class),
374
395
                                ObjName,Fields,[]),
375
396
    emit(nl),
376
397
    gen_encode_constr_type(Erules,EncConstructed),
385
406
    ok.
386
407
 
387
408
 
388
 
gen_encode_objectfields(ClassName,[{typefield,Name,OptOrMand}|Rest],
 
409
gen_encode_objectfields(Erule,ClassName,[{typefield,Name,OptOrMand}|Rest],
389
410
                        ObjName,ObjectFields,ConstrAcc) ->
390
411
    EmitFuncClause = 
391
412
        fun(V) ->
401
422
                                   ObjName}}});
402
423
            {false,'OPTIONAL'} ->
403
424
                EmitFuncClause("Val"),
404
 
                emit("   [{octets,Val}]"),
 
425
                case Erule of
 
426
                    uper_bin ->
 
427
                        emit("   Val");
 
428
                    _ ->
 
429
                        emit("   [{octets,Val}]")
 
430
                end,
405
431
                [];
406
432
            {false,{'DEFAULT',DefaultType}} ->
407
433
                EmitFuncClause("Val"),
418
444
        false ->
419
445
            emit([".",nl])
420
446
    end,
421
 
    gen_encode_objectfields(ClassName,Rest,ObjName,ObjectFields,
 
447
    gen_encode_objectfields(Erule,ClassName,Rest,ObjName,ObjectFields,
422
448
                            MaybeConstr++ConstrAcc);
423
 
gen_encode_objectfields(ClassName,[{objectfield,Name,_,_,OptOrMand}|Rest],
 
449
gen_encode_objectfields(Erule,ClassName,[{objectfield,Name,_,_,OptOrMand}|Rest],
424
450
                        ObjName,ObjectFields,ConstrAcc) ->
425
451
    CurrentMod = get(currmod),
426
452
    EmitFuncClause =
463
489
        false ->
464
490
            emit([".",nl])
465
491
    end,
466
 
    gen_encode_objectfields(ClassName,Rest,ObjName,ObjectFields,ConstrAcc);
467
 
gen_encode_objectfields(ClassName,[_C|Cs],O,OF,Acc) ->
468
 
    gen_encode_objectfields(ClassName,Cs,O,OF,Acc);
469
 
gen_encode_objectfields(_,[],_,_,Acc) ->
 
492
    gen_encode_objectfields(Erule,ClassName,Rest,ObjName,ObjectFields,ConstrAcc);
 
493
gen_encode_objectfields(Erule,ClassName,[_C|Cs],O,OF,Acc) ->
 
494
    gen_encode_objectfields(Erule,ClassName,Cs,O,OF,Acc);
 
495
gen_encode_objectfields(_, _,[],_,_,Acc) ->
470
496
    Acc.
471
497
 
472
498
 
474
500
    case is_already_generated(enc,TypeDef#typedef.name) of
475
501
        true -> ok;
476
502
        _ ->
477
 
            Name = lists:concat(["enc_",TypeDef#typedef.name]),
478
 
            emit({Name,"(Val) ->",nl}),
 
503
%%          FuncName = list_to_atom(lists:concat(["enc_",TypeDef#typedef.name])),
 
504
            FuncName = asn1ct_gen:list2rname(TypeDef#typedef.name ++ [enc]),
 
505
            emit(["'",FuncName,"'(Val) ->",nl]),
479
506
            Def = TypeDef#typedef.typespec,
480
507
            InnerType = asn1ct_gen:get_inner(Def#type.def),
481
 
            asn1ct_gen:gen_encode_constructed(Erules,Name,InnerType,Def),
 
508
            asn1ct_gen:gen_encode_constructed(Erules,TypeDef#typedef.name,
 
509
                                              InnerType,Def),
482
510
            gen_encode_constr_type(Erules,Rest)
483
511
    end;
484
512
gen_encode_constr_type(_,[]) ->
505
533
        {constructed,bif} ->
506
534
            emit({"   'enc_",ObjName,'_',FieldName,
507
535
                  "'(Val)"}),
508
 
            [Type#typedef{name=list_to_atom(lists:concat([ObjName,'_',FieldName]))}];
 
536
%%          [Type#typedef{name=list_to_atom(lists:concat([ObjName,'_',FieldName]))}];
 
537
            [Type#typedef{name=[FieldName,ObjName]}];
509
538
        {ExtMod,TypeName} ->
510
539
            emit({"   '",ExtMod,"':'enc_",TypeName,
511
540
                  "'(Val)"}),
522
551
        {constructed,bif} ->
523
552
%%          asn1ct_gen:gen_encode_constructed(Erules,Typename,InnerType,Type);
524
553
            emit(["   'enc_",ClassName,'_',FieldName,"'(Val)"]),
525
 
            [#typedef{name=list_to_atom(lists:concat([ClassName,'_',FieldName])),
 
554
%%          [#typedef{name=list_to_atom(lists:concat([ClassName,'_',FieldName])),
 
555
            [#typedef{name=[FieldName,ClassName],
526
556
                      typespec=Type}];
527
557
        {primitive,bif} ->
528
558
            gen_encode_prim(per,Type,"false","Val"),
640
670
        {constructed,bif} ->
641
671
            emit({"   'dec_",ObjName,'_',FieldName,
642
672
                  "'(",Bytes,",telltype)"}),
643
 
            [Type#typedef{name=list_to_atom(lists:concat([ObjName,'_',FieldName]))}];
 
673
%%          [Type#typedef{name=list_to_atom(lists:concat([ObjName,'_',FieldName]))}];
 
674
            [Type#typedef{name=[FieldName,ObjName]}];
644
675
        {ExtMod,TypeName} ->
645
676
            emit({"   '",ExtMod,"':'dec_",TypeName,
646
677
                  "'(",Bytes,", telltype)"}),
656
687
    case asn1ct_gen:type(InnerType) of
657
688
        {constructed,bif} ->
658
689
            emit(["   'dec_",ClassName,'_',FieldName,"'(",Bytes,", telltype)"]),
659
 
            [#typedef{name=list_to_atom(lists:concat([ClassName,'_',FieldName])),
 
690
%%          [#typedef{name=list_to_atom(lists:concat([ClassName,'_',FieldName])),
 
691
            [#typedef{name=[FieldName,ClassName],
660
692
                      typespec=Type}];
661
693
        {primitive,bif} ->
662
694
            gen_dec_prim(per,Type,Bytes),
674
706
    case is_already_generated(dec,TypeDef#typedef.name) of
675
707
        true -> ok;
676
708
        _ ->
677
 
            gen_decode(Erules,TypeDef)
 
709
            gen_decode(Erules,TypeDef#typedef{name=asn1ct_gen:list2rname(TypeDef#typedef.name)})
678
710
    end,
679
711
    gen_decode_constr_type(Erules,Rest);
680
712
gen_decode_constr_type(_,[]) ->
720
752
gen_objset_code(Erules,ObjSetName,UniqueFName,Set,ClassName,ClassDef)->
721
753
    ClassFields = (ClassDef#classdef.typespec)#objectclass.fields,
722
754
    InternalFuncs=
723
 
        gen_objset_enc(ObjSetName,UniqueFName,Set,ClassName,ClassFields,1,[]),
 
755
        gen_objset_enc(Erules,ObjSetName,UniqueFName,Set,ClassName,ClassFields,1,[]),
724
756
    gen_objset_dec(ObjSetName,UniqueFName,Set,ClassName,ClassFields,1),
725
757
    gen_internal_funcs(Erules,InternalFuncs).
726
758
 
727
759
%% gen_objset_enc iterates over the objects of the object set
728
 
gen_objset_enc(_,{unique,undefined},_,_,_,_,_) ->
 
760
gen_objset_enc(_,_,{unique,undefined},_,_,_,_,_) ->
729
761
    %% There is no unique field in the class of this object set
730
762
    %% don't bother about the constraint
731
763
    [];
732
 
gen_objset_enc(ObjSName,UniqueName,[{ObjName,Val,Fields},T|Rest],
 
764
gen_objset_enc(Erule,ObjSName,UniqueName,[{ObjName,Val,Fields},T|Rest],
733
765
               ClName,ClFields,NthObj,Acc)->
734
766
    emit({"'getenc_",ObjSName,"'(",{asis,UniqueName},",",{asis,Val},
735
767
          ") ->",nl}),
737
769
    {InternalFunc,NewNthObj}=
738
770
        case ObjName of
739
771
            {no_mod,no_name} ->
740
 
                gen_inlined_enc_funs(Fields,ClFields,ObjSName,NthObj);
 
772
                gen_inlined_enc_funs(Erule,Fields,ClFields,ObjSName,NthObj);
741
773
            {CurrMod,Name} ->
742
774
                emit({"    fun 'enc_",Name,"'/3"}),
743
775
                {[],0};
750
782
                {[],0}
751
783
        end,
752
784
    emit({";",nl}),
753
 
    gen_objset_enc(ObjSName,UniqueName,[T|Rest],ClName,ClFields,
 
785
    gen_objset_enc(Erule,ObjSName,UniqueName,[T|Rest],ClName,ClFields,
754
786
                   NewNthObj,InternalFunc ++ Acc);
755
 
gen_objset_enc(ObjSetName,UniqueName,
 
787
gen_objset_enc(Erule,ObjSetName,UniqueName,
756
788
               [{ObjName,Val,Fields}],_ClName,ClFields,NthObj,Acc) ->
757
789
 
758
790
    emit({"'getenc_",ObjSetName,"'(",{asis,UniqueName},",",
761
793
    {InternalFunc,_}=
762
794
        case ObjName of
763
795
            {no_mod,no_name} ->
764
 
                gen_inlined_enc_funs(Fields,ClFields,ObjSetName,NthObj);
 
796
                gen_inlined_enc_funs(Erule,Fields,ClFields,ObjSetName,NthObj);
765
797
            {CurrMod,Name} ->
766
798
                emit({"    fun 'enc_",Name,"'/3"}),
767
799
                {[],NthObj};
777
809
    emit_default_getenc(ObjSetName,UniqueName),
778
810
    emit({".",nl,nl}),
779
811
    InternalFunc++Acc;
780
 
gen_objset_enc(ObjSetName,_UniqueName,['EXTENSIONMARK'],_ClName,
 
812
gen_objset_enc(Erule,ObjSetName,_UniqueName,['EXTENSIONMARK'],_ClName,
781
813
               _ClFields,_NthObj,Acc) ->
782
814
    emit({"'getenc_",ObjSetName,"'(_, _) ->",nl}),
783
815
    emit({indent(3),"fun(_, Val, _) ->",nl}),
784
 
    emit({indent(6),"[{octets,Val}]",nl}),
 
816
    case Erule of
 
817
        uper_bin ->
 
818
            emit([indent(6),"Val",nl]);
 
819
        _ ->
 
820
            emit([indent(6),"[{octets,Val}]",nl])
 
821
    end,
785
822
    emit({indent(3),"end.",nl,nl}),
786
823
    Acc;
787
 
gen_objset_enc(_,_,[],_,_,_,Acc) ->
 
824
gen_objset_enc(_,_,_,[],_,_,_,Acc) ->
788
825
    Acc.
789
826
 
790
827
emit_ext_encfun(ModuleName,Name) ->
792
829
          Name,"'(T,V,O) end"]).
793
830
 
794
831
emit_default_getenc(ObjSetName,UniqueName) ->
795
 
    emit(["'getenc_",ObjSetName,"'(",{asis,UniqueName},", _) ->",nl]),
796
 
    emit([indent(4),"fun(C,V,_) -> exit({'Type not compatible with table constraint',{component,C},{value,V}}) end"]).
 
832
    emit(["'getenc_",ObjSetName,"'(",{asis,UniqueName},", ErrV) ->",nl]),
 
833
    emit([indent(4),"fun(C,V,_) -> exit({'Type not compatible with table constraint',{component,C},{value,V},{unique_name_and_value,",{asis,UniqueName},",ErrV}}) end"]).
797
834
 
798
835
 
799
836
%% gen_inlined_enc_funs for each object iterates over all fields of a
800
837
%% class, and for each typefield it checks if the object has that
801
838
%% field and emits the proper code.
802
 
gen_inlined_enc_funs(Fields,[{typefield,Name,_}|Rest],ObjSetName,NthObj) ->
 
839
gen_inlined_enc_funs(Erule,Fields,[{typefield,Name,_}|Rest],ObjSetName,NthObj) ->
803
840
    CurrMod = get(currmod),
804
841
    InternalDefFunName = asn1ct_gen:list2name([NthObj,Name,ObjSetName]),
805
842
    case lists:keysearch(Name,1,Fields) of
807
844
            emit({indent(3),"fun(Type, Val, _) ->",nl,
808
845
                  indent(6),"case Type of",nl}),
809
846
            {Ret,N}=emit_inner_of_fun(Type,InternalDefFunName),
810
 
            gen_inlined_enc_funs1(Fields,Rest,ObjSetName,NthObj+N,Ret);
 
847
            gen_inlined_enc_funs1(Erule,Fields,Rest,ObjSetName,NthObj+N,Ret);
811
848
        {value,{_,Type}} when record(Type,typedef) ->
812
849
            emit({indent(3),"fun(Type, Val, _) ->",nl,
813
850
                  indent(6),"case Type of",nl}),
814
851
            emit({indent(9),{asis,Name}," ->",nl}),
815
852
            {Ret,N} = emit_inner_of_fun(Type,InternalDefFunName),
816
 
            gen_inlined_enc_funs1(Fields,Rest,ObjSetName,NthObj+N,Ret);
 
853
            gen_inlined_enc_funs1(Erule,Fields,Rest,ObjSetName,NthObj+N,Ret);
817
854
        {value,{_,#'Externaltypereference'{module=CurrMod,type=T}}} ->
818
855
            emit({indent(3),"fun(Type, Val, _) ->",nl,
819
856
                  indent(6),"case Type of",nl}),
820
857
            emit({indent(9),{asis,Name}," ->",nl}),
821
858
            emit([indent(12),"'enc_",T,"'(Val)"]),
822
859
%           {Ret,N} = emit_inner_of_fun(TDef,InternalDefFunName),
823
 
            gen_inlined_enc_funs1(Fields,Rest,ObjSetName,NthObj,[]);
 
860
            gen_inlined_enc_funs1(Erule,Fields,Rest,ObjSetName,NthObj,[]);
824
861
        {value,{_,#'Externaltypereference'{module=M,type=T}}} ->
825
862
            emit({indent(3),"fun(Type, Val, _) ->",nl,
826
863
                  indent(6),"case Type of",nl}),
827
864
            emit({indent(9),{asis,Name}," ->",nl}),
828
865
            emit([indent(12),"'",M,"'",":'enc_",T,"'(Val)"]),
829
 
            gen_inlined_enc_funs1(Fields,Rest,ObjSetName,NthObj,[]);
 
866
            gen_inlined_enc_funs1(Erule,Fields,Rest,ObjSetName,NthObj,[]);
 
867
        false when Erule == uper_bin ->
 
868
            emit([indent(3),"fun(Type,Val,_) ->",nl,
 
869
                  indent(6),"case Type of",nl,
 
870
                  indent(9),{asis,Name}," -> Val",nl]),
 
871
            gen_inlined_enc_funs1(Erule,Fields,Rest,ObjSetName,NthObj,[]);
830
872
        false ->
831
873
            emit([indent(3),"fun(Type,Val,_) ->",nl,
832
874
                  indent(6),"case Type of",nl,
833
875
                  indent(9),{asis,Name}," -> [{octets,Val}]",nl]),
834
 
            gen_inlined_enc_funs1(Fields,Rest,ObjSetName,NthObj,[])
 
876
            gen_inlined_enc_funs1(Erule,Fields,Rest,ObjSetName,NthObj,[])
835
877
    end;
836
 
gen_inlined_enc_funs(Fields,[_H|Rest],ObjSetName,NthObj) ->
837
 
    gen_inlined_enc_funs(Fields,Rest,ObjSetName,NthObj);
838
 
gen_inlined_enc_funs(_,[],_,NthObj) ->
 
878
gen_inlined_enc_funs(Erule,Fields,[_H|Rest],ObjSetName,NthObj) ->
 
879
    gen_inlined_enc_funs(Erule,Fields,Rest,ObjSetName,NthObj);
 
880
gen_inlined_enc_funs(_,_,[],_,NthObj) ->
839
881
    {[],NthObj}.
840
882
 
841
 
gen_inlined_enc_funs1(Fields,[{typefield,Name,_}|Rest],ObjSetName,
 
883
gen_inlined_enc_funs1(Erule,Fields,[{typefield,Name,_}|Rest],ObjSetName,
842
884
                     NthObj,Acc) ->
843
885
    CurrentMod = get(currmod),
844
886
    InternalDefFunName = asn1ct_gen:list2name([NthObj,Name,ObjSetName]),
860
902
                emit({";",nl,indent(9),{asis,Name}," ->",nl}),
861
903
                emit([indent(12),"'",M,"'",":'enc_",T,"'(Val)"]),
862
904
                {Acc,0};
 
905
            false when Erule == uper_bin ->
 
906
                emit([";",nl,
 
907
                      indent(9),{asis,Name}," -> ",nl,
 
908
                      "Val",nl]),
 
909
                {Acc,0};
863
910
            false ->
864
911
                emit([";",nl,
865
912
                      indent(9),{asis,Name}," -> ",nl,
866
913
                      "[{octets,Val}]",nl]),
867
914
                {Acc,0}
868
915
        end,
869
 
    gen_inlined_enc_funs1(Fields,Rest,ObjSetName,NthObj+NAdd,Acc2);
870
 
gen_inlined_enc_funs1(Fields,[_H|Rest],ObjSetName,NthObj,Acc)->
871
 
    gen_inlined_enc_funs1(Fields,Rest,ObjSetName,NthObj,Acc);
872
 
gen_inlined_enc_funs1(_,[],_,NthObj,Acc) ->
 
916
    gen_inlined_enc_funs1(Erule,Fields,Rest,ObjSetName,NthObj+NAdd,Acc2);
 
917
gen_inlined_enc_funs1(Erule,Fields,[_H|Rest],ObjSetName,NthObj,Acc)->
 
918
    gen_inlined_enc_funs1(Erule,Fields,Rest,ObjSetName,NthObj,Acc);
 
919
gen_inlined_enc_funs1(_,_,[],_,NthObj,Acc) ->
873
920
    emit({nl,indent(6),"end",nl}),
874
921
    emit({indent(3),"end"}),
875
922
    {Acc,NthObj}.
977
1024
          Name,"'(T,V,O1,O2) end"]).
978
1025
 
979
1026
emit_default_getdec(ObjSetName,UniqueName) ->
980
 
    emit(["'getdec_",ObjSetName,"'(",{asis,UniqueName},", _) ->",nl]),
981
 
    emit([indent(2), "fun(C,V,_,_) -> exit({{component,C},{value,V}}) end"]).
 
1027
    emit(["'getdec_",ObjSetName,"'(",{asis,UniqueName},", ErrV) ->",nl]),
 
1028
    emit([indent(2), "fun(C,V,_,_) -> exit({{component,C},{value,V},{unique_name_and_value,",{asis,UniqueName},",ErrV}}) end"]).
982
1029
 
983
1030
 
984
1031
gen_inlined_dec_funs(Fields,[{typefield,Name,_}|Rest],
1195
1242
        'OBJECT IDENTIFIER' ->
1196
1243
            emit({"?RT_PER:decode_object_identifier(",
1197
1244
                  BytesVar,")"});
 
1245
        'RELATIVE-OID' ->
 
1246
            emit({"?RT_PER:decode_relative_oid(",
 
1247
                  BytesVar,")"});
1198
1248
        'ObjectDescriptor' ->
1199
1249
            emit({"?RT_PER:decode_ObjectDescriptor(",
1200
1250
                  BytesVar,")"});
1219
1269
        'NumericString' ->
1220
1270
            emit({"?RT_PER:decode_NumericString(",BytesVar,",",
1221
1271
                  {asis,Constraint},")"});
1222
 
        'TeletexString' ->
 
1272
        TString when TString == 'TeletexString';
 
1273
                     TString == 'T61String' ->
1223
1274
            emit({"?RT_PER:decode_TeletexString(",BytesVar,",",
1224
1275
                  {asis,Constraint},")"});
1225
1276
        'VideotexString' ->