OTP-8647 Xref adds calls to operators when {builtins,true}

When given the option {builtins,true} Xref now adds calls to operators.

3 files changed, 186 insertions, 173 deletions

diff --git a/lib/tools/src/xref_base.erl b/lib/tools/src/xref_base.erl
index d0dbf4a2b4..1656899e8f 100644
--- a/lib/tools/src/xref_base.erl
+++ b/lib/tools/src/xref_base.erl
@@ -1,19 +1,19 @@
 %%
 %% %CopyrightBegin%
-%% 
-%% Copyright Ericsson AB 2000-2009. All Rights Reserved.
-%% 
+%%
+%% Copyright Ericsson AB 2000-2010. All Rights Reserved.
+%%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
 %% compliance with the License. You should have received a copy of the
 %% Erlang Public License along with this software. If not, it can be
 %% retrieved online at http://www.erlang.org/.
-%% 
+%%
 %% Software distributed under the License is distributed on an "AS IS"
 %% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 %% the License for the specific language governing rights and limitations
 %% under the License.
-%% 
+%%
 %% %CopyrightEnd%
 %%
 
@@ -29,7 +29,7 @@
 	 add_release/2, add_release/3,
 	 get_library_path/1, set_library_path/2, set_library_path/3,
 	 set_up/1, set_up/2,
-	 q/2, q/3, info/1, info/2, info/3, update/1, update/2, 
+	 q/2, q/3, info/1, info/2, info/3, update/1, update/2,
 	 forget/1, forget/2, variables/1, variables/2,
 	 analyze/2, analyze/3, analysis/1,
 	 get_default/2, set_default/3,
@@ -38,14 +38,14 @@
 -export([format_error/1]).
 
 %% The following functions are exported for testing purposes only:
--export([do_add_module/4, do_add_application/2, do_add_release/2, 
+-export([do_add_module/4, do_add_application/2, do_add_release/2,
 	 do_remove_module/2]).
 
--import(lists, 
-	[filter/2, flatten/1, foldl/3, keysearch/3, map/2, mapfoldl/3, 
-         member/2, reverse/1, sort/1, usort/1]).
+-import(lists,
+	[filter/2, flatten/1, foldl/3, foreach/2, keysearch/3, map/2,
+         mapfoldl/3, member/2, reverse/1, sort/1, usort/1]).
 
--import(sofs, 
+-import(sofs,
 	[constant_function/2, converse/1, difference/2, domain/1,
          empty_set/0, family/1, family_difference/2, intersection/2,
          family_projection/2, family_to_relation/1, family_union/1,
@@ -103,12 +103,12 @@ delete(State) ->
 			  ok
 		  end
 	     end,
-    map(Fun, dict:to_list(State#xref.variables)),
+    foreach(Fun, dict:to_list(State#xref.variables)),
     ok.
 
 add_directory(State, Dir) ->
     add_directory(State, Dir, []).
-    
+
 %% -> {ok, Modules, NewState} | Error
 add_directory(State, Dir, Options) ->
     ValOptions = option_values([builtins, recurse, verbose, warnings], State),
@@ -277,7 +277,7 @@ q(S, Q, Options) when is_atom(Q) ->
     q(S, atom_to_list(Q), Options);
 q(S, Q, Options) ->
     case xref_utils:is_string(Q, 1) of
-	true -> 
+	true ->
 	    case set_up(S, Options) of
 		{ok, S1} ->
 		    case xref_compiler:compile(Q, S1#xref.variables) of
@@ -336,7 +336,7 @@ forget(State, Variable) when is_atom(Variable) ->
 forget(State, Variables) ->
     Vars = State#xref.variables,
     do_forget(Variables, Vars, Variables, State).
-    
+
 variables(State) ->
     variables(State, [user]).
 
@@ -350,9 +350,9 @@ variables(State, Options) ->
 		{ok, NewState} ->
 		    {U, P} = do_variables(NewState),
 		    R1 = if User -> [{user, U}]; true -> [] end,
-		    R = if 
-			    Predef -> [{predefined,P} | R1]; 
-			    true -> R1 
+		    R = if
+			    Predef -> [{predefined,P} | R1];
+			    true -> R1
 			end,
 		    {{ok, R}, NewState};
 		Error ->
@@ -368,7 +368,7 @@ analyze(State, Analysis) ->
 %% -> {{ok, Answer}, NewState} | {Error, NewState}
 analyze(State, Analysis, Options) ->
     case analysis(Analysis, State#xref.mode) of
-	P when is_list(P) -> 
+	P when is_list(P) ->
 	    q(State, P, Options);
 	error ->
 	    R = case analysis(Analysis, functions) of
@@ -461,7 +461,7 @@ get_default(State, Option) ->
 
 %% -> [{Option, Value}]
 get_default(State) ->
-    Fun = fun(O) -> V = current_default(State, O), {O, V} end, 
+    Fun = fun(O) -> V = current_default(State, O), {O, V} end,
     map(Fun, [builtins, recurse, verbose, warnings]).
 
 %% -> {ok, NewState} -> Error
@@ -478,7 +478,7 @@ set_default(State, Options) ->
 format_error({error, Module, Error}) ->
     Module:format_error(Error);
 format_error({invalid_options, Options}) ->
-    io_lib:format("Unknown option(s) or invalid option value(s): ~p~n", 
+    io_lib:format("Unknown option(s) or invalid option value(s): ~p~n",
 		  [Options]);
 format_error({invalid_filename, Term}) ->
     io_lib:format("A file name (a string) was expected: ~p~n", [Term]);
@@ -540,7 +540,7 @@ updated_modules(State) ->
 		  case xref_utils:file_info(File) of
 		      {ok, {_, file, readable, MTime}} when MTime =/= RTime ->
 			  [{M,File} | L];
-		      _Else -> 
+		      _Else ->
 			  L
 		  end
 	  end,
@@ -591,7 +591,7 @@ do_add_release(Dir, RelName, OB, OV, OW, State) ->
     case xref_utils:release_directory(Dir, true, "ebin") of
 	{ok, ReleaseDirName, ApplDir, Dirs} ->
 	    ApplDirs = xref_utils:select_last_application_version(Dirs),
-	    Release = case RelName of 
+	    Release = case RelName of
 			  [[]] -> ReleaseDirName;
 			  [Name] -> Name
 		      end,
@@ -615,7 +615,7 @@ do_add_release(S, XRel) ->
     end.
 
 add_rel_appls([ApplDir | ApplDirs], Release, OB, OV, OW, State) ->
-    {ok, _AppName,  NewState} = 
+    {ok, _AppName,  NewState} =
 	add_appldir(ApplDir, Release, [[]], OB, OV, OW, State),
     add_rel_appls(ApplDirs, Release, OB, OV, OW, NewState);
 add_rel_appls([], [Release], _OB, _OV, _OW, NewState) ->
@@ -637,10 +637,10 @@ add_appldir(ApplDir, Release, Name, OB, OV, OW, OldState) ->
 		  [[]] -> AppName0;
 		  [N] -> N
 	      end,
-    AppInfo = #xref_app{name = AppName, rel_name = Release, 
+    AppInfo = #xref_app{name = AppName, rel_name = Release,
 			vsn = Vsn, dir = Dir},
     State1 = do_add_application(OldState, AppInfo),
-    {ok, _Modules, NewState} = 
+    {ok, _Modules, NewState} =
 	do_add_directory(Dir, [AppName], OB, false, OV, OW, State1),
     {ok, AppName, NewState}.
 
@@ -662,7 +662,7 @@ do_add_directory(Dir, AppName, Bui, Rec, Ver, War, State) ->
     ok = is_filename(Dir),
     {FileNames, Errors, Jams, Unreadable} =
 	xref_utils:scan_directory(Dir, Rec, [?Suffix], [".jam"]),
-    warnings(War, jam, Jams),	
+    warnings(War, jam, Jams),
     warnings(War, unreadable, Unreadable),
     case Errors of
 	[] ->
@@ -683,7 +683,7 @@ do_add_a_module(File, AppName, Builtins, Verbose, Warnings, State) ->
 	false ->
 	    throw_error({invalid_filename, File});
 	Splitname ->
-	    do_add_module(Splitname, AppName, Builtins, Verbose, 
+	    do_add_module(Splitname, AppName, Builtins, Verbose,
 			  Warnings, State)
     end.
 
@@ -691,7 +691,7 @@ do_add_a_module(File, AppName, Builtins, Verbose, Warnings, State) ->
 %% Options: verbose, warnings, builtins
 do_add_module({Dir, Basename}, AppName, Builtins, Verbose, Warnings, State) ->
     File = filename:join(Dir, Basename),
-    {ok, M, Bad, NewState} = 
+    {ok, M, Bad, NewState} =
 	do_add_module1(Dir, File, AppName, Builtins, Verbose, Warnings, State),
     filter(fun({Tag,B}) -> warnings(Warnings, Tag, [[File,B]]) end, Bad),
     {ok, M, NewState}.
@@ -723,7 +723,7 @@ do_add_module1(Dir, File, AppName, Builtins, Verbose, Warnings, State) ->
 		    {ok, {_, _, _, Time}} -> Time;
 		    Error -> throw(Error)
 		end,
-	    XMod = #xref_mod{name = M, app_name = AppName, dir = Dir, 
+	    XMod = #xref_mod{name = M, app_name = AppName, dir = Dir,
 			     mtime = T, builtins = Builtins,
 			     no_unresolved = NoUnresCalls},
 	    do_add_module(State, XMod, UnresCalls, Data);
@@ -736,13 +736,13 @@ abst(File, Builtins, Mode) when Mode =:= functions ->
     case beam_lib:chunks(File, [abstract_code, exports, attributes]) of
 	{ok, {M,[{abstract_code,NoA},_X,_A]}} when NoA =:= no_abstract_code ->
 	    {ok, M, NoA};
-	{ok, {M, [{abstract_code, {abstract_v1, Forms}}, 
+	{ok, {M, [{abstract_code, {abstract_v1, Forms}},
                   {exports,X0}, {attributes,A}]}} ->
 	    %% R7.
 	    X = xref_utils:fa_to_mfa(X0, M),
             D = deprecated(A, X, M),
 	    xref_reader:module(M, Forms, Builtins, X, D);
-	{ok, {M, [{abstract_code, {abstract_v2, Forms}}, 
+	{ok, {M, [{abstract_code, {abstract_v2, Forms}},
                   {exports,X0}, {attributes,A}]}} ->
 	    %% R8-R9B.
 	    X = xref_utils:fa_to_mfa(X0, M),
@@ -769,8 +769,8 @@ abst(File, Builtins, Mode) when Mode =:= modules ->
 		    true ->
 			I0;
 		    false ->
-			Fun = fun({M,F,A}) -> 
-				      not xref_utils:is_builtin(M, F, A) 
+			Fun = fun({M,F,A}) ->
+				      not xref_utils:is_builtin(M, F, A)
 			      end,
 			filter(Fun, I0)
 		end,
@@ -790,7 +790,7 @@ mfa_exports(X0, Attributes, M) ->
     xref_utils:fa_to_mfa(X1, M).
 
 adjust_arity(F, A) ->
-    case xref_utils:is_static_function(F, A) of 
+    case xref_utils:is_static_function(F, A) of
         true -> A;
         false -> A - 1
     end.
@@ -885,7 +885,7 @@ do_add_module(S, M, XMod, Unres0, Data) when S#xref.mode =:= functions ->
     Unres = domain(UnresCalls),
 
     DefinedFuns = domain(DefAt),
-    {AXC, ALC, Bad1, LPreCAt2, XPreCAt2} = 
+    {AXC, ALC, Bad1, LPreCAt2, XPreCAt2} =
 	extra_edges(AXC1, ALC1, Bad0, DefinedFuns),
     Bad = map(fun(B) -> {xref_attr, B} end, Bad1),
     LPreCAt = union(LPreCAt1, LPreCAt2),
@@ -904,8 +904,8 @@ do_add_module(S, M, XMod, Unres0, Data) when S#xref.mode =:= functions ->
 
     %% {EE, ECallAt} = inter_graph(X, L, LC, XC, LCallAt, XCallAt),
     Self = self(),
-    Fun = fun() -> inter_graph(Self, X, L, LC, XC, CallAt) end, 
-    {EE, ECallAt} = 
+    Fun = fun() -> inter_graph(Self, X, L, LC, XC, CallAt) end,
+    {EE, ECallAt} =
 	xref_utils:subprocess(Fun, [link, {min_heap_size,100000}]),
 
     [DefAt2,L2,X2,LCallAt2,XCallAt2,CallAt2,LC2,XC2,EE2,ECallAt2,
@@ -977,13 +977,13 @@ extra_edges(CAX, CAL, Bad0, F) ->
     ALC = restriction(2, restriction(ALC0, F), F),
     LPreCAt2 = restriction(CAL, ALC),
     XPreCAt2 = restriction(CAX, AXC),
-    Bad = Bad0 ++ to_external(difference(AXC0, AXC)) 
+    Bad = Bad0 ++ to_external(difference(AXC0, AXC))
 	       ++ to_external(difference(ALC0, ALC)),
     {AXC, ALC, Bad, LPreCAt2, XPreCAt2}.
 
 no_info(X, L, LC, XC, EE, Unres, NoCalls, NoUnresCalls) ->
     NoUnres = no_elements(Unres),
-    [{no_calls, {NoCalls-NoUnresCalls, NoUnresCalls}}, 
+    [{no_calls, {NoCalls-NoUnresCalls, NoUnresCalls}},
      {no_function_calls, {no_elements(LC), no_elements(XC)-NoUnres, NoUnres}},
      {no_functions, {no_elements(L), no_elements(X)}},
      %% Note: this is overwritten in do_set_up():
@@ -1011,10 +1011,10 @@ inter_graph(X, L, LC, XC, CallAt) ->
     Es = union(LEs, XEs),
 
     E1 = to_external(restriction(difference(LC, LEs), XL)),
-    R0 = xref_utils:xset(reachable(E1, G, []), 
+    R0 = xref_utils:xset(reachable(E1, G, []),
 			 [{tspec(func), tspec(fun_edge)}]),
     true = digraph:delete(G),
-    
+
     % RL is a set of indirect local calls to exports.
     RL = restriction(R0, XL),
     % RX is a set of indirect external calls to exports.
@@ -1033,7 +1033,7 @@ inter_graph(X, L, LC, XC, CallAt) ->
 
     ?FORMAT("XL=~p~nXEs=~p~nLEs=~p~nE1=~p~nR0=~p~nRL=~p~nRX=~p~nR=~p~n"
 	    "EE=~p~nECallAt1=~p~nECallAt2=~p~nECallAt=~p~n~n",
-	    [XL, XEs, LEs, E1, R0, RL, RX, R, EE, 
+	    [XL, XEs, LEs, E1, R0, RL, RX, R, EE,
 	     ECallAt1, ECallAt2, ECallAt]),
     {EE, ECallAt}.
 
@@ -1121,7 +1121,7 @@ remove_erase([], D) ->
 
 do_add_libraries(Path, Verbose, State) ->
     message(Verbose, lib_search, []),
-    {C, E} = xref_utils:list_path(Path, [?Suffix]),    
+    {C, E} = xref_utils:list_path(Path, [?Suffix]),
     message(Verbose, done, []),
     MDs = to_external(relation_to_family(relation(C))),
     %% message(Verbose, lib_check, []),
@@ -1160,23 +1160,23 @@ do_set_up(S, VerboseOpt) ->
     Reply.
 
 %% If data has been supplied using add_module/9 (and that is the only
-%% sanctioned way), then DefAt, L, X, LCallAt, XCallAt, CallAt, XC, LC, 
-%% and LU are  guaranteed to be functions (with all supplied 
-%% modules as domain (disregarding unknown modules, that is, modules 
+%% sanctioned way), then DefAt, L, X, LCallAt, XCallAt, CallAt, XC, LC,
+%% and LU are  guaranteed to be functions (with all supplied
+%% modules as domain (disregarding unknown modules, that is, modules
 %% not supplied but hosting unknown functions)).
 %% As a consequence, V and E are also functions. V is defined for unknown
 %% modules also.
 %% UU is also a function (thanks to sofs:family_difference/2...).
-%% XU on the other hand can be a partial function (that is, not defined 
+%% XU on the other hand can be a partial function (that is, not defined
 %% for all modules). U is derived from XU, so U is also partial.
 %% The inverse variables - LC_1, XC_1, E_1 and EE_1 - are all partial.
 %% B is also partial.
 do_set_up(S) when S#xref.mode =:= functions ->
     ModDictList = dict:to_list(S#xref.modules),
-    [DefAt0, L, X0, LCallAt, XCallAt, CallAt, LC, XC, LU, 
+    [DefAt0, L, X0, LCallAt, XCallAt, CallAt, LC, XC, LU,
      EE0, ECallAt, UC, LPredefined,
      Mod_DF,Mod_DF_1,Mod_DF_2,Mod_DF_3] = make_families(ModDictList, 18),
-    
+
     {XC_1, XU, XPredefined} = do_set_up_1(XC),
     LC_1 = user_family(union_of_family(LC)),
     E_1 = family_union(XC_1, LC_1),
@@ -1206,7 +1206,7 @@ do_set_up(S) when S#xref.mode =:= functions ->
 
     AM = domain(F1),
     %% Undef is the union of U0 and Lib:
-    {Undef, U0, Lib, Lib_DF, Lib_DF_1, Lib_DF_2, Lib_DF_3} = 
+    {Undef, U0, Lib, Lib_DF, Lib_DF_1, Lib_DF_2, Lib_DF_3} =
 	make_libs(XU, F1, AM, S#xref.library_path, S#xref.libraries),
     {B, U} = make_builtins(U0),
     X1_B = family_union(X1, B),
@@ -1228,22 +1228,22 @@ do_set_up(S) when S#xref.mode =:= functions ->
     %% way to discard calls to local functions in other modules.
     EE_conv = converse(union_of_family(EE0)),
     EE_exported = restriction(EE_conv, union_of_family(X)),
-    EE_local = 
+    EE_local =
       specification({external, fun({{M1,_,_},{M2,_,_}}) -> M1 =:= M2 end},
                     EE_conv),
     EE_0 = converse(union(EE_local, EE_exported)),
     EE_1 = user_family(EE_0),
-    EE1 = partition_family({external, fun({{M1,_,_}, _MFA2}) -> M1 end}, 
+    EE1 = partition_family({external, fun({{M1,_,_}, _MFA2}) -> M1 end},
                            EE_0),
     %% Make sure EE is defined for all modules:
     EE = family_union(family_difference(EE0, EE0), EE1),
-    IFun = 
-       fun({Mod,EE_M}, XMods) -> 
-               IMFun = 
+    IFun =
+       fun({Mod,EE_M}, XMods) ->
+               IMFun =
                  fun(XrefMod) ->
-                         [NoCalls, NoFunctionCalls, 
+                         [NoCalls, NoFunctionCalls,
                           NoFunctions,  _NoInter] = XrefMod#xref_mod.info,
-                         NewInfo = [NoCalls, NoFunctionCalls, NoFunctions, 
+                         NewInfo = [NoCalls, NoFunctionCalls, NoFunctions,
                                     {no_inter_function_calls,length(EE_M)}],
                          XrefMod#xref_mod{info = NewInfo}
                  end,
@@ -1274,11 +1274,11 @@ do_set_up(S) when S#xref.mode =:= functions ->
     finish_set_up(S1, Vs);
 do_set_up(S) when S#xref.mode =:= modules ->
     ModDictList = dict:to_list(S#xref.modules),
-    [X0, I0, Mod_DF, Mod_DF_1, Mod_DF_2, Mod_DF_3] = 
+    [X0, I0, Mod_DF, Mod_DF_1, Mod_DF_2, Mod_DF_3] =
         make_families(ModDictList, 7),
     I = union_of_family(I0),
     AM = domain(X0),
-    
+
     {XU, Predefined} = make_predefined(I, AM),
     %% Add "hidden" functions to the exports.
     X1 = family_union(X0, Predefined),
@@ -1288,8 +1288,8 @@ do_set_up(S) when S#xref.mode =:= modules ->
     M2A = make_M2A(ModDictList),
     {A2R,A} = make_A2R(S#xref.applications),
     R = set(dict:fetch_keys(S#xref.releases)),
-    
-    ME = projection({external, fun({M1,{M2,_F2,_A2}}) -> {M1,M2} end}, 
+
+    ME = projection({external, fun({M1,{M2,_F2,_A2}}) -> {M1,M2} end},
 		    family_to_relation(I0)),
     ME2AE = multiple_relative_product({M2A, M2A}, ME),
 
@@ -1298,7 +1298,7 @@ do_set_up(S) when S#xref.mode =:= modules ->
     RE = range(AE2RE),
 
     %% Undef is the union of U0 and Lib:
-    {_Undef, U0, Lib, Lib_DF, Lib_DF_1, Lib_DF_2, Lib_DF_3} = 
+    {_Undef, U0, Lib, Lib_DF, Lib_DF_1, Lib_DF_2, Lib_DF_3} =
 	make_libs(XU, X1, AM, S#xref.library_path, S#xref.libraries),
     {B, U} = make_builtins(U0),
     X1_B = family_union(X1, B),
@@ -1312,7 +1312,7 @@ do_set_up(S) when S#xref.mode =:= modules ->
     X = family_union(X1, Lib),
 
     Empty = empty_set(),
-    Vs = [{'X',X},{'U',U},{'B',B},{'XU',XU},{v,V}, 
+    Vs = [{'X',X},{'U',U},{'B',B},{'XU',XU},{v,V},
 	  {e,{Empty,Empty}},
 	  {'M',M},{'A',A},{'R',R},
 	  {'AM',AM},{'UM',UM},{'LM',LM},
@@ -1328,10 +1328,10 @@ finish_set_up(S, Vs) ->
     S1 = S#xref{variables = T},
     %% io:format("~p <= state <= ~p~n", [pack:lsize(S), pack:usize(S)]),
     {ok, S1}.
-    
+
 do_finish_set_up([{Key, Value} | Vs], T) ->
     {Type, OType} = var_type(Key),
-    Val = #xref_var{name = Key, value = Value, vtype = predef, 
+    Val = #xref_var{name = Key, value = Value, vtype = predef,
 		    otype = OType, type = Type},
     T1 = dict:store(Key, Val, T),
     do_finish_set_up(Vs, T1);
@@ -1362,15 +1362,15 @@ var_type('EE')   -> {function, edge};
 var_type('LC')   -> {function, edge};
 var_type('UC')   -> {function, edge};
 var_type('XC')   -> {function, edge};
-var_type('AE')   -> {application, edge};    
-var_type('ME')   -> {module, edge};    
+var_type('AE')   -> {application, edge};
+var_type('ME')   -> {module, edge};
 var_type('RE')   -> {release, edge};
 var_type(_)      -> {foo, bar}.
 
 make_families(ModDictList, N) ->
     Fun1 = fun({_,XMod}) -> XMod#xref_mod.data end,
     Ss = from_sets(map(Fun1, ModDictList)),
-    %% io:format("~n~p <= module data <= ~p~n", 
+    %% io:format("~n~p <= module data <= ~p~n",
     %%           [pack:lsize(Ss), pack:usize(Ss)]),
     make_fams(N, Ss, []).
 
@@ -1389,7 +1389,7 @@ make_M2A(ModDictList) ->
 make_A2R(ApplDict) ->
     AppDict = dict:to_list(ApplDict),
     Fun = fun({A,XApp}) -> {A, XApp#xref_app.rel_name} end,
-    Appl0 = family(map(Fun, AppDict)), 
+    Appl0 = family(map(Fun, AppDict)),
     AllApps = domain(Appl0),
     Appl = family_to_relation(Appl0),
     {Appl, AllApps}.
@@ -1445,13 +1445,13 @@ make_libs(XU, F, AM, LibPath, LibDict) ->
 	     false ->
 		 Libraries = dict:to_list(LibDict),
 		 Lb = restriction(a_function(Libraries), UM),
-		 MFun = fun({M,XLib}) -> 
+		 MFun = fun({M,XLib}) ->
 				#xref_lib{dir = Dir} = XLib,
 				xref_utils:module_filename(Dir, M)
 			end,
 		 map(MFun, to_external(Lb))
 	     end,
-    Fun = fun(FileName, Deprs) -> 
+    Fun = fun(FileName, Deprs) ->
 		  case beam_lib:chunks(FileName, [exports, attributes]) of
 		      {ok, {M, [{exports,X}, {attributes,A}]}} ->
 			  Exports = mfa_exports(X, A, M),
@@ -1496,14 +1496,14 @@ user_family(R) ->
     partition_family({external, fun({_MFA1, {M2,_,_}}) -> M2 end}, R).
 
 do_variables(State) ->
-    Fun = fun({Name, #xref_var{vtype = user}}, {P,U}) -> 
+    Fun = fun({Name, #xref_var{vtype = user}}, {P,U}) ->
 		  {P,[Name | U]};
-	     ({Name, #xref_var{vtype = predef}}, A={P,U}) -> 
+	     ({Name, #xref_var{vtype = predef}}, A={P,U}) ->
 		  case atom_to_list(Name) of
 		      [H|_] when H>= $a, H=<$z -> A;
 		      _Else -> {[Name | P], U}
 		  end;
-	     ({{tmp, V}, _}, A) -> 
+	     ({{tmp, V}, _}, A) ->
 		  io:format("Bug in ~p: temporary ~p~n", [?MODULE, V]), A;
 	     (_V, A) -> A
 	  end,
@@ -1565,7 +1565,7 @@ do_info(S, libraries) ->
     map(fun({_L,XLib}) -> lib_info(XLib) end, D);
 do_info(_S, I) ->
     error({no_such_info, I}).
-		      
+
 do_info(S, Type, E) when is_atom(E) ->
     do_info(S, Type, [E]);
 do_info(S, modules, Modules0) when is_list(Modules0) ->
@@ -1598,7 +1598,7 @@ find_info([E | Es], Dict, Error) ->
 	{ok, X} ->
 	    [X | find_info(Es, Dict, Error)]
     end;
-find_info([], _Dict, _Error) ->    
+find_info([], _Dict, _Error) ->
     [].
 
 %% -> {[{AppName, RelName}], [{RelName, XApp}]}
@@ -1618,7 +1618,7 @@ rel_apps(S) ->
 rel_apps_sums(AR, RRA0, S) ->
     AppMods = app_mods(S), % [{AppName, XMod}]
     RRA1 = relation_to_family(relation(RRA0)),
-    RRA = inverse(substitution(1, RRA1)), 
+    RRA = inverse(substitution(1, RRA1)),
     %% RRA is [{RelName,{RelName,[XApp]}}]
     RelMods = relative_product1(relation(AR), relation(AppMods)),
     RelAppsMods = relative_product1(RRA, RelMods),
@@ -1630,7 +1630,7 @@ rel_apps_sums(AR, RRA0, S) ->
 %% -> [{AppName, XMod}]
 app_mods(S) ->
     D = sort(dict:to_list(S#xref.modules)),
-    Fun = fun({_M,XMod}, Acc) -> 
+    Fun = fun({_M,XMod}, Acc) ->
 		  case XMod#xref_mod.app_name of
 		      [] -> Acc;
 		      [AppName] -> [{AppName, XMod} | Acc]
@@ -1639,7 +1639,7 @@ app_mods(S) ->
     foldl(Fun, [], D).
 
 mod_info(XMod) ->
-    #xref_mod{name = M, app_name = AppName, builtins = BuiltIns, 
+    #xref_mod{name = M, app_name = AppName, builtins = BuiltIns,
 	       dir = Dir, info = Info} = XMod,
     App = sup_info(AppName),
     {M, [{application, App}, {builtins, BuiltIns}, {directory, Dir} | Info]}.
@@ -1649,7 +1649,7 @@ app_info({AppName, ModSums}, S) ->
     #xref_app{rel_name = RelName, vsn = Vsn, dir = Dir} = XApp,
     Release = sup_info(RelName),
     {AppName, [{directory,Dir}, {release, Release}, {version,Vsn} | ModSums]}.
-    
+
 rel_info({{RelName, XApps}, ModSums}, S) ->
     NoApps = length(XApps),
     XRel = dict:fetch(RelName, S#xref.releases),
@@ -1678,16 +1678,16 @@ no_sum(S, L) when S#xref.mode =:= modules ->
     [{no_analyzed_modules, length(L)}].
 
 no_sum([XMod | D], C0, UC0, LC0, XC0, UFC0, L0, X0, EV0, NoM) ->
-    [{no_calls, {C,UC}}, 
+    [{no_calls, {C,UC}},
      {no_function_calls, {LC,XC,UFC}},
      {no_functions, {L,X}},
      {no_inter_function_calls, EV}] = XMod#xref_mod.info,
     no_sum(D, C0+C, UC0+UC, LC0+LC, XC0+XC, UFC0+UFC, L0+L, X0+X, EV0+EV, NoM);
 no_sum([], C, UC, LC, XC, UFC, L, X, EV, NoM) ->
     [{no_analyzed_modules, NoM},
-     {no_calls, {C,UC}}, 
+     {no_calls, {C,UC}},
      {no_function_calls, {LC,XC,UFC}},
-     {no_functions, {L,X}}, 
+     {no_functions, {L,X}},
      {no_inter_function_calls, EV}].
 
 %% -> ok | throw(Error)
@@ -1712,20 +1712,20 @@ warnings(Flag, Message, [F | Fs]) ->
 %% pack(term()) -> term()
 %%
 %% The identify function. The returned term does not use more heap
-%% than the given term. Tuples that are equal (=:=/2) are made 
+%% than the given term. Tuples that are equal (=:=/2) are made
 %% "the same".
 %%
 %% The process dictionary is used because it seems to be faster than
 %% anything else right now...
 %%
 %pack(T) -> T;
-pack(T) ->    
+pack(T) ->
     PD = erase(),
     NT = pack1(T),
     %% true = T =:= NT,
     %% io:format("erasing ~p elements...~n", [length(erase())]),
     erase(), % wasting heap (and time)...
-    map(fun({K,V}) -> put(K, V) end, PD),
+    foreach(fun({K,V}) -> put(K, V) end, PD),
     NT.
 
 pack1(C) when not is_tuple(C), not is_list(C) ->
diff --git a/lib/tools/src/xref_compiler.erl b/lib/tools/src/xref_compiler.erl
index 67ac8c617d..c80eb0e669 100644
--- a/lib/tools/src/xref_compiler.erl
+++ b/lib/tools/src/xref_compiler.erl
@@ -1,19 +1,19 @@
 %%
 %% %CopyrightBegin%
-%% 
-%% Copyright Ericsson AB 2000-2009. All Rights Reserved.
-%% 
+%%
+%% Copyright Ericsson AB 2000-2010. All Rights Reserved.
+%%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
 %% compliance with the License. You should have received a copy of the
 %% Erlang Public License along with this software. If not, it can be
 %% retrieved online at http://www.erlang.org/.
-%% 
+%%
 %% Software distributed under the License is distributed on an "AS IS"
 %% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 %% the License for the specific language governing rights and limitations
 %% under the License.
-%% 
+%%
 %% %CopyrightEnd%
 %%
 
@@ -37,15 +37,15 @@
 
 -export([format_error/1]).
 
--import(lists, 
+-import(lists,
 	[concat/1, foldl/3, nthtail/2, reverse/1, sort/1, sublist/2]).
 
 -import(sofs,
 	[composite/2, difference/2, empty_set/0, from_term/1,
 	 intersection/2, is_empty_set/1, multiple_relative_product/2,
 	 projection/2, relation/1, relation_to_family/1,
-	 restriction/2, substitution/2, to_external/1, union/2,
-	 union_of_family/1]).
+	 restriction/2, specification/2, substitution/2,
+	 to_external/1, union/2, union_of_family/1]).
 
 %%
 %%  Exported functions
@@ -75,7 +75,7 @@ compile(Chars, Table) ->
 	{error, Info, Line} ->
 	    error({parse_error, Line, Info})
     end.
-    
+
 format_error({error, Module, Error}) ->
     Module:format_error(Error);
 format_error({parse_error, Line, Error}) ->
@@ -115,7 +115,7 @@ statements([Stmt={assign, VarType, Name, E} | Stmts0], Table, L, UV) ->
 	    throw_error({variable_reassigned, xref_parser:t2s(Stmt)});
 	error ->
 	    {Type, OType, NewE} = t_expr(E, Table),
-	    Val = #xref_var{name = Name, vtype = VarType, 
+	    Val = #xref_var{name = Name, vtype = VarType,
 			    otype = OType, type = Type},
 	    NewTable = dict:store(Name, Val, Table),
 	    Stmts = if Stmts0 =:= [] -> [{variable, Name}]; true -> Stmts0 end,
@@ -128,9 +128,9 @@ statements([Expr], Table, L, UV) ->
     E1 = un_familiarize(Type, OType, NewE),
     NE = case {Type, OType} of
 	     %% Edges with empty sets of line numbers are removed.
-	     {{line, _}, edge} -> 
+	     {{line, _}, edge} ->
 		 {relation_to_family, E1};
-	     {_Type, edge_closure} -> 
+	     {_Type, edge_closure} ->
 		 %% Fake a closure usage, just to make sure it is destroyed.
 		 E2 = {fun graph_access/2, E1, E1},
                  {fun(_E) -> 'closure()' end, E2};
@@ -163,7 +163,7 @@ t_expr(E, Table) ->
 %%% Constant = atom() | {atom(), atom()} | MFA | {MFA, MFA}
 %%% Call = atom() % function in the sofs module
 %%%      | fun()
-%%% Type = {line, LineType} | function | module | application | release 
+%%% Type = {line, LineType} | function | module | application | release
 %%%      | number
 %%% LineType = line | local_call | external_call | export_call | all_line_call
 %%% VarType = predef | user | tmp
@@ -182,7 +182,7 @@ check_expr({variable, Name}, Table) ->
     case dict:find(Name, Table) of
 	{ok, #xref_var{vtype = VarType, otype = OType, type = Type}} ->
 	    V0 = {variable, {VarType, Name}},
-	    V = case {VarType, Type, OType} of 
+	    V = case {VarType, Type, OType} of
 		    {predef, release, _} -> V0;
 		    {predef, application, _} -> V0;
 		    {predef, module, _} -> V0;
@@ -212,7 +212,7 @@ check_expr(Expr={set, SOp, E}, Table) ->
 		{edge_set, domain} -> vertex_set;
 		{edge_set, weak} -> edge_set;
 		{edge_set, strict} -> edge_set;
-		_ -> 
+		_ ->
 		    throw_error({type_error, xref_parser:t2s(Expr)})
 	    end,
     Op = set_op(SOp),
@@ -223,10 +223,10 @@ check_expr(Expr={graph, Op, E}, Table) ->
     case Type of
 	{line, _LineType} ->
 	    throw_error({type_error, xref_parser:t2s(Expr)});
-	_Else -> 
+	_Else ->
 	    ok
     end,
-    OType = 
+    OType =
 	case {NOType, Op} of
 	    {edge, components} -> vertex_set;
 	    {edge, condensation} -> edge_set;
@@ -237,7 +237,7 @@ check_expr(Expr={graph, Op, E}, Table) ->
 	    %% Neither need nor want these ones:
 	    %% {edge_set, closure} -> edge_set_closure;
 	    %% {edge_set, components} -> vertex_set_set;
-	    _ -> 
+	    _ ->
 		throw_error({type_error, xref_parser:t2s(Expr)})
 	end,
     E2 = {convert, NOType, edge_closure, E1},
@@ -271,10 +271,10 @@ check_expr(Expr={set, SOp, E1, E2}, Table) ->
 	number ->
 	    {expr, number, number, {call, ari_op(SOp), NE1, NE2}};
 	_Else -> % set
-	    {Type, NewE1, NewE2} = 
+	    {Type, NewE1, NewE2} =
 		case {type_ord(Type1), type_ord(Type2)} of
 		    {T1, T2} when T1 =:= T2 ->
-			%% Example: if Type1 = {line, line} and 
+			%% Example: if Type1 = {line, line} and
 			%% Type2 = {line, export_line}, then this is not
 			%% correct, but works:
 			{Type1, NE1, NE2};
@@ -296,7 +296,7 @@ check_expr(Expr={restr, ROp, E1, E2}, Table) ->
 	    throw_error({type_error, xref_parser:t2s(Expr)});
 	{_Type1, {line, _LineType2}} ->
 	    throw_error({type_error, xref_parser:t2s(Expr)});
-	_ -> 
+	_ ->
 	    ok
     end,
     case {OType1, OType2} of
@@ -307,14 +307,14 @@ check_expr(Expr={restr, ROp, E1, E2}, Table) ->
 	{edge, vertex} ->
 	    restriction(ROp, E1, Type1, NE1, Type2, NE2);
 	{edge_closure, vertex} when ROp =:= '|||' ->
-	    {expr, _, _, R1} = 
+	    {expr, _, _, R1} =
 		closure_restriction('|', Type1, Type2, OType2, NE1, NE2),
-	    {expr, _, _, R2} = 
+	    {expr, _, _, R2} =
 		closure_restriction('||', Type1, Type2, OType2, NE1, NE2),
 	    {expr, Type1, edge, {call, intersection, R1, R2}};
-	{edge_closure, vertex} -> 
+	{edge_closure, vertex} ->
 	    closure_restriction(ROp, Type1, Type2, OType2, NE1, NE2);
-	_ -> 
+	_ ->
 	    throw_error({type_error, xref_parser:t2s(Expr)})
     end;
 check_expr(Expr={path, E1, E2}, Table) ->
@@ -330,7 +330,7 @@ check_expr(Expr={path, E1, E2}, Table) ->
     end,
     E2b = {convert, OType2, Type2, Type1, E2a},
     {OType1, NE1} = path_arg(OType1a, E1a),
-    NE2 = case {OType1, OType2} of 
+    NE2 = case {OType1, OType2} of
 	      {path, edge} -> {convert, OType2, edge_closure, E2b};
 	      {path, edge_closure} when Type1 =:= Type2 -> E2b;
 	      _ -> throw_error({type_error, xref_parser:t2s(Expr)})
@@ -347,7 +347,7 @@ check_expr({regexpr, RExpr, Type0}, _Table) ->
 	    release -> 'R'
 	end,
     Var = {variable, {predef, V}},
-    Call = {call, fun(E, V2) -> xref_utils:regexpr(E, V2) end, 
+    Call = {call, fun(E, V2) -> xref_utils:regexpr(E, V2) end,
 	    {constants, RExpr}, Var},
     {expr, Type, vertex, Call};
 check_expr(C={constant, _Type, _OType, _C}, Table) ->
@@ -368,15 +368,15 @@ check_conversion(OType, Type1, Type2, Expr) ->
     end.
 
 %% Allowed conversions.
-conversions(_OType, {line, LineType}, {line, LineType}) -> ok; 
+conversions(_OType, {line, LineType}, {line, LineType}) -> ok;
 conversions(edge, {line, _}, {line, all_line_call}) -> ok;
-conversions(edge, From, {line, Line}) 
+conversions(edge, From, {line, Line})
                  when is_atom(From), Line =/= all_line_call -> ok;
 conversions(vertex, From, {line, line}) when is_atom(From) -> ok;
 conversions(vertex, From, To) when is_atom(From), is_atom(To) -> ok;
 conversions(edge, From, To) when is_atom(From), is_atom(To) -> ok;
 %% "Extra":
-conversions(edge, {line, Line}, To) 
+conversions(edge, {line, Line}, To)
                  when is_atom(To), Line =/= all_line_call -> ok;
 conversions(vertex, {line, line}, To) when is_atom(To) -> ok;
 conversions(_OType, _From, _To) -> not_ok.
@@ -399,7 +399,7 @@ ari_op(difference) -> fun(X, Y) -> X - Y end.
 
 restriction(ROp, E1, Type1, NE1, Type2, NE2) ->
     {Column, _} = restr_op(ROp),
-    case NE1 of 
+    case NE1 of
 	{call, union_of_family, _E} when ROp =:= '|' ->
 	    restriction(Column, Type1, E1, Type2, NE2);
 	{call, union_of_family, _E} when ROp =:= '||' ->
@@ -455,8 +455,8 @@ check_constants(Cs=[C={constant, Type0, OType, _Con} | Cs1], Table) ->
 	    E = function_vertices_to_family(Type, OType, {constants, S}),
 	    {expr, Type, OType, E};
 	[{Type1, [C1|_]}, {Type2, [C2|_]} | _] ->
-	    throw_error({type_mismatch, 
-			 make_vertex(Type1, C1), 
+	    throw_error({type_mismatch,
+			 make_vertex(Type1, C1),
 			 make_vertex(Type2, C2)})
     end.
 
@@ -467,7 +467,7 @@ check_mix([C={constant, Type, OType, _Con} | Cs], Type0, OType, _C0)
     check_mix(Cs, Type, OType, C);
 check_mix([C | _], _Type0, _OType0, C0) ->
     throw_error({type_mismatch, xref_parser:t2s(C0), xref_parser:t2s(C)});
-check_mix([], _Type0, _OType0, _C0) -> 
+check_mix([], _Type0, _OType0, _C0) ->
     ok.
 
 split(Types, Cs, Table) ->
@@ -478,11 +478,11 @@ split([Type | Types], Vs, AllSoFar, _Type, Table, L) ->
     S0 = known_vertices(Type, Vs, Table),
     S = difference(S0, AllSoFar),
     case is_empty_set(S) of
-	true -> 
+	true ->
 	    split(Types, Vs, AllSoFar, Type, Table, L);
-	false -> 
+	false ->
 	    All = union(AllSoFar, S0),
-	    split(Types, Vs, All, Type, Table, 
+	    split(Types, Vs, All, Type, Table,
 		  [{Type, to_external(S)} | L])
     end;
 split([], Vs, All, Type, _Table, L) ->
@@ -491,7 +491,7 @@ split([], Vs, All, Type, _Table, L) ->
 	[C|_] -> throw_error({unknown_constant, make_vertex(Type, C)})
     end.
 
-make_vertex(Type, C) -> 
+make_vertex(Type, C) ->
     xref_parser:t2s({constant, Type, vertex, C}).
 
 constant_vertices([{constant, _Type, edge, {A,B}} | Cs], L) ->
@@ -504,7 +504,7 @@ constant_vertices([], L) ->
 known_vertices('Fun', Cs, T) ->
     M = projection(1, Cs),
     F = union_of_family(restriction(fetch_value(v, T), M)),
-    intersection(Cs, F);
+    union(bifs(Cs), intersection(Cs, F));
 known_vertices('Mod', Cs, T) ->
     intersection(Cs, fetch_value('M', T));
 known_vertices('App', Cs, T) ->
@@ -512,6 +512,11 @@ known_vertices('App', Cs, T) ->
 known_vertices('Rel', Cs, T) ->
     intersection(Cs, fetch_value('R', T)).
 
+bifs(Cs) ->
+    specification({external,
+                   fun({M,F,A}) -> xref_utils:is_builtin(M, F, A) end},
+                  Cs).
+
 function_vertices_to_family(function, vertex, E) ->
     {call, partition_family, 1, E};
 function_vertices_to_family(_Type, _OType, E) ->
@@ -567,11 +572,11 @@ convert(E, OType, FromType, ToType) ->
 
 general(_ObjectType, FromType, ToType, X) when FromType =:= ToType ->
     X;
-general(edge, {line, _LineType}, ToType, LEs) -> 
+general(edge, {line, _LineType}, ToType, LEs) ->
     VEs = {projection, ?Q({external, fun({V1V2,_Ls}) -> V1V2 end}), LEs},
     general(edge, function, ToType, VEs);
 general(edge, function, ToType, VEs) ->
-    MEs = {projection, 
+    MEs = {projection,
 	   ?Q({external, fun({{M1,_,_},{M2,_,_}}) -> {M1,M2} end}),
 	   VEs},
     general(edge, module, ToType, MEs);
@@ -580,7 +585,7 @@ general(edge, module, ToType, MEs) ->
     general(edge, application, ToType, AEs);
 general(edge, application, release, AEs) ->
     {image, {get, ae}, AEs};
-general(vertex, {line, _LineType}, ToType, L) -> 
+general(vertex, {line, _LineType}, ToType, L) ->
     V = {partition_family, ?Q(1), {domain, L}},
     general(vertex, function, ToType, V);
 general(vertex, function, ToType, V) ->
@@ -595,18 +600,18 @@ general(vertex, application, release, A) ->
 special(_ObjectType, FromType, ToType, X) when FromType =:= ToType ->
     X;
 special(edge, {line, _LineType}, {line, all_line_call}, Calls) ->
-   {put, ?T(mods), 
-       {projection, 
-	?Q({external, fun({{{M1,_,_},{M2,_,_}},_}) -> {M1,M2} end}), 
+   {put, ?T(mods),
+       {projection,
+	?Q({external, fun({{{M1,_,_},{M2,_,_}},_}) -> {M1,M2} end}),
 	Calls},
-       {put, ?T(def_at), 
+       {put, ?T(def_at),
            {union, {image, {get, def_at},
-                           {union, {domain, {get, ?T(mods)}}, 
+                           {union, {domain, {get, ?T(mods)}},
                                    {range, {get, ?T(mods)}}}}},
            {fun funs_to_lines/2,
 	           {get, ?T(def_at)}, Calls}}};
 special(edge, function, {line, LineType}, VEs) ->
-    Var = if 
+    Var = if
 	      LineType =:= line -> call_at;
 	      LineType =:= export_call -> e_call_at;
 	      LineType =:= local_call -> l_call_at;
@@ -615,9 +620,9 @@ special(edge, function, {line, LineType}, VEs) ->
     line_edges(VEs, Var);
 special(edge, module, ToType, MEs) ->
     VEs = {image,
-	   {projection, 
+	   {projection,
 	    ?Q({external, fun(FE={{M1,_,_},{M2,_,_}}) -> {{M1,M2},FE} end}),
-	    {union, 
+	    {union,
 	     {image, {get, e},
 	      {projection, ?Q({external, fun({M1,_M2}) -> M1 end}), MEs}}}},
 	   MEs},
@@ -629,7 +634,7 @@ special(edge, release, ToType, REs) ->
     AEs = {inverse_image, {get, ae}, REs},
     special(edge, application, ToType, AEs);
 special(vertex, function, {line, _LineType}, V) ->
-    {restriction, 
+    {restriction,
        {union_of_family, {restriction, {get, def_at}, {domain, V}}},
        {union_of_family, V}};
 special(vertex, module, ToType, M) ->
@@ -643,15 +648,15 @@ special(vertex, release, ToType, R) ->
     special(vertex, application, ToType, A).
 
 line_edges(VEs, CallAt) ->
-    {put, ?T(ves), VEs, 
-        {put, ?T(m1), 
-             {projection, ?Q({external, fun({{M1,_,_},_}) -> M1 end}), 
+    {put, ?T(ves), VEs,
+        {put, ?T(m1),
+             {projection, ?Q({external, fun({{M1,_,_},_}) -> M1 end}),
 	      {get, ?T(ves)}},
 	     {image, {projection, ?Q({external, fun(C={VV,_L}) -> {VV,C} end}),
 		      {union, {image, {get, CallAt}, {get, ?T(m1)}}}},
 		     {get, ?T(ves)}}}}.
 
-%% {(((v1,l1),(v2,l2)),l) : 
+%% {(((v1,l1),(v2,l2)),l) :
 %%       (v1,l1) in DefAt and (v2,l2) in DefAt and ((v1,v2),L) in CallAt}
 funs_to_lines(DefAt, CallAt) ->
     T1 = multiple_relative_product({DefAt, DefAt}, projection(1, CallAt)),
@@ -765,7 +770,7 @@ save_vars([], _D, Vs, UVs, L) ->
 
 %% Traverses the expression again, this time using more or less the
 %% inverse of the table created by find_nodes. The first time a node
-%% is visited, its children are traversed, the following times a 
+%% is visited, its children are traversed, the following times a
 %% get instructions are inserted (using the saved value).
 make_instructions(N, UserVars, D) ->
     {D1, Is0} = make_instrs(N, D, []),
@@ -777,9 +782,9 @@ make_instructions(N, UserVars, D) ->
 
 make_more_instrs([UV | UVs], D, Is) ->
     case dict:find(UV, D) of
-	error -> 
+	error ->
 	    make_more_instrs(UVs, D, Is);
-	_Else -> 
+	_Else ->
 	    {ND, NIs} = make_instrs(UV, D, Is),
 	    make_more_instrs(UVs, ND, [pop | NIs])
     end;
@@ -844,17 +849,17 @@ evaluate([{quote, Val} | P], T, S) ->
     evaluate(P, T, [Val | S]);
 evaluate([{get, Var} | P], T, S) when is_atom(Var) -> % predefined
     Value = fetch_value(Var, T),
-    Val = case Value of 
+    Val = case Value of
 	      {R, _} -> R; % relation
 	      _ -> Value   % simple set
 	  end,
-    evaluate(P, T, [Val | S]);    
+    evaluate(P, T, [Val | S]);
 evaluate([{get, {inverse, Var}} | P], T, S) -> % predefined, inverse
     {_, R} = fetch_value(Var, T),
-    evaluate(P, T, [R | S]);    
+    evaluate(P, T, [R | S]);
 evaluate([{get, {user, Var}} | P], T, S) ->
     Val = fetch_value(Var, T),
-    evaluate(P, T, [Val | S]);    
+    evaluate(P, T, [Val | S]);
 evaluate([{get, Var} | P], T, S) -> % tmp
     evaluate(P, T, [dict:fetch(Var, T) | S]);
 evaluate([{save, Var={tmp, _}} | P], T, S=[Val | _]) ->
@@ -862,7 +867,7 @@ evaluate([{save, Var={tmp, _}} | P], T, S=[Val | _]) ->
     evaluate(P, dict:store(Var, Val, T1), S);
 evaluate([{save, {user, Name}} | P], T, S=[Val | _]) ->
     #xref_var{vtype = user, otype = OType, type = Type} = dict:fetch(Name, T),
-    NewVar = #xref_var{name = Name, value = Val, 
+    NewVar = #xref_var{name = Name, value = Val,
 		       vtype = user, otype = OType, type = Type},
     T1 = update_graph_counter(Val, +1, T),
     NT = dict:store(Name, NewVar, T1),
@@ -889,7 +894,7 @@ update_graph_counter(Value, Inc, T) ->
 		error when Inc =:= 1 ->
 		    dict:store(Value, 1, T)
 	    end;
-	_EXIT -> 
+	_EXIT ->
 	    T
     end.
 
diff --git a/lib/tools/src/xref_reader.erl b/lib/tools/src/xref_reader.erl
index db755c31d8..d22f0df164 100644
--- a/lib/tools/src/xref_reader.erl
+++ b/lib/tools/src/xref_reader.erl
@@ -1,19 +1,19 @@
 %%
 %% %CopyrightBegin%
-%% 
-%% Copyright Ericsson AB 2000-2009. All Rights Reserved.
-%% 
+%%
+%% Copyright Ericsson AB 2000-2010. All Rights Reserved.
+%%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
 %% compliance with the License. You should have received a copy of the
 %% Erlang Public License along with this software. If not, it can be
 %% retrieved online at http://www.erlang.org/.
-%% 
+%%
 %% Software distributed under the License is distributed on an "AS IS"
 %% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 %% the License for the specific language governing rights and limitations
 %% under the License.
-%% 
+%%
 %% %CopyrightEnd%
 %%
 -module(xref_reader).
@@ -22,7 +22,7 @@
 
 -import(lists, [keysearch/3, member/2, reverse/1]).
 
--record(xrefr, 
+-record(xrefr,
 	{module=[],
 	 function=[],
 	 def_at=[],
@@ -59,15 +59,15 @@
 module(Module, Forms, CollectBuiltins, X, DF) ->
     Attrs = [{Attr,V} || {attribute,_Line,Attr,V} <- Forms],
     IsAbstract = xref_utils:is_abstract_module(Attrs),
-    S = #xrefr{module = Module, builtins_too = CollectBuiltins, 
+    S = #xrefr{module = Module, builtins_too = CollectBuiltins,
                is_abstr = IsAbstract, x = X, df = DF},
     forms(Forms, S).
 
 forms([F | Fs], S) ->
     S1 = form(F, S),
     forms(Fs, S1);
-forms([], S) -> 
-    #xrefr{module = M, def_at = DefAt, 
+forms([], S) ->
+    #xrefr{module = M, def_at = DefAt,
 	   l_call_at = LCallAt, x_call_at = XCallAt,
 	   el = LC, ex = XC, x = X, df = Depr,
 	   lattrs = AL, xattrs = AX, battrs = B, unresolved = U} = S,
@@ -75,7 +75,7 @@ forms([], S) ->
     {ok, M, {DefAt, LCallAt, XCallAt, LC, XC, X, Attrs, Depr}, U}.
 
 form({attribute, Line, xref, Calls}, S) -> % experimental
-    #xrefr{module = M, function = Fun, 
+    #xrefr{module = M, function = Fun,
 	   lattrs = L, xattrs = X, battrs = B} = S,
     attr(Calls, Line, M, Fun, L, X, B, S);
 form({attribute, _Line, _Attr, _Val}, S) ->
@@ -110,12 +110,12 @@ clauses([{clause, _Line, _H, G, B} | Cs], FunVars, Matches, S) ->
     S2 = expr(B, S1),
     S3 = S2#xrefr{funvars = FunVars, matches = Matches},
     clauses(Cs, S3);
-clauses([], _FunVars, _Matches, S) -> 
+clauses([], _FunVars, _Matches, S) ->
     S.
 
 attr([E={From, To} | As], Ln, M, Fun, AL, AX, B, S) ->
     case mfa(From, M) of
-	{_, _, MFA} when MFA =:= Fun; [] =:= Fun -> 
+	{_, _, MFA} when MFA =:= Fun; [] =:= Fun ->
 	    attr(From, To, Ln, M, Fun, AL, AX, B, S, As, E);
 	{_, _, _} ->
 	    attr(As, Ln, M, Fun, AL, AX, [E | B], S);
@@ -164,7 +164,7 @@ expr({call, Line,
     %% Added in R10B-6. M:F/A.
     expr({'fun', Line, {function, Mod, Fun, Arity}}, S);
 expr({'fun', Line, {function, Mod, Name, Arity}}, S) ->
-    %% Added in R10B-6. M:F/A. 
+    %% Added in R10B-6. M:F/A.
     As = lists:duplicate(Arity, {atom, Line, foo}),
     external_call(Mod, Name, As, Line, false, S);
 expr({'fun', Line, {function, Name, Arity}, _Extra}, S) ->
@@ -183,7 +183,7 @@ expr({call, Line, {remote, _Line, Mod, Name}, As}, S) ->
 expr({call, Line, F, As}, S) ->
     external_call(erlang, apply, [F, list2term(As)], Line, true, S);
 expr({match, _Line, {var,_,Var}, {'fun', _, {clauses, Cs}, _Extra}}, S) ->
-    %% This is what is needed in R7 to avoid warnings for the functions 
+    %% This is what is needed in R7 to avoid warnings for the functions
     %% that are passed around by the "expansion" of list comprehension.
     S1 = S#xrefr{funvars = [Var | S#xrefr.funvars]},
     clauses(Cs, S1);
@@ -192,6 +192,14 @@ expr({match, _Line, {var,_,Var}, E}, S) ->
     %%     Args = [A,B], apply(m, f, Args)
     S1 = S#xrefr{matches = [{Var, E} | S#xrefr.matches]},
     expr(E, S1);
+expr({op, _Line, 'orelse', Op1, Op2}, S) ->
+    expr([Op1, Op2], S);
+expr({op, _Line, 'andalso', Op1, Op2}, S) ->
+    expr([Op1, Op2], S);
+expr({op, Line, Op, Operand1, Operand2}, S) ->
+    external_call(erlang, Op, [Operand1, Operand2], Line, false, S);
+expr({op, Line, Op, Operand}, S) ->
+    external_call(erlang, Op, [Operand], Line, false, S);
 expr(T, S) when is_tuple(T) ->
     expr(tuple_to_list(T), S);
 expr([E | Es], S) ->
@@ -241,13 +249,13 @@ external_call(Mod, Fun, ArgsList, Line, X, S) ->
 	_Else -> % apply2, 1 or 2
 	    check_funarg(W, ArgsList, Line, S1)
     end.
-	    
+
 eval_args(Mod, Fun, ArgsTerm, Line, S, ArgsList, Extra) ->
     {IsSimpleCall, M, F} = mod_fun(Mod, Fun),
     case term2list(ArgsTerm, [], S) of
 	undefined ->
 	    S1 = unresolved(M, F, -1, Line, S),
-	    expr(ArgsList, S1);	    
+	    expr(ArgsList, S1);
 	ArgsList2 when not IsSimpleCall ->
 	    S1 = unresolved(M, F, length(ArgsList2), Line, S),
 	    expr(ArgsList, S1);
@@ -288,14 +296,14 @@ fun_args(apply2, [FunArg, Args]) -> {FunArg, Args};
 fun_args(1, [FunArg | Args]) -> {FunArg, Args};
 fun_args(2, [_Node, FunArg | Args]) -> {FunArg, Args}.
 
-list2term([A | As]) -> 
+list2term([A | As]) ->
     {cons, 0, A, list2term(As)};
-list2term([]) -> 
+list2term([]) ->
     {nil, 0}.
 
 term2list({cons, _Line, H, T}, L, S) ->
     term2list(T, [H | L], S);
-term2list({nil, _Line}, L, _S) -> 
+term2list({nil, _Line}, L, _S) ->
     reverse(L);
 term2list({var, _, Var}, L, S) ->
     case keysearch(Var, 1, S#xrefr.matches) of
@@ -332,11 +340,11 @@ handle_call(Locality, To0, Line, S, IsUnres) ->
              true ->
                  S
          end,
-    case Locality of 
-        local -> 
+    case Locality of
+        local ->
             S1#xrefr{el = [Call | S1#xrefr.el],
                      l_call_at = [CallAt | S1#xrefr.l_call_at]};
-        external -> 
+        external ->
             S1#xrefr{ex = [Call | S1#xrefr.ex],
                      x_call_at = [CallAt | S1#xrefr.x_call_at]}
     end.