[[Property:title|Advanced Options]]
[[Property:weight|4]]
[[Property:uuid|be1dc034-2bca-3d3a-5dfc-8597b2cc7051]]
[[Image:advanced-options|Advanced dialog]]  
* Address Expression: lets you pass `$(s.to_c)` to a feature instead of declaring `a` of type <code>ANY</code>, and then assigning `s.to_c` to `a` and passing `$a`. 
{{Caution|Turn this option on only if you have advanced knowledge of the garbage collector internals, because using this syntax in some situations could lead to bugs that are very hard to trace. }} 
*  Automatic Backup: generate a backup of the class and configuration files during recompilation? 
* Check VAPE: Enforce <code> VAPE </code> validity constraint: lets you disable type checking for <code> VAPE </code> errors in preconditions, which correspond to insufficiently exported features used in preconditions (ETL 2nd edition page 122). 
* Check for Void target: Should "Feature call on Void target" exceptions be raised?
* Console Application: has no effect on Unix systems. It lets Windows users choose between creating a console application or a GUI application (in which case a console will be created if needed, instead of using the console the program was launched from).
* Dead Code Removal: should unused code be removed? (C code generation mode only)
* Dynamic Runtime: makes the generated executable use a shared library version of the runtime on both Windows (DLL) and Unix platforms (.so) that supports shared libraries.(C code generation mode only)

{{note|On Windows, the dynamic run-time is available only if you compile with the Microsoft Visual compiler. }}
* Enforce unique class names: enforce all class names to be system wide unique?
* Exception Trace: makes it possible to see a complete exception trace in a finalized application. Because it is adding some code to remember where the application was during the crash it can slow down the performance of your application by a factor of 5% to 30% depending of your platform. (C code generation mode only)
* Inlining, Inlining Size: enables inlining on Eiffel features that can be inlined, i.e. whose size is less or equal to the specified size in the combo box. The size value given in parameter corresponds to the number of instructions as seen by the Eiffel compiler (for example a := b.f corresponds to 2 instructions). The inlining is very powerful since it can inline a function in all your Eiffel code, without scope limitation as found in C or C++ compilers. (C code generation mode only)
* Platform: override platform value used for checking conditions, useful for cross compilation
* Shared Library Definition: lets you specify a `file_name.def' as the file where the Eiffel compiler will look when it tries to generate the exported functions of the shared library you are developing (C code generation mode only). To have more information concerning definition files, see the [[Dynamic library generation]] . 
* Total Order on REALs: Allow a total order on REAL data types? Allows NaN (Not a Number) equal NaN, and NaN to be the smallest number of all. 
* Library Root: Absolute path to use as base for relative paths. If this is not defined, the path to the configuration file will be used.

==.NET Options==
* Use Optimized Precompile: use an optimized version of a precompile
* Use Cluster Name as Namespace: See [[Advanced Options|Class and feature naming]]  
* Use Recursive Cluster Name as Namespace: See [[Advanced Options|Class and feature naming]]  
* .NET Naming Convention: See [[Advanced Options|Class and feature naming]]  
* IL Verifiable: in the .NET world, verifiability is important. This is the only way to ensure that an application is not going to crash or to crash your system by accessing not authorized memory locations. Due to some semantic differences between Eiffel and.NET, our code generation is not always verifiable for performance reasons. If you want your code to be verifiable, you need to select this option. The compiler will then generate a code that will be slightly slower.
* CLS Compliant: mark generated assemblies as CLS compliant

* Metadata Cache Path: Location where information about external assemblies is stored.
* Classes per Module: Number of classes generated per .NET module during incremental compilation. Increasing this value will slow down the incremental recompilation, but speed up the time to load the assembly while debugging in workbench mode.
* .NET Runtime Version: .NET version to use
* Generation Type: generate an exe or a dll (exe is default)
* Signing Key: specify a cryptographic key for your application so that the compiled assembly can be added to the Global Assembly Cache (GAC). If a non existing filename is chosen, a key will be automatically generated.
* Force 32bit: on a 64bit machine, forces compilation for 32 bit.
<span id="dotnet_naming"></span> 
===Class and feature naming===


The standard naming conventions for .NET and Eiffel are different. To accommodate this difference Eiffel Studio provides a number of options to the developer, allowing for consistent naming of classes and features within and between .NET systems. To illustrate this we shall consider a system using the EiffelBase library and focus on the CURSOR class. The base cluster is included in the project settings Cluster tab as shown below, where $ISE_EIFFEL is the environment variable pointing to the location of Eiffel on your hard disk. 


The CURSOR class is located at '$ISE_EIFFEL\library\base\structures\cursors'.


* Follow .NET naming guidelines: this option determines whether the generated .NET code uses the Eiffel or .NET naming convention. Using Ildasm, the IL disassembler tool provided with the .NET Framework, we can see the difference between them. The Eiffel naming convention uses uppercase characters for all classes whereas the .NET nomenclature uses the Camel Case style. Note that this option is only available in a non-compiled system. Once the system has been compiled the naming standard is fixed for the project.

No .NET naming guidelines

[[Image:ildasm-no-dotnet-naming]]  

.NET naming guidelines

[[Image:ildasm-dotnet-naming]]  


* Use cluster names and Use recursive cluster names: These options dictate how a class is known to the system. In our CURSOR example there are 4 main scenarios. For a quick overview of all scenarios refer to the table at the bottom of the page. If neither box is selected we just have 'CURSOR' or 'Cursor' (depending on whether the .NET naming guidelines are used), as seen above. If 'Use cluster names' is checked then the cluster name is pre-pended to the class name, so 'CURSOR' now becomes 'base.CURSOR'.

[[Image:use-cluster-names]]  



If 'Use recursive cluster names' is true then the full cluster name is pre-pended to the class name, so it thus becomes 'base.structures.cursors.CURSOR'.



[[Image:use-full-cluster-names]]  



The final scenario is where a namespace has been defined for the cluster in the Clusters tab of the Project Settings. In this situation the namespace overrides the name of the cluster. In the example below the namespace name 'MyBaseNameSpace' is used so the resulting name is 'MyBaseNameSpace.structures.cursors.CURSOR'.



[[Image:use-namespace-name]]  



===Naming Scenarios===

This table shows how the class name generation is affected by the naming options using the CURSOR class found in '$ISE_EIFFEL\library\base\structures\cursors' as an example.
{| 
|- 
| Use .NET naming guidelines
| Use cluster names
| Use full cluster names
| Namespace Name
| Generated Name
|- 
| no
| no
| no
| (empty)
| CURSOR
|- 
| yes
| no
| no
| (empty)
| Cursor
|- 
| no
| yes
| no
| (empty)
| base.CURSOR
|- 
| yes
| yes
| no
| (empty)
| Base.Cursor
|- 
| no
| no
| yes
| (empty)
| structures.cursors.CURSOR
|- 
| yes
| no
| yes
| (empty)
| Structures.Cursors.Cursor
|- 
| no
| yes
| yes
| (empty)
| base.structures.cursors.CURSOR
|- 
| yes
| yes
| yes
| (empty)
| Base.Structures.Cursors.Cursor
|- 
| no
| no
| no
| MyNameSpace
| MyNameSpace.CURSOR
|- 
| yes
| no
| no
| MyNameSpace
| MyNameSpace.Cursor
|- 
| no
| yes
| no
| MyNameSpace
| MyNameSpace.CURSOR
|- 
| yes
| yes

| no
| MyNameSpace
| MyNameSpace.Cursor
|- 

| no
| no
| yes
| MyNameSpace
| MyNameSpace.structures.cursors.CURSOR
|- 
| yes
| no
| yes
| MyNameSpace
| MyNameSpace.structures.cursors.Cursor
|- 
| no
| yes
| yes
| MyNameSpace
| MyNameSpace.structures.cursors.CURSOR
|- 
| yes
| yes
| yes
| MyNameSpace
| MyNameSpace.Structures.Cursors.Cursor
|}