Introduction to Mini-Triangle 
 

(This is a copy of a page copied from google cash as the original is no longer awailable on the web. The original author, whoever it is,  is recognised as the owner of this document)

Mini-Triangle is used throughout the textbook Programming Language Processors in Java by Watt and Brown. This handout provides you with the basic definition of Mini-Triangle. For more information you should consult the textbook.

1. Concrete Syntax

The concrete syntax of a language defines how it appears on the page or screen. The concrete syntax consists of a collection of terminals, non-terminals and production rules.

1. Terminal Symbols

begin, const, do, else, end, if, in, let, while, then, var, ;, :, :=, -, (, ), +, ~, *, -, /, <, >, =, \

2. Nonterminal Symbols

Program (start symbol), Command, Expression, V-name, Declaration, Type-denoter, Operator, Integer-Literal, single-Command, primary-Expression, single-Declaration, Identifier

3. Production Rules

Program   ::=  single-Command 

Command ::= single-Command  
|  Command; single-Command 

single-Command ::= V-name := Expression 
| Identifier(Expression) 
| if Expression then single-Command else single-Command 
| while Expression do single-Command 
| let Declaration in single-Command 
| begin Command  end  

Expression ::= primary-Expression  
| Expression Operator primary-Expression 

Primary-Expression ::=  Integer-Literal 
| V-name 
| Operator primary-Expression 
| (Expression) 

V-name ::= Identifier 

Declaration ::= single-Declaration 
| Declaration; single-Declaration 

Single-Declaration ::= const Identifier ~ Expression 
 | var Identifier : Type-denoter 

Type-denoter ::= Identifier 

Operator ::= + | - | * | / | < | > | = | \ 

Identifier ::= Leter | Identifier Letter | Identifier Digit 

Integer-Literal  ::= Digit | Integer-Literal Digit 

Command ::= ! Graphic* eol 

2. Abstract Syntax

1. Terminal Symbols

As before.

2. Nonterminal Symbols

Program, Command, Expression, V-name, Declaration, Type-denoter

3. Production Rules

Program ::=  Command 

Command  ::=  V-name := Expression 
 | Identifier(Expression) 
 |  Command; Command 
 |  if Expression then Command else Command 
 | while Expresion do Command

      |  let Declaration in Command 

Expression ::=  Integer-Literal 
 |  V-name 
 | Operator Expression 
 |  Expression Operator Expression 

V-name ::= Identifier 

Declaration ::= const Identifier ~ Expression 
 | var Identifier : Type-denoter 
 | Declaration; Declaration 

Type-denoter ::= Identifier

3. Semantics

Commands: 

• V := E Evaluate E to produce a value that is assigned to V.
• I(E). Evaluate E to produce a value v then call the prodedure bound to I with argument v.
• C1;C2. Perform C1 then C2.
• if E then C1 else C2. Evaluate E to produce a truth value b. If b is true then perform C1 else perform C2.
• while E do C. Evaluate E to produce a truth value b. If b is true then perform C and repeat. If b is false then command is complete.
• let D in C. Declaration D is elaborated to produce bindings b. C is executed in the environment of the let command overlaid with the bindings b. The bindings b have no effect outside the let command.

Expressions:

• An integer literal expression produces the value of the integer literal.
• A variable produces the value of the variable wrt the current bindings.
• A unary expression OE produces a value obtained by applying the operator O to the value of the expression E.
• A binary expression E1 O E2 produces the value of the operator O applied to the values of the expressions E1 and E2.

Declarations:

• const I ~ E is elaborated by binding I to the value of E.
• var I : T is elaborated by binding I to a newly allocated undefined variable. The variable is deallocated on exiting the containing block.
• D1;D2 is elaborated by  elaborating D1 followed by D2 and combining the resulting bindings: the current bindings are overlaid by D1 then D2 is elaborated and added.