← Back to branch summary

~ubuntu-branches/ubuntu/trusty/erlang/trusty

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Clint Byrum
  • Date: 2011-05-05 15:48:43 UTC
  • mfrom: (3.5.13 sid)
  • Revision ID: james.westby@ubuntu.com-20110505154843-0om6ekzg6m7ugj27
Tags: 1:14.b.2-dfsg-3ubuntu1
* Merge from debian unstable.  Remaining changes:
  - Drop libwxgtk2.8-dev build dependency. Wx isn't in main, and not
    supposed to.
  - Drop erlang-wx binary.
  - Drop erlang-wx dependency from -megaco, -common-test, and -reltool, they
    do not really need wx. Also drop it from -debugger; the GUI needs wx,
    but it apparently has CLI bits as well, and is also needed by -megaco,
    so let's keep the package for now.
  - debian/patches/series: Do what I meant, and enable build-options.patch
    instead.
* Additional changes:
  - Drop erlang-wx from -et
* Dropped Changes:
  - patches/pcre-crash.patch: CVE-2008-2371: outer level option with
    alternatives caused crash. (Applied Upstream)
  - fix for ssl certificate verification in newSSL: 
    ssl_cacertfile_fix.patch (Applied Upstream)
  - debian/patches/series: Enable native.patch again, to get stripped beam
    files and reduce the package size again. (build-options is what
    actually accomplished this)
  - Remove build-options.patch on advice from upstream and because it caused
    odd build failures.

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
 
21
21
%%%-------------------------------------------------------------------
22
22
%%% File    : dialyzer_codeserver.erl
23
23
%%% Author  : Tobias Lindahl <tobiasl@it.uu.se>
24
 
%%% Description : 
 
24
%%% Description :
25
25
%%%
26
26
%%% Created :  4 Apr 2005 by Tobias Lindahl <tobiasl@it.uu.se>
27
27
%%%-------------------------------------------------------------------
29
29
 
30
30
-export([delete/1,
31
31
         finalize_contracts/2,
 
32
         finalize_exported_types/2,
32
33
         finalize_records/2,
33
34
         get_contracts/1,
34
 
         get_exports/1, 
 
35
         get_exported_types/1,
 
36
         get_exports/1,
35
37
         get_records/1,
36
38
         get_next_core_label/1,
37
39
         get_temp_contracts/1,
 
40
         get_temp_exported_types/1,
38
41
         get_temp_records/1,
39
 
         insert/3, 
40
 
         insert_exports/2,       
 
42
         insert/3,
 
43
         insert_exports/2,
 
44
         insert_temp_exported_types/2,
41
45
         is_exported/2,
42
46
         lookup_mod_code/2,
43
47
         lookup_mfa_code/2,
52
56
         store_contracts/3,
53
57
         store_temp_contracts/3]).
54
58
 
 
59
-export_type([codeserver/0]).
 
60
 
55
61
-include("dialyzer.hrl").
56
62
 
57
63
%%--------------------------------------------------------------------
58
64
 
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()}).
 
65
-record(codeserver, {table_pid                        :: pid(),
 
66
                     exported_types      = sets:new() :: set(), % set(mfa())
 
67
                     temp_exported_types = sets:new() :: set(), % set(mfa())
 
68
                     exports             = sets:new() :: set(), % set(mfa())
 
69
                     next_core_label     = 0          :: label(),
 
70
                     records             = dict:new() :: dict(),
 
71
                     temp_records        = dict:new() :: dict(),
 
72
                     contracts           = dict:new() :: dict(),
 
73
                     temp_contracts      = dict:new() :: dict()}).
66
74
 
67
 
-opaque codeserver() :: #dialyzer_codeserver{}.
 
75
-opaque codeserver() :: #codeserver{}.
68
76
 
69
77
%%--------------------------------------------------------------------
70
78
 
71
79
-spec new() -> codeserver().
72
80
 
73
81
new() ->
74
 
  #dialyzer_codeserver{table_pid = table__new()}.
 
82
  #codeserver{table_pid = table__new()}.
75
83
 
76
84
-spec delete(codeserver()) -> 'ok'.
77
85
 
78
 
delete(#dialyzer_codeserver{table_pid = TablePid}) ->
 
86
delete(#codeserver{table_pid = TablePid}) ->
79
87
  table__delete(TablePid).
80
88
 
81
 
-spec insert(module(), cerl:c_module(), codeserver()) -> codeserver().
 
89
-spec insert(atom(), cerl:c_module(), codeserver()) -> codeserver().
82
90
 
83
91
insert(Mod, ModCode, CS) ->
84
 
  NewTablePid = table__insert(CS#dialyzer_codeserver.table_pid, Mod, ModCode),
85
 
  CS#dialyzer_codeserver{table_pid = NewTablePid}.
 
92
  NewTablePid = table__insert(CS#codeserver.table_pid, Mod, ModCode),
 
93
  CS#codeserver{table_pid = NewTablePid}.
 
94
 
 
95
-spec insert_temp_exported_types(set(), codeserver()) -> codeserver().
 
96
 
 
97
insert_temp_exported_types(Set, CS) ->
 
98
  CS#codeserver{temp_exported_types = Set}.
86
99
 
87
100
-spec insert_exports([mfa()], codeserver()) -> codeserver().
88
101
 
89
 
insert_exports(List, #dialyzer_codeserver{exports = Exports} = CS) ->
 
102
insert_exports(List, #codeserver{exports = Exports} = CS) ->
90
103
  Set = sets:from_list(List),
91
104
  NewExports = sets:union(Exports, Set),
92
 
  CS#dialyzer_codeserver{exports = NewExports}.
 
105
  CS#codeserver{exports = NewExports}.
93
106
 
94
107
-spec is_exported(mfa(), codeserver()) -> boolean().
95
108
 
96
 
is_exported(MFA, #dialyzer_codeserver{exports = Exports}) ->
 
109
is_exported(MFA, #codeserver{exports = Exports}) ->
97
110
  sets:is_element(MFA, Exports).
98
111
 
 
112
-spec get_exported_types(codeserver()) -> set(). % set(mfa())
 
113
 
 
114
get_exported_types(#codeserver{exported_types = ExpTypes}) ->
 
115
  ExpTypes.
 
116
 
 
117
-spec get_temp_exported_types(codeserver()) -> set().
 
118
 
 
119
get_temp_exported_types(#codeserver{temp_exported_types = TempExpTypes}) ->
 
120
  TempExpTypes.
 
121
 
99
122
-spec get_exports(codeserver()) -> set().  % set(mfa())
100
123
 
101
 
get_exports(#dialyzer_codeserver{exports = Exports}) ->
 
124
get_exports(#codeserver{exports = Exports}) ->
102
125
  Exports.
103
126
 
104
 
-spec lookup_mod_code(module(), codeserver()) -> cerl:c_module().
 
127
-spec finalize_exported_types(set(), codeserver()) -> codeserver().
 
128
 
 
129
finalize_exported_types(Set, CS) ->
 
130
  CS#codeserver{exported_types = Set, temp_exported_types = sets:new()}.
 
131
 
 
132
-spec lookup_mod_code(atom(), codeserver()) -> cerl:c_module().
105
133
 
106
134
lookup_mod_code(Mod, CS) when is_atom(Mod) ->
107
 
  table__lookup(CS#dialyzer_codeserver.table_pid, Mod).
 
135
  table__lookup(CS#codeserver.table_pid, Mod).
108
136
 
109
137
-spec lookup_mfa_code(mfa(), codeserver()) -> {cerl:c_var(), cerl:c_fun()}.
110
138
 
111
139
lookup_mfa_code({_M, _F, _A} = MFA, CS) ->
112
 
  table__lookup(CS#dialyzer_codeserver.table_pid, MFA).
 
140
  table__lookup(CS#codeserver.table_pid, MFA).
113
141
 
114
142
-spec get_next_core_label(codeserver()) -> label().
115
143
 
116
 
get_next_core_label(#dialyzer_codeserver{next_core_label = NCL}) ->
 
144
get_next_core_label(#codeserver{next_core_label = NCL}) ->
117
145
  NCL.
118
146
 
119
147
-spec set_next_core_label(label(), codeserver()) -> codeserver().
120
148
 
121
149
set_next_core_label(NCL, CS) ->
122
 
  CS#dialyzer_codeserver{next_core_label = NCL}.
123
 
 
124
 
-spec store_records(module(), dict(), codeserver()) -> codeserver().
125
 
 
126
 
store_records(Mod, Dict, #dialyzer_codeserver{records = RecDict} = CS)
 
150
  CS#codeserver{next_core_label = NCL}.
 
151
 
 
152
-spec store_records(atom(), dict(), codeserver()) -> codeserver().
 
153
 
 
154
store_records(Mod, Dict, #codeserver{records = RecDict} = CS)
127
155
  when is_atom(Mod) ->
128
156
  case dict:size(Dict) =:= 0 of
129
157
    true -> CS;
130
 
    false -> CS#dialyzer_codeserver{records = dict:store(Mod, Dict, RecDict)}
 
158
    false -> CS#codeserver{records = dict:store(Mod, Dict, RecDict)}
131
159
  end.
132
160
 
133
 
-spec lookup_mod_records(module(), codeserver()) -> dict(). 
 
161
-spec lookup_mod_records(atom(), codeserver()) -> dict().
134
162
 
135
 
lookup_mod_records(Mod, #dialyzer_codeserver{records = RecDict})
 
163
lookup_mod_records(Mod, #codeserver{records = RecDict})
136
164
  when is_atom(Mod) ->
137
165
  case dict:find(Mod, RecDict) of
138
166
    error -> dict:new();
139
167
    {ok, Dict} -> Dict
140
168
  end.
141
169
 
142
 
-spec get_records(codeserver()) -> dict(). 
 
170
-spec get_records(codeserver()) -> dict().
143
171
 
144
 
get_records(#dialyzer_codeserver{records = RecDict}) ->
 
172
get_records(#codeserver{records = RecDict}) ->
145
173
  RecDict.
146
174
 
147
 
-spec store_temp_records(module(), dict(), codeserver()) -> codeserver().
 
175
-spec store_temp_records(atom(), dict(), codeserver()) -> codeserver().
148
176
 
149
 
store_temp_records(Mod, Dict, #dialyzer_codeserver{temp_records = TempRecDict} = CS)
 
177
store_temp_records(Mod, Dict, #codeserver{temp_records = TempRecDict} = CS)
150
178
  when is_atom(Mod) ->
151
179
  case dict:size(Dict) =:= 0 of
152
180
    true -> CS;
153
 
    false -> CS#dialyzer_codeserver{temp_records = dict:store(Mod, Dict, TempRecDict)}
 
181
    false -> CS#codeserver{temp_records = dict:store(Mod, Dict, TempRecDict)}
154
182
  end.
155
183
 
156
 
-spec get_temp_records(codeserver()) -> dict(). 
 
184
-spec get_temp_records(codeserver()) -> dict().
157
185
 
158
 
get_temp_records(#dialyzer_codeserver{temp_records = TempRecDict}) ->
 
186
get_temp_records(#codeserver{temp_records = TempRecDict}) ->
159
187
  TempRecDict.
160
188
 
161
189
-spec set_temp_records(dict(), codeserver()) -> codeserver().
162
190
 
163
191
set_temp_records(Dict, CS) ->
164
 
  CS#dialyzer_codeserver{temp_records = Dict}.
 
192
  CS#codeserver{temp_records = Dict}.
165
193
 
166
 
-spec finalize_records(dict(), codeserver()) -> codeserver(). 
 
194
-spec finalize_records(dict(), codeserver()) -> codeserver().
167
195
 
168
196
finalize_records(Dict, CS) ->
169
 
  CS#dialyzer_codeserver{records = Dict, temp_records = dict:new()}.
170
 
 
171
 
-spec store_contracts(module(), dict(), codeserver()) -> codeserver(). 
172
 
 
173
 
store_contracts(Mod, Dict, #dialyzer_codeserver{contracts = C} = CS)
174
 
  when is_atom(Mod) ->
 
197
  CS#codeserver{records = Dict, temp_records = dict:new()}.
 
198
 
 
199
-spec store_contracts(atom(), dict(), codeserver()) -> codeserver().
 
200
 
 
201
store_contracts(Mod, Dict, #codeserver{contracts = C} = CS) when is_atom(Mod) ->
175
202
  case dict:size(Dict) =:= 0 of
176
203
    true -> CS;
177
 
    false -> CS#dialyzer_codeserver{contracts = dict:store(Mod, Dict, C)}
 
204
    false -> CS#codeserver{contracts = dict:store(Mod, Dict, C)}
178
205
  end.
179
206
 
180
 
-spec lookup_mod_contracts(module(), codeserver()) -> dict().
 
207
-spec lookup_mod_contracts(atom(), codeserver()) -> dict().
181
208
 
182
 
lookup_mod_contracts(Mod, #dialyzer_codeserver{contracts = ContDict})
 
209
lookup_mod_contracts(Mod, #codeserver{contracts = ContDict})
183
210
  when is_atom(Mod) ->
184
211
  case dict:find(Mod, ContDict) of
185
212
    error -> dict:new();
186
213
    {ok, Dict} -> Dict
187
214
  end.
188
215
 
189
 
-spec lookup_mfa_contract(mfa(), codeserver()) -> 
 
216
-spec lookup_mfa_contract(mfa(), codeserver()) ->
190
217
         'error' | {'ok', dialyzer_contracts:file_contract()}.
191
218
 
192
 
lookup_mfa_contract({M,_F,_A} = MFA, #dialyzer_codeserver{contracts = ContDict}) ->
 
219
lookup_mfa_contract({M,_F,_A} = MFA, #codeserver{contracts = ContDict}) ->
193
220
  case dict:find(M, ContDict) of
194
221
    error -> error;
195
222
    {ok, Dict} -> dict:find(MFA, Dict)
196
223
  end.
197
224
 
198
 
-spec get_contracts(codeserver()) -> dict(). 
 
225
-spec get_contracts(codeserver()) -> dict().
199
226
 
200
 
get_contracts(#dialyzer_codeserver{contracts = ContDict}) ->
 
227
get_contracts(#codeserver{contracts = ContDict}) ->
201
228
  ContDict.
202
229
 
203
 
-spec store_temp_contracts(module(), dict(), codeserver()) -> codeserver(). 
 
230
-spec store_temp_contracts(atom(), dict(), codeserver()) -> codeserver().
204
231
 
205
 
store_temp_contracts(Mod, Dict, #dialyzer_codeserver{temp_contracts = C} = CS)
 
232
store_temp_contracts(Mod, Dict, #codeserver{temp_contracts = C} = CS)
206
233
  when is_atom(Mod) ->
207
234
  case dict:size(Dict) =:= 0 of
208
235
    true -> CS;
209
 
    false -> CS#dialyzer_codeserver{temp_contracts = dict:store(Mod, Dict, C)}
 
236
    false -> CS#codeserver{temp_contracts = dict:store(Mod, Dict, C)}
210
237
  end.
211
238
 
212
239
-spec get_temp_contracts(codeserver()) -> dict().
213
240
 
214
 
get_temp_contracts(#dialyzer_codeserver{temp_contracts = TempContDict}) ->
 
241
get_temp_contracts(#codeserver{temp_contracts = TempContDict}) ->
215
242
  TempContDict.
216
243
 
217
244
-spec finalize_contracts(dict(), codeserver()) -> codeserver().
218
245
 
219
246
finalize_contracts(Dict, CS)  ->
220
 
  CS#dialyzer_codeserver{contracts = Dict, temp_contracts = dict:new()}.
 
247
  CS#codeserver{contracts = Dict, temp_contracts = dict:new()}.
221
248
 
222
249
table__new() ->
223
250
  spawn_link(fun() -> table__loop(none, dict:new()) end).
264
291
      Pid ! {self(), Mod, Ans},
265
292
      table__loop({Mod, Ans}, Map);
266
293
    {insert, List} ->
267
 
      NewMap = lists:foldl(fun({Key, Val}, AccMap) -> 
 
294
      NewMap = lists:foldl(fun({Key, Val}, AccMap) ->
268
295
                               dict:store(Key, Val, AccMap)
269
296
                           end, Map, List),
270
297
      table__loop(Cached, NewMap)