epp_dodger(3erl) Erlang Module Definition epp_dodger(3erl)
NAME
epp_dodger - epp_dodger - bypasses the Erlang preprocessor.
DESCRIPTION
epp_dodger - bypasses the Erlang preprocessor.
This module tokenises and parses most Erlang source code without ex-
panding preprocessor directives and macro applications, as long as
these are syntactically "well-behaved". Because the normal parse trees
of the erl_parse module cannot represent these things (normally, they
are expanded by the Erlang preprocessor epp(3erl) before the parser
sees them), an extended syntax tree is created, using the erl_syntax
module.
DATA TYPES
errorinfo() = {ErrorLine::integer(), Module::atom(), Descrip-
tor::term()}:
This is a so-called Erlang I/O ErrorInfo structure; see the
io(3erl) module for details.
EXPORTS
parse(Dev::IODevice) -> {ok, Forms} | {error, errorinfo()}
Equivalent to parse(IODevice, 1).
parse(Dev::IODevice, L::StartLine) -> {ok, Forms} | {error, error-
info()}
Types:
IODevice = pid()
StartLine = integer()
Forms = [erl_syntax:syntaxTree()]
Equivalent to parse(IODevice, StartLine, []).
See also: parse/1.
parse(Dev::IODevice, L0::StartLine, Options) -> {ok, Forms} | {error,
errorinfo()}
Types:
IODevice = pid()
StartLine = integer()
Options = [term()]
Forms = [erl_syntax:syntaxTree()]
Reads and parses program text from an I/O stream. Characters are
read from IODevice until end-of-file; apart from this, the be-
haviour is the same as for parse_file/2. StartLine is the ini-
tial line number, which should be a positive integer.
See also: parse/2, parse_file/2, parse_form/2, quick_parse/3.
parse_file(File) -> {ok, Forms} | {error, errorinfo()}
Types:
File = file:filename()
Forms = [erl_syntax:syntaxTree()]
Equivalent to parse_file(File, []).
parse_file(File, Options) -> {ok, Forms} | {error, errorinfo()}
Types:
File = file:filename()
Options = [term()]
Forms = [erl_syntax:syntaxTree()]
Reads and parses a file. If successful, {ok, Forms} is returned,
where Forms is a list of abstract syntax trees representing the
"program forms" of the file (cf. erl_syntax:is_form/1). Other-
wise, {error, errorinfo()} is returned, typically if the file
could not be opened. Note that parse errors show up as error
markers in the returned list of forms; they do not cause this
function to fail or return {error, errorinfo()}.
Options:
{no_fail, boolean()}:
If true, this makes epp_dodger replace any program forms
that could not be parsed with nodes of type text (see
erl_syntax:text/1), representing the raw token sequence of
the form, instead of reporting a parse error. The default
value is false.
{clever, boolean()}:
If set to true, this makes epp_dodger try to repair the
source code as it seems fit, in certain cases where parsing
would otherwise fail. Currently, it inserts ++-operators be-
tween string literals and macros where it looks like con-
catenation was intended. The default value is false.
See also: parse/2, quick_parse_file/1, erl_syntax:is_form/1.
parse_form(Dev::IODevice, L0::StartLine) -> {ok, Form, LineNo} | {eof,
LineNo} | {error, errorinfo(), LineNo}
Types:
IODevice = pid()
StartLine = integer()
Form = erl_syntax:syntaxTree()
LineNo = integer()
Equivalent to parse_form(IODevice, StartLine, []).
See also: quick_parse_form/2.
parse_form(Dev::IODevice, L0::StartLine, Options) -> {ok, Form, LineNo}
| {eof, LineNo} | {error, errorinfo(), LineNo}
Types:
IODevice = pid()
StartLine = integer()
Options = [term()]
Form = erl_syntax:syntaxTree()
LineNo = integer()
Reads and parses a single program form from an I/O stream. Char-
acters are read from IODevice until an end-of-form marker is
found (a period character followed by whitespace), or until end-
of-file; apart from this, the behaviour is similar to that of
parse/3, except that the return values also contain the final
line number given that StartLine is the initial line number, and
that {eof, LineNo} may be returned.
See also: parse/3, parse_form/2, quick_parse_form/3.
quick_parse(Dev::IODevice) -> {ok, Forms} | {error, errorinfo()}
Equivalent to quick_parse(IODevice, 1).
quick_parse(Dev::IODevice, L::StartLine) -> {ok, Forms} | {error, er-
rorinfo()}
Types:
IODevice = pid()
StartLine = integer()
Forms = [erl_syntax:syntaxTree()]
Equivalent to quick_parse(IODevice, StartLine, []).
See also: quick_parse/1.
quick_parse(Dev::IODevice, L0::StartLine, Options) -> {ok, Forms} |
{error, errorinfo()}
Types:
IODevice = pid()
StartLine = integer()
Options = [term()]
Forms = [erl_syntax:syntaxTree()]
Similar to parse/3, but does a more quick-and-dirty processing
of the code. See quick_parse_file/2 for details.
See also: parse/3, quick_parse/2, quick_parse_file/2,
quick_parse_form/2.
quick_parse_file(File) -> {ok, Forms} | {error, errorinfo()}
Types:
File = file:filename()
Forms = [erl_syntax:syntaxTree()]
Equivalent to quick_parse_file(File, []).
quick_parse_file(File, Options) -> {ok, Forms} | {error, errorinfo()}
Types:
File = file:filename()
Options = [term()]
Forms = [erl_syntax:syntaxTree()]
Similar to parse_file/2, but does a more quick-and-dirty pro-
cessing of the code. Macro definitions and other preprocessor
directives are discarded, and all macro calls are replaced with
atoms. This is useful when only the main structure of the code
is of interest, and not the details. Furthermore, the quick-
parse method can usually handle more strange cases than the nor-
mal, more exact parsing.
Options: see parse_file/2. Note however that for
quick_parse_file/2, the option no_fail is true by default.
See also: parse_file/2, quick_parse/2.
quick_parse_form(Dev::IODevice, L0::StartLine) -> {ok, Form, LineNo} |
{eof, LineNo} | {error, errorinfo(), LineNo}
Types:
IODevice = pid()
StartLine = integer()
Form = erl_syntax:syntaxTree() | none
LineNo = integer()
Equivalent to quick_parse_form(IODevice, StartLine, []).
See also: parse_form/2.
quick_parse_form(Dev::IODevice, L0::StartLine, Options) -> {ok, Form,
LineNo} | {eof, LineNo} | {error, errorinfo(), LineNo}
Types:
IODevice = pid()
StartLine = integer()
Options = [term()]
Form = erl_syntax:syntaxTree()
LineNo = integer()
Similar to parse_form/3, but does a more quick-and-dirty pro-
cessing of the code. See quick_parse_file/2 for details.
See also: parse/3, parse_form/3, quick_parse_form/2.
tokens_to_string(Tokens::[term()]) -> string()
Generates a string corresponding to the given token sequence.
The string can be re-tokenized to yield the same token list
again.
AUTHORS
Richard Carlsson <carlsson.richard@gmail.com>
syntax_tools 2.3 epp_dodger(3erl)