"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.