Eiffel - Software - Formula Parsing Cluster

Maintainer

Javier Alonso

Description

This small cluster was born from the need to resolve small formulae in the style of

X + ( STEP * 2 ) / KERF

that are defined in a parametric CAD/CAM system under development.

Use of more complex libraries like EiffelLex or EiffelParse (let alone YOOC...) seemed like overkill for such a small task, so this (micro)cluster was developed on the fly to solve positional references related to a working area or slab of material, in a new approach to parametric design. Instead of giving precise numerical positions, these are entered as formulae which use named variables such as thickness, width and length. In this way, if a part to be machined has, say, six holes in it proportionally spaced, the proportion is kept constant if overall dimensions are changed. In actual parametric systems a new part program is generated for any dimensional change, but you need to define a 'pattern program' telling which items are fixed or variable.

Versions

(1997-08-28)

Features

The cluster contains the following classes:

lexem.e is the basic lexical unit in which the expression is decomposed.
fp_constants.e contains some numerical constants used to identify lexems.
formula_parser (fp.e)

The parser allows the definition of named variables only limited by system resources, and works as follows:

Once an instance of the parser is created, new variables can be defined by means of

set_var ( name : STRING; value : DOUBLE )

also, the value of an existing variable can be obtained by

get_var ( name : STRING ) : DOUBLE

Setting the value of an existing variable implies the re-evaluation of the actual expression. Recalculation is also forced by the command

set_expression ( ns : STRING )

The usual way to employ the formula parser is

evaluate_string ( ns : STRING ) : DOUBLE

which set ns as the actual expression, evaluates it, and returns the result.

The parsing process goes this way:

All blank spaces are removed from the string to parse. If, after that, the string is empty, then it is assumed that the resulting value is 0.0 by default, the error flag is raised, and the relevant error text is set.
Then left and right parentheses are counted. If the respective counts are not equal, the error 'Unbalanced parenthesis' is raised.
Next, the list of lexems is generated by an one-pass scan of the string. Lexems belong to any of these groups:
Binary operators ( +, -, *, / ).
Parenthesis, simultaneously recording the nesting level.
Variables, assumed to be a sequence of characters in the interval 'A' to 'Z' so variable names like 'AA102' are not allowed.
Numerics, assumed to be sequences from '0' to '9'. They are resolved on the fly by straight string-to-double conversion.

Any character not matching any of these groups is rejected and the process stopped with the corresponding error flag and message.

As can be seen from the source code, this generation process is conceptually similar to the workings of a finite state machine (as the vast majority is, by the way).

After that, the resolution of variable names is carried on, looking for their values in the respective hash table. Again, a variable name not found in the table raises the error condition.
Once done, resolution of the resulting lexem list is carried as follows:
from the deeper parenthesis level up, sublists are formed with the existing groups of contiguous lexems of the same level,
every sublist of lexems is then partially solved according to the usual precedence of operators.
the whole sublist is then deleted from the main list and a new lexem containing the partial result is stored in its place.

Finally, just one final lexem of type solved literal remains in the list, containing the result of the whole evaluation process.

Supported compilers

ISE Eiffel (ISE Eiffel 3.3.9)

Platforms

Windows

Licensing

» Gnu General Public License (GPL)

Formula Parsing Cluster