# erl_parse

### MODULE

erl_parse

### MODULE SUMMARY

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).

### 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. `AbsForm` is the abstract form of the parsed form.
`{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 abstract forms of the parsed expressions.
`{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) -> Chars`

Types:

`ErrorDescriptor = errordesc()`
`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:

`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`.

### 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(3), erl_scan(3), ERTS User's Guide

### AUTHORS

Robert Virding - support@erlang.ericsson.se

stdlib 1.14.1
Copyright © 1991-2006 Ericsson AB