HANDBOOK
/ LANGUAGE REFERENCE MANUAL
/

# Introduction

* Gentle* is a high-level programming language for compiler writers.
It covers the whole spectrum of compiler construction,
ranging from analysis over transformation to synthesis.
* Gentle* provides a uniform notation for all tasks.

### Language Overview

The language is based on recursive definition and structural induction,
the underlying paradigm of virtually all translation tasks.
* Gentle* allows the user to define
mutally recursive types by enumerating alternative structures

Expr = plus(Expr,Expr), minus(Expr,Expr), const(INT)

Programs in * Gentle* are expressed by rules of the form
G : A B C

These rules may be interpreted
as grammar rules (` G` is constructed from ` A`, ` B`, and ` C`),
as logical statements
(` G` is true if ` A`, ` B`, and ` C` are true),
or in a procedural manner
(to solve task ` G`, solve subtasks ` A`, ` B`, and ` C`).
Members of a rule may have parameters
(an arrow separating input from output parameters).
This results in attributed
grammars

AddingExpression(-> plus(X1, X2)):
AddingExpression(-> X1) "+" Primary(-> X2)

or in transformation schemes that inductively follow the structure
of terms
Eval(plus (X1, X2)->N1+N2): Eval(X1->N1) Eval(X2->N2).
Eval(minus(X1, X2)->N1-N2): Eval(X1->N1) Eval(X2->N2).
Eval(const(N) ->N).

Unparsing may be expressed in a similar way
Code(plus(X1, X2) -> Reg2) :
Code(X1 -> Reg1)
Code(X2 -> Reg2)
Emit("add", Reg1, Reg2).

Such rules can be augmented by cost values. Then, rules are selected
in such a way that the sum of the costs of all selected rules is optimal.
This allows a nondeterministic specification that handles idioms of the
target machine by rules with corresponding patterns.
* Gentle* is a strongly typed language that allows a tool
to statically check the consistency of the specification.
Traditional errors
such as uninitialized variables can be detected at the earliest point.

* Gentle* has a declarative flavor. It also provides mutable
global variables and tables to represent deferred information
and cyclic structures.
* Gentle* supports procedures written in other languages.

### Related Languages

* Gentle* descends from * CDL* [7] and * Prolog* [15].
An early version was described in [10].