erl_parse

19962016 Ericsson AB. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. erl_parse Robert Bjarne Däcker 1 Bjarne Däcker 97-01-24 B erl_parse.sgml

erl_parse The Erlang Parser

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

abstract_clause()

Abstract form of an Erlang clause.

abstract_expr()

Abstract form of an Erlang expression.

abstract_form()

Abstract form of an Erlang form.

abstract_type()

Abstract form of an Erlang type.

Parse an Erlang form

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 Erlang expressions

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 an Erlang term

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 Format an error descriptor ErrorDescriptor = error_description() 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).

Generate a list of tokens for an expression

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

Convert abstract form to an Erlang 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.

Convert an Erlang term into an abstract form

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

erl_parse:abstract(T) is equivalent to erl_parse:abstract(T, 0).

Convert an Erlang term into an abstract form

Converts the Erlang data structure Data into an abstract form of type AbsTerm.

The Line option is the line that will be assigned to each node of AbsTerm.

The Encoding option is used for selecting which integer lists will be considered as strings. The default is to use the encoding returned by epp:default_encoding/0. The value none means that no integer lists will be considered as strings. The encoding_func() will be called with one integer of a list at a time, and if it returns true for every integer the list will be considered a string.

Map a function over the annotations of a erl_parse tree

Modifies the erl_parse tree Abstr by applying Fun on each collection of annotations of the nodes of the erl_parse tree. The erl_parse tree is traversed in a depth-first, left-to-right, fashion.

Fold a function over the annotations of a erl_parse tree

Updates an accumulator by applying Fun on each collection of annotations of the erl_parse tree Abstr. The first call to Fun has AccIn as argument, and the returned accumulator AccOut is passed to the next call, and so on. The final value of the accumulator is returned. The erl_parse tree is traversed in a depth-first, left-to-right, fashion.

Map and fold a function over the annotations of a erl_parse tree

Modifies the erl_parse tree Abstr by applying Fun on each collection of annotations of the nodes of the erl_parse tree, while at the same time updating an accumulator. The first call to Fun has AccIn as second argument, and the returned accumulator AccOut is passed to the next call, and so on. The modified erl_parse tree as well as the the final value of the accumulator are returned. The erl_parse tree is traversed in a depth-first, left-to-right, fashion.

Create new annotations

Assumes that Term is a term with the same structure as a erl_parse tree, but with locations where a erl_parse tree has collections of annotations. Returns a erl_parse tree where each location L has been replaced by the value returned by erl_anno:new(L). The term Term is traversed in a depth-first, left-to-right, fashion.

Return annotations as terms

Assumes that Term is a term with the same structure as a erl_parse tree, but with terms, T say, where a erl_parse tree has collections of annotations. Returns a erl_parse tree where each term T has been replaced by the value returned by erl_anno:from_term(T). The term Term is traversed in a depth-first, left-to-right, fashion.

Return the representation of annotations

Returns a term where each collection of annotations Anno of the nodes of the erl_parse tree Abstr has been replaced by the term returned by erl_anno:to_term(Anno). The erl_parse tree is traversed in a depth-first, left-to-right, fashion.

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)