mirrors/eiffel-org
1
0
Fork 0
mirror of https://github.com/EiffelSoftware/eiffel-org.git synced 2025-12-08 15:52:26 +01:00
Code Issues Packages Projects Releases Wiki Activity

Renamed current as trunk.

Browse Source 
git-svn-id: https://svn.eiffel.com/eiffel-org/trunk@1433 abb3cda0-5349-4a8f-a601-0c33ac3a8c38
This commit is contained in:
eiffel-org
2015-09-23 17:16:49 +00:00
parent 2aba4b49af
commit 5e7183f738
2851 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
documentation/trunk/eiffelstudio/eiffelstudio-reference/compiler/command-line/batch-compilation.wiki Normal file
View File

@@ -0,0 +1,47 @@
[[Property:title|Batch compilation]]
[[Property:weight|2]]
[[Property:uuid|18958db6-dafc-57b7-cdef-aca01bc13661]]
In order to launch a compilation without user intervention you need to specify the `<code>-batch</code>' switch in the '''ec''' command line, otherwise the Eiffel compilation will be blocked. We will present below a typical example of batch processing on both Unix and Windows platforms where we want to compile a project in both frozen and finalized mode, then to launch the C compilations. At the same time we want to save the output of '''ec''' and the C compilations.
===Unix===
In a file called `launch_ec' you can have the following:
<code lang=text>
#!/bin/sh
output_file="/output_path/OUTPUT"
cd /your_project_path
#Launch Eiffel compilation
ec -batch -config config.ecf -finalize -c_compile 2> $output_file
#Since only C compilation for finalized code is done
#Launch C compilation for frozen code
cd EIFGENs/target_name/W_code
finish_freezing > $output_file</code>
It will go the directory where your project is located and compile your Eiffel code using the `<code>config.ecf</code>' file located in your project directory and compile automatically the C code. All outputs will be stored in the file `<code>/output_path/OUTPUT</code>'.
{{note|All output from '''ec''' are going to the error output, so do not forget to redirect the error output when you want to see the result. }}
===Windows===
In a file called `launched_ec.bat' you can have the following:
<code lang=text>
rem Launch Eiffel compilation
ec -batch -config config.ecf -finalize -c_compile > c:\output_path\OUTPUT
rem Since only C compilation for finalized code is done
rem Launch C compilation for frozen code
cd EIFGENs\target_name\W_code
finish_freezing > c:\output_path\OUTPUT</code>
It will go the directory where your project is located and compile your Eiffel code using the `<code>config.ecf</code>' file located in your project directory and compile automatically the C code. All outputs will be stored in the file `<code>c:\output_path/OUTPUT</code>'.
{{seealso|<br/>
[[EiffelStudio: Using command line options|Using command line compiler options]] }}

72
documentation/trunk/eiffelstudio/eiffelstudio-reference/compiler/command-line/command-line-interactive-mode/class-menu.wiki Normal file
View File

@@ -0,0 +1,72 @@
[[Property:title|Class menu]]
[[Property:weight|2]]
[[Property:uuid|441d6cbb-2c48-5d44-8cb1-0884ade26b98]]
The Class command (c or C) in the main menu will only work if the system has been successfully compiled, and will give you information based on the result of the last successful compilation. It produces the following menu:
<code lang=text>
(A) Ancestors : show the ancestors of a class.
(B) Attributes : show the attributes of a class.
(C) Clients : show the clients of a class.
(E) Deferred : show the deferred features of a class.
(D) Descendants : show the descendants of a class.
(V) Edit : edit the text of a class.
(P) Exported : show the exported features of a class.
(X) Externals : show the external features of a class.
(F) Flat : show the flat form of a class.
(I) Flatshort : show the flat-short form of a class.
(O) Once : show the once & constant features of a class.
(R) Routines : show the routines of a class.
(S) Short : show the short form of a class.
(U) Suppliers : show the suppliers of a class.
(T) Text : show the text of a class.
(H) Help : show list of commands.
(M) Main : go back to main menu.
(Q) Quit : terminate session.
(Y) Yank : yank (save) output of last command to a file.
</code>
Each command will prompt you for the name of a class and a filter to use; you can also include the class name and the filter name after the command, separated by a space, as in:
<code>
Command => a linked_list ascii</code>
to obtain the ancestors of the <eiffel>LINKED_LIST</eiffel> class:
<code>
-- Automatic generation produced by ISE Eiffel --
LINKED_LIST [G]
DYNAMIC_LIST [G]
LIST [G]
CHAIN [G]
CURSOR_STRUCTURE [G]
ACTIVE [G]
BAG [G]
COLLECTION [G]
CONTAINER [G]
ANY
INDEXABLE [G, H -> INTEGER]
TABLE [G, H]
BAG [G]...
SEQUENCE [G]
ACTIVE [G]...
BILINEAR [G]
LINEAR [G]
TRAVERSABLE [G]
CONTAINER [G]...
LINEAR [G]...
FINITE [G]
BOX [G]
CONTAINER [G]...
SEQUENCE [G]...
DYNAMIC_CHAIN [G]
CHAIN [G]...
UNBOUNDED [G]
FINITE [G]...
DYNAMIC_CHAIN [G]...
-- Generated by ISE Eiffel --
-- For more details: http://www.eiffel.com --
Command =></code>

29
documentation/trunk/eiffelstudio/eiffelstudio-reference/compiler/command-line/command-line-interactive-mode/compile-and-run-menu.wiki Normal file
View File

@@ -0,0 +1,29 @@
[[Property:title|Compile (and run) menu]]
[[Property:weight|1]]
[[Property:uuid|58af783e-7fc4-9fa3-2374-4143204948bb]]
The Compile command (i or I) in the main menu yields the following item menu:
<code lang=text>
(A) Arguments : set the arguments.
(C) F-compile : (re)compile the C code generated by finalize.
(Z) Finalize : finalize the system (discard assertions by default).
(F) Freeze : freeze the system.
(L) Melt : melt the system.
(K) Quick melt : quick melt the system.
(R) Run : execute the system.
(W) W-compile : (re)compile the C code generated by freeze.
(H) Help : show list of commands.
(M) Main : go back to main menu.
(Q) Quit : terminate session.
(Y) Yank : yank (save) output of last command to a file.
</code>
The most common compiling option is L (Melt): recompile the system, melting recent changes. The other compilation possibilities are F (Freeze) and Z (Finalize). After a Freeze you will need to C-compile the result using the W (W-compile) command; similarly, you can C-compile the result of a Finalize using C (F-compile).
{{caution|You cannot select a different project from within ec loop; also, you cannot select a different configuration file from within the command, although you may of course change the contents of the configuration file (for example by using an editor in an other window). }}
The R option (Run) runs the application. You will be prompted for the arguments if the application needs any.

21
documentation/trunk/eiffelstudio/eiffelstudio-reference/compiler/command-line/command-line-interactive-mode/documentation-menu.wiki Normal file
View File

@@ -0,0 +1,21 @@
[[Property:title|Documentation menu]]
[[Property:weight|7]]
[[Property:uuid|4ed93bc4-07eb-57ed-b339-4890b5f58fcc]]
The Documentation Menu enables you to generate documentation about the classes of your system:
<code lang=text>
(I) Documentation (Flat/Short): Generate flat/short form of all classes in system.
(S) Documentation (Short): Generate short form of all classes in system.
(F) Documentation (Flat): Generate flat form of all classes in system.
(T) Documentation (Text): Generate text form of all classes in system.
(H) Help : show list of commands.
(M) Main : go back to main menu.
(Q) Quit : terminate session.
(Y) Yank : yank (save) output of last command to a file.
</code>
The four documentation commands will trigger the creation of documentation files corresponding to requested information using the specified filter. These files will then be located in the Documentation subdirectory of your project directory.

45
documentation/trunk/eiffelstudio/eiffelstudio-reference/compiler/command-line/command-line-interactive-mode/feature-menu.wiki Normal file
View File

@@ -0,0 +1,45 @@
[[Property:title|Feature menu]]
[[Property:weight|3]]
[[Property:uuid|a662251b-777d-5e28-0e52-ba4932195528]]
The Feature Menu enables you to find properties of a feature:
<code lang=text>
(A) Ancestors : show the ancestor versions of a feature.
(C) Callers : show the callers of a feature.
(D) Descendants : show the descendant versions of a feature.
(F) Flat : show the flat form of a feature.
(O) Homonyms : shown the homonyms of a feature.
(I) Implementers : show the classes implementing a feature.
(T) Text : show the text of a feature.
(H) Help : show list of commands.
(M) Main : go back to main menu.
(Q) Quit : terminate session.
(Y) Yank : yank (save) output of last command to a file.
</code>
Each command will prompt you for the name of a class, the name of a feature in that class and a filter name; you can specify these names (or just the class name) after the command.
{| border="1"
|-
| <center>'''Command'''</center>
| <center>'''Description'''</center>
|-
| <code>Ancestors</code>
| All the versions of a feature that appeared in ancestors.
|-
| <code>Callers</code>
| The list of classes which contains calls to the feature. Modifiers:
* <code>All senders</code> - include all callers rather than only those in the specified class
* <code>Only assigners</code> - restrict callers to those that use given feature only as a target of an assignment instruction
* <code>Only creators</code> - restrict callers to those that use given feature only as a target of a creation instruction
|-
| <code>Descendants</code>
| All the versions of a feature that appeared in descendants.
|-
| <code>Implementers</code>
| The list of classes where the feature is redeclared.
|}

25
documentation/trunk/eiffelstudio/eiffelstudio-reference/compiler/command-line/command-line-interactive-mode/index.wiki Normal file
View File

@@ -0,0 +1,25 @@
[[Property:title|Command line interactive mode]]
[[Property:weight|3]]
[[Property:uuid|3a0acea6-c6d1-c7b9-c2f9-88021cad26b6]]
If you need to use '''ec''' to execute a number of successive operations on a system, you do not need to restart the command each time; instead you may use the '''-loop''' option, which will interactively prompt you for successive operations.
If you launch '''ec''' with this option, you will get the interactive version's Main Menu:
<code lang=text>
==== ISE EiffelStudio - Interactive Batch Version (v5.5.0926 Enterprise Edition) ===
(C) Class : class formats and information.
(I) Compile : compile or run the system.
(F) Feature : feature formats and information.
(S) System : Config and cluster details.
(T) Testing : manage and run tests.
(P) Profile : information about a profiled run.
(D) Documentation: create documents from the system.
(H) Help : show list of commands.
(Q) Quit : terminate session.
(Y) Yank : yank (save) output of last command to a file.
Command =></code>
<br/>
The revision number in the first line may be different in your case to indicate that you have a more recent delivery. In this menu, and in all subsequent ones, the commands appear in two groups.
* commands in the first group are specific to each menu
* commands in the second group H (Help) to repeat the list of choices, Y (Yank) to save the output of the last command to a file that you will be prompted to name, and Q (Quit) to quit appear in all menus, and will be complemented in the Item Menus below by the M (Main) command which returns to the main menu.
By typing one of the letters shown in the Main Menu's first group, you can go to one of the Item Menus: [[Class menu|Class]], [[Compile (and run) menu|Compile]], [[Feature menu|Feature]], [[System menu|System]], [[Profile menu|Profile]], and [[Documentation menu|Documentation]]. [[Compile (and run) menu|Compile]] enables you to compile a system and execute the result; the next three enable you to obtain information about your project. [[Profile menu|Profile]] will enable you to exploit profiling information. Finally, [[Documentation menu|Documentation]] will enable you to generate HTML documentation about your project.

167
documentation/trunk/eiffelstudio/eiffelstudio-reference/compiler/command-line/command-line-interactive-mode/profile-menu.wiki Normal file
View File

@@ -0,0 +1,167 @@
[[Property:title|Profile menu]]
[[Property:weight|6]]
[[Property:uuid|09c424b0-8ba1-626c-0658-32e5d5e1f81b]]
An execution of an instrumented system will generate a file that contains profiling information. This file (named profinfo) is located in the same directory as your compiled system. You must process it through a profile converter to produce the Execution Profile.
The profile menu will enable you to produce the Execution profile and to extract information from it.
The menu (obtained by selecting (P) Profile in the main menu) looks like this:
<code lang=text>
(S) Switches : show the output switches
#Call-E Name-E Total-D
Self-D Desc-D %Time-D.
(U) Query : manipulate subqueries.
(I) Input : specify input file (filename or last_output)
[*.pfi].
(L) Language : specify language (eiffel, c, cycles)
[eiffel].
(R) Run : run the query.
(G) Generate : generate profile information for latest run.
(E) Defaults : reset all values to their defaults.
(H) Help : show list of commands.
(M) Main : go back to main menu.
(Q) Quit : terminate session.
(Y) Yank : yank (save) output of last command to a file.</code>
==Switches submenu==
The (S) Switches submenu enables you to set global options. It leads you to the following set of choices:
<code lang=text>
(N) Calls : disable output of number of calls to a feature [enabled].
(F) Feature name : disable output of feature names [enabled].
(T) Total : enable output of time spent in both the function and its descendants [disabled].
(S) Self : enable output of time spent in a function itself [disabled].
(D) Descendants : enable output of time spent in descendants of a function [disabled].
(P) Percentage : enable output of percentage of time spent in a feature [disabled].
(H) Help : show list of commands.
(M) Main : go back to main menu.
(U) Parent menu : go back to parent menu.
(Q) Quit : terminate session.
(Y) Yank : yank (save) output of last command to a file.</code>
Each one of these commands switches on or off the corresponding column output. The default is set on for the first two, off for the others. To enable or disable a column, type the name with a toggle effect.
==Query submenu==
The (U) Query submenu enables you to define a set of queries. The result will be a Total Query; by default it is the boolean and all the queries you have entered individually, but you may deactivate some of these and choose other boolean operators.
<code lang=text>
(A) Add : add a sub query.
(I) Inactivate : inactivate sub query.
(R) Reactivate : reactivate sub query.
(C) Operator : change the boolean operator.
(S) Show : show the list of queries.
(H) Help : show list of commands.
(M) Main : go back to main menu.
(U) Parent menu : go back to parent menu.
(Q) Quit : terminate session.
(Y) Yank : yank (save) output of last command to a file.</code>
To get useful information, you should add the appropriate queries through (A) Add. Each individual query has the following form: ''attribute operator value'', where ''attribute'' is one of:
* feature name
* calls
* total
* self
* descendants
* percentage
''operator'' is one of:
* <
* >
* <=
* >=
* =
* /=
* in <br/>
and ''value'' is one of:
* An integer (for calls)
* A string (for feature name). The string may contain wild card characters: ?, standing for arbitrary characters, and *,standing for arbitrary substrings.
* A real value (for other attributes)
* An interval, of the form a-b for two values a and b.
* max
* min
* avg
The (S) Show command will display the current queries, each with an associated number. The output includes the total query, explained next.
To inactivate a query, use (I) Inactivate. You will be prompted for a query index, which you may retrieve from (S) Show. This is useful if you make a change about a query, or want to set it aside for future use.
To reactivate a query, use (R) Reactivate. Again you will have to provide a query index.
The Total Query resulting from a succession of (A) Add commands, possibly with some (I) Inactivate and (R) Reactivate commands, is a boolean query resulting by default from adding all the currently active queries. For example after the following set of commands(note that commands output help lines, which have been skipped here):
<code lang=text>
Command => a
--> Subquery: featurename = put*
Command => a
--> Subquery: calls = 3
-- Here we change our mind and deactivate the second query
-- to replace it by calls = 3:
Command => s
[1] featurename = put* is active
[2] calls = 3 is active
The total active query:
featurename = put* and
calls >
Command => i
--> Subquery index: 2
Command =&gt; a
--> Subquery: calls > 5</code>
<br/>
The (S) Show command will show the following result:
<code lang=text>
Command => s
All subqueries:
[1] featurename = put* is active
[2] calls = 3 is inactive
[3] calls > 5 is active
The total active query:
featurename = put* and
calls > 5</code>
To change the boolean operator to 'or' rather than 'and', use the (C) Operator command. It will prompt you for the index of the operator and the new value:
<code lang=text>
Command => c
--> Operator index followed by operator ('and' or 'or'): 1 or
Command => s
All subqueries:
[1] featurename = put* is active
[2] calls = 3 is inactive
[3] calls > 5 is active
The total active query:
featurename = put* or
calls > 5</code>
==Input command==
The (I) Input command serves to load Execution Profiles. It is initially set to *.pfi meaning that it will load all files with extension pfi. By calling the command repeatedly with new arguments, you are able to load more Execution Profiles. If you use the command without any argument, and the set of input files contained just one file, then the queries will use the last generated output. This avoids explicitly loading a file.
==Language command==
The (L) Language command enables you to specify the languages to which profiling should be applied. You can specify Eiffel only, C only, or both. If you specify only one language, the query results will not contain any information about routines written in the other language.
The default is Eiffel only. To switch to both Eiffel and C, use
<code lang=text>
Command => L eiffel and c</code>
To return to just Eiffel, simply type <code>L</code> .
==Run Command==
To run the current total query, use (R) Run.
==Generate command==
To run the profile converter under the command-line interface, use the (G) Generate command. This will generate an Execution Profile, stored in a file with the extension .pfi.
When running the Generate command with no arguments, you will be prompted for the following information:
* Name of file to be converted (default: profinfo).
* Compilation mode: workbench or finalized (default: workbench).
* Name of profiler tool (default: eiffel).
You can also type in the arguments directly without waiting to be prompted, as in
<code lang=text>
Command => g profinfo finalize eiffel </code>
{{seealso|<br/>
[[Profiler Wizard|Profiler wizard]] }}

24
documentation/trunk/eiffelstudio/eiffelstudio-reference/compiler/command-line/command-line-interactive-mode/system-menu.wiki Normal file
View File

@@ -0,0 +1,24 @@
[[Property:title|System menu]]
[[Property:weight|4]]
[[Property:uuid|c1450c9b-a5d3-3709-1176-9c5c49def362]]
The System Menu gives general information about the system:
<code lang=text>
(A) Config : show the config file.
(L) Classes : show the classes in alphabetic order.
(S) Cluster hierarchy: display the cluster hierarchy of the system.
(C) Clusters : show the system's classes, cluster by cluster.
(V) Edit : edit the config file.
(I) Indexing : show indexing clauses of classes.
(O) Modifications: show classes modified since last compilation.
(T) Statistics : show system statistics.
(H) Help : show list of commands.
(M) Main : go back to main menu.
(Q) Quit : terminate session.
(Y) Yank : yank (save) output of last command to a file.</code>
The A (Config) command shows the configuration file; the E (Edit) command enables you to edit the configuration file; the C (Clusters) command is useful to display the entire list of classes, cluster by cluster.

21
documentation/trunk/eiffelstudio/eiffelstudio-reference/compiler/command-line/command-line-interactive-mode/testing-menu.wiki Normal file
View File

@@ -0,0 +1,21 @@
[[Property:title|Testing menu]]
[[Property:weight|5]]
[[Property:uuid|a6a0cf9d-ac10-4473-80e1-470acd461610]]
The AutoTest Menu gives information about the autotest entries:
<code lang=text>
(L) List view : Display tests in a list.
(T) Tree view : Display tests in a tree structure.
(E) Execute : run tests.
(A) AutoTest : AutoTest.
(H) Help : show list of commands.
(M) Main : go back to main menu.
(Q) Quit : terminate session.
(Y) Yank : yank (save) output of last command to a file.
</code>
The L and T displays the test cases in list or tree.
The E execute the existing test cases.

402
documentation/trunk/eiffelstudio/eiffelstudio-reference/compiler/command-line/eiffelstudio-using-command-line-options.wiki Normal file
View File

@@ -0,0 +1,402 @@
[[Property:title|EiffelStudio: Using command line options]]
[[Property:link_title|Using command line options]]
[[Property:weight|1]]
[[Property:uuid|a6b6a676-8660-ce2d-6f37-03de7f23a78e]]
==Compiling and viewing==
The Eiffel Compiler line mode command '''ec''' has many options, as you can see from the tables below. It may be helpful to think of any one '''ec''' command as either a command to compile or a command to view software text.
==Getting help==
You can get details of the usage and options of the '''ec''' command by executing the command with the '''-help''' option.
<code lang="text">
ec -help
</code>
The usage and options display gives you information about which options are valid in a particular command context. Use this display along with the table below to choose the options that meet your needs.
Usage and options of the command line compiler vary from version to version in order to accommodate new and changed features. Here is an example of the command line help from the latest version of EiffelStudio:
<code lang="text">
ISE EiffelStudio version 14.05.9.5158 GPL Edition - win64
Usage:
ec [-help | [-compat | -experiment] | -version | -full
-batch | -clean | -verbose | -use_settings |
-freeze | -finalize [-keep] | -precompile [-finalize [-keep]] | -c_compile |
-loop | -debug | -quick_melt | -melt | -clients [-filter filtername] class |
-suppliers [-filter filtername] class |
-flatshort [-filter filtername] [-all | -all_and_parents | class] |
-flat [-filter filtername] [-all | -all_and_parents | class] |
-short [-filter filtername] [-all | -all_and_parents | class] |
-pretty input_filename [output_filename] |
-filter filtername [-all | class] |
-descendants [-filter filtername] class |
-ancestors [-filter filtername] class |
-aversions [-filter filtername] class feature |
-dversions [-filter filtername] class feature |
-implementers [-filter filtername] class feature |
-callers [-filter filtername] [-show_all] [-assigners | -creators] class feature |
-callees [-filter filtername] [-show_all] [-assignees | -creators] class feature |
[[-config config.ecf] [-target target] |
-ace Ace (obsolete) | -project Project_file_name (obsolete)] |
[class_file.e [-library library_name]] |
-stop | -no_library |
-project_path Project_directory_path | -file File |
-code-analysis [-cadefaults | -caloadprefs pref_file | -caclasses class ...] |
-gc_stats]
Options:
default (no option): quick melt the system.
-ace: specify the Ace file (obsolete).
-ancestors: show the ancestors of a class.
-aversions: show the ancestor versions of a feature.
-batch: launch the compilation without user request.
-c_compile: launch C compilation if needed.
-callees: show the callees of a feature.
-callers: show the callers of a feature.
-class_file.e: specify a class file for single file compilation.
-clean: delete existing project if any and perform a fresh compilation.
-clients: show the clients of a class.
-compat: enable pre-attached type compatibility.
-config: specify the configuration (ECF) file.
-debug: debug the system as a command loop.
-descendants: show the descendants of a class.
-dversions: show the descendant versions of a feature.
-experiment: enable experimental functionalities.
-file: save the output to a file.
-filter: show a filtered form (troff, ...) of the class text.
-finalize: finalize the system (discard assertions by default).
-flat: show the flat form of a class.
-flatshort: show the flat-short form of a class.
-freeze: freeze the system.
-full: with full class checking regardless of ECF settings.
-gc_stats: Show GC statistics.
-gui: start the graphical environment.
-help: show this help message.
-implementers: show the classes implementing a feature.
-library: specify a library for single file compilation.
-loop: run ec as a command loop.
-melt: melt the system.
-no_library: do not convert clusters into libraries.
-overwrite_old_project: overwrite any existing old project.
-precompile: precompile the system.
-pretty: show the pretty form of a class.
-project: specify the project file to load (obsolete).
-project_path: specify the compilation directory.
-quick_melt: quick melt the system.
-short: show the short form of a class.
-stop: stop on error.
-suppliers: show the suppliers of a class.
-target: specify the target.
-use_settings: use settings for project location.
-version: show compiler version number.
</code>
==Commands for compiling==
The simplest compiling command you can enter is:
<code lang="text">
ec
</code>
The command does not include any of the ''Compiling options'' shown below, so the default option "-melt" is used. The "-config" is omitted, so '''ec''' will try to find a configuration file named <code lang="text">Ace.ecf</code> in the current directory.
The command:
<code lang="text">
ec -config my_config_file.ecf
</code>
melts the system having the configuration file in the current directory <code lang="text">my_config_file.ecf</code> .
To freeze or finalize that system, you would just include the appropriate ''Compiling option'':
<code lang="text">
ec -freeze -config my_config_file.ecf
</code>
You can specify the name of a file which contains the root class of a system in the current directory:
<code lang="text">
ec application.e
</code>
This command will compile a system with the class in <code>application.e</code> as its root. If there is no configuration file named <code>application.ecf</code> in the current directory, then '''ec''' will create one. It will also use any classes in the current working directory and by default the library EiffelBase.
{{tip|This "configuration-less" form of compilation is convenient to use for a quick compile. But you should understand that because it does create a configuration file with default names for the configuration file itself, the project, and the root cluster, using it against a root class file in a folder in which a configuration file with another name already exists could lead to confusion. }}
You can add additional libraries to the configuration by using the "-library" option and specifying either the short name of one of the EiffelStudio libraries or a path to a library configuration file. To include EiffelTime in the compilation of <code>application.e</code>, you could use this command:
<code lang="text">
ec application.e -library time
</code>
This immediately adds the EiffelTime library to the configuration file <code>application.ecf</code>, so if you compile again, it is not necessary to respecify the library.
==Commands for viewing==
By selecting certain options on the '''ec''' command, you can generate advanced views of your software much like those provided by EiffelStudio. In the table below you will see the set of ''Viewing options''. These options take arguments that are either a class name or a class name and feature name. The following examples will give you an idea of how to use the ''Viewing options''.
To see the "flat" form of class <code>APPLICATION</code> in the example used above:
<code lang="text">
ec -flat application -config application.ecf
</code>
To save the output, add the "-file" option with a file name:
<code lang="text">
ec -flat application -config application.ecf -file application_flat_form.txt
</code>
Feature-oriented options, like "-implementers", take a class name and feature name:
<code lang="text">
ec -implementers application some_feature -config application.ecf
</code>
===Commands for generating documentation===
You can use variations of the viewing commands to generate documentation for your Eiffel system much like [[Producing and Exporting Documentation|you can from EiffelStudio]].
The following command will produce the ''Chart'', ''Relations'', and ''Text'' documentation for the "application" system in html-stylesheet format in the "Documentation" subfolder of the project folder.
<code lang="text">
ec -filter html-stylesheet -all -config application.ecf
</code>
To produce documentation for a view other than ''Text'', use its option in the command. The following generates ''Chart'', ''Relations'', and ''Flat Short'' documentation:
<code lang="text">
ec -flatshort -filter html-stylesheet -all -config application.ecf
</code>
==Commands for Eiffel Inspector==
To start the Eiffel Inspector you need to pass the '''-code-analysis''' command line options. If no other options are given, it will analyze the whole system. To specify some preferences, enable specific rules or analyze part of a system, you will need to provide some more options described below:
<code lang="text">
ec -config project.ecf -code-analysis [-cadefaults | -caloadprefs pref_file | -caclasses "CLASS1 CLASS2" |
-caforcerules "RULE1 (First preference=1, Second preference=2) RULE2"]
</code>
; -cadefaults : If provided, all preferences regarding the analysis will be reset to their default values (before the analysis is run). For example this leads to enabling all rules that are enabled by default, no matter whether they have been disabled before.
; -caloadprefs : Use preferences from ''pref_file'', an XML file containing the code analysis preferences. ''pref_file'' can be generated by exporting the current preferences in the GUI.
; -caclass : Followed by a list of class names (without file extension ''.e'') of the classes that shall be analyzed. If omitted then the whole system will be analyzed. If more than one class is to be specified, the list must be wrapped in double quotes. The class names can optionally be separated by semicolons ("CLASS1; CLASS2").
; -caforcerules: Followed by a list of rules, enables those rules for the analysis and disables all the others, overriding the current preferences. Specific rule preferences can also be provided in parentheses. Preferences must be separated by commas. The class names can optionally be separated by semicolons. The following example summarizes the syntax of this option:
<code lang="text">
-caforcerules "RULE1; RULE2 (Maximum length threshold=20, Enable something=False); RULE3"
</code>
==Command options==
The table below lists the available ''options'', the arguments they require, and their effect:
{| border="1"
|-
| width="175pt" | '''OPTION'''
| '''ARGUMENTS'''
| '''EFFECT'''
|-
| ''Compiling options''
|-
| -melt
|
| [[Melting Ice Technology#Melting|Melt]] compilation. This is the default option, if no other compiling or viewing option is specified.
|-
| -freeze
|
| [[Melting Ice Technology#Freezing|Freeze]] system.
|-
| -finalize
|
| [[Melting Ice Technology#Finalizing|Finalize]] system. See note below.
|-
| -precompile
|
| [[Melting Ice Technology#Precompiling|Precompile]] system, treating it as a library.
|-
| -full
|
| Full class checking. Rechecks features of the parent classes for validity in heirs. See example in [[Converting existing software to void-safety#Enable full class checking|Converting existing software to void-safety]]. NOTE: Full class checking increases compile times, which may be noticeable in large systems.
|-
| -compat
|
| Compile using facilities that are [[Eiffel compatibility options#EiffelStudio and Eiffel compiler options|compatible with older versions]] of Eiffel.
|-
| -experiment
|
| Compile using facilities that are [[Eiffel compatibility options#EiffelStudio and Eiffel compiler options|compatible with an upcoming version]] of Eiffel.
|-
| ''Viewing options''
|-
| -ancestors
| class_name
| Print the ancestors of the class.
|-
| -aversions
| class_name, feature_name
| Print the ancestor versions of the feature.
|-
| -callers
| class_name, feature_name
| Print all the routines that call the feature.
|-
| -clients
| class_name
| Print the clients of the class
|-
| -descendants
| class_name
| Print the descendants of the class.
|-
| -dversions
| class_name, feature_name
| Print all the versions of the feature in the descendant versions of the class.
|-
| -flat
| class_name
| Print the flat view of the class.
|-
| -flatshort
| class_name
| Print the Flat Contract view (previously called flat-short form) of the class.
|-
| -implementers
| class_name, feature_name
| Print all the classes that declare or redeclare the feature.
|-
| -short
| class_name
| Print the Contract view (previously called short form) of the class.
|-
| -suppliers
| class_name
| Print all the suppliers of the class.
|-
| ''Other options''
|-
| -batch
|
| Launch the compilation without user request.
|-
| -clean
|
| Delete project if already compiled and compile project as if it was the first time.
|-
| -config
| file_name
| Use the file as configuration.
|-
| -c_compile
|
| Launch C compilation, if needed, after Eiffel compilation.
|-
| -file
| file_name
| Save the output to the file.
|-
| -filter
| filter_file_name
| Print text as processed by the [[Appendix: Writing Documentation Filters with EFF, the Eiffel Filter Format|filter]] defined in the file named "''filter_file_name''.fil"
|-
| -help
|
| Print the help.
|-
| -keep
|
| Keep assertions in final mode. Useful with -finalize only.
|-
| -library
| library_name
| Library is included in the configuration when a file name for the root class is given.
|-
| -loop
|
| Enter interactive mode. See: [[Command line interactive mode]].
|-
| -metadata_cache_path
| directory_name
| Specify location of Metadata Cache used for .NET compilation. This overrides any settings from your configuration file.
|-
| -no_library
|
| When converting an old configuration file format, do not convert clusters into libraries.
|-
| -project_path
| directory_name
| Use this directory as compilation directory. (Default: current directory.)
|-
| -stop
|
| Stop on errors. (Default: no.)
|-
| -target
| target_name
| Act on the system target named ''target_name''.
|-
| -use_settings
|
| Use the project global settings to retrieve the project location for the last compilation of this project.
|-
| -verbose
|
| Display detail progress report during compile.
|-
| -version
|
| Print compiler version number.
|}
{{note|In the third column, to '''print''' means to produce the requested information on the default output of the '''ec''' command.}}
{{note|When using '''-finalize''', assertions will be discarded (unlike in EiffelStudio which asks first). The assertion disposition specified in the project configuration file can be retained in finalization by combining the '''-keep''' option with '''-finalize'''.}}
Some options can have modifiers that can affect their results. The modifiers are listed in the table below:
{| border="1"
|-
| <center>'''Option'''</center>
| <center>'''Modifier'''</center>
| <center>'''Effect'''</center>
|-
| -callers
! colspan="2" |
|-
|
| -show_all
| Include all callers rather than only those in the specified class.
|-
|
| -assigners
| Restrict callers to those that use given feature only as a target of an assignment instruction.
|-
|
| -creators
| Restrict callers to those that use given feature only as a target of a creation instruction.
|}
{{seealso|<br/>
[[Batch compilation|Batch compilation]] }}

64
documentation/trunk/eiffelstudio/eiffelstudio-reference/compiler/command-line/finish-freezing-utility.wiki Normal file
View File

@@ -0,0 +1,64 @@
[[Property:title|finish_freezing utility]]
[[Property:weight|4]]
[[Property:uuid|bfc362f4-9187-ea47-baf6-46880ed43fdd]]
=Introduction=
The command line utility finish_freezing is used to compile external code generated by the Eiffel compiler. Most of the time finish_freezing gets executed behind the scenes as you freeze and finalize Eiffel systems, so you don't really need to be aware of it. However, finish_freezing can be run standalone, and is useful, for example, when [[Porting an Eiffel application from UNIX to Windows or vice-versa|porting systems to other platforms]].
=Usage of finish_freezing=
<code lang="text">
finish_freezing [-location <directory>] [-generate_only] [-nproc <n>] [-low]
[-x86] [-library] [-version] [-nologo]
</code>
Options:
:Options should be prefixed with: '-' or '/'
{| border="1"
|-
! style="text-align: center" | Option
! style="text-align: center" | Arguments
! style="text-align: center" | Effect
|-
|-
| -location
| ''directory''
| Alternative location to compile C code in.
|-
| -generate_only
|
| Informs tool to generate only a Makefile.
|-
| -nproc
| ''n''
| Maximum number of processors to use.
|-
| -low
|
| Executes finish freezing in low-execution priority mode.
|-
| -x86
|
| Generate 32bit lib DLLs for .NET projects.
|-
| -library
|
| Compiles the C code of an Eiffel library.
|-
| -?
|
| Display usage information.
|-
| -version
|
| Displays version information.
|-
| -nologo
|
| Supresses copyright information.
|}

11
documentation/trunk/eiffelstudio/eiffelstudio-reference/compiler/command-line/index.wiki Normal file
View File

@@ -0,0 +1,11 @@
[[Property:title|Command line]]
[[Property:weight|-13]]
[[Property:uuid|e1a93995-38bf-14fa-421e-e6fe1f07b9f6]]
==Using the command line compiler==
It is possible to compile from outside of the graphical environment, by using the command '''ec'''. The form of compilation's results are the same in both cases. You may therefore alternate between the two techniques. '''ec''' will enable you to [[EiffelStudio: Using command line options|melt or freeze]] a project and therefore to use [[Batch compilation|batch compilation]] . It will also enable you to produce [[EiffelStudio: Using command line options|information about a class]] such as its Flat and Flat Contract views.
The [[EiffelStudio: Using command line options|-loop option]] makes it possible to start '''ec''' just once and then repeatedly request any of the available operations.