Abstract Syntax Tree

S-Expression Grammar

Compilation Unit

compilationUnit :=
  '(' COMPUNIT filenameNode timestampNode digestNode moduleNode ')'
  ;

Generic Sample

(COMPUNIT
  (FILENAME ...)
  (COMPILED ...)
  (DIGEST ...)
  (DEFMOD ...))

Filename Node

filenameNode :=
  '(' FILENAME quotedLiteral ')'
  ;

Sample

(FILENAME "Foobar.def")

Timestamp Node

timestampNode :=
  '(' COMPILED quotedLiteral ')'
  ;

Sample

(COMPILED "202009242016000+900")

Digest Node

digestNode :=
  '(' DIGEST quotedLiteral ')'
  ;

Sample

(DIGEST "9E107D9D372BB6826BD81D3542A419D6")

Module Node

moduleNode :=
  defModNode | impModNode | progNode
  ;

Definition Module

defModNode :=
  '(' DEFMOD idNode importNode* reExportNode* declarationNode* ')'
  ;

Generic Sample

(DEFMOD (ID "Foobar")
  (IMPORT ...)
  (REEXPORT ...)
  (CONST ...)
  (VAR ...)
  (TYPE ...)
  (PROC ...)
  (BIND ...))

Identifier Node

idNode :=
  '(' ID quotedLiteral ')'
  ;

Sample

(ID "Foobar")

Import Node

importNode :=
  '(' IMPORT quotedLiteral+ ')'
  ;

Sample

IMPORT Foo, Bar, Baz;

compiles to

(IMPORT "Foo" "Bar" "Baz")

Re-Export Node

reExportNode :=
  '(' REEXPORT quotedLiteral+ ')'
  ;

Sample

IMPORT Foo+, Bar+;

compiles to

(IMPORT "Foo" "Bar")
(REEXPORT "Foo" "Bar")

Declaration Node

declarationNode :=
  constDeclNode | varDeclNode | typeDeclNode | procDeclNode
  ;

Constant Declaration Node

constDeclNode :=
  '(' CONST idNode exprNode typeIdNode? ')'
  ;
alias typeIdNode = idNode ;

Samples

CONST Foo = 42;
CONST Bar : INTEGER = -1;

compiles to

(CONST (ID "Foo") (EXPR (NUM 42)))
(CONST (ID "Bar") (EXPR (NEG (NUM 1))) (ID "INTEGER"))

Variable Declaration Node

varDeclNode :=
  '(' VAR idListNode typeIdNode ')'
  ;

Samples

VAR foo : Foo;
VAR i, j : INTEGER;

compiles to

(VAR (ID "foo") (ID "Foo"))
(VAR (ID "i" "j") (ID "INTEGER"))

Identifier List Node

idListNode :=
  '(' ID quotedLiteral+ ')'
  ;

Sample

(ID "foo" "bar" "baz")

Type Declaration Node

typeDeclNode :=
  '(' TYPE idNode typeConstructorNode ')'
  ;
typeConstructorNode :=
  aliasTypeNode | derivedTypeNode | subrangeTypeNode |enumTypeNode |
  setTypeNode | arrayTypeNode | recordTypeNode | pointerTypeNode |
  opaqueTypeNode | procTypeNode
  ;

Generic Sample

(TYPE (ID "TypeIdent") ...)

Alias Type Node

aliasTypeNode :=
  '(' ALIAS baseTypeNode ')'
  ;
alias baseTypeNode = typeIdNode ;

Sample

TYPE Foo = ALIAS OF Bar;

compiles to

(TYPE (ID "Foo") (ALIAS (ID "Bar)))

Derived Type Node

alias derivedTypeNode = typeIdNode ;

Sample

TYPE Foo = Bar;

compiles to

(TYPE (ID "Foo") (ID "Bar))

Subrange Type Node

subrangeTypeNode :=
  '(' SUBR baseTypeNode lowerBound upperBound ')'
  ;
alias lowerBound, upperBound = exprNode ;

Sample

TYPE Hour = [0..23] OF INTEGER;

compiles to

(TYPE (ID "Hour") (ID "INTEGER") (SUBR (EXPR (NUM 0))(EXPR (NUM 23))))

Enumeration Type Node

enumTypeNode :=
  '(' ENUM valueListNode baseTypeNode? ')'
  ;
alias valueListNode = idListNode ;

Samples

TYPE Colour = ( Red, Green, Blue );
TYPE MoreColour = ( +Colour, Orange, Magenta );

compiles to

(TYPE (ID "Colour") (ENUM (ID "Red" "Green" "Blue")))
(TYPE (ID "MoreColour") (ENUM (ID "Orange" "Magenta") (ID "Colour")))

Set Type Node

setTypeNode :=
  '(' SET enumTypeIdNode ')'
  ;
alias enumTypeIdNode = typeIdNode ;

Sample

TYPE ColourSet = SET OF Colour;

compiles to

(TYPE (ID "ColourSet") (SET (ID "Colour")))

Array Type Node

arrayTypeNode :=
  '(' ARRAY capacity baseTypeNode ')'
  ;
alias capacity = exprNode ;

Sample

TYPE Str80 = ARRAY 80 OF CHAR;

compiles to

(TYPE (ID "Str80") (ARRAY (EXPR (NUM 80)) (ID "Colour")))