## "Fossies" - the Fresh Open Source Software Archive

### Member "gentle-97/html/abstrsyn.html" (20 Aug 1998, 2539 Bytes) of package /linux/misc/old/gentle-97.tar.gz:

Caution: In this restricted "Fossies" environment the current HTML page may not be correctly presentated and may have some non-functional links.
You can here alternatively try to

browse the pure source code or just

view or

download the uninterpreted raw source code. If the rendering is insufficient you may try to find and view the page on the

**gentle-97.tar.gz** project site itself.

HANDBOOK
/ GENTLE PRIMER
/ At a Glance
/

# Abstract Syntax

We presented above a concrete syntax for expressions.
In this section, we discuss a so-called * abstract syntax*.

Abstract syntax is often much better suited as the basis
for the specification of
program transformations, and is used as an intermediate program representation
in compilers.

Similar to concrete syntax, a class of phrases (here called * terms*)
are defined by listing the alternatives (corresponding to the rules)
and specifying the constituents of each alternative.
Each alternative has a name (called a * functor*).

'type' Expr
plus(Expr, Expr)
minus(Expr, Expr)
mult(Expr, Expr)
div(Expr, Expr)
neg(Expr)
num(INT)

This introduces the type ` Expr`. Values of this type are constructed
as specified by the given alternatives.

For example, the alternative

num(INT)

specifies that the functor ` num` used with an argument of type ` INT`
represents a value of type ` Expr`.
For example,
` num(20)` and ` num(30)`
are values of type ` Expr`.
The alternative

mult(Expr, Expr)

specifies that the functor ` mult` may be used with two arguments of type
` Expr`. E.g. since
` num(20)` and ` num(30)` are values of type ` Expr`
the term
` mult(num(20), num(30))` is also a value of type ` Expr`.
Similarly the alternative

plus(Expr, Expr)

can be used to construct the value
` plus(num(10), mult(num(20), num(30)))`.
This abstract syntax term can be used as a representation of the expression
` 10+20*30`.
Note that in abstract syntax the structure of terms is uniquely determined.
Thus, we do not need to introduce several types to reflect the binding strength
of operators.
` plus(num(10), mult(num(20), num(30)))`
is used as a representation of ` 10+(20*30)`
and also as a representation of
the expression ` 10+20*30`.