← Back to branch summary

~ubuntu-branches/ubuntu/lucid/erlang/lucid-proposed

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Sergei Golovan
  • Date: 2009-06-11 12:18:07 UTC
  • mfrom: (1.2.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20090611121807-ks7eb4xrt7dsysgx
Tags: 1:13.b.1-dfsg-1
http://bugs.debian.org/529512
* New upstream release.
* Removed unnecessary dependency of erlang-os-mon on erlang-observer and
  erlang-tools and added missing dependency of erlang-nox on erlang-os-mon
  (closes: #529512).
* Removed a patch to eunit application because the bug was fixed upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/ic/src/ic_noc.erl
74
74
    ok.
75
75
 
76
76
 
77
 
gen(G, N, [X|Xs]) when record(X, preproc) ->
 
77
gen(G, N, [X|Xs]) when is_record(X, preproc) ->
78
78
    NewG = ic:handle_preproc(G, N, X#preproc.cat, X),
79
79
    gen(NewG, N, Xs);
80
80
 
81
 
gen(G, N, [X|Xs]) when record(X, module) ->
 
81
gen(G, N, [X|Xs]) when is_record(X, module) ->
82
82
    CD = ic_code:codeDirective(G,X),
83
83
    G2 = ic_file:filename_push(G, N, X, CD),
84
84
    N2 = [get_id2(X) | N],
87
87
    G3 = ic_file:filename_pop(G2, CD),
88
88
    gen(G3, N, Xs);
89
89
 
90
 
gen(G, N, [X|Xs]) when record(X, interface) ->
 
90
gen(G, N, [X|Xs]) when is_record(X, interface) ->
91
91
    G2 = ic_file:filename_push(G, N, X, erlang),
92
92
    N2 = [get_id2(X) | N],
93
93
    gen_head(G2, N2, X),
98
98
    G3 = ic_file:filename_pop(G2, erlang),
99
99
    gen(G3, N, Xs);
100
100
 
101
 
gen(G, N, [X|Xs]) when record(X, const) ->
 
101
gen(G, N, [X|Xs]) when is_record(X, const) ->
102
102
%    N2 = [get_id2(X) | N],
103
103
    emit_constant_func(G, X#const.id, X#const.val),
104
104
    gen(G, N, Xs); %% N2 or N?
105
105
 
106
 
gen(G, N, [X|Xs]) when record(X, op) ->
 
106
gen(G, N, [X|Xs]) when is_record(X, op) ->
107
107
    {Name, ArgNames, TypeList, OutArgs} = extract_info(G, N, X),
108
108
 
109
109
    case getNocType(G,X,N) of
120
120
    gen(G, N, Xs);
121
121
        
122
122
 
123
 
gen(G, N, [X|Xs]) when record(X, attr) ->
 
123
gen(G, N, [X|Xs]) when is_record(X, attr) ->
124
124
    emit_attr(G, N, X, fun emit_stub_func/7),
125
125
    gen(G, N, Xs);
126
126
 
127
 
gen(G, N, [X|Xs]) when record(X, except) ->
 
127
gen(G, N, [X|Xs]) when is_record(X, except) ->
128
128
    icstruct:except_gen(G, N, X, erlang),
129
129
    gen(G, N, Xs);
130
130
 
138
138
gen(_G, _N, []) -> ok.
139
139
 
140
140
 
141
 
may_contain_structs(X) when record(X, typedef) -> true;
142
 
may_contain_structs(X) when record(X, struct) -> true;
143
 
may_contain_structs(X) when record(X, union) -> true;
 
141
may_contain_structs(X) when is_record(X, typedef) -> true;
 
142
may_contain_structs(X) when is_record(X, struct) -> true;
 
143
may_contain_structs(X) when is_record(X, union) -> true;
144
144
may_contain_structs(_X) -> false.
145
145
 
146
146
 
172
172
            ok
173
173
    end.
174
174
 
175
 
gen_calls(G, N, [X|Xs]) when record(X, op) ->
 
175
gen_calls(G, N, [X|Xs]) when is_record(X, op) ->
176
176
    case is_oneway(X) of
177
177
        false ->
178
178
            {Name, ArgNames, TypeList, OutArgs} = extract_info(G, N, X),
182
182
            gen_calls(G, N, Xs)
183
183
    end;
184
184
 
185
 
gen_calls(G, N, [X|Xs]) when record(X, attr) ->
 
185
gen_calls(G, N, [X|Xs]) when is_record(X, attr) ->
186
186
    emit_attr(G, N, X, fun emit_skel_func/7),
187
187
    gen_calls(G, N, Xs);
188
188
 
189
189
gen_calls(G, N, [_X|Xs]) -> gen_calls(G, N, Xs);
190
190
gen_calls(_G, _N, []) -> ok.
191
191
 
192
 
gen_casts(G, N, [X|Xs]) when record(X, op) ->
 
192
gen_casts(G, N, [X|Xs]) when is_record(X, op) ->
193
193
    case is_oneway(X) of
194
194
        true ->
195
195
            {Name, ArgNames, TypeList, OutArgs} = extract_info(G, N, X),
217
217
                          end end, ic_forms:get_idlist(X)).
218
218
 
219
219
 
220
 
extract_info(G, _N, X) when record(X, op) ->
 
220
extract_info(G, _N, X) when is_record(X, op) ->
221
221
    Name        = get_id2(X),
222
222
    InArgs      = ic:filter_params([in,inout], X#op.params),
223
223
    OutArgs     = ic:filter_params([out,inout], X#op.params),
414
414
    end.
415
415
 
416
416
 
417
 
get_if(G,N,[X|Rest]) when record(X, op) ->
 
417
get_if(G,N,[X|Rest]) when is_record(X, op) ->
418
418
    R = ic_forms:get_tk(X),
419
419
    IN = lists:map(fun(P) -> ic_forms:get_tk(P) end,
420
420
                   ic:filter_params([in, inout], X#op.params)),
427
427
            get_if(G,N,Rest)
428
428
    end;
429
429
 
430
 
get_if(G,N,[X|Rest]) when record(X, attr) -> %% Attributes not handled so far <<<<<<<<<<<<<<<<<<<<<<<<
 
430
get_if(G,N,[X|Rest]) when is_record(X, attr) -> %% Attributes not handled so far <<<<<<<<<<<<<<<<<<<<<<<<
431
431
    {GetT, SetT} = mk_attr_func_types([], X),
432
432
    AList = lists:map(fun(Id) -> 
433
433
                              {Get, Set} = mk_attr_func_names([], get_id(Id)),
454
454
%%
455
455
 
456
456
 
457
 
gen_head_special(G, N, X) when record(X, interface) ->
 
457
gen_head_special(G, N, X) when is_record(X, interface) ->
458
458
    Fd = ic_genobj:stubfiled(G),
459
459
    NocType = getNocType(G,X,N),
460
460
 
506
506
 
507
507
exp_top(_G, _N, X, _NT, Acc)  when element(1, X) == preproc -> 
508
508
    Acc;
509
 
exp_top(G, N, L, NT, Acc)  when list(L) ->
 
509
exp_top(G, N, L, NT, Acc)  when is_list(L) ->
510
510
    exp_list(G, N, L, NT, Acc);
511
 
exp_top(G, N, M, NT, Acc)  when record(M, module) ->
 
511
exp_top(G, N, M, NT, Acc)  when is_record(M, module) ->
512
512
    exp_list(G, N, get_body(M), NT, Acc);
513
 
exp_top(G, N, I, NT, Acc)  when record(I, interface) ->
 
513
exp_top(G, N, I, NT, Acc)  when is_record(I, interface) ->
514
514
    exp_list(G, N, get_body(I), NT, Acc);
515
515
exp_top(G, N, X, NT, Acc) ->
516
516
    exp3(G, N, X, NT, Acc).
517
517
 
518
 
exp3(_G, _N, C, _NT, Acc)  when record(C, const) -> 
 
518
exp3(_G, _N, C, _NT, Acc)  when is_record(C, const) -> 
519
519
    [{get_id(C#const.id), 0} | Acc];
520
520
 
521
 
exp3(G, N, Op, NocType, Acc)  when record(Op, op) ->
 
521
exp3(G, N, Op, NocType, Acc)  when is_record(Op, op) ->
522
522
    FuncName = get_id(Op#op.id),
523
523
    
524
524
    TA = case use_timeout(G,N,Op) of
551
551
            Arity = length(ic:filter_params([in, inout], Op#op.params)) + TA + 1,
552
552
            [{FuncName, Arity} | Acc]
553
553
    end;
554
 
exp3(_G, _N, A, _NT, Acc)  when record(A, attr) ->
 
554
exp3(_G, _N, A, _NT, Acc)  when is_record(A, attr) ->
555
555
    lists:foldr(fun(Id, Acc2) ->
556
556
                        {Get, Set} = mk_attr_func_names([], get_id(Id)),
557
557
                        case A#attr.readonly of
756
756
%% Unfold identifier lists or nested lists. Note that many records
757
757
%% contain an entry named id that is a list before unfold and a single
758
758
%% id afterwards.
759
 
unfold(L) when list(L) ->
 
759
unfold(L) when is_list(L) ->
760
760
    lists:flatten(map(fun(X) -> unfold2(X) end, L));
761
761
unfold(X) -> unfold2(X).
762
762
    
763
 
unfold2(A) when record(A, attr) ->
 
763
unfold2(A) when is_record(A, attr) ->
764
764
    map(fun(Id) -> A#attr{id=Id} end, A#attr.id);
765
 
unfold2(M) when record(M, member) ->
 
765
unfold2(M) when is_record(M, member) ->
766
766
    map(fun(Id) -> M#member{id=Id} end, M#member.id);
767
 
unfold2(M) when record(M, case_dcl) ->
 
767
unfold2(M) when is_record(M, case_dcl) ->
768
768
    map(fun(Id) -> M#case_dcl{label=Id} end, M#case_dcl.label);
769
 
unfold2(T) when record(T, typedef) ->
 
769
unfold2(T) when is_record(T, typedef) ->
770
770
    map(fun(Id) -> T#typedef{id=Id} end, T#typedef.id   ).
771
771
 
772
772
 
810
810
    end.
811
811
 
812
812
 
813
 
getNocType(G,X,Scope) when record(X, interface) -> %% default | specified 
 
813
getNocType(G,X,Scope) when is_record(X, interface) -> %% default | specified 
814
814
    OpList = getAllOperationScopes(G,Scope),
815
815
    getNocType2(G,X,OpList);
816
816
getNocType(G,X,Scope) -> %% transparent | {extraarg1,....,extraargN}
930
930
%%   * if the operation has a specific pragma, apply the real
931
931
%%     scope, otherwise return the including scope 
932
932
%%
933
 
getActualScope(G, X, Scope) when record(X, op) ->
 
933
getActualScope(G, X, Scope) when is_record(X, op) ->
934
934
    OpScope = getRealOpScope(G,X,Scope),
935
935
    case ets:match(ic_genobj:pragmatab(G),{codeopt_specific,OpScope}) of
936
936
        [[]] ->
945
945
%%  Just seek and return the scope for the operation
946
946
%%  where it were originaly defined
947
947
%%
948
 
getRealOpScope(G,X,N) when record(X, op) ->
 
948
getRealOpScope(G,X,N) when is_record(X, op) ->
949
949
    Ptab = ic_genobj:pragmatab(G),
950
950
    Id = get_id2(X),
951
951
    
1019
1019
    end.
1020
1020
 
1021
1021
 
1022
 
print_tk(G, N, X) when record(X, op)-> %% operation
 
1022
print_tk(G, N, X) when is_record(X, op)-> %% operation
1023
1023
    case getNocType(G,X,N) of
1024
1024
        transparent ->
1025
1025
            false;