SYSTEM OPTIONS

Following is the list of system-level options supported by
'gexace' (of the form <option name="..." value="..."/>),
and how they are translated to the vendor dependent Ace or
ESD files. "N/A" does not necessarily mean that the corresponding
Eiffel compiler does not support this facility, it could just
be that the facility is not parameterizable or is activated
from the command-line or from a separate tool (such as VETuner
for Visual Eiffel) rather than from the Ace or ESD file. When
an entry is marked "N/A" the option will be silently ignored
and nothing will be generated in the Ace or ESD file for this
option. Likewise when the name of an option specified in
an Xace file is not known by 'gexace'.

The DEFAULT section shows 'gexace' default value when this
option is not explicitely specified in the Xace file. It
can be different from the default value used by the various
Eiffel vendors in their Ace or ESD files.

For further details about each option, please refer to the
documentation provided with the Eiffel compilers.

-------------------------------------------------------------
NAME: address_expression

VALUES: true | false
DEFAULT: false
DESCRIPTION: Enable expressions of the form '$(s.to_c)' instead
  of having to declare 'a' of type ANY, and then having to 
  assign 's.to_c' to 'a' and passing '$a'. Turn this option on
  only if you have advanced knowledge of the garbage collector
  insides, since using this syntax illegally can lead to bugs
  very hard to trace.
NOTE: This form of syntax is not supported in Visual Eiffel and
  SmartEiffel.

ISE:
  true -> address_expression (yes)
  false -> address_expression (no)
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: arguments

VALUES: <arguments>
DEFAULT: no default
DESCRIPTION: Arguments passed to the application when launched
  from ISE EiffelStudio.
NOTE: There can be several of these options.

ISE:
  <arguments> -> arguments ("<arguments>")
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: array_optimization

VALUES: true | false
DEFAULT: false
DESCRIPTION: Enable array optimization in loops when the array
  has been declared as local variable or formal argument.
NOTE: The option 'finalize' (finalization mode) should
  be set in order for this option to have any effect.

ISE:
  true -> array_optimization (yes)
  false -> array_optimization (no)
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: assertion

VALUES: none | generate | require | ensure | invariant |
        loop_invariant | loop_variant | check | all
DEFAULT: require
DESCRIPTION: Set default assertion level of the Eiffel system.
NOTE: There can be several of these options.
NOTE: The purpose of 'generate' is to generate the code of
  the assertions in the generated code even if these assertions
  are turned off. VE can turn them on after the system has been
  compiled.

ISE:
  none -> assertion (no)
  generate -> assertion (no)
  require -> assertion (require)
  ensure -> assertion (ensure)
  invariant -> assertion (invariant)
  loop_invariant -> assertion (loop)
  loop_variant -> assertion (loop)
  check -> assertion (check)
  all -> assertion (all)
VE:
  none ->
       assertions off
       require off
       ensure off
       class invariant off
       loop invariant off
       loop variant off
       check off
  generate ->
       assertions on
       require off
       ensure off
       class invariant off
       loop invariant off
       loop variant off
       check off
  require ->
       assertions on
       require on
       ensure off
       class invariant off
       loop invariant off
       loop variant off
       check off
  ensure ->
       assertions on
       require off
       ensure on
       class invariant off
       loop invariant off
       loop variant off
       check off
  invariant ->
       assertions on
       require off
       ensure off
       class invariant on
       loop invariant off
       loop variant off
       check off
  loop_invariant ->
       assertions on
       require off
       ensure off
       class invariant off
       loop invariant on
       loop variant off
       check off
  loop_variant ->
       assertions on
       require off
       ensure off
       class invariant off
       loop invariant off
       loop variant on
       check off
  check ->
       assertions on
       require off
       ensure off
       class invariant off
       loop invariant off
       loop variant off
       check on
  all ->
       assertions on
       require on
       ensure on
       class invariant on
       loop invariant on
       loop variant on
       check on
  --
  If several occurrences of ESD options would need to be generated,
  only one occurrence would actually be generated with value 'on'
  if there is at least one 'on' and 'off' otherwise.
SE:
  none -> assertion (no)
  generate -> assertion (no)
  require -> assertion (require)
  ensure -> assertion (ensure)
  invariant -> assertion (invariant)
  loop_invariant -> assertion (loop)
  loop_variant -> assertion (loop)
  check -> assertion (check)
  all -> assertion (all)
  --
  If several occurrences of Ace options would need to be generated,
  only one occurrence would actually be generated with the value
  which appears below all the others in the list above. However if
  'boost' is specified in the option 'finalize', then values specified
  in option 'assertion' are ignored.
-------------------------------------------------------------
NAME: case_insensitive

VALUES: true | false
DEFAULT: true
DESCRIPTION: Enable Eiffel code to be case insensitive.

ISE:
  N/A
VE:
  N/A
SE:
  true -> case_insensitive (yes)
  false -> nothing (this is the default)
-------------------------------------------------------------
NAME: check_vape

VALUES: true | false
DEFAULT: true
DESCRIPTION: Report VAPE validity errors (ETL 2nd edition page 122).

ISE:
  true -> check_vape (yes)
  false -> check_vape (no)
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: clean

VALUES: true | false
DEFAULT: false
DESCRIPTION: Remove all generated C files, all generated object
  files and all other temporary files generated during the
  compilation process.

ISE:
  N/A
VE:
  N/A
SE:
  true -> clean (yes)
  false -> clean (no)
-------------------------------------------------------------
NAME: cls_compliant

VALUES: true | false
DEFAULT: true
DESCRIPTION: When compiling to the .NET framework. Is the generated
  code CLS compliant?

ISE:
  true -> cls_compliant (yes)
  false -> cls_compliant (no)
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: console_application

VALUES: true | false
DEFAULT: true
DESCRIPTION: Under Windows, generate either a console or a windows
  application.

ISE:
  true -> console_application (yes)
  false -> console_application (no)
VE:
  true -> target <target> console
  false -> target <target> windows
SE:
  N/A
-------------------------------------------------------------
NAME: create_keyword_extension

VALUES: true | false
DEFAULT: true
DESCRIPTION: Specify that 'create' should be considered as
  a keyword (replacing the old form !!) and not as an
  identifier.
NOTE: This option was for the Halstenbach compiler. 
  Even if Halstenbach is not supported any more, gexace
  still supports this option because some Xace files may 
  have it.
  
ISE:
  N/A
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: c_compiler_options

VALUES: <options>
DEFAULT: no default
DESCRIPTION: Specifies options to be passed to the c compiler,
  which is responsible for compiling the C code that has been
  generated from the Eiffel system.
NOTE: There can be several of these options.
  Makes only sense for Eiffel compilers, which generate c 
  code.

ISE:
  <options> -> include_path: "some123/fake432/path567 <options>"
VE:
  N/A
SE:
  <options> -> c_compiler_options: "<options>"
-------------------------------------------------------------
NAME: dead_code_removal

VALUES: none | low_level | feature | class | all
DEFAULT: all
DESCRIPTION: Do not include dead code in the generated application.
  'low_level' means that unreachable chuncks of code are not included,
  'feature' means that features which are never called are not
  included, and 'class' means the classes which are in the system
  but which are never instanciated in the living code are not
  included.
NOTE: The option 'finalize' (finalization mode) should be set
  in order for 'feature', 'class' and 'all' (except its low_level
  part in VE) to have any effect.
NOTE: There can be several of these options.

ISE:
  none -> dead_code_removal (no)
  low_level -> dead_code_removal (no)
  feature -> dead_code_removal (yes)
  class -> dead_code_removal (no)
  all -> dead_code_removal (yes)
  --
  If several occurrences of Ace options would need to be generated,
  only one occurrence would actually be generated with value 'yes'
  if there is at least one 'yes' and 'no' otherwise.
VE:
  none ->
     optimize dead_code off
     optimize calls off
     optimize dyn_type off
  low_level ->
     optimize dead_code on
     optimize calls off
     optimize dyn_type off
  feature ->
     optimize dead_code off
     optimize calls on
     optimize dyn_type off
  class ->
     optimize dead_code off
     optimize calls off
     optimize dyn_type on
  all ->
     optimize dead_code on
     optimize calls on
     optimize dyn_type on
  --
  If several occurrences of ESD options would need to be generated,
  only one occurrence would actually be generated with value 'on'
  if there is at least one 'on' and 'off' otherwise.
SE:
  N/A
-------------------------------------------------------------
NAME: debug

VALUES: true | false
DEFAULT: false
DESCRIPTION: Enable debug instructions.

ISE:
  true -> debug (yes)
  false -> debug (no)
VE:
  true -> debug instructions on
  false -> debug instructions off
  --
  If option 'debug_tag' is also specified, then set to
  'on' if at least one of the two 'debug instructions'
  are 'on', 'off' otherwise.
  The debug instructions are actually only executed if
  so specified in the command-line of the application.
SE:
  true -> debug (yes)
  false -> debug (no)
-------------------------------------------------------------
NAME: debug_tag

VALUES: <tag>
DEFAULT: no default
DESCRIPTION: Enable debug instructions with tag '<tag>'.
NOTE: There can be several of these options.

ISE:
  <tag> -> debug ("<tag>")
VE:
  <tag> -> debug instructions on
  --
  If option 'debug' is also specified, then set to 'on'
  if at least one of the two 'debug instructions' are
  'on', 'off' otherwise.
  The debug instructions are actually only executed if
  so specified in the command-line of the application.
SE:
  <tag> -> debug ("<tag>")
-------------------------------------------------------------
NAME: debugger

VALUES: true | false
DEFAULT: false
DESCRIPTION: Specify whether debug information should be
  generated. Debug information is required to use the
  debugger with Visual Eiffel.

ISE:
  N/A
VE:
  true -> debug on
  false -> debug off
SE:
  N/A
-------------------------------------------------------------
NAME: document

VALUES: <pathname>
DEFAULT: no default
DESCRIPTION: Specify in which directory the documentation
  generated by ISE EiffelStudio should be put (when using the
  Project/Generate documentation... menu). If no directory is
  specified, the documentation will be generated at the same
  level as the EIFGEN directory in a directory called
  'Documentation'. 

ISE:
  <pathname> -> document ("<pathname>")
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: dotnet_naming_convention

VALUES: true | false
DEFAULT: false
DESCRIPTION: When compiling to the .NET framework. Should the
  Eiffel code use .NET naming convention when calling routines
  from the assembly (use Eiffel naming convention otherwise)?

ISE:
  true -> dotnet_naming_convention (yes)
  false -> dotnet_naming_convention (no)
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: dynamic_runtime

VALUES: true | false
DEFAULT: false
DESCRIPTION: Enable the use of the Eiffel runtime as a
  DLL or shared library.

ISE:
  true -> dynamic_runtime (yes)
  false -> dynamic_runtime (no)
VE:
  true -> run_time_in_dll on
  false -> run_time_in_dll off
SE:
  N/A
-------------------------------------------------------------
NAME: exception_trace

VALUES: true | false
DEFAULT: false
DESCRIPTION: Enable to see a complete exception trace
  when a finalized application is crashing.
NOTE: The option 'finalize' (finalization mode) should
  be set in order for this option to have any effect.

ISE:
  true -> exception_trace (yes)
  false -> exception_trace (no)
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: finalize

VALUES: true | false
DEFAULT: false
DESCRIPTION: Enable global optimizations (finalization mode).
NOTE: This option has no direct effect. Each individual
  optimization option should be set separately.

ISE:
  N/A
VE:
  true -> finalize on
  false -> finalize off
  --  
  Setting 'finalize on' automatically turns 'assertions off'.
SE:
  true -> assertion (boost)
  false -> assertion (no)
  --
  If 'boost' is specified, then values specified in option 'assertion'
  are ignored. Otherwise 'no' might be overriden by values specified
  in option 'assertion'.
-------------------------------------------------------------
NAME: flat_fst_optimization

VALUES: true | false
DEFAULT: false
DESCRIPTION: Specify whether dynamic tables may be kept not
  compacted for faster dynamic access to features.
NOTE: The option 'finalize' (finalization mode) should
  be set in order for this option to have any effect.

ISE:
  N/A
VE:
  true -> optimize flat_fsf on
  false -> optimize flat_fsf off
SE:
  N/A
-------------------------------------------------------------
NAME: fst_expansion_factor

VALUES: <value>
DEFAULT: 2
DESCRIPTION: Visual Eiffel supports dynamic binding via
  mechanism of FST (stands for Feature Selection Tables).
  Every entry in such table is a pair "class id (magic
  number) - feature address/attribute offset". In the general
  case binary searching is used to find the proper entry. To
  make this search faster and more efficient binary searching
  in the table can be replaced with direct linear access to
  array items (class id will be used as index of the array
  item). <value> is a positive integer number. When FST size
  multiplied by <value> is greater than the maximum class id
  in this FST, it is transformed into array.

ISE:
  N/A
VE:
  <value> -> FST_expansion_factor <value>
SE:
  N/A
-------------------------------------------------------------
NAME: fst_optimization

VALUES: true | false
DEFAULT: false
DESCRIPTION: Replace dynamic feature calls by static ones
  when possible (FST stands for Feature Selection Tables).

ISE:
  N/A
VE:
  true -> optimize FST on
  false -> optimize FST off
SE:
  N/A
-------------------------------------------------------------
NAME: garbage_collector

VALUES: none | internal | boehm
DEFAULT: internal
DESCRIPTION: Select garbage collector.

ISE:
  N/A
VE:
  N/A
SE:
  none -> collect (no)
  internal -> collect (yes)
  boehm -> collect (no)
-------------------------------------------------------------
NAME: gc_info

VALUES: true | false
DEFAULT: false
DESCRIPTION: Enable garbage collector status information.

ISE:
  N/A
VE:
  N/A
SE:
  true -> gc_info (yes)
  false -> gc_info (no)
-------------------------------------------------------------
NAME: header

VALUES: <pathname>
DEFAULT: no default
DESCRIPTION: Specify a directory containing C header files.
NOTE: There can be several of these options.

ISE:
  <pathname> -> include_path: "<pathname>"
VE:
  N/A
SE:
  <pathname> -> external_header_path: "<pathname>"
-------------------------------------------------------------
NAME: heap_size

VALUES: <value>
DEFAULT: no default
DESCRIPTION: Specify the dynamic heap size for the program.
  <value> is a positive number of bytes that will be reserved
  for the heap.

ISE:
  N/A
VE:
  <value> -> heap_size <value>
SE:
  N/A
-------------------------------------------------------------
NAME: high_memory_compiler

VALUES: true | false
DEFAULT: false
DESCRIPTION: Allow the compiler to use more memory at compile
  time (caching, bigger buffers, etc.). Compilation is likely
  to be quicker, if you have enough memory (RAM, not disk!)... 

ISE:
  N/A
VE:
  N/A
SE:
  true -> high_memory_compiler (yes)
  false -> high_memory_compiler (no)
-------------------------------------------------------------
NAME: il_verifiable

VALUES: true | false
DEFAULT: true
DESCRIPTION: When compiling to the .NET framework. Is the generated
  code IL verifiable?

ISE:
  true -> il_verifiable (yes)
  false -> il_verifiable (no)
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: inlining

VALUES: none | array | constant | once | all
DEFAULT: none
DESCRIPTION: Enable inlining. 'array' means ARRAY and STRING
  inlining, 'constants' means constant inlining, 'once' means
  once-feature inlining, and 'all' means anything that can
  be inlined.
NOTE: There can be several of these options.

ISE:
  none -> inlining (no)
  array -> inlining (yes)
  constant -> inlining (yes)
  once -> inlining (yes)
  all -> inlining (yes)
  --
  If several occurrences of Ace options would need to be generated,
  only one occurrence would actually be generated with value 'yes'
  if there is at least one 'yes' and 'no' otherwise.
  The option has effect only in finalized mode.
VE:
  none ->
       optimize inline off
       optimize constants off
       optimize once off
  array ->
       optimize inline on
       optimize constants off
       optimize once off
  constant ->
       optimize inline off
       optimize constants on
       optimize once off
  once ->
       optimize inline off
       optimize constants off
       optimize once on
  all ->
       optimize inline on
       optimize constants on
       optimize once on
  --
  If several occurrences of ESD options would need to be generated,
  only one occurrence would actually be generated with value 'on'
  if there is at least one 'on' and 'off' otherwise.
SE:
  N/A
-------------------------------------------------------------
NAME: inlining_size

VALUES: <value>
DEFAULT: 4
DESCRIPTION: Specify maximum size of routines to be inlined.
NOTE: No effect if 'inlining' is disabled.

ISE:
  <value> -> inlining_size ("<value>")
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: jumps_optimization

VALUES: true | false
DEFAULT: false
DESCRIPTION: Specify whether jumps optimization will be enabled.
  This option activates low-level code optimization: chains of
  jump instructions (when one jump instruction transfers control
  to another jump instruction) are replaced when possible by the
  shortcut jump instruction.

ISE:
  N/A
VE:
  true -> optimize jumps on
  false -> optimize jumps off
SE:
  N/A
-------------------------------------------------------------
NAME: layout_optimization

VALUES: true | false
DEFAULT: false
DESCRIPTION: Specify whether special rearrangements may be used
  to represent the objects in the memory in more access-efficient
  way by changing the order of the attributes.
NOTE: The option 'finalize' (finalization mode) should
  be set in order for this option to have any effect.

ISE:
  N/A
VE:
  true -> optimize layout on
  false -> optimize layout off
SE:
  N/A
-------------------------------------------------------------
NAME: leaves_optimization

VALUES: true | false
DEFAULT: false
DESCRIPTION: Specify whether all calls to features of the leaf
  classes will be direct ones.
NOTE: The option 'finalize' (finalization mode) should
  be set in order for this option to have any effect.

ISE:
  N/A
VE:
  true -> optimize leaves on
  false -> optimize leaves off
SE:
  N/A
-------------------------------------------------------------
NAME: line_generation

VALUES: true | false
DEFAULT: false
DESCRIPTION: Generate C pragmas '#line x' in generated C code.

ISE:
  true -> line_generation (yes)
  false -> line_generation (no)
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: link

VALUES: <pathname>
DEFAULT: no default
DESCRIPTION: Specify object files, library files or command
  line options to be passed to the linker.
NOTE: There can be several of these options.

ISE:
  <pathname> -> object: "<pathname>"
VE:
  <pathname> -> link "<pathname>"
SE:
  <pathname> -> external_lib: "<pathname>"
-------------------------------------------------------------
NAME: linker

VALUES: default | microsoft
DEFAULT: default
DESCRIPTION: Specify which linker should be used. 'default'
  means that the standard Object Tools linker is invoked for
  linking, 'microsoft' means that ther standard Microsoft
  linker is invoked.

ISE:
  N/A
VE:
  default -> linker default
  microsoft -> linker microsoft
SE:
  N/A
-------------------------------------------------------------
NAME: linux_fpu_double_precision

VALUES: true | false
DEFAULT: false
DESCRIPTION: The default FPU precision used by gcc for Linux
  may not be appropriate for some users and does not match the
  behavior of gcc on other platforms or the behavior of other
  compilers on the same architecture (i386). The option
  has no effect if used on a different platform.
NOTE: This option was for the Halstenbach compiler. 
  Even if Halstenbach is not supported any more, gexace
  still supports this option because some Xace files may 
  have it.
  
ISE:
  N/A
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: manifest_string_trace

VALUES: true | false
DEFAULT: false
DESCRIPTION: Print an information message each time a non-once
  manifest string is allocated at runtime.

ISE:
  N/A
VE:
  N/A
SE:
  true -> manifest_string_trace (yes)
  false -> manifest_string_trace (no)
-------------------------------------------------------------
NAME: map

VALUES: true | false
DEFAULT: false
DESCRIPTION: Specify whether the map file is to be created.

ISE:
  N/A
VE:
  true -> map on
  false -> map off
SE:
  N/A
-------------------------------------------------------------
NAME: metadata_cache_path

VALUES: <pathname>
DEFAULT: no default
DESCRIPTION: When compiling to the .NET framework. Specify pathname
  where XML files describing DLLs assemblies will be generated.

ISE:
  <pathname> -> metadada_cache_path ("<pathname>")
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: msil_assembly_compatibility

VALUES: "None"|"Same domain"|"Same machine"|"Same process"
DEFAULT: no default
DESCRIPTION: When compiling to the .NET framework. Assembly compatibility.

ISE:
  <value> -> msil_assembly_compatibility ("<value>")
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: msil_clr_version

VALUES: <version>
DEFAULT: no default
EXAMPLE: v1.1.4322
DESCRIPTION: When compiling to the .NET framework. Specify version
  of .NET framework to be used.

ISE:
  <pathname> -> msil_clr_version ("<version>")
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: msil_generation

VALUES: true | false
DEFAULT: false
DESCRIPTION: Compile to the .NET framework.

ISE:
  true -> msil_generation (yes)
  false -> msil_generation (no)
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: msil_generation_version

VALUES: <version>
DEFAULT: no default
EXAMPLE: 1.1.0411.02
DESCRIPTION: When compiling to the .NET framework. Specify version
  of generated DLL or EXE assembly (info stored in the metadata).

ISE:
  <pathname> -> version ("<version>")
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: multithreaded

VALUES: true | false
DEFAULT: false
DESCRIPTION: Enable generation of a multithreaded application.

ISE:
  true -> multithreaded (yes)
  false -> multithreaded (no)
VE:
  true -> multithreading on
  false -> multithreading off
  --
  No effect on platforms other than Windows.
SE:
  N/A
-------------------------------------------------------------
NAME: no_default_lib

VALUES: true | false
DEFAULT: false
DESCRIPTION: Specify that default library should not be linked
  in (works only with Object Tools linker)

ISE:
  N/A
VE:
  true -> no_default_lib on
  false -> no_default_lib off
SE:
  N/A
-------------------------------------------------------------
NAME: override_cluster

VALUES: <cluster_name>
DEFAULT: no default
DESCRIPTION: Enable all classes of <cluster_name> to override
  the classes with the same names located in other clusters.

ISE:
  <cluster_name> -> override_cluster (<cluster_name>)
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: portable_code_generation

VALUES: true | false
DEFAULT: false
DESCRIPTION: Should generated C code be portable?
NOTE: This option was for the Halstenbach compiler. 
  Even if Halstenbach is not supported any more, gexace
  still supports this option because some Xace files may 
  have it.
  
ISE:
  N/A
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: precompiled

VALUES: <pathname>
DEFAULT: no default
DESCRIPTION: Specify a precompiled library.

ISE:
  <pathname> -> precompiled ("<pathname>")
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: profile

VALUES: true | false
DEFAULT: false
DESCRIPTION: Enable Eiffel profiling.

ISE:
  true -> profile (yes)
  false -> profile (no)
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: reloads_optimization

VALUES: true | false
DEFAULT: false
DESCRIPTION: Specify whether register reloads optimizations
  will be enabled. This option activates low-level code
  optimization: the value will not be loaded in a register
  from the memory if it is already stored in the register.

ISE:
  N/A
VE:
  true -> optimize reloads on
  false -> optimize reloads off
SE:
  N/A
-------------------------------------------------------------
NAME: shared_library_definition

VALUES: <filename.def>
DEFAULT: no default
DESCRIPTION: Specify the file where the Eiffel compiler will
  look when generating the exported functions of a shared
  library.

ISE:
  <filename.def> -> shared_library_definition ("<filename.def>")
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: split

VALUES: true | false
DEFAULT: false
DESCRIPTION: Generate several C files instead of one big
  single C file for the complete system.

ISE:
  N/A
VE:
  N/A
SE
  true -> no_split (no)
  false -> no_split (yes)
-------------------------------------------------------------
NAME: stack_size

VALUES: <value>
DEFAULT: no default
DESCRIPTION: Specify the stack size for the program. <value>
  is a positive number of bytes that will be reserved for
  the program stack.

ISE:
  N/A
VE:
  <value> -> stack_size <value>
SE:
  N/A
-------------------------------------------------------------
NAME: storable_filename

VALUES: <filename>
DEFAULT: no default
DESCRIPTION: Specify a list of class names (one per line) that
  should be marked as 'storable'. It's an alternative to declaring
  these classes in 'storable' clauses in cluster declarations
  in Ace files.
NOTE: This option was for the Halstenbach compiler. 
  Even if Halstenbach is not supported any more, gexace
  still supports this option because some Xace files may 
  have it.
  
ISE:
  N/A
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: strip

VALUES: true | false
DEFAULT: true
DESCRIPTION: Enable 'strip' to be run on the generated executable.

ISE:
  N/A
VE:
  N/A
SE
  true -> no_strip (no)
  false -> no_strip (yes)
-------------------------------------------------------------
NAME: target

VALUES: exe | dll | com | no_main
DEFAULT: exe
DESCRIPTION: Specify the output target of the application.

ISE:
  exe -> msil_generation_type ("exe")
  dll -> msil_generation_type ("dll")
  com -> msil_generation_type ("exe")
  no_main -> msil_generation_type ("exe")
VE:
  exe -> target exe <application>
  dll -> target dll <application>
  com -> target com <application>
  no_main -> target dll <application>
SE:
  exe -> no_main (no)
  dll -> no_main (yes)
  com -> no_main (yes)
  no_main -> no_main (yes)
-------------------------------------------------------------
NAME: trace

VALUES: true | false
DEFAULT: false
DESCRIPTION: Enable trace mode.

ISE:
  true -> trace (yes)
  false -> trace (no)
VE:
  N/A
SE:
  true -> trace (yes)
  false -> trace (no)
-------------------------------------------------------------
NAME: use_cluster_name_as_namespace

VALUES: true | false
DEFAULT: false
DESCRIPTION: When compiling to the .NET framework. Should the
  cluster name be used as namespace (e.g. base.STRING)?

ISE:
  true -> use_cluster_name_as_namespace (yes)
  false -> use_cluster_name_as_namespace (no)
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: use_full_cluster_name_as_namespace

VALUES: true | false
DEFAULT: false
DESCRIPTION: When compiling to the .NET framework. Should the
  full cluster name be used as namespace (e.g. base.kernel.STRING)?

ISE:
  true -> use_all_cluster_name_as_namespace (yes)
  false -> use_all_cluster_name_as_namespace (no)
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: verbose

VALUES: true | false
DEFAULT: false
DESCRIPTION: Run compiler in verbose mode.

ISE:
  N/A
VE:
  N/A
SE:
  true -> verbose (yes)
  false -> verbose (no)
-------------------------------------------------------------
NAME: visible_filename

VALUES: <filename>
DEFAULT: no default
DESCRIPTION: Specify a list of class names (one per line) that
  should be marked as 'visible'. It's an alternative to declaring
  these classes in 'visible' clauses in cluster declarations
  in Ace files.
NOTE: This option was for the Halstenbach compiler. 
  Even if Halstenbach is not supported any more, gexace
  still supports this option because some Xace files may 
  have it.
  
ISE:
  N/A
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: warning

VALUES: none | style | default | all
DEFAULT: default
DESCRIPTION: Specify warning level. 'style' means that Eiffel
  style warnings (e.g. having feature names in all upper-case)
  are emitted. 'default' means that warnings such as local
  variables unused are emitted. 'all' means that all warnings
  are emitted.

ISE:
  N/A
VE:
  N/A
SE:
  none ->
      no_style_warning (yes)
      no_warning (yes)
  style ->
      no_style_warning (no)
      no_warning (yes)
  default ->
      no_style_warning (yes)
      no_warning (no)
  all ->
      no_style_warning (no)
      no_warning (no)
-------------------------------------------------------------
NAME: wedit

VALUES: true | false
DEFAULT: false
DESCRIPTION: Enable support for the Wedit debugger.

ISE:
  N/A
VE:
  N/A
SE:
  true -> wedit (yes)
  false -> wedit (no)
-------------------------------------------------------------

NOTE: When precompiling with Visual Eiffel, only the
following options are supported by the compiler:

. assertions on/off
. debug on/off

NOTE2: the following ISE Eiffel options are not supported
yet by 'gexace':

. disabled_debug (...)

=============================================================

CLUSTER OPTIONS

Following is the list of cluster-level options supported by
'gexace' (of the form <option name="..." value="..."/>),
and how they are translated to the vendor dependent Ace or
ESD files. "N/A" does not necessarily mean that the corresponding
Eiffel compiler does not support this facility, it could just
be that the facility is not parameterizable or is activated
from the command-line or from a separate tool (such as VETuner
for Visual Eiffel) rather than from the Ace or ESD file. When
an entry is marked "N/A" the option will be silently ignored
and nothing will be generated in the Ace or ESD file for this
option. Likewise when the name of an option specified in
an Xace file is not known by 'gexace'.

The DEFAULT section shows 'gexace' default value when this
option is not explicitely specified in the Xace file. It
can be different from the default value used by the various
Eiffel vendors in their Ace or ESD files.

For further details about each option, please refer to the
documentation provided with the Eiffel compilers.

-------------------------------------------------------------
NAME: abstract

VALUES: true | false
DEFAULT: false
DESCRIPTION: Specify that this cluster should not be searched
  for Eiffel classes (but its subclusters can if they don't
  have this option set).

ISE:
  true ->
      if there is at least one non-abstract subcluster ->
          cluster_name: "pathname"
      if there is no non-abstract subcluster ->
          no output
  false ->
      cluster_name: "pathname"
VE:
  true ->
      no output
  false ->
      cluster_name: "pathname"
SE:
  true ->
      no output
  false ->
      cluster_name: "pathname"
-------------------------------------------------------------
NAME: assembly

VALUES: <name>
DEFAULT: no default
DESCRIPTION: Specify that the cluster is in fact a .NET assembly.

ISE:
  <name> ->
      assembly
         cluster_name: "<name>", "<version>", "<culture>", "<public_key_token>"
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: assertion

VALUES: none | generate | require | ensure | invariant |
        loop_invariant | loop_variant | check | all
DEFAULT: no default
DESCRIPTION: Set default assertion level for the classes of
  this cluster. Override the assertion level specified at
  the system level.
NOTE: There can be several of these options.
NOTE: The purpose of 'generate' is to generate the code of
  the assertions in the generated code even if these assertions
  are turned off. VE can turn them on after the system has been
  compiled.

ISE:
  none -> assertion (no)
  generate -> assertion (no)
  require -> assertion (require)
  ensure -> assertion (ensure)
  invariant -> assertion (invariant)
  loop_invariant -> assertion (loop)
  loop_variant -> assertion (loop)
  check -> assertion (check)
  all -> assertion (all)
VE:
  N/A
SE:
  none -> assertion (no)
  generate -> assertion (no)
  require -> assertion (require)
  ensure -> assertion (ensure)
  invariant -> assertion (invariant)
  loop_invariant -> assertion (loop)
  loop_variant -> assertion (loop)
  check -> assertion (check)
  all -> assertion (all)
  --
  If several occurrences of Ace options would need to be generated,
  only one occurrence would actually be generated with the value
  which appears below all the others in the list above.
-------------------------------------------------------------
NAME: component

VALUES: <pathname>
DEFAULT: no default
DESCRIPTION: Specify that the cluster is in fact a component library.
NOTE: This option was for the Halstenbach compiler. 
  Even if Halstenbach is not supported any more, gexace
  still supports this option because some Xace files may 
  have it.
  
ISE:
  N/A
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: culture

VALUES: <culture>
DEFAULT: neutral
DESCRIPTION: Specify the culture of the .NET assembly.
NOTE: The option 'assembly' should be set in order for this
  option to have any effect.

ISE:
  <culture> ->
      assembly
         cluster_name: "<name>", "<version>", "<culture>", "<public_key_token>"
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: debug

VALUES: true | false
DEFAULT: no default
DESCRIPTION: Enable debug instructions for the classes of this cluster.
  Override the 'debug' option specified at the system level.

ISE:
  true -> debug (yes)
  false -> debug (no)
VE:
  N/A
SE:
  true -> debug (yes)
  false -> debug (no)
-------------------------------------------------------------
NAME: debug_tag

VALUES: <tag>
DEFAULT: no default
DESCRIPTION: Enable debug instructions with tag '<tag>' for the
  classes of this cluster. Override the 'debug_tag' option
  specified at the system level.
NOTE: There can be several of these options.

ISE:
  <tag> -> debug ("<tag>")
VE:
  N/A
SE:
  <tag> -> debug ("<tag>")
-------------------------------------------------------------
NAME: document

VALUES: <pathname>
DEFAULT: no default
DESCRIPTION: Specify in which directory the documentation for
  the classes of this cluster generated by ISE EiffelStudio
  should be put (when using the Project/Generate documentation...
  menu). If no directory is specified, the documentation will
  be generated at the same level as the EIFGEN directory in a
  directory called 'Documentation'. Override the 'document'
  option specified at the system level.

ISE:
  <pathname> -> document ("<pathname>")
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: exclude

VALUES: <pathname>
DEFAULT: no default
DESCRIPTION: Specify a filename, or a directory name when the
  'recursive' option is set, that should not be taken into
  account when searching the cluster for Eiffel classes.
NOTE: There can be several of these options.

ISE:
  <pathname> ->
      cluster_name: "pathname"
         exclude
            "<pathname>"
         end
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: header

VALUES: <pathname>
DEFAULT: no default
DESCRIPTION: Specify a directory containing C header files.
NOTE: There can be several of these options.

ISE:
  <pathname> -> include_path: "<pathname>"
VE:
  N/A
SE:
  <pathname> -> external_header_path: "<pathname>"
-------------------------------------------------------------
NAME: include

VALUES: <pathname>
DEFAULT: no default
DESCRIPTION: Specify a filename that should be taken into
  account when searching the cluster for Eiffel classes,
  even though it does not necessarily have a .e extension.
NOTE: There can be several of these options.

ISE:
  <pathname> ->
      cluster_name: "pathname"
         include
            "<pathname>"
         end
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: link

VALUES: <pathname>
DEFAULT: no default
DESCRIPTION: Specify object files, library files or command
  line options to be passed to the linker.
NOTE: There can be several of these options.

ISE:
  <pathname> -> object: "<pathname>"
VE:
  <pathname> -> link "<pathname>"
SE:
  <pathname> -> external_lib: "<pathname>"
-------------------------------------------------------------
NAME: namespace

VALUES: <namespace>
DEFAULT: no default
DESCRIPTION: When compiling to the .NET framework. Specify the
  namespace to be used for the classes of this cluster.

ISE:
  <namespace> -> namespace ("<namespace>")
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: prefix

VALUES: <prefix>
DEFAULT: no default
DESCRIPTION: Specify the class prefix for the .NET assembly.
NOTE: The option 'assembly' should be set in order for this
  option to have any effect.

ISE:
  <prefix> ->
      assembly
         cluster_name: "<name>", "<version>", "<culture>", "<public_key_token>"
            prefix
               "<prefix>"
            end
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: profile

VALUES: true | false
DEFAULT: no default
DESCRIPTION: Enable Eiffel profiling for the classes of this
  cluster. Override the 'profile' option specified at the
  system level.

ISE:
  true -> profile (yes)
  false -> profile (no)
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: public_key_token

VALUES: <public_key_token>
DEFAULT: b77a5c561934e089
DESCRIPTION: Specify the public_key_token of the .NET assembly.
NOTE: The option 'assembly' should be set in order for this
  option to have any effect.

ISE:
  <public_key_token> ->
      assembly
         cluster_name: "<name>", "<version>", "<culture>", "<public_key_token>"
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: read_only

VALUES: true | false
DEFAULT: false
DESCRIPTION: Specify that the classes in the cluster
  directory should be considered as read-only by the
  underlying Eiffel tool.
NOTE: This option is only supported by ISE's EiffelStudio
  when the cluster is also 'recursive'. Otherwise it
  has no effect

ISE:
  true ->
      library cluster_name: "pathname"
  false ->
      cluster_name: "pathname"
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: recursive

VALUES: true | false
DEFAULT: false
DESCRIPTION: Specify that the cluster directory and its
  subdirectories should be recursively traversed to find
  Eiffel classes.

ISE:
  true ->
      all cluster_name: "pathname"
  false ->
      cluster_name: "pathname"
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: storable

VALUES: true | false
DEFAULT: no default
DESCRIPTION: Specify that all classes in the cluster should
  be included into the system.
NOTE: This option was for the Halstenbach compiler. 
  Even if Halstenbach is not supported any more, gexace
  still supports this option because some Xace files may 
  have it.
  
ISE:
  N/A
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: trace

VALUES: true | false
DEFAULT: no default
DESCRIPTION: Enable trace mode for the classes of this cluster.
  Override the 'trace' option specified at the system level.

ISE:
  true -> trace (yes)
  false -> trace (no)
VE:
  N/A
SE:
  true -> trace (yes)
  false -> trace (no)
-------------------------------------------------------------
NAME: version

VALUES: <version>
DEFAULT: 1.0.5000.0
DESCRIPTION: Specify the version of the .NET assembly.
NOTE: The option 'assembly' should be set in order for this
  option to have any effect.

ISE:
  <version> ->
      assembly
         cluster_name: "<name>", "<version>", "<culture>", "<public_key_token>"
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------

=============================================================

CLASS OPTIONS

Following is the list of class-level options supported by
'gexace' (of the form <option name="..." value="..."/>),
and how they are translated to the vendor dependent Ace or
ESD files. "N/A" does not necessarily mean that the corresponding
Eiffel compiler does not support this facility, it could just
be that the facility is not parameterizable or is activated
from the command-line or from a separate tool (such as VETuner
for Visual Eiffel) rather than from the Ace or ESD file. When
an entry is marked "N/A" the option will be silently ignored
and nothing will be generated in the Ace or ESD file for this
option. Likewise when the name of an option specified in
an Xace file is not known by 'gexace'.

The DEFAULT section shows 'gexace' default value when this
option is not explicitely specified in the Xace file. It
can be different from the default value used by the various
Eiffel vendors in their Ace or ESD files.

For further details about each option, please refer to the
documentation provided with the Eiffel compilers.

-------------------------------------------------------------
NAME: assertion

VALUES: none | generate | require | ensure | invariant |
        loop_invariant | loop_variant | check | all
DEFAULT: no default
DESCRIPTION: Set default assertion level for this class.
  Override the assertion level specified at the cluster
  and system levels.
NOTE: There can be several of these options.
NOTE: The purpose of 'generate' is to generate the code of
  the assertions in the generated code even if these assertions
  are turned off. VE can turn them on after the system has been
  compiled.

ISE:
  none -> assertion (no): CLASS_NAME
  generate -> assertion (no): CLASS_NAME
  require -> assertion (require): CLASS_NAME
  ensure -> assertion (ensure): CLASS_NAME
  invariant -> assertion (invariant): CLASS_NAME
  loop_invariant -> assertion (loop): CLASS_NAME
  loop_variant -> assertion (loop): CLASS_NAME
  check -> assertion (check): CLASS_NAME
  all -> assertion (all): CLASS_NAME
VE:
  N/A
SE:
  none -> assertion (no): CLASS_NAME
  generate -> assertion (no): CLASS_NAME
  require -> assertion (require): CLASS_NAME
  ensure -> assertion (ensure): CLASS_NAME
  invariant -> assertion (invariant): CLASS_NAME
  loop_invariant -> assertion (loop): CLASS_NAME
  loop_variant -> assertion (loop): CLASS_NAME
  check -> assertion (check): CLASS_NAME
  all -> assertion (all): CLASS_NAME
  --
  If several occurrences of Ace options would need to be generated,
  only one occurrence would actually be generated with the value
  which appears below all the others in the list above.
-------------------------------------------------------------
NAME: debug

VALUES: true | false
DEFAULT: no default
DESCRIPTION: Enable debug instructions for this class.
  Override the 'debug' option specified at the cluster and
  system levels.

ISE:
  true -> debug (yes): CLASS_NAME
  false -> debug (no): CLASS_NAME
VE:
  N/A
SE:
  true -> debug (yes): CLASS_NAME
  false -> debug (no): CLASS_NAME
-------------------------------------------------------------
NAME: debug_tag

VALUES: <tag>
DEFAULT: no default
DESCRIPTION: Enable debug instructions with tag '<tag>' for this
  class. Override the 'debug_tag' option specified at the cluster
  and system levels.
NOTE: There can be several of these options.

ISE:
  <tag> -> debug ("<tag>"): CLASS_NAME
VE:
  N/A
SE:
  <tag> -> debug ("<tag>"): CLASS_NAME
-------------------------------------------------------------
NAME: export

VALUES: <external_name>
DEFAULT: no default
DESCRIPTION: Specify that this class and its features should
  be visible from C when using Cecil for example.

ISE:
  <external_name> ->
     visible
         CLASS_NAME
             end
  --
  Limitation: the external name is not taken into account.
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: layout

VALUES: auto | sequential
DEFAULT: auto
DESCRIPTION: Specify the layout of an object when it is accessed
  from outside Eiffel code. 'auto' means the layout for the object
  fields (variable attributes) in memory is chosen automatically.
  'sequential' means the fields are laid out in memory in the order
  they appear in a class text. The fields of child classes are laid
  out after the fields of parent classes. Inability to do so
  (because of repeated and multiple inheritance) results in a
  compilation error.

ISE:
  N/A
VE:
  auto -> no output
  sequential -> interface CLASS_NAME
SE:
  N/A
-------------------------------------------------------------
NAME: storable

VALUES: true | false
DEFAULT: no default
DESCRIPTION: Specify that this class should be included into
  the system.
NOTE: This option was for the Halstenbach compiler. 
  Even if Halstenbach is not supported any more, gexace
  still supports this option because some Xace files may 
  have it.
  
ISE:
  N/A
VE:
  N/A
SE:
  N/A
-------------------------------------------------------------
NAME: trace

VALUES: true | false
DEFAULT: no default
DESCRIPTION: Enable trace mode for this class. Override the
  'trace' option specified at the cluster and system levels.

ISE:
  true -> trace (yes): CLASS_NAME
  false -> trace (no): CLASS_NAME
VE:
  N/A
SE:
  true -> trace: CLASS_NAME
  false -> no output
-------------------------------------------------------------

=============================================================

FEATURE OPTIONS

Following is the list of feature-level options supported by
'gexace' (of the form <option name="..." value="..."/>),
and how they are translated to the vendor dependent Ace or
ESD files. "N/A" does not necessarily mean that the corresponding
Eiffel compiler does not support this facility, it could just
be that the facility is not parameterizable or is activated
from the command-line or from a separate tool (such as VETuner
for Visual Eiffel) rather than from the Ace or ESD file. When
an entry is marked "N/A" the option will be silently ignored
and nothing will be generated in the Ace or ESD file for this
option. Likewise when the name of an option specified in
an Xace file is not known by 'gexace'.

The DEFAULT section shows 'gexace' default value when this
option is not explicitely specified in the Xace file. It
can be different from the default value used by the various
Eiffel vendors in their Ace or ESD files.

For further details about each option, please refer to the
documentation provided with the Eiffel compilers.

-------------------------------------------------------------
NAME: callback

VALUES: winapi
DEFAULT: no default
DESCRIPTION: Specify that this feature should get a wrapper
  when $ operator is applied; the result can be used as a pointer
  to the Windows API callback function if value of the option is
  "winapi".
ISE:
  N/A
VE:
  winapi ->
    callback
      class CLASS_NAME
        feature_name
      end
SE:
  N/A
-------------------------------------------------------------
NAME: export

VALUES: <external_name>
DEFAULT: no default
DESCRIPTION: Specify that this feature should be visible
  from C when using Cecil for example.

ISE:
  <external_name> ->
     visible
         CLASS_NAME
             export
                 feature_name
             end
  --
  Limitation: the external name is not taken into account.
VE:
  N/A
SE:
  <external_name> ->
     In Ace file:
        external cecil ("cecil.se")
     In 'cecil.se' file:
        <external_name> CLASS_NAME feature_name
-------------------------------------------------------------

