Provided by: erlang-manpages_14.b.4-dfsg-1ubuntu1_all bug

NAME

       erl_parse - The Erlang Parser

DESCRIPTION

       This  module  is  the  basic Erlang parser which converts tokens into the abstract form of
       either forms (i.e., top-level constructs), expressions, or terms. The Abstract  Format  is
       described  in the ERTS User's Guide. Note that a token list must end with the dot token in
       order to be acceptable to the parse functions (see erl_scan(3erl)).

DATA TYPES

       abstract_clause() = term()

              Parse tree for Erlang clause.

       abstract_expr() = term()

              Parse tree for Erlang expression.

       abstract_form() = term()

              Parse tree for Erlang form.

       error_description() = term()

       error_info() = {erl_scan:line(), module(), error_description()}

       token() = {Tag :: atom(), Line :: erl_scan:line()}

EXPORTS

       parse_form(Tokens) -> {ok, AbsForm} | {error, ErrorInfo}

              Types:

                 Tokens = [token()]
                 AbsForm = abstract_form()
                 ErrorInfo = error_info()

              This function parses Tokens as if it were a form. It returns:

                {ok, AbsForm}:
                  The parsing was successful. AbsForm is the abstract form of the parsed form.

                {error, ErrorInfo}:
                  An error occurred.

       parse_exprs(Tokens) -> {ok, ExprList} | {error, ErrorInfo}

              Types:

                 Tokens = [token()]
                 ExprList = [abstract_expr()]
                 ErrorInfo = error_info()

              This function parses Tokens as if it were a list of expressions. It returns:

                {ok, ExprList}:
                  The parsing was successful. ExprList is a list of the  abstract  forms  of  the
                  parsed expressions.

                {error, ErrorInfo}:
                  An error occurred.

       parse_term(Tokens) -> {ok, Term} | {error, ErrorInfo}

              Types:

                 Tokens = [token()]
                 Term = term()
                 ErrorInfo = error_info()

              This function parses Tokens as if it were a term. It returns:

                {ok, Term}:
                  The  parsing was successful. Term is the Erlang term corresponding to the token
                  list.

                {error, ErrorInfo}:
                  An error occurred.

       format_error(ErrorDescriptor) -> Chars

              Types:

                 ErrorDescriptor =
                 Chars = [char() | Chars]

              Uses an ErrorDescriptor and returns  a  string  which  describes  the  error.  This
              function is usually called implicitly when an ErrorInfo structure is processed (see
              below).

       tokens(AbsTerm) -> Tokens

       tokens(AbsTerm, MoreTokens) -> Tokens

              Types:

                 AbsTerm = abstract_expr()
                 MoreTokens = Tokens = [token()]

              This function generates a list of tokens representing the abstract form AbsTerm  of
              an expression. Optionally, it appends MoreTokens.

       normalise(AbsTerm) -> Data

              Types:

                 AbsTerm = abstract_expr()
                 Data = term()

              Converts  the  abstract  form  AbsTerm  of  a  term into a conventional Erlang data
              structure (i.e., the term itself). This is the inverse of abstract/1.

       abstract(Data) -> AbsTerm

              Types:

                 Data = term()
                 AbsTerm = abstract_expr()

              Converts the Erlang data structure Data into an abstract form of type AbsTerm. This
              is the inverse of normalise/1.

ERROR INFORMATION

       The  ErrorInfo  mentioned above is the standard ErrorInfo structure which is returned from
       all IO modules. It has the format:

           {ErrorLine, Module, ErrorDescriptor}

       A string which describes the error is obtained with the following call:

           Module:format_error(ErrorDescriptor)

SEE ALSO

       io(3erl), erl_scan(3erl), ERTS User's Guide