Lugaru's Epsilon
Programmer's
Editor

Context:
Epsilon User's Manual and Reference
   . . .
   Introduction to EEL
      Epsilon Extension Language Features
      EEL Tutorial
   Epsilon Extension Language
      EEL Command Line Flags
      The EEL Preprocessor
      Lexical Rules
      . . .
   Primitives and EEL Subroutines
      Buffer Primitives
      Display Primitives
      File Primitives
      . . .
      Defining Language Modes
   . . .

Previous   Up    Next
Epsilon Extension Language  Epsilon Extension Language   The EEL Preprocessor


Epsilon User's Manual and Reference > Epsilon Extension Language >

EEL Command Line Flags

To invoke the EEL compiler, type eel filename. If you omit the file name, the compiler will display a message showing its command line options.

Before the filename, you can optionally specify one or more command line switches. The EEL compiler looks for an environment variable named EEL before examining its command line, then "types in" the contents of that variable before the compiler's real command line. Under Windows, the EEL compiler uses a registry entry named EEL (a "configuration variable", as described in Configuration Variables), not an environment variable.

The EEL compiler has the following flags:

-b
By default, in each file it compiles, the EEL compiler includes a variable definition that provides the full path to the original source file. It has a name such as _loaded_eel_file_xyz for a file xyz.e. This flag omits that variable; it's used for compiling all EEL files that are part of Epsilon's standard distribution. Epsilon's list-customizations command uses the information provided by such variables.

-dmac!def
This flag defines the textual macro mac, giving it the definition def, as if you had defined it using the #define command. The syntax -dmac defines the macro mac, giving it the definition (1). You can also use the syntax -dmac=def, but beware: if you run EEL via a .BAT or .CMD file, the system will replace any ='s with spaces, and EEL will not correctly interpret the flag.

-e
This flag tells the compiler to exclude definitions from #included files when it writes the bytecode file. This results in smaller bytecode files. You can safely use this flag when compiling EEL files other than epsilon.e that only include the file eel.h, but it's most useful with autoloaded files. Epsilon will signal an error if you call a function using a variable whose definition has been omitted by -e in all loaded bytecode files.

-f
This flag makes the compiler act as a filter, reading EEL code from stdin instead of a file, and writing its binary output to stdout. A file name on the command line is still required, but it is used only for error messages and debugging information.

-F
This flag makes the compiler write its binary output to stdout instead of a bytecode file.

-idirectory
This flag sets the directories to search for files included with the preprocessor #include command. Precede each search directory with -i. If you use several -i flags on the command line, the compiler will search the directories in the order they appear.

The compiler searches for included files using the following rules. First, if you use the syntax #include "file.h", not #include <file.h>, EEL searches in the directory containing the current source file. The -w1 flag makes it skip this step.

Next, EEL searches in each directory specified by -i.

If EEL still hasn't found the include file, the -w2 flag makes EEL give up at this point. Otherwise, EEL searches the EPSPATH configuration variable, looking for an include subdirectory of each directory. If there is no EPSPATH configuration variable, EEL searches a default EPSPATH (see How Epsilon Finds its Files). When constructing this default EPSPATH, the -w8 flag makes EEL omit any directory chosen based on the EEL compiler's location.

-i-
Makes the EEL compiler ignore all prior -i flags. This is useful if you use a configuration variable to always provide certain -i flags.

-n
Makes the EEL compiler skip displaying its copyright message.

-ofile
Sets the output file. Normally EEL constructs the file name for the bytecode file based on the input file, with the .e extension replaced by ".b", and puts the bytecode file in the current directory.

-p
Makes the compiler display a preprocessed version of the file.

-q
Suppress warning messages about unused local variables and function parameters.

-s
Leave out debugging information from the bytecode file. Such a file takes up less space, and runs a bit faster. If you use this switch, though, you cannot use the debugger on this file, and the debug key Ctrl-<Scroll Lock> (except under Windows and Unix) will not work while such a function executes. We compiled the standard system with the -s flag. You may wish to recompile some files without this flag so you can trace through functions and see how they work.

-v
Prints a hash mark each time the compiler encounters a function or global variable definition. Use it to follow the progress of the compiler.

-wNUM
Bits in NUM control how EEL searches for include files. The 1 bit tells EEL to treat #include "file.h" the same as #include <file.h> and skip looking in the current source file's directory. The 2 bit tells EEL not to search for included files based on the EPSPATH. The 8 bit tells EEL that when constructing a default EPSPATH, it shouldn't consider the location of the EEL executable. See the description of the -i flag above. Values in the -w flag are cumulative, so -w1 -w2 is the same as -w3. Omit the number (use -w) to clear all bits.

An example using these switches is:

eel -s -p -v -dCODE=3 -oout -i/headers source >preproc



Previous   Up    Next
Epsilon Extension Language  Epsilon Extension Language   The EEL Preprocessor


Lugaru Copyright (C) 1984, 2012 Lugaru Software Ltd. All Rights Reserved.