Skip Navigation
 
 

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

" " | "\t"


ASCII - Space

 
     
ign  Line  :: 

"\n" | "\r"


UNIX / Windows / DOS / Mac

 
     
ign  Page  :: 

"\p"


weak separation convention

 
     
ign  Etx  :: 

"\1a" { Byte }


CPM / older DOS Versions

 
     
 Definitions and simple tokens
let  ULetter  :: 

'A' .. 'Z'


 
     
let  LLetter  :: 

'a' .. 'z'


 
     
let  Letter  :: 

ULetter | LLetter


 
     
let  Bit  :: 

'0' | '1'


 
     
let  Hex1  :: 

'0' .. '9' | 'a' .. 'f' | 'A' .. 'Z'


 
     
let  Hex2  :: 

Hex1 Hex1


 
     
let  Hex4  :: 

Hex2 Hex2


 
     
let  Digit  :: 

'0' .. '9'


 
     
let  Space11  :: 

'\08' | '\09' | '\0a' | '\0b' | '\0c' | '\0d'


 
     
let  NQSpecial  :: 

'!\"#$%&+,-./:;<=>?@[\\]^_\`{|}(*)~'


 
     
let  Sign  :: 

'+' | '-'


 
     
let  ComChar  :: 

Printable | Space | Space11


 
     
 Comments et al
com  ComBlock  :: 

< "(*" > < "*)" >


 
     
com  ComLine  :: 

"--" { Byte - Line } Line


 
     
 Complex tokens
tok  Ide [I] :: 

Letter { Letter | Digit | '_' }


 
     
tok  Bin  :: 

"%" Bit +


 
     
tok  Nat  :: 

Digit +


 
     
tok  Flt  :: 

Digit + "." [ Digit + ] [ 'eE' [ Sign ] Digit + ]


 
     
tok  Lit  :: 

'\"' Hex4 + '\"'


 
     
tok  Str  :: 

'\'' { Space | Space11 | Letter | Digit | NQSpecial | "\'\'" } '\''


 
     
tok  Opr  :: 

NQSpecial | ">=" | "<=" | "<>" | ":=" [ ':' ] | "<*" | "**" | ":<>:" | "||"


 



Context-free Grammar

( legend )

start  Step11  :: 

Schemas


 
     
let  Schemas  :: 

Schema Schemas0


 
     
let  Schemas0  :: 

Schema Schemas0


 
     
   | 

 

 
     
let  Schema  :: 

schema Ide ; SchemaBody end_schema ;


 
     
let  SchemaBody  :: 

Interfaces ConstDecl Decls


 
     
let  Interfaces  :: 

Interface Interfaces


 
     
   | 

 

 
     
let  Interface  :: 

use from Ide References ;


 
     
   | 

reference from Ide References ;

 

 
     
let  References  :: 

( References1 )


 
     
   | 

 

 
     
let  References1  :: 

Ref References0


 
     
let  References0  :: 

, Ref References0


 
     
   | 

 

 
     
let  Ref  :: 

Ide


 
     
   | 

Ide as Ide

 

 
     
let  ConstDecl  :: 

constant Constants end_constant ;


 
     
   | 

 

 
     
let  Constants  :: 

Constant Constants0


 
     
let  Constants0  :: 

Constant Constants0


 
     
   | 

 

 
     
let  Constant  :: 

Ide : TypeB := Exp ;


 
     
let  TypeN  :: 

Ide


 
     
let  Type  :: 

logical


 
     
   | 

boolean

 

 
     
   | 

binary Size

 

 
     
   | 

integer

 

 
     
   | 

string Size

 

 
     
   | 

real OptExp3

 

 
     
   | 

number

 

 
     
let  TypeA  :: 

bag Bound of TypeB


 
     
   | 

list Bound of KeyUniq TypeB

 

 
     
   | 

set Bound of TypeB

 

 
     
   | 

array Bound of KeyOpt KeyUniq TypeB

 

 
     
let  TypeB  :: 

Type


 
     
   | 

TypeA

 

 
     
   | 

TypeN

 

 
     
let  Bound  :: 

[ Exp1 : Exp1 ]


 
     
let  Size  :: 


 
     
   | 

( Exp1 ) KeyFix

 

 
     
let  KeyOpt  :: 


 
     
   | 

optional

 

 
     
let  KeyUniq  :: 


 
     
   | 

unique

 

 
     
let  KeyFix  :: 


 
     
   | 

fixed

 

 
     
let  Exp  :: 

Exp1 in Exp1


Prio 0

 
     
   | 

Exp1 <> Exp1

 

 
     
   | 

Exp1 like Exp1

 

 
     
   | 

Exp1 >= Exp1

 

 
     
   | 

Exp1 <= Exp1

 

 
     
   | 

Exp1 > Exp1

 

 
     
   | 

Exp1 :<>: Exp1

 

 
     
   | 

Exp1 = Exp1

 

 
     
   | 

Exp1

 

 
     
   | 

Exp1 :=: Exp1

 

 
     
   | 

Exp1 < Exp1

 

 
     
let  Exp1  :: 

Exp1 + Exp2


Prio 1

 
     
   | 

Exp1 - Exp2

 

 
     
   | 

Exp1 or Exp2

 

 
     
   | 

Exp2

 

 
     
   | 

Exp1 xor Exp2

 

 
     
let  Exp2  :: 

Exp2 || Exp3


Prio 2

 
     
   | 

Exp3

 

 
     
   | 

Exp2 mod Exp3

 

 
     
   | 

Exp2 div Exp3

 

 
     
   | 

Exp2 and Exp3

 

 
     
   | 

Exp2 * Exp3

 

 
     
   | 

Exp2 / Exp3

 

 
     
let  Exp3  :: 

Exp4


Prio 3

 
     
   | 

Exp4 ** Exp4

 

 
     
let  Exp4  :: 

{ Exp1 IvalOpr Exp1 IvalOpr Exp1 }


Prio 4

 
     
   | 

[ ExpRng0 ]

 

 
     
   | 

query ( Ide <* Exp1 | Exp )

 

 
     
   | 

not Exp5

 

 
     
   | 

Exp5

 

 
     
   | 

- Exp5

 

 
     
   | 

+ Exp5

 

 
     
let  IvalOpr  :: 

<


 
     
   | 

<=

 

 
     
let  Exp5  :: 

Fun APars Quals


Prio 5

 
     
   | 

pi Quals

 

 
     
   | 

Str

 

 
     
   | 

Flt

 

 
     
   | 

true

 

 
     
   | 

const_e Quals

 

 
     
   | 

self Quals

 

 
     
   | 

unknown

 

 
     
   | 

Lit

 

 
     
   | 

? Quals

 

 
     
   | 

Bin

 

 
     
   | 

( Exp )

 

 
     
   | 

Nat

 

 
     
   | 

false

 

 
     
let  ExpRng0  :: 

Exp : Exp1


 
     
   | 

Exp

 

 
     
let  ExpRng  :: 

Exp1 : Exp1


 
     
   | 

Exp1

 

 
     
let  Quals  :: 


 
     
   | 

ExpQual Quals

 

 
     
let  ExpQual  :: 

. Ide


 
     
   | 

\ Ide

 

 
     
   | 

[ ExpRng ]

 

 
     
let  Exps  :: 

Exp Exps0


 
     
let  Exps0  :: 


 
     
   | 

, Exp Exps0

 

 
     
let  Fun0  :: 

Ide


 
     
let  Fun  :: 

nvl


 
     
   | 

sqrt

 

 
     
   | 

lobound

 

 
     
   | 

value

 

 
     
   | 

atan

 

 
     
   | 

exists

 

 
     
   | 

blength

 

 
     
   | 

typeof

 

 
     
   | 

usedin

 

 
     
   | 

loindex

 

 
     
   | 

log2

 

 
     
   | 

log10

 

 
     
   | 

tan

 

 
     
   | 

exp

 

 
     
   | 

acos

 

 
     
   | 

sizeof

 

 
     
   | 

log

 

 
     
   | 

hiindex

 

 
     
   | 

odd

 

 
     
   | 

Fun0

 

 
     
   | 

value_in

 

 
     
   | 

length

 

 
     
   | 

value_unique

 

 
     
   | 

hibound

 

 
     
   | 

asin

 

 
     
   | 

rolesof

 

 
     
   | 

sin

 

 
     
   | 

format

 

 
     
   | 

cos

 

 
     
   | 

abs

 

 
     
let  FunP  :: 

Fun0


 
     
   | 

remove

 

 
     
   | 

insert

 

 
     
let  FPars  :: 


 
     
   | 

( FPars1 )

 

 
     
let  FPars1  :: 

FPar FPars0


 
     
let  FPars0  :: 

; FPar FPars0


 
     
   | 

 

 
     
let  FParsP  :: 

( FParsP1 )


 
     
   | 

 

 
     
let  FParsP1  :: 

FParP FParsP0


 
     
let  FParsP0  :: 


 
     
   | 

; FParP FParsP0

 

 
     
let  FPar  :: 

Ids : TypeP


 
     
let  FParP  :: 

FPar


 
     
   | 

var Ids : TypeP

 

 
     
let  APars  :: 

( APars1 )


 
     
   | 

 

 
     
let  APars1  :: 

Exp APars0


 
     
let  APars0  :: 


 
     
   | 

, Exp APars0

 

 
     
let  Decls  :: 

Decl Decls


 
     
   | 

 

 
     
let  Decls0  :: 


 
     
   | 

Decl0 Decls0

 

 
     
let  Decl0  :: 

type Ide = TypeU ; Where1 end_type ;


 
     
   | 

ObjHead ObjBody end_entity ;

 

 
     
   | 

FunHead AHead Stmts1 end_function ;

 

 
     
   | 

ProcHead AHead Stmts end_procedure ;

 

 
     
let  Decl  :: 

RuleHead AHead Stmts Where end_rule ;


 
     
   | 

Decl0

 

 
     
let  Ids  :: 

Ide Ids0


 
     
let  Ids0  :: 

, Ide Ids0


 
     
   | 

 

 
     
let  ObjHead  :: 

entity Ide SubSup SubSup1 ;


 
     
let  ProcHead  :: 

procedure Ide FParsP ;


 
     
let  FunHead  :: 

function Ide FPars : TypeP ;


 
     
let  ObjBody  :: 

EAttrDecls DAttrDecls IAttrDecls RuleUniqs Where1


 
     
let  EAttrDecls  :: 

EAttrDecl EAttrDecls


 
     
   | 

 

 
     
let  EAttrDecl  :: 

Attrs : KeyOpt TypeB ;


 
     
let  Attrs  :: 

Attr Attrs0


 
     
let  Attrs0  :: 

, Attr Attrs0


 
     
   | 

 

 
     
let  DAttrDecls  :: 


 
     
   | 

derive DAttrDecl DAttrDecls0

 

 
     
let  DAttrDecls0  :: 


 
     
   | 

DAttrDecl DAttrDecls0

 

 
     
let  DAttrDecl  :: 

Attr : TypeB := Exp ;


 
     
let  IAttrDecls  :: 

inverse IAttrDecl IAttrDecls0


 
     
   | 

 

 
     
let  IAttrDecls0  :: 


 
     
   | 

IAttrDecl IAttrDecls0

 

 
     
let  IAttrDecl  :: 

Attr : TypeI for Ide ;


 
     
let  RuleUniqs  :: 


 
     
   | 

unique LblAttrs ; RuleUniqs0

 

 
     
let  RuleUniqs0  :: 

LblAttrs ; RuleUniqs0


 
     
   | 

 

 
     
let  LblAttrs  :: 

Attrs


 
     
   | 

Ide : Attrs

 

 
     
let  TypeI  :: 

bag Bound of TypeN


 
     
   | 

TypeN

 

 
     
   | 

set Bound of TypeN

 

 
     
let  TypeU  :: 

enumeration of ( Ids )


 
     
   | 

Type

 

 
     
   | 

select ( Ids )

 

 
     
   | 

TypeN

 

 
     
   | 

TypeA

 

 
     
let  Attr  :: 

Ide


 
     
   | 

self \ Ide . Ide

 

 
     
let  SubSup0  :: 


 
     
let  SubSup  :: 

SubSup0


 
     
   | 

supertype CondSubType

 

 
     
   | 

abstract supertype OptCondSubType

 

 
     
let  SubSup1  :: 

subtype of ( Ids )


 
     
   | 

SubSup0

 

 
     
let  CondSubType  :: 

of ( ExpSup )


 
     
let  OptCondSubType  :: 


 
     
   | 

CondSubType

 

 
     
let  ExpSup  :: 

ExpSup1


Prio 0

 
     
   | 

ExpSup1 andor ExpSup1

 

 
     
let  ExpSup1  :: 

ExpSup2 and ExpSup2


Prio 1

 
     
   | 

ExpSup2

 

 
     
let  ExpSup2  :: 

Ide


 
     
   | 

( ExpSup )

 

 
     
   | 

oneof ( ExpSups )

 

 
     
let  ExpSups  :: 

ExpSup ExpSups0


 
     
let  ExpSups0  :: 

, ExpSup ExpSups0


 
     
   | 

 

 
     
let  RuleHead  :: 

rule Ide for ( Ids ) ;


 
     
let  AHead  :: 

Decls0 ConstDecl LocalDecl


 
     
let  LocalDecl  :: 


 
     
   | 

local Vars end_local ;

 

 
     
let  Vars  :: 

Var Vars0


 
     
let  Vars0  :: 


 
     
   | 

Var Vars0

 

 
     
let  Var  :: 

Ids : TypeP OptExp ;


 
     
let  TypeP  :: 

array Bound of KeyOpt KeyUniq TypeP


 
     
   | 

TypeN

 

 
     
   | 

aggregate Label of TypeP

 

 
     
   | 

list Bound of KeyUniq TypeP

 

 
     
   | 

bag Bound of TypeP

 

 
     
   | 

set Bound of TypeP

 

 
     
   | 

Type

 

 
     
   | 

generic Label

 

 
     
let  OptExp  :: 

:= Exp


 
     
   | 

 

 
     
let  OptExp1  :: 

( Exp )


 
     
   | 

 

 
     
let  OptExp2  :: 

by Exp1


 
     
   | 

 

 
     
let  OptExp3  :: 

( Exp1 )


 
     
   | 

 

 
     
let  Where  :: 

where ExpLbl ; Where0


 
     
let  Where0  :: 

ExpLbl ; Where0


 
     
   | 

 

 
     
let  Where1  :: 


 
     
   | 

Where

 

 
     
let  Label  :: 

: Ide


 
     
   | 

 

 
     
let  ExpLbl  :: 

Exp


 
     
   | 

Ide : Exp

 

 
     
let  Stmts  :: 


 
     
   | 

Stmt Stmts

 

 
     
let  Stmts1  :: 

Stmt Stmts


 
     
let  StmtsElse  :: 


 
     
   | 

else Stmts1

 

 
     
let  LoopCtrl  :: 

while Exp


 
     
   | 

 

 
     
   | 

until Exp

 

 
     
   | 

Ide := Exp1 to Exp1 OptExp2

 

 
     
let  Cases  :: 

Case Cases


 
     
   | 

 

 
     
let  Case  :: 

Exps : Stmt


 
     
   | 

otherwise : Stmt

 

 
     
let  Stmt  :: 

;


 
     
   | 

if Exp then Stmts1 StmtsElse end_if ;

 

 
     
   | 

escape ;

 

 
     
   | 

Ide Quals := Exp ;

 

 
     
   | 

FunP APars ;

 

 
     
   | 

skip ;

 

 
     
   | 

alias Ide for Ide Quals ; Stmts1 end_alias ;

 

 
     
   | 

case Exp of Cases end_case ;

 

 
     
   | 

return OptExp1 ;

 

 
     
   | 

repeat LoopCtrl ; Stmts1 end_repeat ;

 

 
     
   | 

begin Stmts1 end ;