← Back to branch summary

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

« back to all changes in this revision

Viewing changes to lib/ic/src/ictype.erl

  • Committer: Bazaar Package Importer
  • Author(s): Soren Hansen
  • Date: 2007-05-01 16:57:10 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20070501165710-2sapk0hp2gf3o0ip
Tags: 1:11.b.4-2ubuntu1
* Merge with Debian Unstable. Remaining changes:
  - Add -fno-stack-protector to fix broken crypto_drv.
* DebianMaintainerField update.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/ic/src/ictype.erl
58
58
        false ->
59
59
            lookup(G, S, N, X, Id)
60
60
    end.
61
 
    
 
61
 
62
62
 
63
63
%%--------------------------------------------------------------------
64
64
%% maybe_array
112
112
                                error ->
113
113
                                    %% Last resort: seek in pragma table
114
114
                                    lookup_type_in_pragmatab(G, SName);
115
 
                                
 
115
 
116
116
                                Other ->
117
117
                                    Other
118
118
                            end;                
157
157
        [] ->
158
158
            %% No match, seek included
159
159
            case ets:match(S,{file_data_included,'_','_','$2','_','_',SName,'_','_'}) of 
160
 
                
 
160
 
161
161
                [] ->
162
162
                    error;
163
163
                [[Type]] ->
360
360
    tktab_add(G, S, N, X),
361
361
    N2 = [ic_forms:get_id2(X) | N],
362
362
    Ps = lists:map(fun(P) -> 
363
 
                     tktab_add(G, S, N2, P),
364
 
                     P#param{tk=tk_base(G, S, N, ic_forms:get_type(P))} end,
365
 
             X#op.params),
 
363
                           tktab_add(G, S, N2, P),
 
364
                           P#param{tk=tk_base(G, S, N, ic_forms:get_type(P))} end,
 
365
                   X#op.params),
366
366
    %% Check for exception defs.
367
367
    Raises = lists:map(fun(E) -> name_lookup(G, S, N, E) end,
368
 
                 X#op.raises),
 
368
                       X#op.raises),
369
369
    case ic_forms:is_oneway(X) of
370
370
        true ->
371
371
            if  TK /= tk_void ->
592
592
        _ ->
593
593
            case scoped_lookup(G, S, N, {scoped_id,V1,V2,["TypeCode","CORBA"]}) of
594
594
                T when element(1, T) == error -> T;
595
 
                T when tuple(T) -> element(3, T);
596
 
                _ -> invalid_tk
 
595
                T when tuple(T) -> element(3, T)
597
596
            end 
598
597
    end;
599
598
 
600
599
tk_base(G, S, N, X) when element(1, X) == scoped_id ->
601
600
    case scoped_lookup(G, S, N, X) of
602
601
        T when element(1, T) == error -> T;
603
 
        T when tuple(T) -> element(3, T);
604
 
        _ -> invalid_tk
 
602
        T when tuple(T) -> element(3, T)
605
603
    end;
606
604
tk_base(_G, _S, _N, {long, _})                  -> tk_long;
607
605
tk_base(_G, _S, _N, {'long long', _})           -> tk_longlong;  %% LLONG
630
628
%%
631
629
tk_memberlist(G, S, N, [X | Xs]) ->
632
630
    BaseTK = tk(G, S, N, ic_forms:get_type(X)),
633
 
    
 
631
 
634
632
    XX = #id_of{type=X},
635
633
    lists:foldr(fun(Id, Acc) ->
636
 
                  [tk_member(G, S, N, XX#id_of{id=Id}, BaseTK) | Acc] end, 
637
 
          tk_memberlist(G, S, N, Xs), 
638
 
          ic_forms:get_idlist(X));
 
634
                        [tk_member(G, S, N, XX#id_of{id=Id}, BaseTK) | Acc] end, 
 
635
                tk_memberlist(G, S, N, Xs), 
 
636
                ic_forms:get_idlist(X));
639
637
tk_memberlist(_G, _S, _N, []) -> [].
640
638
 
641
639
%% same as above but for case dcls
642
640
tk_caselist(G, S, N, DiscrTK, Xs) ->
643
641
    lists:foldl(fun(Case, Acc) ->
644
 
                  BaseTK = tk(G, S, N, ic_forms:get_type(Case)),
645
 
                  %% tktab_add for the uniqueness check of the declarator
646
 
                  tktab_add(G, S, N, Case),
647
 
                  lists:foldl(fun(Id, Acc2) ->
648
 
                                case tk_case(G, S, N, Case, BaseTK,
649
 
                                             DiscrTK, Id) of
650
 
                                    Err when element(1, Err)==error ->
651
 
                                        Acc2;
652
 
                                    TK ->
653
 
                                        unique_add_case_label(G, S, N, Id, 
654
 
                                                              TK, Acc2)
655
 
                                end
656
 
                        end, 
657
 
                        Acc,
658
 
                        ic_forms:get_idlist(Case))
659
 
          end,
660
 
          [],
661
 
          Xs).
 
642
                        BaseTK = tk(G, S, N, ic_forms:get_type(Case)),
 
643
                        %% tktab_add for the uniqueness check of the declarator
 
644
                        tktab_add(G, S, N, Case),
 
645
                        lists:foldl(fun(Id, Acc2) ->
 
646
                                            case tk_case(G, S, N, Case, BaseTK,
 
647
                                                         DiscrTK, Id) of
 
648
                                                Err when element(1, Err)==error ->
 
649
                                                    Acc2;
 
650
                                                TK ->
 
651
                                                    unique_add_case_label(G, S, N, Id, 
 
652
                                                                          TK, Acc2)
 
653
                                            end
 
654
                                    end, 
 
655
                                    Acc,
 
656
                                    ic_forms:get_idlist(Case))
 
657
                end,
 
658
                [],
 
659
                Xs).
662
660
 
663
661
 
664
662
%% Handling of the things that can be in an idlist or caselist
690
688
                     maybe_array(G, S, N, X#case_dcl.id, BaseTK)};
691
689
                false ->
692
690
                    ic_error:error(G, {bad_case_type, DiscrTK, X, 
693
 
                                    iceval:get_val(Val)})
 
691
                                       iceval:get_val(Val)})
694
692
            end
695
693
    end.
696
694
 
712
710
                   [Id | N];
713
711
               false ->
714
712
                   [Id | tl(N)]
715
 
                 end,
 
713
           end,
716
714
 
717
715
    UName = mk_uppercase(Name),
718
716
    case ets:lookup(S, Name) of
719
 
        [{_, forward, _, _}] when record(X, interface) -> ok;
720
 
        [XX] when record(X, forward), element(2, XX)==interface -> ok;
721
717
        [_] -> ic_error:error(G, {multiply_defined, X});
722
718
        [] ->
723
719
            case ets:lookup(S, UName) of
781
777
            Name = [Id | N],
782
778
            UName = mk_uppercase(Name),
783
779
            case ets:lookup(S, Name) of
784
 
                [{_, forward, _, _}] when record(X, interface) -> ok;
785
 
                [XX] when record(X, forward), element(2, XX)==interface -> ok;
786
780
                [_] -> ic_error:error(G, {multiply_defined, X});
787
781
                [] ->
788
782
                    case ets:lookup(S, UName) of
823
817
%%
824
818
enum_body(G, S, N, [Enum | EnumList]) -> 
825
819
    tktab_add(G, S, N, Enum), %%%, enum_val, Enum),
826
 
%%    tktab_add(G, S, N, X, TK, V),
 
820
    %%    tktab_add(G, S, N, X, TK, V),
827
821
    [ic_forms:get_id2(Enum) | enum_body(G, S, N, EnumList)];
828
822
enum_body(_G, _S, _N, []) -> [].
829
823
 
863
857
%%
864
858
 
865
859
case_eval(G, S, N, DiscrTK, X) when element(1, DiscrTK) == tk_enum,
866
 
element(1, X) == scoped_id -> 
 
860
                                    element(1, X) == scoped_id -> 
867
861
    {tk_enum, _, _, Cases} = DiscrTK,
868
862
    Id = get_case_id_and_check(G, S, N, X, X),
869
863
    %%io:format("Matching: ~p to ~p~n", [Id, Cases]),
886
880
 
887
881
 
888
882
unique_add_case_label(G, _S, _N, Id, TK, TKList) ->
889
 
    %%%io:format("check_case_labels: TK:~p TKLIST:~p ~n", [TK, TKList]),
 
883
%%%io:format("check_case_labels: TK:~p TKLIST:~p ~n", [TK, TKList]),
890
884
    if  element(1, TK) == error -> 
891
885
            TKList;
892
886
        true ->
898
892
                    [TK | TKList]
899
893
            end
900
894
    end.
901
 
                                
 
895
 
902
896
 
903
897
%%--------------------------------------------------------------------
904
898
%% default_count
956
950
check_switch_tk(_G, _S, _N, _X, tk_wchar) -> true;  %% WCHAR
957
951
check_switch_tk(_G, _S, _N, _X, TK) when element(1, TK) == tk_enum -> true;
958
952
check_switch_tk(G, _S, _N, X, TK) -> ic_error:error(G, {illegal_switch_t, X, TK}),
959
 
                                   false.
 
953
                                     false.
960
954
 
961
955
 
962
956
 
963
957
%% Lookup a name
964
958
name_lookup(G, S, N, X) ->
965
959
    case scoped_lookup(G, S, N, X) of
966
 
        T when tuple(T) -> element(1, T);
967
 
        _ -> []
 
960
        T when tuple(T) -> element(1, T)
968
961
    end.
969
962
 
970
963
 
975
968
        [] ->       
976
969
            case look_for_interface(G, S, [hd(N2)], tl(N2)) of
977
970
 
978
 
                %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% First attempt: filtering inherited members !
 
971
                %% First attempt: filtering inherited members !
979
972
                [{_, member, _, _}] ->      
980
973
                    case look_for_interface(G, S, [hd(N)], tl(N2)) of
981
974
                        [T] -> 
982
975
                            ?DBG("    --  found ~p~n", [T]), 
983
976
                            T;
984
977
                        _ ->
985
 
                            if  N == [] -> 
986
 
                                    ic_error:error(G, {tk_not_found, X});
987
 
                                true ->
988
 
                                    lookup(G, S, tl(N), X, Id)
989
 
                            end
 
978
                            lookup(G, S, tl(N), X, Id)
990
979
                    end;
991
 
                %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
980
                %%
992
981
 
993
982
                [T] -> 
994
983
                    ?DBG("    --  found ~p~n", [T]), 
1003
992
 
1004
993
            end;
1005
994
 
1006
 
        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Second attempt: filtering members !
 
995
        %% Second attempt: filtering members !
1007
996
        [{_, member, _, _}] ->      
1008
997
            case look_for_interface(G, S, [hd(N2)], tl(N2)) of
1009
998
                [T] -> 
1016
1005
                            lookup(G, S, tl(N), X, Id)
1017
1006
                    end
1018
1007
            end;
1019
 
        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1020
 
 
 
1008
        %%
1021
1009
        [T] -> 
1022
1010
            ?DBG("    --  found ~p~n", [T]),
1023
1011
            T
1175
1163
%% Y and Y shadows X.
1176
1164
collision(G, XPath, X, YPath, Y) ->
1177
1165
    I1 = get_beef(X),
1178
 
%    I2 = get_beef(Y),
 
1166
                                                %    I2 = get_beef(Y),
1179
1167
    if record(I1, op) -> %%, record(I2, op) ->
1180
1168
            ic_error:error(G, {inherit_name_collision, 
1181
 
                            {YPath, Y}, {XPath, X}});
 
1169
                               {YPath, Y}, {XPath, X}});
1182
1170
       record(I1, attr) -> %%, record(I2, attr) ->
1183
1171
            ic_error:error(G, {inherit_name_collision, 
1184
 
                            {YPath, Y}, {XPath, X}});
 
1172
                               {YPath, Y}, {XPath, X}});
1185
1173
       true ->
1186
1174
            ?ifopt(G, warn_name_shadow, 
1187
1175
                   ic_error:warn(G, {inherit_name_shadow, 
1188
 
                                  {YPath, Y}, {XPath, X}}))
 
1176
                                     {YPath, Y}, {XPath, X}}))
1189
1177
    end.
1190
1178
 
1191
1179
has_idlist(X) when record(X, typedef) -> true;
1290
1278
 
1291
1279
        { _, spellcheck } ->
1292
1280
            filter( Is );
1293
 
        
 
1281
 
1294
1282
        _ ->
1295
1283
            error
1296
1284
    end.