← Back to branch summary

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

« back to all changes in this revision

Viewing changes to lib/dialyzer/src/dialyzer_codeserver.erl

  • Committer: Bazaar Package Importer
  • Author(s): Sergei Golovan
  • Date: 2010-03-09 17:34:57 UTC
  • mfrom: (10.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20100309173457-4yd6hlcb2osfhx31
Tags: 1:13.b.4-dfsg-3
Manpages in section 1 are needed even if only arch-dependent packages are
built. So, re-enabled them.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/dialyzer/src/dialyzer_codeserver.erl
1
1
%% -*- erlang-indent-level: 2 -*-
2
2
%%-----------------------------------------------------------------------
3
3
%% %CopyrightBegin%
4
 
%% 
5
 
%% Copyright Ericsson AB 2006-2009. All Rights Reserved.
6
 
%% 
 
4
%%
 
5
%% Copyright Ericsson AB 2006-2010. All Rights Reserved.
 
6
%%
7
7
%% The contents of this file are subject to the Erlang Public License,
8
8
%% Version 1.1, (the "License"); you may not use this file except in
9
9
%% compliance with the License. You should have received a copy of the
10
10
%% Erlang Public License along with this software. If not, it can be
11
11
%% retrieved online at http://www.erlang.org/.
12
 
%% 
 
12
%%
13
13
%% Software distributed under the License is distributed on an "AS IS"
14
14
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
15
15
%% the License for the specific language governing rights and limitations
16
16
%% under the License.
17
 
%% 
 
17
%%
18
18
%% %CopyrightEnd%
19
19
%%
20
20
 
56
56
 
57
57
%%--------------------------------------------------------------------
58
58
 
59
 
-record(dialyzer_codeserver, {table_pid                   :: pid(),
60
 
                              exports   = sets:new()      :: set(), % set(mfa())
61
 
                              next_core_label = 0         :: label(),
62
 
                              records   = dict:new()      :: dict(),
63
 
                              temp_records = dict:new()   :: dict(),
64
 
                              contracts = dict:new()      :: dict(),
65
 
                              temp_contracts = dict:new() :: dict()}).
 
59
-record(codeserver, {table_pid                    :: pid(),
 
60
                     exports         = sets:new() :: set(), % set(mfa())
 
61
                     next_core_label = 0          :: label(),
 
62
                     records         = dict:new() :: dict(),
 
63
                     temp_records    = dict:new() :: dict(),
 
64
                     contracts       = dict:new() :: dict(),
 
65
                     temp_contracts  = dict:new() :: dict()}).
66
66
 
67
 
-opaque codeserver() :: #dialyzer_codeserver{}.
 
67
-opaque codeserver() :: #codeserver{}.
68
68
 
69
69
%%--------------------------------------------------------------------
70
70
 
71
71
-spec new() -> codeserver().
72
72
 
73
73
new() ->
74
 
  #dialyzer_codeserver{table_pid = table__new()}.
 
74
  #codeserver{table_pid = table__new()}.
75
75
 
76
76
-spec delete(codeserver()) -> 'ok'.
77
77
 
78
 
delete(#dialyzer_codeserver{table_pid = TablePid}) ->
 
78
delete(#codeserver{table_pid = TablePid}) ->
79
79
  table__delete(TablePid).
80
80
 
81
81
-spec insert(module(), cerl:c_module(), codeserver()) -> codeserver().
82
82
 
83
83
insert(Mod, ModCode, CS) ->
84
 
  NewTablePid = table__insert(CS#dialyzer_codeserver.table_pid, Mod, ModCode),
85
 
  CS#dialyzer_codeserver{table_pid = NewTablePid}.
 
84
  NewTablePid = table__insert(CS#codeserver.table_pid, Mod, ModCode),
 
85
  CS#codeserver{table_pid = NewTablePid}.
86
86
 
87
87
-spec insert_exports([mfa()], codeserver()) -> codeserver().
88
88
 
89
 
insert_exports(List, #dialyzer_codeserver{exports = Exports} = CS) ->
 
89
insert_exports(List, #codeserver{exports = Exports} = CS) ->
90
90
  Set = sets:from_list(List),
91
91
  NewExports = sets:union(Exports, Set),
92
 
  CS#dialyzer_codeserver{exports = NewExports}.
 
92
  CS#codeserver{exports = NewExports}.
93
93
 
94
94
-spec is_exported(mfa(), codeserver()) -> boolean().
95
95
 
96
 
is_exported(MFA, #dialyzer_codeserver{exports = Exports}) ->
 
96
is_exported(MFA, #codeserver{exports = Exports}) ->
97
97
  sets:is_element(MFA, Exports).
98
98
 
99
99
-spec get_exports(codeserver()) -> set().  % set(mfa())
100
100
 
101
 
get_exports(#dialyzer_codeserver{exports = Exports}) ->
 
101
get_exports(#codeserver{exports = Exports}) ->
102
102
  Exports.
103
103
 
104
104
-spec lookup_mod_code(module(), codeserver()) -> cerl:c_module().
105
105
 
106
106
lookup_mod_code(Mod, CS) when is_atom(Mod) ->
107
 
  table__lookup(CS#dialyzer_codeserver.table_pid, Mod).
 
107
  table__lookup(CS#codeserver.table_pid, Mod).
108
108
 
109
109
-spec lookup_mfa_code(mfa(), codeserver()) -> {cerl:c_var(), cerl:c_fun()}.
110
110
 
111
111
lookup_mfa_code({_M, _F, _A} = MFA, CS) ->
112
 
  table__lookup(CS#dialyzer_codeserver.table_pid, MFA).
 
112
  table__lookup(CS#codeserver.table_pid, MFA).
113
113
 
114
114
-spec get_next_core_label(codeserver()) -> label().
115
115
 
116
 
get_next_core_label(#dialyzer_codeserver{next_core_label = NCL}) ->
 
116
get_next_core_label(#codeserver{next_core_label = NCL}) ->
117
117
  NCL.
118
118
 
119
119
-spec set_next_core_label(label(), codeserver()) -> codeserver().
120
120
 
121
121
set_next_core_label(NCL, CS) ->
122
 
  CS#dialyzer_codeserver{next_core_label = NCL}.
 
122
  CS#codeserver{next_core_label = NCL}.
123
123
 
124
124
-spec store_records(module(), dict(), codeserver()) -> codeserver().
125
125
 
126
 
store_records(Mod, Dict, #dialyzer_codeserver{records = RecDict} = CS)
 
126
store_records(Mod, Dict, #codeserver{records = RecDict} = CS)
127
127
  when is_atom(Mod) ->
128
128
  case dict:size(Dict) =:= 0 of
129
129
    true -> CS;
130
 
    false -> CS#dialyzer_codeserver{records = dict:store(Mod, Dict, RecDict)}
 
130
    false -> CS#codeserver{records = dict:store(Mod, Dict, RecDict)}
131
131
  end.
132
132
 
133
133
-spec lookup_mod_records(module(), codeserver()) -> dict(). 
134
134
 
135
 
lookup_mod_records(Mod, #dialyzer_codeserver{records = RecDict})
 
135
lookup_mod_records(Mod, #codeserver{records = RecDict})
136
136
  when is_atom(Mod) ->
137
137
  case dict:find(Mod, RecDict) of
138
138
    error -> dict:new();
141
141
 
142
142
-spec get_records(codeserver()) -> dict(). 
143
143
 
144
 
get_records(#dialyzer_codeserver{records = RecDict}) ->
 
144
get_records(#codeserver{records = RecDict}) ->
145
145
  RecDict.
146
146
 
147
147
-spec store_temp_records(module(), dict(), codeserver()) -> codeserver().
148
148
 
149
 
store_temp_records(Mod, Dict, #dialyzer_codeserver{temp_records = TempRecDict} = CS)
 
149
store_temp_records(Mod, Dict, #codeserver{temp_records = TempRecDict} = CS)
150
150
  when is_atom(Mod) ->
151
151
  case dict:size(Dict) =:= 0 of
152
152
    true -> CS;
153
 
    false -> CS#dialyzer_codeserver{temp_records = dict:store(Mod, Dict, TempRecDict)}
 
153
    false -> CS#codeserver{temp_records = dict:store(Mod, Dict, TempRecDict)}
154
154
  end.
155
155
 
156
156
-spec get_temp_records(codeserver()) -> dict(). 
157
157
 
158
 
get_temp_records(#dialyzer_codeserver{temp_records = TempRecDict}) ->
 
158
get_temp_records(#codeserver{temp_records = TempRecDict}) ->
159
159
  TempRecDict.
160
160
 
161
161
-spec set_temp_records(dict(), codeserver()) -> codeserver().
162
162
 
163
163
set_temp_records(Dict, CS) ->
164
 
  CS#dialyzer_codeserver{temp_records = Dict}.
 
164
  CS#codeserver{temp_records = Dict}.
165
165
 
166
166
-spec finalize_records(dict(), codeserver()) -> codeserver(). 
167
167
 
168
168
finalize_records(Dict, CS) ->
169
 
  CS#dialyzer_codeserver{records = Dict, temp_records = dict:new()}.
 
169
  CS#codeserver{records = Dict, temp_records = dict:new()}.
170
170
 
171
171
-spec store_contracts(module(), dict(), codeserver()) -> codeserver(). 
172
172
 
173
 
store_contracts(Mod, Dict, #dialyzer_codeserver{contracts = C} = CS)
174
 
  when is_atom(Mod) ->
 
173
store_contracts(Mod, Dict, #codeserver{contracts = C} = CS) when is_atom(Mod) ->
175
174
  case dict:size(Dict) =:= 0 of
176
175
    true -> CS;
177
 
    false -> CS#dialyzer_codeserver{contracts = dict:store(Mod, Dict, C)}
 
176
    false -> CS#codeserver{contracts = dict:store(Mod, Dict, C)}
178
177
  end.
179
178
 
180
179
-spec lookup_mod_contracts(module(), codeserver()) -> dict().
181
180
 
182
 
lookup_mod_contracts(Mod, #dialyzer_codeserver{contracts = ContDict})
 
181
lookup_mod_contracts(Mod, #codeserver{contracts = ContDict})
183
182
  when is_atom(Mod) ->
184
183
  case dict:find(Mod, ContDict) of
185
184
    error -> dict:new();
189
188
-spec lookup_mfa_contract(mfa(), codeserver()) -> 
190
189
         'error' | {'ok', dialyzer_contracts:file_contract()}.
191
190
 
192
 
lookup_mfa_contract({M,_F,_A} = MFA, #dialyzer_codeserver{contracts = ContDict}) ->
 
191
lookup_mfa_contract({M,_F,_A} = MFA, #codeserver{contracts = ContDict}) ->
193
192
  case dict:find(M, ContDict) of
194
193
    error -> error;
195
194
    {ok, Dict} -> dict:find(MFA, Dict)
197
196
 
198
197
-spec get_contracts(codeserver()) -> dict(). 
199
198
 
200
 
get_contracts(#dialyzer_codeserver{contracts = ContDict}) ->
 
199
get_contracts(#codeserver{contracts = ContDict}) ->
201
200
  ContDict.
202
201
 
203
202
-spec store_temp_contracts(module(), dict(), codeserver()) -> codeserver(). 
204
203
 
205
 
store_temp_contracts(Mod, Dict, #dialyzer_codeserver{temp_contracts = C} = CS)
 
204
store_temp_contracts(Mod, Dict, #codeserver{temp_contracts = C} = CS)
206
205
  when is_atom(Mod) ->
207
206
  case dict:size(Dict) =:= 0 of
208
207
    true -> CS;
209
 
    false -> CS#dialyzer_codeserver{temp_contracts = dict:store(Mod, Dict, C)}
 
208
    false -> CS#codeserver{temp_contracts = dict:store(Mod, Dict, C)}
210
209
  end.
211
210
 
212
211
-spec get_temp_contracts(codeserver()) -> dict().
213
212
 
214
 
get_temp_contracts(#dialyzer_codeserver{temp_contracts = TempContDict}) ->
 
213
get_temp_contracts(#codeserver{temp_contracts = TempContDict}) ->
215
214
  TempContDict.
216
215
 
217
216
-spec finalize_contracts(dict(), codeserver()) -> codeserver().
218
217
 
219
218
finalize_contracts(Dict, CS)  ->
220
 
  CS#dialyzer_codeserver{contracts = Dict, temp_contracts = dict:new()}.
 
219
  CS#codeserver{contracts = Dict, temp_contracts = dict:new()}.
221
220
 
222
221
table__new() ->
223
222
  spawn_link(fun() -> table__loop(none, dict:new()) end).