Skip Navigation
 
 

st Language Reference


Regular Grammar

( legend )
 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 )

start  file  :: 

classes


 
     
let  classes  :: 


class definition list

 
     
   | 

class classes

 

 
     
let  class  :: 

temps stats1 !


class definition

 
     
   | 

! simexp ! methods !

 

 
     
let  methods  :: 


method list

 
     
   | 

method ! methods

 

 
     
 Method Definition
let  method  :: 

msgpat temps stats


method

 
     
   | 

msgpat temps prim 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  :: 

keyvars keyword var


keyword variable list

 
     
   | 

keyword var

 

 
     
let  keyword  :: 

KEYWRD


keyword

 
     
 Temporaries -----------------
let  temps  :: 


temporaries

 
     
   | 

| vars |

 

 
     
let  vars  :: 

var vars


variable names

 
     
   | 

 

 
     
 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

 
     
   | 

msgexp

 

 
     
   | 

casexp

 

 
     
let  exp0  :: 

block


primary

 
     
   | 

lit

 

 
     
   | 

var

 

 
     
   | 

( exp )

 

 
     
let  msgexp  :: 

unaexp


message expression

 
     
   | 

keyexp

 

 
     
   | 

binexp

 

 
     
let  unaexp  :: 

unanoj unasel


unary expression

 
     
let  unanoj  :: 

exp0


unary object description

 
     
   | 

unaexp

 

 
     
let  binexp  :: 

binobj binsel unanoj


binary expression

 
     
let  binobj  :: 

binexp


binary object description

 
     
   | 

unanoj

 

 
     
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  :: 

unasel


message elt

 
     
   | 

keylst

 

 
     
   | 

binsel unanoj

 

 
     
 Block ---------------------------------------
let  block  :: 

[ blkvars stats ]


block

 
     
let  blkvars  :: 

: var blkvars1 |


opt block variables

 
     
   | 

 

 
     
let  blkvars1  :: 


block variable list

 
     
   | 

: var blkvars1

 

 
     
 Literals --------------------------------
let  lit  :: 

symcon


literal

 
     
   | 

number

 

 
     
   | 

CHRLIT

 

 
     
   | 

STRLIT

 

 
     
   | 

# array

 

 
     
let  number  :: 

INTLIT


number

 
     
   | 

FLTLIT

 

 
     
let  symcon  :: 

# symbol


symbol constant

 
     
let  symbol  :: 

IDENT


symbol

 
     
   | 

SYMKEY

 

 
     
   | 

binsel

 

 
     
   | 

KEYWRD

 

 
     
let  array  :: 

( aryelts )


array

 
     
let  aryelts  :: 


array constant list

 
     
   | 

aryelt aryelts

 

 
     
let  aryelt  :: 

symbol


array constant elt

 
     
   | 

number

 

 
     
   | 

CHRLIT

 

 
     
   | 

STRLIT

 

 
     
   | 

array