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() = erl_scan:error_info():

         option() = atom() | {atom(), term()}:

EXPORTS

       parse(Dev::file:io_device()) -> {ok, erl_syntax:forms()}

              Equivalent to parse(IODevice, 1).

       parse(Dev::file:io_device(), L::erl_anno:location()) -> {ok, erl_syntax:forms()}

              Equivalent to parse(IODevice, StartLocation, []).

              See also: parse/1.

       parse(Dev::file:io_device(),   L0::erl_anno:location(),   Options::[option()])   ->   {ok,
       erl_syntax:forms()}

              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.
              StartLocation is the initial location.

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

       parse_file(File::file:filename()) -> {ok, erl_syntax:forms()} | {error, errorinfo()}

              Equivalent to parse_file(File, []).

       parse_file(File::file:filename(),  Options::[option()])  ->  {ok,  erl_syntax:forms()}   |
       {error, errorinfo()}

              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::file:io_device(),  L0::erl_anno:location())  ->  {ok,  erl_syntax:forms(),
       erl_anno:location()}    |    {eof,    erl_anno:location()}    |    {error,    errorinfo(),
       erl_anno:location()}

              Equivalent to parse_form(IODevice, StartLocation, []).

              See also: quick_parse_form/2.

       parse_form(Dev::file:io_device(), L0::erl_anno:location(),  Options::[option()])  ->  {ok,
       erl_syntax:forms(),   erl_anno:location()}   |   {eof,   erl_anno:location()}   |  {error,
       errorinfo(), erl_anno:location()}

              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 location
              given that StartLocation is the initial location, and that {eof, Location}  may  be
              returned.

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

       quick_parse(Dev::file:io_device()) -> {ok, erl_syntax:forms()}

              Equivalent to quick_parse(IODevice, 1).

       quick_parse(Dev::file:io_device(), L::erl_anno:location()) -> {ok, erl_syntax:forms()}

              Equivalent to quick_parse(IODevice, StartLocation, []).

              See also: quick_parse/1.

       quick_parse(Dev::file:io_device(),  L0::erl_anno:location(),  Options::[option()]) -> {ok,
       erl_syntax:forms()}

              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::file:filename()) -> {ok, erl_syntax:forms()} | {error, errorinfo()}

              Equivalent to quick_parse_file(File, []).

       quick_parse_file(File::file:filename(), Options::[option()]) -> {ok, erl_syntax:forms()} |
       {error, errorinfo()}

              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::file:io_device(),       L0::erl_anno:location())       ->       {ok,
       erl_syntax:forms(),  erl_anno:location()}   |   {eof,   erl_anno:location()}   |   {error,
       errorinfo(), erl_anno:location()}

              Equivalent to quick_parse_form(IODevice, StartLocation, []).

              See also: parse_form/2.

       quick_parse_form(Dev::file:io_device(),  L0::erl_anno:location(),  Options::[option()]) ->
       {ok, erl_syntax:forms(),  erl_anno:location()}  |  {eof,  erl_anno:location()}  |  {error,
       errorinfo(), erl_anno:location()}

              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(Ts::[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.6                        epp_dodger(3erl)