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

"{ NameSpace: Smalltalk }"

PPAbstractParserTest subclass:#PPCTokenizingCodeGeneratorTest

	instanceVariableNames:'visitor node result compiler parser context choiceNode tokenizer

		arguments'

	classVariableNames:''

	poolDictionaries:''

	category:'PetitCompiler-Tests-Visitors'

!

!PPCTokenizingCodeGeneratorTest methodsFor:'as yet unclassified'!

assert: whatever parse: input

	result := super assert: whatever parse: input.

!

assert: whatever recognizesToken: input

	whatever startSymbol: #nextToken.

	self assert: whatever parse: input.

	self assert: (result isKindOf: PPToken).

	whatever startSymbol: #start

!

compileTokenizer: aNode

	tokenizer := visitor visit: aNode	

!

compileTree: root

	| configuration |

	configuration := PPCPluggableConfiguration on: [ :_self | 

		result := (visitor visit: _self ir).

		compiler compileParser startSymbol: result methodName.

		parser := compiler compileParser new.

		_self ir: parser

	].

	parser := configuration compile: root arguments: arguments.

!

context	

	^ context := PPCProfilingContext new

!

literalNode: literal

	^ PPCLiteralNode new

		literal: literal;

		yourself

!

setUp

	arguments := PPCArguments default

		profile: true;

		yourself.	

	compiler := PPCCompiler new.

	compiler arguments: arguments.

	visitor := PPCTokenizingCodeGenerator new.

	visitor compiler: compiler.

!

tearDown

	| class |

	class := (Smalltalk at: #PPGeneratedParser ifAbsent: [nil]).

	class notNil ifTrue:[ 

		class removeFromSystem

	].

!

testSimpleChoice1

	| token1 token2 token1Consume token2Consume  tokenizerNode eof |

	token1 := (self tokenNodeForLiteral: 'foo') markForInline; yourself.

	token2 := (self tokenNodeForLiteral: 'bar') markForInline; yourself.

	eof := (self tokenNodeForEOF) markForInline; yourself.

	token1Consume := PPCTokenConsumeNode new

							child: token1;

							yourself.

	token2Consume := PPCTokenConsumeNode new

							child: token2;

							yourself.

	choiceNode := PPCLLChoiceNode new

		children: { token1Consume . token2Consume };

		yourself.

	tokenizerNode := PPCChoiceNode new

		children: { token1 . token2 . eof };

		name: 'nextToken';

		yourself.

	self compileTokenizer: tokenizerNode.

	self compileTree: choiceNode.

	self assert: parser recognizesToken: 'foo'.

	self assert: parser recognizesToken: 'bar'.

	self assert: parser recognizesToken: ''.

	parser := compiler compiledParser new.

	self assert: parser parse: 'foo'.

	self assert: result inputValue = 'foo'.

	parser := compiler compiledParser new.

	self assert: parser parse: 'bar'.

	self assert: result inputValue = 'bar'.

	parser := compiler compiledParser new.

	self assert: parser fail: 'baz'.	

!

tokenNode: child

	^ PPCTokenNode new

		child: child;

		tokenClass: PPToken;

		yourself

!

tokenNodeForEOF

	| eof |

	eof := PPCEndOfFileNode new

		yourself.

	^ PPCTokenNode new

		child: eof;

		tokenClass: PPToken;

		yourself.

!

tokenNodeForLiteral: literal

	| literalNode |

	literalNode := self literalNode: literal.

	^ self tokenNode: literalNode

! !