The Visual Eiffel components

We have defined a common protocol for accessing all the information about a project or a library. We call this protocol VE API and have released it into the public domain. You can use it to build your own tools - they can access all of the compiler's internal information. The system delivery contains some tools that access this information, including:

We refer to the information that the compiler keeps about a project or a library as just data. This data contains information about the functionality of the classes and the relationships between them. The only thing missing is the source code (as keeping the source code secret is often an important requirement for software distribution). The source code can be made available separately as plain text if desired. The data contains all other information, even comments from the routine headers.

Now we can describe how Visual Eiffel works - using these and other components to access the data. In addition we describe how a typical session activates the different components. Finally we explain how the compiler tries to use your computer's disk as efficiently as possible (and to get the maximum speed gain ;-)

The OT Workbench

The workbench is the central part of the system (yes, the compiler itself is much more complex, but the workbench is what the user sees - the "hearth"). The workbench obtains information about the underlying Eiffel project through VE API. So it's easy to use the workbench to control any OO compiler tool - provided it supports VE API or another interface specification which can be translated on the fly to VE API.

How it works

If one wants to access a database it is first necessary to generate such a database. This may seem obvious - nevertheless it is important to know about this constraint. The database is generated from source code by a special tool. The name of this tool? You guessed it - the compiler!

The compiler takes Eiffel sources and builds the database. Of course it does other things too: builds executable programs or libraries for example. In fact the compiler builds the database not primarily for the benefit of other tools, but because it needs the data itself in order to compile properly.

After a compilation, the workbench can access this data - browse though the inheritance chain, display all class relationships and produce short and flat form versions of the classes. This is done by activating the query DLL and asking the proper queries using the VE API protocol. Typical question are for example "give me the names of all attributes of class XYZ" or "tell me the type of the first parameter of function abc in class XYZ". The interface for the DLL access is a very simple (but not very small) Eiffel class available as source code. And what is the name of the query DLL? Yes, it's the compiler again (naturally, the tool which produced the database can also access it again).

The Compiler

The compiler is in fact a DLL - with several different entry points offering different services to different clients:


A typical Visual Eiffel session

This description follows the example presented in the guided tour, not from the visual standpoint but from a more technical viewpoint.

You click the mouse - the rest is easy: the workbench starts up and waits for your commands. You can, for example:

If you open an existing project, the workbench loads the compiler DLL and reads the available internal information. You can now:

It may be appropriate to do all of the above steps. Finally the project information is stored again before the Workbench is closed.


Organization of the disk space

Our main objectives were simple:

Information is stored on a cluster-by-cluster basis (a cluster comprises the classes stored in a single directory). Visual Eiffel creates up to three additional subdirectories for each cluster:


Copyright © Object Tools -- info@object-tools.com
Last updated: 2005/02/02 11:51:33