Estelle Compiler
The Estelle Compiler translates an Estelle specification
into C language source code. The compiler consist of the following two
tools:
-
a translator (Estelle Translator) which given an Estelle
specification returns the specification representation in so called Intermediate
Form (IF) augmented with information resulting from a complete analysis
(lexical, syntactical and semantical) of the specification. The translator
was designed using the automatic tool SYNTAX developed in INRIA.
-
a C code generator (Estelle Generator) which given the Intermediate
Form representation of an Estelle specification returns C-code for the
specification.
The two parts of the compiler may be used separately or chained
one after another to produce C-code directly from source Estelle text.
The term "compiler" refers to the chained usage.
A special library giving a procedural interface to the
Intermediate Form (IF) is available enabling the users to design their
own tools (e.g., a C++ code generator).
The output of the Estelle Compiler mainly contains a portable,
operating system independent, C representation of the components of source
Estelle specification.
This generated code may be executed under the control
of either the simulator/debugger or an implementation motor, which serves
as the interface to a given operating system.
The implementation motor is a set of precompiled, specification
independent, run-time support routines to be linked to the generated code
to produce an executable program. The implementation motor for the UNIX
operating system was developed by MARBEN. MSDOS and OS/2 versions of the
implementation motor also exist.
The Estelle-to-C compiler (Ec) was developed by BULL S.A.
based on the functional specification carried out within the European Esprit
SEDOS (No.410) project. Some extensions of Ec have been developed by INT.
Estelle Simulator/Debugger (Edb)
The Estelle simulator/debugger (Edb) is an interactive symbolic
simulator/debugger. The input of Edb is the Estelle specification source,
the associated intermediate form and the result of the compilation of the
generated C code. Edb simulates the execution of an Estelle specification
in accordance with the Semantic Model defined in the ISO 9074 standard.
The purpose of Edb is to help the user in discovering
and correcting errors that occur during the execution of an Estelle specification.
The user may control, observe and trace the execution of the specification
by means of the simulation commands.
In accordance with the "transition atomicity" principle
of the Estelle Semantic Model, the unit of execution in Edb is a simple
transition. All sorts of nondeterminism inherent to an Estelle description
are resolved during the simulation by a random selection if treated without
any user intervention. Special commands are offered by the simulator/debugger
to control some of these nondeterministic choices in an interactive manner.
Edb offers powerful means (macro-commands, observers)
to describe a simulation scenario (including the specification of anomalies
to be detected), and it does not require the user to have any particular
knowledge of how the simulation is implemented. The user can concentrate
fully on the properties he wants to verify or detect.
There are three major and interrelated fields of application
of the Estelle simulator/debugger:
(1) The analysis and validation of "global" properties
of the simulated specification by means of its execution in a simulated
environment. According to the Estelle semantic model, the unit of execution
is a transition. This means that the user may observe the overall effects
of executing transitions with respect to communication between the system
components (module instances). In that sense the simulation concentrates
on "global" system behaviour, and it provides means to detect and eliminate
"logical" design errors (e.g., deadlocks, undesired sequences of transitions,
etc.).
(2) The indication of run-time errors and warning situations
while executing a transition or evaluating a transition's enabling condition
(the errors or warning situations are caused, for instance, by an uninitialized
variable, division by zero, lost output, etc.). This classical debugging
facility complements that of (1) in that it detects "local" (with respect
to a transition) errors that can influence global behaviour.
(3) The simulation and debugging, in the sense of (1)
and (2), of Estelle specifications extended with "time constraints" defined
by the user, i.e., with the average speed of a module instance or a subsystem
explicitly specified (e.g., average execution time of transitions). These
time constraints may reflect known execution speeds of components of a
real computer architecture in which a specification is to be implemented.
In this way implementation dependent problems related to performance may
be studied in a simulated environment.
By default there are no time-constraints in Estelle (i.e.,
the execution time of each transition is assumed "infinitely small" or,
as it is usual to say, zero). Thus, no execution speed is taken into account
and all potential time relationships are represented. In this default case
only relative values of "time-outs" (delays specified in transitions) are
considered. This agrees with Estelle semantics, which treats time relationships
as implementation dependent.
MSC trace generator
During the edb simulation session the user may request
to generate multiple on-line Message Sequence Chart (MSC) views, individually
parametrised.
A tree module/body structure is displayed in a window
with some complementary objects namely, interaction points (external, internal)
and associated output interactions. The user may select the tree type (static,
dynamic). The static structure (by default) corresponds to the generic
(textual) module/body structure and a dynamic structure corresponds to
the current module instance structure.
The tree may be displayed also in a compact way (the space
reserved to modules is no more disjoint) and all identifiers may be compressed.
The user may also select spacing between displayed objects (horizontal,
vertical) . By default the displayed tree is static, not compact and the
identifiers are not compressed.
By default all interactions will be displayed in MSC views
(all are selected). To filter some of them the user has to click on an
object. If it is an interaction, then only this interaction will be filtered.
If it is another object, then all descendent objects (and associated interactions)
are filtered.
The filtering may be done on static or dynamic tree in
any moment of the simulation (provided a new MSC view has been requested
at this moment). Filtering an object on static structure leads to filter
such objects in all module instances.
Edb was developed by BULL S.A. based on the functional
specification carried out within the Esprit SEDOS (No.410) project. Many
extensions of Edb have been developed by INT, in particular the MSC trace
generator and performance studies (partially supported by CNET).
Universal Generator (Ug)
The Universal Generator is a tool which permits the user
to:
generate from a given Estelle specification a modified one
in which some selected module bodies are replaced by so-called universal
bodies (Universal test drivers generator - Utdg)
generate from (split) an Estelle specification containing
'n' subsystems i.e., modules attributed 'systemprocess' or 'systemactivity'
(Distributed Specification Generator - splitter)
into:
-
n Estelle specifications each containing one of the
subsystems and a special interface (called also "switch board") to the
external word,
-
a supervisor C program
generate from an intermediate form the corresponding Estelle
specification (decompiler)
Each particular function of the Universal Generator may be
viewed as a separate tool (Test Drivers Generator,
Distributed Specification Generator (splitter), Decompiler).
The decompilation function do not need any further remarks.
The splitter function has been aided as a part of a procedure to generate
distributed implementations.
The Universal Test Generator allows automatic generation
of interactive test drivers for any "open" Estelle specification.
A system specified in Estelle is frequently "open" in
that it can cooperate with some systems (an environment) not defined within
the same specification. For example, a protocol entity of the i-th layer
specified in Estelle cooperates with the (i-1)-th and (i+1)-th layers'
entities, which are not specified within the same specification.
To validate (to test) an open system, its specification
has to be completed with modules of the environment (test drivers), capable
of sending sequences of interactions to the system to test its reactions
and/or to respond to its requests. In this case a testing module is associated
with every interaction point of the open system under test.
The task of specifying the environment (test driver modules)
is usually time consuming. Also, to enlarge or to restrict a set of test
sequences that a module may produce can be laborious. In addition, in many
situations, one would like to start executing (testing) a system while
it is still being designed, even before it is completely specified. The
UTDG (Universal Test Drivers Generator) tool helps the user in all such
situations by automatically completing a specification in a desired way
and enabling its interactive prototype execution.
The completion is done by requesting the tool to generate
"universal" bodies for those module-headers of the specification that are
indicated by the user. The term "universal" means that the generated module
body is capable of accepting and sending any interaction that is defined,
by appropriate channels, for the module interaction points (it also offers
the possibility of assigning a value to each of the exported variables
of the module if it has any of them defined in its header definition).
The "universal" bodies for the testing modules might have
been automatically created by UTDG replacing existing (possibly "empty")
bodies, i.e., in Estelle terms, inserting the <body_definition> part
of the scheme:
body <body_name>
for <module_header_name>
<body_definition>
end;
The execution of a specification with some inserted "universal"
module bodies is interactive, in that the user, when he gets control, may
choose (for any of these modules):
-
an interaction point through which he wants to send an interaction,
-
a name of the interaction to be sent and the values of its
parameters,
-
the values of exported variables, if such variables have
been declared within the module header.
It has to be stressed that a "universal" body description
may replace ANY module body definition within a given Estelle specification;
hence the use of UTDG can be much larger than that suggested above. Testing
seems to be the most obivious and important use of the tool. For example,
one may put a "universal" module in place of an internal module of a specification,
which may be, in general, very useful for an interactive design of the
module's final behaviour.
The development of UTDG was partially supported by ESPRIT
Project N0 5341 -- OSI 95.
State/Event Tables Generator
The tool permits creation of the state/event tables corresponding
to a user-specified body within a specification (generated from the information
given in the intermediate form file generated from a specification by Estelle
Translator. A state/event table represents a behaviour of a body whose
absolute name is given on the top of the table.
Each column corresponds to a from-state, a stateset or
state_list. Each line correspods to an event which is a transition firing
condition. In each cell a transition name, to-state(s) and outputs are
displayed.
If the names of objects are to long to fit in a column
they abreviations are shown (first and last letters separeted by points.
The width of columns can be modified. The name of objects adapts automatically
tothe new column width.
The user can zoom to display all the information
of the transitions for each cell of the displayed table.
The results can be output either on the screen or on a
printer (selective printing and global printing modes). The development
of this version was partially supported by CNET-France Telecom.
Browser
The Estelle Browser is an interactive tool, which enable
the user to generate a so-called high-level-design (hld) views of the specification
represented in its Intermediate Form. These views can be then displayed
on the screen and registered on a file.
The 'hld' view consists of the description of the module
instance hierarchy and of communication links between the module instances
(interaction points) without the description of the modules' behaviour.
The 'hld' view corresponds to the specification architecture, in terms
of module instances considered until a user-specified DEPTH.
Pretty Printer
Estelle Pretty Printer (Epp) takes an Estelle specification
and gives it back in a diffrerent (pretty) form. The user may choose several
options:
-
the identifiers and keywords may be translated (uppercase,
lowercase) or not i.e., kept as they was in the original text
-
the comments in the Estelle original text may be stripped
or not
-
the lines width and tabulation size may be selected.
X11 Windows interface (XEDT)
XEDT is an X-windows interface for the Estelle Development
Toolset (EDT). It was developed under X11R5 using MOTIF 1.2 objects. Its
functions are guaranteed when used under the 'mwm' window manager. Experiments
have shown that it does work also under 'twm' and others window managers
(but problems occurs with 'olvm').
The following EDT tools are currently integrated under
the XEDT interface:
In addition to the above tools a Viewer tool is also integrated
within XEDT.
In general any number of instances of these tools may
be simultaneously invoked and used under the XEDT interface. To know the
actual number, please consult the terms of your license to use EDT tools,
since this number may be limited. For example, the 'evaluation' license
limits the number of simultaneous accesses to each of the EDT tools to
just 1.
The development of this version
was partially supported by CNET-France Telecom.
The graphical editor
The Estelle/GR editor is graphical
window-based interface for defining, editing and viewing an Estelle specification
document in the Estelle/GR (graphical) syntax.
The editor provides a structured
environment which separates Estelle structure and behaviour definitions.
It is designed to compliment the Estelle Development Toolset (EDT), in
that it can import textual ISO Estelle documents which have been compiled
to the EDT intermediate form using ec, and can generate textual
ISO Estelle form which can be used as an input to the EDT tools.
The graphical editor is integrated
with the Estelle compiler (ec), which it uses to detect static specification
errors, reducing debugging time dramatically.
The main functions of the editor
are :
-
Import - Convert a text ISO-Estelle
document (in EDT intermediate form) to the Estelle/GR equivalent.
-
Export - Convert an Estelle/GR document
to textual ISO-Estelle form.
-
Document - Generate postscript output
of the Estelle/GR diagrams.
-
Edit - Provide full-function editing
(cut-copy-paste, undo) of an Estelle/GR document.
-
Explore - Provide an interface and
additional views which help understanding n large documents.
The graphical editor was developed
in cooperation with the Data Networks Architecture Laboratory at the University
of Cape Town in South Africa. This cooperation was funded in parts by the
CNET (France), the Ministre des Affaires Etrangères (France), the
Ministre de l?'Education Nationale, de la Recherche et de la Technologie
(France), and the Foundation for Research and Development (South Africa).
[ TOP ]
|
EDT: