Provided by: erlang-manpages_22.0.7+dfsg-1_all bug

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 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(3erl) before the  parser  sees
       them), an extended syntax tree is created, using the erl_syntax module.

DATA TYPES

         errorinfo() = {ErrorLine::integer(), Module::atom(), Descriptor::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, errorinfo()}

              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 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(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). 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, 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  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(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. 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(Dev::IODevice) -> {ok, Forms} | {error, errorinfo()}

              Equivalent to quick_parse(IODevice, 1).

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

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