!PPCCodeGenerator methodsFor:'code generation'!

generateChoiceChildOf: choiceNode atIndex: choiceChildNodeIndex useGuards: useGuards storeResultInto: resultVar

    | children |

    children := choiceNode children.

    useGuards ifTrue:[

        self addGuard: (children at: choiceChildNodeIndex) ifTrue: [ 

                    compiler add: 'self clearError.'.

                    compiler 

                          codeAssignParsedValueOf:[ self visit:(children at: choiceChildNodeIndex) ]

                          to: resultVar.

                    compiler add: 'error ifFalse: [ '.

                    compiler codeReturn: resultVar.  

                    compiler add: ' ].'.

                ] ifFalse:[ 

                    compiler add: 'error := true.'.

                ].

                compiler add: 'error ifTrue:[ '.

                choiceChildNodeIndex < children size ifTrue:[ 

                    self generateChoiceChildOf: choiceNode atIndex: choiceChildNodeIndex + 1 useGuards: useGuards storeResultInto: resultVar.

                ] ifFalse:[ 

                    compiler codeError: 'no choice suitable'.

                ].

                compiler addOnLine: '].'.

    ] ifFalse:[ 

                choiceChildNodeIndex <= children size ifTrue:[ 

                    compiler add: 'self clearError.'.

                    compiler 

                          codeAssignParsedValueOf:[ self visit:(children at: choiceChildNodeIndex) ]

                          to: resultVar.

                    compiler add: 'error ifFalse: [ '.

                    compiler codeReturn: resultVar.  

                    compiler add: ' ].'.

                    self generateChoiceChildOf: choiceNode atIndex: choiceChildNodeIndex + 1 useGuards: useGuards storeResultInto: resultVar.

                ] ifFalse:[ 

                    compiler codeError: 'no choice suitable'.

                ].

    ].

!

generateSequenceChildOf: sequenceNode atIndex: sequenceNodeChildIndex useMememntoVar: mementoVar storeResultInto: elementVars

        | child childValueVar |

        child := sequenceNode children at: sequenceNodeChildIndex.

        childValueVar := elementVars at: sequenceNodeChildIndex.

        compiler codeAssignParsedValueOf: [ self visit:child ] 

                                      to: childValueVar.

        child acceptsEpsilon ifFalse: [   

            compiler codeIfErrorThen: [

                "Handle error in the first element in a special way,

                 because one does not need to do backtracking  if the first element fails."

                (sequenceNodeChildIndex == 1) ifTrue: [                         

                    compiler codeReturn: 'failure'

                ] ifFalse: [

                    compiler smartRestore: sequenceNode from: mementoVar.

                    compiler codeReturn: 'failure.'.

                ]

            ] else:[ 

                sequenceNode returnParsedObjectsAsCollection ifTrue:[

                    compiler add: self retvalVar , ' at: ', sequenceNodeChildIndex asString, ' put: ', childValueVar, '.'.

                ].

                (sequenceNodeChildIndex < sequenceNode children size) ifTrue:[ 

                    self generateSequenceChildOf: sequenceNode atIndex: sequenceNodeChildIndex + 1 useMememntoVar: mementoVar storeResultInto: elementVars.

                ].

            ]

        ] ifTrue:[

            sequenceNode returnParsedObjectsAsCollection ifTrue:[

                compiler add: self retvalVar , ' at: ', sequenceNodeChildIndex asString, ' put: ', childValueVar, '.'.

            ].

            (sequenceNodeChildIndex < sequenceNode children size) ifTrue:[ 

                    self generateSequenceChildOf: sequenceNode atIndex: sequenceNodeChildIndex + 1 useMememntoVar: mementoVar storeResultInto: elementVars.

            ].

        ]

! !

!PPCCodeGenerator methodsFor:'private'!

withAllVariableNodesOf: anRBProgramNode do: aBlock

    "Enumerate all chilren of `anRBProgramNode` (including itself)

     and evaluate `aBlock` for each variable node.

     This is a replacement for Smalltalk/X's RBProgramNode>>variableNodesDo:

     which is not present in Pharo"

    anRBProgramNode isVariable ifTrue:[ 

        aBlock value: anRBProgramNode.

        ^ self.

    ].

    anRBProgramNode children do:[:each | 

        self withAllVariableNodesOf: each do: aBlock

    ].

    "Created: / 18-06-2015 / 22:02:43 / Jan Vrany <jan.vrany@fit.cvut.cz>"

! !

        compiler 

              codeAssignParsedValueOf:[ self visit:node whitespace ]

              to:#whatever.

    ^ compiler currentReturnVariable

    "Modified: / 15-06-2015 / 18:20:37 / Jan Vrany <jan.vrany@fit.cvut.cz>"

        compiler startInline: (compiler idFor: node).

        compiler addComment: 'BEGIN inlined code of ' , node printString.

        compiler indent.

        compiler startMethod: (compiler idFor: node).

        compiler addComment: 'GENERATED by ' , node printString.

        compiler allocateReturnVariable.

    "Modified (format): / 15-06-2015 / 18:03:07 / Jan Vrany <jan.vrany@fit.cvut.cz>"

    | blockNode blockBody blockNodesVar blockNeedsCollection blockMatches childValueVars |

    blockNode := node block sourceNode copy.

    self assert: blockNode arguments size == 1.

    blockNodesVar := blockNode arguments first .

    blockBody := blockNode body.

    "Now, analyze block body, search for all references to

     block arg <barg> and check if in all cases it's used 

     in one of the following patterns:

        * <barg> first , <barg> second, ... , <barg> sixth

        * <barg> at: <integer constant>

     If so, then the block code can be inlined and the intermediate

     result collection need not to be created. Keep this information

     in temporary `blockNeedsCollection`. 

     During the analysis, remember all nodes that matches the pattern

     in a dictionary `blockMatches` mapping the node to actual temporary

     variable where the node is used. This will be later used for block's node

     rewriting"

    blockNeedsCollection := true.

    node child isSequenceNode ifTrue:[

        blockNeedsCollection := false.

        blockMatches := IdentityDictionary new."Must use IDENTITY dict as nodes have overwritten their #=!!!!!!"

        childValueVars := node child preferredChildrenVariableNames.

        self withAllVariableNodesOf: blockBody do:[:variableNode| 

            variableNode name = blockNodesVar name ifTrue:[ 

                "Check if variable node matches..."

                variableNode parent isMessage ifTrue:[ 

                    | parent |

                    parent := variableNode parent.

                    "Check for <barg> at: <number>"

                    ((parent selector == #at:) and:[ parent arguments first isLiteralNumber ]) ifTrue:[ 

                        blockMatches at: parent put: (childValueVars at: parent arguments first value).

                    ] ifFalse:[ 

                        "Check for <barg> first / second / ..."

                        | i |

                        i := #(first second third fourth fifth sixth) indexOf: parent selector.

                        i ~~ 0 ifTrue:[ 

                            blockMatches at: parent put: (childValueVars at: i).

                        ] ifFalse:[ 

                            blockNeedsCollection := true.

                        ].

                    ].

                ] ifFalse:[ 

                    blockNeedsCollection := true.

                ].

            ].

        ].

    ].

    blockNeedsCollection ifTrue:[

        "Bad, we have to use the collection.

         Replace all references to blockNodeVar to retvalVar..."

        self withAllVariableNodesOf: blockBody do:[:variableNode| 

            variableNode name = blockNodesVar name ifTrue:[ 

                variableNode name: self retvalVar.

            ].

        ].

    ] ifFalse:[ 

        "Good, can avoid intermediate collection.

         Replace references to collection with corresponding temporary variable"

        blockMatches keysAndValuesDo:[:matchingNode :childValueVar |

            matchingNode parent replaceNode: matchingNode withNode: (RBVariableNode named: childValueVar).

        ].

        node child returnParsedObjectsAsCollection: false. 

    ].

    "Block return value is return value of last statement.

     So if the method is not inline, make last statement a return.

        if the method is inline, make it assignment to retvalVar."

    blockBody statements notEmpty ifTrue:["Care for empty blocks - [:t | ] !!"

        compiler currentMethod isInline ifTrue:[ 

            |  assignment |

            assignment := RBAssignmentNode variable: (RBVariableNode named: self retvalVar) value:  blockBody statements last.

            blockBody replaceNode: blockBody statements last withNode: assignment.

        ] ifFalse:[  

            | return |

            return := RBReturnNode value: blockBody statements last.

            blockBody replaceNode: blockBody statements last withNode: return.

        ].

    ].

    compiler codeAssignParsedValueOf:[ self visit:node child ] to:self retvalVar.

    compiler codeIfErrorThen: [ 

        compiler codeReturn: 'failure'. 

    ] else: [

        compiler code: blockBody.    

    ]

    "Modified: / 19-06-2015 / 07:05:35 / Jan Vrany <jan.vrany@fit.cvut.cz>"

    compiler 

          codeAssignParsedValueOf:[ self visit:node child ]

          to:self retvalVar.

    |  whitespaceConsumed useGuards resultVar  |

    resultVar := compiler allocateTemporaryVariableNamed: 'element'.

    whitespaceConsumed := self addGuardTrimming: node.

    useGuards := whitespaceConsumed.

    self generateChoiceChildOf: node atIndex: 1 useGuards: useGuards storeResultInto: resultVar

    "Modified: / 29-05-2015 / 07:17:36 / Jan Vrany <jan.vrany@fit.cvut.cz>"