The R13B03 release.OTP_R13B03

1 files changed, 3023 insertions, 0 deletions

diff --git a/lib/syntax_tools/src/igor.erl b/lib/syntax_tools/src/igor.erl
new file mode 100644
index 0000000000..9e7b784170
--- /dev/null
+++ b/lib/syntax_tools/src/igor.erl
@@ -0,0 +1,3023 @@
+%% =====================================================================
+%% This library is free software; you can redistribute it and/or modify
+%% it under the terms of the GNU Lesser General Public License as
+%% published by the Free Software Foundation; either version 2 of the
+%% License, or (at your option) any later version.
+%%
+%% This library is distributed in the hope that it will be useful, but
+%% WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+%% Lesser General Public License for more details.
+%%
+%% You should have received a copy of the GNU Lesser General Public
+%% License along with this library; if not, write to the Free Software
+%% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+%% USA
+%%
+%% $Id$
+%%
+%% @copyright 1998-2006 Richard Carlsson
+%% @author Richard Carlsson <[email protected]>
+%% @end
+%% =====================================================================
+
+%% @doc Igor: the Module Merger and Renamer.
+%%
+%% The program Igor merges the source code of one or more Erlang
+%% modules into a single module, which can then replace the original set
+%% of modules. Igor is also able to rename a set of (possibly
+%% interdependent) modules, without joining them into a single
+%% module.
+%%
+%% The main user interface consists of the functions {@link merge/3} and
+%% {@link rename/3}. See also the function {@link parse_transform/2}.
+%%
+%% A note of warning: Igor cannot do anything about the case when the
+%% name of a remote function is passed to the built-in functions
+%% `apply' and `spawn' <em>unless</em> the module
+%% and function names are explicitly stated in the call, as in e.g.
+%% `apply(lists, reverse, [Xs])'. In all other cases, Igor
+%% leaves such calls unchanged, and warns the user that manual editing
+%% might be necessary.
+%%
+%% Also note that Erlang records will be renamed as necessary to
+%% avoid non-equivalent definitions using the same record name. This
+%% does not work if the source code accesses the name field of such
+%% record tuples by `element/2' or similar methods. Always
+%% use the record syntax to handle record tuples, if possible.
+%%
+%% Disclaimer: the author of this program takes no responsibility for
+%% the correctness of the produced output, or for any effects of its
+%% execution. In particular, the author may not be held responsible
+%% should Igor include the code of a deceased madman in the result.
+%%
+%% For further information on Igors in general, see e.g. "Young
+%% Frankenstein", Mel Brooks, 1974, and "The Fifth Elephant", Terry
+%% Pratchett, 1999.
+%% @end
+%% =====================================================================
+
+
+%% This program is named after the character Igor, assistant to Dr.
+%% Frankenstein, in the 1939 film "Son of Frankenstein" (with Boris
+%% Karloff playing The Monster for the last time; Igor was played by
+%% Bela Lugosi). Igor's job (in the film) was mainly to bring reasonably
+%% fresh parts of various human corpses to the good Doctor, for his
+%% purpose of reanimating them in the shape of a new formidable, living
+%% creature.
+%%
+%% Merging code is done by joining the sources, possibly changing the
+%% order of declarations as necessary, renaming functions and records to
+%% avoid name clashes, and changing remote calls to local calls where
+%% possible. Stub modules may be automatically generated to redirect any
+%% calls that still use the old names. Indirectly, code merging can be
+%% used to simply rename a set of modules.
+%%
+%% What Igor does not do is to optimise the resulting code, which
+%% typically can benefit from techniques such as inlining, constant
+%% folding, specialisation, etc. This task is left to the Doctor.
+%% (Luckily, Igor can call on Inga to do some cleanup; cf. 'erl_tidy'.)
+
+%% TODO: FIXME: don't remove module qualifier if name is (auto-)imported!
+%% TODO: handle merging of parameterized modules (somehow).
+%% TODO: check for redefinition of macros; check equivalence; comment out.
+%% TODO: {export, [E]}, E = atom() | {atom(), atom(), integer()}.
+%% TODO: improve documentation. 
+%% TODO: optionally rename all functions from specified (or all) modules.
+
+-module(igor).
+
+-export([create_stubs/2, merge/2, merge/3, merge_files/3, merge_files/4,
+	 merge_sources/3, parse_transform/2, rename/2, rename/3]).
+
+-include_lib("kernel/include/file.hrl").
+
+
+%% =====================================================================
+%% Global Constants
+
+-define(NOTE_HEADER, "Note from Igor: ").
+-define(COMMENT_PREFIX, "% ").
+-define(COMMENT_BAR,
+	"======================="
+	"======================="
+	"=======================").
+-define(NOTE_PREFIX, "%! ").
+-define(KILL_PREFIX, "%<<< ").
+-define(DEFAULT_INCLUDES, ["."]).
+-define(DEFAULT_MACROS, []).
+-define(DEFAULT_SUFFIX, ".erl").
+-define(DEFAULT_BACKUP_SUFFIX, ".bak").
+-define(DEFAULT_DIR, "").
+-define(DEFAULT_STUB_DIR, "stubs").
+-define(TIDY_OPTS, [quiet]).
+
+%% This may also be used in patterns. R must not be an integer, i.e.,
+%% the structure must be distinct from function names.
+
+-define(record_name(R), {record, R}).
+
+
+%% Data structure for module information
+
+-record(module, {name,		% = atom()
+		 vars = none,	% = [atom()] | none
+		 functions,	% = ordset({atom(), int()})
+		 exports,	% = ordset({atom(), int()})
+				% | ordset({{atom(), int()},
+				%	    term()})
+		 aliases,	% = ordset({{atom(), int()},
+				%	    {atom(),
+				%	     {atom(), int()}}})
+		 attributes,	% = ordset({atom(), term()})
+		 records	% = [{atom(), [{atom(), term()}]}]
+		}).
+
+%% The default pretty-printing function.
+
+default_printer(Tree, Options) ->
+    erl_prettypr:format(Tree, Options).
+
+
+%% =====================================================================
+%% @spec parse_transform(Forms::[syntaxTree()], Options::[term()]) ->
+%%           [syntaxTree()]
+%%
+%%         syntaxTree() = erl_syntax:syntaxTree()
+%%
+%% @doc Allows Igor to work as a component of the Erlang compiler.
+%% Including the term `{parse_transform, igor}' in the
+%% compile options when compiling an Erlang module (cf.
+%% `compile:file/2'), will call upon Igor to process the
+%% source code, allowing automatic inclusion of other source files. No
+%% files are created or overwritten when this function is used.
+%%
+%% Igor will look for terms `{igor, List}' in the compile
+%% options, where `List' is a list of Igor-specific options,
+%% as follows:
+%% <dl>
+%%  <dt>`{files, [filename()]}'</dt>
+%%    <dd>The value specifies a list of source files to be merged with
+%%    the file being compiled; cf. `merge_files/4'.</dd>
+%% </dl>
+%%
+%% See `merge_files/4' for further options. Note, however,
+%% that some options are preset by this function and cannot be
+%% overridden by the user; in particular, all cosmetic features are
+%% turned off, for efficiency. Preprocessing is turned on.
+%%
+%% @see merge_files/4
+%% @see //compiler/compile:file/2
+
+parse_transform(Forms, Options) ->
+    M = get_module_info(Forms),
+    Name = M#module.name,
+    Opts = proplists:append_values(igor, Options),
+    Files = proplists:append_values(files, Opts),
+    %% We turn off all features that are only cosmetic, and make sure to
+    %% turn on preservation of `file' attributes.
+    Opts1 = [{comments, false},
+	     {notes, no},
+	     {no_imports, true},
+	     {file_attributes, yes},
+	     {preprocess, true},
+	     {export, [Name]}
+	     | Opts],
+    {T, _} = merge_files(Name, [Forms], Files, Opts1),
+    verbose("done.", Opts1),
+    erl_syntax:revert_forms(T).
+
+
+%% =====================================================================
+%% @spec merge(Name::atom(), Files::[filename()]) -> [filename()]
+%% @equiv merge(Name, Files, [])
+
+merge(Name, Files) ->
+    merge(Name, Files, []).
+
+%% =====================================================================
+%% @spec merge(Name::atom(), Files::[filename()], Options::[term()]) ->
+%%           [filename()]
+%%
+%%	    filename() = file:filename()
+%%
+%% @doc Merges source code files to a single file. `Name'
+%% specifies the name of the resulting module - not the name of the
+%% output file. `Files' is a list of file names and/or module
+%% names of source modules to be read and merged (see
+%% `merge_files/4' for details). All the input modules must
+%% be distinctly named.
+%%
+%% The resulting source code is written to a file named
+%% "`<em>Name</em>.erl'" in the current directory, unless
+%% otherwise specified by the options `dir' and
+%% `outfile' described below.
+%%
+%% Examples:
+%% <ul>
+%%   <li>given a module `m' in file "`m.erl'"
+%%   which uses the standard library module `lists', calling
+%%   `igor:merge(m, [m, lists])' will create a new file
+%%   "`m.erl' which contains the code from `m' and
+%%   exports the same functions, and which includes the referenced code
+%%   from the `lists' module. The original file will be
+%%   renamed to "`m.erl.bak'".</li>
+%%
+%%   <li>given modules `m1' and `m2', in
+%%   corresponding files, calling `igor:merge(m, [m1, m2])'
+%%   will create a file "`m.erl'" which contains the code
+%%   from `m1' and `m2' and exports the functions
+%%   of `m1'.</li>
+%% </ul>
+%%
+%% Stub module files are created for those modules that are to be
+%% exported by the target module (see options `export',
+%% `stubs' and `stub_dir').
+%%
+%% The function returns the list of file names of all created
+%% modules, including any automatically created stub modules. The file
+%% name of the target module is always first in the list.
+%%
+%% Note: If you get a "syntax error" message when trying to merge
+%% files (and you know those files to be correct), then try the
+%% `preprocess' option. It typically means that your code
+%% contains too strange macros to be handled without actually performing
+%% the preprocessor expansions.
+%% 
+%% Options:
+%% <dl>
+%%   <dt>`{backup_suffix, string()}'</dt>
+%%
+%%     <dd>Specifies the file name suffix to be used when a backup file
+%%     is created; the default value is `".bak"'.</dd>
+%%
+%%   <dt>`{backups, bool()}'</dt>
+%%
+%%     <dd>If the value is `true', existing files will be
+%%     renamed before new files are opened for writing. The new names
+%%     are formed by appending the string given by the
+%%     `backup_suffix' option to the original name. The
+%%     default value is `true'.</dd>
+%%
+%%   <dt>`{dir, filename()}'</dt>
+%%
+%%     <dd>Specifies the name of the directory in which the output file
+%%     is to be written. An empty string is interpreted as the current
+%%     directory. By default, the current directory is used.</dd>
+%%
+%%   <dt>`{outfile, filename()}'</dt>
+%%
+%%     <dd>Specifies the name of the file (without suffix) to which the
+%%     resulting source code is to be written. By default, this is the
+%%     same as the `Name' argument.</dd>
+%%
+%%   <dt>`{preprocess, bool()}'</dt>
+%%
+%%     <dd>If the value is `true', preprocessing will be done
+%%     when reading the source code. See `merge_files/4' for
+%%     details.</dd>
+%%
+%%   <dt>`{printer, Function}'</dt>
+%%     <dd><ul>
+%%       <li>`Function = (syntaxTree()) -> string()'</li>
+%%     </ul>
+%%     Specifies a function for prettyprinting Erlang syntax trees.
+%%     This is used for outputting the resulting module definition, as
+%%     well as for creating stub files. The function is assumed to
+%%     return formatted text for the given syntax tree, and should raise
+%%     an exception if an error occurs. The default formatting function
+%%     calls `erl_prettypr:format/2'.</dd>
+%%
+%%   <dt>`{stub_dir, filename()}'</dt>
+%%
+%%     <dd>Specifies the name of the directory to which any generated
+%%     stub module files are written. The default value is
+%%     `"stubs"'.</dd>
+%%
+%%   <dt>`{stubs, bool()}'</dt>
+%%
+%%     <dd>If the value is `true', stub module files will be
+%%     automatically generated for all exported modules that do not have
+%%     the same name as the target module. The default value is
+%%     `true'.</dd>
+%%
+%%   <dt>`{suffix, string()}'</dt>
+%%
+%%     <dd>Specifies the suffix to be used for the output file names;
+%%     the default value is `".erl"'.</dd>
+%% </dl>
+%%
+%% See `merge_files/4' for further options.
+%%
+%% @see merge/2
+%% @see merge_files/4
+
+%% The defaults for 'merge' are also used for 'create_stubs'.
+
+-define(DEFAULT_MERGE_OPTS,
+	[{backup_suffix, ?DEFAULT_BACKUP_SUFFIX},
+	 backups, 
+	 {dir, ?DEFAULT_DIR},
+	 {printer, fun default_printer/2},
+	 {stub_dir, ?DEFAULT_STUB_DIR},
+	 stubs,
+	 {suffix, ?DEFAULT_SUFFIX},
+	 {verbose, false}]).
+
+merge(Name, Files, Opts) ->
+    Opts1 = Opts ++ ?DEFAULT_MERGE_OPTS,
+    {Tree, Stubs} = merge_files(Name, Files, Opts1),
+    Dir = proplists:get_value(dir, Opts1, ""),
+    Filename = proplists:get_value(outfile, Opts1, Name),
+    File = write_module(Tree, Filename, Dir, Opts1),
+    [File | maybe_create_stubs(Stubs, Opts1)].
+
+
+%% =====================================================================
+%% @spec merge_files(Name::atom(), Files::[filename()],
+%%                   Options::[term()]) ->
+%%           {syntaxTree(), [stubDescriptor()]}
+%% @equiv merge_files(Name, [], Files, Options)
+
+merge_files(Name, Files, Options) ->
+    merge_files(Name, [], Files, Options).
+
+
+%% =====================================================================
+%% @spec merge_files(Name::atom(), Sources::[Forms],
+%%                   Files::[filename()], Options::[term()]) ->
+%%           {syntaxTree(), [stubDescriptor()]}
+%%     Forms = syntaxTree() | [syntaxTree()]
+%%
+%% @doc Merges source code files and syntax trees to a single syntax
+%% tree. This is a file-reading front end to
+%% `merge_sources/3'. `Name' specifies the name of
+%% the resulting module - not the name of the output file.
+%% `Sources' is a list of syntax trees and/or lists of
+%% "source code form" syntax trees, each entry representing a module
+%% definition. `Files' is a list of file names and/or module
+%% names of source modules to be read and included. All the input
+%% modules must be distinctly named.
+%%
+%% If a name in `Files' is not the name of an existing
+%% file, Igor assumes it represents a module name, and tries to locate
+%% and read the corresponding source file. The parsed files are appended
+%% to `Sources' and passed on to
+%% `merge_sources/3', i.e., entries in `Sources'
+%% are listed before entries read from files.
+%%
+%% If no exports are listed by an `export' option (see
+%% `merge_sources/3' for details), then if `Name'
+%% is also the name of one of the input modules, that module will be
+%% exported; otherwise, the first listed module will be exported. Cf.
+%% the examples under `merge/3'.
+%%
+%% The result is a pair `{Tree, Stubs}', where
+%% `Tree' represents the source code that is the result of
+%% merging all the code in `Sources' and `Files',
+%% and `Stubs' is a list of stub module descriptors (see
+%% `merge_sources/3' for details).
+%%
+%% Options:
+%% <dl>
+%%   <dt>`{comments, bool()}'</dt>
+%%
+%%     <dd>If the value is `true', source code comments in
+%%     the original files will be preserved in the output. The default
+%%     value is `true'.</dd>
+%%
+%%   <dt>`{find_src_rules, [{string(), string()}]}'</dt>
+%%
+%%     <dd>Specifies a list of rules for associating object files with
+%%     source files, to be passed to the function
+%%     `filename:find_src/2'. This can be used to change the
+%%     way Igor looks for source files. If this option is not specified,
+%%     the default system rules are used. The first occurrence of this
+%%     option completely overrides any later in the option list.</dd>
+%%
+%%   <dt>`{includes, [filename()]}'</dt>
+%%
+%%     <dd>Specifies a list of directory names for the Erlang
+%%     preprocessor, if used, to search for include files (cf. the
+%%     `preprocess' option). The default value is the empty
+%%     list. The directory of the source file and the current directory
+%%     are automatically appended to the list.</dd>
+%%
+%%   <dt>`{macros, [{atom(), term()}]}'</dt>
+%%
+%%     <dd>Specifies a list of "pre-defined" macro definitions for the
+%%     Erlang preprocessor, if used (cf. the `preprocess'
+%%     option). The default value is the empty list.</dd>
+%%
+%%   <dt>`{preprocess, bool()}'</dt>
+%%
+%%     <dd>If the value is `false', Igor will read source
+%%     files without passing them through the Erlang preprocessor
+%%     (`epp'), in order to avoid expansion of preprocessor
+%%     directives such as `-include(...).',
+%%     `-define(...).' and `-ifdef(...)', and
+%%     macro calls such as `?LINE' and `?MY_MACRO(x,
+%%     y)'. The default value is `false', i.e.,
+%%     preprocessing is not done. (See the module
+%%     `epp_dodger' for details.)
+%%
+%%     Notes: If a file contains too exotic definitions or uses of
+%%     macros, it will not be possible to read it without preprocessing.
+%%     Furthermore, Igor does not currently try to sort out multiple
+%%     inclusions of the same file, or redefinitions of the same macro
+%%     name. Therefore, when preprocessing is turned off, it may become
+%%     necessary to edit the resulting source code, removing such
+%%     re-inclusions and redefinitions.</dd>
+%% </dl>
+%%
+%% See `merge_sources/3' for further options.
+%%
+%% @see merge/3
+%% @see merge_files/3
+%% @see merge_sources/3
+%% @see //stdlib/filename:find_src/2
+%% @see epp_dodger
+
+merge_files(_, _Trees, [], _) ->
+    report_error("no files to merge."),
+    exit(badarg);
+merge_files(Name, Trees, Files, Opts) ->
+    Opts1 = Opts ++ [{includes, ?DEFAULT_INCLUDES},
+		     {macros, ?DEFAULT_MACROS},
+		     {preprocess, false},
+		     comments],
+    Sources = [read_module(F, Opts1) || F <- Files],
+    merge_sources(Name, Trees ++ Sources, Opts1).
+
+
+%% =====================================================================
+%% @spec merge_sources(Name::atom(), Sources::[Forms],
+%%                     Options::[term()]) ->
+%%           {syntaxTree(), [stubDescriptor()]}
+%%
+%%     Forms = syntaxTree() | [syntaxTree()]
+%%
+%% @type stubDescriptor() = [{ModuleName, Functions, [Attribute]}]
+%%	    ModuleName = atom()
+%%	    Functions = [{FunctionName, {ModuleName, FunctionName}}]
+%%	    FunctionName = {atom(), integer()}
+%%	    Attribute = {atom(), term()}.
+%%
+%%      A stub module descriptor contains the module name, a list of
+%%      exported functions, and a list of module attributes. Each
+%%      function is described by its name (which includes its arity),
+%%      and the corresponding module and function that it calls. (The
+%%      arities should always match.) The attributes are simply
+%%      described by key-value pairs.
+%%
+%% @doc Merges syntax trees to a single syntax tree. This is the main
+%% code merging "engine". `Name' specifies the name of the
+%% resulting module. `Sources' is a list of syntax trees of
+%% type `form_list' and/or lists of "source code form" syntax
+%% trees, each entry representing a module definition. All the input
+%% modules must be distinctly named.
+%%
+%% Unless otherwise specified by the options, all modules are assumed
+%% to be at least "static", and all except the target module are assumed
+%% to be "safe". See the `static' and `safe'
+%% options for details.
+%%
+%% If `Name' is also the name of one of the input modules,
+%% the code from that module will occur at the top of the resulting
+%% code, and no extra "header" comments will be added. In other words,
+%% the look of that module will be preserved.
+%%
+%% The result is a pair `{Tree, Stubs}', where
+%% `Tree' represents the source code that is the result of
+%% merging all the code in `Sources', and `Stubs'
+%% is a list of stub module descriptors (see below).
+%%
+%% `Stubs' contains one entry for each exported input
+%% module (cf. the `export' option), each entry describing a
+%% stub module that redirects calls of functions in the original module
+%% to the corresponding (possibly renamed) functions in the new module.
+%% The stub descriptors can be used to automatically generate stub
+%% modules; see `create_stubs/2'.
+%%
+%% Options:
+%% <dl>
+%%   <dt>`{export, [atom()]}'</dt>
+%%
+%%     <dd>Specifies a list of names of input modules whose interfaces
+%%     should be exported by the output module. A stub descriptor is
+%%     generated for each specified module, unless its name is
+%%     `Name'. If no modules are specified, then if
+%%     `Name' is also the name of an input module, that
+%%     module will be exported; otherwise the first listed module in
+%%     `Sources' will be exported. The default value is the
+%%     empty list.</dd>
+%%
+%%   <dt>`{export_all, bool()}'</dt>
+%%
+%%     <dd>If the value is `true', this is equivalent to
+%%     listing all of the input modules in the `export'
+%%     option. The default value is `false'.</dd>
+%%
+%% <dt>`{file_attributes, Preserve}'</dt>
+%%     <dd><ul>
+%%       <li>`Preserve = yes | comment | no'</li>
+%%     </ul>
+%%     If the value is `yes', all file attributes
+%%     `-file(...)' in the input sources will be preserved in
+%%     the resulting code. If the value is `comment', they
+%%     will be turned into comments, but remain in their original
+%%     positions in the code relative to the other source code forms. If
+%%     the value is `no', all file attributes will be removed
+%%     from the code, unless they have attached comments, in which case
+%%     they will be handled as in the `comment' case. The
+%%     default value is `no'.</dd>
+%%
+%% <dt>`{no_banner, bool()}'</dt>
+%%
+%%     <dd>If the value is `true', no banner comment will be
+%%     added at the top of the resulting module, even if the target
+%%     module does not have the same name as any of the input modules.
+%%     Instead, Igor will try to preserve the look of the module whose
+%%     code is at the top of the output. The default value is
+%%     `false'.</dd>
+%%
+%% <dt>`{no_headers, bool()}'</dt>
+%%
+%%     <dd>If the value is `true', no header comments will be
+%%     added to the resulting module at the beginning of each section of
+%%     code that originates from a particular input module. The default
+%%     value is `false', which means that section headers are
+%%     normally added whenever more than two or more modules are
+%%     merged.</dd>
+%%
+%% <dt>`{no_imports, bool()}'</dt>
+%%
+%%     <dd>If the value is `true', all
+%%     `-import(...)' declarations in the original code will
+%%     be expanded in the result; otherwise, as much as possible of the
+%%     original import declarations will be preserved. The default value
+%%     is `false'.</dd>
+%%
+%% <dt>`{notes, Notes}'</dt>
+%%     <dd><ul>
+%%       <li>`Notes = always | yes | no'</li>
+%%     </ul>
+%%     If the value is `yes', comments will be inserted where
+%%     important changes have been made in the code. If the value is
+%%     `always', <em>all</em> changes to the code will be
+%%     commented. If the value is `no', changes will be made
+%%     without comments. The default value is `yes'.</dd>
+%%
+%% <dt>`{redirect, [{atom(), atom()}]}'</dt>
+%%
+%%     <dd>Specifies a list of pairs of module names, representing a
+%%     mapping from old names to new. <em>The set of old names may not
+%%     include any of the names of the input modules.</em> All calls to
+%%     the listed old modules will be rewritten to refer to the
+%%     corresponding new modules. <em>The redirected calls will not be
+%%     further processed, even if the new destination is in one of the
+%%     input modules.</em> This option mainly exists to support module
+%%     renaming; cf. `rename/3'. The default value is the
+%%     empty list.</dd>
+%%
+%% <dt>`{safe, [atom()]}'</dt>
+%%
+%%     <dd>Specifies a list of names of input modules such that calls to
+%%     these "safe" modules may be turned into direct local calls, that
+%%     do not test for code replacement. Typically, this can be done for
+%%     e.g. standard library modules. If a module is "safe", it is per
+%%     definition also "static" (cf. below). The list may be empty. By
+%%     default, all involved modules <em>except the target module</em>
+%%     are considered "safe".</dd>
+%%
+%% <dt>`{static, [atom()]}'</dt>
+%%
+%%     <dd>Specifies a list of names of input modules which will be
+%%     assumed never to be replaced (reloaded) unless the target module
+%%     is also first replaced. The list may be empty. The target module
+%%     itself (which may also be one of the input modules) is always
+%%     regarded as "static", regardless of the value of this option. By
+%%     default, all involved modules are assumed to be static.</dd>
+%%
+%% <dt>`{tidy, bool()}'</dt>
+%%
+%%     <dd>If the value is `true', the resulting code will be
+%%     processed using the `erl_tidy' module, which removes
+%%     unused functions and does general code cleanup. (See
+%%     `erl_tidy:module/2' for additional options.) The
+%%     default value is `true'.</dd>
+%%
+%% <dt>`{verbose, bool()}'</dt>
+%%
+%%     <dd>If the value is `true', progress messages will be
+%%     output while the program is running; the default value is
+%%     `false'.</dd>
+%% </dl>
+%%
+%% Note: The distinction between "static" and "safe" modules is
+%% necessary in order not to break the semantics of dynamic code
+%% replacement. A "static" source module will not be replaced unless the
+%% target module also is. Now imagine a state machine implemented by
+%% placing the code for each state in a separate module, and suppose
+%% that we want to merge this into a single target module, marking all
+%% source modules as static. At each point in the original code where a
+%% call is made from one of the modules to another (i.e., the state
+%% transitions), code replacement is expected to be detected. Then, if
+%% we in the merged code do not check at these points if the
+%% <em>target</em> module (the result of the merge) has been replaced,
+%% we can not be sure in general that we will be able to do code
+%% replacement of the merged state machine - it could run forever
+%% without detecting the code change. Therefore, all such calls must
+%% remain remote-calls (detecting code changes), but may call the target
+%% module directly.
+%%
+%% If we are sure that this kind of situation cannot ensue, we may
+%% specify the involved modules as "safe", and all calls between them
+%% will become local. Note that if the target module itself is specified
+%% as safe, "remote" calls to itself will be turned into local calls.
+%% This would destroy the code replacement properties of e.g. a typical
+%% server loop.
+%%
+%% @see create_stubs/2
+%% @see rename/3
+%% @see erl_tidy:module/2
+
+%% Currently, there is no run-time support in Erlang for detecting
+%% whether some module has been changed since the current module was
+%% loaded. Therefore, if a source module is specified as non-static, not
+%% much will be gained from merging: a call to a non-static module will
+%% remain a remote call using the old module name, even when it is
+%% performed from within the merged code. If that module is specified as
+%% exported, the old name could then refer to an auto-generated stub,
+%% redirecting the call back to the corresponding function in the target
+%% module. This could possibly be useful in some cases, but efficiency
+%% is not improved by such a transformation. If support for efficient
+%% testing for module updates is added to Erlang in future versions,
+%% code merging will be able to use local calls even for non-static
+%% source modules, opening the way for compiler optimisations over the
+%% module boundaries.
+
+%% Data structure for merging environment.
+
+-record(merge, {target,		% = atom()
+		sources,	% = ordset(atom())
+		export,		% = ordset(atom())
+		static,		% = ordset(atom())
+		safe,		% = ordset(atom())
+		preserved,	% = bool()
+		no_headers,	% = bool()
+		notes,		% = bool()
+		redirect,	% = dict(atom(), atom())
+		no_imports,	% = ordset(atom())
+		options		% = [term()]
+	       }).
+
+merge_sources(Name, Sources, Opts) ->
+    %% Prepare the options and the inputs.
+    Opts1 = Opts ++ [{export_all, false},
+		     {file_attributes, no},
+		     {no_imports, false},
+		     {notes, yes},
+		     tidy,
+		     {verbose, false}],
+    Trees = case Sources of
+		[] ->
+		    report_error("no sources to merge."),
+		    exit(badarg);
+		_ ->
+		    [if is_list(M) -> erl_syntax:form_list(M);
+			true -> M
+		     end
+		     || M <- Sources]
+	    end,
+    %% There must be at least one module to work with.
+    Modules = [get_module_info(T) || T <- Trees],
+    merge_sources_1(Name, Modules, Trees, Opts1).
+
+%% Data structure for keeping state during transformation.
+
+-record(state, {export}).
+
+state__add_export(Name, Arity, S) ->
+    S#state{export = sets:add_element({Name, Arity},
+				      S#state.export)}.
+
+merge_sources_1(Name, Modules, Trees, Opts) ->
+    %% Get the (nonempty) list of source module names, in the given
+    %% order. Multiple occurrences of the same source module name are
+    %% not accepted.
+    Ns = [M#module.name || M <- Modules],
+    case duplicates(Ns) of
+	[] ->
+	    ok;
+	Ns1 ->
+	    report_error("same module names repeated in input: ~p.",
+			 [Ns1]),
+	    exit(error)
+    end,
+    Sources = ordsets:from_list(Ns),
+    All = ordsets:add_element(Name, Sources),
+
+    %% Initialise the merging environment from the given options.
+    %%
+    %% If the `export' option is the empty list, then if the target
+    %% module is the same as one of the sources, that module will be
+    %% exported; otherwise the first listed source module is exported.
+    %% This simplifies use in most cases, and guarantees that the
+    %% generated module has a well-defined interface. If `export_all' is
+    %% `true', we expand it here by including the set of source module
+    %% names.
+    Es = case proplists:append_values(export, Opts) of
+	     [] ->
+		 case ordsets:is_element(Name, Sources) of
+		     true ->
+			 [Name];
+		     false ->
+			 [hd(Ns)]
+		 end;
+	     Es1 when is_list(Es1) ->
+		 ordsets:from_list(Es1)
+	 end,
+    Export = case proplists:get_bool(export_all, Opts) of
+		 false ->
+		     Es;
+		 true ->
+		     ordsets:union(Sources, Es)
+	     end,
+    check_module_names(Export, Sources, "declared as exported"),
+    verbose("modules exported from `~w': ~p.", [Name, Export], Opts),
+
+    %% The target module is always "static". (Particularly useful when
+    %% the target is the same as one of the source modules). It is
+    %% however not "safe" by default. If no modules are explicitly
+    %% specified as static, it is assumed that *all* are static.
+    Static0 = ordsets:from_list(proplists:append_values(static, Opts)),
+    case proplists:is_defined(static, Opts) of
+	false ->
+	    Static = All;
+	true ->
+	    Static = ordsets:add_element(Name, Static0)
+    end,
+    check_module_names(Static, All, "declared 'static'"),
+    verbose("static modules: ~p.", [Static], Opts),
+
+    %% If no modules are explicitly specified as "safe", it is assumed
+    %% that *all* source modules are "safe" except the target module and
+    %% those explicitly specified as "static".
+    Safe = case proplists:is_defined(safe, Opts) of
+	       false ->
+		   ordsets:subtract(Sources,
+				    ordsets:add_element(Name, Static0));
+	       true ->
+		   ordsets:from_list(
+		     proplists:append_values(safe, Opts))
+	   end,
+    check_module_names(Safe, All, "declared 'safe'"),
+    verbose("safe modules: ~p.", [Safe], Opts),
+
+    Preserved = (ordsets:is_element(Name, Sources)
+		 and ordsets:is_element(Name, Export))
+	or proplists:get_bool(no_banner, Opts),
+    NoHeaders = proplists:get_bool(no_headers, Opts),
+    Notes = proplists:get_value(notes, Opts, always),
+    Rs = proplists:append_values(redirect, Opts),
+    Redirect = case is_atom_map(Rs) of
+		   true ->
+		       Ms = ordsets:from_list([M || {M, _} <- Rs]),
+		       case ordsets:intersection(Sources, Ms) of
+			   [] ->
+			       ok;
+			   Ms1 ->
+			       report_error("cannot redirect calls to "
+					    "modules in input set: ~p.",
+					    [Ms1]),
+			       exit(error)
+		       end,
+		       dict:from_list(Rs);
+		   false ->
+		       report_error("bad value for `redirect' option: "
+				    "~P.",
+				    [Rs, 10]),
+		       exit(error)
+	       end,
+    NoImports = case proplists:get_bool(no_imports, Opts) of
+		    true ->
+			ordsets:from_list(Sources ++
+					  dict:fetch_keys(Redirect));
+		    false ->
+			ordsets:from_list(dict:fetch_keys(Redirect))
+		end,
+    Env = #merge{target = Name,
+		 sources = Sources,
+		 export = Export,
+		 safe = Safe,
+		 static = Static,
+		 preserved = Preserved,
+		 no_headers = NoHeaders,
+		 notes = Notes,
+		 redirect = Redirect,
+		 no_imports = NoImports,
+		 options = Opts},
+    merge_sources_2(Env, Modules, Trees, Opts).
+
+is_atom_map([{A1, A2} | As]) when is_atom(A1), is_atom(A2) ->
+    is_atom_map(As);
+is_atom_map([]) ->
+    true;
+is_atom_map(_) ->
+    false.
+
+check_module_names(Names, Sources, Txt) ->
+    case Names -- Sources of
+	[] ->
+	    ok;
+	Xs ->
+	    report_error("unknown modules ~s: ~p.", [Txt, Xs]),
+	    exit(error)
+    end.
+
+%% This function performs all the stages of the actual merge:
+
+merge_sources_2(Env, Modules, Trees, Opts) ->
+    %% Compute the merged name space and the list of renamings.
+    {Names, Renaming} = merge_namespaces(Modules, Env),
+    
+    %% Merge the source module descriptions, computing a structure
+    %% describing the resulting module, and a table of aliases which
+    %% must be expanded.
+    {Module, Expansions} = merge_info(Modules, Names, Renaming,
+				      Env),
+    
+    %% Merge the actual source code, also returning the "original
+    %% header" (for the first code section in the output).
+    St = #state{export = sets:new()},
+    {Tree, Header, St1} = merge_code(Trees, Modules, Expansions,
+				     Renaming, Env, St),
+
+    %% Filter out unwanted program forms and add a preamble to the code,
+    %% making a complete module.
+    Tree1 = erl_syntax:form_list([make_preamble(Module, Header,
+						Env, St1),
+				  filter_forms(Tree, Env)]),
+    
+    %% Tidy the final syntax tree (removing unused functions) and return
+    %% it together with the list of stub descriptors.
+    {tidy(Tree1, Opts), make_stubs(Modules, Renaming, Env)}.
+
+make_preamble(Module, Header, Env, St) ->
+    Name = Module#module.name,
+    Vars = Module#module.vars,
+    Extras = ordsets:from_list(sets:to_list(St#state.export)),
+    Exports = make_exports(Module#module.exports, Extras),
+    Imports = make_imports(Module#module.aliases),
+    Attributes = make_attributes(Module#module.attributes),
+    erl_syntax:form_list(module_header(Header, Name, Vars, Env)
+			 ++ Exports
+			 ++ Imports
+			 ++ Attributes).
+
+%% If the target preserves one of the source modules, we do not generate
+%% a new header, but use the original.
+
+module_header(Forms, Name, Vars, Env) ->
+    case Env#merge.preserved of
+	true ->
+	    update_header(Forms, Name, Vars);
+	false ->
+	    [comment([?COMMENT_BAR,
+		      "This module was formed by merging "
+		      "the following modules:",
+		      ""]
+		     ++ [lists:flatten(io_lib:fwrite("\t\t`~w'",
+						     [M]))
+			 || M <- Env#merge.sources]
+		     ++ ["",
+			 timestamp(),
+			 ""]),
+	     erl_syntax:attribute(erl_syntax:atom('module'),
+				  [erl_syntax:atom(Name)])]
+    end.
+
+update_header(Fs, Name, Vars) ->
+    [M | Fs1] = lists:reverse(Fs),
+    Ps = if Vars =:= none -> [];
+	    true -> [erl_syntax:list([erl_syntax:variable(V)
+				      || V <- Vars])]
+	 end,
+    M1 = rewrite(M, erl_syntax:attribute(erl_syntax:atom('module'),
+					 [erl_syntax:atom(Name) | Ps])),
+    lists:reverse([M1 | Fs1]).
+
+%% Some functions may have been noted as necessary to export (because of
+%% how they are called) even though the user did not specify that the
+%% modules in which these functions originated should be part of the
+%% interface of the resulting module.
+
+make_exports(Exports, Extras) ->
+    case ordsets:subtract(Extras, Exports) of
+	[] ->
+	    [make_export(Exports)];
+	Es ->
+	    [make_export(Exports),
+	     comment(["** The following exports "
+		      "are not official: **"]),
+	     make_export(Es)]
+    end.
+
+make_export(Names) ->
+    Es = [erl_syntax:arity_qualifier(erl_syntax:atom(F),
+				     erl_syntax:integer(A))
+	  || {F, A} <- Names],
+    if Es =:= [] ->
+	    comment(["** Nothing is officially exported "
+		    "from this module! **"]);
+       true ->
+	    erl_syntax:attribute(erl_syntax:atom('export'),
+				 [erl_syntax:list(Es)])
+    end.
+
+%% Any aliases that cannot be expressed using `import' (i.e. those not
+%% on the form `{F, {M, F}}') are ignored.
+
+make_imports(As) ->
+    %% First remove any auto-imports and "non-proper" imports from
+    %% the list.
+    As1 = [A || {F, {_M, F}} = A <- As, not is_auto_import(F)],
+    [make_import(M, Fs) || {M, Fs} <- group_imports(As1)].
+
+make_import(Module, Names) ->
+    Is = [erl_syntax:arity_qualifier(erl_syntax:atom(F),
+				     erl_syntax:integer(A))
+	  || {F, A} <- Names],
+    erl_syntax:attribute(erl_syntax:atom('import'),
+			 [erl_syntax:atom(Module),
+			  erl_syntax:list(Is)]).
+
+%% Group aliases by module.
+
+group_imports(Imports) ->
+    dict:to_list(
+      lists:foldl(
+	fun ({F, {M, F}}, D) ->
+		case dict:find(M, D) of
+		    {ok, V} ->
+			V1 = ordsets:add_element(F, V),
+			dict:store(M, V1, D);
+		    error ->
+			dict:store(M, [F], D)
+		end
+	end,
+	dict:new(), Imports)).
+
+
+%% ---------------------------------------------------------------------
+%% Making stub descriptors
+%%
+%% These are generated for all exported modules that are not the target
+%% module.
+
+make_stubs(Modules, Renaming, Env) ->
+    make_stubs_1(Modules, Renaming, Env).
+
+make_stubs_1([M | Ms], Renaming, Env) ->
+    Name = M#module.name,
+    if Name /= Env#merge.target ->
+	    case ordsets:is_element(Name, Env#merge.export) of
+		true ->
+		    [make_stub(M, Renaming(Name), Env)
+		     | make_stubs_1(Ms, Renaming, Env)];
+		false ->
+		    make_stubs_1(Ms, Renaming, Env)
+	    end;
+       true ->
+	    make_stubs_1(Ms, Renaming, Env)
+    end;
+make_stubs_1([], _, _) ->
+    [].
+
+make_stub(M, Map, Env) ->
+    Target = Env#merge.target,
+    Es = [{F, {Target, Map(F)}} || F <- M#module.exports],
+    {M#module.name, Es, M#module.attributes}.
+
+
+%% ---------------------------------------------------------------------
+%% Removing and/or out-commenting program forms. The returned form
+%% sequence tree is not necessarily flat.
+
+-record(filter, {records, file_attributes, attributes}).
+
+filter_forms(Tree, Env) ->
+    Forms = erl_syntax:form_list_elements(
+	      erl_syntax:flatten_form_list(Tree)),
+    erl_syntax:form_list(filter_forms_1(Forms, Env)).
+
+filter_forms_1(Forms, Env) ->
+    {Fs, _} = filter_forms_2(Forms, Env),
+    lists:reverse(Fs).
+
+filter_forms_2(Forms, Env) ->
+    FileAttrsOpt = proplists:get_value(file_attributes,
+				       Env#merge.options, comment),
+    %% Sanity check and translation of option value:
+    FileAttrs = case FileAttrsOpt of
+		    yes -> keep;
+		    no -> delete;
+		    comment -> kill;
+		    _ ->
+			report_error("invalid value for option "
+				     "`file_attributes': ~w.",
+				     [FileAttrsOpt]),
+			exit(error)
+		end,
+    Attrs = if length(Env#merge.sources) =:= 1 ->
+		    delete;    %% keeping the originals looks weird
+	       true ->
+		    kill
+	    end,
+    S = #filter{records = sets:new(),
+		file_attributes = FileAttrs,
+		attributes = Attrs},
+    lists:foldl(
+      fun (F, {Fs, S0}) ->
+	      case filter_form(F, S0) of
+		  {keep, S1} ->
+		      {[F | Fs], S1};    % keep
+		  {kill, S1} ->
+		      {[kill_form(F) | Fs], S1};    % kill
+		  {delete, S1} ->
+		      %% Remove, or kill if it has comments (only
+		      %% top-level comments are examined).
+		      case erl_syntax:has_comments(F) of
+			  false ->
+			      {Fs, S1};
+			  true ->
+			      {[kill_form(F) | Fs], S1}
+		      end
+	      end
+      end,
+      {[], S}, Forms).
+
+filter_form(F, S) ->
+    case erl_syntax_lib:analyze_form(F) of
+	{attribute, {'file', _}} ->
+	    {S#filter.file_attributes, S};
+	{attribute, {'module', _}} ->
+	    {delete, S};
+	{attribute, {'export', _}} ->
+	    {delete, S};
+	{attribute, {'import', _}} ->
+	    {delete, S};
+	{attribute, {'record', {R, _}}} ->
+	    Records = S#filter.records,
+	    case sets:is_element(R, Records) of
+		true ->
+		    {kill, S};    % already defined above
+		false ->
+		    S1 = S#filter{records =
+				  sets:add_element(R, Records)},
+		    {keep, S1}
+	    end;
+	{attribute, preprocessor} ->
+	    {keep, S};    %% keep all preprocessor attributes
+	{attribute, _} ->
+	    {S#filter.attributes, S};    %% handle all other attributes
+	{error_marker, _} ->
+	    {delete, S};
+	{warning_marker, _} ->
+	    {delete, S};
+	eof_marker ->
+	    {delete, S};    % these must be deleted!
+	_ ->
+	    {keep, S}    % keep all other Erlang forms
+    end.
+
+%% This out-comments (kills) a program form. Any top-level pre-comments
+%% are moved out, to avoid "nested" comments.
+
+kill_form(F) ->
+    F1 = erl_syntax:set_precomments(F, []),
+    F2 = erl_syntax_lib:to_comment(F1, ?KILL_PREFIX),
+    erl_syntax:set_precomments(F2,
+			       erl_syntax:get_precomments(F)).
+
+
+%% ---------------------------------------------------------------------
+%% Merging the name spaces of a set of modules. Returns the final set
+%% (see module `sets') of names and a total renaming function (atom())
+%% -> ({atom(), integer()}) -> {atom(), integer()}.
+%%
+%% Names are added in two passes, in order to avoid renaming the
+%% interface functions whenever possible: all exported functions are
+%% added to the name space before any nonexported are added, and
+%% "exported" modules are taken before any other. Thus, the order is:
+%%
+%%   - exported functions of exported modules
+%%   - exported functions of nonexported modules
+%%   - internal functions of exported modules
+%%   - internal functions of nonexported modules
+%%
+%% In fact, only the first group is important, but there might be some
+%% point in establishing the above order, for better readability of the
+%% final code.
+
+merge_namespaces(Modules, Env) ->
+    Export = Env#merge.export,
+    Split = fun (M) ->
+		    ordsets:is_element(M#module.name, Export)
+	    end,
+    {M1, M2} = split_list(Split, Modules),
+    R = dict:new(),
+    Acc = {sets:new(), R},
+    {M3, Acc1} = merge_namespaces_1(M1, Acc),
+
+    %% Detect and warn about renamed interface functions
+    {_, Maps0} = Acc1,
+    case [{M, dict:to_list(Map)}
+	  || {M, Map} <- dict:to_list(Maps0), dict:size(Map) =/= 0] of
+	[] ->
+	    ok;
+	Fs ->
+	    report_warning("interface functions renamed:\n\t~p.",
+			   [Fs])
+    end,
+    {M4, Acc2} = merge_namespaces_1(M2, Acc1),
+    Ms = M3 ++ M4,
+    Acc3 = merge_namespaces_2(Ms, Acc2),
+    {{Names, Maps}, _} = merge_namespaces_3(Ms, Acc3),
+    {Names, make_renaming_function(Maps)}.
+
+%% Adding exported names. (Note that the list gets a new temporary
+%% format also containing the exports.) This first step initialises the
+%% Maps "dict-of-dicts" structure.
+
+merge_namespaces_1(Modules, Acc) ->
+    lists:mapfoldl(
+      fun (Module, {Names, Maps}) ->
+	      Exports = sets:from_list(Module#module.exports),
+	      M = Module#module.name,
+	      {Names1, Map} = add_function_renamings(M, Exports, Names,
+						     dict:new()),
+	      Maps1 = dict:store(M, Map, Maps),
+	      {{Module, Exports}, {Names1, Maps1}}
+      end,
+      Acc, Modules).
+
+%% Adding nonexported names.
+
+merge_namespaces_2(Modules, Acc) ->
+    lists:foldl(
+      fun ({Module, Exports}, {Names, Maps}) ->
+	      Other = sets:subtract(
+			sets:from_list(Module#module.functions),
+			Exports),
+	      M = Module#module.name,
+	      Map = dict:fetch(M, Maps),
+	      {Names1, Map1} = add_function_renamings(M, Other, Names,
+						      Map),
+	      Maps1 = dict:store(M, Map1, Maps),
+	      {Names1, Maps1}
+      end,
+      Acc, Modules).
+
+%% Adding record names. We need to keep a global
+%% "record-definition-to-new-record-name" mapping RMap while doing this.
+
+merge_namespaces_3(Modules, Acc) ->
+    lists:foldl(
+      fun ({Module, _Exports}, {{Names, Maps}, RMap}) ->
+	      Records = Module#module.records,
+	      M = Module#module.name,
+	      Map = dict:fetch(M, Maps),
+	      {Names1, Map1, RMap1} = add_record_renamings(M, Records,
+							   Names, Map,
+							   RMap),
+	      Maps1 = dict:store(M, Map1, Maps),
+	      {{Names1, Maps1}, RMap1}
+      end,
+      {Acc, dict:new()}, Modules).
+
+%% This takes the set of added function names together with the existing
+%% name set, creates new function names where necessary, and returns the
+%% final name set together with the list of renamings.
+
+add_function_renamings(Module, New, Names, Map) ->
+    Clashes = sets:to_list(sets:intersection(New, Names)),
+    lists:foldl(
+      fun (F = {_, A}, {Names, Map}) when is_integer(A) ->
+	      F1 = new_function_name(Module, F, Names),
+	      {sets:add_element(F1, Names), dict:store(F, F1, Map)}
+      end,
+      {sets:union(New, Names), Map}, Clashes).
+
+%% This is similar to the above, but for record names. Note that we add
+%% both the record name and the whole definition to the namespace.
+
+add_record_renamings(Module, Records, Names, Map, RMap) ->
+    lists:foldl(
+      fun (N = {R, Fs}, {Names, Map, RMap}) ->
+	      case sets:is_element(?record_name(R), Names) of
+		  true ->
+		      %% The name is already in use.
+		      case sets:is_element(?record_name(N), Names) of
+			  true ->
+			      %% We have seen this definition before;
+			      %% make sure we use the same name.
+			      {R1, _} = remap_record_name(N, RMap),
+			      Map1 = dict:store(?record_name(R),
+						?record_name(R1), Map),
+			      {Names, Map1, RMap};
+			  false ->
+			      %% Redefinition of existing name. Create
+			      %% new name and set up renamings.
+			      N1 = {R1, _} = new_record_name(Module, R,
+							     Fs, Names),
+			      Map1 = dict:store(?record_name(R),
+						?record_name(R1), Map),
+			      RMap1 = dict:store(N, N1, RMap),
+			      Names1 = sets:add_element(?record_name(N1),
+							Names),
+			      {Names1, Map1, RMap1}
+		      end;
+		  false ->
+		      %% A previously unused record name.
+		      Names1 = sets:add_element(?record_name(R), Names),
+		      Names2 = sets:add_element(?record_name(N), Names1),
+		      {Names2, Map, RMap}
+	      end
+      end,
+      {Names, Map, RMap}, Records).
+
+remap_record_name(N, Map) ->
+    case dict:find(N, Map) of
+	{ok, N1} -> N1;
+	error -> N
+    end.
+
+%% This hides the implementation of the record namespace. Since Map
+%% yields identity for non-remapped names, the remapped names must be
+%% stored in wrapped form.
+
+map_record_name(R, Map) ->
+    ?record_name(R1) = Map(?record_name(R)),
+    R1.
+
+%% When we rename a function, we want the new name to be as close as
+%% possible to the old, and as informative as possible. Therefore, we
+%% first prefix it with the name of the originating module, followed by
+%% two underscore characters, and then if there still is a name clash,
+%% we suffix the name by "_N", where N is the smallest possible positive
+%% integer that does not cause a clash.
+
+new_function_name(M, {F, A}, Names) ->
+    Base = atom_to_list(M) ++ "__" ++ atom_to_list(F),
+    Name = {list_to_atom(Base), A},
+    case sets:is_element(Name, Names) of
+	false ->
+	    Name;
+	true ->
+	    new_function_name(1, A, Base, Names)
+    end.
+
+new_function_name(N, Arity, Base, Names) ->
+    Name = {list_to_atom(Base ++ "_" ++ integer_to_list(N)),
+	    Arity},
+    case sets:is_element(Name, Names) of
+	false ->
+	    Name;
+	true ->
+	    %% Increment counter and try again.
+	    new_function_name(N + 1, Arity, Base, Names)
+    end.
+
+%% This is pretty much the same as new_function_name, for now.
+
+new_record_name(M, R, Fs, Names) ->
+    Base = atom_to_list(M) ++ "__" ++ atom_to_list(R),
+    Name = {list_to_atom(Base), Fs},
+    case sets:is_element(?record_name(Name), Names) of
+	false ->
+	    Name;
+	true ->
+	    new_record_name_1(1, Base, Fs, Names)
+    end.
+
+new_record_name_1(N, Base, Fs, Names) ->
+    Name = {list_to_atom(Base ++ "_" ++ integer_to_list(N)), Fs},
+    case sets:is_element(?record_name(Name), Names) of
+	false ->
+	    Name;
+	true ->
+	    %% Increment counter and try again.
+	    new_record_name_1(N + 1, Base, Fs, Names)
+    end.
+
+%% This returns a *total* function from the set of module names to the
+%% set of *total* operators on function names, yielding identity for all
+%% function names that are not specified in the given partial map
+%% (ModuleName -> (Name -> Name)).
+
+make_renaming_function(Maps) ->
+    fun (Module) ->
+	    case dict:find(Module, Maps) of
+		{ok, Map} ->
+		    fun (Name) ->
+			    case dict:find(Name, Map) of
+				{ok, Name1} ->
+				    Name1;    % renamed
+				error ->
+				    Name    % identity
+			    end
+		    end;
+		error ->
+		    %% Other module - yield identity map.
+		    fun (Name) -> Name end
+	    end
+    end.
+
+
+%% ---------------------------------------------------------------------
+%% Merging module info records into a target module record, and finding
+%% necessary alias expansions. Returns `{Module, Expansions}' where
+%% `Expansions' has type `dict(ModuleName, dict(Alias, FullName))'
+
+merge_info(Modules, Names, Renaming, Env) ->
+    Forbid = sets:from_list(Env#merge.no_imports),
+    Expansions = alias_expansions(Modules, Names, Forbid),
+    Module = merge_info_1(Modules, Renaming, Expansions, Env),
+    {Module, Expansions}.
+
+merge_info_1(Modules, Renaming, Expansions, Env) ->
+    lists:foldl(
+      fun (M, A) ->
+	      Name = M#module.name,
+	      Map = Renaming(Name),
+	      Functions = join_functions(Map,
+					 M#module.functions,
+					 A#module.functions),
+	      Exports = join_exports(Env, Name, Map,
+				     M#module.exports,
+				     A#module.exports),
+	      Aliases = join_aliases(Name, Expansions,
+				     M#module.aliases,
+				     A#module.aliases),
+	      Attributes = join_attributes(Env, Name,
+					   M#module.attributes,
+					   A#module.attributes),
+	      Records = join_records(Map,
+				     M#module.records,
+				     A#module.records),
+	      A#module{functions = Functions,
+		       exports = Exports,
+		       aliases = Aliases,
+		       attributes = Attributes,
+		       records = Records}
+      end,
+      #module{name = Env#merge.target,
+	      functions = ordsets:new(),
+	      exports = ordsets:new(),
+	      aliases = ordsets:new(),
+	      attributes = ordsets:new(),
+	      records = ordsets:new()},
+      Modules).
+
+%% Functions must be renamed before including.
+
+join_functions(Map, Source, Target) ->
+    ordsets:union(ordsets:from_list([Map(A) || A <- Source]),
+		  Target).
+
+%% Exports also need renaming, and are kept only if their originating
+%% modules are exported.
+
+join_exports(Env, Name, Map, Source, Target) ->
+    case ordsets:is_element(Name, Env#merge.export) of
+	true ->
+	    ordsets:union(ordsets:from_list([Map(F)
+					     || F <- Source]),
+			  Target);
+	false ->
+	    Target
+    end.
+
+%% Aliases never need renaming; instead we always expand uses which
+%% could cause name clashes. We must then remove the expanded names from
+%% the imports of the target.
+
+join_aliases(Name, Expansions, Source, Target) ->
+    As = case dict:find(Name, Expansions) of
+	     {ok, As1} ->
+		 ordsets:from_list(dict:to_list(As1));
+	     error ->
+		 []
+	 end,
+    ordsets:union(ordsets:subtract(Source, As), Target).
+
+%% We only propagate attributes if the number of source modules is 1 or
+%% the source module has the same name as the resulting module.
+
+join_attributes(Env, Name, Source, Target) ->
+    if Env#merge.target =:= Name ->
+	    ordsets:union(Source, Target);
+       true ->
+	    if length(Env#merge.sources) =:= 1 ->
+		    ordsets:union(Source, Target);
+	       true ->
+		    Target
+	    end
+    end.
+
+%% The final record info in itself is not used at present, but we
+%% compute the join anyway. We apply renaming to records much like we do
+%% to functions, but records have a separate namespace.
+
+join_records(Map, Source, Target) ->
+    Renamed = [{map_record_name(R, Map), Fs} || {R, Fs} <- Source],
+    ordsets:union(ordsets:from_list(Renamed), Target).
+
+%% This finds aliases that are in conflict or are for other reasons
+%% necessary to expand while transforming the code later. It is assumed
+%% that each module is in itself correct, and thus does not contain
+%% conflicting definitions of the same alias.
+%%
+%% We could of course simply say that *all* aliases, without exception,
+%% should be expanded, but such a big change in the style of the code
+%% should not be done unless the user explicitly specifies it.
+%%
+%% The returned `Expansions' is a dictionary (module `dict') mapping
+%% each module name in `Modules' to a dictionary which maps those
+%% aliases to be expanded for that module to their corresponding full
+%% names.
+%%
+%% Aliases are filtered according to the following rules:
+%%
+%%	1. If a name is defined (in some source module) as an alias of a
+%%	name `M:...', where `M' is any of the source modules(*), then
+%%	the definition of that alias should be removed, and all its uses
+%%	(in the same module as the definition) be expanded.
+%%
+%%	2. Then, if a name is defined (in some source module) as an
+%%	alias, but the name occurs in the name space of the resulting
+%%	module, then the definition should be removed and all uses (in
+%%	the same module) expanded.
+%%
+%%	3. Finally, if a name has two or more distinct alias definitions
+%%	in the source modules, then all definitions of that alias should
+%%	be removed and all uses (in all modules) expanded. (We remove
+%%	all definitions mainly for symmetry.)
+%%
+%%	(*) It is actually possible for an alias to refer to the module
+%%	in which it is itself defined. However, since we also in this
+%%	case want to expand all uses, we don't have to do any extra work
+%%	to handle it.
+
+%% The filtering is done in two stages.
+
+alias_expansions(Modules, Names, Forbid) ->
+    Table = alias_expansions_1(Modules, Forbid, Names),
+    alias_expansions_2(Modules, Table).
+
+%% First consider each alias in isolation.
+
+alias_expansions_1(Modules, Forbid, Names) ->
+    lists:foldl(
+      fun (M, T) ->
+	      Map = lists:foldl(
+		      fun ({A, F}, T1) ->
+			      case keep_alias(A, F, Forbid, Names)
+				  of
+				  true ->
+				      T1;
+				  false ->
+				      dict:store(A, F, T1)
+			      end
+		      end,
+		      dict:new(), M#module.aliases),
+	      dict:store(M#module.name, Map, T)
+      end,
+      dict:new(), Modules).
+
+keep_alias(A, {M, _}, Forbid, Names) ->
+    case sets:is_element(M, Forbid) of
+	true ->
+	    false;
+	false ->
+	    not sets:is_element(A, Names)
+    end.
+
+%% In this second stage, we resolve any conflicts that may remain
+%% because of distinct source modules still containing distinct alias
+%% definitions of the same name - in that case we remove *all* of them
+%% (mainly for symmetry).
+
+alias_expansions_2(Modules, Table) ->
+    %% Get the set of all alias definitions in all modules (collapsing
+    %% duplicated but equivalent definitions).
+    Aliases = lists:foldl(
+		fun (M, A) ->
+			ordsets:union(A, M#module.aliases)
+		end,
+		ordsets:new(), Modules),
+    
+    %% Get the set of names with multiple (distinct) definitions.
+    Names = duplicates([F || {F, _} <- Aliases]),
+    
+    %% Go through all aliases in all source modules and add necessary
+    %% entries to the expansion-table. We expect that there is an entry
+    %% in the table here for each module.
+    lists:foldl(
+      fun (M, T) ->
+	      N = M#module.name,
+	      lists:foldl(
+		fun ({A, F}, T1) ->
+			case ordsets:is_element(A, Names) of
+			    true ->
+				T2 = dict:fetch(N, T1),
+				dict:store(N,
+					   dict:store(A, F, T2),
+					   T1);
+			    false ->
+				T1
+			end
+		end,
+		T, M#module.aliases)
+      end,
+      Table, Modules).
+
+
+%% ---------------------------------------------------------------------
+%% Merging the source code.
+
+%% Data structure for code transformation environment.
+
+-record(code, {module,		% = atom()
+	       target,		% = atom()
+	       sources,		% = ordset(atom())
+	       static,		% = ordset(atom())
+	       safe,		% = ordset(atom())
+	       preserved,	% = bool()
+	       no_headers,	% = bool()
+	       notes,		% = bool()
+	       map,		% = ({atom(), int()}) -> {atom(), int()}
+	       renaming,	% = (atom()) -> ({atom(), int()}) ->
+				%               {atom(), int()}
+	       expand,		% = dict({atom(), int()},
+				%      {atom(), {atom(), int()}})
+	       redirect		% = dict(atom(), atom())
+	      }).
+
+%% `Trees' must be a list of syntax trees of type `form_list'. The
+%% result is a pair `{Result, Header}' where `Result' is a `form_list'
+%% tree representing the merged code, and if the `preserved' flag is
+%% set, `Header' is the list of forms up to and including the first
+%% `-module(...)' declaration, but stripped of any `-file(...)'
+%% attributes - otherwise `Header' is an empty list.
+
+merge_code(Trees, Modules, Expansions, Renaming, Env, St) ->
+    Env1 = #code{target = Env#merge.target,
+		 sources = sets:from_list(Env#merge.sources),
+		 static = sets:from_list(Env#merge.static),
+		 safe = sets:from_list(Env#merge.safe),
+		 preserved = Env#merge.preserved,
+		 no_headers = Env#merge.no_headers,
+		 notes = Env#merge.notes,
+		 redirect = Env#merge.redirect,
+		 renaming = Renaming},
+    Code = order_code(Modules, Trees, Env1),
+    {Code1, Header} = case Env1#code.preserved of
+			  true ->
+			      take_header(Code);
+			  false ->
+			      {Code, erl_syntax:form_list([])}
+		      end,
+    {Forms, St1} = merge_code_1(Code1, Expansions, Env1, St),
+    Tree = erl_syntax:form_list(Forms),
+    {Tree, Header, St1}.
+
+merge_code_1(Code, Expansions, Env, St) ->
+      lists:foldr(
+	fun ({Module, T}, {Acc, St0}) ->
+		M = Module#module.name,
+		Expand = case dict:find(M, Expansions) of
+			     {ok, Dict} -> Dict;
+			     error -> dict:new()
+			 end,
+		Env1 = Env#code{module = M,
+				map = (Env#code.renaming)(M),
+				expand = Expand},
+		{T1, St1} = transform(T, Env1, St0),
+		{[section_header(M, T1, Env1) | Acc], St1}
+	end,
+	{[], St}, Code).
+
+%% Pair module info and source code, in the order we want, and flatten
+%% the form lists. If the name of the target is the same as one of the
+%% source modules, and the result should preserve the original module,
+%% the code for that module should be first in the output.
+
+order_code(Modules, Trees, Env) ->
+    order_code(Modules, Trees, {}, [], Env).
+
+order_code([M | Ms], [T | Ts], First, Rest, Env) ->
+    T1 = erl_syntax:flatten_form_list(T),
+    case (M#module.name =:= Env#code.target) and
+	Env#code.preserved of
+	true ->
+	    order_code(Ms, Ts, {M, T1}, Rest, Env);
+	false ->
+	    order_code(Ms, Ts, First, [{M, T1} | Rest], Env)
+    end;
+order_code([], [], First, Rest, _Env) ->
+    Rest1 = lists:reverse(Rest),
+    case First of
+	{} ->
+	    Rest1;
+	M ->
+	    [M | Rest1]
+    end.
+
+%% Extracting the "original" header (the `-module(...)' declaration is
+%% sure to exist).
+
+take_header([{M, T} | Ms]) ->
+    Fs = erl_syntax:form_list_elements(T),
+    {Header, Fs1} = take_header_1(Fs, []),
+    T1 = erl_syntax:form_list(Fs1),
+    {[{M, T1} | Ms], Header}.
+
+take_header_1([F | Fs], As) ->
+    case erl_syntax_lib:analyze_form(F) of
+	{'attribute', {'module', _}} ->
+	    {lists:reverse([F | As]), Fs};    % done
+	{'attribute', {'file', _}} ->
+	    take_header_1(Fs, As);    % discard
+	_ ->
+	    take_header_1(Fs, [F | As])    % keep
+    end.
+
+section_header(Name, Tree, Env) ->
+    N = sets:size(Env#code.sources),
+    if N > 1, Name /= Env#code.target, Env#code.notes /= no,
+       Env#code.no_headers /= true ->
+	    Text = io_lib:fwrite("The following code stems "
+				 "from module `~w'.", [Name]),
+	    Header = comment([?COMMENT_BAR, "",
+			      lists:flatten(Text), ""]),
+	    erl_syntax:form_list([Header, Tree]);
+       true ->
+	    Tree
+    end.
+
+transform(Tree, Env, St) ->
+    case erl_syntax:type(Tree) of
+	application ->
+	    transform_application(Tree, Env, St);
+	attribute ->
+	    transform_attribute(Tree, Env, St);
+  	function ->
+  	    transform_function(Tree, Env, St);
+ 	implicit_fun ->
+ 	    transform_implicit_fun(Tree, Env, St);
+  	rule ->
+  	    transform_rule(Tree, Env, St);
+  	record_expr ->
+  	    transform_record(Tree, Env, St);
+  	record_index_expr ->
+  	    transform_record(Tree, Env, St);
+  	record_access ->
+  	    transform_record(Tree, Env, St);
+	_ ->
+	    default_transform(Tree, Env, St)
+    end.
+
+default_transform(Tree, Env, St) ->
+    case erl_syntax:subtrees(Tree) of
+	[] ->
+	    {Tree, St};
+	Gs ->
+	    {Gs1, St1} = transform_1(Gs, Env, St),
+	    Tree1 = rewrite(Tree, erl_syntax:make_tree(
+				    erl_syntax:type(Tree),
+				    Gs1)),
+	    {Tree1, St1}
+    end.
+
+transform_1([G | Gs], Env, St) ->
+    {G1, St1} = transform_list(G, Env, St),
+    {Gs1, St2} = transform_1(Gs, Env, St1),
+    {[G1 | Gs1], St2};
+transform_1([], _Env, St) ->
+    {[], St}.
+
+transform_list([T | Ts], Env, St) ->
+    {T1, St1} = transform(T, Env, St),
+    {Ts1, St2} = transform_list(Ts, Env, St1),
+    {[T1 | Ts1], St2};
+transform_list([], _Env, St) ->
+    {[], St}.
+
+%% Renaming function definitions
+
+transform_function(T, Env, St) ->
+    {T1, St1} = default_transform(T, Env, St),
+    F = erl_syntax_lib:analyze_function(T1),
+    {V, Text} = case (Env#code.map)(F) of
+		    F ->
+			%% Not renamed
+			{none, []};
+		    {Atom, _Arity} ->
+			%% Renamed
+			Cs = erl_syntax:function_clauses(T1),
+			N = rename_atom(
+			      erl_syntax:function_name(T1),
+			      Atom),
+			T2 = erl_syntax:function(N, Cs),
+			{{value, T2}, renaming_note(Atom)}
+		end,
+    {maybe_modified(V, T1, 2, Text, Env), St1}.
+
+renaming_note(Name) ->
+    [lists:flatten(io_lib:fwrite("renamed function to `~w'",
+				 [Name]))].
+
+rename_atom(Node, Atom) ->
+    rewrite(Node, erl_syntax:atom(Atom)).
+
+%% Renaming Mnemosyne rules (just like function definitions)
+
+transform_rule(T, Env, St) ->
+    {T1, St1} = default_transform(T, Env, St),
+    F = erl_syntax_lib:analyze_rule(T1),
+    {V, Text} = case (Env#code.map)(F) of
+		    F ->
+			%% Not renamed
+			{none, []};
+		    {Atom, _Arity} ->
+			%% Renamed
+			Cs = erl_syntax:rule_clauses(T1),
+			N = rename_atom(
+			      erl_syntax:rule_name(T1),
+			      Atom),
+			T2 = rewrite(T1,
+				     erl_syntax:rule(N, Cs)),
+			{{value, T2}, renaming_note(Atom)}
+		end,
+    {maybe_modified(V, T1, 2, Text, Env), St1}.
+
+%% Renaming "implicit fun" expressions (done quietly).
+
+transform_implicit_fun(T, Env, St) ->
+    {T1, St1} = default_transform(T, Env, St),
+    F = erl_syntax_lib:analyze_implicit_fun(T1),
+    {V, Text} = case (Env#code.map)(F) of
+		    F ->
+			%% Not renamed
+			{none, []};
+		    {Atom, Arity} ->
+			%% Renamed
+			N = rewrite(
+			      erl_syntax:implicit_fun_name(T1),
+			      erl_syntax:arity_qualifier(
+				erl_syntax:atom(Atom),
+				erl_syntax:integer(Arity))),
+			T2 = erl_syntax:implicit_fun(N),
+			{{value, T2}, ["function was renamed"]}
+		end,
+    {maybe_modified_quiet(V, T1, 2, Text, Env), St1}.
+
+%% Transforming function applications
+
+transform_application(T, Env, St) ->
+    %% We transform the arguments first, so we can concentrate on the
+    %% application itself after that point.
+    {As, St1} = transform_list(
+		  erl_syntax:application_arguments(T),
+		  Env, St),
+    F = erl_syntax:application_operator(T),
+
+    %% See if the operator is an explicit function name.
+    %% (Usually, this will be the case.)
+    case catch {ok, erl_syntax_lib:analyze_function_name(F)} of
+	{ok, Name} ->
+	    transform_application_1(Name, F, As, T, Env, St1);
+	syntax_error ->
+	    %% Oper is not a function name, but might be any other
+	    %% expression - we just visit it and reassemble the
+	    %% application.
+	    %% We do not handle applications of tuples `{M, F}'.
+	    {F1, St2} = transform(F, Env, St1),
+	    {rewrite(T, erl_syntax:application(F1, As)), St2};
+	{'EXIT', R} ->
+	    exit(R);
+	R ->
+	    throw(R)
+    end.
+
+%% At this point we should have an explicit function name, which might
+%% or might not be qualified by a module name.
+
+transform_application_1(Name, F, As, T, Env, St) ->
+    %% Before doing anything else, we must unfold any uses of aliases
+    %% whose definitions have been killed.
+    Arity = length(As),
+    {Name1, F1} = expand_operator(Name, Arity, F, Env),
+    F2 = maybe_modified_quiet(F1, F, 7, ["unfolded alias"], Env),
+    {V, St1} = transform_application_2(Name1, Arity, F2, As, Env,
+				       St),
+    T1 = rewrite(T, erl_syntax:application(F2, As)),
+    T3 = case V of
+	     none ->
+		 T1;
+	     {value, {T2, Depth, Message}} ->
+		 maybe_modified_quiet({value, T2}, T1, Depth,
+				      Message, Env)
+	 end,
+    {T3, St1}.
+
+%% Here, Name has been expanded if necessary (if so, this is also
+%% reflected by F), and As have been transformed. We should return
+%% `{none, State}' if no further rewriting is necessary, and otherwise
+%% `{{value, {Tree, Depth, Message}}, State}', where `Depth' and
+%% `Message' are to be passed to `maybe_modified'.
+
+transform_application_2(Name, Arity, F, As, Env, St)
+  when is_atom(Name) ->
+    transform_atom_application(Name, Arity, F, As, Env, St);
+transform_application_2({M, N}, Arity, F, As, Env, St)
+  when is_atom(M), is_atom(N) ->
+    transform_qualified_application(M, N, Arity, F, As, Env, St);
+transform_application_2(_Name, _Arity, _F, _As, _Env, St) ->
+    {none, St}.    % strange name - do nothing.
+
+expand_operator(Name, Arity, _F, Env) when is_atom(Name) ->
+    %% An unqualified function name - must be looked up. However, we
+    %% must first check that it is not an auto-imported name - these
+    %% have precedence over normal imports. We do a sanity check on the
+    %% found arity.
+    case is_auto_import({Name, Arity}) of
+	true ->
+	    {Name, none};    % auto-import - never expand.
+	false ->
+	    case dict:find({Name, Arity}, Env#code.expand) of
+		{ok, {M, {N, A}}} when A =:= Arity ->
+		    %% Expand to a qualified name.
+		    F1 = erl_syntax:module_qualifier(
+			   erl_syntax:atom(M),
+			   erl_syntax:atom(N)),
+		    {{M, N}, {value, F1}};
+		error ->
+		    %% Not in the table - leave it unchanged
+		    {Name, none}
+	    end
+    end;
+expand_operator(Name, _Arity, _F, _Env) ->
+    %% Qualified function name - leave it unchanged
+    {Name, none}.
+
+%% Transforming an application of a named function without module
+%% qualifier (often misleadingly called "local" applications). Note that
+%% since the `apply', `spawn' and `spawn_link' functions are implicitly
+%% imported (from module `erlang'), applications of these names cannot
+%% refer to functions defined in the source code.
+
+transform_atom_application(Name, Arity, F, As, Env, St) ->
+    %% Catch applications of `apply' and `spawn'.
+    case {Name, Arity} of
+	{'apply', 2} ->
+	    warning_apply_2(Env#code.module, Env#code.target),
+	    {none, St};
+	{'apply', 3} ->
+	    transform_apply_call(F, As, Env, St);
+	{'spawn', 3} ->
+	    transform_spawn_call(F, As, Env, St);
+	{'spawn', 4} ->
+	    transform_spawn_call(F, As, Env, St);
+	{'spawn_link', 3} ->
+	    transform_spawn_call(F, As, Env, St);
+	{'spawn_link', 4} ->
+	    transform_spawn_call(F, As, Env, St);
+	_ ->
+	    %% A simple call of an unqualified function name - just
+	    %% remap the name as necessary. Auto-imported names may not
+	    %% be changed - the call never refers to a local function.
+	    %% We do a sanity check on the arity.
+	    case is_auto_import({Name, Arity}) of
+		true ->
+		    {none, St};    % auto-import - do not change.
+		false ->
+		    case (Env#code.map)({Name, Arity}) of
+			{N, A} when N =:= Name, A =:= Arity ->
+			    %% Not changed.
+			    {none, St};
+			{N, A} when A =:= Arity ->
+			    %% The callee (in the current module)
+			    %% was renamed.
+			    F1 = rewrite(F, erl_syntax:atom(N)),
+			    T = erl_syntax:application(F1, As),
+			    V = {T, 2, ["callee was renamed"]},
+			    {{value, V}, St}
+		    end
+	    end
+    end.
+
+%% Transforming an application of an explicitly named function qualified
+%% with an (also explicit) module name. (Often called "remote"
+%% applications.)
+
+transform_qualified_application(Module, Name, Arity, F, As, Env, St) ->
+    %% Catch applications of `apply' and `spawn'.
+    case {Module, Name, Arity} of
+	{'erlang', 'apply', 2} ->
+	    warning_apply_2(Env#code.module, Env#code.target),
+	    {none, St};
+	{'erlang', 'apply', 3} ->
+	    transform_apply_call(F, As, Env, St);
+	{'erlang', 'spawn', 3} ->
+	    transform_spawn_call(F, As, Env, St);
+	{'erlang', 'spawn', 4} ->
+	    transform_spawn_call(F, As, Env, St);
+	{'erlang', 'spawn_link', 3} ->
+	    transform_spawn_call(F, As, Env, St);
+	{'erlang', 'spawn_link', 4} ->
+	    transform_spawn_call(F, As, Env, St);
+	_ ->
+	    case erlang:is_builtin(Module, Name, Arity) of
+		false ->
+		    transform_qualified_application_1(
+		      Module, Name, Arity, F, As, Env, St);
+		true ->
+		    {none, St}
+	    end
+    end.
+
+transform_qualified_application_1(Module, Name, Arity, F, As, Env,
+				  St) ->
+    MakeLocal = fun (N) ->
+			F1 = rewrite(F, erl_syntax:atom(N)),
+			erl_syntax:application(F1, As)
+		end,
+    MakeRemote = fun () ->
+			 erl_syntax:application(F, As)
+		 end,
+    MakeDynamic = fun(M, N) ->
+			  F1 = erl_syntax:module_qualifier(
+				 erl_syntax:atom(M),
+				 erl_syntax:atom(N)),
+			  F2 = rewrite(F, F1),
+			  erl_syntax:application(F2, As)
+		  end,
+    localise(Module, Name, Arity, MakeLocal, MakeRemote,
+	     MakeDynamic, 3, Env, St).
+
+%% For an `apply/3' call, if we know the called module and function
+%% names, and the number of arguments, then we can rewrite it to a
+%% direct remote call - and if we do not, there is nothing we can
+%% change.
+
+transform_apply_call(F, As, Env, St) ->
+    [Module, Name, List] = As,
+    case (erl_syntax:type(Module) =:= atom)
+	and (erl_syntax:type(Name) =:= atom)
+	and erl_syntax:is_proper_list(List) of
+	true ->
+	    transform_apply_call_1(Module, Name, List, F, As, Env,
+				   St);
+	false ->
+	    %% We can't get enough information about the
+	    %% arguments to the `apply' call, so we do nothing
+	    %% but warn.
+	    warning_unsafe_call(apply, Env#code.module,
+				Env#code.target),
+	    {none, St}
+    end.
+
+%% Rewrite the apply-call to a static qualified call and handle that
+%% instead.
+
+transform_apply_call_1(Module, Name, List, F, _As, Env, St) ->
+    F1 = rewrite(F, erl_syntax:module_qualifier( Module, Name)),
+    As1 = erl_syntax:list_elements(List),
+    M = erl_syntax:atom_value(Module),
+    N = erl_syntax:atom_value(Name),
+    A = length(As1),
+    transform_qualified_application_1(M, N, A, F1, As1, Env, St).
+
+%% `spawn' and `spawn_link' (with arity 3 or 4) are very much like
+%% `apply/3', but there could be an extra `Node' argument. Note that `F'
+%% below can represent both `spawn' and `spawn_link'.
+
+transform_spawn_call(F, As, Env, St) ->
+    case As of
+	[Module, Name, List] ->
+	    MakeSpawn = fun (As1) ->
+				erl_syntax:application(F, As1)
+			end,
+	    transform_spawn_call_1(Module, Name, List, MakeSpawn,
+				   Env, St);
+	[Node, Module, Name, List] ->
+	    MakeSpawn = fun (As1) ->
+				erl_syntax:application(
+				  F, [Node | As1])
+			end,
+	    transform_spawn_call_1(Module, Name, List, MakeSpawn,
+				   Env, St)
+    end.
+
+%% Here, we can treat all dynamic-lookup spawns like `spawn/3'.
+
+transform_spawn_call_1(Module, Name, List, MakeSpawn, Env, St) ->
+    case (erl_syntax:type(Module) =:= atom)
+	and (erl_syntax:type(Name) =:= atom)
+	and erl_syntax:is_proper_list(List)
+	of
+	true ->
+	    transform_spawn_call_2(Module, Name, List, MakeSpawn,
+				   Env, St);
+	_ ->
+	    %% We can't get enough information about the arguments to
+	    %% the `spawn' call, so we do nothing but warn.
+	    warning_unsafe_call(spawn, Env#code.module,
+				Env#code.target),
+	    {none, St}
+    end.
+
+transform_spawn_call_2(Module, Name, List, MakeSpawn, Env, St) ->
+    As = erl_syntax:list_elements(List),
+    Arity = length(As),
+    MakeLocal = fun (N) ->
+			%% By using `spawn-a-fun', we do not have to
+			%% force the callee to be exported.
+			A = rewrite(Name, erl_syntax:atom(N)),
+			B = erl_syntax:application(A, As),
+			C = erl_syntax:clause([], [B]),
+			F = erl_syntax:fun_expr([C]),
+			MakeSpawn([F])
+		end,
+    MakeRemote = fun () ->
+			 MakeSpawn([Module, Name, List])
+		 end,
+    MakeDynamic = fun (M, N) ->
+			  F = rewrite(Name, erl_syntax:atom(N)),
+			  MakeSpawn([erl_syntax:atom(M), F, List])
+		  end,
+    localise(erl_syntax:atom_value(Module),
+	     erl_syntax:atom_value(Name),
+	     Arity, MakeLocal, MakeRemote, MakeDynamic,
+	     4, Env, St).
+
+%% MakeLocal = (atom()) -> syntaxTree()
+%% MakeRemote = () -> syntaxTree()
+%% MakeDynamic = (atom(), atom()) -> syntaxTree()
+%% localise(...) -> {none, state()} | {{value, V}, State}
+
+localise(Module, Name, Arity, MakeLocal, MakeRemote, MakeDynamic,
+	 Depth, Env, St) ->
+    %% Is the callee in one of the source modules?
+    case sets:is_element(Module, Env#code.sources) of
+	false ->
+	    case dict:find(Module, Env#code.redirect) of
+		{ok, Module1} ->
+		    T = MakeDynamic(Module1, Name),
+		    V = {T, Depth, ["redirected call"]},
+		    {{value, V}, St};
+		error ->
+		    {none, St}    % Nothing needs doing.
+	    end;
+	true ->
+	    %% Remap the name of the callee, as necessary. Do a sanity
+	    %% check on the arity.
+	    Map = (Env#code.renaming)(Module),
+	    Name1 = case Map({Name, Arity}) of
+			{N, A} when A =:= Arity ->
+			    N
+		    end,
+
+	    %% See if the callee module is "safe" and/or "static".
+	    Safe = sets:is_element(Module, Env#code.safe),
+	    Static = (sets:is_element(Module, Env#code.static)
+		      or Safe),
+
+	    %% Select what kind of code to generate for the call:
+	    case Static of
+		false ->
+		    %% (This also implies that the called module is not
+		    %% the target module - which is always "static" -
+		    %% and that it is not "safe".) The called module
+		    %% could be replaced dynamically, independent of the
+		    %% target module, so we must protect the localised
+		    %% call. We strip all comments from the localised
+		    %% code, to avoid getting the same comments twice.
+		    L = MakeLocal(Name1),
+		    L1 = erl_syntax_lib:strip_comments(L),
+		    R = MakeRemote(),
+		    {T, Text} = protect_call(Module, L1, R),
+		    V = {T, Depth, Text},
+		    {{value, V}, St};
+		true ->
+		    %% In this case, the called module is never replaced
+		    %% unless the target module also is. (N.B.: These
+		    %% might be the same module.)
+		    case Safe of
+			false ->
+			    %% The normal code replacement semantics
+			    %% must be preserved here, so the generated
+			    %% call must be qualified with the name of
+			    %% the target module. (We assume this is
+			    %% efficiently compiled even if we do not
+			    %% insert an explicit "latest version"
+			    %% test.)
+			    Target = Env#code.target,
+			    case Module =:= Target of
+				true ->
+				    %% Already calling the target module
+				    %% - do not insert irritating notes.
+				    {none, St};
+				false ->
+				    %% We must ensure that the function
+				    %% is exported.
+				    St1 = state__add_export(Name1,
+							    Arity, St),
+				    T = MakeDynamic(Target, Name1),
+				    Text = ["localised call"],
+				    V = {T, Depth, Text},
+				    {{value, V}, St1}
+			    end;
+			true ->
+			    %% The call is regarded as safe to localise
+			    %% completely. Code replacement will in
+			    %% general not be detected (except for
+			    %% spawn/apply).
+			    T = MakeLocal(Name1),
+			    Text = ["localised safe call"],
+			    V = {T, Depth, Text},
+			    {{value, V}, St}
+		    end
+	    end
+    end.
+
+%%% %% This creates a test on whether there is a later loaded version of
+%%% %% Module: if not, select the `Local' expression, otherwise the `Remote'
+%%% %% expression. We knowingly duplicate code here, to allow better
+%%% %% optimisations, but we never duplicate work.
+%%%
+%%% protect_call(Module, Local, Remote) ->
+%%%     T = erl_syntax:if_expr(
+%%% 	  [erl_syntax:clause([erl_syntax:application(
+%%% 				erl_syntax:atom('not_replaced'),
+%%% 				[erl_syntax:atom(Module)])],
+%%% 			     [Local]),
+%%% 	   erl_syntax:clause([erl_syntax:atom('true')],
+%%% 			     [Remote])]),
+%%%     {T, ["localised dynamic call"]}.
+
+%% This "protects" a localised call by letting it remain a remote call.
+
+protect_call(_Module, _Local, Remote) ->
+    {Remote, ["dynamic call"]}.
+
+%% Renaming record declarations
+
+transform_attribute(T, Env, St) ->
+    {T1, St1} = TSt1 = default_transform(T, Env, St),
+    case erl_syntax_lib:analyze_attribute(T1) of
+	{record, {R, _}} ->
+	    F = fun(R) ->
+			[_ | As] = erl_syntax:attribute_arguments(T1),
+			erl_syntax:attribute(
+			  erl_syntax:attribute_name(T1),
+			  [erl_syntax:atom(R) | As])
+		end,
+	    {V, Text} = rename_record(R, F, Env),
+	    {maybe_modified(V, T1, 2, Text, Env), St1};
+	_ ->
+	    TSt1
+    end.
+
+%% This handles renaming of records.
+
+transform_record(T, Env, St) ->
+    {T1, St1} = TSt1 = default_transform(T, Env, St),
+    X = case catch erl_syntax_lib:analyze_record_expr(T1) of
+	    {record_expr, {R, _}} ->
+		F = fun (R) ->
+			    erl_syntax:record_expr(
+			      erl_syntax:record_expr_argument(T1),
+			      erl_syntax:atom(R),
+			      erl_syntax:record_expr_fields(T1))
+		    end,
+		{R, F};
+	    {record_index_expr, {R, _}} ->
+		F = fun (R) ->
+			    erl_syntax:record_index_expr(
+			      erl_syntax:atom(R),
+			      erl_syntax:record_index_expr_field(T1))
+		    end,
+		{R, F};
+	    {record_access, {R, _}} ->
+		F = fun (R) ->
+			    erl_syntax:record_access(
+			      erl_syntax:record_access_argument(T1),
+			      erl_syntax:atom(R),
+			      erl_syntax:record_access_field(T1))
+		    end,
+		{R, F};
+	    _Type ->
+		false
+	end,
+    case X of
+	{R1, F1} ->
+	    {V, Text} = rename_record(R1, F1, Env),
+	    {maybe_modified(V, T1, 1, Text, Env), St1};
+	false ->
+	    TSt1
+    end.
+
+rename_record(R, F, Env) ->
+    case map_record_name(R, Env#code.map) of
+	R ->
+	    %% Not renamed
+	    {none, []};
+	R1 ->
+	    %% Renamed
+	    {{value, F(R1)}, ["record was renamed"]}
+    end.
+
+%% Maybe-rewriting Node, adding modification notes.
+
+%% This is for non-primary modifications; they are not commented unless
+%% the `notes' option is set to `always'.
+
+maybe_modified_quiet(V, Node, Depth, Message, Env) ->
+    case Env#code.notes of
+	always ->
+	    maybe_modified_1(V, Node, Depth, Message, yes);
+	_ ->
+	    maybe_modified_1(V, Node, Depth, Message, no)
+    end.
+
+%% This is for important notes; they are only disabled if the `notes'
+%% option is set to `no'.
+
+maybe_modified(V, Node, Depth, Message, Env) ->
+    maybe_modified_1(V, Node, Depth, Message, Env#code.notes).
+
+maybe_modified_1(none, Node, _Depth, _Message, _Notes) ->
+    Node;
+maybe_modified_1({value, Node1}, Node, Depth, Message, Notes) ->
+    case Notes of
+	no ->
+	    rewrite(Node, Node1);
+	_ ->
+	    Code = erl_syntax:comment_text(
+		     erl_syntax_lib:to_comment(
+		       erl_syntax_lib:strip_comments(
+			 erl_syntax_lib:limit(Node, Depth)),
+		       "\040\040")),
+	    erl_syntax:add_precomments(
+	      [comment_note(Message ++
+			    ["Original code:" | Code])],
+	      rewrite(Node, Node1))
+    end.
+
+
+%% =====================================================================
+%% @spec create_stubs(Stubs::[stubDescriptor()], Options::[term()]) ->
+%%           [string()]
+%%
+%% @doc Creates stub module source files corresponding to the given stub
+%% descriptors. The returned value is the list of names of the created
+%% files. See `merge_sources/3' for more information about
+%% stub descriptors.
+%%
+%% Options:
+%% <dl>
+%%   <dt>`{backup_suffix, string()}'</dt>
+%%   <dt>`{backups, bool()}'</dt>
+%%   <dt>`{printer, Function}'</dt>
+%%   <dt>`{stub_dir, filename()}'</dt>
+%%   <dt>`{suffix, string()}'</dt>
+%%   <dt>`{verbose, bool()}'</dt>
+%% </dl>
+%% 
+%% See `merge/3' for details on these options.
+%%
+%% @see merge/3
+%% @see merge_sources/3
+
+create_stubs(Stubs, Opts) ->
+    Opts1 = Opts ++ ?DEFAULT_MERGE_OPTS,
+    lists:foldl(fun (S, Fs) ->
+			F = create_stub(S, Opts1),
+			[F | Fs]
+		end,
+		[], Stubs).
+
+maybe_create_stubs(Stubs, Opts) ->
+    case proplists:get_bool(stubs, Opts) of
+	true ->
+	    create_stubs(Stubs, Opts);
+	false ->
+	    []
+    end.
+
+create_stub({Name, Fs, Attrs}, Opts) ->
+    Defs = [stub_function(F) || F <- Fs],
+    Exports = [F || {F, _} <- Fs],
+    Forms = stub_header(Name, Exports, Attrs) ++ Defs,
+    Dir = proplists:get_value(stub_dir, Opts, ""),
+    verbose("creating stub file for module `~w'.", [Name], Opts),
+    write_module(erl_syntax:form_list(Forms), Name, Dir, Opts).
+
+%% We just follow the arity specifications naively when we create the
+%% stub funcion - it is not our responsibility to check them.
+
+stub_function({{F, A}, {M, {F1, A1}}}) ->
+    Vs = var_list(A),
+    Vs1 = var_list(A1),
+    R = erl_syntax:module_qualifier(erl_syntax:atom(M),
+				    erl_syntax:atom(F1)),
+    Call = erl_syntax:application(R, Vs1),
+    erl_syntax:function(erl_syntax:atom(F),
+			[erl_syntax:clause(Vs, [], [Call])]).
+
+var_list(N) ->
+    var_list(N, 1).
+
+var_list(N, I) when N > 0 ->
+    [erl_syntax:variable("X" ++ integer_to_list(I))
+     | var_list(N - 1, I + 1)];
+var_list(0, _) ->
+    [].
+
+stub_header(Name, Exports, Attrs) ->
+    [comment([?COMMENT_BAR,
+	      io_lib:fwrite("This is an automatically "
+			    "generated stub interface\n"
+			    "for the module `~w'.",
+			    [Name]),
+	      "",
+	      timestamp(),
+	      ""]),
+     erl_syntax:attribute(erl_syntax:atom('module'),
+			  [erl_syntax:atom(Name)]),
+     make_export(Exports)]
+	++ make_attributes(Attrs).
+
+
+%% =====================================================================
+%% @spec rename(Files::[filename()], Renamings) -> [string()]
+%% @equiv rename(Files, Renamings, [])
+
+rename(Files, Renamings) ->
+    rename(Files, Renamings, []).
+
+%% =====================================================================
+%% @spec rename(Files::[filename()], Renamings, Options::[term()]) ->
+%%           [string()]
+%%
+%%     Renamings = [{atom(), atom()}]
+%%
+%% @doc Renames a set of possibly interdependent source code modules.
+%% `Files' is a list of file names of source modules to be
+%% processed. `Renamings' is a list of pairs of <em>module
+%% names</em>, representing a mapping from old names to new. The
+%% returned value is the list of output file names.
+%%
+%% Each file in the list will be read and processed separately. For
+%% every file, each reference to some module M, such that there is an
+%% entry `{<em>M</em>, <em>M1</em>}' in
+%% `Renamings', will be changed to the corresponding M1.
+%% Furthermore, if a file F defines module M, and there is an entry
+%% `{<em>M</em>, <em>M1</em>}' in `Renamings', a
+%% new file named `<em>M1</em>.erl' will be created in the
+%% same directory as F, containing the source code for module M, renamed
+%% to M1. If M does not have an entry in `Renamings', the
+%% module is not renamed, only updated, and the resulting source code is
+%% written to `<em>M</em>.erl' (typically, this overwrites
+%% the original file). The `suffix' option (see below) can be
+%% used to change the default "`.erl'" suffix for the
+%% generated files.
+%%
+%% Stub modules will automatically be created (see the
+%% `stubs' and `stub_dir' options below) for each
+%% module that is renamed. These can be used to redirect any calls still
+%% using the old module names. The stub files are created in the same
+%% directory as the source file (typically overwriting the original
+%% file).
+%%
+%% Options:
+%% <dl>
+%%   <dt>`{backup_suffix, string()}'</dt>
+%%   <dt>`{backups, bool()}'</dt>
+%%   <dt>`{printer, Function}'</dt>
+%%   <dt>`{stubs, bool()}'</dt>
+%%   <dt>`{suffix, string()}'</dt>
+%% </dl>
+%% See `merge/3' for details on these options.
+%%
+%% <dl>
+%%   <dt>`{comments, bool()}'</dt>
+%%   <dt>`{preprocess, bool()}'</dt>
+%% </dl>
+%% See `merge_files/4' for details on these options.
+%%
+%% <dl>
+%%   <dt>`{no_banner, bool()}'</dt>
+%% </dl>
+%% For the `rename' function, this option is
+%% `true' by default. See `merge_sources/3' for
+%% details.
+%%
+%% <dl>
+%%   <dt>`{tidy, bool()}'</dt>
+%% </dl>
+%% For the `rename' function, this option is
+%% `false' by default. See `merge_sources/3' for
+%% details.
+%%
+%% <dl>
+%%   <dt>`{no_headers, bool()}'</dt>
+%%   <dt>`{stub_dir, filename()}'</dt>
+%% </dl>
+%% These options are preset by the `rename' function and
+%% cannot be overridden by the user.
+%%
+%% See `merge_sources/3' for further options.
+%%
+%% @see merge/3
+%% @see merge_sources/3
+%% @see merge_files/4
+
+rename(Files, Renamings, Opts) ->
+    Dict = case is_atom_map(Renamings) of
+	       true ->
+		   dict:from_list(Renamings);
+	       false ->
+		   report_error("bad module renaming: ~P.",
+				[Renamings, 10]),
+		   exit(error)
+	   end,
+    %% We disable *all* automatic source code lookup, for safety: you
+    %% are only allowed to do renaming on a module if you give its path.
+    Opts1 = [{find_src_rules, []}]
+	++ Opts ++ [{backup_suffix, ?DEFAULT_BACKUP_SUFFIX},
+		    backups, 
+		    {printer, fun default_printer/2},
+		    stubs,
+		    {suffix, ?DEFAULT_SUFFIX},
+		    comments, 
+		    {preprocess, false},
+		    {tidy, false},
+		    no_banner,
+		    {notes, no},
+		    {verbose, false}],
+    lists:flatmap(fun (F) -> rename_file(F, Dict, Opts1) end, Files).
+
+rename_file(File, Dict, Opts) ->
+    S = read_module(File, Opts),
+    M = get_module_info(S),
+    Name = M#module.name,
+    Name1 = case dict:find(Name, Dict) of
+		{ok, N} -> N;
+		error -> Name
+	    end,
+    %% We convert the dictionary to a new list to ensure that we use the
+    %% exact same renaming for redirections. We must remove the current
+    %% module from the redirection set.
+    Dict1 = dict:erase(Name, Dict),
+    Opts1 = [no_headers,
+	     {export, [Name]},
+	     {static, [Name]},
+	     {redirect, dict:to_list(Dict1)}] ++ Opts,
+    {Tree, Stubs} = merge_sources(Name1, [S], Opts1),
+    Dir = filename:dirname(filename(File)),
+    File1 = write_module(Tree, Name1, Dir, Opts),
+
+    %% We create the stub file in the same directory as the source file
+    %% and the target file.
+    [File1 | maybe_create_stubs(Stubs, [{stub_dir, Dir} | Opts1])].
+
+
+%% ---------------------------------------------------------------------
+%% Initialise a module-info record with data about the module
+%% represented by the syntax tree (or list of "forms"). Listed exports
+%% are guaranteed to be in the set of function names.
+
+get_module_info(Forms) ->
+    L = case catch {ok, erl_syntax_lib:analyze_forms(Forms)} of
+	    {ok, L1} ->
+		L1;
+	    syntax_error ->
+		report_error("syntax error in input."),
+		erlang:error(badarg);
+	    {'EXIT', R} ->
+		exit(R);
+	    R ->
+		throw(R)
+	end,
+    {Name, Vars} =
+	case lists:keyfind(module, 1, L) of
+	    {module, {_N, _Vs} = NVs} ->
+		NVs;
+	    {module, N} ->
+		{N, none};
+	    false ->
+		report_error("in source code: module name missing."),
+		exit(error)
+	end,
+    case lists:keyfind(errors, 1, L) of
+	{errors, Ds} when Ds =/= [] ->
+	    report_errors(Ds, Name),
+	    exit(error);
+	_ ->
+	    ok
+    end,
+    case lists:keyfind(warnings, 1, L) of
+	{warnings, Ds1} when Ds1 =/= [] ->
+	    report_warnings(Ds1, Name); 
+	_ ->
+	    ok
+    end,
+    Functions = case lists:keyfind(functions, 1, L) of
+		    {functions, Fs} ->
+			ordsets:from_list(Fs);
+		    _ ->
+			[]
+		end,
+    Exports = case lists:keyfind(exports, 1, L) of
+		  {exports, Es} ->
+		      ordsets:from_list(Es);
+		  _ ->
+		      []
+	      end,
+    Imports = case lists:keyfind(imports, 1, L) of
+		  {imports, Is} ->
+		      expand_imports(Is, Name);
+		  _ ->
+		      []
+	      end,
+    Attributes = case lists:keyfind(attributes, 1, L) of
+		     {attributes, As} ->
+			 ordsets:from_list(As);
+		     _ ->
+			 []
+		 end,
+    Records = case lists:keyfind(records, 1, L) of
+		  {records, Rs} ->
+		      fold_record_fields(Rs);
+		  _ ->
+		      []
+	      end,
+    check_records(Records, Name),
+    #module{name = Name,
+	    vars = Vars,
+	    functions = Functions,
+	    exports = ordsets:intersection(Exports, Functions),
+	    aliases = Imports,
+	    attributes = Attributes,
+	    records = Records}.
+
+fold_record_fields(Rs) ->
+    [{N, [fold_record_field(F) || F <- Fs]} || {N, Fs} <- Rs].
+
+fold_record_field({_Name, none} = None) ->
+    None;
+fold_record_field({Name, F}) ->
+    case erl_syntax:is_literal(F) of
+	true ->
+	    {Name, {value, erl_syntax:concrete(F)}};
+	false ->
+	    %% The default value for the field is not a constant, so we
+	    %% represent it by a hash value instead. (We don't want to
+	    %% do this in the general case.)
+	    {Name, {hash, erlang:phash(F, 16#ffffff)}}
+    end.
+
+report_errors([D | Ds], Name) ->
+    report_error("error: " ++ error_text(D, Name)),
+    report_errors(Ds, Name);
+report_errors([], _) ->
+    ok.
+
+report_warnings([D | Ds], Name) ->
+    report_warning(error_text(D, Name)),
+    report_errors(Ds, Name);
+report_warnings([], _) ->
+    ok.
+
+error_text(D, Name) ->
+    case D of
+	{L, M, E} when is_integer(L), is_atom(M) ->
+	    case catch M:format_error(E) of
+		S when is_list(S) ->
+		    io_lib:fwrite("`~w', line ~w: ~s.",
+				  [Name, L, S]);
+		_ ->
+		    error_text_1(D, Name)
+	    end;
+	_E ->
+	    error_text_1(D, Name)
+    end.
+
+error_text_1(D, Name) ->
+    io_lib:fwrite("error: `~w', ~P.", [Name, D, 15]).
+
+check_records(Rs, Name) ->
+    case duplicates([N || {N, _} <- Rs]) of
+	[] ->
+	    ok;
+	Ns ->
+	    report_error("in module `~w': "
+			 "multiply defined records: ~p.",
+			 [Name, Ns]),
+	    exit(error)
+    end.
+
+expand_imports(Is, Name) ->
+    Fs = ordsets:from_list(lists:append([[{M, F} || F <- Fs]
+					 || {M, Fs} <- Is])),
+    As = erl_syntax_lib:function_name_expansions(Fs),
+    case duplicates([N || {N, _} <- As]) of
+	[] ->
+	    ordsets:from_list(As);
+	Ns ->
+	    report_error("in module `~w': "
+			 "multiply imported functions: ~p.",
+			 [Name, Ns]),
+	    exit(error)
+    end.
+
+
+%% ---------------------------------------------------------------------
+%% File handling
+
+%% open_output_file(filename()) -> filedescriptor()
+
+open_output_file(FName) ->
+    case catch file:open(FName, [write]) of
+	{ok, FD} ->
+	    FD;
+	{error, _} = Error ->
+	    error_open_output(FName),
+	    exit(Error);
+	{'EXIT', R} ->
+	    error_open_output(FName),
+	    exit(R);
+	R ->
+	    error_open_output(FName),
+	    exit(R)
+    end.
+
+%% read_module(Name, Options) -> syntaxTree()
+%%
+%% This also tries to locate the real source file, if "Name" does not
+%% point directly to a particular file.
+
+read_module(Name, Options) ->
+    case file_type(Name) of
+	{value, _} ->
+	    read_module_1(Name, Options);
+	none ->
+	    Rules = proplists:get_value(find_src_rules, Options),
+	    case find_src(Name, Rules) of
+		{error, _} ->
+		    %% It seems that we have no file - go on anyway,
+		    %% just to get a decent error message.
+		    read_module_1(Name, Options);
+		{Name1, _} ->
+		    read_module_1(Name1 ++ ".erl", Options)
+	    end
+    end.
+
+read_module_1(Name, Options) ->
+    verbose("reading module `~s'.", [filename(Name)], Options),
+    Forms = read_module_2(Name, Options),
+    case proplists:get_bool(comments, Options) of
+	false ->
+	    Forms;
+	true ->
+	    Comments = erl_comment_scan:file(Name),
+	    erl_recomment:recomment_forms(Forms, Comments)
+    end.
+
+read_module_2(Name, Options) ->
+    case read_module_3(Name, Options) of
+	{ok, Forms} ->
+	    check_forms(Forms, Name), 
+	    Forms;
+	{error, _} = Error ->
+	    error_read_file(Name),
+	    exit(Error)
+    end.
+
+read_module_3(Name, Options) ->
+    case proplists:get_bool(preprocess, Options) of
+	false ->
+	    epp_dodger:parse_file(Name);
+	true ->
+	    read_module_4(Name, Options)
+    end.
+
+read_module_4(Name, Options) ->
+    Includes = proplists:append_values(includes, Options)
+	++ [filename:dirname(Name) | ?DEFAULT_INCLUDES],
+    Macros = proplists:append_values(macros, Options)
+	++ ?DEFAULT_MACROS,
+    epp:parse_file(Name, Includes, Macros).
+
+check_forms([F | Fs], File) ->
+    case erl_syntax:type(F) of
+	error_marker ->
+	    S = case erl_syntax:error_marker_info(F) of
+		    {_, M, D} ->
+			M:format_error(D);
+		    _ ->
+			"unknown error"
+		end,
+	    report_error("in file `~s' at line ~w:\n  ~s",
+			 [filename(File), erl_syntax:get_pos(F), S]),
+	    exit(error);
+	_ ->
+	    check_forms(Fs, File)
+    end;
+check_forms([], _) ->
+    ok.
+
+find_src(Name, undefined) ->
+    filename:find_src(filename(Name));
+find_src(Name, Rules) ->
+    filename:find_src(filename(Name), Rules).
+
+%% file_type(filename()) -> {value, Type} | none
+
+file_type(Name) ->
+    case catch file:read_file_info(Name) of
+	{ok, Env} ->
+	    {value, Env#file_info.type};
+	{error, enoent} ->
+	    none;
+	{error, _} = Error ->
+	    error_read_file_info(Name),
+	    exit(Error);
+	{'EXIT', R} ->
+	    error_read_file_info(Name),
+	    exit(R);
+	R ->
+	    error_read_file_info(Name),
+	    throw(R)
+    end.
+
+%% Create the target directory and make a backup file if necessary, then
+%% open the file, output the text and close the file safely. Returns the
+%% file name.
+
+write_module(Tree, Name, Dir, Opts) ->
+    Name1 = filename(Name),
+    Dir1 = filename(Dir),
+    Base = if Dir1 =:= "" ->
+		   Name1;
+	      true ->
+		   case file_type(Dir1) of
+		       {value, directory} ->
+			   ok;
+		       {value, _} ->
+			   report_error("`~s' is not a directory.",
+					[Dir1]),
+			   exit(error);
+		       none ->
+			   case file:make_dir(Dir1) of
+			       ok ->
+				   verbose("created directory `~s'.",
+					   [Dir1], Opts),
+				   ok;
+			       E ->
+				   report_error("failed to create "
+						"directory `~s'.",
+						[Dir1]),
+				   exit({make_dir, E})
+			   end
+		   end,
+		   filename:join(Dir1, Name1)
+	   end,
+    Suffix = proplists:get_value(suffix, Opts, ""),
+    File = Base ++ Suffix,
+    case proplists:get_bool(backups, Opts) of
+	true ->
+	    backup_file(File, Opts);
+	false ->
+	    ok
+    end,
+    Printer = proplists:get_value(printer, Opts),
+    FD = open_output_file(File),
+    verbose("writing to file `~s'.", [File], Opts),
+    V = (catch {ok, output(FD, Printer, Tree, Opts)}),
+    ok = file:close(FD),
+    case V of
+	{ok, _} ->
+	    File;
+	{'EXIT', R} ->
+	    error_write_file(File),
+	    exit(R);
+	R ->
+	    error_write_file(File),
+	    throw(R)
+    end.
+
+output(FD, Printer, Tree, Opts) ->
+    io:put_chars(FD, Printer(Tree, Opts)),
+    io:nl(FD).
+
+%% If the file exists, rename it by appending the given suffix to the
+%% file name.
+
+backup_file(Name, Opts) ->
+    case file_type(Name) of
+	{value, regular} ->
+	    backup_file_1(Name, Opts);
+	{value, _} ->
+	    error_backup_file(Name),
+	    exit(error);
+	none ->
+	    ok
+    end.
+
+%% The file should exist and be a regular file here.
+
+backup_file_1(Name, Opts) ->
+    Name1 = filename(Name),
+    Suffix = proplists:get_value(backup_suffix, Opts, ""),
+    Dest = filename:join(filename:dirname(Name1),
+			 filename:basename(Name1) ++ Suffix),
+    case catch file:rename(Name1, Dest) of
+	ok ->
+	    verbose("made backup of file `~s'.", [Name1], Opts);
+	{error, R} ->
+	    error_backup_file(Name1),
+	    exit({error, R});
+	{'EXIT', R} ->
+	    error_backup_file(Name1),
+	    exit(R);
+	R ->
+	    error_backup_file(Name1),
+	    throw(R)
+    end.
+
+
+%% =====================================================================
+%% Utility functions
+
+%% The form sequence returned by 'erl_tidy:module' is flat, even if the
+%% given tree is not.
+
+tidy(Tree, Opts) ->
+    case proplists:get_bool(tidy, Opts) of
+	true ->
+	    verbose("tidying final module.", Opts),
+	    erl_tidy:module(Tree, ?TIDY_OPTS);
+	false ->
+	    Tree
+    end.
+
+make_attributes(As) ->
+    [make_attribute(A) || A <- As].
+
+make_attribute({Name, Term}) ->
+    erl_syntax:attribute(erl_syntax:atom(Name),
+			 [erl_syntax:abstract(Term)]).
+
+is_auto_import({F, A}) ->
+    erl_internal:bif(F, A);
+is_auto_import(_) ->
+    false.
+
+timestamp() ->
+    {{Yr, Mth, Dy}, {Hr, Mt, Sc}} = erlang:localtime(),
+    lists:flatten(io_lib:fwrite("Created by Igor "
+				"~w-~2.2.0w-~2.2.0w, "
+				"~2.2.0w:~2.2.0w:~2.2.0w.",
+				[Yr, Mth, Dy, Hr, Mt, Sc])).
+
+filename([C | T]) when is_integer(C), C > 0, C =< 255 ->
+    [C | filename(T)];
+filename([H|T]) ->
+    filename(H) ++ filename(T);
+filename([]) ->
+    [];
+filename(N) when is_atom(N) ->
+    atom_to_list(N);
+filename(N) ->
+    report_error("bad filename: `~P'.", [N, 25]),
+    exit(error).
+
+duplicates(Xs) ->
+    ordsets:from_list(Xs -- ordsets:from_list(Xs)).
+
+split_list(F, L) ->
+    split_list(L, F, [], []).
+
+split_list([H | T], F, A1, A2) ->
+    case F(H) of
+	true ->
+	    split_list(T, F, [H | A1], A2);
+	false ->
+	    split_list(T, F, A1, [H | A2])
+    end;
+split_list([], _, A1, A2) ->
+    {lists:reverse(A1), lists:reverse(A2)}.
+
+rewrite(Source, Target) ->
+    erl_syntax:copy_attrs(Source, Target).
+
+comment_note([L | Ls]) ->
+    comment([?NOTE_HEADER ++ L | Ls], ?NOTE_PREFIX).
+
+comment(Txt) ->
+    comment(Txt, ?COMMENT_PREFIX).
+
+comment(Txt, Prefix) ->
+    erl_syntax:comment(prefix_lines(split_lines(Txt), Prefix)).
+
+prefix_lines([L | Ls], Prefix) ->
+    [Prefix ++ L | prefix_lines(Ls, Prefix)];
+prefix_lines([], _) ->
+    [].
+
+split_lines(Ls) ->
+    split_lines(Ls, []).
+
+split_lines([L | Ls], Ls1) ->
+    split_lines(Ls, split_lines(L, [], Ls1));
+split_lines([], Ls1) ->
+    lists:reverse(Ls1).
+
+split_lines([$\r, $\n | Cs], Cs1, Ls) ->
+    split_lines_1(Cs, Cs1, Ls);
+split_lines([$\r | Cs], Cs1, Ls) ->
+    split_lines_1(Cs, Cs1, Ls);
+split_lines([$\n | Cs], Cs1, Ls) ->
+    split_lines_1(Cs, Cs1, Ls);
+split_lines([C | Cs], Cs1, Ls) ->
+    split_lines(Cs, [C | Cs1], Ls);
+split_lines([], Cs, Ls) ->
+    [lists:reverse(Cs) | Ls].
+
+split_lines_1(Cs, Cs1, Ls) ->
+    split_lines(Cs, [], [lists:reverse(Cs1) | Ls]).
+
+
+%% =====================================================================
+%% Reporting
+
+warning_unsafe_call(Name, Module, Target) ->
+    report_warning("call to `~w' in module `~w' "
+		   "possibly unsafe in `~s'.", [Name, Module, Target]).
+
+warning_apply_2(Module, Target) ->
+    report_warning("call to `apply/2' in module `~w' "
+		   "possibly unsafe in `~s'.", [Module, Target]).
+
+error_open_output(Name) ->
+    report_error("cannot open file `~s' for output.", [filename(Name)]).
+
+error_read_file(Name) ->
+    report_error("error reading file `~s'.", [filename(Name)]).
+
+error_read_file_info(Name) ->
+    report_error("error getting file info: `~s'.", [filename(Name)]).
+
+error_write_file(Name) ->
+    report_error("error writing to file `~s'.", [filename(Name)]).
+
+error_backup_file(Name) ->
+    report_error("could not create backup of file `~s'.",
+		 [filename(Name)]).
+
+verbose(S, Opts) ->
+    verbose(S, [], Opts).
+
+verbose(S, Vs, Opts) ->
+    case proplists:get_bool(verbose, Opts) of
+	true ->
+	    report(S, Vs);
+	false ->
+	    ok
+    end.
+
+report_error(S) ->
+    report_error(S, []).
+
+report_error(S, Vs) ->
+    report(S, Vs).
+
+report_warning(S) ->
+    report_warning(S, []).
+
+report_warning(S, Vs) ->
+    report("warning: " ++ S, Vs).
+
+% report(S) ->
+%     report(S, []).
+
+report(S, Vs) ->
+    io:fwrite(lists:concat([?MODULE, ": ", S, "\n"]), Vs).
+