
   compile_to_c
   
   
   
   compile_to_c [options] <Root-Class> [<Root-Procedure>] [*.c] [*.o]
   [-l*]
   
   Command compile_to_c is the SmallEiffel ANSI C code generator. Usualy
   this command is automatically called by command compile but you can
   use it separately to produce C code.
   
   Command compile_to_c must have at least one argument to indicate the
   starting execution point of the system. Thus, execution will start in
   <Root-Procedure> of <Root-Class>. The default <Root-Procedure> is
   make.
   
   Command compile_to_c produce all needed C files and also produce one
   command script file. The name of this script file change with the
   operating system used (*.make on Unix or *.BAT on DOS for example).
   
   1. Options to select Eiffel compilation mode
   There are 8 modes of compilation given by the following options names:
   -debug_check -all_check -loop_check -invariant_check -ensure_check
   -require_check -no_check and -boost option. Only one mode can be
   selected for the whole system to compile. Option -all_check is the
   default one.
   -boost:
          
          Compilation mode which includes all optimization. There is no
          target's existence test, no system-level validity checking.
          Some routines are inlined. No code is generated to get an
          execution trace in case of failure. There is no assertion
          check.
          
   -no_check:
          
          Compilation mode in which no Eiffel assertion is checked.
          The target's existence test is performed. Some code is
          generated for the system-level validity checking, and to
          produce an execution trace (an execution stack is managed).
          There is no inlining and no assertion check.
          
   -require_check:
          
          Compilation mode in which Eiffel preconditions are checked. The
          generated code is similar to the previous one, but also
          includes code to test preconditions (require).
          
   -ensure_check:
          
          The generated code is similar to the previous one, but also
          includes code to test postconditions (ensure).
          
   -invariant_check:
          
          The generated code is similar to the previous one, but also
          includes code to test class invariant.
          
   -loop_check:
          
          The generated code is similar to the previous one, but also
          includes code to test loop variant and loop invariant.
          
   -all_check:
          
          The default mode. The generated code is similar to the previous
          one, but also includes code for the check instruction.
          
   -debug_check:
          
          The generated code is similar to the previous one, but also
          includes code for the debug instruction. All debug are checked
          regardless of the optional string key.
          
   
   
   2. Others options
   -trace:
          
          This option may be useful to debug your program or to do some
          profiling. When selected, this option add some more C code to
          produce at run time the file "trace.se" (file "trace.se" is not
          produced at compile time). When running a traced program, you
          get a (usually huge) file "trace.se" in the launching
          directory. File "trace.se" tells you where your program is
          going: which line, which column in which Eiffel source file.
          Because all classes are traced, file "trace.se" is a huge file
          even for a small program. The feature GENERAL.trace_switch
          allow dynamic turning on/off of printed trace. At run time,
          when argument of trace_switch is true, trace printing is
          switched on (conversely, false is to switch off trace
          printing). When option -trace is not selected, calls to
          trace_switch are not taken in account by compile_to_c (no C
          code is produced). The -trace mode is not available whith mode
          -boost. Using at the same time -trace with -boost as the same
          effect as using -trace with -no_check. Also keep in mind that
          very simple instructions (as for example "i := i + 1;") may not
          be traced.
          
   -cc <c_compiler>:
          
          Call <c_compiler> instead of the default C compiler. See
          READ_ME of directory sys to set the default C compiler as well
          as the default linker.
          
   -no_split:
          
          produce only one C file for the whole Eiffel system. Thus, the
          C compiler may inline more functions calls. This option is
          usefull only to finalize an application (the incremental C
          compiling mode is switched off with -no_split).
          
   -no_strip:
          
          Do not produce a strip in the command file.
          
   -o <output_name>:
          
          Same meaning as -o option of the C compiler. The <output_name>
          is the name of the produced executable file.
          
   -cecil <cecil_file>:
          
          To allow some Eiffel features to be called from C (see cecil
          file for details). To call C functions/macros from Eiffel see
          external file.
          
   -verbose:
          
          to have information during the compilation (the full path of
          loaded files is printed, type inference score, removed files,
          etc).
          
   -no_warning:
          
          Suppress output for all warning messages (error messages are
          still printed).
          
   -case_insensitive:
          
          Switch on the case insensitive mode. For example, when this
          mode is selected, the Eiffel parser considers that the
          following identifiers are equivalent : item, ITEM, ItEm, ...
          
   
   
   3. Options passed to the C compiler
   Remaining options, *.c files, *.o files, library -l* are passed to the
   C compiler/linker.
   
   4. The environment variable SmallEiffel
   The environment variable SmallEiffel is used to indicate the place on
   the disk where the SmallEiffel directory is. This variable also
   indicates which system is used. When the SmallEiffel value contains a
   slash character ('/'), the compiler assumes it is a UNIX-like system.
   [Line]
   Copyright &copy; Dominique COLNET and Suzanne COLLIN -
   <colnet@loria.fr>
   Last update: Monday December 22, 1997 
