The
ferite options are listed below.
In keeping with the freedom-of-choice philosophy, options may be eliminated
or default values chosen at compile-time, so options and defaults listed
may not accurately reflect the version installed on your system.

-h,--help

Show the current for the program

--version

Show the current version or the program

--copyright

Show the current copyright for the program

-v,--verbose

This will cause the ferite executable to be verbose, this means that it will
explain where abouts in the grand scheme of things it is, eg. loading a file,
compiling it, deleting it.

-s,--showargs

This will cause the program to dump the list of arguments it is passing to
the initialisation of the ferite engine.

-e script, --execute script

This will cause ferite to instead of loading a disk file to compile and run,
use the string
script.
eg.
ferite -e "uses console; Console.println(Hello);" - this will print out
Hello

-c,--compile-only

ferite will only compile the program - this is useful for checking that you
have written syntacically correct code

-w,--warnings

ferite will display any warnings that are accumilated whilst compiling or
executing a script.

-Ipath, --include path

This will add
path to the list of directories that ferite searches for library
files, this is useful if you are say testing a library before installing it, or
have particular paths for files [eg. a home directory].

-Pmodule, --preload module

This will add
module to the list of modules that get loaded into the system before the script is
compiled.

The following options are specific to the engine and can be used where ever
the engine is used.

--fe-debug

This will turn on internal debugging of the engine. This will (if the engine
has been compiled with --enable-debug) cause a huge amount of data to be
outputed onto
stdout. The information contained within it is invaluable - tracking of function
execution flow, all sorts of messages allowing for the very quick location of
bugs.

--fe-use-classic

ferite by default usess its own memory suballocator called
jedi but there are times when it is useful to either access the systems malloc
directly, or to track when memory is being used. If ferite is compiled with
debugging, the classic memory manager will track memory allocations and dump
a table at the end of the programs execution to show all allocated memory.
This is vital for tracking memory leaks.
WARNING: This mode will cause ferites speed to drop immensily - its only useful for
debugging the engine.

--fe-show-mem-use

ferite keeps internal counters of memory useage, use this to see at the end
of a programs execution how much memory is still allocated, or has been
allocated.

--fe-use-mm-with-pcre

Tell ferite to use its own memory manager with the pcre regular
expression library