File: compile_to_jvm.txt

package info (click to toggle)
smarteiffel 1.1-11
  • links: PTS
  • area: main
  • in suites: etch, etch-m68k
  • size: 12,288 kB
  • ctags: 40,785
  • sloc: ansic: 35,791; lisp: 4,036; sh: 1,783; java: 895; ruby: 613; python: 209; makefile: 115; csh: 78; cpp: 50
file content (129 lines) | stat: -rw-r--r-- 5,079 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
   The compile_to_jvm Command

   The compile_to_jvm command is the SmartEiffel Java byte code generator
   for  the  Java  Virtual  Machine.  There  are  two  invocation  modes:
   traditional  and  ACE.  In  traditional  mode,  a  variety of compiler
   options  can  be  specified  on  the  command line. In ACE mode, these
   options  are  not permitted; it is presumed that the required compiler
   options are listed in the ACE file.

   Usage

   Traditional mode
   compile_to_jvm [options] <RootClass> [<RootProcedure>]

   ACE mode
   compile_to_jvm [general_options] <ACEfile.ace>

   In traditional mode, the compile_to_jvm command must be given at least
   one  argument  to indicate the starting execution point of the system.
   Thus  your  program  will start in <RootProcedure> of <RootClass>. The
   default <RootProcedure> is make.

   In  ACE  mode, the name of the ACE file must end with the .ace suffix.
   For   examples   of  how  to  use  ACE  files,  have  a  look  in  the
   SmartEiffel/tutorial/ace directory.

   Load Path for Eiffel Source Files

   compile_to_jvm  uses  the technique described in the documentation for
   the  [1]finder  command  to locate the Eiffel source files it tries to
   compile.  Note  that  what  actually happens depends on the invocation
   mode (traditional or ACE).

   General Options

   -help:
          Display  a  brief  summary  of  the  command-line  syntax and a
          complete list of compiler options.
   -verbose:
          Print  system  information during the compilation (full path of
          files loaded, type inference score, removed files, etc.).
   -version:
          Display  the  version  number of the SmartEiffel release you're
          using.

   -loadpath <loadpath_file>:
   Adds  a  loadpath  file for class lookup. See details in the [2]finder
   man page.

   Options to Select Eiffel Compilation Modes (traditional mode only)

   As  with  the  compile_to_c command, there are 8 different compilation
   modes:     -boost,     -no_check,    -require_check,    -ensure_check,
   -invariant_check, -loop_check, -all_check and -debug_check.
   These  options  have  the  same  meaning as with compile_to_c. See the
   [3]compile_to_c documentation for details.

   Other Options (traditional mode only)

   -o <output_name>:
          Place  the  main  output in <output_name>.class and other class
          files  in  the  directory  <output_name>.  When  this option is
          absent, the default is <Root-Class>.
   -no_style_warning:
          Suppress   output   for   warning   messages   related  to  the
          non-respecting   of   standard  Eiffel  style  guidelines  (for
          example, ItEm will not trigger a warning).
   -case_insensitive:
          Switch case-insensitive mode on.
          For  example,  when  this  mode  is selected, the Eiffel parser
          considers  that  the  following  identifiers  refer to the same
          feature: item, ITEM, ItEm, ...
   -no_warning:
          Suppress  output  for all warning messages. (Error messages are
          still printed.)

   The SmartEiffelRuntime.java class

   The  SmartEiffelRuntime.java  class implements some low-level external
   features.  This  file is in the directory SmartEiffel/sys/runtime. The
   file  SmartEiffelRuntime.class  must  be  present  to execute the Java
   byte-code generated by the compile_to_jvm command. Don't forget to add
   this class to your Java CLASSPATH system environment variable. You can
   also  copy  the  file  SmartEiffelRuntime.class  to  some  appropriate
   directory.

   Examples

   Example 1
   When  SmartEiffel  is  correctly installed, you can type the following
   command to test the hello world program :
          compile_to_jvm hello_world

   Then, in order to execute the Java byte code produced, you can use the
   command:
          java hello_world

   Example 2
   As  for the compile_to_c command you can add the option -boost to omit
   all assertion checking:
          compile_to_jvm -boost hello_world

   Example 3
   To change the name of the generated main class, you have to add the -o
   option:
          compile_to_jvm -boost -o out hello_world

   Then, you can run the Java byte code with:
          java out

   Note  that the name used for the class files directory is also changed
   (this directory is also named out).

   Example 4
   Finally,  the  -verbose  option may be useful to check which files are
   loaded, which files are created, or to fix some installation problem:
          compile_to_jvm -verbose hello_world

                                   [Line]
             Copyright  Dominique COLNET and Suzanne COLLIN -
                         [4]<SmartEiffel@loria.fr>
                Last modified: Tue Feb 11 12:14:05 CET 2003

References

   1. file://localhost/users/miro/colnet/SmartEiffel/man/finder.html
   2. file://localhost/users/miro/colnet/SmartEiffel/man/finder.html
   3. file://localhost/users/miro/colnet/SmartEiffel/man/compile_to_c.html
   4. mailto:SmartEiffel@loria.fr