"{ Package: 'stx:goodies/petitparser/compiler/tests/extras' }"

"{ NameSpace: Smalltalk }"

PPCompositeParser subclass:#PPCLRPParser
	instanceVariableNames:'program variable block bra ket identifier machine body event
		transition epsilon wildcard state onentry running onexit comment
		lineTerminator statebody spawn integer errorNode success failed
		lastError styler timeoutIdentifier timeoutInteger endOfComment'
	classVariableNames:''
	poolDictionaries:''
	category:'PetitCompiler-Extras-Tests-LRP'
!

!PPCLRPParser class methodsFor:'accessing'!

ignoredNames

    ^super ignoredNames , #(styler failed lastError)
! !

!PPCLRPParser methodsFor:'accessing'!

error
    ^super error

    "Modified: / 30-07-2015 / 17:12:19 / Jan Vrany <jan.vrany@fit.cvut.cz>"
!

failed
    ^failed
!

lastError
    ^lastError
!

start
    ^program end
!

styler: aSHStyler

    styler := aSHStyler.
!

success
    ^success
! !

!PPCLRPParser methodsFor:'block creation'!

createSTBlockFrom: aBlockNode withVariables: aDictionary
    |compiled retval keys|
    
    keys := OrderedCollection new: aDictionary size.
    aDictionary associations do: [:asoc|
        keys add: asoc key.
    ].

    compiled := (self methodizeBlock: aBlockNode withArguments: keys) compiledMethod.
    retval := compiled valueWithReceiver: Object new arguments: {aDictionary}.

    ^retval.
!

methodizeBlock: parsedBlock withArguments: anArray
    
    |method retval inspoint|
    
    method := 'captureV: PPCLRPScopeVariables'.
     
    retval := PPSmalltalkParser new method parse: method , '^[1]'.
    inspoint := retval body statements first.
    parsedBlock scope: inspoint value scope.
    parsedBlock parent: inspoint.
    inspoint value: parsedBlock.
    retval source: retval asString.
    
    anArray do: [:aVarName|
        retval := retval rewritePPCLRPVarNamedWrite: aVarName.
        retval := retval rewritePPCLRPVarNamedRead: aVarName.
    ].
    ^retval
! !

!PPCLRPParser methodsFor:'error handing'!

failWithValue: anObject

    failed := true.
    lastError := anObject.
! !

!PPCLRPParser methodsFor:'grammar'!

body
    ^(variable / event / state / transition / timeoutIdentifier / timeoutInteger / epsilon / wildcard / comment / errorNode) star
!

errorNode
    ^(bra,  (bra/ket)negate star , ket) 
        ==> [ :tokens |  
                PPCLRPErrorNode new start: tokens first start stop: tokens last stop; yourself.
            ]
!

event
    ^ (bra, 'event' asParser trim, identifier, block,  ket)  
        ==> [:tokens | | ident |
                ident := (tokens at: 3).
                (PPCLRPEvent named: ident inputValue 
                     trigger: (tokens  at: 4))
                start: tokens first start stop: tokens last stop;
                nameRange: (ident start to: ident stop);
                yourself.
            ]
!

integer 
    ^(#digit asParser) plus flatten trim token
!

machine
    ^(bra , 'machine' asParser trim , identifier , body , ket) 
        ==> [:tokens | | ident bod stop |
                ident := (tokens at: 3).
                bod := (tokens at: 4).
                bod isEmpty
                    ifTrue: [ stop := tokens last stop - 1 ]
                 	ifFalse: [ stop := (bod at: 1) start - 1 ].
                (PPCLRPMachine name: ident inputValue body: bod)
                    start: (tokens first start) stop: (tokens last stop);
                    nameRange: (ident start to: stop);
                    yourself.
            ]
!

onentry
    ^ (bra, 'onentry' asParser trim, (block/spawn) ,  ket ) 
        ==> [:tokens | 
                (PPCLRPOnEntry block: (tokens at: 3))
                start: (tokens first start) stop: (tokens last stop);
                keywordEnd: (tokens at: 3) start -1;
                yourself.
            ]
!

onexit
    ^ (bra, 'onexit' asParser trim, (block/spawn),  ket)  
        ==> [:tokens | 
                (PPCLRPOnExit block: (tokens at: 3))
                start: (tokens first start) stop: (tokens last stop);
                keywordEnd: (tokens at: 3) start -1;
                yourself.
            ]
!

program
    ^ (variable / machine / comment / spawn / errorNode) star
!

running
    ^ (bra, 'running' asParser trim, (block/spawn),  ket)  
        ==> [:tokens | 
                (PPCLRPRunning block: (tokens at: 3))
                start: (tokens first start) stop: (tokens last stop);
                keywordEnd: (tokens at: 3) start -1;
                yourself.
            ]
!

spawn
    ^(bra , 'spawn' asParser trim , identifier , identifier , ket) 
        ==> [ :tokens |  
                (PPCLRPSpawn
                    machine: (tokens at: 3) parsedValue
                    state: (tokens at: 4) parsedValue)
                start: (tokens first start) stop: (tokens last stop);
                nameRange: ((tokens at: 3) start to: (tokens at: 4) stop)
                yourself.
            ]
        
!

state
    ^(bra , 'state' asParser trim , identifier , statebody , ket) 
        ==> [ :tokens | | ident |
                ident := (tokens at: 3).
                (PPCLRPState name: ident inputValue
                    body: (tokens at: 4))
                start: (tokens first start) stop: (tokens last stop);
                nameRange: (ident start to: ident stop);
                yourself.
            ]
        
!

statebody
    ^(onentry / running / onexit / machine / comment / errorNode) star
        
!

variable
    ^ (bra , 'var' asParser trim , identifier , ':=' asParser trim , block , ket) 
        ==> [ :tokens | |ident|
            ident := (tokens at: 3).
            (PPCLRPVariable name: ident inputValue value: (tokens at: 5))
                start: (tokens first start) stop: (tokens last stop);
                nameRange: (ident start to: ident stop);
                yourself.
        ]
! !

!PPCLRPParser methodsFor:'grammar-comments'!

comment
    ^ ( $; asParser token , (endOfComment negate star) flatten,  endOfComment token) trim 
    ==> [ :tokens |  |text|
            text := tokens  at: 2.
                (PPCLRPComment text: (text copyFrom: 1 to: text size -1))
                start: (tokens first start) stop: (tokens last stop);
                yourself.
        ]
!

endOfComment
    ^ #eof asParser / lineTerminator
!

lineTerminator

    ^ (Character lf asParser) / (Character cr asParser , (Character lf asParser ) optional )
! !

!PPCLRPParser methodsFor:'grammar-common'!

block
    ^PPSmalltalkParser new block
!

bra
    ^ $( asParser token trim
!

identifier 
    ^(#letter asParser , (#word asParser /  $_ asParser) star) flatten token trim
!

ket
    ^ $) asParser token trim
! !

!PPCLRPParser methodsFor:'grammar-transitions'!

epsilon
    ^ (bra, 'eps' asParser trim, identifier, '->' asParser trim, identifier,  identifier optional, ket) 
        ==> [ :tokens |  | trans name |
                name := (tokens at: 6).
                name ifNil: [name := '' ] ifNotNil: [ name := name inputValue ].
                trans := 
                    (PPCLRPEpsilonTransition
                        from: (tokens at: 3) inputValue
                        to: (tokens at: 5) inputValue
                        name: name).
                self setTransitionRangesIn: trans for: tokens withArrowAt: 3. 
                trans
        ]
!

timeoutIdentifier
    ^ (bra, 'ontime' asParser trim, identifier , identifier, '->' asParser trim, identifier,  identifier optional, ket)
        ==> [:tokens | self transitionActionHandlerFor: PPCLRPTimeoutTransition tokens: tokens ].

    "Modified: / 30-07-2015 / 17:14:45 / Jan Vrany <jan.vrany@fit.cvut.cz>"
!

timeoutInteger
    ^ (bra, 'ontime' asParser trim,  integer, identifier, '->' asParser trim, identifier,  identifier optional, ket)
        ==> [ :tokens | | trans name |
        name := (tokens at: 7).
        name ifNil: [name := '' ] ifNotNil: [ name := name inputValue ].
        trans :=
            (PPCLRPTimeoutTransition
                on: (Integer readFrom: (tokens at: 3) inputValue)
                from: (tokens at: 4) inputValue
                to: (tokens at: 6) inputValue
                name: name).
        self setTransitionRangesIn: trans for: tokens withArrowAt: 4.
        trans.
    ]
!

transition
    ^ (bra, 'on' asParser trim, identifier, identifier, '->' asParser trim, identifier,  identifier optional , ket) 
        ==> [ :tokens | self transitionActionHandlerFor: PPCLRPTransition tokens: tokens ]

    "Modified: / 30-07-2015 / 17:15:13 / Jan Vrany <jan.vrany@fit.cvut.cz>"
!

wildcard
    ^ (bra, 'on' asParser trim, identifier,  '*->' asParser trim, identifier,  identifier optional, ket) 
        ==> [ :tokens |  | trans name |
                name := (tokens at: 6).
                name ifNil: [name := '' ] ifNotNil: [ name := name inputValue ].
                trans :=
                    (PPCLRPWildcardTransition
                        on: (tokens at: 3) inputValue
                        to: (tokens at: 5) inputValue
                        name: name ).
                self setTransitionRangesIn: trans for: tokens withArrowAt: 3. 
                trans
            ]
        
! !

!PPCLRPParser methodsFor:'parsing'!

parse: aText styleOn: aViewOrMorph
    |parsedProgram|
    
    parsedProgram := self parsePPCLRP: aText.
    self styler view: aViewOrMorph; parser: self; nodes: parsedProgram; style: aText.
    
    ^parsedProgram.
!

parsePPCLRP: aString

    |parsedProgram |
    failed := false.
    parsedProgram := self parse: aString.
    
    parsedProgram isPetitFailure ifTrue:[
        parsedProgram := 
            {PPCLRPErrorNode new 
                start: 1;
                stop: aString size; 
                yourself.
            }
    ].
    
    "visit pattern?"
    parsedProgram do:[:aNode|
        (aNode onErrorNode: [:anErrorNode| ] parser: self)
    ].
    
    ^parsedProgram.
! !

!PPCLRPParser methodsFor:'transitions'!

setTransitionRangesIn: aTransition for: aTokenArray withArrowAt: index
    | ident |
    ident := (aTokenArray at: index + 3).
    ident
        ifNil: [ aTransition nameRange: (1 to: 1) ]
        ifNotNil: [ aTransition nameRange: (ident start to: ident stop) ].
    aTransition
        start: (aTokenArray first start) stop: (aTokenArray last stop);
        arrowRange:
                    ((aTokenArray at: index) stop + 1
                        to: (aTokenArray at: index + 2) start -1);
        keywordEnd: (aTokenArray at: 3) start -1
!

transitionActionHandlerFor: class tokens: tokens
    | trans name|
    name := (tokens  at: 7).
    name isNil ifTrue:[ name := '' ] ifFalse:[ name := name inputValue ].
    trans :=
        (class
            on: (tokens at: 3) inputValue
            from: (tokens at: 4) inputValue
            to: (tokens at: 6) inputValue
            name: name).
    self setTransitionRangesIn: trans for: tokens withArrowAt: 4.
    ^ trans.

    "Created: / 30-07-2015 / 17:12:55 / Jan Vrany <jan.vrany@fit.cvut.cz>"
! !