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

boolean


 
     
   | 

real OptExp3

 
     
   | 

number

 
     
   | 

binary Size

 
     
   | 

logical

 
     
   | 

string Size

 
     
   | 

integer

 
     
let  TypeA  :: 

bag Bound of TypeB


 
     
   | 

array Bound of KeyOpt KeyUniq TypeB

 
     
   | 

list Bound of KeyUniq TypeB

 
     
   | 

set Bound of TypeB

 
     
let  TypeB  :: 

TypeA


 
     
   | 

TypeN

 
     
   | 

Type

 
     
let  Bound  :: 

[ Exp1 : Exp1 ]


 
     
let  Size  :: 


 
     
   | 

( Exp1 ) KeyFix

 
     
let  KeyOpt  :: 


 
     
   | 

optional

 
     
let  KeyUniq  :: 

unique


 
     
   | 

 
     
let  KeyFix  :: 

fixed


 
     
   | 

 
     
let  Exp  :: 

Exp1 > Exp1



 Prio 0

 
     
   | 

Exp1 :=: Exp1

 
     
   | 

Exp1 < Exp1

 
     
   | 

Exp1 like Exp1

 
     
   | 

Exp1 :<>: Exp1

 
     
   | 

Exp1 <> Exp1

 
     
   | 

Exp1 in Exp1

 
     
   | 

Exp1 >= Exp1

 
     
   | 

Exp1 <= Exp1

 
     
   | 

Exp1

 
     
   | 

Exp1 = Exp1

 
     
let  Exp1  :: 

Exp1 or Exp2



 Prio 1

 
     
   | 

Exp1 xor Exp2

 
     
   | 

Exp1 + Exp2

 
     
   | 

Exp2

 
     
   | 

Exp1 - Exp2

 
     
let  Exp2  :: 

Exp2 * Exp3



 Prio 2

 
     
   | 

Exp2 and Exp3

 
     
   | 

Exp2 || Exp3

 
     
   | 

Exp2 / Exp3

 
     
   | 

Exp2 mod Exp3

 
     
   | 

Exp2 div Exp3

 
     
   | 

Exp3

 
     
let  Exp3  :: 

Exp4 ** Exp4



 Prio 3

 
     
   | 

Exp4

 
     
let  Exp4  :: 

[ ExpRng0 ]



 Prio 4

 
     
   | 

query ( Ide <* Exp1 | Exp )

 
     
   | 

{ Exp1 IvalOpr Exp1 IvalOpr Exp1 }

 
     
   | 

- Exp5

 
     
   | 

not Exp5

 
     
   | 

+ Exp5

 
     
   | 

Exp5

 
     
let  IvalOpr  :: 

<


 
     
   | 

<=

 
     
let  Exp5  :: 

const_e Quals



 Prio 5

 
     
   | 

Str

 
     
   | 

self Quals

 
     
   | 

false

 
     
   | 

Flt

 
     
   | 

unknown

 
     
   | 

Lit

 
     
   | 

true

 
     
   | 

pi Quals

 
     
   | 

? Quals

 
     
   | 

( Exp )

 
     
   | 

Nat

 
     
   | 

Fun APars Quals

 
     
   | 

Bin

 
     
let  ExpRng0  :: 

Exp : Exp1


 
     
   | 

Exp

 
     
let  ExpRng  :: 

Exp1 : Exp1


 
     
   | 

Exp1

 
     
let  Quals  :: 


 
     
   | 

ExpQual Quals

 
     
let  ExpQual  :: 

[ ExpRng ]


 
     
   | 

\ Ide

 
     
   | 

. Ide

 
     
let  Exps  :: 

Exp Exps0


 
     
let  Exps0  :: 

, Exp Exps0


 
     
   | 

 
     
let  Fun0  :: 

Ide


 
     
let  Fun  :: 

hiindex


 
     
   | 

format

 
     
   | 

tan

 
     
   | 

asin

 
     
   | 

cos

 
     
   | 

abs

 
     
   | 

loindex

 
     
   | 

hibound

 
     
   | 

exists

 
     
   | 

value_in

 
     
   | 

length

 
     
   | 

blength

 
     
   | 

odd

 
     
   | 

typeof

 
     
   | 

log10

 
     
   | 

sizeof

 
     
   | 

value

 
     
   | 

nvl

 
     
   | 

atan

 
     
   | 

sqrt

 
     
   | 

rolesof

 
     
   | 

log2

 
     
   | 

acos

 
     
   | 

sin

 
     
   | 

usedin

 
     
   | 

Fun0

 
     
   | 

value_unique

 
     
   | 

log

 
     
   | 

exp

 
     
   | 

lobound

 
     
let  FunP  :: 

Fun0


 
     
   | 

insert

 
     
   | 

remove

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

var Ids : TypeP


 
     
   | 

FPar

 
     
let  APars  :: 


 
     
   | 

( APars1 )

 
     
let  APars1  :: 

Exp APars0


 
     
let  APars0  :: 


 
     
   | 

, Exp APars0

 
     
let  Decls  :: 


 
     
   | 

Decl Decls

 
     
let  Decls0  :: 


 
     
   | 

Decl0 Decls0

 
     
let  Decl0  :: 

ObjHead ObjBody end_entity ;


 
     
   | 

FunHead AHead Stmts1 end_function ;

 
     
   | 

ProcHead AHead Stmts end_procedure ;

 
     
   | 

type Ide = TypeU ; Where1 end_type ;

 
     
let  Decl  :: 

Decl0


 
     
   | 

RuleHead AHead Stmts Where end_rule ;

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

TypeN


 
     
   | 

bag Bound of TypeN

 
     
   | 

set Bound of TypeN

 
     
let  TypeU  :: 

select ( Ids )


 
     
   | 

TypeN

 
     
   | 

Type

 
     
   | 

TypeA

 
     
   | 

enumeration of ( Ids )

 
     
let  Attr  :: 

Ide


 
     
   | 

self \ Ide . Ide

 
     
let  SubSup0  :: 


 
     
let  SubSup  :: 

abstract supertype OptCondSubType


 
     
   | 

supertype CondSubType

 
     
   | 

SubSup0

 
     
let  SubSup1  :: 

subtype of ( Ids )


 
     
   | 

SubSup0

 
     
let  CondSubType  :: 

of ( ExpSup )


 
     
let  OptCondSubType  :: 

CondSubType


 
     
   | 

 
     
let  ExpSup  :: 

ExpSup1 andor ExpSup1



 Prio 0

 
     
   | 

ExpSup1

 
     
let  ExpSup1  :: 

ExpSup2 and ExpSup2



 Prio 1

 
     
   | 

ExpSup2

 
     
let  ExpSup2  :: 

oneof ( ExpSups )


 
     
   | 

Ide

 
     
   | 

( ExpSup )

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

Type


 
     
   | 

aggregate Label of TypeP

 
     
   | 

array Bound of KeyOpt KeyUniq TypeP

 
     
   | 

bag Bound of TypeP

 
     
   | 

set Bound of TypeP

 
     
   | 

TypeN

 
     
   | 

list Bound of KeyUniq TypeP

 
     
   | 

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

Ide : Exp


 
     
   | 

Exp

 
     
let  Stmts  :: 


 
     
   | 

Stmt Stmts

 
     
let  Stmts1  :: 

Stmt Stmts


 
     
let  StmtsElse  :: 


 
     
   | 

else Stmts1

 
     
let  LoopCtrl  :: 


 
     
   | 

Ide := Exp1 to Exp1 OptExp2

 
     
   | 

while Exp

 
     
   | 

until Exp

 
     
let  Cases  :: 


 
     
   | 

Case Cases

 
     
let  Case  :: 

Exps : Stmt


 
     
   | 

otherwise : Stmt

 
     
let  Stmt  :: 

alias Ide for Ide Quals ; Stmts1 end_alias ;


 
     
   | 

begin Stmts1 end ;

 
     
   | 

if Exp then Stmts1 StmtsElse end_if ;

 
     
   | 

return OptExp1 ;

 
     
   | 

repeat LoopCtrl ; Stmts1 end_repeat ;

 
     
   | 

Ide Quals := Exp ;

 
     
   | 

escape ;

 
     
   | 

case Exp of Cases end_case ;

 
     
   | 

FunP APars ;

 
     
   | 

skip ;

 
     
   | 

;

 


Last update on 06 September 2010 . Authors & Credits . Feedback & Support