dts.peg

package main

import "github.com/Archs/dtsparser/dts"

type Parser Peg {
	dts.DTS
}

start
	<- space (ModuleDeclaration 
	          / ClassDeclaration 
	          / InterfaceDeclaration
	          / EnumDeclaration
	          / ObjDeclaration
	          / AssignmentDeclaration
	          / VariableDeclaration
	          / FuncDeclaration )+ eof

ModuleDeclaration
	<- ModuleModifier ModuleIdentifier ModuleBody { p.EndBlock("module") }

ModuleModifier
	<- <modifier?>  { p.NewBlock(text, "Module") }

ModuleIdentifier
	<- 'module' space <fakeIdentifier> { p.SetBlockID(text) }

ModuleBody
	<- block_start 
		   (ClassDeclaration
		   	/ InterfaceDeclaration
		   	/ ModuleDeclaration
		   	/ EnumDeclaration
			/ ObjDeclaration
			/ VariableDeclaration
			/ FuncDeclaration
			/ AssignmentDeclaration)*
	   block_end

ClassDeclaration
	<- ClassModifier ClassIdentifier ExtendClause? ImplementClause? ClassBody 
	   { p.EndBlock("class") }

ClassModifier
	<- <modifier?>  { p.NewBlock(text, "Class") }

ClassIdentifier
	<- 'class' space <GenericIdentifier> { p.SetBlockID(text) }

ClassBody
	<- block_start
			(ObjDeclaration / VariableDeclaration / FuncDeclaration)* 
	   block_end

InterfaceDeclaration
	<- InterfaceModifier InterfaceIdentifier ExtendClause? InterfaceBody 
	   { p.EndBlock("interface") }

InterfaceModifier
	<- <modifier?>  { p.NewBlock(text, "Interface") }

InterfaceIdentifier
	<- 'interface' space <GenericIdentifier> { p.SetBlockID(text) }

InterfaceBody
	<- block_start
			(ObjDeclaration
			 / VariableDeclaration 
			 / FuncDeclaration 
			 / (FuncType end)
			 / IndexDeclaration)* 
	   block_end

EnumDeclaration
	<- EnumModifier EnumIdentifier EnumBody { p.EndBlock("enum") }

EnumModifier
	<- <modifier?>  { p.NewBlock(text, "Enum") }

EnumIdentifier
	<- 'enum' space <Identifier> { p.SetBlockID(text) }

EnumBody
	<- block_start
			AssignmentDifinition (and AssignmentDifinition)*
	   block_end

ObjDeclaration
	<- ObjModifier ObjIdentifier hasType ObjBody (space '[]')* end { p.EndBlock("obj") }

ObjModifier
	<- <modifier?>  { p.NewBlock(text, "Obj") }

ObjIdentifier
	<- <Identifier> { p.SetBlockID(text) }

ObjBody
	<- block_start
			(ObjDeclaration 
			/ FuncDeclaration 
			/ VariableDeclaration 
			/ (FuncType end))*
	   block_end

AssignmentDeclaration
	<- AssignmentDifinition end

AssignmentDifinition
	<- assignmentModifier? Identifier? equals AssignmentValue

assignmentModifier
	<- (('declare' / 'export' / 'private' / 'static' 
	    / 'import' / "var" / "function" / 'type') space)+

AssignmentValue
	<- Value (or Value)* 

IndexDeclaration
	<- square_start
			VariableDifinition
	   square_end
	   hasType
	   Type
	   end

ExtendClause
	<- space 'extends' space <GenericIdentifier (and GenericIdentifier)*> {p.Extends(text)}

ImplementClause
	<- space 'implements' space <Identifier (and Identifier)*>            {p.Implements(text)}

VariableDeclaration
	<- <VdModifier VdIdentifier hasType VdType> end {p.EndVariable(text)}

VdModifier
	<- <modifier?>       {p.NewVariable(text)}

VdIdentifier
	<- <Identifier?>     {p.VSetIdentifier(text)}

VdType
	<- <Type>            {p.VSetType(text)}

VariableDifinition
	<- Identifier? hasType Type

FuncDeclaration
	<- <FdModifier FdIdentifier FdType> end      {p.EndFunction(text)}

FdModifier
	<- <modifier?>                               {p.NewFunction(text)}

FdIdentifier
	<- <Identifier>                              {p.FSetIdentifier(text)}

FdType
	<- GenericForm? paren_start 
			FuncArgDifinition? (and FuncArgDifinition)*
	   paren_end 
	   (( return / hasType) <Type>)?     {p.FSetType(text)}                        

FuncArgDifinition
	<- <FadIdentifier hasType FadType>    {p.EndArg(text)}

FadIdentifier 
	<- <Identifier?>                      {p.NewArg(text)}

FadType
	<- <Type>                             {p.VSetType(text)}    

Type
	<- ('typeof' space)? (BasicType (or BasicType)*)

GenericIdentifier
	<- Identifier GenericForm?

GenericType
	<- Identifier GenericForm

GenericForm
	<- g_start
	   	genericDecl (and genericDecl)*
	   g_end

genericDecl
	<- Type (space 'extends' space Type)?

BasicType
	<- ArrayType
		/ GenericType
		/ FixedArrayType
		/ ObjectType 
		/ ParenFunc
		/ FuncType 
		/ "number" 
		/ "boolean"
		/ "string"
		/ "function"
		/ "any"
		/ LiteralType
		/ Identifier

ParenFunc
	<- paren_start 
			FuncType
	   paren_end 

FuncType
	<- GenericForm? paren_start 
			VariableDifinition? (and VariableDifinition)*
	   paren_end 
	   (( return / hasType) Type)?

FixedArrayType
	<- square_start
			Type (and Type)*
	   square_end

ArrayType
	<-  (GenericType
		/ FixedArrayType
		/ ObjectType 
		/ ParenFunc
		/ FuncType 
		/ "number" 
		/ "boolean"
		/ "string"
		/ "function"
		/ "any"
		/ LiteralType
		/ Identifier) '[]'+

ObjectType
	<- block_start
			((ObjectKey hasType Type end)
			 / FuncDeclaration
			 / FuncType end)*
	   block_end

ObjectKey
	<- Identifier / SquareKey

SquareKey
	<- square_start
			Identifier hasType Type
	   square_end   

LiteralType
	<- String

keywords
	<- 'module' / 'class' / 'interface' / 'extends' / 'implements'
		/ 'boolean' / 'number' / 'string' / 'void'

modifier
	<- (('declare' / 'export' / 'private' / 'static' 
	    / 'import' / "var" / "function") space)+

fakeIdentifier
	<- ([[A-Z]]/[_.$'"]) ([[A-Z]]/[0-9]/[_?.$<>'"])*

Identifier
	<- ([[A-Z]]/[_.$]) ([[A-Z]]/[0-9]/[_?.$])*

Value
	<- FuncCall / Type / Number / String

# Value for function call
FuncCall
	<- Identifier
	   paren_start
	   		Value (and Value)*
	   paren_end

Number
	<- [+-]? [0-9] [.]? [0-9]*

String
	<- ['] ( [[A-Z]] / [_.$] ) ( [[A-Z]] / [0-9]  /[_?.$<>] / '-' )* [']
	  /["] ( [[A-Z]] / [_.$] ) ( [[A-Z]] / [0-9]  /[_?.$<>] / '-' )* ["]


separator
	<- [:;(){},\[\]=>]

return
	<- space '=>' space

hasType
	<- space ':' space

equals
	<- space '=' space

or
	<- space '|' space

and
	<- space ',' space

end
	<- ((';' / eol)? space)?

block_start
	<- space '{' space

block_end
	<- space '}' space

paren_start
	<- space '(' space

paren_end
	<- space ')' space

square_start
	<- space '[' space

square_end
	<- space ']' space

g_start
	<- space '<' space

g_end
	<- space '>' space

space
	<- spacing* 

comment
	<- lineComment / blockComment

lineComment
	<- '//' (!eol .)* eol

blockComment
	<- '/*' (!'*/' .)* '*/'

ws				<- [ \t\n\r]
spacing         <- [ \t\n\r] / comment
eol             <- '\n'
eof             <- !.