st Language Reference

Regular Grammar

Character Set
let	Byte	::	'\00' .. '\ff' all extended ascii

let	Control	::	'\00' .. '\1f' \| '\7f' \| '\ff' control DEL space-like extended ascii

Basic elements of tokens
let	Printable	::	Byte - Control

ign	Space	::	" " ASCII - Space

ign	Tab	::	"\t"

ign	Line	::	"\n" \| "\r\n" UNIX / CPM / DOS

ign	Page	::	"\p" weak separation convention

ign	Etx	::	"\1a" { Byte } CPM / older DOS Versions

Definitions and simple tokens
let	Letter	::	'A' .. 'Z' \| 'a' .. 'z'

let	HexDigit	::	'0' .. '9' \| 'a' .. 'f'

let	Digit	::	'0' .. '9'

let	Normal	::	Letter \| Digit \| Space

let	Quote	::	'\'\"\`\\'

tok	Parenthesis	::	'()[]{}' one character tokens

let	Special	::	Printable - Normal - Parenthesis - Quote - '$#!^' \| '\\'

let	Nat	::	Digit +

tokens
tok	ASGOP	::	"_" \| ":="

tok	BINOP	::	"-" \| ( Special [ Special ] ) - ASGOP

tok	CHRLIT	::	"$" Printable

tok	IDENT	::	Letter { Letter \| Digit }

tok	INTLIT	::	[ Nat "r" ] [ "-" ] Nat

tok	FLTLIT	::	( INTLIT [ "." Nat ] [ "e" [ "-" ] Nat ] ) - INTLIT

tok	KEYWRD	::	IDENT ":"

tok	SYMKEY	::	KEYWRD KEYWRD +

tok	STRLIT	::	"\'" { Byte - '\'' \| "\'\'" } "\'"

com	Comment	::	"\"" { Byte - '\"' \| "\"\"" } "\""

tok	delim	::	'!#^'

Context-free Grammar

( legend )

Method Definition
start	file	::	classes

let	classes	::	class definition list

		\|	class classes

let	class	::	temps stats1 ! class definition

		\|	! simexp ! methods !

let	methods	::	method ! methods method list

		\|

let	method	::	msgpat temps prim stats method

		\|	msgpat temps stats

let	prim	::	< primitive: INTLIT > primitive

Message Pattern (Formal Parameter List)
let	msgpat	::	keyvars message pattern

		\|	binsel var

		\|	unasel

let	unasel	::	IDENT unary selector

let	binsel	::	> binary selector

		\|	BINOP

		\|	\|

		\|	<

let	var	::	IDENT variable name

let	keyvars	::	keyword var keyword variable list

		\|	keyvars keyword var

let	keyword	::	KEYWRD keyword

Temporaries -----------------
let	temps	::	\| vars \| temporaries

		\|

let	vars	::	variable names

		\|	var vars

Statements -----------------
let	stats	::	statements

		\|	stats1

let	stats1	::	stat non empty statements

		\|	stat . stats

let	stat	::	exp

		\|	^ exp

let	exp	::	simexp expression

		\|	var ASGOP simexp

Expressions --------------------------------------
let	simexp	::	exp0 simple expression

		\|	casexp

		\|	msgexp

let	exp0	::	var primary

		\|	( exp )

		\|	block

		\|	lit

let	msgexp	::	binexp message expression

		\|	unaexp

		\|	keyexp

let	unaexp	::	unanoj unasel unary expression

let	unanoj	::	unaexp unary object description

		\|	exp0

let	binexp	::	binobj binsel unanoj binary expression

let	binobj	::	unanoj binary object description

		\|	binexp

let	keyexp	::	binobj keylst keyword expression

let	keylst	::	keylst keyword binobj keyword binary object description list

		\|	keyword binobj

let	casexp	::	msgexp msglst cascaded message expression

let	msglst	::	msglst ; msgelt semi message list

		\|	; msgelt

let	msgelt	::	keylst message elt

		\|	unasel

		\|	binsel unanoj

Block ---------------------------------------
let	block	::	[ blkvars stats ] block

let	blkvars	::	: var blkvars1 \| opt block variables

		\|

let	blkvars1	::	: var blkvars1 block variable list

		\|

Literals --------------------------------
let	lit	::	symcon literal

		\|	number

		\|	# array

		\|	STRLIT

		\|	CHRLIT

let	number	::	FLTLIT number

		\|	INTLIT

let	symcon	::	# symbol symbol constant

let	symbol	::	IDENT symbol

		\|	KEYWRD

		\|	binsel

		\|	SYMKEY

let	array	::	( aryelts ) array

let	aryelts	::	array constant list

		\|	aryelt aryelts

let	aryelt	::	CHRLIT array constant elt

		\|	STRLIT

		\|	symbol

		\|	array

		\|	number