← Back to branch summary

~ubuntu-branches/debian/squeeze/erlang/squeeze

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Sergei Golovan
  • Date: 2009-08-05 20:54:29 UTC
  • mfrom: (6.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20090805205429-pm4pnwew8axraosl
Tags: 1:13.b.1-dfsg-5
http://bugs.debian.org/536891
* Fixed parentheses in Emacs mode (closes: #536891).
* Removed unnecessary conflicts with erlang-manpages package.
* Added workaround for #475459: disabled threads on sparc architecture.
  This breaks wxErlang, so it's only a temporary solution.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/ic/src/ictype.erl
69
69
%%      the type, therefore the declarator decides if the array type
70
70
%%      kind is added or not.
71
71
%%
72
 
maybe_array(G, S, N, X, TK) when record(X, array) ->
 
72
maybe_array(G, S, N, X, TK) when is_record(X, array) ->
73
73
    mk_array(G, S, N, X#array.size, TK);
74
74
maybe_array(_G, _S, _N, _, TK) -> TK.
75
75
 
84
84
 
85
85
%% This is en overloaded function,
86
86
%% differs in input on unions
87
 
member2type(_G, X, I) when record(X, union)->
 
87
member2type(_G, X, I) when is_record(X, union)->
88
88
    Name = ic_forms:get_id2(I),
89
89
    case lists:keysearch(Name,2,element(6,X#union.tk)) of
90
90
        false ->
182
182
        _ ->
183
183
            false
184
184
    end; 
185
 
isString(_G, _N, T)  when record(T, string) ->
 
185
isString(_G, _N, T)  when is_record(T, string) ->
186
186
    true;
187
187
isString(_G, _N, _Other) ->
188
188
    false. 
195
195
        _ ->
196
196
            false
197
197
    end; 
198
 
isWString(_G, _N, T)  when record(T, wstring) ->
 
198
isWString(_G, _N, T)  when is_record(T, wstring) ->
199
199
    true;
200
200
isWString(_G, _N, _Other) ->
201
201
    false. 
208
208
        _ ->
209
209
            false
210
210
    end; 
211
 
isArray(_G, _N, T)  when record(T, array) ->
 
211
isArray(_G, _N, T)  when is_record(T, array) ->
212
212
    true;
213
213
isArray(_G, _N, _Other) ->
214
214
    false. 
221
221
        _ ->
222
222
            false
223
223
    end; 
224
 
isSequence(_G, _N, T)  when record(T, sequence) ->
 
224
isSequence(_G, _N, T)  when is_record(T, sequence) ->
225
225
    true;
226
226
isSequence(_G, _N, _Other) ->
227
227
    false. 
234
234
        _ ->
235
235
            false
236
236
    end; 
237
 
isStruct(_G, _N, T)  when record(T, struct) ->
 
237
isStruct(_G, _N, T)  when is_record(T, struct) ->
238
238
    true;
239
239
isStruct(_G, _N, _Other) ->
240
240
    false.
247
247
        _Other ->
248
248
            false
249
249
    end; 
250
 
isUnion(_G, _N, T)  when record(T, union) ->
 
250
isUnion(_G, _N, T)  when is_record(T, union) ->
251
251
    true;
252
252
isUnion(_G, _N, _Other) ->
253
253
    false.
261
261
        _Other ->
262
262
            false
263
263
    end; 
264
 
isEnum(_G, _N, T)  when record(T, enum) ->
 
264
isEnum(_G, _N, T)  when is_record(T, enum) ->
265
265
    true;
266
266
isEnum(_G, _N, _Other) ->
267
267
    false.
352
352
%%-----------------------------------------------------------------
353
353
%% Internal functions
354
354
%%-----------------------------------------------------------------
355
 
check(G, _S, N, X) when record(X, preproc) ->
 
355
check(G, _S, N, X) when is_record(X, preproc) ->
356
356
    handle_preproc(G, N, X#preproc.cat, X),
357
357
    X;
358
358
 
359
 
check(G, S, N, X) when record(X, op) ->
 
359
check(G, S, N, X) when is_record(X, op) ->
360
360
    ?STDDBG,
361
361
    TK = tk_base(G, S, N, ic_forms:get_type(X)),
362
362
    tktab_add(G, S, N, X),
389
389
    end,
390
390
    X#op{params=Ps, tk=TK, raises=Raises};
391
391
 
392
 
check(G, S, N, X) when record(X, interface) ->
 
392
check(G, S, N, X) when is_record(X, interface) ->
393
393
    ?STDDBG,
394
394
    N2 = [ic_forms:get_id2(X) | N],
395
395
    TK = {tk_objref, ictk:get_IR_ID(G, N, X), ic_forms:get_id2(X)},
402
402
    ic_symtab:store(G, N, X2),
403
403
    X2;
404
404
 
405
 
check(G, S, N, X) when record(X, forward) ->
 
405
check(G, S, N, X) when is_record(X, forward) ->
406
406
    ?STDDBG,
407
407
    tktab_add(G, S, N, X, {tk_objref, ictk:get_IR_ID(G, N, X), ic_forms:get_id2(X)}),
408
408
    X;
409
409
 
410
410
 
411
 
check(G, S, N, X) when record(X, const) ->
 
411
check(G, S, N, X) when is_record(X, const) ->
412
412
    ?STDDBG,
413
413
    case tk_base(G, S, N, ic_forms:get_type(X)) of
414
414
        Err when element(1, Err) == error -> X;
427
427
            end
428
428
    end;
429
429
 
430
 
check(G, S, N, X) when record(X, const) ->
 
430
check(G, S, N, X) when is_record(X, const) ->
431
431
    ?STDDBG,
432
432
    case tk_base(G, S, N, ic_forms:get_type(X)) of
433
433
        Err when element(1, Err) == error -> X;
442
442
            end
443
443
    end;
444
444
 
445
 
check(G, S, N, X) when record(X, except) ->
 
445
check(G, S, N, X) when is_record(X, except) ->
446
446
    ?STDDBG,
447
447
    TK = tk(G, S, N, X),
448
448
    X#except{tk=TK};
449
449
 
450
 
check(G, S, N, X) when record(X, struct) ->
 
450
check(G, S, N, X) when is_record(X, struct) ->
451
451
    ?STDDBG,
452
452
    TK = tk(G, S, N, X),
453
453
    X#struct{tk=TK};
454
454
 
455
 
check(G, S, N, X) when record(X, enum) ->
 
455
check(G, S, N, X) when is_record(X, enum) ->
456
456
    ?STDDBG,
457
457
    TK = tk(G, S, N, X),
458
458
    X#enum{tk=TK};
459
459
 
460
 
check(G, S, N, X) when record(X, union) ->
 
460
check(G, S, N, X) when is_record(X, union) ->
461
461
    ?STDDBG,
462
462
    TK = tk(G, S, N, X),
463
463
    X#union{tk=TK};
464
464
 
465
 
check(G, S, N, X) when record(X, attr) ->
 
465
check(G, S, N, X) when is_record(X, attr) ->
466
466
    ?STDDBG,
467
467
    TK = tk_base(G, S, N, ic_forms:get_type(X)),
468
468
    XX = #id_of{type=X},
470
470
                  ic_forms:get_idlist(X)),
471
471
    X#attr{tk=TK};
472
472
 
473
 
check(G, S, N, X) when record(X, module) -> 
 
473
check(G, S, N, X) when is_record(X, module) -> 
474
474
    ?STDDBG,
475
475
    tktab_add(G, S, N, X),
476
476
    X#module{body=check_list(G, S, [ic_forms:get_id2(X) | N], ic_forms:get_body(X))};
477
477
 
478
 
check(G, S, N, X) when record(X, typedef) ->
 
478
check(G, S, N, X) when is_record(X, typedef) ->
479
479
    ?STDDBG,
480
480
    TKbase = tk(G, S, N, X),
481
481
    X#typedef{tk=TKbase};
494
494
%%
495
495
%%--------------------------------------------------------------------
496
496
 
497
 
tk(G, S, N, X) when record(X, union) ->
 
497
tk(G, S, N, X) when is_record(X, union) ->
498
498
    N2 = [ic_forms:get_id2(X) | N],
499
499
    DisrcTK = tk(G, S, N, ic_forms:get_type(X)),
500
500
    case check_switch_tk(G, S, N, X, DisrcTK) of
509
509
            tk_void
510
510
    end;
511
511
 
512
 
tk(G, S, N, X) when record(X, enum) ->
 
512
tk(G, S, N, X) when is_record(X, enum) ->
513
513
    N2 = [ic_forms:get_id2(X) | N],
514
514
    tktab_add(G, S, N, X,
515
515
              {tk_enum, ictk:get_IR_ID(G, N, X), ic_forms:get_id2(X), 
519
519
%% Note that the TK returned from this function is the base TK. It
520
520
%% must be modified for each of the identifiers in the idlist (for
521
521
%% array reasons).
522
 
tk(G, S, N, X) when record(X, typedef) ->
 
522
tk(G, S, N, X) when is_record(X, typedef) ->
523
523
    case X of
524
524
        %% Special case only for term and java backend !
525
525
        {typedef,{any,_},[{'<identifier>',_,"term"}],undefined} ->
546
546
            TK
547
547
    end;
548
548
 
549
 
tk(G, S, N, X) when record(X, struct) ->
 
549
tk(G, S, N, X) when is_record(X, struct) ->
550
550
    N2 = [ic_forms:get_id2(X) | N],
551
551
    tktab_add(G, S, N, X, {tk_struct, ictk:get_IR_ID(G, N, X), ic_forms:get_id2(X), 
552
552
                           tk_memberlist(G, S, N2, ic_forms:get_body(X))});
553
553
 
554
 
tk(G, S, N, X) when record(X, except) ->
 
554
tk(G, S, N, X) when is_record(X, except) ->
555
555
    N2 = [ic_forms:get_id2(X) | N],
556
556
    tktab_add(G, S, N, X, {tk_except, ictk:get_IR_ID(G, N, X), ic_forms:get_id2(X), 
557
557
                           tk_memberlist(G, S, N2, ic_forms:get_body(X))});
559
559
tk(G, S, N, X) -> tk_base(G, S, N, X).
560
560
 
561
561
 
562
 
tk_base(G, S, N, X) when record(X, sequence) ->
 
562
tk_base(G, S, N, X) when is_record(X, sequence) ->
563
563
    {tk_sequence, tk(G, S, N, X#sequence.type), 
564
564
     len_eval(G, S, N, X#sequence.length)};
565
565
 
566
 
tk_base(G, S, N, X) when record(X, string) ->
 
566
tk_base(G, S, N, X) when is_record(X, string) ->
567
567
    {tk_string, len_eval(G, S, N, X#string.length)};
568
568
 
569
 
tk_base(G, S, N, X) when record(X, wstring) ->  %% WSTRING
 
569
tk_base(G, S, N, X) when is_record(X, wstring) ->  %% WSTRING
570
570
    {tk_wstring, len_eval(G, S, N, X#wstring.length)};
571
571
 
572
572
%% Fixed constants can be declared as:
573
573
%% (1)  const fixed pi = 3.14D; or
574
574
%% (2)  typedef fixed<3,2> f32;
575
575
%%      const f32 pi = 3.14D;
576
 
tk_base(G, S, N, X) when record(X, fixed) -> 
 
576
tk_base(G, S, N, X) when is_record(X, fixed) -> 
577
577
    %% Case 2
578
578
    {tk_fixed, len_eval(G, S, N, X#fixed.digits), len_eval(G, S, N, X#fixed.scale)};
579
579
tk_base(_G, _S, _N, {fixed, _}) -> 
594
594
        _ ->
595
595
            case scoped_lookup(G, S, N, {scoped_id,V1,V2,["TypeCode","CORBA"]}) of
596
596
                T when element(1, T) == error -> T;
597
 
                T when tuple(T) -> element(3, T)
 
597
                T when is_tuple(T) -> element(3, T)
598
598
            end 
599
599
    end;
600
600
 
601
601
tk_base(G, S, N, X) when element(1, X) == scoped_id ->
602
602
    case scoped_lookup(G, S, N, X) of
603
603
        T when element(1, T) == error -> T;
604
 
        T when tuple(T) -> element(3, T)
 
604
        T when is_tuple(T) -> element(3, T)
605
605
    end;
606
606
tk_base(_G, _S, _N, {long, _})                  -> tk_long;
607
607
tk_base(_G, _S, _N, {'long long', _})           -> tk_longlong;  %% LLONG
702
702
    tktab_add_id(G, S, N, X, ic_forms:get_id2(X), TK, Aux).
703
703
 
704
704
 
705
 
tktab_add_id(G, S, N, X, Id, TK, Aux) when record(X,enumerator) ->
 
705
tktab_add_id(G, S, N, X, Id, TK, Aux) when is_record(X,enumerator) ->
706
706
 
707
707
    %% Check if the "scl" flag is set to true
708
708
    %% if so, allow old semantics ( errornous )
731
731
%% Fixes the multiple file module definition check 
732
732
%% but ONLY for Corba backend
733
733
%%                              
734
 
tktab_add_id(G, S, N, X, Id, TK, Aux) when record(X,module) ->
 
734
tktab_add_id(G, S, N, X, Id, TK, Aux) when is_record(X,module) ->
735
735
    case ic_options:get_opt(G, be) of
736
736
        erl_template ->
737
737
            Name = [Id | N],
795
795
    Name = [Id | N],
796
796
    UName = mk_uppercase(Name),
797
797
    case ets:lookup(S, Name) of
798
 
        [{_, forward, _, _}] when record(X, interface) -> ok;
799
 
        [XX] when record(X, forward), element(2, XX)==interface -> ok;
 
798
        [{_, forward, _, _}] when is_record(X, interface) -> ok;
 
799
        [XX] when is_record(X, forward) andalso element(2, XX)==interface -> ok;
800
800
        [_] -> ic_error:error(G, {multiply_defined, X});
801
801
        [] ->
802
802
            case ets:lookup(S, UName) of
875
875
 
876
876
 
877
877
%% The enum declarator is in the union scope.
878
 
do_special_enum(G, S, N, X) when record(X, enum) ->
 
878
do_special_enum(G, S, N, X) when is_record(X, enum) ->
879
879
    tktab_add(G, S, N, #id_of{id=X#enum.id, type=X});
880
880
do_special_enum(_G, _S, _N, _X) ->
881
881
    ok.
959
959
%% Lookup a name
960
960
name_lookup(G, S, N, X) ->
961
961
    case scoped_lookup(G, S, N, X) of
962
 
        T when tuple(T) -> element(1, T)
 
962
        T when is_tuple(T) -> element(1, T)
963
963
    end.
964
964
 
965
965
 
1021
1021
        [{_, interface, _TK, Inh}] -> 
1022
1022
            case look_in_inherit(G, S, Hd, Inh) of
1023
1023
                %% gather_inherit(G, S, Inh, [])) of
1024
 
                [X] when tuple(X) -> 
 
1024
                [X] when is_tuple(X) -> 
1025
1025
                    [X];
1026
1026
                _ -> 
1027
1027
                    look_for_interface(G, S, Hd ++ [hd(Tl)], tl(Tl))
1032
1032
 
1033
1033
look_in_inherit(G, S, Id, [I | Is]) ->
1034
1034
    case ets:lookup(S, Id ++ I) of
1035
 
        [X] when tuple(X) -> 
 
1035
        [X] when is_tuple(X) -> 
1036
1036
            [X];
1037
1037
        [] ->  
1038
1038
            look_in_inherit(G, S, Id, Is)
1058
1058
 
1059
1059
calc_inherit_body(G, N, OrigBody, [X|Xs], InhBody) ->
1060
1060
    case ic_symtab:retrieve(G, X) of
1061
 
        Intf when record(Intf, interface) ->
 
1061
        Intf when is_record(Intf, interface) ->
1062
1062
            Body = filter_body(G, X, ic_forms:get_body(Intf), N, OrigBody, InhBody),
1063
1063
            calc_inherit_body(G, N, OrigBody, Xs, [{X, Body} | InhBody]);
1064
1064
        XXX ->
1166
1166
collision(G, XPath, X, YPath, Y) ->
1167
1167
    I1 = get_beef(X),
1168
1168
                                                %    I2 = get_beef(Y),
1169
 
    if record(I1, op) -> %%, record(I2, op) ->
 
1169
    if is_record(I1, op) -> %%, record(I2, op) ->
1170
1170
            ic_error:error(G, {inherit_name_collision, 
1171
1171
                               {YPath, Y}, {XPath, X}});
1172
 
       record(I1, attr) -> %%, record(I2, attr) ->
 
1172
       is_record(I1, attr) -> %%, record(I2, attr) ->
1173
1173
            ic_error:error(G, {inherit_name_collision, 
1174
1174
                               {YPath, Y}, {XPath, X}});
1175
1175
       true ->
1178
1178
                                     {YPath, Y}, {XPath, X}}))
1179
1179
    end.
1180
1180
 
1181
 
has_idlist(X) when record(X, typedef) -> true;
1182
 
has_idlist(X) when record(X, member) -> true;
1183
 
has_idlist(X) when record(X, case_dcl) -> true;
1184
 
has_idlist(X) when record(X, attr) -> true;
 
1181
has_idlist(X) when is_record(X, typedef) -> true;
 
1182
has_idlist(X) when is_record(X, member) -> true;
 
1183
has_idlist(X) when is_record(X, case_dcl) -> true;
 
1184
has_idlist(X) when is_record(X, attr) -> true;
1185
1185
has_idlist(_) -> false.
1186
1186
 
1187
 
replace_idlist(X, IdList) when record(X, typedef) -> X#typedef{id=IdList};
1188
 
replace_idlist(X, IdList) when record(X, attr) -> X#attr{id=IdList}.
 
1187
replace_idlist(X, IdList) when is_record(X, typedef) -> X#typedef{id=IdList};
 
1188
replace_idlist(X, IdList) when is_record(X, attr) -> X#attr{id=IdList}.
1189
1189
 
1190
 
get_beef(X) when record(X, id_of) -> X#id_of.type;
 
1190
get_beef(X) when is_record(X, id_of) -> X#id_of.type;
1191
1191
get_beef(X) -> X.
1192
1192
 
1193
1193
 
1401
1401
    searchIncludedTk(TK,IR_ID);
1402
1402
searchIncludedTk({tk_sequence,TK,_},IR_ID) ->
1403
1403
    searchIncludedTk(TK,IR_ID);
1404
 
searchIncludedTk(TK, _IR_ID) when atom(TK) ->
 
1404
searchIncludedTk(TK, _IR_ID) when is_atom(TK) ->
1405
1405
    false;
1406
1406
searchIncludedTk(TK,IR_ID) ->
1407
1407
    case element(2,TK) == IR_ID of