%% =====================================================================
%% Abstract Erlang syntax trees (`erl_parse'-compatible).
%%
%% Copyright (C) 1997-2004 Richard Carlsson
%%
%% 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
%%
%% Author contact: richardc@csd.uu.se
%%
%% $Id: refac_syntax.erl,v 1.5 2008/04/30 09:28:12 hl Exp $
%%
%% Modified: 17 Jan 2007 by  Huiqing Li <hl@kent.ac.uk>
%% =====================================================================
%%
%% @doc Abstract Erlang syntax trees.
%%
%% <p> This module defines an abstract data type for representing Erlang
%% source code as syntax trees, in a way that is backwards compatible
%% with the data structures created by the Erlang standard library
%% parser module <code>erl_parse</code> (often referred to as "parse
%% trees", which is a bit of a misnomer). This means that all
%% <code>erl_parse</code> trees are valid abstract syntax trees, but the
%% reverse is not true: abstract syntax trees can in general not be used
%% as input to functions expecting an <code>erl_parse</code> tree.
%% However, as long as an abstract syntax tree represents a correct
%% Erlang program, the function <a
%% href="#revert-1"><code>revert/1</code></a> should be able to
%% transform it to the corresponding <code>erl_parse</code>
%% representation.</p>
%%
%% <p>A recommended starting point for the first-time user is the
%% documentation of the <a
%% href="#type-syntaxTree"><code>syntaxTree()</code></a> data type, and
%% the function <a href="#type-1"><code>type/1</code></a>.</p>
%%
%% <h3><b>NOTES:</b></h3>
%%
%% <p>This module deals with the composition and decomposition of
%% <em>syntactic</em> entities (as opposed to semantic ones); its
%% purpose is to hide all direct references to the data structures used
%% to represent these entities. With few exceptions, the functions in
%% this module perform no semantic interpretation of their inputs, and
%% in general, the user is assumed to pass type-correct arguments - if
%% this is not done, the effects are not defined.</p>
%%
%% <p>With the exception of the <code>erl_parse</code> data structures,
%% the internal representations of abstract syntax trees are subject to
%% change without notice, and should not be documented outside this
%% module. Furthermore, we do not give any guarantees on how an abstract
%% syntax tree may or may not be represented, <em>with the following
%% exceptions</em>: no syntax tree is represented by a single atom, such
%% as <code>none</code>, by a list constructor <code>[X | Y]</code>, or
%% by the empty list <code>[]</code>. This can be relied on when writing
%% functions that operate on syntax trees.</p>
%%
%% @type syntaxTree(). An abstract syntax tree. The
%% <code>erl_parse</code> "parse tree" representation is a subset of the
%% <code>syntaxTree()</code> representation.
%%
%% <p>Every abstract syntax tree node has a <em>type</em>, given by the
%% function <a href="#type-1"><code>type/1</code></a>. Each node also
%% has associated <em>attributes</em>; see <a
%% href="#get_attrs-1"><code>get_attrs/1</code></a> for details. The
%% functions <a href="#make_tree-2"><code>make_tree/2</code></a> and <a
%% href="#subtrees-1"><code>subtrees/1</code></a> are generic
%% constructor/decomposition functions for abstract syntax trees. The
%% functions <a href="#abstract-1"><code>abstract/1</code></a> and <a
%% href="#concrete-1"><code>concrete/1</code></a> convert between
%% constant Erlang terms and their syntactic representations. The set of
%% syntax tree nodes is extensible through the <a
%% href="#tree-2"><code>tree/2</code></a> function.</p>
%%
%% <p>A syntax tree can be transformed to the <code>erl_parse</code>
%% representation with the <a href="#revert-1"><code>revert/1</code></a>
%% function.</p>
%%
%% @end
%% =====================================================================

-module(refac_syntax).

-export([abstract/1, add_ann/2, add_postcomments/2,
	 add_precomments/2, application/2, application/3,
	 application_arguments/1, application_operator/1,
	 arity_qualifier/2, arity_qualifier_argument/1,
	 arity_qualifier_body/1, atom/1, atom_literal/1,
	 atom_name/1, atom_value/1, attribute/1, attribute/2,
	 attribute_arguments/1, attribute_name/1, binary/1,
	 binary_field/1, binary_field/2, binary_field/3,
	 binary_field_body/1, binary_field_size/1,
	 binary_field_types/1, binary_fields/1, block_expr/1,
	 block_expr_body/1, case_expr/2, case_expr_argument/1,
	 case_expr_clauses/1, catch_expr/1, catch_expr_body/1,
	 char/1, char_literal/1, char_value/1, class_qualifier/2,
	 class_qualifier_argument/1, class_qualifier_body/1,
	 clause/2, clause/3, clause_body/1, clause_guard/1,
	 clause_patterns/1, comment/1, comment/2,
	 comment_padding/1, comment_text/1, compact_list/1,
	 concrete/1, cond_expr/1, cond_expr_clauses/1,
	 conjunction/1, conjunction_body/1, cons/2, copy_ann/2,
	 copy_attrs/2, copy_comments/2, copy_pos/2, data/1,
	 disjunction/1, disjunction_body/1, eof_marker/0,
	 error_marker/1, error_marker_info/1,
	 flatten_form_list/1, float/1, float_literal/1,
	 float_value/1, form_list/1, form_list_elements/1,
	 fun_expr/1, fun_expr_arity/1, fun_expr_clauses/1,
	 function/2, function_arity/1, function_clauses/1,
	 function_name/1, generator/2, generator_body/1,
	 generator_pattern/1, get_ann/1, get_attrs/1, get_pos/1,
	 get_postcomments/1, get_precomments/1, has_comments/1,
	 if_expr/1, if_expr_clauses/1, implicit_fun/1,
	 implicit_fun/2, implicit_fun_name/1, infix_expr/3,
	 infix_expr_left/1, infix_expr_operator/1,
	 infix_expr_right/1, integer/1, integer_literal/1,
	 integer_value/1, is_atom/2, is_char/2, is_form/1,
	 is_integer/2, is_leaf/1, is_list_skeleton/1,
	 is_literal/1, is_proper_list/1, is_string/2, is_tree/1,
	 join_comments/2, list/1, list/2, list_comp/2,
	 list_comp_body/1, list_comp_template/1, list_elements/1,
	 list_head/1, list_length/1, list_prefix/1,
	 list_suffix/1, list_tail/1, macro/1, macro/2,
	 macro_arguments/1, macro_name/1, make_tree/2,
	 match_expr/2, match_expr_body/1, match_expr_pattern/1,
	 meta/1, module_qualifier/2, module_qualifier_argument/1,
	 module_qualifier_body/1, nil/0, normalize_list/1,
	 operator/1, operator_literal/1, operator_name/1,
	 parentheses/1, parentheses_body/1, prefix_expr/2,
	 prefix_expr_argument/1, prefix_expr_operator/1,
	 qualified_name/1, qualified_name_segments/1,
	 query_expr/1, query_expr_body/1, receive_expr/1,
	 receive_expr/3, receive_expr_action/1,
	 receive_expr_clauses/1, receive_expr_timeout/1,
	 record_access/2, record_access/3,
	 record_access_argument/1, record_access_field/1,
	 record_access_type/1, record_expr/2, record_expr/3,
	 record_expr_argument/1, record_expr_fields/1,
	 record_expr_type/1, record_field/1, record_field/2,
	 record_field_name/1, record_field_value/1,
	 typed_record_field_name/1, typed_record_field_value/1,
	 typed_record_field/1, typed_record_type/1,
	 record_index_expr/2, record_index_expr_field/1,
	 record_index_expr_type/1, remove_comments/1, revert/1,
	 revert_forms/1, rule/2, rule_arity/1, rule_clauses/1,
	 rule_name/1, set_ann/2, set_attrs/2,
	 set_name/2, set_pos/2, set_postcomments/2,
	 set_precomments/2, size_qualifier/2,
	 size_qualifier_argument/1, size_qualifier_body/1,
	 string/1, string_literal/1, string_value/1, subtrees/1,
	 text/1, text_string/1, tree/1, tree/2, try_after_expr/2,
	 try_expr/2, try_expr/3, try_expr/4, try_expr_after/1,
	 try_expr_body/1, try_expr_clauses/1,
	 try_expr_handlers/1, tuple/1, tuple_elements/1,
	 tuple_size/1, type/1, underscore/0, update_tree/2,
	 variable/1, variable_literal/1, variable_name/1,
	 warning_marker/1, warning_marker_info/1,
	 default_literals_vars/2]).
	

%% =====================================================================
%% IMPLEMENTATION NOTES:
%%
%% All nodes are represented by tuples of arity 2 or greater, whose
%% first element is an atom which uniquely identifies the type of the
%% node. (In the backwards-compatible representation, the interpretation
%% is also often dependent on the context; the second element generally
%% holds the position information - with a couple of exceptions; see
%% `get_pos' and `set_pos' for details). In the documentation of this
%% module, `Pos' is the source code position information associated with
%% a node; usually, this is a positive integer indicating the original
%% source code line, but no assumptions are made in this module
%% regarding the format or interpretation of position information. When
%% a syntax tree node is constructed, its associated position is by
%% default set to the integer zero.
%% =====================================================================

-define(NO_UNUSED, true).

%% =====================================================================
%% Declarations of globally used internal data structures
%% =====================================================================

%% `com' records are used to hold comment information attached to a
%% syntax tree node or a wrapper structure.
%%
%% #com{pre :: Pre, post :: Post}
%%
%%	Pre = Post = [Com]
%%	Com = syntaxTree()
%%
%%	type(Com) = comment

-record(com, {pre = [], post = []}).

%% `attr' records store node attributes as an aggregate.
%%
%% #attr{pos :: Pos, ann :: Ann, com :: Comments}
%%
%%	Pos = term()
%%	Ann = [term()]
%%	Comments = none | #com{}
%%
%% where `Pos' `Ann' and `Comments' are the corresponding values of a
%% `tree' or `wrapper' record.

-record(attr, {pos = {0,0}, ann = [], com = none}).

%% `tree' records represent new-form syntax tree nodes.
%%
%% Tree = #tree{type :: Type, attr :: Attr, data :: Data}
%%
%%	Type = atom()
%%	Attr = #attr{}
%%	Data = term()
%%
%%	is_tree(Tree) = true

-record(tree, {type, attr = #attr{}, data}).

%% `wrapper' records are used for attaching new-form node information to
%% `erl_parse' trees.
%%
%% Wrapper = #wrapper{type :: Type, attr :: Attr, tree :: ParseTree}
%%
%%	Type = atom()
%%	Attr = #attr{}
%%	ParseTree = term()
%%
%%	is_tree(Wrapper) = false

-record(wrapper, {type, attr = #attr{}, tree}).

%% =====================================================================
%%
%%			Exported functions
%%
%% =====================================================================

%% =====================================================================
%% @spec type(Node::syntaxTree()) -> atom()
%%
%% @doc Returns the type tag of <code>Node</code>. If <code>Node</code>
%% does not represent a syntax tree, evaluation fails with reason
%% <code>badarg</code>. Node types currently defined by this module are:
%% <p><center><table border="1">
%%  <tr>
%%   <td>application</td>
%%   <td>arity_qualifier</td>
%%   <td>atom</td>
%%   <td>attribute</td>
%%  </tr><tr>
%%   <td>binary</td>
%%   <td>binary_field</td>
%%   <td>block_expr</td>
%%   <td>case_expr</td>
%%  </tr><tr>
%%   <td>catch_expr</td>
%%   <td>char</td>
%%   <td>class_qualifier</td>
%%   <td>clause</td>
%%  </tr><tr>
%%   <td>comment</td>
%%   <td>cond_expr</td>
%%   <td>conjunction</td>
%%   <td>disjunction</td>
%%  </tr><tr>
%%   <td>eof_marker</td>
%%   <td>error_marker</td>
%%   <td>float</td>
%%   <td>form_list</td>
%%  </tr><tr>
%%   <td>fun_expr</td>
%%   <td>function</td>
%%   <td>generator</td>
%%   <td>if_expr</td>
%%  </tr><tr>
%%   <td>implicit_fun</td>
%%   <td>infix_expr</td>
%%   <td>integer</td>
%%   <td>list</td>
%%  </tr><tr>
%%   <td>list_comp</td>
%%   <td>macro</td>
%%   <td>match_expr</td>
%%   <td>module_qualifier</td>
%%  </tr><tr>
%%   <td>nil</td>
%%   <td>operator</td>
%%   <td>parentheses</td>
%%   <td>prefix_expr</td>
%%  </tr><tr>
%%   <td>qualified_name</td>
%%   <td>query_expr</td>
%%   <td>receive_expr</td>
%%   <td>record_access</td>
%%  </tr><tr>
%%   <td>record_expr</td>
%%   <td>record_field</td>
%%   <td>record_index_expr</td>
%%   <td>rule</td>
%%  </tr><tr>
%%   <td>size_qualifier</td>
%%   <td>string</td>
%%   <td>text</td>
%%   <td>try_expr</td>
%%  </tr><tr>
%%   <td>tuple</td>
%%   <td>underscore</td>
%%   <td>variable</td>
%%   <td>warning_marker</td>
%%  </tr>
%% </table></center></p>
%% <p>The user may (for special purposes) create additional nodes
%% with other type tags, using the <code>tree/2</code> function.</p>
%%
%% <p>Note: The primary constructor functions for a node type should
%% always have the same name as the node type itself.</p>
%%
%% @see tree/2
%% @see application/3
%% @see arity_qualifier/2
%% @see atom/1
%% @see attribute/2
%% @see binary/1
%% @see binary_field/2
%% @see block_expr/1
%% @see case_expr/2
%% @see catch_expr/1
%% @see char/1
%% @see class_qualifier/2
%% @see clause/3
%% @see comment/2
%% @see cond_expr/1
%% @see conjunction/1
%% @see disjunction/1
%% @see eof_marker/0
%% @see error_marker/1
%% @see float/1
%% @see form_list/1
%% @see fun_expr/1
%% @see function/2
%% @see generator/2
%% @see if_expr/1
%% @see implicit_fun/2
%% @see infix_expr/3
%% @see integer/1
%% @see list/2
%% @see list_comp/2
%% @see macro/2
%% @see match_expr/2
%% @see module_qualifier/2
%% @see nil/0
%% @see operator/1
%% @see parentheses/1
%% @see prefix_expr/2
%% @see qualified_name/1
%% @see query_expr/1
%% @see receive_expr/3
%% @see record_access/3
%% @see record_expr/2
%% @see record_field/2
%% @see record_index_expr/2
%% @see rule/2
%% @see size_qualifier/2
%% @see string/1
%% @see text/1
%% @see try_expr/3
%% @see tuple/1
%% @see underscore/0
%% @see variable/1
%% @see warning_marker/1

type(#tree{type = T}) -> T;
type(#wrapper{type = T}) -> T;
type(Node) ->
    %% Check for `erl_parse'-compatible nodes, and otherwise fail.
    case Node of
      %% Leaf types
      {atom, _, _} -> atom;
      {char, _, _} -> char;
      {float, _, _} -> float;
      {integer, _, _} -> integer;
      {nil, _} -> nil;
      {string, _, _} -> string;
      {var, _, Name} ->
	  if Name == '_' -> underscore;
	     true -> variable
	  end;
      {error, _} -> error_marker;
      {warning, _} -> warning_marker;
      {eof, _} -> eof_marker;
      %% Composite types
      {'case', _, _, _} -> case_expr;
      {'catch', _, _} -> catch_expr;
      {'cond', _, _} -> cond_expr;
      {'fun', _, {clauses, _}} -> fun_expr;
      {'fun', _, {function, _, _}} -> implicit_fun;
      {'fun', _, {function, _, _, _}} -> implicit_fun;   %% Added by Huiqing Li			      
      {'if', _, _} -> if_expr;
      {'receive', _, _, _, _} -> receive_expr;
      {'receive', _, _} -> receive_expr;
      {attribute, _, _, _} ->   attribute;
      {bin, _, _} -> binary;
      {bin_element, _, _, _, _} -> binary_field;
      {block, _, _} -> block_expr;
      {call, _, _, _} -> application;
      {clause, _, _, _, _} -> clause;
      {cons, _, _, _} -> list;
      {function, _, _, _, _} -> function;
      {generate, _, _, _} -> generator;
      {lc, _, _, _} -> list_comp;
      {match, _, _, _} -> match_expr;
      {op, _, _, _, _} -> infix_expr;
      {op, _, _, _} -> prefix_expr;
      {'query', _, _} -> query_expr;
      {record, _, _, _, _} -> record_expr;
      {record, _, _, _} -> record_expr;
      {record_field, _, _, _, _} -> record_access;
      {record_field, _, _, _} ->
	  case is_qualified_name(Node) of
	    true -> qualified_name;
	    false -> record_access
	  end;
      {record_index, _, _, _} -> record_index_expr;
      {remote, _, _, _} -> module_qualifier;
      {rule, _, _, _, _} -> rule;
      {'try', _, _, _, _, _} -> try_expr;
      {type, _, _, _} -> type;     
      {tuple, _, _} -> tuple;
        _ -> erlang:error({badarg, Node})
    end.

%% =====================================================================
%% @spec is_leaf(Node::syntaxTree()) -> bool()
%%
%% @doc Returns <code>true</code> if <code>Node</code> is a leaf node,
%% otherwise <code>false</code>. The currently recognised leaf node
%% types are:
%% <p><center><table border="1">
%%  <tr>
%%   <td><code>atom</code></td>
%%   <td><code>char</code></td>
%%   <td><code>comment</code></td>
%%   <td><code>eof_marker</code></td>
%%   <td><code>error_marker</code></td>
%%  </tr><tr>
%%   <td><code>float</code></td>
%%   <td><code>integer</code></td>
%%   <td><code>nil</code></td>
%%   <td><code>operator</code></td>
%%   <td><code>string</code></td>
%%  </tr><tr>
%%   <td><code>text</code></td>
%%   <td><code>underscore</code></td>
%%   <td><code>variable</code></td>
%%   <td><code>warning_marker</code></td>
%%  </tr>
%% </table></center></p>
%% <p>A node of type <code>tuple</code> is a leaf node if and only if
%% its arity is zero.</p>
%%
%% <p>Note: not all literals are leaf nodes, and vice versa. E.g.,
%% tuples with nonzero arity and nonempty lists may be literals, but are
%% not leaf nodes. Variables, on the other hand, are leaf nodes but not
%% literals.</p>
%%
%% @see type/1
%% @see is_literal/1

is_leaf(Node) ->
    case type(Node) of
      atom -> true;
      char -> true;
      comment -> true;        % nonstandard type
      eof_marker -> true;
      error_marker -> true;
      float -> true;
      integer -> true;
      nil -> true;
      operator -> true;       % nonstandard type
      string -> true;
      text -> true;           % nonstandard type
      tuple ->
	  case tuple_elements(Node) of
	    [] -> true;
	    _ -> false
	  end;
      underscore -> true;
      variable -> true;
      warning_marker -> true;
      type -> true;   %% a temporary fix;
      _ -> false
    end.

%% =====================================================================
%% @spec is_form(Node::syntaxTree()) -> bool()
%%
%% @doc Returns <code>true</code> if <code>Node</code> is a syntax tree
%% representing a so-called "source code form", otherwise
%% <code>false</code>. Forms are the Erlang source code units which,
%% placed in sequence, constitute an Erlang program. Current form types
%% are:
%% <p><center><table border="1">
%%  <tr>
%%   <td><code>attribute</code></td>
%%   <td><code>comment</code></td>
%%   <td><code>error_marker</code></td>
%%   <td><code>eof_marker</code></td>
%%  </tr><tr>
%%   <td><code>form_list</code></td>
%%   <td><code>function</code></td>
%%   <td><code>rule</code></td>
%%   <td><code>warning_marker</code></td>
%%  </tr>
%% </table></center></p>
%% @see type/1
%% @see attribute/2
%% @see comment/2
%% @see eof_marker/1
%% @see error_marker/1
%% @see form_list/1
%% @see function/2
%% @see rule/2
%% @see warning_marker/1

is_form(Node) ->
    case type(Node) of
      attribute -> true;
      comment -> true;
      function -> true;
      eof_marker -> true;
      error_marker -> true;
      form_list -> true;
      rule -> true;
      warning_marker -> true;
      _ -> false
    end.

%% =====================================================================
%% @spec get_pos(Node::syntaxTree()) -> term()
%%
%% @doc Returns the position information associated with
%% <code>Node</code>. This is usually a nonnegative integer (indicating
%% the source code line number), but may be any term. By default, all
%% new tree nodes have their associated position information set to the
%% integer zero.
%%
%% @see set_pos/2
%% @see get_attrs/1

%% All `erl_parse' tree nodes are represented by tuples whose second
%% field is the position information (usually an integer), *with the
%% exceptions of* `{error, ...}' (type `error_marker') and `{warning,
%% ...}' (type `warning_marker'), which only contain the associated line
%% number *of the error descriptor*; this is all handled transparently
%% by `get_pos' and `set_pos'.

get_pos(#tree{attr = Attr}) -> Attr#attr.pos;
get_pos(#wrapper{attr = Attr}) -> Attr#attr.pos;
get_pos({error, {Pos, _, _}}) -> Pos;
get_pos({error, {{Pos, _, _}, _}}) -> Pos;
get_pos({warning, {Pos, _, _}}) -> Pos;
get_pos(Node) ->
    %% Here, we assume that we have an `erl_parse' node with position
    %% information in element 2.
    element(2, Node).

%% =====================================================================
%% @spec set_pos(Node::syntaxTree(), Pos::term()) -> syntaxTree()
%%
%% @doc Sets the position information of <code>Node</code> to
%% <code>Pos</code>.
%%
%% @see get_pos/1
%% @see copy_pos/2

set_pos(Node, Pos) ->
     case Node of
       #tree{attr = Attr} ->
 	  Node#tree{attr = Attr#attr{pos = Pos}};
       #wrapper{attr = Attr} ->
 	  Node#wrapper{attr = Attr#attr{pos = Pos}};
       _ ->
 	  %% We then assume we have an `erl_parse' node, and create a
 	  %% wrapper around it to make things more uniform.
 	  set_pos(wrap(Node), Pos)
     end.


%% =====================================================================
%% @spec copy_pos(Source::syntaxTree(), Target::syntaxTree()) ->
%%           syntaxTree()
%%
%% @doc Copies the position information from <code>Source</code> to
%% <code>Target</code>.
%%
%% <p>This is equivalent to <code>set_pos(Target,
%% get_pos(Source))</code>, but potentially more efficient.</p>
%%
%% @see get_pos/1
%% @see set_pos/2

copy_pos(Source, Target) ->
    set_pos(Target, get_pos(Source)).

%% =====================================================================
%% `get_com' and `set_com' are for internal use only.

get_com(#tree{attr = Attr}) -> Attr#attr.com;
get_com(#wrapper{attr = Attr}) -> Attr#attr.com;
get_com(_) -> none.

set_com(Node, Com) ->
    case Node of
      #tree{attr = Attr} ->
	  Node#tree{attr = Attr#attr{com = Com}};
      #wrapper{attr = Attr} ->
	  Node#wrapper{attr = Attr#attr{com = Com}};
      _ -> set_com(wrap(Node), Com)
    end.

%% =====================================================================
%% @spec get_precomments(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the associated pre-comments of a node. This is a
%% possibly empty list of abstract comments, in top-down textual order.
%% When the code is formatted, pre-comments are typically displayed
%% directly above the node. For example:
%% <pre>
%%         % Pre-comment of function
%%         foo(X) -> {bar, X}.</pre>
%%
%% <p>If possible, the comment should be moved before any preceding
%% separator characters on the same line. E.g.:
%% <pre>
%%         foo([X | Xs]) ->
%%             % Pre-comment of 'bar(X)' node
%%             [bar(X) | foo(Xs)];
%%         ...</pre>
%% (where the comment is moved before the "<code>[</code>").</p>
%%
%% @see comment/2
%% @see set_precomments/2
%% @see get_postcomments/1
%% @see get_attrs/1

get_precomments(#tree{attr = Attr}) ->
    get_precomments_1(Attr);
get_precomments(#wrapper{attr = Attr}) ->
    get_precomments_1(Attr);
get_precomments(_) -> [].

get_precomments_1(#attr{com = none}) -> [];
get_precomments_1(#attr{com = #com{pre = Cs}}) -> Cs.

%% =====================================================================
%% @spec set_precomments(Node::syntaxTree(),
%%                       Comments::[syntaxTree()]) -> syntaxTree()
%%
%% @doc Sets the pre-comments of <code>Node</code> to
%% <code>Comments</code>. <code>Comments</code> should be a possibly
%% empty list of abstract comments, in top-down textual order.
%%
%% @see comment/2
%% @see get_precomments/1
%% @see add_precomments/2
%% @see set_postcomments/2
%% @see copy_comments/2
%% @see remove_comments/1
%% @see join_comments/2

set_precomments(Node, Cs) ->
    case Node of
      #tree{attr = Attr} ->
	  Node#tree{attr = set_precomments_1(Attr, Cs)};
      #wrapper{attr = Attr} ->
	  Node#wrapper{attr = set_precomments_1(Attr, Cs)};
      _ -> set_precomments(wrap(Node), Cs)
    end.

set_precomments_1(#attr{com = none} = Attr, Cs) ->
    Attr#attr{com = #com{pre = Cs}};
set_precomments_1(#attr{com = Com} = Attr, Cs) ->
    Attr#attr{com = Com#com{pre = Cs}}.

%% =====================================================================
%% @spec add_precomments(Comments::[syntaxTree()],
%%                       Node::syntaxTree()) -> syntaxTree()
%%
%% @doc Appends <code>Comments</code> to the pre-comments of
%% <code>Node</code>.
%%
%% <p>Note: This is equivalent to <code>set_precomments(Node,
%% get_precomments(Node) ++ Comments)</code>, but potentially more
%% efficient.</p>
%%
%% @see comment/2
%% @see get_precomments/1
%% @see set_precomments/2
%% @see add_postcomments/2
%% @see join_comments/2

add_precomments(Cs, Node) ->
    case Node of
      #tree{attr = Attr} ->
	  Node#tree{attr = add_precomments_1(Cs, Attr)};
      #wrapper{attr = Attr} ->
	  Node#wrapper{attr = add_precomments_1(Cs, Attr)};
      _ -> add_precomments(Cs, wrap(Node))
    end.

add_precomments_1(Cs, #attr{com = none} = Attr) ->
    Attr#attr{com = #com{pre = Cs}};
add_precomments_1(Cs, #attr{com = Com} = Attr) ->
    Attr#attr{com = Com#com{pre = Com#com.pre ++ Cs}}.

%% =====================================================================
%% @spec get_postcomments(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the associated post-comments of a node. This is a
%% possibly empty list of abstract comments, in top-down textual order.
%% When the code is formatted, post-comments are typically displayed to
%% the right of and/or below the node. For example:
%% <pre>
%%         {foo, X, Y}     % Post-comment of tuple</pre>
%%
%% <p>If possible, the comment should be moved past any following
%% separator characters on the same line, rather than placing the
%% separators on the following line. E.g.:
%% <pre>
%%         foo([X | Xs], Y) ->
%%             foo(Xs, bar(X));     % Post-comment of 'bar(X)' node
%%          ...</pre>
%% (where the comment is moved past the rightmost "<code>)</code>" and
%% the "<code>;</code>").</p>
%%
%% @see comment/2
%% @see set_postcomments/2
%% @see get_precomments/1
%% @see get_attrs/1

get_postcomments(#tree{attr = Attr}) ->
    get_postcomments_1(Attr);
get_postcomments(#wrapper{attr = Attr}) ->
    get_postcomments_1(Attr);
get_postcomments(_) -> [].

get_postcomments_1(#attr{com = none}) -> [];
get_postcomments_1(#attr{com = #com{post = Cs}}) -> Cs.

%% =====================================================================
%% @spec set_postcomments(Node::syntaxTree(),
%%                        Comments::[syntaxTree()]) -> syntaxTree()
%%
%% @doc Sets the post-comments of <code>Node</code> to
%% <code>Comments</code>. <code>Comments</code> should be a possibly
%% empty list of abstract comments, in top-down textual order
%%
%% @see comment/2
%% @see get_postcomments/1
%% @see add_postcomments/2
%% @see set_precomments/2
%% @see copy_comments/2
%% @see remove_comments/1
%% @see join_comments/2

set_postcomments(Node, Cs) ->
    case Node of
      #tree{attr = Attr} ->
	  Node#tree{attr = set_postcomments_1(Attr, Cs)};
      #wrapper{attr = Attr} ->
	  Node#wrapper{attr = set_postcomments_1(Attr, Cs)};
      _ -> set_postcomments(wrap(Node), Cs)
    end.

set_postcomments_1(#attr{com = none} = Attr, Cs) ->
    Attr#attr{com = #com{post = Cs}};
set_postcomments_1(#attr{com = Com} = Attr, Cs) ->
    Attr#attr{com = Com#com{post = Cs}}.

%% =====================================================================
%% @spec add_postcomments(Comments::[syntaxTree()],
%%                        Node::syntaxTree()) -> syntaxTree()
%%
%% @doc Appends <code>Comments</code> to the post-comments of
%% <code>Node</code>.
%%
%% <p>Note: This is equivalent to <code>set_postcomments(Node,
%% get_postcomments(Node) ++ Comments)</code>, but potentially more
%% efficient.</p>
%%
%% @see comment/2
%% @see get_postcomments/1
%% @see set_postcomments/2
%% @see add_precomments/2
%% @see join_comments/2

add_postcomments(Cs, Node) ->
    case Node of
      #tree{attr = Attr} ->
	  Node#tree{attr = add_postcomments_1(Cs, Attr)};
      #wrapper{attr = Attr} ->
	  Node#wrapper{attr = add_postcomments_1(Cs, Attr)};
      _ -> add_postcomments(Cs, wrap(Node))
    end.

add_postcomments_1(Cs, #attr{com = none} = Attr) ->
    Attr#attr{com = #com{post = Cs}};
add_postcomments_1(Cs, #attr{com = Com} = Attr) ->
    Attr#attr{com = Com#com{post = Com#com.post ++ Cs}}.

%% =====================================================================
%% @spec has_comments(Node::syntaxTree()) -> bool()
%%
%% @doc Yields <code>false</code> if the node has no associated
%% comments, and <code>true</code> otherwise.
%%
%% <p>Note: This is equivalent to <code>(get_precomments(Node) == [])
%% and (get_postcomments(Node) == [])</code>, but potentially more
%% efficient.</p>
%%
%% @see get_precomments/1
%% @see get_postcomments/1
%% @see remove_comments/1

has_comments(#tree{attr = Attr}) ->
    case Attr#attr.com of
      none -> false;
      #com{pre = [], post = []} -> false;
      _ -> true
    end;
has_comments(#wrapper{attr = Attr}) ->
    case Attr#attr.com of
      none -> false;
      #com{pre = [], post = []} -> false;
      _ -> true
    end;
has_comments(_) -> false.

%% =====================================================================
%% @spec remove_comments(Node::syntaxTree()) -> syntaxTree()
%%
%% @doc Clears the associated comments of <code>Node</code>.
%%
%% <p>Note: This is equivalent to
%% <code>set_precomments(set_postcomments(Node, []), [])</code>, but
%% potentially more efficient.</p>
%%
%% @see set_precomments/2
%% @see set_postcomments/2

remove_comments(Node) ->
    case Node of
      #tree{attr = Attr} ->
	  Node#tree{attr = Attr#attr{com = none}};
      #wrapper{attr = Attr} ->
	  Node#wrapper{attr = Attr#attr{com = none}};
      _ -> Node
    end.

%% =====================================================================
%% @spec copy_comments(Source::syntaxTree(), Target::syntaxTree()) ->
%%           syntaxTree()
%%
%% @doc Copies the pre- and postcomments from <code>Source</code> to
%% <code>Target</code>.
%%
%% <p>Note: This is equivalent to
%% <code>set_postcomments(set_precomments(Target,
%% get_precomments(Source)), get_postcomments(Source))</code>, but
%% potentially more efficient.</p>
%%
%% @see comment/2
%% @see get_precomments/1
%% @see get_postcomments/1
%% @see set_precomments/2
%% @see set_postcomments/2

copy_comments(Source, Target) ->
    set_com(Target, get_com(Source)).

%% =====================================================================
%% @spec join_comments(Source::syntaxTree(), Target::syntaxTree()) ->
%%           syntaxTree()
%%
%% @doc Appends the comments of <code>Source</code> to the current
%% comments of <code>Target</code>.
%%
%% <p>Note: This is equivalent to
%% <code>add_postcomments(get_postcomments(Source),
%% add_precomments(get_precomments(Source), Target))</code>, but
%% potentially more efficient.</p>
%%
%% @see comment/2
%% @see get_precomments/1
%% @see get_postcomments/1
%% @see add_precomments/2
%% @see add_postcomments/2

join_comments(Source, Target) ->
    add_postcomments(get_postcomments(Source),
		     add_precomments(get_precomments(Source), Target)).

%% =====================================================================
%% @spec get_ann(syntaxTree()) -> [term()]
%%
%% @doc Returns the list of user annotations associated with a syntax
%% tree node. For a newly created node, this is the empty list. The
%% annotations may be any terms.
%%
%% @see set_ann/2
%% @see get_attrs/1

get_ann(#tree{attr = Attr}) -> Attr#attr.ann;
get_ann(#wrapper{attr = Attr}) -> Attr#attr.ann;
get_ann(_) -> [].

%% =====================================================================
%% @spec set_ann(Node::syntaxTree(), Annotations::[term()]) ->
%%           syntaxTree()
%%
%% @doc Sets the list of user annotations of <code>Node</code> to
%% <code>Annotations</code>.
%%
%% @see get_ann/1
%% @see add_ann/2
%% @see copy_ann/2

set_ann(Node, As) ->
    case Node of
      #tree{attr = Attr} ->
	  Node#tree{attr = Attr#attr{ann = As}};
      #wrapper{attr = Attr} ->
	  Node#wrapper{attr = Attr#attr{ann = As}};
      _ ->
	  %% Assume we have an `erl_parse' node and create a wrapper
	  %% structure to carry the annotation.
	  set_ann(wrap(Node), As)
    end.

%% =====================================================================
%% @spec add_ann(Annotation::term(), Node::syntaxTree()) -> syntaxTree()
%%
%% @doc Appends the term <code>Annotation</code> to the list of user
%% annotations of <code>Node</code>.
%%
%% <p>Note: this is equivalent to <code>set_ann(Node, [Annotation |
%% get_ann(Node)])</code>, but potentially more efficient.</p>
%%
%% @see get_ann/1
%% @see set_ann/2

add_ann(A, Node) ->
    case Node of
      #tree{attr = Attr} ->
	  Node#tree{attr = Attr#attr{ann = [A | Attr#attr.ann]}};
      #wrapper{attr = Attr} ->
	  Node#wrapper{attr =
			   Attr#attr{ann = [A | Attr#attr.ann]}};
      _ ->
	  %% Assume we have an `erl_parse' node and create a wrapper
	  %% structure to carry the annotation.
	  add_ann(A, wrap(Node))
    end.

%% =====================================================================
%% @spec copy_ann(Source::syntaxTree(), Target::syntaxTree()) ->
%%           syntaxTree()
%%
%% @doc Copies the list of user annotations from <code>Source</code> to
%% <code>Target</code>.
%%
%% <p>Note: this is equivalent to <code>set_ann(Target,
%% get_ann(Source))</code>, but potentially more efficient.</p>
%%
%% @see get_ann/1
%% @see set_ann/2

copy_ann(Source, Target) ->
    set_ann(Target, get_ann(Source)).

%% =====================================================================
%% @spec get_attrs(syntaxTree()) -> syntaxTreeAttributes()
%%
%% @doc Returns a representation of the attributes associated with a
%% syntax tree node. The attributes are all the extra information that
%% can be attached to a node. Currently, this includes position
%% information, source code comments, and user annotations. The result
%% of this function cannot be inspected directly; only attached to
%% another node (cf. <code>set_attrs/2</code>).
%%
%% <p>For accessing individual attributes, see <code>get_pos/1</code>,
%% <code>get_ann/1</code>, <code>get_precomments/1</code> and
%% <code>get_postcomments/1</code>.</p>
%%
%% @type syntaxTreeAttributes(). This is an abstract representation of
%% syntax tree node attributes; see the function <a
%% href="#get_attrs-1"><code>get_attrs/1</code></a>.
%%
%% @see set_attrs/2
%% @see get_pos/1
%% @see get_ann/1
%% @see get_precomments/1
%% @see get_postcomments/1

get_attrs(#tree{attr = Attr}) -> Attr;
get_attrs(#wrapper{attr = Attr}) -> Attr;
get_attrs(Node) ->
    #attr{pos = get_pos(Node), ann = get_ann(Node),
	  com = get_com(Node)}.

%% =====================================================================
%% @spec set_attrs(Node::syntaxTree(),
%%                 Attributs::syntaxTreeAttributes()) -> syntaxTree()
%%
%% @doc Sets the attributes of <code>Node</code> to
%% <code>Attributes</code>.
%%
%% @see get_attrs/1
%% @see copy_attrs/2

set_attrs(Node, Attr) ->
    case Node of
      #tree{} -> Node#tree{attr = Attr};
      #wrapper{} -> Node#wrapper{attr = Attr};
      _ -> set_attrs(wrap(Node), Attr)
    end.

%% =====================================================================
%% @spec copy_attrs(Source::syntaxTree(), Target::syntaxTree()) ->
%%           syntaxTree()
%%
%% @doc Copies the attributes from <code>Source</code> to
%% <code>Target</code>.
%%
%% <p>Note: this is equivalent to <code>set_attrs(Target,
%% get_attrs(Source))</code>, but potentially more efficient.</p>
%%
%% @see get_attrs/1
%% @see set_attrs/2

copy_attrs(S, T) -> set_attrs(T, get_attrs(S)).

%% =====================================================================
%% @spec comment(Strings) -> syntaxTree()
%% @equiv comment(none, Strings)

comment(Strings) -> comment(none, Strings).

%% =====================================================================
%% @spec comment(Padding, Strings::[string()]) -> syntaxTree()
%%	    Padding = none | integer()
%%
%% @doc Creates an abstract comment with the given padding and text. If
%% <code>Strings</code> is a (possibly empty) list
%% <code>["<em>Txt1</em>", ..., "<em>TxtN</em>"]</code>, the result
%% represents the source code text
%% <pre>
%%     %<em>Txt1</em>
%%     ...
%%     %<em>TxtN</em></pre>
%% <code>Padding</code> states the number of empty character positions
%% to the left of the comment separating it horizontally from
%% source code on the same line (if any). If <code>Padding</code> is
%% <code>none</code>, a default positive number is used. If
%% <code>Padding</code> is an integer less than 1, there should be no
%% separating space. Comments are in themselves regarded as source
%% program forms.
%%
%% @see comment/1
%% @see is_form/1

-record(comment, {pad, text}).

%% type(Node) = comment
%% data(Node) = #comment{pad :: Padding, text :: Strings}
%%
%%	Padding = none | integer()
%%	Strings = [string()]

comment(Pad, Strings) ->
    tree(comment, #comment{pad = Pad, text = Strings}).

%% =====================================================================
%% @spec comment_text(Node::syntaxTree()) -> [string()]
%%
%% @doc Returns the lines of text of the abstract comment.
%%
%% @see comment/2

comment_text(Node) -> (data(Node))#comment.text.

%% =====================================================================
%% @spec comment_padding(Node::syntaxTree()) -> none | integer()
%%
%% @doc Returns the amount of padding before the comment, or
%% <code>none</code>. The latter means that a default padding may be
%% used.
%%
%% @see comment/2

comment_padding(Node) -> (data(Node))#comment.pad.

%% =====================================================================
%% @spec form_list(Forms::[syntaxTree()]) -> syntaxTree()
%%
%% @doc Creates an abstract sequence of "source code forms". If
%% <code>Forms</code> is <code>[F1, ..., Fn]</code>, where each
%% <code>Fi</code> is a form (cf. <code>is_form/1</code>, the result
%% represents
%% <pre>
%%     <em>F1</em>
%%     ...
%%     <em>Fn</em></pre>
%% where the <code>Fi</code> are separated by one or more line breaks. A
%% node of type <code>form_list</code> is itself regarded as a source
%% code form; cf. <code>flatten_form_list/1</code>.
%%
%% <p>Note: this is simply a way of grouping source code forms as a
%% single syntax tree, usually in order to form an Erlang module
%% definition.</p>
%%
%% @see form_list_elements/1
%% @see is_form/1
%% @see flatten_form_list/1

%% type(Node) = form_list
%% data(Node) = [Form]
%%
%%	Form = syntaxTree()
%%	is_form(Form) = true

form_list(Forms) -> tree(form_list, Forms).

%% =====================================================================
%% @spec form_list_elements(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of subnodes of a <code>form_list</code> node.
%%
%% @see form_list/1

form_list_elements(Node) -> data(Node).

%% =====================================================================
%% @spec flatten_form_list(Node::syntaxTree()) -> syntaxTree()
%%
%% @doc Flattens sublists of a <code>form_list</code> node. Returns
%% <code>Node</code> with all subtrees of type <code>form_list</code>
%% recursively expanded, yielding a single "flat" abstract form
%% sequence.
%%
%% @see form_list/1

flatten_form_list(Node) ->
    Fs = form_list_elements(Node),
    Fs1 = lists:reverse(flatten_form_list_1(Fs, [])),
    copy_attrs(Node, form_list(Fs1)).

flatten_form_list_1([F | Fs], As) ->
    case type(F) of
      form_list ->
	  As1 = flatten_form_list_1(form_list_elements(F), As),
	  flatten_form_list_1(Fs, As1);
      _ -> flatten_form_list_1(Fs, [F | As])
    end;
flatten_form_list_1([], As) -> As.

%% =====================================================================
%% @spec text(String::string()) -> syntaxTree()
%%
%% @doc Creates an abstract piece of source code text. The result
%% represents exactly the sequence of characters in <code>String</code>.
%% This is useful in cases when one wants full control of the resulting
%% output, e.g., for the appearance of floating-point numbers or macro
%% definitions.
%%
%% @see text_string/1

%% type(Node) = text
%% data(Node) = string()

text(String) -> tree(text, String).

%% =====================================================================
%% @spec text_string(syntaxTree()) -> string()
%%
%% @doc Returns the character sequence represented by a
%% <code>text</code> node.
%%
%% @see text/1

text_string(Node) -> data(Node).

%% =====================================================================
%% @spec variable(Name) -> syntaxTree()
%%	    Name = atom() | string()
%%
%% @doc Creates an abstract variable with the given name.
%% <code>Name</code> may be any atom or string that represents a
%% lexically valid variable name, but <em>not</em> a single underscore
%% character; cf. <code>underscore/0</code>.
%%
%% <p>Note: no checking is done whether the character sequence
%% represents a proper variable name, i.e., whether or not its first
%% character is an uppercase Erlang character, or whether it does not
%% contain control characters, whitespace, etc.</p>
%%
%% @see variable_name/1
%% @see variable_literal/1
%% @see underscore/0

%% type(Node) = variable
%% data(Node) = atom()
%%
%% `erl_parse' representation:
%%
%% {var, Pos, Name}
%%
%%	Name = atom() \ '_'

variable(Name) when is_atom(Name) ->
    tree(variable, Name);
variable(Name) -> tree(variable, list_to_atom(Name)).

revert_variable(Node) ->
    Pos = get_pos(Node),
    Name = variable_name(Node),
    {var, Pos, Name}.

%% =====================================================================
%% @spec variable_name(syntaxTree()) -> atom()
%%
%% @doc Returns the name of a <code>variable</code> node as an atom.
%%
%% @see variable/1

variable_name(Node) ->
    case unwrap(Node) of
      {var, _, Name} -> Name;
      Node1 -> data(Node1)
    end.

%% =====================================================================
%% @spec variable_literal(syntaxTree()) -> string()
%%
%% @doc Returns the name of a <code>variable</code> node as a string.
%%
%% @see variable/1

variable_literal(Node) ->
    case unwrap(Node) of
      {var, _, Name} -> atom_to_list(Name);
      Node1 -> atom_to_list(data(Node1))
    end.

%% =====================================================================
%% @spec underscore() -> syntaxTree()
%%
%% @doc Creates an abstract universal pattern ("<code>_</code>"). The
%% lexical representation is a single underscore character. Note that
%% this is <em>not</em> a variable, lexically speaking.
%%
%% @see variable/1

%% type(Node) = underscore
%% data(Node) = []
%%
%% `erl_parse' representation:
%%
%% {var, Pos, '_'}

underscore() -> tree(underscore, []).

revert_underscore(Node) ->
    Pos = get_pos(Node), {var, Pos, '_'}.

%% =====================================================================
%% @spec integer(Value::integer()) -> syntaxTree()
%%
%% @doc Creates an abstract integer literal. The lexical representation
%% is the canonical decimal numeral of <code>Value</code>.
%%
%% @see integer_value/1
%% @see integer_literal/1
%% @see is_integer/2

%% type(Node) = integer
%% data(Node) = integer()
%%
%% `erl_parse' representation:
%%
%% {integer, Pos, Value}
%%
%%	Value = integer()

integer(Value) -> tree(integer, Value).

revert_integer(Node) ->
    Pos = get_pos(Node),
    {integer, Pos, integer_value(Node)}.

%% =====================================================================
%% @spec is_integer(Node::syntaxTree(), Value::integer()) -> bool()
%%
%% @doc Returns <code>true</code> if <code>Node</code> has type
%% <code>integer</code> and represents <code>Value</code>, otherwise
%% <code>false</code>.
%%
%% @see integer/1

is_integer(Node, Value) ->
    case unwrap(Node) of
      {integer, _, Value} -> true;
      #tree{type = integer, data = Value} -> true;
      _ -> false
    end.

%% =====================================================================
%% @spec integer_value(syntaxTree()) -> integer()
%%
%% @doc Returns the value represented by an <code>integer</code> node.
%%
%% @see integer/1

integer_value(Node) ->
    Res =case unwrap(Node) of
	     {integer, _, Value} -> Value;
	     Node1 -> data(Node1)
	 end,
    case is_integer(Res) of 
	true ->
	     Res;
	_ -> try list_to_integer(Res) of   %% list_to_integer does not work with based integers; this is only a temp fix.
		 V -> V
	     catch 
		 _E1:_E2_ -> Res
	     end
    end.

%% =====================================================================
%% @spec integer_literal(syntaxTree()) -> string()
%%
%% @doc Returns the numeral string represented by an
%% <code>integer</code> node.
%%
%% @see integer/1

integer_literal(Node) ->
    V = case unwrap(Node) of 
	    {integer, _, Value} -> Value;
	    Node1 -> data(Node1)
	end,
    case is_list(V) of 
	true -> V;
	_ ->integer_to_list(V)
    end.

%% =====================================================================
%% @spec float(Value::float()) -> syntaxTree()
%%
%% @doc Creates an abstract floating-point literal. The lexical
%% representation is the decimal floating-point numeral of
%% <code>Value</code>.
%%
%% @see float_value/1
%% @see float_literal/1

%% type(Node) = float
%% data(Node) = Value
%%
%%	Value = float()
%%
%% `erl_parse' representation:
%%
%% {float, Pos, Value}
%%
%%	Value = float()

%% Note that under current versions of Erlang, the name `float/1' cannot
%% be used for local calls (i.e., within the module) - it will be
%% overridden by the type conversion BIF of the same name, so always use
%% `make_float/1' for local calls.

float(Value) -> make_float(Value).

make_float(Value) -> tree(float, Value).

revert_float(Node) ->
    Pos = get_pos(Node), {float, Pos, float_value(Node)}.

%% =====================================================================
%% @spec float_value(syntaxTree()) -> float()
%%
%% @doc Returns the value represented by a <code>float</code> node. Note
%% that floating-point values should usually not be compared for
%% equality.
%%
%% @see float/1

float_value(Node) ->
    case unwrap(Node) of
      {float, _, Value} -> Value;
      Node1 -> data(Node1)
    end.

%% =====================================================================
%% @spec float_literal(syntaxTree()) -> string()
%%
%% @doc Returns the numeral string represented by a <code>float</code>
%% node.
%%
%% @see float/1

float_literal(Node) -> io_lib:write(float_value(Node)).

%% =====================================================================
%% @spec char(Value::char()) -> syntaxTree()
%%
%% @doc Creates an abstract character literal. The result represents
%% "<code>$<em>Name</em></code>", where <code>Name</code> corresponds to
%% <code>Value</code>.
%%
%% <p>Note: the literal corresponding to a particular character value is
%% not uniquely defined. E.g., the character "<code>a</code>" can be
%% written both as "<code>$a</code>" and "<code>$\141</code>", and a Tab
%% character can be written as "<code>$\11</code>", "<code>$\011</code>"
%% or "<code>$\t</code>".</p>
%%
%% @see char_value/1
%% @see char_literal/1
%% @see is_char/2

%% type(Node) = char
%% data(Node) = char()
%%
%% `erl_parse' representation:
%%
%% {char, Pos, Code}
%%
%%	Code = integer()

char(Char) -> tree(char, Char).

revert_char(Node) ->
    Pos = get_pos(Node), {char, Pos, char_value(Node)}.

%% =====================================================================
%% @spec is_char(Node::syntaxTree(), Value::char()) -> bool()
%%
%% @doc Returns <code>true</code> if <code>Node</code> has type
%% <code>char</code> and represents <code>Value</code>, otherwise
%% <code>false</code>.
%%
%% @see char/1

is_char(Node, Value) ->
    case unwrap(Node) of
      {char, _, Value} -> true;
      #tree{type = char, data = Value} -> true;
      _ -> false
    end.

%% =====================================================================
%% @spec char_value(syntaxTree()) -> char()
%%
%% @doc Returns the value represented by a <code>char</code> node.
%%
%% @see char/1

char_value(Node) ->
    case unwrap(Node) of
      {char, _, Char} -> Char;
      Node1 -> data(Node1)
    end.

%% =====================================================================
%% @spec char_literal(syntaxTree()) -> string()
%%
%% @doc Returns the literal string represented by a <code>char</code>
%% node. This includes the leading "<code>$</code>" character.
%%
%% @see char/1

char_literal(Node) ->
    io_lib:write_char(char_value(Node)).

%% =====================================================================
%% @spec string(Value::string()) -> syntaxTree()
%%
%% @doc Creates an abstract string literal. The result represents
%% <code>"<em>Text</em>"</code> (including the surrounding
%% double-quotes), where <code>Text</code> corresponds to the sequence
%% of characters in <code>Value</code>, but not representing a
%% <em>specific</em> string literal. E.g., the result of
%% <code>string("x\ny")</code> represents any and all of
%% <code>"x\ny"</code>, <code>"x\12y"</code>, <code>"x\012y"</code> and
%% <code>"x\^Jy"</code>; cf. <code>char/1</code>.
%%
%% @see string_value/1
%% @see string_literal/1
%% @see is_string/2
%% @see char/1

%% type(Node) = string
%% data(Node) = string()
%%
%% `erl_parse' representation:
%%
%% {string, Pos, Chars}
%%
%%	Chars = string()

string(String) -> tree(string, String).

revert_string(Node) ->
    Pos = get_pos(Node), {string, Pos, string_value(Node)}.

%% =====================================================================
%% @spec is_string(Node::syntaxTree(), Value::string()) -> bool()
%%
%% @doc Returns <code>true</code> if <code>Node</code> has type
%% <code>string</code> and represents <code>Value</code>, otherwise
%% <code>false</code>.
%%
%% @see string/1

is_string(Node, Value) ->
    case unwrap(Node) of
      {string, _, Value} -> true;
      #tree{type = string, data = Value} -> true;
      _ -> false
    end.

%% =====================================================================
%% @spec string_value(syntaxTree()) -> string()
%%
%% @doc Returns the value represented by a <code>string</code> node.
%%
%% @see string/1

string_value(Node) ->
    case unwrap(Node) of
      {string, _, List} -> List;
      Node1 -> data(Node1)
    end.

%% =====================================================================
%% @spec string_literal(syntaxTree()) -> string()
%%
%% @doc Returns the literal string represented by a <code>string</code>
%% node. This includes surrounding double-quote characters.
%%
%% @see string/1

string_literal(Node) ->
    io_lib:write_string(string_value(Node)).

%% =====================================================================
%% @spec atom(Name) -> syntaxTree()
%%	    Name = atom() | string()
%%
%% @doc Creates an abstract atom literal. The print name of the atom is
%% the character sequence represented by <code>Name</code>.
%%
%% @see atom_value/1
%% @see atom_name/1
%% @see atom_literal/1
%% @see is_atom/2

%% type(Node) = atom
%% data(Node) = atom()
%%
%% `erl_parse' representation:
%%
%% {atom, Pos, Value}
%%
%%	Value = atom()
 
atom(Name) when is_atom(Name) -> tree(atom, Name);
atom(Name) -> tree(atom, list_to_atom(Name)).

revert_atom(Node) ->
    Pos = get_pos(Node), {atom, Pos, atom_value(Node)}.

%% =====================================================================
%% @spec is_atom(Node::syntaxTree(), Value::atom()) -> bool()
%%
%% @doc Returns <code>true</code> if <code>Node</code> has type
%% <code>atom</code> and represents <code>Value</code>, otherwise
%% <code>false</code>.
%%
%% @see atom/1

is_atom(Node, Value) ->
    case unwrap(Node) of
      {atom, _, Value} -> true;
      #tree{type = atom, data = Value} -> true;
      _ -> false
    end.

%% =====================================================================
%% @spec atom_value(syntaxTree())-> atom()
%%
%% @doc Returns the value represented by an <code>atom</code> node.
%%
%% @see atom/1

atom_value(Node) ->
    case unwrap(Node) of
      {atom, _, Name} -> Name;
      Node1 -> data(Node1)
    end.

%% =====================================================================
%% @spec atom_name(syntaxTree()) -> string()
%%
%% @doc Returns the printname of an <code>atom</code> node.
%%
%% @see atom/1

atom_name(Node) -> atom_to_list(atom_value(Node)).

%% =====================================================================
%% @spec atom_literal(syntaxTree()) -> string()
%%
%% @doc Returns the literal string represented by an <code>atom</code>
%% node. This includes surrounding single-quote characters if necessary.
%%
%% <p>Note that e.g. the result of <code>atom("x\ny")</code> represents
%% any and all of <code>'x\ny'</code>, <code>'x\12y'</code>,
%% <code>'x\012y'</code> and <code>'x\^Jy\'</code>; cf.
%% <code>string/1</code>.</p>
%%
%% @see atom/1
%% @see string/1

atom_literal(Node) ->
    io_lib:write_atom(atom_value(Node)).

%% =====================================================================
%% @spec tuple(Elements::[syntaxTree()]) -> syntaxTree()
%%
%% @doc Creates an abstract tuple. If <code>Elements</code> is
%% <code>[X1, ..., Xn]</code>, the result represents
%% "<code>{<em>X1</em>, ..., <em>Xn</em>}</code>".
%%
%% <p>Note: The Erlang language has distinct 1-tuples, i.e.,
%% <code>{X}</code> is always distinct from <code>X</code> itself.</p>
%%
%% @see tuple_elements/1
%% @see tuple_size/1

%% type(Node) = tuple
%% data(Node) = Elements
%%
%%	Elements = [syntaxTree()]
%%
%% `erl_parse' representation:
%%
%% {tuple, Pos, Elements}
%%
%%	Elements = [erl_parse()]

tuple(List) -> tree(tuple, List).

revert_tuple(Node) ->
    Pos = get_pos(Node), {tuple, Pos, tuple_elements(Node)}.

%% =====================================================================
%% @spec tuple_elements(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of element subtrees of a <code>tuple</code>
%% node.
%%
%% @see tuple/1

tuple_elements(Node) ->
    case unwrap(Node) of
      {tuple, _, List} -> List;
      Node1 -> data(Node1)
    end.

%% =====================================================================
%% @spec tuple_size(syntaxTree()) -> integer()
%%
%% @doc Returns the number of elements of a <code>tuple</code> node.
%%
%% <p>Note: this is equivalent to
%% <code>length(tuple_elements(Node))</code>, but potentially more
%% efficient.</p>
%%
%% @see tuple/1
%% @see tuple_elements/1

tuple_size(Node) -> length(tuple_elements(Node)).

%% =====================================================================
%% @spec list(List) -> syntaxTree()
%% @equiv list(List, none)

list(List) -> list(List, none).

%% =====================================================================
%% @spec list(List, Tail) -> syntaxTree()
%%	    List = [syntaxTree()]
%%	    Tail = none | syntaxTree()
%%
%% @doc Constructs an abstract list skeleton. The result has type
%% <code>list</code> or <code>nil</code>. If <code>List</code> is a
%% nonempty list <code>[E1, ..., En]</code>, the result has type
%% <code>list</code> and represents either "<code>[<em>E1</em>, ...,
%% <em>En</em>]</code>", if <code>Tail</code> is <code>none</code>, or
%% otherwise "<code>[<em>E1</em>, ..., <em>En</em> |
%% <em>Tail</em>]</code>". If <code>List</code> is the empty list,
%% <code>Tail</code> <em>must</em> be <code>none</code>, and in that
%% case the result has type <code>nil</code> and represents
%% "<code>[]</code>" (cf. <code>nil/0</code>).
%%
%% <p>The difference between lists as semantic objects (built up of
%% individual "cons" and "nil" terms) and the various syntactic forms
%% for denoting lists may be bewildering at first. This module provides
%% functions both for exact control of the syntactic representation as
%% well as for the simple composition and deconstruction in terms of
%% cons and head/tail operations.</p>
%%
%% <p>Note: in <code>list(Elements, none)</code>, the "nil" list
%% terminator is implicit and has no associated information (cf.
%% <code>get_attrs/1</code>), while in the seemingly equivalent
%% <code>list(Elements, Tail)</code> when <code>Tail</code> has type
%% <code>nil</code>, the list terminator subtree <code>Tail</code> may
%% have attached attributes such as position, comments, and annotations,
%% which will be preserved in the result.</p>
%%
%% @see nil/0
%% @see list/1
%% @see list_prefix/1
%% @see list_suffix/1
%% @see cons/2
%% @see list_head/1
%% @see list_tail/1
%% @see is_list_skeleton/1
%% @see is_proper_list/1
%% @see list_elements/1
%% @see list_length/1
%% @see normalize_list/1
%% @see compact_list/1
%% @see get_attrs/1

-record(list, {prefix, suffix}).

%% type(Node) = list
%% data(Node) = #list{prefix :: Elements, suffix :: Tail}
%%
%%	    Elements = [syntaxTree()]
%%	    Tail = none | syntaxTree()
%%
%% `erl_parse' representation:
%%
%% {cons, Pos, Head, Tail}
%%
%%	Head = Tail = [erl_parse()]
%%
%%	This represents `[<Head> | <Tail>]', or more generally `[<Head>
%%	<Suffix>]' where the form of <Suffix> can depend on the
%%	structure of <Tail>; there is no fixed printed form.

list([], none) -> nil();
list(Elements, Tail) when Elements /= [] ->
    tree(list, #list{prefix = Elements, suffix = Tail}).

revert_list(Node) ->
    Pos = get_pos(Node),
    P = list_prefix(Node),
    S = case list_suffix(Node) of
	  none -> revert_nil(set_pos(nil(), Pos));
	  S1 -> S1
	end,
    lists:foldr(fun (X, A) -> {cons, Pos, X, A} end, S, P).

%% =====================================================================
%% @spec nil() -> syntaxTree()
%%
%% @doc Creates an abstract empty list. The result represents
%% "<code>[]</code>". The empty list is traditionally called "nil".
%%
%% @see list/2
%% @see is_list_skeleton/1

%% type(Node) = nil
%% data(Node) = term()
%%
%% `erl_parse' representation:
%%
%% {nil, Pos}

nil() -> tree(nil).

revert_nil(Node) -> Pos = get_pos(Node), {nil, Pos}.

%% =====================================================================
%% @spec list_prefix(Node::syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the prefix element subtrees of a <code>list</code> node.
%% If <code>Node</code> represents "<code>[<em>E1</em>, ...,
%% <em>En</em>]</code>" or "<code>[<em>E1</em>, ..., <em>En</em> |
%% <em>Tail</em>]</code>", the returned value is <code>[E1, ...,
%% En]</code>.
%%
%% @see list/2

list_prefix(Node) ->
    case unwrap(Node) of
      {cons, _, Head, _} -> [Head];
      Node1 -> (data(Node1))#list.prefix
    end.

%% =====================================================================
%% @spec list_suffix(Node::syntaxTree()) ->  none | syntaxTree()
%%
%% @doc Returns the suffix subtree of a <code>list</code> node, if one
%% exists. If <code>Node</code> represents "<code>[<em>E1</em>, ...,
%% <em>En</em> | <em>Tail</em>]</code>", the returned value is
%% <code>Tail</code>, otherwise, i.e., if <code>Node</code> represents
%% "<code>[<em>E1</em>, ..., <em>En</em>]</code>", <code>none</code> is
%% returned.
%%
%% <p>Note that even if this function returns some <code>Tail</code>
%% that is not <code>none</code>, the type of <code>Tail</code> can be
%% <code>nil</code>, if the tail has been given explicitly, and the list
%% skeleton has not been compacted (cf.
%% <code>compact_list/1</code>).</p>
%%
%% @see list/2
%% @see nil/0
%% @see compact_list/1

list_suffix(Node) ->
    case unwrap(Node) of
      {cons, _, _, Tail} ->
	  %% If there could be comments/annotations on the tail node,
	  %% we should not return `none' even if it has type `nil'.
	  case Tail of
	    {nil, _} ->
		none;    % no interesting information is lost
	    _ -> Tail
	  end;
      Node1 -> (data(Node1))#list.suffix
    end.

%% =====================================================================
%% @spec cons(Head::syntaxTree(), Tail::syntaxTree()) -> syntaxTree()
%%
%% @doc "Optimising" list skeleton cons operation. Creates an abstract
%% list skeleton whose first element is <code>Head</code> and whose tail
%% corresponds to <code>Tail</code>. This is similar to
%% <code>list([Head], Tail)</code>, except that <code>Tail</code> may
%% not be <code>none</code>, and that the result does not necessarily
%% represent exactly "<code>[<em>Head</em> | <em>Tail</em>]</code>", but
%% may depend on the <code>Tail</code> subtree. E.g., if
%% <code>Tail</code> represents <code>[X, Y]</code>, the result may
%% represent "<code>[<em>Head</em>, X, Y]</code>", rather than
%% "<code>[<em>Head</em> | [X, Y]]</code>". Annotations on
%% <code>Tail</code> itself may be lost if <code>Tail</code> represents
%% a list skeleton, but comments on <code>Tail</code> are propagated to
%% the result.
%%
%% @see list/2
%% @see list_head/1
%% @see list_tail/1

cons(Head, Tail) ->
    case type(Tail) of
      list ->
	  copy_comments(Tail,
			list([Head | list_prefix(Tail)], list_suffix(Tail)));
      nil -> copy_comments(Tail, list([Head]));
      _ -> list([Head], Tail)
    end.

%% =====================================================================
%% @spec list_head(Node::syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the head element subtree of a <code>list</code> node. If
%% <code>Node</code> represents "<code>[<em>Head</em> ...]</code>", the
%% result will represent "<code><em>Head</em></code>".
%%
%% @see list/2
%% @see list_tail/1
%% @see cons/2

list_head(Node) -> hd(list_prefix(Node)).

%% =====================================================================
%% list_tail(Node::syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the tail of a <code>list</code> node. If
%% <code>Node</code> represents a single-element list
%% "<code>[<em>E</em>]</code>", then the result has type
%% <code>nil</code>, representing "<code>[]</code>". If
%% <code>Node</code> represents "<code>[<em>E1</em>, <em>E2</em>
%% ...]</code>", the result will represent "<code>[<em>E2</em>
%% ...]</code>", and if <code>Node</code> represents
%% "<code>[<em>Head</em> | <em>Tail</em>]</code>", the result will
%% represent "<code><em>Tail</em></code>".
%%
%% @see list/2
%% @see list_head/1
%% @see cons/2

list_tail(Node) ->
    Tail = list_suffix(Node),
    case tl(list_prefix(Node)) of
      [] ->
	  if Tail == none ->
		 nil();    % implicit list terminator.
	     true -> Tail
	  end;
      Es ->
	  list(Es, Tail)    % `Es' is nonempty.
    end.

%% =====================================================================
%% @spec is_list_skeleton(syntaxTree()) -> bool()
%%
%% @doc Returns <code>true</code> if <code>Node</code> has type
%% <code>list</code> or <code>nil</code>, otherwise <code>false</code>.
%%
%% @see list/2
%% @see nil/0

is_list_skeleton(Node) ->
    case type(Node) of
      list -> true;
      nil -> true;
      _ -> false
    end.

%% =====================================================================
%% @spec is_proper_list(Node::syntaxTree()) -> bool()
%%
%% @doc Returns <code>true</code> if <code>Node</code> represents a
%% proper list, and <code>false</code> otherwise. A proper list is a
%% list skeleton either on the form "<code>[]</code>" or
%% "<code>[<em>E1</em>, ..., <em>En</em>]</code>", or "<code>[... |
%% <em>Tail</em>]</code>" where recursively <code>Tail</code> also
%% represents a proper list.
%%
%% <p>Note: Since <code>Node</code> is a syntax tree, the actual
%% run-time values corresponding to its subtrees may often be partially
%% or completely unknown. Thus, if <code>Node</code> represents e.g.
%% "<code>[... | Ns]</code>" (where <code>Ns</code> is a variable), then
%% the function will return <code>false</code>, because it is not known
%% whether <code>Ns</code> will be bound to a list at run-time. If
%% <code>Node</code> instead represents e.g. "<code>[1, 2, 3]</code>" or
%% "<code>[A | []]</code>", then the function will return
%% <code>true</code>.</p>
%%
%% @see list/2

is_proper_list(Node) ->
    case type(Node) of
      list ->
	  case list_suffix(Node) of
	    none -> true;
	    Tail -> is_proper_list(Tail)
	  end;
      nil -> true;
      _ -> false
    end.

%% =====================================================================
%% @spec list_elements(Node::syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of element subtrees of a list skeleton.
%% <code>Node</code> must represent a proper list. E.g., if
%% <code>Node</code> represents "<code>[<em>X1</em>, <em>X2</em> |
%% [<em>X3</em>, <em>X4</em> | []]</code>", then
%% <code>list_elements(Node)</code> yields the list <code>[X1, X2, X3,
%% X4]</code>.
%%
%% @see list/2
%% @see is_proper_list/1

list_elements(Node) ->
    lists:reverse(list_elements(Node, [])).

list_elements(Node, As) ->
    case type(Node) of
      list ->
	    As1 = lists:reverse(list_prefix(Node)) ++ As,
	    case list_suffix(Node) of
	    none -> As1;
	    Tail -> list_elements(Tail, As1)
	  end;
      nil -> As
    end.

%% =====================================================================
%% list_length(Node::syntaxTree()) -> integer()
%%
%% @doc Returns the number of element subtrees of a list skeleton.
%% <code>Node</code> must represent a proper list. E.g., if
%% <code>Node</code> represents "<code>[X1 | [X2, X3 | [X4, X5,
%% X6]]]</code>", then <code>list_length(Node)</code> returns the
%% integer 6.
%%
%% <p>Note: this is equivalent to
%% <code>length(list_elements(Node))</code>, but potentially more
%% efficient.</p>
%%
%% @see list/2
%% @see is_proper_list/1
%% @see list_elements/1

list_length(Node) -> list_length(Node, 0).

list_length(Node, A) ->
    case type(Node) of
      list ->
	  A1 = length(list_prefix(Node)) + A,
	  case list_suffix(Node) of
	    none -> A1;
	    Tail -> list_length(Tail, A1)
	  end;
      nil -> A;
      _ -> A +1    
    end.

%% =====================================================================
%% @spec normalize_list(Node::syntaxTree()) -> syntaxTree()
%%
%% @doc Expands an abstract list skeleton to its most explicit form. If
%% <code>Node</code> represents "<code>[<em>E1</em>, ..., <em>En</em> |
%% <em>Tail</em>]</code>", the result represents "<code>[<em>E1</em> |
%% ... [<em>En</em> | <em>Tail1</em>] ... ]</code>", where
%% <code>Tail1</code> is the result of
%% <code>normalize_list(Tail)</code>. If <code>Node</code> represents
%% "<code>[<em>E1</em>, ..., <em>En</em>]</code>", the result simply
%% represents "<code>[<em>E1</em> | ... [<em>En</em> | []] ...
%% ]</code>". If <code>Node</code> does not represent a list skeleton,
%% <code>Node</code> itself is returned.
%%
%% @see list/2
%% @see compact_list/1

normalize_list(Node) ->
    case type(Node) of
      list ->
	  P = list_prefix(Node),
	  case list_suffix(Node) of
	    none -> copy_attrs(Node, normalize_list_1(P, nil()));
	    Tail ->
		Tail1 = normalize_list(Tail),
		copy_attrs(Node, normalize_list_1(P, Tail1))
	  end;
      _ -> Node
    end.

normalize_list_1(Es, Tail) ->
    lists:foldr(fun (X, A) ->
			list([X], A)    % not `cons'!
		end,
		Tail, Es).

%% =====================================================================
%% @spec compact_list(Node::syntaxTree()) -> syntaxTree()
%%
%% @doc Yields the most compact form for an abstract list skeleton. The
%% result either represents "<code>[<em>E1</em>, ..., <em>En</em> |
%% <em>Tail</em>]</code>", where <code>Tail</code> is not a list
%% skeleton, or otherwise simply "<code>[<em>E1</em>, ...,
%% <em>En</em>]</code>". Annotations on subtrees of <code>Node</code>
%% that represent list skeletons may be lost, but comments will be
%% propagated to the result. Returns <code>Node</code> itself if
%% <code>Node</code> does not represent a list skeleton.
%%
%% @see list/2
%% @see normalize_list/1

compact_list(Node) ->
    case type(Node) of
      list ->
	  case list_suffix(Node) of
	    none -> Node;
	    Tail ->
		case type(Tail) of
		  list ->  %% Modified by HL;
			Tail1 = compact_list(Tail),
			Prefix = case list_prefix(Tail1) of
				      [H] ->
					 [join_comments(Tail1, H)];
				     [H|T] ->
					 Prefix1 =[add_precomments(get_precomments(Tail1), H)|T],
					 case list_suffix(Tail1) of
					     none ->
						 [H1|T1] = lists:reverse(Prefix1),
						 lists:reverse([add_postcomments(get_postcomments(Tail1), H1)|T1]);					          
					     _ -> Prefix1
					 end						  
				 end,
			Suffix = case list_suffix(Tail1) of
				     none -> none;
				     S -> add_postcomments(get_postcomments(Tail1), S)
				 end,					      
			Node1 = list(list_prefix(Node) ++Prefix,
				    Suffix),
			copy_attrs(Node, Node1);
		    nil ->
			Node1 = list(list_prefix(Node)),
			join_comments(Tail, copy_attrs(Node, Node1));
		    _ -> Node
		end
	  end;
      _ -> Node
    end.

%% =====================================================================
%% @spec binary(Fields::[syntaxTree()]) -> syntaxTree()
%%
%% @doc Creates an abstract binary-object template. If
%% <code>Fields</code> is <code>[F1, ..., Fn]</code>, the result
%% represents "<code>&lt;&lt;<em>F1</em>, ...,
%% <em>Fn</em>&gt;&gt;</code>".
%%
%% @see binary_fields/1
%% @see binary_field/2

%% type(Node) = binary
%% data(Node) = Fields
%%
%%	Fields = [syntaxTree()]
%%
%% `erl_parse' representation:
%%
%% {bin, Pos, Fields}
%%
%%	Fields = [Field]
%%	Field = {bin_element, ...}
%%
%%	See `binary_field' for documentation on `erl_parse' binary
%%	fields (or "elements").

binary(List) -> tree(binary, List).

revert_binary(Node) ->
    Pos = get_pos(Node), {bin, Pos, binary_fields(Node)}.

%% =====================================================================
%% @spec binary_fields(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of field subtrees of a <code>binary</code>
%% node.
%%
%% @see binary/1
%% @see binary_field/2

binary_fields(Node) ->
    case unwrap(Node) of
      {bin, _, List} -> List;
      Node1 -> data(Node1)
    end.

%% =====================================================================
%% @spec binary_field(Body) -> syntaxTree()
%% @equiv binary_field(Body, [])

binary_field(Body) -> binary_field(Body, []).

%% =====================================================================
%% @spec binary_field(Body::syntaxTree(), Size,
%%                    Types::[syntaxTree()]) -> syntaxTree()
%%	    Size = none | syntaxTree()
%%
%% @doc Creates an abstract binary template field. (Utility function.)
%% If <code>Size</code> is <code>none</code>, this is equivalent to
%% "<code>binary_field(Body, Types)</code>", otherwise it is
%% equivalent to "<code>binary_field(size_qualifier(Body, Size),
%% Types)</code>".
%%
%% @see binary/1
%% @see binary_field/2
%% @see size_qualifier/2

binary_field(Body, none, Types) ->
    binary_field(Body, Types);
binary_field(Body, Size, Types) ->
    binary_field(size_qualifier(Body, Size), Types).

%% =====================================================================
%% @spec binary_field(Body::syntaxTree(), Types::[syntaxTree()]) ->
%%           syntaxTree()
%%
%% @doc Creates an abstract binary template field. If
%% <code>Types</code> is the empty list, the result simply represents
%% "<code><em>Body</em></code>", otherwise, if <code>Types</code> is
%% <code>[T1, ..., Tn]</code>, the result represents
%% "<code><em>Body</em>/<em>T1</em>-...-<em>Tn</em></code>".
%%
%% @see binary/1
%% @see binary_field/1
%% @see binary_field/3
%% @see binary_field_body/1
%% @see binary_field_types/1
%% @see binary_field_size/1

-record(binary_field, {body, types}).

%% type(Node) = binary_field
%% data(Node) = #binary_field{body :: Body, types :: Types}
%%
%%	    Body = syntaxTree()
%%	    Types = [Type]
%%
%% `erl_parse' representation:
%%
%% {bin_element, Pos, Expr, Size, TypeList}
%%
%%	Expr = erl_parse()
%%	Size = default | erl_parse()
%%	TypeList = default | [Type] \ []
%%	Type = atom() | {atom(), integer()}

binary_field(Body, Types) ->
    tree(binary_field,
	 #binary_field{body = Body, types = Types}).

revert_binary_field(Node) ->
    Pos = get_pos(Node),
    Body = binary_field_body(Node),
    {Expr, Size} = case type(Body) of
		     size_qualifier ->
			 %% Note that size qualifiers are not
			 %% revertible out of context.
			 {size_qualifier_body(Body),
			  size_qualifier_argument(Body)};
		     _ -> {Body, default}
		   end,
    Types = case binary_field_types(Node) of
	      [] -> default;
	      Ts -> fold_binary_field_types(Ts)
	    end,
    {bin_element, Pos, Expr, Size, Types}.

%% =====================================================================
%% @spec binary_field_body(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the body subtree of a <code>binary_field</code>.
%%
%% @see binary_field/2

binary_field_body(Node) ->
    case unwrap(Node) of
      {bin_element, _, Body, Size, _} ->
	  if Size == default -> Body;
	     true -> size_qualifier(Body, Size)
	  end;
      Node1 -> (data(Node1))#binary_field.body
    end.

%% =====================================================================
%% @spec binary_field_types(Node::syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of type-specifier subtrees of a
%% <code>binary_field</code> node. If <code>Node</code> represents
%% "<code>.../<em>T1</em>, ..., <em>Tn</em></code>", the result is
%% <code>[T1, ..., Tn]</code>, otherwise the result is the empty list.
%%
%% @see binary_field/2

binary_field_types(Node) ->
    case unwrap(Node) of
      {bin_element, Pos, _, Size, Types} ->
	  if Types == default -> [];
	     true -> 
		  {L, C} = case Size==default of 
			       true->
				   Pos;
			       _ -> get_pos(Size)
			   end,
		  %% TODO: the type info is not accurate here;
                  %% should change the parse to return tokens of type
		  %% instead of kust values.
		  unfold_binary_field_types(Types, {L, C+10}) 
	  end;
      Node1 -> (data(Node1))#binary_field.types
    end.

%% =====================================================================
%% @spec binary_field_size(Node::syntaxTree()) -> none | syntaxTree()
%%
%% @doc Returns the size specifier subtree of a
%% <code>binary_field</code> node, if any. (Utility function.) If
%% <code>Node</code> represents
%% "<code><em>Body</em>:<em>Size</em></code>" or
%% "<code><em>Body</em>:<em>Size</em>/<em>T1</em>, ...,
%% <em>Tn</em></code>", the result is <code>Size</code>, otherwise
%% <code>none</code> is returned.
%%
%% @see binary_field/2
%% @see binary_field/3

binary_field_size(Node) ->
    case unwrap(Node) of
      {bin_element, _, _, Size, _} ->
	  if Size == default -> none;
	     true -> Size
	  end;
      Node1 ->
	  Body = (data(Node1))#binary_field.body,
	  case type(Body) of
	    size_qualifier -> size_qualifier_argument(Body);
	    _ -> none
	  end
    end.

%% =====================================================================
%% @spec size_qualifier(Body::syntaxTree(), Size::syntaxTree()) ->
%%           syntaxTree()
%%
%% @doc Creates an abstract size qualifier. The result represents
%% "<code><em>Body</em>:<em>Size</em></code>".
%%
%% @see size_qualifier_body/1
%% @see size_qualifier_argument/1

-record(size_qualifier, {body, size}).

%% type(Node) = size_qualifier
%% data(Node) = #size_qualifier{body :: Body, size :: Size}
%%
%%	Body = Size = syntaxTree()

size_qualifier(Body, Size) ->
    tree(size_qualifier,
	 #size_qualifier{body = Body, size = Size}).

%% =====================================================================
%% @spec size_qualifier_body(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the body subtree of a <code>size_qualifier</code>
%% node.
%%
%% @see size_qualifier/2

size_qualifier_body(Node) ->
    (data(Node))#size_qualifier.body.

%% =====================================================================
%% @spec size_qualifier_argument(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the argument subtree (the size) of a
%% <code>size_qualifier</code> node.
%%
%% @see size_qualifier/2

size_qualifier_argument(Node) ->
    (data(Node))#size_qualifier.size.

%% =====================================================================
%% @spec error_marker(Error::term()) -> syntaxTree()
%%
%% @doc Creates an abstract error marker. The result represents an
%% occurrence of an error in the source code, with an associated Erlang
%% I/O ErrorInfo structure given by <code>Error</code> (see module
%% <code>io</code> for details). Error markers are regarded as source
%% code forms, but have no defined lexical form.
%%
%% <p>Note: this is supported only for backwards compatibility with
%% existing parsers and tools.</p>
%%
%% @see error_marker_info/1
%% @see warning_marker/1
%% @see eof_marker/0
%% @see is_form/1
%% @see io

%% type(Node) = error_marker
%% data(Node) = term()
%%
%% `erl_parse' representation:
%%
%% {error, Error}
%%
%%	Error = term()
%%
%%	Note that there is no position information for the node
%%	itself: `get_pos' and `set_pos' handle this as a special case.

error_marker(Error) -> tree(error_marker, Error).

revert_error_marker(Node) ->
    %% Note that the position information of the node itself is not
    %% preserved.
    {error, error_marker_info(Node)}.

%% =====================================================================
%% @spec error_marker_info(syntaxTree()) -> term()
%%
%% @doc Returns the ErrorInfo structure of an <code>error_marker</code>
%% node.
%%
%% @see error_marker/1

error_marker_info(Node) ->
    case unwrap(Node) of
      {error, Error} -> Error;
      T -> data(T)
    end.

%% =====================================================================
%% @spec warning_marker(Error::term()) -> syntaxTree()
%%
%% @doc Creates an abstract warning marker. The result represents an
%% occurrence of a possible problem in the source code, with an
%% associated Erlang I/O ErrorInfo structure given by <code>Error</code>
%% (see module <code>io</code> for details). Warning markers are
%% regarded as source code forms, but have no defined lexical form.
%%
%% <p>Note: this is supported only for backwards compatibility with
%% existing parsers and tools.</p>
%%
%% @see warning_marker_info/1
%% @see error_marker/1
%% @see eof_marker/0
%% @see is_form/1
%% @see io

%% type(Node) = warning_marker
%% data(Node) = term()
%%
%% `erl_parse' representation:
%%
%% {warning, Error}
%%
%%	Error = term()
%%
%%	Note that there is no position information for the node
%%	itself: `get_pos' and `set_pos' handle this as a special case.

warning_marker(Warning) ->
    tree(warning_marker, Warning).

revert_warning_marker(Node) ->
    %% Note that the position information of the node itself is not
    %% preserved.
    {warning, warning_marker_info(Node)}.

%% =====================================================================
%% @spec warning_marker_info(syntaxTree()) -> term()
%%
%% @doc Returns the ErrorInfo structure of a <code>warning_marker</code>
%% node.
%%
%% @see warning_marker/1

warning_marker_info(Node) ->
    case unwrap(Node) of
      {warning, Error} -> Error;
      T -> data(T)
    end.

%% =====================================================================
%% @spec eof_marker() -> syntaxTree()
%%
%% @doc Creates an abstract end-of-file marker. This represents the
%% end of input when reading a sequence of source code forms. An
%% end-of-file marker is itself regarded as a source code form
%% (namely, the last in any sequence in which it occurs). It has no
%% defined lexical form.
%%
%% <p>Note: this is retained only for backwards compatibility with
%% existing parsers and tools.</p>
%%
%% @see error_marker/1
%% @see warning_marker/1
%% @see is_form/1

%% type(Node) = eof_marker
%% data(Node) = term()
%%
%% `erl_parse' representation:
%%
%% {eof, Pos}

eof_marker() -> tree(eof_marker).

revert_eof_marker(Node) ->
    Pos = get_pos(Node), {eof, Pos}.

%% =====================================================================
%% @spec attribute(Name) -> syntaxTree()
%% @equiv attribute(Name, none)

attribute(Name) -> attribute(Name, none).

%% =====================================================================
%% @spec attribute(Name::syntaxTree(), Arguments) -> syntaxTree()
%%           Arguments = none | [syntaxTree()]
%%
%% @doc Creates an abstract program attribute. If
%% <code>Arguments</code> is <code>[A1, ..., An]</code>, the result
%% represents "<code>-<em>Name</em>(<em>A1</em>, ...,
%% <em>An</em>).</code>". Otherwise, if <code>Arguments</code> is
%% <code>none</code>, the result represents
%% "<code>-<em>Name</em>.</code>". The latter form makes it possible
%% to represent preprocessor directives such as
%% "<code>-endif.</code>". Attributes are source code forms.
%%
%% <p>Note: The preprocessor macro definition directive
%% "<code>-define(<em>Name</em>, <em>Body</em>).</code>" has relatively
%% few requirements on the syntactical form of <code>Body</code> (viewed
%% as a sequence of tokens). The <code>text</code> node type can be used
%% for a <code>Body</code> that is not a normal Erlang construct.</p>
%%
%% @see attribute/1
%% @see attribute_name/1
%% @see attribute_arguments/1
%% @see text/1
%% @see is_form/1

-record(attribute, {name, args}).

%% type(Node) = attribute
%% data(Node) = #attribute{name :: Name, args :: Arguments}
%%
%%	Name = syntaxTree()
%%	Arguments = none | [syntaxTree()]
%%
%% `erl_parse' representation:
%%
%% {attribute, Pos, module, {Name,Vars}}
%% {attribute, Pos, module, Name}
%%
%%	Name = atom() | [atom()]
%%	Vars = [atom()]
%%
%%	Representing `-module(M).', or `-module(M, Vs).', where M is
%%	`A1.A2.....An' if Name is `[A1, A2, ..., An]', and Vs is `[V1,
%%	..., Vm]' if Vars is `[V1, ..., Vm]'.
%%
%% {attribute, Pos, export, Exports}
%%
%%	Exports = [{atom(), integer()}]
%%
%%	Representing `-export([A1/N1, ..., Ak/Nk]).', if `Exports' is
%%	`[{A1, N1}, ..., {Ak, Nk}]'.
%%
%% {attribute, Pos, import, Imports}
%%
%%	Imports = {atom(), Pairs} | [atom()]
%%	Pairs = [{atom(), integer()]
%%
%%	Representing `-import(Module, [A1/N1, ..., Ak/Nk]).', if
%%	`Imports' is `{Module, [{A1, N1}, ..., {Ak, Nk}]}', or
%%	`-import(A1.....An).', if `Imports' is `[A1, ..., An]'.
%%
%% {attribute, Pos, file, Position}
%%
%%	Position = {filename(), integer()}
%%
%%	Representing `-file(Name, Line).', if `Position' is `{Name,
%%	Line}'.
%%
%% {attribute, Pos, record, Info}
%%
%%	Info = {Name, [Entries]}
%%	Name = atom()
%%	Entries = {record_field, Pos, atom()}
%%		| {record_field, Pos, atom(), erl_parse()}
%%
%%	Representing `-record(Name, {<F1>, ..., <Fn>}).', if `Info' is
%%	`{Name, [D1, ..., D1]}', where each `Fi' is either `Ai = <Ei>',
%%	if the corresponding `Di' is `{record_field, Pos, Ai, Ei}', or
%%	otherwise simply `Ai', if `Di' is `{record_field, Pos, Ai}'.
%%
%% {attribute, L, Name, Term}
%%
%%	Name = atom() \ StandardName
%%	StandardName = module | export | import | file | record
%%	Term = term()
%%
%%	Representing `-Name(Term).'.

attribute(Name, Args) ->
    tree(attribute, #attribute{name = Name, args = Args}).

revert_attribute(Node) ->
    Name = attribute_name(Node),
    Args = attribute_arguments(Node),
    Pos = get_pos(Node),
    case type(Name) of
      atom ->
	  revert_attribute_1(atom_value(Name), Args, Pos, Node);
      _ -> Node
    end.

%% All the checking makes this part a bit messy:

revert_attribute_1(module, [M], Pos, Node) ->
    case revert_module_name(M) of
      {ok, A} -> {attribute, Pos, module, A};
      error -> Node
    end;
revert_attribute_1(module, [M, List], Pos, Node) ->
    Vs = case is_list_skeleton(List) of
	   true ->
	       case is_proper_list(List) of
		 true -> fold_variable_names(list_elements(List));
		 false -> Node
	       end;
	   false -> Node
	 end,
    case revert_module_name(M) of
      {ok, A} -> {attribute, Pos, module, {A, Vs}};
      error -> Node
    end;
revert_attribute_1(export, [List], Pos, Node) ->
    case is_list_skeleton(List) of
      true ->
	  case is_proper_list(List) of
	    true ->
		Fs = fold_function_names(list_elements(List)),
		{attribute, Pos, export, Fs};
	    false -> Node
	  end;
      false -> Node
    end;
revert_attribute_1(import, [M], Pos, Node) ->
    case revert_module_name(M) of
      {ok, A} -> {attribute, Pos, import, A};
      error -> Node
    end;
revert_attribute_1(import, [A, List], Pos, Node) ->
    case type(A) of
      atom ->
	  case is_list_skeleton(List) of
	    true ->
		case is_proper_list(List) of
		  true ->
		      Fs = fold_function_names(list_elements(List)),
		      {attribute, Pos, import, {concrete(A), Fs}};
		  false -> Node
		end;
	    false -> Node
	  end;
      _ -> Node
    end;
revert_attribute_1(file, [A, Line], Pos, Node) ->
    case type(A) of
      string ->
	  case type(Line) of
	    integer ->
		{attribute, Pos, file, {concrete(A), concrete(Line)}};
	    _ -> Node
	  end;
      _ -> Node
    end;
revert_attribute_1(record, [A, Tuple], Pos, Node) ->
    case type(A) of
      atom ->
	  case type(Tuple) of
	    tuple ->
		Fs = fold_record_fields(tuple_elements(Tuple)),
		{attribute, Pos, record, {concrete(A), Fs}};
	    _ -> Node
	  end;
      _ -> Node
    end;
revert_attribute_1(N, [T], Pos, _) ->
    {attribute, Pos, N, concrete(T)};
revert_attribute_1(_, _, _, Node) -> Node.

revert_module_name(A) ->
    case type(A) of
      atom -> {ok, concrete(A)};
      qualified_name ->
	  Ss = qualified_name_segments(A),
	  {ok, [concrete(S) || S <- Ss]};
      _ -> error
    end.

%% =====================================================================
%% @spec attribute_name(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the name subtree of an <code>attribute</code> node.
%%
%% @see attribute/1

attribute_name(Node) ->
    case unwrap(Node) of
      {attribute, Pos, Name, _} -> set_pos(atom(Name), Pos);
      Node1 -> (data(Node1))#attribute.name
    end.

%% =====================================================================
%% @spec attribute_arguments(Node::syntaxTree()) ->
%%           none | [syntaxTree()]
%%
%% @doc Returns the list of argument subtrees of an
%% <code>attribute</code> node, if any. If <code>Node</code>
%% represents "<code>-<em>Name</em>.</code>", the result is
%% <code>none</code>. Otherwise, if <code>Node</code> represents
%% "<code>-<em>Name</em>(<em>E1</em>, ..., <em>En</em>).</code>",
%% <code>[E1, ..., E1]</code> is returned.
%%
%% @see attribute/1

attribute_arguments(Node) ->
    case unwrap(Node) of
      {attribute, Pos, Name, Data} ->
	  case Name of
	    module ->
		{M1, Vs} = case Data of
			     {M0, Vs0} -> {M0, unfold_variable_names(Vs0, Pos)};
			     M0 -> {M0, none}
			   end,
		M2 = if is_list(M1) ->
			    qualified_name([atom(A) || A <- M1]);
			true -> atom(M1)
		     end,
		M = set_pos(M2, Pos),
		if Vs == none -> [M];
		   true -> [M, set_pos(list(Vs), Pos)]
		end;
	    export ->
		[set_pos(list(unfold_function_names(Data, Pos)), Pos)];
	    import ->
		case Data of
		  {Module, Imports} ->
		      [if is_list(Module) ->
			      qualified_name([atom(A) || A <- Module]);
			  true -> set_pos(atom(Module), Pos)
		       end,
		       set_pos(list(unfold_function_names(Imports, Pos)),
			       Pos)];
		  _ -> [qualified_name([atom(A) || A <- Data])]
		end;
	    file ->
		{File, Line} = Data,
		[set_pos(string(File), Pos),
		 set_pos(integer(Line), Pos)];
	    record ->
		%% Note that we create a tuple as container
		%% for the second argument!
		{Type, Entries} = Data,
		[set_pos(atom(Type), Pos),
		 set_pos(tuple(unfold_record_fields(Entries)), Pos)];
	     spec ->
  		  {FunSpec, TypeSpec} = Data,
  		  case FunSpec of 
  		      {Fun, Arity} -> [set_pos(tuple([set_pos(atom(Fun),Pos), set_pos(integer(Arity),Pos)]), Pos),list(TypeSpec)];
		      {Mod, Fun,Arity} ->
			  [set_pos(tuple([set_pos(atom(Mod), Pos), set_pos(atom(Fun),Pos), set_pos(integer(Arity),Pos)]), Pos),list(TypeSpec)]
  		  end;	
	      type ->
		  {TypeName, TypeSpec1, TypeSpec2} = Data,
		  case TypeName of 
		      {_TypeName1, _TypeName2} ->
			  [];  %% FIX THIS (TYPED RECORD).
		      %% set_pos(atom(TypeName2), Pos),set_pos(list(TypeSpec1),Pos), list(TypeSpec2)];
		       _ ->
			  [set_pos(atom(TypeName), Pos), TypeSpec1, list(TypeSpec2)]			     
		  end;
	      _ ->
	       [set_pos(abstract(Data), Pos)]
	  end;
      Node1 -> (data(Node1))#attribute.args
    end.

  

%% =====================================================================
%% @spec arity_qualifier(Body::syntaxTree(), Arity::syntaxTree()) ->
%%           syntaxTree()
%%
%% @doc Creates an abstract arity qualifier. The result represents
%% "<code><em>Body</em>/<em>Arity</em></code>".
%%
%% @see arity_qualifier_body/1
%% @see arity_qualifier_argument/1

-record(arity_qualifier, {body, arity}).

%% type(Node) = arity_qualifier
%% data(Node) = #arity_qualifier{body :: Body, arity :: Arity}
%%
%%	Body = Arity = syntaxTree()

arity_qualifier(Body, Arity) ->
    tree(arity_qualifier,
	 #arity_qualifier{body = Body, arity = Arity}).

%% =====================================================================
%% @spec arity_qualifier_body(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the body subtree of an <code>arity_qualifier</code>
%% node.
%%
%% @see arity_qualifier/1

arity_qualifier_body(Node) ->
    (data(Node))#arity_qualifier.body.

%% =====================================================================
%% @spec arity_qualifier_argument(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the argument (the arity) subtree of an
%% <code>arity_qualifier</code> node.
%%
%% @see arity_qualifier/1

arity_qualifier_argument(Node) ->
    (data(Node))#arity_qualifier.arity.

%% =====================================================================
%% @spec module_qualifier(Module::syntaxTree(), Body::syntaxTree()) ->
%%           syntaxTree()
%%
%% @doc Creates an abstract module qualifier. The result represents
%% "<code><em>Module</em>:<em>Body</em></code>".
%%
%% @see module_qualifier_argument/1
%% @see module_qualifier_body/1

-record(module_qualifier, {module, body}).

%% type(Node) = module_qualifier
%% data(Node) = #module_qualifier{module :: Module, body :: Body}
%%
%%	Module = Body = syntaxTree()
%%
%% `erl_parse' representation:
%%
%% {remote, Pos, Module, Arg}
%%
%%	Module = Arg = erl_parse()

module_qualifier(Module, Body) ->
    tree(module_qualifier,
	 #module_qualifier{module = Module, body = Body}).

revert_module_qualifier(Node) ->
    Pos = get_pos(Node),
    Module = module_qualifier_argument(Node),
    Body = module_qualifier_body(Node),
    {remote, Pos, Module, Body}.

%% =====================================================================
%% @spec module_qualifier_argument(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the argument (the module) subtree of a
%% <code>module_qualifier</code> node.
%%
%% @see module_qualifier/2

module_qualifier_argument(Node) ->
    case unwrap(Node) of
      {remote, _, Module, _} -> Module;
      Node1 -> (data(Node1))#module_qualifier.module
    end.

%% =====================================================================
%% @spec module_qualifier_body(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the body subtree of a <code>module_qualifier</code>
%% node.
%%
%% @see module_qualifier/2

module_qualifier_body(Node) ->
    case unwrap(Node) of
      {remote, _, _, Body} -> Body;
      Node1 -> (data(Node1))#module_qualifier.body
    end.

%% =====================================================================
%% @spec qualified_name(Segments::[syntaxTree()]) -> syntaxTree()
%%
%% @doc Creates an abstract qualified name. The result represents
%% "<code><em>S1</em>.<em>S2</em>. ... .<em>Sn</em></code>", if
%% <code>Segments</code> is <code>[S1, S2, ..., Sn]</code>.
%%
%% @see qualified_name_segments/1

%% type(Node) = qualified_name
%% data(Node) = [syntaxTree()]
%%
%% `erl_parse' representation:
%%
%% {record_field, Pos, Node, Node}
%%
%%	Node = {atom, Pos, Value} | {record_field, Pos, Node, Node}
%%
%% Note that if not all leaf subnodes are (abstract) atoms, then Node
%% represents a Mnemosyne query record field access ('record_access');
%% see type/1 for details.

qualified_name(Segments) ->
    tree(qualified_name, Segments).

revert_qualified_name(Node) ->
    Pos = get_pos(Node),
    fold_qualified_name(qualified_name_segments(Node), Pos).

%% =====================================================================
%% @spec qualified_name_segments(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of name segments of a
%% <code>qualified_name</code> node.
%%
%% @see qualified_name/1

qualified_name_segments(Node) ->
    case unwrap(Node) of
      {record_field, _, _, _} = Node1 ->
	  unfold_qualified_name(Node1);
      Node1 -> data(Node1)
    end.

%% =====================================================================
%% @spec function(Name::syntaxTree(), Clauses::[syntaxTree()]) ->
%%           syntaxTree()
%%
%% @doc Creates an abstract function definition. If <code>Clauses</code>
%% is <code>[C1, ..., Cn]</code>, the result represents
%% "<code><em>Name</em> <em>C1</em>; ...; <em>Name</em>
%% <em>Cn</em>.</code>". More exactly, if each <code>Ci</code>
%% represents "<code>(<em>Pi1</em>, ..., <em>Pim</em>) <em>Gi</em> ->
%% <em>Bi</em></code>", then the result represents
%% "<code><em>Name</em>(<em>P11</em>, ..., <em>P1m</em>) <em>G1</em> ->
%% <em>B1</em>; ...; <em>Name</em>(<em>Pn1</em>, ..., <em>Pnm</em>)
%% <em>Gn</em> -> <em>Bn</em>.</code>". Function definitions are source
%% code forms.
%%
%% @see function_name/1
%% @see function_clauses/1
%% @see function_arity/1
%% @see is_form/1
%% @see rule/2

-record(function, {name, clauses}).

%% type(Node) = function
%% data(Node) = #function{name :: Name, clauses :: Clauses}
%%
%%	Name = syntaxTree()
%%	Clauses = [syntaxTree()]
%%
%%	(There's no real point in precomputing and storing the arity,
%%	and passing it as a constructor argument makes it possible to
%%	end up with an inconsistent value. Besides, some people might
%%	want to check all clauses, and not just the first, so the
%%	computation is not obvious.)
%%
%% `erl_parse' representation:
%%
%% {function, Pos, Name, Arity, Clauses}
%%
%%	Name = atom()
%%	Arity = integer()
%%	Clauses = [Clause] \ []
%%	Clause = {clause, ...}
%%
%%	where the number of patterns in each clause should be equal to
%%	the integer `Arity'; see `clause' for documentation on
%%	`erl_parse' clauses.

function(Name, Clauses) ->
    tree(function,
	 #function{name = Name, clauses = Clauses}).

revert_function(Node) ->
    Name = function_name(Node),
    Clauses = [revert_clause(C)
	       || C <- function_clauses(Node)],
    Pos = get_pos(Node),
    case type(Name) of
      atom ->
	  A = function_arity(Node),
	  {function, Pos, concrete(Name), A, Clauses};
      _ -> Node
    end.

%% =====================================================================
%% function_name(Node) -> Name
%%
%%	    Node = Name = syntaxTree()
%%	    type(Node) = function
%%
%% @doc Returns the name subtree of a <code>function</code> node.
%%
%% @see function/2

function_name(Node) ->
    case unwrap(Node) of
      {function, Pos, Name, _, _} -> set_pos(atom(Name), Pos);
      Node1 -> (data(Node1))#function.name
    end.

%% =====================================================================
%% function_clauses(Node) -> Clauses
%%
%%	    Node = syntaxTree()
%%	    Clauses = [syntaxTree()]
%%	    type(Node) = function
%%
%% @doc Returns the list of clause subtrees of a <code>function</code>
%% node.
%%
%% @see function/2

function_clauses(Node) ->
    case unwrap(Node) of
      {function, _, _, _, Clauses} -> Clauses;
      Node1 -> (data(Node1))#function.clauses
    end.

%% =====================================================================
%% @spec function_arity(Node::syntaxTree()) -> integer()
%%
%% @doc Returns the arity of a <code>function</code> node. The result
%% is the number of parameter patterns in the first clause of the
%% function; subsequent clauses are ignored.
%%
%% <p>An exception is thrown if <code>function_clauses(Node)</code>
%% returns an empty list, or if the first element of that list is not
%% a syntax tree <code>C</code> of type <code>clause</code> such that
%% <code>clause_patterns(C)</code> is a nonempty list.</p>
%%
%% @see function/2
%% @see function_clauses/1
%% @see clause/3
%% @see clause_patterns/1

function_arity(Node) ->
    %% Note that this never accesses the arity field of `erl_parse'
    %% function nodes.
    length(clause_patterns(hd(function_clauses(Node)))).

%% =====================================================================
%% @spec clause(Guard, Body) -> syntaxTree()
%% @equiv clause([], Guard, Body)

clause(Guard, Body) -> clause([], Guard, Body).

%% =====================================================================
%% @spec clause(Patterns::[syntaxTree()], Guard,
%%              Body::[syntaxTree()]) -> syntaxTree()
%%	    Guard = none | syntaxTree()
%%                | [syntaxTree()] | [[syntaxTree()]]
%%
%% @doc Creates an abstract clause. If <code>Patterns</code> is
%% <code>[P1, ..., Pn]</code> and <code>Body</code> is <code>[B1, ...,
%% Bm]</code>, then if <code>Guard</code> is <code>none</code>, the
%% result represents "<code>(<em>P1</em>, ..., <em>Pn</em>) ->
%% <em>B1</em>, ..., <em>Bm</em></code>", otherwise, unless
%% <code>Guard</code> is a list, the result represents
%% "<code>(<em>P1</em>, ..., <em>Pn</em>) when <em>Guard</em> >
%% <em>B1</em>, ..., <em>Bm</em></code>".
%%
%% <p>For simplicity, the <code>Guard</code> argument may also be any
%% of the following:
%% <ul>
%%   <li>An empty list <code>[]</code>. This is equivalent to passing
%%       <code>none</code>.</li>
%%   <li>A nonempty list <code>[E1, ..., Ej]</code> of syntax trees.
%%       This is equivalent to passing <code>conjunction([E1, ...,
%%       Ej])</code>.</li>
%%   <li>A nonempty list of lists of syntax trees <code>[[E1_1, ...,
%%       E1_k1], ..., [Ej_1, ..., Ej_kj]]</code>, which is equivalent
%%       to passing <code>disjunction([conjunction([E1_1, ...,
%%       E1_k1]), ..., conjunction([Ej_1, ..., Ej_kj])])</code>.</li>
%% </ul>
%% </p>
%%
%% @see clause/2
%% @see clause_patterns/1
%% @see clause_guard/1
%% @see clause_body/1

-record(clause, {patterns, guard, body}).

%% type(Node) = clause
%% data(Node) = #clause{patterns :: Patterns, guard :: Guard,
%%		        body :: Body}
%%
%%	Patterns = [syntaxTree()]
%%	Guard = syntaxTree() | none
%%	Body = [syntaxTree()]
%%
%% `erl_parse' representation:
%%
%% {clause, Pos, Patterns, Guard, Body}
%%
%%	Patterns = [erl_parse()]
%%	Guard = [[erl_parse()]] | [erl_parse()]
%%	Body = [erl_parse()] \ []
%%
%%	Taken out of context, if `Patterns' is `[P1, ..., Pn]' and
%%	`Body' is `[B1, ..., Bm]', this represents `(<P1>, ..., <Pn>) ->
%%	<B1>, ..., <Bm>' if `Guard' is `[]', or otherwise `(<P1>, ...,
%%	<Pn>) when <G> -> <Body>', where `G' is `<E1_1>, ..., <E1_k1>;
%%	...; <Ej_1>, ..., <Ej_kj>', if `Guard' is a list of lists
%%	`[[E1_1, ..., E1_k1], ..., [Ej_1, ..., Ej_kj]]'. In older
%%	versions, `Guard' was simply a list `[E1, ..., En]' of parse
%%	trees, which is equivalent to the new form `[[E1, ..., En]]'.

clause(Patterns, Guard, Body) ->
    Guard1 = case Guard of
	       [] -> none;
	       [X | _] when is_list(X) ->
		   disjunction(conjunction_list(Guard));
	       [_ | _] ->
		   %% Handle older forms also.
		   conjunction(Guard);
	       _ ->
		   %% This should be `none' or a syntax tree.
		   Guard
	     end,
    tree(clause,
	 #clause{patterns = Patterns, guard = Guard1,
		 body = Body}).

conjunction_list([L | Ls]) ->
    [conjunction(L) | conjunction_list(Ls)];
conjunction_list([]) -> [].

revert_clause(Node) ->
    Pos = get_pos(Node),
    Guard = case clause_guard(Node) of
	      none -> [];
	      E ->
		  case type(E) of
		    disjunction -> revert_clause_disjunction(E);
		    conjunction ->
			%% Only the top level expression is
			%% unfolded here; no recursion.
			[conjunction_body(E)];
		    _ ->
			[[E]]       % a single expression
		  end
	    end,
    {clause, Pos, clause_patterns(Node), Guard,
     clause_body(Node)}.

revert_clause_disjunction(D) ->
    %% We handle conjunctions within a disjunction, but only at
    %% the top level; no recursion.
    [case type(E) of
       conjunction -> conjunction_body(E);
       _ -> [E]
     end
     || E <- disjunction_body(D)].

revert_try_clause(Node) ->
    fold_try_clause(revert_clause(Node)).

fold_try_clause({clause, Pos, [P], Guard, Body}) ->
    P1 = case type(P) of
	   class_qualifier ->
	       {tuple, Pos,
		[class_qualifier_argument(P), class_qualifier_body(P),
		 {var, Pos, '_'}]};
	   _ ->
	       {tuple, Pos, [P, {var, Pos, '_'}]}
	 end,
    {clause, Pos, [P1], Guard, Body}.

unfold_try_clauses(Cs) ->
    [unfold_try_clause(C) || C <- Cs].

unfold_try_clause({clause, Pos,  
 		   [{tuple, _, [{atom, Pos1, throw}, V, _]}], Guard, Body}) ->
    case Pos1 == get_pos(V) of 
	true ->  {clause, Pos, [V], Guard, Body}; 
	false -> {clause, Pos, [class_qualifier({atom, Pos1, throw}, V)], Guard, Body}
    end;
	
unfold_try_clause({clause, Pos, [{tuple, _, [C, V, _]}],
		   Guard, Body}) ->
    {clause, Pos, [class_qualifier(C, V)], Guard, Body}.

%% =====================================================================
%% @spec clause_patterns(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of pattern subtrees of a <code>clause</code>
%% node.
%%
%% @see clause/3

clause_patterns(Node) ->
    case unwrap(Node) of
      {clause, _, Patterns, _, _} -> Patterns;
      Node1 -> (data(Node1))#clause.patterns
    end.

%% =====================================================================
%% @spec clause_guard(Node::syntaxTree()) -> none | syntaxTree()
%%
%% @doc Returns the guard subtree of a <code>clause</code> node, if
%% any. If <code>Node</code> represents "<code>(<em>P1</em>, ...,
%% <em>Pn</em>) when <em>Guard</em> -> <em>B1</em>, ...,
%% <em>Bm</em></code>", <code>Guard</code> is returned. Otherwise, the
%% result is <code>none</code>.
%%
%% @see clause/3

clause_guard(Node) ->
    case unwrap(Node) of
      {clause, _, _, Guard, _} ->
	  case Guard of
	    [] -> none;
	    [L | _] when is_list(L) ->
		disjunction(conjunction_list(Guard));
	    [_ | _] -> conjunction(Guard)
	  end;
      Node1 -> (data(Node1))#clause.guard
    end.

%% =====================================================================
%% @spec clause_body(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Return the list of body subtrees of a <code>clause</code>
%% node.
%%
%% @see clause/3

clause_body(Node) ->
    case unwrap(Node) of
      {clause, _, _, _, Body} -> Body;
      Node1 -> (data(Node1))#clause.body
    end.

%% =====================================================================
%% @spec disjunction(List::[syntaxTree()]) -> syntaxTree()
%%
%% @doc Creates an abstract disjunction. If <code>List</code> is
%% <code>[E1, ..., En]</code>, the result represents
%% "<code><em>E1</em>; ...; <em>En</em></code>".
%%
%% @see disjunction_body/1
%% @see conjunction/1

%% type(Node) = disjunction
%% data(Node) = [syntaxTree()]

disjunction(Tests) -> tree(disjunction, Tests).

%% =====================================================================
%% @spec disjunction_body(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of body subtrees of a
%% <code>disjunction</code> node.
%%
%% @see disjunction/1

disjunction_body(Node) -> data(Node).

%% =====================================================================
%% @spec conjunction(List::[syntaxTree()]) -> syntaxTree()
%%
%% @doc Creates an abstract conjunction. If <code>List</code> is
%% <code>[E1, ..., En]</code>, the result represents
%% "<code><em>E1</em>, ..., <em>En</em></code>".
%%
%% @see conjunction_body/1
%% @see disjunction/1

%% type(Node) = conjunction
%% data(Node) = [syntaxTree()]

conjunction(Tests) -> tree(conjunction, Tests).

%% =====================================================================
%% @spec conjunction_body(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of body subtrees of a
%% <code>conjunction</code> node.
%%
%% @see conjunction/1

conjunction_body(Node) -> data(Node).

%% =====================================================================
%% @spec catch_expr(Expr::syntaxTree()) -> syntaxTree()
%%
%% @doc Creates an abstract catch-expression. The result represents
%% "<code>catch <em>Expr</em></code>".
%%
%% @see catch_expr_body/1

%% type(Node) = catch_expr
%% data(Node) = syntaxTree()
%%
%% `erl_parse' representation:
%%
%% {'catch', Pos, Expr}
%%
%%	Expr = erl_parse()

catch_expr(Expr) -> tree(catch_expr, Expr).

revert_catch_expr(Node) ->
    Pos = get_pos(Node),
    Expr = catch_expr_body(Node),
    {'catch', Pos, Expr}.

%% =====================================================================
%% @spec catch_expr_body(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the body subtree of a <code>catch_expr</code> node.
%%
%% @see catch_expr/1

catch_expr_body(Node) ->
    case unwrap(Node) of
      {'catch', _, Expr} -> Expr;
      Node1 -> data(Node1)
    end.

%% =====================================================================
%% @spec match_expr(Pattern::syntaxTree(), Body::syntaxTree()) ->
%%           syntaxTree()
%%
%% @doc Creates an abstract match-expression. The result represents
%% "<code><em>Pattern</em> = <em>Body</em></code>".
%%
%% @see match_expr_pattern/1
%% @see match_expr_body/1

-record(match_expr, {pattern, body}).

%% type(Node) = match_expr
%% data(Node) = #match_expr{pattern :: Pattern, body :: Body}
%%
%%	Pattern = Body = syntaxTree()
%%
%% `erl_parse' representation:
%%
%% {match, Pos, Pattern, Body}
%%
%%	Pattern = Body = erl_parse()

match_expr(Pattern, Body) ->
    tree(match_expr,
	 #match_expr{pattern = Pattern, body = Body}).

revert_match_expr(Node) ->
    Pos = get_pos(Node),
    Pattern = match_expr_pattern(Node),
    Body = match_expr_body(Node),
    {match, Pos, Pattern, Body}.

%% =====================================================================
%% @spec match_expr_pattern(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the pattern subtree of a <code>match_expr</code> node.
%%
%% @see match_expr/2

match_expr_pattern(Node) ->
    case unwrap(Node) of
      {match, _, Pattern, _} -> Pattern;
      Node1 -> (data(Node1))#match_expr.pattern
    end.

%% =====================================================================
%% @spec match_expr_body(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the body subtree of a <code>match_expr</code> node.
%%
%% @see match_expr/2

match_expr_body(Node) ->
    case unwrap(Node) of
      {match, _, _, Body} -> Body;
      Node1 -> (data(Node1))#match_expr.body
    end.

%% =====================================================================
%% @spec operator(Name) -> syntaxTree()
%%	    Name = atom() | string()
%%
%% @doc Creates an abstract operator. The name of the operator is the
%% character sequence represented by <code>Name</code>. This is
%% analogous to the print name of an atom, but an operator is never
%% written within single-quotes; e.g., the result of
%% <code>operator('++')</code> represents "<code>++</code>" rather
%% than "<code>'++'</code>".
%%
%% @see operator_name/1
%% @see operator_literal/1
%% @see atom/1

%% type(Node) = operator
%% data(Node) = atom()

operator(Name) when is_atom(Name) ->
    tree(operator, Name);
operator(Name) -> tree(operator, list_to_atom(Name)).

%% =====================================================================
%% @spec operator_name(syntaxTree())-> atom()
%%
%% @doc Returns the name of an <code>operator</code> node. Note that
%% the name is returned as an atom.
%%
%% @see operator/1

operator_name(Node) -> data(Node).

%% =====================================================================
%% @spec operator_literal(syntaxTree())-> string()
%%
%% @doc Returns the literal string represented by an
%% <code>operator</code> node. This is simply the operator name as a
%% string.
%%
%% @see operator/1

operator_literal(Node) ->
    atom_to_list(operator_name(Node)).

%% =====================================================================
%% @spec infix_expr(Left::syntaxTree(), Operator::syntaxTree(),
%%                  Right::syntaxTree()) -> syntaxTree()
%%
%% @doc Creates an abstract infix operator expression. The result
%% represents "<code><em>Left</em> <em>Operator</em>
%% <em>Right</em></code>".
%%
%% @see infix_expr_left/1
%% @see infix_expr_right/1
%% @see infix_expr_operator/1
%% @see prefix_expr/2

-record(infix_expr, {operator, left, right}).

%% type(Node) = infix_expr
%% data(Node) = #infix_expr{left :: Left, operator :: Operator,
%%		            right :: Right}
%%
%%	Left = Operator = Right = syntaxTree()
%%
%% `erl_parse' representation:
%%
%% {op, Pos, Operator, Left, Right}
%%
%%	Operator = atom()
%%	Left = Right = erl_parse()

infix_expr(Left, Operator, Right) ->
    tree(infix_expr,
	 #infix_expr{operator = Operator, left = Left,
		     right = Right}).

revert_infix_expr(Node) ->
    Pos = get_pos(Node),
    Operator = infix_expr_operator(Node),
    Left = infix_expr_left(Node),
    Right = infix_expr_right(Node),
    case type(Operator) of
      operator ->
	  %% Note that the operator itself is not revertible out
	  %% of context.
	  {op, Pos, operator_name(Operator), Left, Right};
      _ -> Node
    end.

%% =====================================================================
%% @spec infix_expr_left(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the left argument subtree of an
%% <code>infix_expr</code> node.
%%
%% @see infix_expr/3

infix_expr_left(Node) ->
    case unwrap(Node) of
      {op, _, _, Left, _} -> Left;
      Node1 -> (data(Node1))#infix_expr.left
    end.

%% =====================================================================
%% @spec infix_expr_operator(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the operator subtree of an <code>infix_expr</code>
%% node.
%%
%% @see infix_expr/3

infix_expr_operator(Node) ->
    case unwrap(Node) of
      {op, Pos, Operator, _, _} ->
	  set_pos(operator(Operator), Pos);
      Node1 -> (data(Node1))#infix_expr.operator
    end.

%% =====================================================================
%% @spec infix_expr_right(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the right argument subtree of an
%% <code>infix_expr</code> node.
%%
%% @see infix_expr/3

infix_expr_right(Node) ->
    case unwrap(Node) of
      {op, _, _, _, Right} -> Right;
      Node1 -> (data(Node1))#infix_expr.right
    end.

%% =====================================================================
%% @spec prefix_expr(Operator::syntaxTree(), Argument::syntaxTree()) ->
%%           syntaxTree()
%%
%% @doc Creates an abstract prefix operator expression. The result
%% represents "<code><em>Operator</em> <em>Argument</em></code>".
%%
%% @see prefix_expr_argument/1
%% @see prefix_expr_operator/1
%% @see infix_expr/3

-record(prefix_expr, {operator, argument}).

%% type(Node) = prefix_expr
%% data(Node) = #prefix_expr{operator :: Operator,
%%		             argument :: Argument}
%%
%%	Operator = Argument = syntaxTree()
%%
%% `erl_parse' representation:
%%
%% {op, Pos, Operator, Arg}
%%
%%	Operator = atom()
%%	Argument = erl_parse()

prefix_expr(Operator, Argument) ->
    tree(prefix_expr,
	 #prefix_expr{operator = Operator, argument = Argument}).

revert_prefix_expr(Node) ->
    Pos = get_pos(Node),
    Operator = prefix_expr_operator(Node),
    Argument = prefix_expr_argument(Node),
    case type(Operator) of
      operator ->
	  %% Note that the operator itself is not revertible out
	  %% of context.
	  {op, Pos, operator_name(Operator), Argument};
      _ -> Node
    end.

%% =====================================================================
%% @spec prefix_expr_operator(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the operator subtree of a <code>prefix_expr</code>
%% node.
%%
%% @see prefix_expr/2

prefix_expr_operator(Node) ->
    case unwrap(Node) of
      {op, Pos, Operator, _} ->
	  set_pos(operator(Operator), Pos);
      Node1 -> (data(Node1))#prefix_expr.operator
    end.

%% =====================================================================
%% @spec prefix_expr_argument(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the argument subtree of a <code>prefix_expr</code>
%% node.
%%
%% @see prefix_expr/2

prefix_expr_argument(Node) ->
    case unwrap(Node) of
      {op, _, _, Argument} -> Argument;
      Node1 -> (data(Node1))#prefix_expr.argument
    end.

%% =====================================================================
%% @spec record_field(Name) -> syntaxTree()
%% @equiv record_field(Name, none)

record_field(Name) -> record_field(Name, none).

%% =====================================================================
%% @spec record_field(Name::syntaxTree(), Value) -> syntaxTree()
%%	    Value = none | syntaxTree()
%%
%% @doc Creates an abstract record field specification. If
%% <code>Value</code> is <code>none</code>, the result represents
%% simply "<code><em>Name</em></code>", otherwise it represents
%% "<code><em>Name</em> = <em>Value</em></code>".
%%
%% @see record_field_name/1
%% @see record_field_value/1
%% @see record_expr/3

-record(record_field, {name, value}).

%% type(Node) = record_field
%% data(Node) = #record_field{name :: Name, value :: Value}
%%
%%	Name = Value = syntaxTree()

record_field(Name, Value) ->
    tree(record_field,
	 #record_field{name = Name, value = Value}).


-record(typed_record_field, {recordfield, type}).


typed_record_field(RecordField, Type) ->
    tree(typed_record_field,
	 #typed_record_field{recordfield=RecordField, type=Type}).

     
typed_record_field_name(Node) ->
    Field = (data(Node))#typed_record_field.recordfield,
    (data(Field))#record_field.name.

typed_record_field_value(Node) ->
    Field = (data(Node))#typed_record_field.recordfield,
    (data(Field))#record_field.value.

typed_record_field(Node) ->
    (data(Node))#typed_record_field.recordfield.

typed_record_type(Node) ->
    (data(Node))#typed_record_field.type.
    
%% =====================================================================
%% @spec record_field_name(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the name subtree of a <code>record_field</code> node.
%%
%% @see record_field/2

record_field_name(Node) ->
    (data(Node))#record_field.name.

%% =====================================================================
%% @spec record_field_value(syntaxTree()) -> none | syntaxTree()
%%
%% @doc Returns the value subtree of a <code>record_field</code> node,
%% if any. If <code>Node</code> represents
%% "<code><em>Name</em></code>", <code>none</code> is
%% returned. Otherwise, if <code>Node</code> represents
%% "<code><em>Name</em> = <em>Value</em></code>", <code>Value</code>
%% is returned.
%%
%% @see record_field/2

record_field_value(Node) ->
    (data(Node))#record_field.value.

%% =====================================================================
%% @spec record_index_expr(Type::syntaxTree(), Field::syntaxTree()) ->
%%           syntaxTree()
%%
%% @doc Creates an abstract record field index expression. The result
%% represents "<code>#<em>Type</em>.<em>Field</em></code>".
%%
%% <p>(Note: the function name <code>record_index/2</code> is reserved
%% by the Erlang compiler, which is why that name could not be used
%% for this constructor.)</p>
%%
%% @see record_index_expr_type/1
%% @see record_index_expr_field/1
%% @see record_expr/3

-record(record_index_expr, {type, field}).

%% type(Node) = record_index_expr
%% data(Node) = #record_index_expr{type :: Type, field :: Field}
%%
%%	Type = Field = syntaxTree()
%%
%% `erl_parse' representation:
%%
%% {record_index, Pos, Type, Field}
%%
%%	Type = atom()
%%	Field = erl_parse()

record_index_expr(Type, Field) ->
    tree(record_index_expr,
	 #record_index_expr{type = Type, field = Field}).

revert_record_index_expr(Node) ->
    Pos = get_pos(Node),
    Type = record_index_expr_type(Node),
    Field = record_index_expr_field(Node),
    case type(Type) of
      atom -> {record_index, Pos, concrete(Type), Field};
      _ -> Node
    end.

%% =====================================================================
%% @spec record_index_expr_type(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the type subtree of a <code>record_index_expr</code>
%% node.
%%
%% @see record_index_expr/2

record_index_expr_type(Node) ->
    case unwrap(Node) of
      {record_index, Pos, Type, _} ->
	  set_pos(atom(Type), Pos);
      Node1 -> (data(Node1))#record_index_expr.type
    end.

%% =====================================================================
%% @spec record_index_expr_field(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the field subtree of a <code>record_index_expr</code>
%% node.
%%
%% @see record_index_expr/2

record_index_expr_field(Node) ->
    case unwrap(Node) of
      {record_index, _, _, Field} -> Field;
      Node1 -> (data(Node1))#record_index_expr.field
    end.

%% =====================================================================
%% @spec record_access(Argument, Field) -> syntaxTree()
%% @equiv record_access(Argument, none, Field)

record_access(Argument, Field) ->
    record_access(Argument, none, Field).

%% =====================================================================
%% @spec record_access(Argument::syntaxTree(), Type,
%%                     Field::syntaxTree()) -> syntaxTree()
%%	    Type = none | syntaxTree()
%%
%% @doc Creates an abstract record field access expression. If
%% <code>Type</code> is not <code>none</code>, the result represents
%% "<code><em>Argument</em>#<em>Type</em>.<em>Field</em></code>".
%%
%% <p>If <code>Type</code> is <code>none</code>, the result represents
%% "<code><em>Argument</em>.<em>Field</em></code>". This is a special
%% form only allowed within Mnemosyne queries.</p>
%%
%% @see record_access/2
%% @see record_access_argument/1
%% @see record_access_type/1
%% @see record_access_field/1
%% @see record_expr/3
%% @see query_expr/1

-record(record_access, {argument, type, field}).

%% type(Node) = record_access
%% data(Node) = #record_access{argument :: Argument, type :: Type,
%%			       field :: Field}
%%
%%	Argument = Field = syntaxTree()
%%	Type = none | syntaxTree()
%%
%% `erl_parse' representation:
%%
%% {record_field, Pos, Argument, Type, Field}
%% {record_field, Pos, Argument, Field}
%%
%%	Argument = Field = erl_parse()
%%	Type = atom()

record_access(Argument, Type, Field) ->
    tree(record_access,
	 #record_access{argument = Argument, type = Type,
			field = Field}).

revert_record_access(Node) ->
    Pos = get_pos(Node),
    Argument = record_access_argument(Node),
    Type = record_access_type(Node),
    Field = record_access_field(Node),
    if Type == none -> {record_field, Pos, Argument, Field};
       true ->
	   case type(Type) of
	     atom ->
		 {record_field, Pos, Argument, concrete(Type), Field};
	     _ -> Node
	   end
    end.

%% =====================================================================
%% @spec record_access_argument(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the argument subtree of a <code>record_access</code>
%% node.
%%
%% @see record_access/3

record_access_argument(Node) ->
    case unwrap(Node) of
      {record_field, _, Argument, _} -> Argument;
      {record_field, _, Argument, _, _} -> Argument;
      Node1 -> (data(Node1))#record_access.argument
    end.

%% =====================================================================
%% @spec record_access_type(syntaxTree()) -> none | syntaxTree()
%%
%% @doc Returns the type subtree of a <code>record_access</code> node,
%% if any. If <code>Node</code> represents
%% "<code><em>Argument</em>.<em>Field</em></code>", <code>none</code>
%% is returned, otherwise if <code>Node</code> represents
%% "<code><em>Argument</em>#<em>Type</em>.<em>Field</em></code>",
%% <code>Type</code> is returned.
%%
%% @see record_access/3

record_access_type(Node) ->
    case unwrap(Node) of
      {record_field, _, _, _} -> none;
      {record_field, Pos, _, Type, _} ->
	  set_pos(atom(Type), Pos);
      Node1 -> (data(Node1))#record_access.type
    end.

%% =====================================================================
%% @spec record_access_field(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the field subtree of a <code>record_access</code>
%% node.
%%
%% @see record_access/3

record_access_field(Node) ->
    case unwrap(Node) of
      {record_field, _, _, Field} -> Field;
      {record_field, _, _, _, Field} -> Field;
      Node1 -> (data(Node1))#record_access.field
    end.

%% =====================================================================
%% @spec record_expr(Type, Fields) -> syntaxTree()
%% @equiv record_expr(none, Type, Fields)

record_expr(Type, Fields) ->
    record_expr(none, Type, Fields).

%% =====================================================================
%% @spec record_expr(Argument, Type::syntaxTree(),
%%                   Fields::[syntaxTree()]) -> syntaxTree()
%%	    Argument = none | syntaxTree()
%%
%% @doc Creates an abstract record expression. If <code>Fields</code> is
%% <code>[F1, ..., Fn]</code>, then if <code>Argument</code> is
%% <code>none</code>, the result represents
%% "<code>#<em>Type</em>{<em>F1</em>, ..., <em>Fn</em>}</code>",
%% otherwise it represents
%% "<code><em>Argument</em>#<em>Type</em>{<em>F1</em>, ...,
%% <em>Fn</em>}</code>".
%%
%% @see record_expr/2
%% @see record_expr_argument/1
%% @see record_expr_fields/1
%% @see record_expr_type/1
%% @see record_field/2
%% @see record_index_expr/2
%% @see record_access/3

-record(record_expr, {argument, type, fields}).

%% type(Node) = record_expr
%% data(Node) = #record_expr{argument :: Argument, type :: Type,
%%			     fields :: Fields}
%%
%%	Argument = none | syntaxTree()
%%	Type = syntaxTree
%%	Fields = [syntaxTree()]
%%
%% `erl_parse' representation:
%%
%% {record, Pos, Type, Fields}
%% {record, Pos, Argument, Type, Fields}
%%
%%	Argument = erl_parse()
%%	Type = atom()
%%	Fields = [Entry]
%%	Entry = {record_field, Pos, Field, Value}
%%	      | {record_field, Pos, Field}
%%	Field = Value = erl_parse()

record_expr(Argument, Type, Fields) ->
    tree(record_expr,
	 #record_expr{argument = Argument, type = Type,
		      fields = Fields}).

revert_record_expr(Node) ->
    Pos = get_pos(Node),
    Argument = record_expr_argument(Node),
    Type = record_expr_type(Node),
    Fields = record_expr_fields(Node),
    case type(Type) of
      atom ->
	  T = concrete(Type),
	  Fs = fold_record_fields(Fields),
	  case Argument of
	    none -> {record, Pos, T, Fs};
	    _ -> {record, Pos, Argument, T, Fs}
	  end;
      _ -> Node
    end.

%% =====================================================================
%% @spec record_expr_argument(syntaxTree()) -> none | syntaxTree()
%%
%% @doc Returns the argument subtree of a <code>record_expr</code> node,
%% if any. If <code>Node</code> represents
%% "<code>#<em>Type</em>{...}</code>", <code>none</code> is returned.
%% Otherwise, if <code>Node</code> represents
%% "<code><em>Argument</em>#<em>Type</em>{...}</code>",
%% <code>Argument</code> is returned.
%%
%% @see record_expr/3

record_expr_argument(Node) ->
    case unwrap(Node) of
      {record, _, _, _} -> none;
      {record, _, Argument, _, _} -> Argument;
      Node1 -> (data(Node1))#record_expr.argument
    end.

%% =====================================================================
%% record_expr_type(Node) -> Type
%%
%%	    Node = Type = syntaxTree()
%%	    type(Node) = record_expr
%%
%% @doc Returns the type subtree of a <code>record_expr</code> node.
%%
%% @see record_expr/3

record_expr_type(Node) ->
    case unwrap(Node) of
      {record, Pos, Type, _} -> set_pos(atom(Type), Pos);
      {record, Pos, _, Type, _} -> set_pos(atom(Type), Pos);
      Node1 -> (data(Node1))#record_expr.type
    end.

%% =====================================================================
%% record_expr_fields(Node) -> Fields
%%
%%	    Node = syntaxTree()
%%	    Fields = [syntaxTree()]
%%	    type(Node) = record_expr
%%
%% @doc Returns the list of field subtrees of a
%% <code>record_expr</code> node.
%%
%% @see record_expr/3

record_expr_fields(Node) ->
    case unwrap(Node) of
      {record, _, _, Fields} -> unfold_record_fields(Fields);
      {record, _, _, _, Fields} ->
	  unfold_record_fields(Fields);
      Node1 -> (data(Node1))#record_expr.fields
    end.


%% =====================================================================
%% @spec application(Module, Function::syntaxTree(),
%%                   Arguments::[syntaxTree()]) -> syntaxTree()
%%	    Module = none | syntaxTree()
%%
%% @doc Creates an abstract function application expression. (Utility
%% function.) If <code>Module</code> is <code>none</code>, this is
%% call is equivalent to <code>application(Function,
%% Arguments)</code>, otherwise it is equivalent to
%% <code>application(module_qualifier(Module, Function),
%% Arguments)</code>.
%%
%% @see application/2
%% @see module_qualifier/2

application(none, Name, Arguments) ->
    application(Name, Arguments);
application(Module, Name, Arguments) ->
    application(module_qualifier(Module, Name), Arguments).

%% =====================================================================
%% @spec application(Operator::syntaxTree(),
%%                   Arguments::[syntaxTree()]) -> syntaxTree()
%%
%% @doc Creates an abstract function application expression. If
%% <code>Arguments</code> is <code>[A1, ..., An]</code>, the result
%% represents "<code><em>Operator</em>(<em>A1</em>, ...,
%% <em>An</em>)</code>".
%%
%% @see application_operator/1
%% @see application_arguments/1
%% @see application/3

-record(application, {operator, arguments}).


%% type(Node) = application
%% data(Node) = #application{operator :: Operator,
%%			     arguments :: Arguments}
%%
%%	Operator = syntaxTree()
%%	Arguments = [syntaxTree()]
%%
%% `erl_parse' representation:
%%
%% {call, Pos, Fun, Args}
%%
%%	Operator = erl_parse()
%%	Arguments = [erl_parse()]

application(Operator, Arguments) ->
    tree(application,
	 #application{operator = Operator,
		      arguments = Arguments}).

revert_application(Node) ->
    Pos = get_pos(Node),
    Operator = application_operator(Node),
    Arguments = application_arguments(Node),
    {call, Pos, Operator, Arguments}.

%% =====================================================================
%% @spec application_operator(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the operator subtree of an <code>application</code>
%% node.
%%
%% <p>Note: if <code>Node</code> represents
%% "<code><em>M</em>:<em>F</em>(...)</code>", then the result is the
%% subtree representing "<code><em>M</em>:<em>F</em></code>".</p>
%%
%% @see application/2
%% @see module_qualifier/2

application_operator(Node) ->
    case unwrap(Node) of
      {call, _, Operator, _} -> Operator;
      Node1 -> (data(Node1))#application.operator
    end.

%% =====================================================================
%% @spec application_arguments(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of argument subtrees of an
%% <code>application</code> node.
%%
%% @see application/2

application_arguments(Node) ->
    case unwrap(Node) of
      {call, _, _, Arguments} -> Arguments;
      Node1 -> (data(Node1))#application.arguments
    end.

%% =====================================================================
%% @spec list_comp(Template::syntaxTree(), Body::[syntaxTree()]) ->
%%           syntaxTree()
%%
%% @doc Creates an abstract list comprehension. If <code>Body</code> is
%% <code>[E1, ..., En]</code>, the result represents
%% "<code>[<em>Template</em> || <em>E1</em>, ..., <em>En</em>]</code>".
%%
%% @see list_comp_template/1
%% @see list_comp_body/1
%% @see generator/2

-record(list_comp, {template, body}).

%% type(Node) = list_comp
%% data(Node) = #list_comp{template :: Template, body :: Body}
%%
%%	Template = Node = syntaxTree()
%%	Body = [syntaxTree()]
%%
%% `erl_parse' representation:
%%
%% {lc, Pos, Template, Body}
%%
%%	Template = erl_parse()
%%	Body = [erl_parse()] \ []

list_comp(Template, Body) ->
    tree(list_comp,
	 #list_comp{template = Template, body = Body}).

revert_list_comp(Node) ->
    Pos = get_pos(Node),
    Template = list_comp_template(Node),
    Body = list_comp_body(Node),
    {lc, Pos, Template, Body}.

%% =====================================================================
%% @spec list_comp_template(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the template subtree of a <code>list_comp</code> node.
%%
%% @see list_comp/2

list_comp_template(Node) ->
    case unwrap(Node) of
      {lc, _, Template, _} -> Template;
      Node1 -> (data(Node1))#list_comp.template
    end.

%% =====================================================================
%% @spec list_comp_body(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of body subtrees of a <code>list_comp</code>
%% node.
%%
%% @see list_comp/2

list_comp_body(Node) ->
    case unwrap(Node) of
      {lc, _, _, Body} -> Body;
      Node1 -> (data(Node1))#list_comp.body
    end.

%% =====================================================================
%% @spec query_expr(Body::syntaxTree()) -> syntaxTree()
%%
%% @doc Creates an abstract Mnemosyne query expression. The result
%% represents "<code>query <em>Body</em> end</code>".
%%
%% @see query_expr_body/1
%% @see record_access/2
%% @see rule/2

%% type(Node) = query_expr
%% data(Node) = syntaxTree()
%%
%% `erl_parse' representation:
%%
%% {'query', Pos, Body}
%%
%%	Body = erl_parse()

query_expr(Body) -> tree(query_expr, Body).

revert_query_expr(Node) ->
    Pos = get_pos(Node),
    Body = list_comp_body(Node),
    {'query', Pos, Body}.

%% =====================================================================
%% @spec query_expr_body(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the body subtree of a <code>query_expr</code> node.
%%
%% @see query_expr/1

query_expr_body(Node) ->
    case unwrap(Node) of
      {'query', _, Body} -> Body;
      Node1 -> data(Node1)
    end.

%% =====================================================================
%% @spec rule(Name::syntaxTree(), Clauses::[syntaxTree()]) ->
%%           syntaxTree()
%%
%% @doc Creates an abstract Mnemosyne rule. If <code>Clauses</code> is
%% <code>[C1, ..., Cn]</code>, the results represents
%% "<code><em>Name</em> <em>C1</em>; ...; <em>Name</em>
%% <em>Cn</em>.</code>". More exactly, if each <code>Ci</code>
%% represents "<code>(<em>Pi1</em>, ..., <em>Pim</em>) <em>Gi</em> ->
%% <em>Bi</em></code>", then the result represents
%% "<code><em>Name</em>(<em>P11</em>, ..., <em>P1m</em>) <em>G1</em> :-
%% <em>B1</em>; ...; <em>Name</em>(<em>Pn1</em>, ..., <em>Pnm</em>)
%% <em>Gn</em> :- <em>Bn</em>.</code>". Rules are source code forms.
%%
%% @see rule_name/1
%% @see rule_clauses/1
%% @see rule_arity/1
%% @see is_form/1
%% @see function/2

-record(rule, {name, clauses}).

%% type(Node) = rule
%% data(Node) = #rule{name :: Name, clauses :: Clauses}
%%
%%	Name = syntaxTree()
%%	Clauses = [syntaxTree()]
%%
%%	(See `function' for notes on why the arity is not stored.)
%%
%% `erl_parse' representation:
%%
%% {rule, Pos, Name, Arity, Clauses}
%%
%%	Name = atom()
%%	Arity = integer()
%%	Clauses = [Clause] \ []
%%	Clause = {clause, ...}
%%
%%	where the number of patterns in each clause should be equal to
%%	the integer `Arity'; see `clause' for documentation on
%%	`erl_parse' clauses.

rule(Name, Clauses) ->
    tree(rule, #rule{name = Name, clauses = Clauses}).

revert_rule(Node) ->
    Name = rule_name(Node),
    Clauses = [revert_clause(C) || C <- rule_clauses(Node)],
    Pos = get_pos(Node),
    case type(Name) of
      atom ->
	  A = rule_arity(Node),
	  {rule, Pos, concrete(Name), A, Clauses};
      _ -> Node
    end.

%% =====================================================================
%% @spec rule_name(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the name subtree of a <code>rule</code> node.
%%
%% @see rule/2

rule_name(Node) ->
    case unwrap(Node) of
      {rule, Pos, Name, _, _} -> set_pos(atom(Name), Pos);
      Node1 -> (data(Node1))#rule.name
    end.

%% =====================================================================
%% @spec rule_clauses(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of clause subtrees of a <code>rule</code> node.
%%
%% @see rule/2

rule_clauses(Node) ->
    case unwrap(Node) of
      {rule, _, _, _, Clauses} -> Clauses;
      Node1 -> (data(Node1))#rule.clauses
    end.

%% =====================================================================
%% @spec rule_arity(Node::syntaxTree()) -> integer()
%%
%% @doc Returns the arity of a <code>rule</code> node. The result is the
%% number of parameter patterns in the first clause of the rule;
%% subsequent clauses are ignored.
%%
%% <p>An exception is thrown if <code>rule_clauses(Node)</code> returns
%% an empty list, or if the first element of that list is not a syntax
%% tree <code>C</code> of type <code>clause</code> such that
%% <code>clause_patterns(C)</code> is a nonempty list.</p>
%%
%% @see rule/2
%% @see rule_clauses/1
%% @see clause/3
%% @see clause_patterns/1

rule_arity(Node) ->
    %% Note that this never accesses the arity field of
    %% `erl_parse' rule nodes.
    length(clause_patterns(hd(rule_clauses(Node)))).

%% =====================================================================
%% @spec generator(Pattern::syntaxTree(), Body::syntaxTree()) ->
%%           syntaxTree()
%%
%% @doc Creates an abstract generator. The result represents
%% "<code><em>Pattern</em> &lt;- <em>Body</em></code>".
%%
%% @see generator_pattern/1
%% @see generator_body/1
%% @see list_comp/2

-record(generator, {pattern, body}).

%% type(Node) = generator
%% data(Node) = #generator{pattern :: Pattern, body :: Body}
%%
%%	Pattern = Argument = syntaxTree()
%%
%% `erl_parse' representation:
%%
%% {generate, Pos, Pattern, Body}
%%
%%	Pattern = Body = erl_parse()

generator(Pattern, Body) ->
    tree(generator,
	 #generator{pattern = Pattern, body = Body}).

revert_generator(Node) ->
    Pos = get_pos(Node),
    Pattern = generator_pattern(Node),
    Body = generator_body(Node),
    {generate, Pos, Pattern, Body}.

%% =====================================================================
%% @spec generator_pattern(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the pattern subtree of a <code>generator</code> node.
%%
%% @see generator/2

generator_pattern(Node) ->
    case unwrap(Node) of
      {generate, _, Pattern, _} -> Pattern;
      Node1 -> (data(Node1))#generator.pattern
    end.

%% =====================================================================
%% @spec generator_body(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the body subtree of a <code>generator</code> node.
%%
%% @see generator/2

generator_body(Node) ->
    case unwrap(Node) of
      {generate, _, _, Body} -> Body;
      Node1 -> (data(Node1))#generator.body
    end.

%% =====================================================================
%% @spec block_expr(Body::[syntaxTree()]) -> syntaxTree()
%%
%% @doc Creates an abstract block expression. If <code>Body</code> is
%% <code>[B1, ..., Bn]</code>, the result represents "<code>begin
%% <em>B1</em>, ..., <em>Bn</em> end</code>".
%%
%% @see block_expr_body/1

%% type(Node) = block_expr
%% data(Node) = Body
%%
%%	Body = [syntaxTree()]
%%
%% `erl_parse' representation:
%%
%% {block, Pos, Body}
%%
%%	    Body = [erl_parse()] \ []

block_expr(Body) -> tree(block_expr, Body).

revert_block_expr(Node) ->
    Pos = get_pos(Node),
    Body = block_expr_body(Node),
    {block, Pos, Body}.

%% =====================================================================
%% @spec block_expr_body(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of body subtrees of a <code>block_expr</code>
%% node.
%%
%% @see block_expr/1

block_expr_body(Node) ->
    case unwrap(Node) of
      {block, _, Body} -> Body;
      Node1 -> data(Node1)
    end.

%% =====================================================================
%% @spec if_expr(Clauses::[syntaxTree()]) -> syntaxTree()
%%
%% @doc Creates an abstract if-expression. If <code>Clauses</code> is
%% <code>[C1, ..., Cn]</code>, the result represents "<code>if
%% <em>C1</em>; ...; <em>Cn</em> end</code>". More exactly, if each
%% <code>Ci</code> represents "<code>() <em>Gi</em> ->
%% <em>Bi</em></code>", then the result represents "<code>if
%% <em>G1</em> -> <em>B1</em>; ...; <em>Gn</em> -> <em>Bn</em>
%% end</code>".
%%
%% @see if_expr_clauses/1
%% @see clause/3
%% @see case_expr/2

%% type(Node) = if_expr
%% data(Node) = Clauses
%%
%%	Clauses = [syntaxTree()]
%%
%% `erl_parse' representation:
%%
%% {'if', Pos, Clauses}
%%
%%	Clauses = [Clause] \ []
%%	Clause = {clause, ...}
%%
%%	See `clause' for documentation on `erl_parse' clauses.

if_expr(Clauses) -> tree(if_expr, Clauses).

revert_if_expr(Node) ->
    Pos = get_pos(Node),
    Clauses = [revert_clause(C)
	       || C <- if_expr_clauses(Node)],
    {'if', Pos, Clauses}.

%% =====================================================================
%% if_expr_clauses(Node) -> Clauses
%%
%%	    Node = syntaxTree()
%%	    Clauses = [syntaxTree()]
%%	    type(Node) = if_expr
%%
%% @doc Returns the list of clause subtrees of an <code>if_expr</code>
%% node.
%%
%% @see if_expr/1

if_expr_clauses(Node) ->
    case unwrap(Node) of
      {'if', _, Clauses} -> Clauses;
      Node1 -> data(Node1)
    end.

%% =====================================================================
%% @spec case_expr(Argument::syntaxTree(), Clauses::[syntaxTree()]) ->
%%           syntaxTree()
%%
%% @doc Creates an abstract case-expression. If <code>Clauses</code> is
%% <code>[C1, ..., Cn]</code>, the result represents "<code>case
%% <em>Argument</em> of <em>C1</em>; ...; <em>Cn</em> end</code>". More
%% exactly, if each <code>Ci</code> represents "<code>(<em>Pi</em>)
%% <em>Gi</em> -> <em>Bi</em></code>", then the result represents
%% "<code>case <em>Argument</em> of <em>P1</em> <em>G1</em> ->
%% <em>B1</em>; ...; <em>Pn</em> <em>Gn</em> -> <em>Bn</em> end</code>".
%%
%% @see case_expr_clauses/1
%% @see case_expr_argument/1
%% @see clause/3
%% @see if_expr/1
%% @see cond_expr/1

-record(case_expr, {argument, clauses}).

%% type(Node) = case_expr
%% data(Node) = #case_expr{argument :: Argument,
%%			   clauses :: Clauses}
%%
%%	Argument = syntaxTree()
%%	Clauses = [syntaxTree()]
%%
%% `erl_parse' representation:
%%
%% {'case', Pos, Argument, Clauses}
%%
%%	Argument = erl_parse()
%%	Clauses = [Clause] \ []
%%	Clause = {clause, ...}
%%
%%	See `clause' for documentation on `erl_parse' clauses.

case_expr(Argument, Clauses) ->
    tree(case_expr,
	 #case_expr{argument = Argument, clauses = Clauses}).

revert_case_expr(Node) ->
    Pos = get_pos(Node),
    Argument = case_expr_argument(Node),
    Clauses = [revert_clause(C)
	       || C <- case_expr_clauses(Node)],
    {'case', Pos, Argument, Clauses}.

%% =====================================================================
%% @spec case_expr_argument(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the argument subtree of a <code>case_expr</code> node.
%%
%% @see case_expr/2

case_expr_argument(Node) ->
    case unwrap(Node) of
      {'case', _, Argument, _} -> Argument;
      Node1 -> (data(Node1))#case_expr.argument
    end.

%% =====================================================================
%% @spec case_expr_clauses(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of clause subtrees of a <code>case_expr</code>
%% node.
%%
%% @see case_expr/2

case_expr_clauses(Node) ->
    case unwrap(Node) of
      {'case', _, _, Clauses} -> Clauses;
      Node1 -> (data(Node1))#case_expr.clauses
    end.

%% =====================================================================
%% @spec cond_expr(Clauses::[syntaxTree()]) -> syntaxTree()
%%
%% @doc Creates an abstract cond-expression. If <code>Clauses</code> is
%% <code>[C1, ..., Cn]</code>, the result represents "<code>cond
%% <em>C1</em>; ...; <em>Cn</em> end</code>". More exactly, if each
%% <code>Ci</code> represents "<code>() <em>Ei</em> ->
%% <em>Bi</em></code>", then the result represents "<code>cond
%% <em>E1</em> -> <em>B1</em>; ...; <em>En</em> -> <em>Bn</em>
%% end</code>".
%%
%% @see cond_expr_clauses/1
%% @see clause/3
%% @see case_expr/2

%% type(Node) = cond_expr
%% data(Node) = Clauses
%%
%%	Clauses = [syntaxTree()]
%%
%% `erl_parse' representation:
%%
%% {'cond', Pos, Clauses}
%%
%%	Clauses = [Clause] \ []
%%	Clause = {clause, ...}
%%
%%	See `clause' for documentation on `erl_parse' clauses.

cond_expr(Clauses) -> tree(cond_expr, Clauses).

revert_cond_expr(Node) ->
    Pos = get_pos(Node),
    Clauses = [revert_clause(C)
	       || C <- cond_expr_clauses(Node)],
    {'cond', Pos, Clauses}.

%% =====================================================================
%% cond_expr_clauses(Node) -> Clauses
%%
%%	    Node = syntaxTree()
%%	    Clauses = [syntaxTree()]
%%	    type(Node) = cond_expr
%%
%% @doc Returns the list of clause subtrees of a <code>cond_expr</code>
%% node.
%%
%% @see cond_expr/1

cond_expr_clauses(Node) ->
    case unwrap(Node) of
      {'cond', _, Clauses} -> Clauses;
      Node1 -> data(Node1)
    end.

%% =====================================================================
%% @spec receive_expr(Clauses) -> syntaxTree()
%% @equiv receive_expr(Clauses, none, [])

receive_expr(Clauses) ->
    receive_expr(Clauses, none, []).

%% =====================================================================
%% @spec receive_expr(Clauses::[syntaxTree()], Timeout,
%%                    Action::[syntaxTree()]) -> syntaxTree()
%%	    Timeout = none | syntaxTree()
%%
%% @doc Creates an abstract receive-expression. If <code>Timeout</code>
%% is <code>none</code>, the result represents "<code>receive
%% <em>C1</em>; ...; <em>Cn</em> end</code>" (the <code>Action</code>
%% argument is ignored). Otherwise, if <code>Clauses</code> is
%% <code>[C1, ..., Cn]</code> and <code>Action</code> is <code>[A1, ...,
%% Am]</code>, the result represents "<code>receive <em>C1</em>; ...;
%% <em>Cn</em> after <em>Timeout</em> -> <em>A1</em>, ..., <em>Am</em>
%% end</code>". More exactly, if each <code>Ci</code> represents
%% "<code>(<em>Pi</em>) <em>Gi</em> -> <em>Bi</em></code>", then the
%% result represents "<code>receive <em>P1</em> <em>G1</em> ->
%% <em>B1</em>; ...; <em>Pn</em> <em>Gn</em> -> <em>Bn</em> ...
%% end</code>".
%%
%% <p>Note that in Erlang, a receive-expression must have at least one
%% clause if no timeout part is specified.</p>
%%
%% @see receive_expr_clauses/1
%% @see receive_expr_timeout/1
%% @see receive_expr_action/1
%% @see receive_expr/1
%% @see clause/3
%% @see case_expr/2

-record(receive_expr, {clauses, timeout, action}).

%% type(Node) = receive_expr
%% data(Node) = #receive_expr{clauses :: Clauses,
%%			      timeout :: Timeout,
%%			      action :: Action}
%%
%%	Clauses = [syntaxTree()]
%%	Timeout = none | syntaxTree()
%%	Action = [syntaxTree()]
%%
%% `erl_parse' representation:
%%
%% {'receive', Pos, Clauses}
%% {'receive', Pos, Clauses, Timeout, Action}
%%
%%	Clauses = [Clause] \ []
%%	Clause = {clause, ...}
%%	Timeout = erl_parse()
%%	Action = [erl_parse()] \ []
%%
%%	See `clause' for documentation on `erl_parse' clauses.

receive_expr(Clauses, Timeout, Action) ->
    %% If `Timeout' is `none', we always replace the actual
    %% `Action' argument with an empty list, since
    %% `receive_expr_action' should in that case return the empty
    %% list regardless.
    Action1 = case Timeout of
		none -> [];
		_ -> Action
	      end,
    tree(receive_expr,
	 #receive_expr{clauses = Clauses, timeout = Timeout,
		       action = Action1}).

revert_receive_expr(Node) ->
    Pos = get_pos(Node),
    Clauses = [revert_clause(C)
	       || C <- receive_expr_clauses(Node)],
    Timeout = receive_expr_timeout(Node),
    Action = receive_expr_action(Node),
    case Timeout of
      none -> {'receive', Pos, Clauses};
      _ -> {'receive', Pos, Clauses, Timeout, Action}
    end.

%% =====================================================================
%% @spec receive_expr_clauses(syntaxTree()) -> [syntaxTree()]
%%	     type(Node) = receive_expr
%%
%% @doc Returns the list of clause subtrees of a
%% <code>receive_expr</code> node.
%%
%% @see receive_expr/3

receive_expr_clauses(Node) ->
    case unwrap(Node) of
      {'receive', _, Clauses} -> Clauses;
      {'receive', _, Clauses, _, _} -> Clauses;
      Node1 -> (data(Node1))#receive_expr.clauses
    end.

%% =====================================================================
%% @spec receive_expr_timeout(Node::syntaxTree()) -> Timeout
%%	     Timeout = none | syntaxTree()
%%
%% @doc Returns the timeout subtree of a <code>receive_expr</code> node,
%% if any. If <code>Node</code> represents "<code>receive <em>C1</em>;
%% ...; <em>Cn</em> end</code>", <code>none</code> is returned.
%% Otherwise, if <code>Node</code> represents "<code>receive
%% <em>C1</em>; ...; <em>Cn</em> after <em>Timeout</em> -> <em>A1</em>,
%% ..., <em>Am</em> end</code>", <code>[A1, ..., Am]</code> is returned.
%%
%% @see receive_expr/3

receive_expr_timeout(Node) ->
    case unwrap(Node) of
      {'receive', _, _} -> none;
      {'receive', _, _, Timeout, _} -> Timeout;
      Node1 -> (data(Node1))#receive_expr.timeout
    end.

%% =====================================================================
%% @spec receive_expr_action(Node::syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of action body subtrees of a
%% <code>receive_expr</code> node. If <code>Node</code> represents
%% "<code>receive <em>C1</em>; ...; <em>Cn</em> end</code>", this is the
%% empty list.
%%
%% @see receive_expr/3

receive_expr_action(Node) ->
    case unwrap(Node) of
      {'receive', _, _} -> [];
      {'receive', _, _, _, Action} -> Action;
      Node1 -> (data(Node1))#receive_expr.action
    end.

%% =====================================================================
%% @spec try_expr(Body::syntaxTree(), Handlers::[syntaxTree()]) ->
%%           syntaxTree()
%% @equiv try_expr(Body, [], Handlers)

try_expr(Body, Handlers) ->
    try_expr(Body, [], Handlers).

%% =====================================================================
%% @spec try_expr(Body::syntaxTree(), Clauses::[syntaxTree()],
%%           Handlers::[syntaxTree()]) -> syntaxTree()
%% @equiv try_expr(Body, Clauses, Handlers, [])

try_expr(Body, Clauses, Handlers) ->
    try_expr(Body, Clauses, Handlers, []).

%% =====================================================================
%% @spec try_after_expr(Body::syntaxTree(), After::[syntaxTree()]) ->
%%           syntaxTree()
%% @equiv try_expr(Body, [], [], After)

try_after_expr(Body, After) ->
    try_expr(Body, [], [], After).

%% =====================================================================
%% @spec try_expr(Body::[syntaxTree()], Clauses::[syntaxTree()],
%%                Handlers::[syntaxTree()], After::[syntaxTree()]) ->
%%           syntaxTree()
%%
%% @doc Creates an abstract try-expression. If <code>Body</code> is
%% <code>[B1, ..., Bn]</code>, <code>Clauses</code> is <code>[C1, ...,
%% Cj]</code>, <code>Handlers</code> is <code>[H1, ..., Hk]</code>, and
%% <code>After</code> is <code>[A1, ..., Am]</code>, the result
%% represents "<code>try <em>B1</em>, ..., <em>Bn</em> of <em>C1</em>;
%% ...; <em>Cj</em> catch <em>H1</em>; ...; <em>Hk</em> after
%% <em>A1</em>, ..., <em>Am</em> end</code>". More exactly, if each
%% <code>Ci</code> represents "<code>(<em>CPi</em>) <em>CGi</em> ->
%% <em>CBi</em></code>", and each <code>Hi</code> represents
%% "<code>(<em>HPi</em>) <em>HGi</em> -> <em>HBi</em></code>", then the
%% result represents "<code>try <em>B1</em>, ..., <em>Bn</em> of
%% <em>CP1</em> <em>CG1</em> -> <em>CB1</em>; ...; <em>CPj</em>
%% <em>CGj</em> -> <em>CBj</em> catch <em>HP1</em> <em>HG1</em> ->
%% <em>HB1</em>; ...; <em>HPk</em> <em>HGk</em> -> <em>HBk</em> after
%% <em>A1</em>, ..., <em>Am</em> end</code>"; cf.
%% <code>case_expr/2</code>. If <code>Clauses</code> is the empty list,
%% the <code>of ...</code> section is left out. If <code>After</code> is
%% the empty list, the <code>after ...</code> section is left out. If
%% <code>Handlers</code> is the empty list, and <code>After</code> is
%% nonempty, the <code>catch ...</code> section is left out.
%%
%% @see try_expr_body/1
%% @see try_expr_clauses/1
%% @see try_expr_handlers/1
%% @see try_expr_after/1
%% @see try_expr/2
%% @see try_expr/3
%% @see try_after_expr/2
%% @see clause/3
%% @see class_qualifier/2
%% @see case_expr/2

-record(try_expr, {body, clauses, handlers, 'after'}).

%% type(Node) = try_expr
%% data(Node) = #try_expr{body :: Body,
%%			  clauses :: Clauses,
%%			  handlers :: Clauses,
%%			  after :: Body}
%%
%%	Body = syntaxTree()
%%	Clauses = [syntaxTree()]
%%
%% `erl_parse' representation:
%%
%% {'try', Pos, Body, Clauses, Handlers, After}
%%
%%	Body = [erl_parse()]
%%	Clauses = [Clause]
%%	Handlers = [Clause] \ []
%%	Clause = {clause, ...}
%%	After = [erl_parse()]
%%
%%	See `clause' for documentation on `erl_parse' clauses.

try_expr(Body, Clauses, Handlers, After) ->
    tree(try_expr,
	 #try_expr{body = Body, clauses = Clauses,
		   handlers = Handlers, 'after' = After}).

revert_try_expr(Node) ->
    Pos = get_pos(Node),
    Body = try_expr_body(Node),
    Clauses = [revert_clause(C)
	       || C <- try_expr_clauses(Node)],
    Handlers = [revert_try_clause(C)
		|| C <- try_expr_handlers(Node)],
    After = try_expr_after(Node),
    {'try', Pos, Body, Clauses, Handlers, After}.

%% =====================================================================
%% @spec try_expr_body(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of body subtrees of a <code>try_expr</code>
%% node.
%%
%% @see try_expr/4

try_expr_body(Node) ->
    case unwrap(Node) of
      {'try', _, Body, _, _, _} -> Body;
      Node1 -> (data(Node1))#try_expr.body
    end.

%% =====================================================================
%% @spec try_expr_clauses(Node::syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of case-clause subtrees of a
%% <code>try_expr</code> node. If <code>Node</code> represents
%% "<code>try <em>Body</em> catch <em>H1</em>; ...; <em>Hn</em>
%% end</code>", the result is the empty list.
%%
%% @see try_expr/4

try_expr_clauses(Node) ->
    case unwrap(Node) of
      {'try', _, _, Clauses, _, _} -> Clauses;
      Node1 -> (data(Node1))#try_expr.clauses
    end.

%% =====================================================================
%% @spec try_expr_handlers(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of handler-clause subtrees of a
%% <code>try_expr</code> node.
%%
%% @see try_expr/4

try_expr_handlers(Node) ->
    case unwrap(Node) of
      {'try', _, _, _, Handlers, _} ->
	  unfold_try_clauses(Handlers);
      Node1 -> (data(Node1))#try_expr.handlers
    end.

%% =====================================================================
%% @spec try_expr_after(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of "after" subtrees of a <code>try_expr</code>
%% node.
%%
%% @see try_expr/4

try_expr_after(Node) ->
    case unwrap(Node) of
      {'try', _, _, _, _, After} -> After;
      Node1 -> (data(Node1))#try_expr.'after'
    end.

%% =====================================================================
%% @spec class_qualifier(Class::syntaxTree(), Body::syntaxTree()) ->
%%           syntaxTree()
%%
%% @doc Creates an abstract class qualifier. The result represents
%% "<code><em>Class</em>:<em>Body</em></code>".
%%
%% @see class_qualifier_argument/1
%% @see class_qualifier_body/1
%% @see try_expr/4

-record(class_qualifier, {class, body}).

%% type(Node) = class_qualifier
%% data(Node) = #class_qualifier{class :: Class, body :: Body}
%%
%%	Class = Body = syntaxTree()

class_qualifier(Class, Body) ->
    tree(class_qualifier,
	 #class_qualifier{class = Class, body = Body}).

%% =====================================================================
%% @spec class_qualifier_argument(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the argument (the class) subtree of a
%% <code>class_qualifier</code> node.
%%
%% @see class_qualifier/1

class_qualifier_argument(Node) ->
    (data(Node))#class_qualifier.class.

%% =====================================================================
%% @spec class_qualifier_body(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the body subtree of a <code>class_qualifier</code> node.
%%
%% @see class_qualifier/1

class_qualifier_body(Node) ->
    (data(Node))#class_qualifier.body.

%% =====================================================================
%% @spec implicit_fun(Name::syntaxTree(), Arity::syntaxTree()) ->
%%           syntaxTree()
%%
%% @doc Creates an abstract "implicit fun" expression. (Utility
%% function.) If <code>Arity</code> is <code>none</code>, this is
%% equivalent to <code>implicit_fun(Name)</code>, otherwise it is
%% equivalent to <code>implicit_fun(arity_qualifier(Name,
%% Arity))</code>.
%%
%% @see implicit_fun/1

implicit_fun(Name, none) -> implicit_fun(Name);
implicit_fun(Name, Arity) ->
    implicit_fun(arity_qualifier(Name, Arity)).

%% =====================================================================
%% @spec implicit_fun(Name::syntaxTree()) -> syntaxTree()
%%
%% @doc Creates an abstract "implicit fun" expression. The result
%% represents "<code>fun <em>Name</em></code>".
%%
%% @see implicit_fun_name/1
%% @see implicit_fun/2

%% type(Node) = implicit_fun
%% data(Node) = syntaxTree()
%%
%% `erl_parse' representation:
%%
%% {'fun', Pos, {function, Name, Arity}}
%%
%%	Name = atom()
%%	Arity = integer()

implicit_fun(Name) -> tree(implicit_fun, Name).

revert_implicit_fun(Node) ->
    Pos = get_pos(Node),
    Name = implicit_fun_name(Node),
    case type(Name) of
      arity_qualifier ->
	  F = arity_qualifier_body(Name),
	  A = arity_qualifier_argument(Name),
	  case {type(F), type(A)} of
	    {atom, integer} ->
		{'fun', Pos, {function, concrete(F), concrete(A)}};
	    _ -> Node
	  end;
      _ -> Node
    end.

%% =====================================================================
%% @spec implicit_fun_name(Node::syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the name subtree of an <code>implicit_fun</code> node.
%%
%% <p>Note: if <code>Node</code> represents "<code>fun
%% <em>N</em>/<em>A</em></code>", then the result is the subtree
%% representing "<code><em>N</em>/<em>A</em></code>".</p>
%%
%% @see implicit_fun/1

implicit_fun_name(Node) ->
    case unwrap(Node) of
	{'fun', Pos, {function, Atom, Arity}} ->
	    arity_qualifier(set_pos(atom(Atom), Pos),
			    set_pos(integer(Arity), Pos));
	{'fun', Pos, {function, Module, Atom, Arity}} ->
	    module_qualifier(set_pos(atom(Module), Pos),
			     arity_qualifier(
			       set_pos(atom(Atom), Pos),
			       set_pos(integer(Arity), Pos)));
	Node1 ->
	    data(Node1)
    end.

%% =====================================================================
%% @spec fun_expr(Clauses::[syntaxTree()]) -> syntaxTree()
%%
%% @doc Creates an abstract fun-expression. If <code>Clauses</code> is
%% <code>[C1, ..., Cn]</code>, the result represents "<code>fun
%% <em>C1</em>; ...; <em>Cn</em> end</code>". More exactly, if each
%% <code>Ci</code> represents "<code>(<em>Pi1</em>, ..., <em>Pim</em>)
%% <em>Gi</em> -> <em>Bi</em></code>", then the result represents
%% "<code>fun (<em>P11</em>, ..., <em>P1m</em>) <em>G1</em> ->
%% <em>B1</em>; ...; (<em>Pn1</em>, ..., <em>Pnm</em>) <em>Gn</em> ->
%% <em>Bn</em> end</code>".
%%
%% @see fun_expr_clauses/1
%% @see fun_expr_arity/1

%% type(Node) = fun_expr
%% data(Node) = Clauses
%%
%%	Clauses = [syntaxTree()]
%%
%%	(See `function' for notes; e.g. why the arity is not stored.)
%%
%% `erl_parse' representation:
%%
%% {'fun', Pos, {clauses, Clauses}}
%%
%%	Clauses = [Clause] \ []
%%	Clause = {clause, ...}
%%
%%	See `clause' for documentation on `erl_parse' clauses.

fun_expr(Clauses) -> tree(fun_expr, Clauses).

revert_fun_expr(Node) ->
    Clauses = [revert_clause(C)
	       || C <- fun_expr_clauses(Node)],
    Pos = get_pos(Node),
    {'fun', Pos, {clauses, Clauses}}.

%% =====================================================================
%% @spec fun_expr_clauses(syntaxTree()) -> [syntaxTree()]
%%
%% @doc Returns the list of clause subtrees of a <code>fun_expr</code>
%% node.
%%
%% @see fun_expr/1

fun_expr_clauses(Node) ->
    case unwrap(Node) of
      {'fun', _, {clauses, Clauses}} -> Clauses;
      Node1 -> data(Node1)
    end.

%% =====================================================================
%% @spec fun_expr_arity(syntaxTree()) -> integer()
%%
%% @doc Returns the arity of a <code>fun_expr</code> node. The result is
%% the number of parameter patterns in the first clause of the
%% fun-expression; subsequent clauses are ignored.
%%
%% <p>An exception is thrown if <code>fun_expr_clauses(Node)</code>
%% returns an empty list, or if the first element of that list is not a
%% syntax tree <code>C</code> of type <code>clause</code> such that
%% <code>clause_patterns(C)</code> is a nonempty list.</p>
%%
%% @see fun_expr/1
%% @see fun_expr_clauses/1
%% @see clause/3
%% @see clause_patterns/1

fun_expr_arity(Node) ->
    length(clause_patterns(hd(fun_expr_clauses(Node)))).

%% =====================================================================
%% @spec parentheses(Body::syntaxTree()) -> syntaxTree()
%%
%% @doc Creates an abstract parenthesised expression. The result
%% represents "<code>(<em>Body</em>)</code>", independently of the
%% context.
%%
%% @see parentheses_body/1

%% type(Node) = parentheses
%% data(Node) = syntaxTree()

parentheses(Expr) -> tree(parentheses, Expr).

revert_parentheses(Node) -> parentheses_body(Node).

%% =====================================================================
%% @spec parentheses_body(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the body subtree of a <code>parentheses</code> node.
%%
%% @see parentheses/1

parentheses_body(Node) -> data(Node).

%% =====================================================================
%% @spec macro(Name) -> syntaxTree()
%% @equiv macro(Name, none)

macro(Name) -> macro(Name, none).

%% =====================================================================
%% @spec macro(Name::syntaxTree(), Arguments) -> syntaxTree()
%%	    Arguments = none | [syntaxTree()]
%%
%% @doc Creates an abstract macro application. If <code>Arguments</code>
%% is <code>none</code>, the result represents
%% "<code>?<em>Name</em></code>", otherwise, if <code>Arguments</code>
%% is <code>[A1, ..., An]</code>, the result represents
%% "<code>?<em>Name</em>(<em>A1</em>, ..., <em>An</em>)</code>".
%%
%% <p>Notes: if <code>Arguments</code> is the empty list, the result
%% will thus represent "<code>?<em>Name</em>()</code>", including a pair
%% of matching parentheses.</p>
%%
%% <p>The only syntactical limitation imposed by the preprocessor on the
%% arguments to a macro application (viewed as sequences of tokens) is
%% that they must be balanced with respect to parentheses, brackets,
%% <code>begin ... end</code>, <code>case ... end</code>, etc. The
%% <code>text</code> node type can be used to represent arguments which
%% are not regular Erlang constructs.</p>
%%
%% @see macro_name/1
%% @see macro_arguments/1
%% @see macro/1
%% @see text/1

-record(macro, {name, arguments}).

%% type(Node) = macro
%% data(Node) = #macro{name :: Name, arguments :: Arguments}
%%
%%	Name = syntaxTree()
%%	Arguments = none | [syntaxTree()]

macro(Name, Arguments) ->
    tree(macro, #macro{name = Name, arguments = Arguments}).

%% =====================================================================
%% @spec macro_name(syntaxTree()) -> syntaxTree()
%%
%% @doc Returns the name subtree of a <code>macro</code> node.
%%
%% @see macro/2

macro_name(Node) -> (data(Node))#macro.name.

%% =====================================================================
%% @spec macro_arguments(Node::syntaxTree()) -> none | [syntaxTree()]
%%
%% @doc Returns the list of argument subtrees of a <code>macro</code>
%% node, if any. If <code>Node</code> represents
%% "<code>?<em>Name</em></code>", <code>none</code> is returned.
%% Otherwise, if <code>Node</code> represents
%% "<code>?<em>Name</em>(<em>A1</em>, ..., <em>An</em>)</code>",
%% <code>[A1, ..., An]</code> is returned.
%%
%% @see macro/2

macro_arguments(Node) -> (data(Node))#macro.arguments.

%% =====================================================================
%% @spec abstract(Term::term()) -> syntaxTree()
%%
%% @doc Returns the syntax tree corresponding to an Erlang term.
%% <code>Term</code> must be a literal term, i.e., one that can be
%% represented as a source code literal. Thus, it may not contain a
%% process identifier, port, reference, binary or function value as a
%% subterm. The function recognises printable strings, in order to get a
%% compact and readable representation. Evaluation fails with reason
%% <code>badarg</code> if <code>Term</code> is not a literal term.
%%
%% @see concrete/1
%% @see is_literal/1

abstract([H | T]) when is_integer(H) ->
    case is_printable([H | T]) of
      true -> string([H | T]);
      false -> abstract_tail(H, T)
    end;
abstract([H | T]) -> abstract_tail(H, T);
abstract(T) when is_atom(T) -> atom(T);
abstract(T) when is_integer(T) -> integer(T);
abstract(T) when is_float(T) ->
    make_float(T);    % (not `float', which would call the BIF)
abstract([]) -> nil();
abstract(T) when is_tuple(T) ->
    tuple(abstract_list(tuple_to_list(T)));
abstract(T) when is_binary(T) ->
    binary([binary_field(integer(B))
	    || B <- binary_to_list(T)]);
abstract(T) -> erlang:error({badarg, T}).

abstract_list([T | Ts]) ->
    [abstract(T) | abstract_list(Ts)];
abstract_list([]) -> [].

%% This is entered when we might have a sequence of conses that might or
%% might not be a proper list, but which should not be considered as a
%% potential string, to avoid unnecessary checking. This also avoids
%% that a list like `[4711, 42, 10]' could be abstracted to represent
%% `[4711 | "*\n"]'.

abstract_tail(H1, [H2 | T]) ->
    %% Recall that `cons' does "intelligent" composition
    cons(abstract(H1), abstract_tail(H2, T));
abstract_tail(H, T) -> cons(abstract(H), abstract(T)).

%% =====================================================================
%% @spec concrete(Node::syntaxTree()) -> term()
%%
%% @doc Returns the Erlang term represented by a syntax tree. Evaluation
%% fails with reason <code>badarg</code> if <code>Node</code> does not
%% represent a literal term.
%%
%% <p>Note: Currently, the set of syntax trees which have a concrete
%% representation is larger than the set of trees which can be built
%% using the function <code>abstract/1</code>. An abstract character
%% will be concretised as an integer, while <code>abstract/1</code> does
%% not at present yield an abstract character for any input. (Use the
%% <code>char/1</code> function to explicitly create an abstract
%% character.)</p>
%%
%% @see abstract/1
%% @see is_literal/1
%% @see char/1

concrete(Node) ->
    case type(Node) of
      atom -> atom_value(Node);
      integer -> integer_value(Node);
      float -> float_value(Node);
      char -> char_value(Node);
      string -> string_value(Node);
      nil -> [];
      list ->
	  [concrete(list_head(Node)) | concrete(list_tail(Node))];
      tuple ->
	  list_to_tuple(concrete_list(tuple_elements(Node)));
      binary ->
	  Fs =
	      [revert_binary_field(binary_field(binary_field_body(F),
						case binary_field_size(F) of
						  none -> none;
						  S -> revert(S)
						end,
						binary_field_types(F)))
	       || F <- binary_fields(Node)],
	  {value, B, _} = eval_bits:expr_grp(Fs, [],
					     fun (F, _) ->
						     {value, concrete(F), []}
					     end,
					     [], true),
	  B;
      _ -> erlang:error({badarg, Node})
    end.

concrete_list([E | Es]) ->
    [concrete(E) | concrete_list(Es)];
concrete_list([]) -> [].

%% =====================================================================
%% @spec is_literal(Node::syntaxTree()) -> bool()
%%
%% @doc Returns <code>true</code> if <code>Node</code> represents a
%% literal term, otherwise <code>false</code>. This function returns
%% <code>true</code> if and only if the value of
%% <code>concrete(Node)</code> is defined.
%%
%% @see abstract/1
%% @see concrete/1

is_literal(T) ->
    case type(T) of
      atom -> true;
      integer -> true;
      float -> true;
      char -> true;
      string -> true;
      nil -> true;
      list ->
	  case is_literal(list_head(T)) of
	    true -> is_literal(list_tail(T));
	    false -> false
	  end;
      tuple -> lists:all(fun is_literal/1, tuple_elements(T));
      _ -> false
    end.

%% =====================================================================
%% @spec revert(Tree::syntaxTree()) -> syntaxTree()
%%
%% @doc Returns an <code>erl_parse</code>-compatible representation of a
%% syntax tree, if possible. If <code>Tree</code> represents a
%% well-formed Erlang program or expression, the conversion should work
%% without problems. Typically, <code>is_tree/1</code> yields
%% <code>true</code> if conversion failed (i.e., the result is still an
%% abstract syntax tree), and <code>false</code> otherwise.
%%
%% <p>The <code>is_tree/1</code> test is not completely foolproof. For a
%% few special node types (e.g. <code>arity_qualifier</code>), if such a
%% node occurs in a context where it is not expected, it will be left
%% unchanged as a non-reverted subtree of the result. This can only
%% happen if <code>Tree</code> does not actually represent legal Erlang
%% code.</p>
%%
%% @see revert_forms/1
%% @see erl_parse

revert(Node) ->
    case is_tree(Node) of
      false ->
	  %% Just remove any wrapper. `erl_parse' nodes never contain
	  %% abstract syntax tree nodes as subtrees.
	  unwrap(Node);
      true ->
	  case is_leaf(Node) of
	    true -> revert_root(Node);
	    false ->
		%% First revert the subtrees, where possible.
		%% (Sometimes, subtrees cannot be reverted out of
		%% context, and the real work will be done when the
		%% parent node is reverted.)
		Gs = [[revert(X) || X <- L] || L <- subtrees(Node)],
		%% Then reconstruct the node from the reverted
		%% parts, and revert the node itself.
		  Node1 = update_tree(Node, Gs),
		  revert_root(Node1)
	  end
    end.

%% Note: The concept of "compatible root node" is not strictly defined.
%% At a minimum, if `make_tree' is used to compose a node `T' from
%% subtrees that are all completely backwards compatible, then the
%% result of `revert_root(T)' should also be completely backwards
%% compatible.

revert_root(Node) ->
    case type(Node) of
      application -> revert_application(Node);
      atom -> revert_atom(Node);
      attribute -> revert_attribute(Node);
      binary -> revert_binary(Node);
      binary_field -> revert_binary_field(Node);
      block_expr -> revert_block_expr(Node);
      case_expr -> revert_case_expr(Node);
      catch_expr -> revert_catch_expr(Node);
      char -> revert_char(Node);
      clause -> revert_clause(Node);
      cond_expr -> revert_cond_expr(Node);
      eof_marker -> revert_eof_marker(Node);
      error_marker -> revert_error_marker(Node);
      float -> revert_float(Node);
      fun_expr -> revert_fun_expr(Node);
      function -> revert_function(Node);
      generator -> revert_generator(Node);
      if_expr -> revert_if_expr(Node);
      implicit_fun -> revert_implicit_fun(Node);
      infix_expr -> revert_infix_expr(Node);
      integer -> revert_integer(Node);
      list -> revert_list(Node);
      list_comp -> revert_list_comp(Node);
      match_expr -> revert_match_expr(Node);
      module_qualifier -> revert_module_qualifier(Node);
      nil -> revert_nil(Node);
      parentheses -> revert_parentheses(Node);
      prefix_expr -> revert_prefix_expr(Node);
      qualified_name -> revert_qualified_name(Node);
      query_expr -> revert_query_expr(Node);
      receive_expr -> revert_receive_expr(Node);
      record_access -> revert_record_access(Node);
      record_expr -> revert_record_expr(Node);
      record_index_expr -> revert_record_index_expr(Node);
      rule -> revert_rule(Node);
      string -> revert_string(Node);
      try_expr -> revert_try_expr(Node);
      tuple -> revert_tuple(Node);
      underscore -> revert_underscore(Node);
      variable -> revert_variable(Node);
      warning_marker -> revert_warning_marker(Node);
      _ ->
	  %% Non-revertible new-form node
	  Node
    end.

%% =====================================================================
%% @spec revert_forms(Forms) -> [erl_parse()]
%%
%%	    Forms = syntaxTree() | [syntaxTree()]
%%
%% @doc Reverts a sequence of Erlang source code forms. The sequence can
%% be given either as a <code>form_list</code> syntax tree (possibly
%% nested), or as a list of "program form" syntax trees. If successful,
%% the corresponding flat list of <code>erl_parse</code>-compatible
%% syntax trees is returned (cf. <code>revert/1</code>). If some program
%% form could not be reverted, <code>{error, Form}</code> is thrown.
%% Standalone comments in the form sequence are discarded.
%%
%% @see revert/1
%% @see form_list/1
%% @see is_form/1

revert_forms(L) when is_list(L) ->
    revert_forms(form_list(L));
revert_forms(T) ->
    case type(T) of
      form_list ->
	  T1 = flatten_form_list(T),
	  case catch {ok, revert_forms_1(form_list_elements(T1))}
	      of
	    {ok, Fs} -> Fs;
	    {error, R} -> erlang:error({error, R});
	    {'EXIT', R} -> exit(R);
	    R -> throw(R)
	  end;
      _ -> erlang:error({badarg, T})
    end.

revert_forms_1([T | Ts]) ->
    case type(T) of
      comment -> revert_forms_1(Ts);
      _ ->
	  T1 = revert(T),
	  case is_tree(T1) of
	    true -> throw({error, T1});
	    false -> [T1 | revert_forms_1(Ts)]
	  end
    end;
revert_forms_1([]) -> [].

%% =====================================================================
%% @spec subtrees(Node::syntaxTree()) -> [[syntaxTree()]]
%%
%% @doc Returns the grouped list of all subtrees of a syntax tree. If
%% <code>Node</code> is a leaf node (cf. <code>is_leaf/1</code>), this
%% is the empty list, otherwise the result is always a nonempty list,
%% containing the lists of subtrees of <code>Node</code>, in
%% left-to-right order as they occur in the printed program text, and
%% grouped by category. Often, each group contains only a single
%% subtree.
%%
%% <p>Depending on the type of <code>Node</code>, the size of some
%% groups may be variable (e.g., the group consisting of all the
%% elements of a tuple), while others always contain the same number of
%% elements - usually exactly one (e.g., the group containing the
%% argument expression of a case-expression). Note, however, that the
%% exact structure of the returned list (for a given node type) should
%% in general not be depended upon, since it might be subject to change
%% without notice.</p>
%%
%% <p>The function <code>subtrees/1</code> and the constructor functions
%% <code>make_tree/2</code> and <code>update_tree/2</code> can be a
%% great help if one wants to traverse a syntax tree, visiting all its
%% subtrees, but treat nodes of the tree in a uniform way in most or all
%% cases. Using these functions makes this simple, and also assures that
%% your code is not overly sensitive to extensions of the syntax tree
%% data type, because any node types not explicitly handled by your code
%% can be left to a default case.</p>
%%
%% <p>For example:
%% <pre>
%%   postorder(F, Tree) ->
%%       F(case subtrees(Tree) of
%%           [] -> Tree;
%%           List -> update_tree(Tree,
%%                               [[postorder(F, Subtree)
%%                                 || Subtree &lt;- Group]
%%                                || Group &lt;- List])
%%         end).
%% </pre>
%% maps the function <code>F</code> on <code>Tree</code> and all its
%% subtrees, doing a post-order traversal of the syntax tree. (Note the
%% use of <code>update_tree/2</code> to preserve node attributes.) For a
%% simple function like:
%% <pre>
%%   f(Node) ->
%%       case type(Node) of
%%           atom -> atom("a_" ++ atom_name(Node));
%%           _ -> Node
%%       end.
%% </pre>
%% the call <code>postorder(fun f/1, Tree)</code> will yield a new
%% representation of <code>Tree</code> in which all atom names have been
%% extended with the prefix "a_", but nothing else (including comments,
%% annotations and line numbers) has been changed.</p>
%%
%% @see make_tree/2
%% @see type/1
%% @see is_leaf/1
%% @see copy_attrs/2

subtrees(T) ->
    case is_leaf(T) of
      true -> [];
      false ->
	    case type(T) of
	    application ->
		[[application_operator(T)], application_arguments(T)];
	    arity_qualifier ->
		[[arity_qualifier_body(T)],
		 [arity_qualifier_argument(T)]];
	    attribute ->
		case attribute_arguments(T) of
		  none -> [[attribute_name(T)]];
		    As ->
			[[attribute_name(T)], As]
		    end;
	    binary -> [binary_fields(T)];
	    binary_field ->
		case binary_field_types(T) of
		  [] -> [[binary_field_body(T)]];
		  Ts -> [[binary_field_body(T)], Ts]
		end;
	    block_expr -> [block_expr_body(T)];
	    case_expr ->
		[[case_expr_argument(T)], case_expr_clauses(T)];
	    catch_expr -> [[catch_expr_body(T)]];
	    class_qualifier ->
		[[class_qualifier_argument(T)],
		 [class_qualifier_body(T)]];
	    clause ->
		case clause_guard(T) of
		  none -> [clause_patterns(T), clause_body(T)];
		  G -> [clause_patterns(T), [G], clause_body(T)]
		end;
	    cond_expr -> [cond_expr_clauses(T)];
	    conjunction -> [conjunction_body(T)];
	    disjunction -> [disjunction_body(T)];
	    form_list -> [form_list_elements(T)];
	    fun_expr -> [fun_expr_clauses(T)];
	    function -> [[function_name(T)], function_clauses(T)];
	    generator ->
		[[generator_pattern(T)], [generator_body(T)]];
	    if_expr -> [if_expr_clauses(T)];
	    implicit_fun -> [[implicit_fun_name(T)]];
	    infix_expr ->
		[[infix_expr_left(T)], [infix_expr_operator(T)],
		 [infix_expr_right(T)]];
	    list ->
		case list_suffix(T) of
		  none -> [list_prefix(T)];
		  S -> [list_prefix(T), [S]]
		end;
	    list_comp ->
		[[list_comp_template(T)], list_comp_body(T)];
	    macro ->
		case macro_arguments(T) of
		  none -> [[macro_name(T)]];
		  As -> [[macro_name(T)], As]
		end;
	    match_expr ->
		[[match_expr_pattern(T)], [match_expr_body(T)]];
	    module_qualifier ->
		[[module_qualifier_argument(T)],
		 [module_qualifier_body(T)]];
	    parentheses -> [[parentheses_body(T)]];
	    prefix_expr ->
		[[prefix_expr_operator(T)], [prefix_expr_argument(T)]];
	    qualified_name -> [qualified_name_segments(T)];
	    query_expr -> [[query_expr_body(T)]];
	    receive_expr ->
		case receive_expr_timeout(T) of
		  none -> [receive_expr_clauses(T)];
		  E ->
		      [receive_expr_clauses(T), [E], receive_expr_action(T)]
		end;
	    record_access ->
		case record_access_type(T) of
		  none ->
		      [[record_access_argument(T)], [record_access_field(T)]];
		  R ->
		      [[record_access_argument(T)], [R],
		       [record_access_field(T)]]
		end;
	    record_expr ->
		case record_expr_argument(T) of
		  none -> [[record_expr_type(T)], record_expr_fields(T)];
		  V -> [[V], [record_expr_type(T)], record_expr_fields(T)]
		end;
	    record_field ->
		case record_field_value(T) of
		  none -> [[record_field_name(T)]];
		  V -> [[record_field_name(T)], [V]]
		end;
            type_record_field->
		    [[typed_record_field(T)],
		     [typed_record_type(T)]];
	    record_index_expr ->
		[[record_index_expr_type(T)],
		 [record_index_expr_field(T)]];
	    rule -> [[rule_name(T)], rule_clauses(T)];
	    size_qualifier ->
		[[size_qualifier_body(T)],
		 [size_qualifier_argument(T)]];
	    try_expr ->
		[try_expr_body(T), try_expr_clauses(T),
		 try_expr_handlers(T), try_expr_after(T)];
	    tuple -> [tuple_elements(T)];
	    type -> [];
		_ ->[]  %% added by huiqing li to handle {wrapper, [] ...} which could be returned from Elisp.
	    end
    end.

%% =====================================================================
%% @spec update_tree(Node::syntaxTree(), Groups::[[syntaxTree()]]) ->
%%           syntaxTree()
%%
%% @doc Creates a syntax tree with the same type and attributes as the
%% given tree. This is equivalent to <code>copy_attrs(Node,
%% make_tree(type(Node), Groups))</code>.
%%
%% @see make_tree/2
%% @see copy_attrs/2
%% @see type/1

update_tree(Node, Groups) ->
    copy_attrs(Node, make_tree(type(Node), Groups)).

%% =====================================================================
%% @spec make_tree(Type::atom(), Groups::[[syntaxTree()]]) ->
%%           syntaxTree()
%%
%% @doc Creates a syntax tree with the given type and subtrees.
%% <code>Type</code> must be a node type name (cf. <code>type/1</code>)
%% that does not denote a leaf node type (cf. <code>is_leaf/1</code>).
%% <code>Groups</code> must be a <em>nonempty</em> list of groups of
%% syntax trees, representing the subtrees of a node of the given type,
%% in left-to-right order as they would occur in the printed program
%% text, grouped by category as done by <code>subtrees/1</code>.
%%
%% <p>The result of <code>copy_attrs(Node, make_tree(type(Node),
%% subtrees(Node)))</code> (cf. <code>update_tree/2</code>) represents
%% the same source code text as the original <code>Node</code>, assuming
%% that <code>subtrees(Node)</code> yields a nonempty list. However, it
%% does not necessarily have the same data representation as
%% <code>Node</code>.</p>
%%
%% @see update_tree/1
%% @see subtrees/1
%% @see type/1
%% @see is_leaf/1
%% @see copy_attrs/2

make_tree(application, [[F], A]) -> application(F, A);
make_tree(arity_qualifier, [[N], [A]]) ->
    arity_qualifier(N, A);
make_tree(attribute, [[N]]) -> attribute(N);
make_tree(attribute, [[N], A]) -> attribute(N, A);
make_tree(binary, [Fs]) -> binary(Fs);
make_tree(binary_field, [[B]]) -> binary_field(B);
make_tree(binary_field, [[B], Ts]) ->
    binary_field(B, Ts);
make_tree(block_expr, [B]) -> block_expr(B);
make_tree(case_expr, [[A], C]) -> case_expr(A, C);
make_tree(catch_expr, [[B]]) -> catch_expr(B);
make_tree(class_qualifier, [[A], [B]]) ->
    class_qualifier(A, B);
make_tree(clause, [P, B]) -> clause(P, none, B);
make_tree(clause, [P, [G], B]) -> clause(P, G, B);
make_tree(cond_expr, [C]) -> cond_expr(C);
make_tree(conjunction, [E]) -> conjunction(E);
make_tree(disjunction, [E]) -> disjunction(E);
make_tree(form_list, [E]) -> form_list(E);
make_tree(fun_expr, [C]) -> fun_expr(C);
make_tree(function, [[N], C]) -> function(N, C);
make_tree(generator, [[P], [E]]) -> generator(P, E);
make_tree(if_expr, [C]) -> if_expr(C);
make_tree(implicit_fun, [[N]]) -> implicit_fun(N);
make_tree(infix_expr, [[L], [F], [R]]) ->
    infix_expr(L, F, R);
make_tree(list, [P]) -> list(P);
make_tree(list, [P, [S]]) -> list(P, S);
make_tree(list_comp, [[T], B]) -> list_comp(T, B);
make_tree(macro, [[N]]) -> macro(N);
make_tree(macro, [[N], A]) -> macro(N, A);
make_tree(match_expr, [[P], [E]]) -> match_expr(P, E);
make_tree(module_qualifier, [[M], [N]]) ->
    module_qualifier(M, N);
make_tree(parentheses, [[E]]) -> parentheses(E);
make_tree(prefix_expr, [[F], [A]]) -> prefix_expr(F, A);
make_tree(qualified_name, [S]) -> qualified_name(S);
make_tree(query_expr, [[B]]) -> query_expr(B);
make_tree(receive_expr, [C]) -> receive_expr(C);
make_tree(receive_expr, [C, [E], A]) ->
    receive_expr(C, E, A);
make_tree(record_access, [[E], [F]]) ->
    record_access(E, F);
make_tree(record_access, [[E], [T], [F]]) ->
    record_access(E, T, F);
make_tree(record_expr, [[T], F]) -> record_expr(T, F);
make_tree(record_expr, [[E], [T], F]) ->
    record_expr(E, T, F);
make_tree(record_field, [[N]]) -> record_field(N);
make_tree(record_field, [[N], [E]]) ->
    record_field(N, E);
make_tree(record_index_expr, [[T], [F]]) ->
    record_index_expr(T, F);
make_tree(rule, [[N], C]) -> rule(N, C);
make_tree(size_qualifier, [[N], [A]]) ->
    size_qualifier(N, A);
make_tree(try_expr, [B, C, H, A]) ->
    try_expr(B, C, H, A);
make_tree(tuple, [E]) -> tuple(E).


%% =====================================================================
%% @spec meta(Tree::syntaxTree()) -> syntaxTree()
%%
%% @doc Creates a meta-representation of a syntax tree. The result
%% represents an Erlang expression "<code><em>MetaTree</em></code>"
%% which, if evaluated, will yield a new syntax tree representing the
%% same source code text as <code>Tree</code> (although the actual data
%% representation may be different). The expression represented by
%% <code>MetaTree</code> is <em>implementation independent</em> with
%% regard to the data structures used by the abstract syntax tree
%% implementation. Comments attached to nodes of <code>Tree</code> will
%% be preserved, but other attributes are lost.
%%
%% <p>Any node in <code>Tree</code> whose node type is
%% <code>variable</code> (cf. <code>type/1</code>), and whose list of
%% annotations (cf. <code>get_ann/1</code>) contains the atom
%% <code>meta_var</code>, will remain unchanged in the resulting tree,
%% except that exactly one occurrence of <code>meta_var</code> is
%% removed from its annotation list.</p>
%%
%% <p>The main use of the function <code>meta/1</code> is to transform a
%% data structure <code>Tree</code>, which represents a piece of program
%% code, into a form that is <em>representation independent when
%% printed</em>. E.g., suppose <code>Tree</code> represents a variable
%% named "V". Then (assuming a function <code>print/1</code> for
%% printing syntax trees), evaluating <code>print(abstract(Tree))</code>
%% - simply using <code>abstract/1</code> to map the actual data
%% structure onto a syntax tree representation - would output a string
%% that might look something like "<code>{tree, variable, ..., "V",
%% ...}</code>", which is obviously dependent on the implementation of
%% the abstract syntax trees. This could e.g. be useful for caching a
%% syntax tree in a file. However, in some situations like in a program
%% generator generator (with two "generator"), it may be unacceptable.
%% Using <code>print(meta(Tree))</code> instead would output a
%% <em>representation independent</em> syntax tree generating
%% expression; in the above case, something like
%% "<code>erl_syntax:variable("V")</code>".</p>
%%
%% @see abstract/1
%% @see type/1
%% @see get_ann/1

meta(T) ->
    %% First of all we check for metavariables:
    case type(T) of
      variable ->
	  case lists:member(meta_var, get_ann(T)) of
	    false -> meta_precomment(T);
	    true ->
		%% A meta-variable: remove the first found
		%% `meta_var' annotation, but otherwise leave
		%% the node unchanged.
		set_ann(T, lists:delete(meta_var, get_ann(T)))
	  end;
      _ ->
	  case has_comments(T) of
	    true -> meta_precomment(T);
	    false -> meta_1(T)
	  end
    end.

meta_precomment(T) ->
    case get_precomments(T) of
      [] -> meta_postcomment(T);
      Cs ->
	  meta_call(set_precomments,
		    [meta_postcomment(T), list(meta_list(Cs))])
    end.

meta_postcomment(T) ->
    case get_postcomments(T) of
      [] -> meta_0(T);
      Cs ->
	  meta_call(set_postcomments,
		    [meta_0(T), list(meta_list(Cs))])
    end.

meta_0(T) -> meta_1(remove_comments(T)).

meta_1(T) ->
    %% First handle leaf nodes and other common cases, in order to
    %% generate compact code.
    case type(T) of
      atom -> meta_call(atom, [T]);
      char -> meta_call(char, [T]);
      comment ->
	  meta_call(comment,
		    [list([string(S) || S <- comment_text(T)])]);
      eof_marker -> meta_call(eof_marker, []);
      error_marker ->
	  meta_call(error_marker,
		    [abstract(error_marker_info(T))]);
      float -> meta_call(float, [T]);
      integer -> meta_call(integer, [T]);
      nil -> meta_call(nil, []);
      operator ->
	  meta_call(operator, [atom(operator_name(T))]);
      string -> meta_call(string, [T]);
      text -> meta_call(text, [string(text_string(T))]);
      underscore -> meta_call(underscore, []);
      variable ->
	  meta_call(variable, [string(variable_name(T))]);
      warning_marker ->
	  meta_call(warning_marker,
		    [abstract(warning_marker_info(T))]);
      list ->
	  case list_suffix(T) of
	    none ->
		meta_call(list, [list(meta_list(list_prefix(T)))]);
	    S ->
		meta_call(list,
			  [list(meta_list(list_prefix(T))), meta(S)])
	  end;
      tuple ->
	  meta_call(tuple, [list(meta_list(tuple_elements(T)))]);
      Type ->
	  %% All remaining cases are handled using `subtrees'
	  %% and `make_tree' to decompose and reassemble the
	  %% nodes. More cases could of course be handled
	  %% directly to get a more compact output, but I can't
	  %% be bothered right now.
	  meta_call(make_tree,
		    [abstract(Type), meta_subtrees(subtrees(T))])
    end.

meta_list([T | Ts]) -> [meta(T) | meta_list(Ts)];
meta_list([]) -> [].

meta_subtrees(Gs) ->
    list([list([meta(T) || T <- G]) || G <- Gs]).

meta_call(F, As) ->
    application(atom(?MODULE), atom(F), As).

%% =====================================================================
%% Functions for abstraction of the syntax tree representation; may be
%% used externally, but not intended for the normal user.
%% =====================================================================

%% =====================================================================
%% @spec tree(Type) -> syntaxTree()
%% @equiv tree(Type, [])

tree(Type) -> tree(Type, []).

%% =====================================================================
%% @spec tree(Type::atom(), Data::term()) -> syntaxTree()
%%
%% @doc <em>For special purposes only</em>. Creates an abstract syntax
%% tree node with type tag <code>Type</code> and associated data
%% <code>Data</code>.
%%
%% <p>This function and the related <code>is_tree/1</code> and
%% <code>data/1</code> provide a uniform way to extend the set of
%% <code>erl_parse</code> node types. The associated data is any term,
%% whose format may depend on the type tag.</p>
%%
%% <h4>Notes:</h4>
%% <ul>
%%  <li>Any nodes created outside of this module must have type tags
%%      distinct from those currently defined by this module; see
%%      <code>type/1</code> for a complete list.</li>
%%  <li>The type tag of a syntax tree node may also be used
%%      as a primary tag by the <code>erl_parse</code> representation;
%%      in that case, the selector functions for that node type
%%      <em>must</em> handle both the abstract syntax tree and the
%%      <code>erl_parse</code> form. The function <code>type(T)</code>
%%      should return the correct type tag regardless of the
%%      representation of <code>T</code>, so that the user sees no
%%      difference between <code>erl_syntax</code> and
%%      <code>erl_parse</code> nodes.</li>
%% </ul>
%% @see is_tree/1
%% @see data/1
%% @see type/1

tree(Type, Data) -> #tree{type = Type, data = Data}.

%% =====================================================================
%% @spec is_tree(Tree::syntaxTree()) -> bool()
%%
%% @doc <em>For special purposes only</em>. Returns <code>true</code> if
%% <code>Tree</code> is an abstract syntax tree and <code>false</code>
%% otherwise.
%%
%% <p><em>Note</em>: this function yields <code>false</code> for all
%% "old-style" <code>erl_parse</code>-compatible "parse trees".</p>
%%
%% @see tree/2

is_tree(#tree{}) -> true;
is_tree(_) -> false.

%% =====================================================================
%% @spec data(Tree::syntaxTree()) -> term()
%%
%% @doc <em>For special purposes only</em>. Returns the associated data
%% of a syntax tree node. Evaluation fails with reason
%% <code>badarg</code> if <code>is_tree(Node)</code> does not yield
%% <code>true</code>.
%%
%% @see tree/2

data(#tree{data = D}) -> D;
data(#wrapper{tree=D}) -> D;  %% Added by Huiqing Li. (Is this correct?)
data(T) -> erlang:error({badarg, T}).  %% TODO: CHANGE THIS BACK.

% =====================================================================
%% Primitives for backwards compatibility; for internal use only
%% =====================================================================

%% =====================================================================
%% @spec wrap(Node::erl_parse()) -> syntaxTree()
%%
%% @type erl_parse() = erl_parse:parse_tree(). The "parse tree"
%% representation built by the Erlang standard library parser
%% <code>erl_parse</code>. This is a subset of the
%% <a href="#type-syntaxTree"><code>syntaxTree</code></a> type.
%%
%% @doc Creates a wrapper structure around an <code>erl_parse</code>
%% "parse tree".
%%
%% <p>This function and the related <code>unwrap/1</code> and
%% <code>is_wrapper/1</code> provide a uniform way to attach arbitrary
%% information to an <code>erl_parse</code> tree. Some information about
%% the encapsuled tree may be cached in the wrapper, such as the node
%% type. All functions on syntax trees must behave so that the user sees
%% no difference between wrapped and non-wrapped <code>erl_parse</code>
%% trees. <em>Attaching a wrapper onto another wrapper structure is an
%% error</em>.</p>

wrap(Node) ->
    %% We assume that Node is an old-school `erl_parse' tree.
    #wrapper{type = type(Node),
	     attr = #attr{pos = get_pos(Node)}, tree = Node}.

%% =====================================================================
%% @spec unwrap(Node::syntaxTree()) -> syntaxTree()
%%
%% @doc Removes any wrapper structure, if present. If <code>Node</code>
%% is a wrapper structure, this function returns the wrapped
%% <code>erl_parse</code> tree; otherwise it returns <code>Node</code>
%% itself.

unwrap(#wrapper{tree = Node}) -> Node;
unwrap(Node) ->
    Node.    % This could also be a new-form node.

%% =====================================================================
%% @spec is_wrapper(Term::term()) -> bool()
%%
%% @doc Returns <code>true</code> if the argument is a wrapper
%% structure, otherwise <code>false</code>.

-ifndef(NO_UNUSED).
is_wrapper(#wrapper{}) ->
    true;
is_wrapper(_) ->
    false.
-endif.

%% =====================================================================
%% General utility functions for internal use
%% =====================================================================

is_printable(S) -> io_lib:printable_list(S).

%% Support functions for transforming lists of function names
%% specified as `arity_qualifier' nodes.

%% unfold_function_names(Ns, Pos) ->
%%     F = fun ({Atom, Arity}) ->
%% 		N = arity_qualifier(atom(Atom), integer(Arity)),
%% 		set_pos(N, Pos)
%% 	end,
%%     [F(N) || N <- Ns].

unfold_function_names(Ns, _Pos) ->
    F = fun ({{atom, Pos1, Atom},{integer, Pos2, Arity}}) ->
		N = arity_qualifier(set_pos(atom(Atom), Pos1), set_pos(integer(Arity),Pos2)),
		set_pos(N, Pos1)
	end,
    [F(N) || N <- Ns].

fold_function_names(Ns) ->
    [fold_function_name(N) || N <- Ns].

fold_function_name(N) ->
    Name = arity_qualifier_body(N),
    Arity = arity_qualifier_argument(N),
    case (type(Name) == atom) and (type(Arity) == integer)
	of
      true -> {concrete(Name), concrete(Arity)}
    end.

fold_variable_names(Vs) ->
    [variable_name(V) || V <- Vs].

unfold_variable_names(Vs, Pos) ->
    [set_pos(variable(V), Pos) || V <- Vs].

%% Support functions for qualified names ("foo.bar.baz",
%% "erl.lang.lists", etc.). The representation overlaps with the weird
%% "Mnesia query record access" operators. The '.' operator is left
%% associative, so folding should nest on the left.

is_qualified_name({record_field, _, L, R}) ->
    case is_qualified_name(L) of
      true -> is_qualified_name(R);
      false -> false
    end;
is_qualified_name({atom, _, _}) -> true;
is_qualified_name(_) -> false.

unfold_qualified_name(Node) ->
    lists:reverse(unfold_qualified_name(Node, [])).

unfold_qualified_name({record_field, _, L, R}, Ss) ->
    unfold_qualified_name(R, unfold_qualified_name(L, Ss));
unfold_qualified_name(S, Ss) -> [S | Ss].

fold_qualified_name([S | Ss], Pos) ->
    fold_qualified_name(Ss, Pos,
			{atom, Pos, atom_value(S)}).

fold_qualified_name([S | Ss], Pos, Ack) ->
    fold_qualified_name(Ss, Pos,
			{record_field, Pos, Ack, {atom, Pos, atom_value(S)}});
fold_qualified_name([], _Pos, Ack) -> Ack.

%% Support functions for transforming lists of record field definitions.
%%
%% There is no unique representation for field definitions in the
%% standard form. There, they may only occur in the "fields" part of a
%% record expression or declaration, and are represented as
%% `{record_field, Pos, Name, Value}', or as `{record_field, Pos, Name}'
%% if the value part is left out. However, these cannot be distinguished
%% out of context from the representation of record field access
%% expressions (see `record_access').

fold_record_fields(Fs) ->
    [fold_record_field(F) || F <- Fs].

fold_record_field(F) ->
    Pos = get_pos(F),
    Name = record_field_name(F),
    case record_field_value(F) of
      none -> {record_field, Pos, Name};
      Value -> {record_field, Pos, Name, Value}
    end.

unfold_record_fields(Fs) ->
    [unfold_record_field(F) || F <- Fs].

unfold_record_field({record_field, Pos, Name}) ->
    set_pos(record_field(Name), Pos);
unfold_record_field({record_field, Pos, Name, Value}) ->
    set_pos(record_field(Name, Value), Pos);
unfold_record_field({typed_record_field, RecordField={record_field, Pos, _Name}, Type}) ->
     set_pos(typed_record_field(unfold_record_field(RecordField), Type), Pos);
unfold_record_field({typed_record_field, RecordField={record_field, Pos, _Name, _Value}, Type}) ->
    set_pos(typed_record_field(unfold_record_field(RecordField), Type), Pos).
		   

fold_binary_field_types(Ts) ->
    [fold_binary_field_type(T) || T <- Ts].

fold_binary_field_type(Node) ->
    case type(Node) of
      size_qualifier ->
	  {concrete(size_qualifier_body(Node)),
	   concrete(size_qualifier_argument(Node))};
      _ -> concrete(Node)
    end.

unfold_binary_field_types(Ts, Pos) ->
    [unfold_binary_field_type(T, Pos) || T <- Ts].

unfold_binary_field_type({Type, Size}, Pos) ->
    set_pos(size_qualifier(atom(Type), integer(Size)), Pos);
unfold_binary_field_type(Type, Pos) ->
    set_pos(atom(Type), Pos).

%% =====================================================================

set_name(Node, Name) ->
    case Node of
      #wrapper{tree = Tree} ->
	  Node#wrapper{tree = set_name(Tree, Name)};
      #tree{data = Data} ->
	  Node#tree{data = set_name(Data, Name)};
      {var, Pos, _} -> {var, Pos, Name}
    end.


default_literals_vars(Node, Value) ->
    case Node of 
	#wrapper{tree = Tree} ->
	    Node#wrapper{tree = default_literals_vars(Tree, Value)};
	#tree{data = Data} ->
	    Node#tree{data = default_literals_vars(Data, Value)};
	{T, _Pos, _} -> {T, {0,0}, Value};
	{nil, _} -> {nil, {0,0}};
	_  -> Node      
    end.

 
