jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

nofoward doesn't exist yet; fixes #890

Browse source
This commit is contained in:
Araq 2014-02-10 00:16:29 +01:00
commit b9c0a4addc
1 changed files with 38 additions and 35 deletions
Download patch file Download diff file Expand all files Collapse all files

73
doc/manual.txt
View file

@ -5136,51 +5136,54 @@ Example:
.. code-block:: nimrod .. code-block:: nimrod
{.deadCodeElim: on.} {.deadCodeElim: on.}
NoForward pragma
----------------
The `noforward`:idx: pragma can be used to turn on and off a special compilation
mode that to large extent eliminates the need for forward declarations. In this
mode, the proc definitions may appear out of order and the compiler will postpone
their semantic analysis and compilation until it actually needs to generate code
using the definitions. In this regard, this mode is similar to the modus operandi
of dynamic scripting languages, where the function calls are not resolved until
the code is executed. Here is the detailed algorithm taken by the compiler:
1. When a callable symbol is first encountered, the compiler will only note the ..
symbol callable name and it will add it to the appropriate overload set in the NoForward pragma
current scope. At this step, it won't try to resolve any of the type expressions ----------------
used in the signature of the symbol (so they can refer to other not yet defined The `noforward`:idx: pragma can be used to turn on and off a special compilation
symbols). mode that to large extent eliminates the need for forward declarations. In this
mode, the proc definitions may appear out of order and the compiler will postpone
their semantic analysis and compilation until it actually needs to generate code
using the definitions. In this regard, this mode is similar to the modus operandi
of dynamic scripting languages, where the function calls are not resolved until
the code is executed. Here is the detailed algorithm taken by the compiler:
2. When a top level call is encountered (usually at the very end of the module), 1. When a callable symbol is first encountered, the compiler will only note the
the compiler will try to determine the actual types of all of the symbols in the symbol callable name and it will add it to the appropriate overload set in the
matching overload set. This is a potentially recursive process as the signatures current scope. At this step, it won't try to resolve any of the type expressions
of the symbols may include other call expressions, whoose types will be resolved used in the signature of the symbol (so they can refer to other not yet defined
at this point too. symbols).
3. Finally, after the best overload is picked, the compiler will start compiling 2. When a top level call is encountered (usually at the very end of the module),
the body of the respective symbol. This in turn will lead the compiler to discover the compiler will try to determine the actual types of all of the symbols in the
more call expresions that need to be resolved and steps 2 and 3 will be repeated matching overload set. This is a potentially recursive process as the signatures
as necessary. of the symbols may include other call expressions, whoose types will be resolved
at this point too.
Please note that if a callable symbol is never used in this scenario, its body 3. Finally, after the best overload is picked, the compiler will start compiling
will never be compiled. This is the default behavior leading to best compilation the body of the respective symbol. This in turn will lead the compiler to discover
times, but if exhaustive compilation of all definitions is required, using more call expresions that need to be resolved and steps 2 and 3 will be repeated
``nimrod check`` provides this option as well. as necessary.
Example: Please note that if a callable symbol is never used in this scenario, its body
will never be compiled. This is the default behavior leading to best compilation
times, but if exhaustive compilation of all definitions is required, using
``nimrod check`` provides this option as well.
.. code-block:: nimrod Example:
{.noforward: on.} .. code-block:: nimrod
proc foo(x: int) = {.noforward: on.}
bar x
proc bar(x: int) = proc foo(x: int) =
echo x bar x
proc bar(x: int) =
echo x
foo(10)
foo(10)
Pragma pragma Pragma pragma
------------- -------------