# Module epp_dodger

`epp_dodger` - bypasses the Erlang preprocessor.

- Description
- Data Types
- Function Index
- Function Details

## Description

`epp_dodger` - bypasses the Erlang preprocessor.

This module tokenises and parses most Erlang source code without expanding 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` before the parser sees them), an extended syntax tree is created, using the `erl_syntax` module.

## Data Types

### errorinfo()

`errorinfo() = {ErrorLine::integer(), Module::atom(), Descriptor::term()}`

This is a so-called Erlang I/O ErrorInfo structure; see the stdlib `io` module for details.

## Function Index

parse/1 | Equivalent to `parse(IODevice, 1)`.
parse/2 | Equivalent to `parse(IODevice, StartLine, [])`.
parse/3 | Reads and parses program text from an I/O stream.
parse_file/1 | Equivalent to `parse_file(File, [])`.
parse_file/2 | Reads and parses a file.
parse_form/2 | Equivalent to `parse_form(IODevice, StartLine, [])`.
parse_form/3 | Reads and parses a single program form from an I/O stream.
quick_parse/1 | Equivalent to `quick_parse(IODevice, 1)`.
quick_parse/2 | Equivalent to `quick_parse(IODevice, StartLine, [])`.
quick_parse/3 | Similar to `parse/3`, but does a more quick-and-dirty processing of the code.
quick_parse_file/1 | Equivalent to `quick_parse_file(File, [])`.
quick_parse_file/2 | Similar to `parse_file/2`, but does a more quick-and-dirty processing of the code.
quick_parse_form/2 | Equivalent to `quick_parse_form(IODevice, StartLine, [])`.
quick_parse_form/3 | Similar to `parse_form/3`, but does a more quick-and-dirty processing of the code.
tokens_to_string/1 | Generates a string corresponding to the given token sequence.

## Function Details

### parse/1

`parse(Dev::IODevice) -> {ok, Forms} | {error, errorinfo()}`

Equivalent to `parse(IODevice, 1)`.

### parse/2

`parse(Dev::IODevice, L::StartLine) -> {ok, Forms} | {error, errorinfo()}`

- `IODevice = pid()`
- `StartLine = integer()`
- `Forms = [erl_syntax:syntaxTree()]`

Equivalent to `parse(IODevice, StartLine, [])`.

See also: parse/1.

### parse/3

`parse(Dev::IODevice, L0::StartLine, Options) -> {ok, Forms} | {error, errorinfo()}`

- `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 behaviour is the same as for `parse_file/2`. `StartLine` is the initial line number, which should be a positive integer.

See also: parse/2, parse_file/2, parse_form/2, quick_parse/3.

### parse_file/1

`parse_file(File) -> {ok, Forms} | {error, errorinfo()}`

- `File = file:filename()`
- `Forms = [erl_syntax:syntaxTree()]`

Equivalent to `parse_file(File, [])`.

### parse_file/2

`parse_file(File, Options) -> {ok, Forms} | {error, errorinfo()}`

- `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`). Otherwise, `{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, bool()}`
  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, bool()}`
  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 between string literals and macros where it looks like concatenation was intended. The default value is `false`.

See also: parse/2, quick_parse_file/1, erl_syntax:is_form/1.

### parse_form/2

`parse_form(Dev::IODevice, L0::StartLine) -> {ok, Form, LineNo} | {eof, LineNo} | {error, errorinfo(), LineNo}`

- `IODevice = pid()`
- `StartLine = integer()`
- `Form = erl_syntax:syntaxTree()`
- `LineNo = integer()`

Equivalent to `parse_form(IODevice, StartLine, [])`.

See also: quick_parse_form/2.

### parse_form/3

`parse_form(Dev::IODevice, L0::StartLine, Options) -> {ok, Form, LineNo} | {eof, LineNo} | {error, errorinfo(), LineNo}`

- `IODevice = pid()`
- `StartLine = integer()`
- `Options = [term()]`
- `Form = erl_syntax:syntaxTree()`
- `LineNo = integer()`

Reads and parses a single program form from an I/O stream. Characters 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/1

`quick_parse(Dev::IODevice) -> {ok, Forms} | {error, errorinfo()}`

Equivalent to `quick_parse(IODevice, 1)`.

### quick_parse/2

`quick_parse(Dev::IODevice, L::StartLine) -> {ok, Forms} | {error, errorinfo()}`

- `IODevice = pid()`
- `StartLine = integer()`
- `Forms = [erl_syntax:syntaxTree()]`

Equivalent to `quick_parse(IODevice, StartLine, [])`.

See also: quick_parse/1.

### quick_parse/3

`quick_parse(Dev::IODevice, L0::StartLine, Options) -> {ok, Forms} | {error, errorinfo()}`

- `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/1

`quick_parse_file(File) -> {ok, Forms} | {error, errorinfo()}`

- `File = file:filename()`
- `Forms = [erl_syntax:syntaxTree()]`

Equivalent to `quick_parse_file(File, [])`.

### quick_parse_file/2

`quick_parse_file(File, Options) -> {ok, Forms} | {error, errorinfo()}`

- `File = file:filename()`
- `Options = [term()]`
- `Forms = [erl_syntax:syntaxTree()]`

Similar to `parse_file/2`, but does a more quick-and-dirty processing 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 normal, 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/2

`quick_parse_form(Dev::IODevice, L0::StartLine) -> {ok, Form, LineNo} | {eof, LineNo} | {error, errorinfo(), LineNo}`

- `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/3

`quick_parse_form(Dev::IODevice, L0::StartLine, Options) -> {ok, Form, LineNo} | {eof, LineNo} | {error, errorinfo(), LineNo}`

- `IODevice = pid()`
- `StartLine = integer()`
- `Options = [term()]`
- `Form = erl_syntax:syntaxTree()`
- `LineNo = integer()`

Similar to `parse_form/3`, but does a more quick-and-dirty processing of the code. See `quick_parse_file/2` for details.

See also: parse/3, parse_form/3, quick_parse_form/2.

### tokens_to_string/1

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