erl_parse(3)

MODULE
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. Note that a token list must end with the dot token in order to be acceptable to the parse functions (see erl_scan).

EXPORTS

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

    Types
        Tokens = [Token]
        Token = {Tag, Line} | {Tag, Line, term()}
        Tag = atom()
        AbsForm = term()
        ErrorInfo = see section Error Information below.

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

        {ok, AbsForm}:
            The parsing was successful. See section Abstract Form below for a description of AbsForm.

        {error, ErrorInfo}:
            An error occurred.

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

    Types
        Tokens = [Token]
        Token = {Tag, Line} | {Tag, Line, term()}
        Tag = atom()
        Expr_list = [AbsExpr]
        AbsExpr = term()
        ErrorInfo = see section Error Information below.

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

        {ok, Expr_list}:
            The parsing was successful. Expr_list is a list of the form AbsExpr, which is described in the section Abstract Form below.

        {error, ErrorInfo}:
            An error occurred.

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

    Types
        Tokens = [Token]
        Token = {Tag, Line} | {Tag, Line, term()}
        Tag = atom()
        Term = term()
        ErrorInfo = see section Error Information below.

    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) -> string()

    Types
        ErrorDescriptor = errordesc()

    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
        Tokens = MoreTokens = [Token]
        Token = {Tag, Line} | {Tag, Line, term()}
        Tag = atom()
        AbsTerm = term()
        ErrorInfo = see section Error Information below.

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

normalise(AbsTerm) -> Data

    Types
        AbsTerm = 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 = AbsTerm = term()

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

Abstract Form

To be supplied

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:
apply(Module, format_error, ErrorDescriptor)

See Also

io, erl_scan

AUTHOR
Robert Virding - rv@erix.ericsson.se