SystemOrganization addCategory: #'PetitBeta-Processor'!
SystemOrganization addCategory: #'PetitBeta-JIT'!
SystemOrganization addCategory: #'PetitBeta-Compiler'!
SystemOrganization addCategory: #'PetitBeta-Tests'!

PPParser subclass: #PPCompiledParser
	instanceVariableNames: ''
	classVariableNames: ''
	poolDictionaries: ''
	category: 'PetitBeta-Compiler'!

!PPCompiledParser methodsFor: 'parsing' stamp: 'lr 8/8/2010 12:17'!
parseOn: aStream
	^ self parseStartOn: aStream! !

PPCompiledParser subclass: #PPTestParser
	instanceVariableNames: ''
	classVariableNames: ''
	poolDictionaries: ''
	category: 'PetitBeta-Compiler'!

!PPTestParser methodsFor: 'generated-utilities' stamp: 'lr 8/8/2010 13:17'!
create: aCollection start: aStartInteger stop: aStopInteger
	^ self tokenClass on: aCollection start: aStartInteger stop: aStopInteger! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseArrayItemOn: aStream
	| element |
	element := self parseNumberLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseStringLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseCharLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseArrayLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseByteLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseSymbolLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseNilLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseTrueLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseFalseLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseSymbolLiteralArrayOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseArrayLiteralArrayOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseByteLiteralArrayOn: aStream.
	^ element! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseArrayLiteralArrayOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 3.
	element := self parseUnnamed0072On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0073On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	element := self parseUnnamed0074On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 3 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseArrayLiteralOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 3.
	element := self parseUnnamed0046On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0047On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	element := self parseUnnamed0048On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 3 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:56'!
parseArrayOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 3.
	element := self parseUnnamed0125On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseStatementsOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	element := self parseUnnamed0126On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 3 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseAssignmentOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseVariableOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseAssignmentTokenOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 13:17'!
parseAssignmentTokenOn: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:56'!
parseBinaryExpressionOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnaryExpressionOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0103On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:56'!
parseBinaryMessageOn: aStream
	| element |
	^ (element := self parseUnnamed0129On: aStream) isPetitFailure
		ifFalse: [ 
			| nodes |
			nodes := element.
			Array with: (Array with: nodes first) with: (Array with: nodes second) ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseBinaryMethodOn: aStream
	| element |
	^ (element := self parseUnnamed0007On: aStream) isPetitFailure
		ifFalse: [ 
			| nodes |
			nodes := element.
			Array with: (Array with: nodes first) with: (Array with: nodes second) ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseBinaryOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnnamed0008On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0009On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseBinaryPragmaOn: aStream
	| element |
	^ (element := self parseUnnamed0082On: aStream) isPetitFailure
		ifFalse: [ 
			| nodes |
			nodes := element.
			Array with: (Array with: nodes first) with: (Array with: nodes second) ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 13:17'!
parseBinaryTokenOn: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:56'!
parseBlockArgumentOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnnamed0111On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseVariableOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseBlockArgumentsOn: aStream
	| element |
	element := self parseBlockArgumentsWithOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseBlockArgumentsWithoutOn: aStream.
	^ element! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:56'!
parseBlockArgumentsWithOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnnamed0109On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0110On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:56'!
parseBlockArgumentsWithoutOn: aStream
	| element |
	^ (element := self parseUnnamed0119On: aStream) isPetitFailure
		ifFalse: [ 
			| nodes |
			nodes := element.
			Array with: #() with: nil ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseBlockBodyOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseBlockArgumentsOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseSequenceOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:56'!
parseBlockOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 3.
	element := self parseUnnamed0106On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseBlockBodyOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	element := self parseUnnamed0107On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 3 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseByteLiteralArrayOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 3.
	element := self parseUnnamed0077On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0078On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	element := self parseUnnamed0079On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 3 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseByteLiteralOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 3.
	element := self parseUnnamed0051On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0052On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	element := self parseUnnamed0053On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 3 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:56'!
parseCascadeExpressionOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseKeywordExpressionOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0102On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:56'!
parseCascadeMessageOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnnamed0133On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseMessageOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 13:17'!
parseCharLiteralOn: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseCharOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnnamed0044On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0045On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-utilities' stamp: 'lr 8/8/2010 12:53'!
parseComments: anArray on: aStream
	| start comments |
	comments := anArray.
	[ [ aStream atEnd not and: [ aStream peek isSeparator ] ]
		whileTrue: [ aStream next ].
	  aStream peek = $" ] whileTrue: [
		aStream next.
		start := aStream position.
		aStream upTo: $".
		comments := comments copyWith: (start to: aStream position) ].
	^ comments! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:56'!
parseExpressionOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnnamed0098On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseCascadeExpressionOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 13:17'!
parseFalseLiteralOn: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseIdentifierOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnnamed0003On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0004On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:56'!
parseKeywordExpressionOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 3.
	element := self parseUnaryExpressionOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0103On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	element := self parseUnnamed0104On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 3 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:56'!
parseKeywordMessageOn: aStream
	| element |
	^ (element := self parseUnnamed0131On: aStream) isPetitFailure
		ifFalse: [ 
			| nodes |
			nodes := element.
			Array with: (nodes collect: [ :each | each first ]) with: (nodes collect: [ :each | each second ]) ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseKeywordMethodOn: aStream
	| element |
	^ (element := self parseUnnamed0001On: aStream) isPetitFailure
		ifFalse: [ 
			| nodes |
			nodes := element.
			Array with: (nodes collect: [ :each | each first ]) with: (nodes collect: [ :each | each second ]) ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseKeywordOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 3.
	element := self parseUnnamed0003On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0004On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	element := self parseUnnamed0005On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 3 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseKeywordPragmaOn: aStream
	| element |
	^ (element := self parseUnnamed0018On: aStream) isPetitFailure
		ifFalse: [ 
			| nodes |
			nodes := element.
			Array with: (nodes collect: [ :each | each first ]) with: (nodes collect: [ :each | each second ]) ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 13:17'!
parseKeywordTokenOn: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseMessageOn: aStream
	| element |
	element := self parseKeywordMessageOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseBinaryMessageOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseUnaryMessageOn: aStream.
	^ element! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseMethodDeclarationOn: aStream
	| element |
	element := self parseKeywordMethodOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseUnaryMethodOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseBinaryMethodOn: aStream.
	^ element! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseMethodOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseMethodDeclarationOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseMethodSequenceOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseMethodSequenceOn: aStream
	| element |
	^ (element := self parseUnnamed0011On: aStream) isPetitFailure
		ifFalse: [ 
			| nodes |
			nodes := element.
			Array with: nodes second , nodes fourth with: nodes third with: nodes fifth ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseMultiwordOn: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	(element := self parseKeywordOn: aStream) isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements addLast: element.
	[ 
	(element := self parseKeywordOn: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 13:17'!
parseNilLiteralOn: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 13:17'!
parseNumberLiteralOn: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseNumberOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnnamed0020On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0021On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:56'!
parseParensOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 3.
	element := self parseUnnamed0121On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseExpressionOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	element := self parseUnnamed0122On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 3 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parsePragmaMessageOn: aStream
	| element |
	element := self parseKeywordPragmaOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseUnaryPragmaOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseBinaryPragmaOn: aStream.
	^ element! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parsePragmaOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 3.
	element := self parseUnnamed0015On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parsePragmaMessageOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	element := self parseUnnamed0016On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 3 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parsePragmasOn: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parsePragmaOn: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parsePrimaryOn: aStream
	| element |
	element := self parseNumberLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseStringLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseCharLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseArrayLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseByteLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseSymbolLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseNilLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseTrueLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseFalseLiteralOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseVariableOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseBlockOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseParensOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseArrayOn: aStream.
	^ element! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseSequenceOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseTemporariesOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseStatementsOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseStartOn: aStream
	| position result |
	position := aStream position.
	result := self parseMethodOn: aStream.
	(result isPetitFailure or: [ aStream atEnd ])
		ifTrue: [ ^ result ].
	result := PPFailure message: 'end of input expected' at: aStream position.
	aStream position: position.
	^ result! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseStatementsOn: aStream
	| element |
	element := self parseUnnamed0092On: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseUnnamed0093On: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseUnnamed0094On: aStream.
	^ element! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 13:17'!
parseStringLiteralOn: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseStringOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 3.
	element := self parseUnnamed0034On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0035On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	element := self parseUnnamed0036On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 3 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 13:17'!
parseSymbolLiteralArrayOn: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 13:17'!
parseSymbolLiteralOn: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseSymbolOn: aStream
	| element |
	element := self parseUnaryOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseBinaryOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseMultiwordOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseStringOn: aStream.
	^ element! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseTemporariesOn: aStream
	| element |
	^ (element := self parseUnnamed0084On: aStream) isPetitFailure
		ifFalse: [ element ifNil: [ #() ] ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 13:17'!
parseTrueLiteralOn: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:56'!
parseUnaryExpressionOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parsePrimaryOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0105On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseUnaryMessageOn: aStream
	| element |
	^ (element := self parseUnaryTokenOn: aStream) isPetitFailure
		ifFalse: [ 
			| node |
			node := element.
			Array with: (Array with: node) with: Array new ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseUnaryMethodOn: aStream
	| element |
	^ (element := self parseVariableOn: aStream) isPetitFailure
		ifFalse: [ 
			| node |
			node := element.
			Array with: (Array with: node) with: Array new ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseUnaryOn: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 3.
	element := self parseUnnamed0003On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0004On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	element := self parseUnnamed0058On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 3 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 12:53'!
parseUnaryPragmaOn: aStream
	| element |
	^ (element := self parseVariableOn: aStream) isPetitFailure
		ifFalse: [ 
			| node |
			node := element.
			Array with: (Array with: node) with: Array new ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 13:17'!
parseUnaryTokenOn: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0001On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	(element := self parseUnnamed0002On: aStream) isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements addLast: element.
	[ 
	(element := self parseUnnamed0002On: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0002On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseKeywordTokenOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseVariableOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0003On: aStream
	^ (aStream atEnd not and: [ aStream peek isLetter ])
		ifFalse: [ PPFailure message: 'letter expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0004On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parseUnnamed0006On: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0005On: aStream
	^ (aStream atEnd not and: [ aStream peek = $: ])
		ifFalse: [ PPFailure message: '$: expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0006On: aStream
	^ (aStream atEnd not and: [ aStream peek isAlphaNumeric ])
		ifFalse: [ PPFailure message: 'letter or digit expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0007On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseBinaryTokenOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseVariableOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0008On: aStream
	^ (aStream atEnd not
		and: [ 
			| each |
			each := aStream peek.
			'!!%&*+,-/<=>?@\|~' includes: each ])
		ifFalse: [ PPFailure message: 'any of ''!!%&*+,-/<=>?@\|~'' expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0009On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parseUnnamed0010On: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0010On: aStream
	^ (aStream atEnd not
		and: [ 
			| each |
			each := aStream peek.
			'!!%&*+,/<=>?@\|~' includes: each ])
		ifFalse: [ PPFailure message: 'any of ''!!%&*+,/<=>?@\|~'' expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0011On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 5.
	element := self parseUnnamed0012On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parsePragmasOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	element := self parseTemporariesOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 3 put: element.
	element := self parsePragmasOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 4 put: element.
	element := self parseStatementsOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 5 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0012On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parseUnnamed0013On: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0013On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0014On: aStream
	^ (aStream atEnd not and: [ aStream peek = $. ])
		ifFalse: [ PPFailure message: '$. expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0015On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0016On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0017On: aStream
	^ (aStream atEnd not and: [ aStream peek = $< ])
		ifFalse: [ PPFailure message: '$< expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0018On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	(element := self parseUnnamed0019On: aStream) isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements addLast: element.
	[ 
	(element := self parseUnnamed0019On: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0019On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseKeywordTokenOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseArrayItemOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0020On: aStream
	| element position |
	position := aStream position.
	element := self parseUnnamed0022On: aStream.
	aStream position: position.
	^ element! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0021On: aStream
	| position result |
	position := aStream position.
	result := [ :stream | [ Number readFrom: stream ] on: Error do: [ :err | PPFailure message: err messageText at: stream position ] ] value: aStream.
	result isPetitFailure
		ifTrue: [ aStream position: position ].
	^ result! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0022On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 3.
	element := self parseUnnamed0023On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0024On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	element := self parseUnnamed0025On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 3 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0023On: aStream
	| element |
	element := self parseUnnamed0026On: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseUnnamed0027On: aStream.
	^ element! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0024On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	(element := self parseUnnamed0028On: aStream) isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements addLast: element.
	[ 
	(element := self parseUnnamed0028On: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0025On: aStream
	| element |
	element := self parseUnnamed0029On: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseUnnamed0030On: aStream.
	^ element! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0026On: aStream
	^ (aStream atEnd not and: [ aStream peek = $- ])
		ifFalse: [ PPFailure message: '$- expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0027On: aStream
	^ nil! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0028On: aStream
	^ (aStream atEnd not and: [ aStream peek isDigit ])
		ifFalse: [ PPFailure message: 'digit expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0029On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnnamed0031On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0032On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0030On: aStream
	^ nil! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0031On: aStream
	^ (aStream atEnd not and: [ aStream peek = $. ])
		ifFalse: [ PPFailure message: '$. expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0032On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	(element := self parseUnnamed0033On: aStream) isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements addLast: element.
	[ 
	(element := self parseUnnamed0033On: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0033On: aStream
	^ (aStream atEnd not and: [ aStream peek isDigit ])
		ifFalse: [ PPFailure message: 'digit expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0034On: aStream
	^ (aStream atEnd not and: [ aStream peek = $' ])
		ifFalse: [ PPFailure message: '$'' expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0035On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parseUnnamed0037On: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0036On: aStream
	^ (aStream atEnd not and: [ aStream peek = $' ])
		ifFalse: [ PPFailure message: '$'' expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0037On: aStream
	| element |
	element := self parseUnnamed0038On: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseUnnamed0039On: aStream.
	^ element! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0038On: aStream
	| position result |
	position := aStream position.
	result := aStream next: 2.
	result = '''''' ifTrue: [ ^ result ].
	aStream position: position.
	^ PPFailure message: ''''''''''''' expected' at: aStream position! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0039On: aStream
	| element |
	^ (element := self parseUnnamed0040On: aStream) isPetitFailure
		ifFalse: [ #second value: element ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0040On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnnamed0041On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0042On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0041On: aStream
	| element position |
	position := aStream position.
	element := self parseUnnamed0043On: aStream.
	aStream position: position.
	^ element isPetitFailure
		ifFalse: [ PPFailure message: '' at: aStream position ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0042On: aStream
	^ (aStream atEnd not
		and: [ 
			| each |
			each := aStream peek.
			true ])
		ifFalse: [ PPFailure message: 'input expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0043On: aStream
	^ (aStream atEnd not and: [ aStream peek = $' ])
		ifFalse: [ PPFailure message: '$'' expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0044On: aStream
	^ (aStream atEnd not and: [ aStream peek = $$ ])
		ifFalse: [ PPFailure message: '$$ expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0045On: aStream
	^ (aStream atEnd not
		and: [ 
			| each |
			each := aStream peek.
			true ])
		ifFalse: [ PPFailure message: 'input expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0046On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0047On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parseArrayItemOn: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0048On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0049On: aStream
	| position result |
	position := aStream position.
	result := aStream next: 2.
	result = '#(' ifTrue: [ ^ result ].
	aStream position: position.
	^ PPFailure message: '''#('' expected' at: aStream position! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0050On: aStream
	^ (aStream atEnd not and: [ aStream peek = $) ])
		ifFalse: [ PPFailure message: '$) expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0051On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0052On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parseNumberLiteralOn: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0053On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0054On: aStream
	| position result |
	position := aStream position.
	result := aStream next: 2.
	result = '#[' ifTrue: [ ^ result ].
	aStream position: position.
	^ PPFailure message: '''#['' expected' at: aStream position! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0055On: aStream
	^ (aStream atEnd not and: [ aStream peek = $] ])
		ifFalse: [ PPFailure message: '$] expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0056On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnnamed0057On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseSymbolOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0057On: aStream
	^ (aStream atEnd not and: [ aStream peek = $# ])
		ifFalse: [ PPFailure message: '$# expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0058On: aStream
	| element position |
	position := aStream position.
	element := self parseUnnamed0059On: aStream.
	aStream position: position.
	^ element isPetitFailure
		ifFalse: [ PPFailure message: '' at: aStream position ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0059On: aStream
	^ (aStream atEnd not and: [ aStream peek = $: ])
		ifFalse: [ PPFailure message: '$: expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0060On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnnamed0061On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0062On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0061On: aStream
	| position result |
	position := aStream position.
	result := aStream next: 3.
	result = 'nil' ifTrue: [ ^ result ].
	aStream position: position.
	^ PPFailure message: '''nil'' expected' at: aStream position! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0062On: aStream
	| element position |
	position := aStream position.
	element := self parseUnnamed0063On: aStream.
	aStream position: position.
	^ element isPetitFailure
		ifFalse: [ PPFailure message: '' at: aStream position ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0063On: aStream
	^ (aStream atEnd not and: [ aStream peek isAlphaNumeric ])
		ifFalse: [ PPFailure message: 'letter or digit expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0064On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnnamed0065On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0066On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0065On: aStream
	| position result |
	position := aStream position.
	result := aStream next: 4.
	result = 'true' ifTrue: [ ^ result ].
	aStream position: position.
	^ PPFailure message: '''true'' expected' at: aStream position! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0066On: aStream
	| element position |
	position := aStream position.
	element := self parseUnnamed0067On: aStream.
	aStream position: position.
	^ element isPetitFailure
		ifFalse: [ PPFailure message: '' at: aStream position ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0067On: aStream
	^ (aStream atEnd not and: [ aStream peek isAlphaNumeric ])
		ifFalse: [ PPFailure message: 'letter or digit expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0068On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnnamed0069On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0070On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0069On: aStream
	| position result |
	position := aStream position.
	result := aStream next: 5.
	result = 'false' ifTrue: [ ^ result ].
	aStream position: position.
	^ PPFailure message: '''false'' expected' at: aStream position! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0070On: aStream
	| element position |
	position := aStream position.
	element := self parseUnnamed0071On: aStream.
	aStream position: position.
	^ element isPetitFailure
		ifFalse: [ PPFailure message: '' at: aStream position ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0071On: aStream
	^ (aStream atEnd not and: [ aStream peek isAlphaNumeric ])
		ifFalse: [ PPFailure message: 'letter or digit expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0072On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0073On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parseArrayItemOn: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0074On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0075On: aStream
	^ (aStream atEnd not and: [ aStream peek = $( ])
		ifFalse: [ PPFailure message: '$( expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0076On: aStream
	^ (aStream atEnd not and: [ aStream peek = $) ])
		ifFalse: [ PPFailure message: '$) expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0077On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0078On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parseNumberLiteralOn: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0079On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0080On: aStream
	^ (aStream atEnd not and: [ aStream peek = $[ ])
		ifFalse: [ PPFailure message: '$[ expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0081On: aStream
	^ (aStream atEnd not and: [ aStream peek = $] ])
		ifFalse: [ PPFailure message: '$] expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0082On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseBinaryTokenOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseArrayItemOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0083On: aStream
	^ (aStream atEnd not and: [ aStream peek = $> ])
		ifFalse: [ PPFailure message: '$> expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0084On: aStream
	| element |
	element := self parseUnnamed0085On: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseUnnamed0086On: aStream.
	^ element! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0085On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 3.
	element := self parseUnnamed0087On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0088On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	element := self parseUnnamed0089On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 3 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0086On: aStream
	^ nil! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0087On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0088On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parseVariableOn: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0089On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0090On: aStream
	^ (aStream atEnd not and: [ aStream peek = $| ])
		ifFalse: [ PPFailure message: '$| expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0091On: aStream
	^ (aStream atEnd not and: [ aStream peek = $| ])
		ifFalse: [ PPFailure message: '$| expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamed0092On: aStream
	| element |
	^ (element := self parseUnnamed0095On: aStream) isPetitFailure
		ifFalse: [ 
			| nodes |
			nodes := element.
			(Array with: nodes first) , nodes last ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0093On: aStream
	| element |
	^ (element := self parseUnnamed0143On: aStream) isPetitFailure
		ifFalse: [ 
			| nodes |
			nodes := element.
			(Array with: nodes first) , nodes last ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0094On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parseUnnamed0149On: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0095On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnnamed0096On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnnamed0097On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0096On: aStream
	^ self parseExpressionOn: aStream! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0097On: aStream
	| element |
	element := self parseUnnamed0135On: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseUnnamed0136On: aStream.
	^ element! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0098On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parseAssignmentOn: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0099On: aStream
	| element |
	element := self parseUnnamed0100On: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseUnnamed0101On: aStream.
	^ element! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0100On: aStream
	| position result |
	position := aStream position.
	result := aStream next: 2.
	result = ':=' ifTrue: [ ^ result ].
	aStream position: position.
	^ PPFailure message: ''':='' expected' at: aStream position! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0101On: aStream
	| position result |
	position := aStream position.
	result := aStream next: 1.
	result = '_' ifTrue: [ ^ result ].
	aStream position: position.
	^ PPFailure message: '''_'' expected' at: aStream position! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0102On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parseCascadeMessageOn: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0103On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parseBinaryMessageOn: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0104On: aStream
	| element |
	element := self parseKeywordMessageOn: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseUnnamed0130On: aStream.
	^ element! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0105On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parseUnaryMessageOn: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0106On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0107On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0108On: aStream
	^ (aStream atEnd not and: [ aStream peek = $[ ])
		ifFalse: [ PPFailure message: '$[ expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0109On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	(element := self parseBlockArgumentOn: aStream) isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements addLast: element.
	[ 
	(element := self parseBlockArgumentOn: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0110On: aStream
	| element |
	element := self parseUnnamed0113On: aStream.
	element isPetitFailure
		ifFalse: [ ^ element ].
	element := self parseUnnamed0114On: aStream.
	^ element! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0111On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0112On: aStream
	^ (aStream atEnd not and: [ aStream peek = $: ])
		ifFalse: [ PPFailure message: '$: expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0113On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0114On: aStream
	| element |
	^ (element := self parseUnnamed0116On: aStream) isPetitFailure
		ifFalse: [ 
			| node |
			node := element.
			nil ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0115On: aStream
	^ (aStream atEnd not and: [ aStream peek = $| ])
		ifFalse: [ PPFailure message: '$| expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0116On: aStream
	| element position |
	position := aStream position.
	element := self parseUnnamed0117On: aStream.
	aStream position: position.
	^ element! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0117On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0118On: aStream
	^ (aStream atEnd not and: [ aStream peek = $] ])
		ifFalse: [ PPFailure message: '$] expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0119On: aStream
	^ nil! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0120On: aStream
	^ (aStream atEnd not and: [ aStream peek = $] ])
		ifFalse: [ PPFailure message: '$] expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0121On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0122On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0123On: aStream
	^ (aStream atEnd not and: [ aStream peek = $( ])
		ifFalse: [ PPFailure message: '$( expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0124On: aStream
	^ (aStream atEnd not and: [ aStream peek = $) ])
		ifFalse: [ PPFailure message: '$) expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0125On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0126On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0127On: aStream
	^ (aStream atEnd not and: [ aStream peek = ${ ])
		ifFalse: [ PPFailure message: '${ expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0128On: aStream
	^ (aStream atEnd not and: [ aStream peek = $} ])
		ifFalse: [ PPFailure message: '$} expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0129On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseBinaryTokenOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseUnaryExpressionOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0130On: aStream
	^ nil! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0131On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	(element := self parseUnnamed0132On: aStream) isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements addLast: element.
	[ 
	(element := self parseUnnamed0132On: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0132On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseKeywordTokenOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseBinaryExpressionOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0133On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0134On: aStream
	^ (aStream atEnd not and: [ aStream peek = $; ])
		ifFalse: [ PPFailure message: '$; expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0135On: aStream
	| element |
	^ (element := self parseUnnamed0137On: aStream) isPetitFailure
		ifFalse: [ 
			| nodes |
			nodes := element.
			nodes first , nodes last ]
		ifTrue: [ element ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0136On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parseUnnamed0141On: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0137On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 2.
	element := self parseUnnamed0138On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseStatementsOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0138On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	(element := self parseUnnamed0139On: aStream) isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements addLast: element.
	[ 
	(element := self parseUnnamed0139On: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0139On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0140On: aStream
	^ (aStream atEnd not and: [ aStream peek = $. ])
		ifFalse: [ PPFailure message: '$. expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0141On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0142On: aStream
	^ (aStream atEnd not and: [ aStream peek = $. ])
		ifFalse: [ PPFailure message: '$. expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0143On: aStream
	| start elements element |
	start := aStream position.
	elements := Array new: 3.
	element := self parseUnnamed0144On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 1 put: element.
	element := self parseExpressionOn: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 2 put: element.
	element := self parseUnnamed0145On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	elements at: 3 put: element.
	^ elements! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0144On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0145On: aStream
	| start element elements |
	start := aStream position.
	elements := OrderedCollection new.
	[ 
	(element := self parseUnnamed0147On: aStream) isPetitFailure
		ifTrue: [ ^ elements asArray ].
	elements addLast: element ] repeat! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0146On: aStream
	^ (aStream atEnd not and: [ aStream peek = $^ ])
		ifFalse: [ PPFailure message: '$^ expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0147On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0148On: aStream
	^ (aStream atEnd not and: [ aStream peek = $. ])
		ifFalse: [ PPFailure message: '$. expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 13:17'!
parseUnnamed0149On: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:56'!
parseUnnamed0150On: aStream
	^ (aStream atEnd not and: [ aStream peek = $. ])
		ifFalse: [ PPFailure message: '$. expected' at: aStream position ]
		ifTrue: [ aStream next ]! !

!PPTestParser methodsFor: 'generated-unnamed' stamp: 'lr 8/8/2010 12:53'!
parseUnnamedOn: aStream
	^ self parseStartOn: aStream! !

!PPTestParser methodsFor: 'generated-parser' stamp: 'lr 8/8/2010 13:17'!
parseVariableOn: aStream
	| start comments token |
	start := aStream position.
	comments := self parseComments: #() on: aStream.
	token := self superPPSmalltalkTokenParserparseOn: aStream.
	token isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ token ].
	comments := self parseComments: comments on: aStream.
	^ token comments: comments! !

!PPTestParser methodsFor: 'generated-utilities' stamp: 'lr 8/8/2010 13:33'!
superPPSmalltalkTokenParserparseOn: aStream
	| start element stop |
	start := aStream position.
	element := self parseUnnamed0150On: aStream.
	element isPetitFailure
		ifTrue: [ 
			aStream position: start.
			^ element ].
	stop := aStream position.
	^ self create: aStream collection start: start + 1 stop: stop! !

!PPTestParser methodsFor: 'generated-utilities' stamp: 'lr 8/8/2010 13:28'!
tokenClass
	^ PPSmalltalkToken! !

!PPParser methodsFor: '*petitbeta-operations' stamp: 'lr 4/16/2010 15:43'!
dynamicChoice: aParser
	| dynamicChoice |
	^ dynamicChoice := self | aParser / [ :stream |
		| resolution |
		resolution := UIManager default
			chooseFrom: { self name. aParser name }
			values: { self. aParser }
			title: 'Resolve ambiguity'.
		dynamicChoice def: resolution.
		resolution parseOn: stream ] asParser! !

!PPParser methodsFor: '*petitbeta-operations' stamp: 'lr 4/29/2010 23:13'!
optimize
	"Optimizes the receiving parser for speed and size."

	^ PPOptimizer new optimize: self! !

!PPParser methodsFor: '*petitbeta-operations' stamp: 'lr 4/16/2010 21:09'!
whatFollows: aString at: anInteger
	| stream |
	stream := aString asPetitStream.
	(self transform: [ :parser |
		parser ==> [ :node |
			stream position < anInteger
				ifTrue: [ node ]
				ifFalse: [ ^ parser followSets ] ] ])
		parseOn: stream.
	^ #()! !

TestResource subclass: #PPJitResource
	instanceVariableNames: 'jitter'
	classVariableNames: ''
	poolDictionaries: ''
	category: 'PetitBeta-JIT'!

!PPJitResource methodsFor: 'accessing' stamp: 'lr 8/6/2010 19:17'!
jitter
	^ jitter! !

!PPJitResource methodsFor: 'running' stamp: 'lr 8/7/2010 10:21'!
setUp
	super setUp.
	jitter := PPJit new! !

PPAbstractParseTest subclass: #PPOptimizerTest
	instanceVariableNames: 'a b c'
	classVariableNames: ''
	poolDictionaries: ''
	category: 'PetitBeta-Tests'!

!PPOptimizerTest class methodsFor: 'accessing' stamp: 'lr 5/31/2010 18:50'!
packageNamesUnderTest
	^ #('PetitBeta')! !

!PPOptimizerTest methodsFor: 'utilities' stamp: 'lr 4/29/2010 23:21'!
optimize: aParser
	^ aParser optimize! !

!PPOptimizerTest methodsFor: 'running' stamp: 'lr 4/29/2010 23:20'!
setUp
	super setUp.
	a := $a asParser.
	b := $b asParser.
	c := $c asParser! !

!PPOptimizerTest methodsFor: 'testing-choice' stamp: 'lr 5/3/2010 21:49'!
testEmptyChoice
	| grammar |
	grammar := self optimize: PPChoiceParser new.
	self assert: grammar class = PPEpsilonParser! !

!PPOptimizerTest methodsFor: 'testing-choice' stamp: 'lr 4/28/2010 20:57'!
testNestedChoice
	| grammar |
	grammar := self optimize: a / (b / c).
	self assert: grammar class = PPChoiceParser.
	self assert: grammar children size = 3.
	self assert: grammar children first class = PPLiteralObjectParser.
	self assert: grammar children last class = PPLiteralObjectParser.

	grammar := self optimize: (a / b) / c.
	self assert: grammar class = PPChoiceParser.
	self assert: grammar children size = 3.
	self assert: grammar children first class = PPLiteralObjectParser.
	self assert: grammar children last class = PPLiteralObjectParser! !

!PPOptimizerTest methodsFor: 'testing-choice' stamp: 'lr 4/28/2010 20:57'!
testNulledChoice
	| grammar |
	grammar := self optimize: a / nil asParser / b / c.
	self assert: grammar class = PPChoiceParser.
	self assert: grammar children size = 2.
	self assert: grammar children first class = PPLiteralObjectParser.
	self assert: grammar children last class = PPEpsilonParser.

	grammar := self optimize: a / b / nil asParser / c.
	self assert: grammar class = PPChoiceParser.
	self assert: grammar children size = 3.
	self assert: grammar children first class = PPLiteralObjectParser.
	self assert: grammar children last class = PPEpsilonParser.
	
	grammar := self optimize: a / b / c / nil asParser.
	self assert: grammar class = PPChoiceParser.
	self assert: grammar children size = 4.
	self assert: grammar children first class = PPLiteralObjectParser.
	self assert: grammar children last class = PPEpsilonParser
! !

!PPOptimizerTest methodsFor: 'testing-choice' stamp: 'lr 4/29/2010 22:10'!
testPostfixChoice
	| grammar |
	grammar := self optimize: (a , b) / (c , b).
	self assert: grammar class = PPSequenceParser.
	self assert: grammar children size = 2.
	self assert: grammar children first class = PPChoiceParser.
	self assert: grammar children first children size = 2.
	self assert: grammar children first children first literal = $a.
	self assert: grammar children first children last literal = $c.
	self assert: grammar children last literal = $b! !

!PPOptimizerTest methodsFor: 'testing-choice' stamp: 'lr 4/29/2010 22:09'!
testPrefixChoice
	| grammar |
	grammar := self optimize: (a , b) / (a , c).
	self assert: grammar class = PPSequenceParser.
	self assert: grammar children size = 2.
	self assert: grammar children first literal = $a.
	self assert: grammar children last class = PPChoiceParser.
	self assert: grammar children last children size = 2.
	self assert: grammar children last children first literal = $b.
	self assert: grammar children last children last literal = $c! !

!PPOptimizerTest methodsFor: 'testing-delegate' stamp: 'lr 4/19/2010 18:39'!
testReduceDelegate
	| grammar |
	grammar := self optimize: (PPAndParser on: (PPAndParser on: a)).
	self assert: grammar class = PPAndParser.
	self assert: grammar children first class = PPLiteralObjectParser.
	
	grammar := self optimize: (PPNotParser on: (PPNotParser on: a)).
	self assert: grammar class = PPNotParser.
	self assert: grammar children first class = PPLiteralObjectParser.
	
	grammar := self optimize: (PPFlattenParser on: (PPFlattenParser on: a)).
	self assert: grammar class = PPFlattenParser.
	self assert: grammar children first class = PPLiteralObjectParser.
	
	grammar := self optimize: (PPTokenParser on: (PPTokenParser on: a)).
	self assert: grammar class = PPTokenParser.
	self assert: grammar children first class = PPLiteralObjectParser.

	grammar := self optimize: (PPMemoizedParser on: (PPMemoizedParser on: a)).
	self assert: grammar class = PPMemoizedParser.
	self assert: grammar children first class = PPLiteralObjectParser.

	grammar := self optimize: (PPTrimmingParser on: (PPTrimmingParser on: a)).
	self assert: grammar class = PPTrimmingParser.
	self assert: grammar children first class = PPLiteralObjectParser! !

!PPOptimizerTest methodsFor: 'testing-delegate' stamp: 'lr 4/28/2010 20:57'!
testRemoveDelegate
	| grammar |
	grammar := self optimize: a wrapped.
	self assert: grammar class = PPLiteralObjectParser.
	
	grammar := self optimize: a wrapped wrapped.
	self assert: grammar class = PPLiteralObjectParser.
	
	grammar := self optimize: a wrapped / b wrapped wrapped.
	self assert: grammar class = PPChoiceParser.
	self assert: grammar children first class = PPLiteralObjectParser.
	self assert: grammar children last class = PPLiteralObjectParser! !

!PPOptimizerTest methodsFor: 'testing-choice' stamp: 'lr 4/28/2010 20:57'!
testRepeatedChoice
	| grammar |
	grammar := self optimize: a / a / b / c.
	self assert: grammar class = PPChoiceParser.
	self assert: grammar children size = 3.
	
	grammar := self optimize: a / b / a / a.
	self assert: grammar class = PPChoiceParser.
	self assert: grammar children size = 2.

	grammar := self optimize: a / a / a / a.
	self assert: grammar class = PPLiteralObjectParser! !

!PPOptimizerTest methodsFor: 'testing-choice' stamp: 'lr 5/3/2010 21:50'!
testSingleChoice
	| grammar |
	grammar := self optimize: (PPChoiceParser with: a).
	self assert: grammar class = PPLiteralObjectParser! !

PPDelegateParser subclass: #PPJitParser
	instanceVariableNames: 'method'
	classVariableNames: ''
	poolDictionaries: ''
	category: 'PetitBeta-JIT'!

!PPJitParser class methodsFor: 'instance creation' stamp: 'lr 8/1/2010 09:02'!
on: aParser method: aCompiledMethod
	^ (self on: aParser) setMethod: aCompiledMethod! !

!PPJitParser methodsFor: 'accessing' stamp: 'lr 8/1/2010 15:51'!
method
	^ method! !

!PPJitParser methodsFor: 'parsing' stamp: 'lr 7/31/2010 23:15'!
parseOn: aStream
	^ self 
		withArgs: (Array with: aStream)
		executeMethod: method! !

!PPJitParser methodsFor: 'initialization' stamp: 'lr 7/31/2010 23:16'!
setMethod: aCompiledMethod
	method := aCompiledMethod! !

PPParserTest subclass: #PPJitTest
	instanceVariableNames: 'jitter'
	classVariableNames: ''
	poolDictionaries: ''
	category: 'PetitBeta-JIT'!

!PPJitTest class methodsFor: 'accessing' stamp: 'lr 8/6/2010 19:17'!
resources
	^ Array with: PPJitResource! !

!PPJitTest methodsFor: 'utilities' stamp: 'lr 8/6/2010 19:18'!
assert: aParser fail: aCollection
	| parser stream result |
	parser := PPJitResource current jitter
		compile: aParser.
	self assert: (parser isKindOf: PPJitParser).
	stream := aCollection asPetitStream.
	result := parser parse: stream.
	self assert: result isPetitFailure.
	self assert: stream position = 0! !

!PPJitTest methodsFor: 'utilities' stamp: 'lr 8/6/2010 19:18'!
assert: aParser parse: aCollection to: aTargetObject end: anInteger
	| parser stream result |
	parser := PPJitResource current jitter
		compile: aParser.
	self assert: (parser isKindOf: PPJitParser).
	stream := aCollection asPetitStream.
	result := parser parse: stream.
	aTargetObject isNil
		ifTrue: [ self deny: result isPetitFailure ]
		ifFalse: [ self assert: result = aTargetObject ].
	self assert: stream position = anInteger! !

!PPJitTest methodsFor: 'testing' stamp: 'lr 8/7/2010 10:37'!
testMemoized
	"This test does not work"! !

Object subclass: #PPJit
	instanceVariableNames: 'methodTemplates inlineTemplates literalMapping'
	classVariableNames: ''
	poolDictionaries: ''
	category: 'PetitBeta-JIT'!

!PPJit methodsFor: 'public' stamp: 'lr 8/6/2010 19:15'!
compile: aParser
	"Try to optimize aParser. If no reasonable optimization can be performed return the original parser."
	
	| methodTree |
	methodTree := (methodTemplates
		at: aParser class
		ifAbsent: [ ^ aParser ])
			copy.
	literalMapping := IdentityDictionary new.
	
	methodTree := self inlineAll: methodTree for: aParser.
	methodTree := self
		rewrite: (self
			rewrite: (self
				rewrite: methodTree removeDeadCode
				using: self rewriteParserBlocks)
			using: self rewriteEmtpyIfTrue)
		using: self rewriteEmptyBlock.
	
	^ PPJitParser on: aParser method: (self 
		patchLiterals: (self rootParserClass compilerClass new
			compile: methodTree formattedCode
			in: self rootParserClass
			classified: nil notifying: nil
			ifFail: [ ^ aParser ])
				generate)! !

!PPJit methodsFor: 'initialization' stamp: 'lr 8/6/2010 14:55'!
initialize
	self initializeTemplates! !

!PPJit methodsFor: 'initialization' stamp: 'lr 8/6/2010 17:58'!
initializeTemplate: class
	| parseTree |
	parseTree := (class lookupSelector: self parseOnSelector)
		parseTree.
	(parseTree isNil 
		or: [ parseTree isPrimitive 
		or: [ parseTree superMessages notEmpty ] ])
			ifTrue: [ ^ self ].
	parseTree := (self
		rewrite: (self
			rewrite: (self
				rewrite: parseTree 
				using: self rewriteGuardClause)
			using: self rewriteIfTrue)
		using: self rewriteReturns)
			addSelfReturn;
			yourself.
	(parseTree body temporaries isEmpty
		and: [ parseTree body statements size = 1
		and: [ parseTree body statements first isReturn
		and: [ parseTree body statements first value containsReturn not ] ] ])
			ifTrue: [ inlineTemplates at: class put: parseTree body statements first value ].
	methodTemplates at: class put: parseTree! !

!PPJit methodsFor: 'initialization' stamp: 'lr 8/6/2010 18:24'!
initializeTemplates
	methodTemplates := IdentityDictionary new.
	inlineTemplates := IdentityDictionary new.
	self rootParserClass
		withAllSubclassesDo: [ :class | self initializeTemplate: class ]! !

!PPJit methodsFor: 'private' stamp: 'lr 8/6/2010 19:12'!
inlineAll: aNode for: aParser
	| rewriter1 rewriter2 |
	rewriter1 := RBParseTreeRewriter new.
	rewriter1
		replace: '`variable value: `@expr'
			withValueFrom: [ :node | self inlineBlock: node for: aParser ]
			when: [ :node | (self instanceVariable: node receiver for: aParser) isBlock ];
		replace: '`variable parseOn: `stream'
			withValueFrom: [ :node | self inlineParser: node for: aParser ]
			when: [ :node | (self instanceVariable: node receiver for: aParser) isPetitParser ];
		replace: '`variable `@msg: `@args'
			withValueFrom: [ :node | self inlineCollection: node for: aParser ]
			when: [ :node | (self instanceVariable: node receiver for: aParser) isCollection ].
	rewriter2 := RBParseTreeRewriter new.
	rewriter2
		replace: 'self' 
		withValueFrom: [ :node | self inlineObject: aParser ];
		replace: '`variable' 
		withValueFrom: [ :node | self inlineVariable: node for: aParser ].
	^ rewriter2 executeTree: (rewriter1 executeTree: aNode; tree); tree! !

!PPJit methodsFor: 'private' stamp: 'lr 8/7/2010 09:52'!
inlineBlock: aNode for: aParser
	| block tree |
	block := self
		instanceVariable: aNode receiver
		for: aParser.
	(block numArgs = 1 and: [ block numCopiedValues = 0 ])
		ifFalse: [ ^ aNode ].
	tree := RBParser
		parseExpression: block asString
		onError: [ :msg :pos | ^ aNode ].
	(tree isBlock and: [ tree body temporaries isEmpty and: [ tree body statements size = 1 and: [ tree containsReturn not ] ] ])
		ifFalse: [ ^ aNode ].
	tree body statements first nodesDo: [ :each |
		each isVariable ifTrue: [ 
			each name = tree arguments first name
				ifTrue: [ each replaceWith: aNode arguments first ]
				ifFalse: [ ^ aNode ] ] ].
	^ tree body statements first! !

!PPJit methodsFor: 'private' stamp: 'lr 8/6/2010 18:18'!
inlineCollection: aNode for: aParser
	| collection arguments |
	collection := self
		instanceVariable: aNode receiver
		for: aParser.
	arguments := aNode arguments collect: [ :each | 
		each isLiteral
			ifTrue: [ each value ]
			ifFalse: [ ^ aNode ] ].
	^ RBLiteralNode value: (collection
		perform: aNode selector
		withArguments: arguments)! !

!PPJit methodsFor: 'private' stamp: 'lr 8/6/2010 18:13'!
inlineObject: anObject
	"Inlines anObject into the literal frame of the generated method."
	
	^ RBLiteralNode value: (literalMapping
		at: anObject
		ifAbsentPut: [ ('__ref_' , literalMapping size asString) asSymbol ])! !

!PPJit methodsFor: 'private' stamp: 'lr 8/6/2010 17:52'!
inlineParser: aNode for: aParser
	| parser tree |
	parser := self
		instanceVariable: aNode receiver
		for: aParser.
	tree := (inlineTemplates
		at: parser class
		ifAbsent: [ ^ aNode ])
			copy.
	^ self inlineAll: tree for: parser! !

!PPJit methodsFor: 'private' stamp: 'lr 8/6/2010 16:56'!
inlineVariable: aNode for: aParser
	| value |
	value := self 
		instanceVariable: aNode for: aParser
		ifAbsent: [ ^ aNode ].
	value isLiteral
		ifTrue: [ ^ RBLiteralNode value: value ].
	^ self inlineObject: value! !

!PPJit methodsFor: 'private' stamp: 'lr 8/6/2010 17:41'!
inlineVariables: aNode for: aParser
	| rewriter |
	rewriter := RBParseTreeRewriter new.
	rewriter
		replace: '`var value'
			withValueFrom: [ :node | self inlineBlock: node for: aParser ]
			when: [ :node | (self instanceVariable: node receiver for: aParser) isBlock ];
		replace: '`var parseOn: aStream'
			withValueFrom: [ :node | self inlineParser: node for: aParser ]
			when: [ :node | (self instanceVariable: node receiver for: aParser) isPetitParser ];
		replace: '`var' 
			withValueFrom: [ :node | self inlineVariable: node for: aParser ].
	^ rewriter executeTree: aNode; answer! !

!PPJit methodsFor: 'private' stamp: 'lr 8/6/2010 16:56'!
instanceVariable: aNode for: aParser
	^ self instanceVariable: aNode for: aParser ifAbsent: [ nil ]! !

!PPJit methodsFor: 'private' stamp: 'lr 8/6/2010 16:56'!
instanceVariable: aNode for: aParser ifAbsent: aBlock
	| index |
	(aNode whoDefines: aNode name) notNil
		ifTrue: [ ^ aBlock value ].
	index := aParser class allInstVarNames
		indexOf: aNode name
		ifAbsent: [ ^ aBlock value ].
	^ aParser instVarAt: index! !

!PPJit methodsFor: 'configuration' stamp: 'lr 8/1/2010 08:52'!
parseOnSelector
	^ #parseOn:! !

!PPJit methodsFor: 'private' stamp: 'lr 8/2/2010 21:53'!
patchLiterals: aCompiledMethod
	| inverseMapping |
	inverseMapping := IdentityDictionary new: literalMapping size.
	literalMapping keysAndValuesDo: [ :key :value | inverseMapping at: value put: key ].
	2 to: aCompiledMethod numLiterals + 1 do: [ :index |
		aCompiledMethod objectAt: index put: (inverseMapping
			at: (aCompiledMethod objectAt: index)
			ifAbsent: [ aCompiledMethod objectAt: index ]) ].
	^ aCompiledMethod! !

!PPJit methodsFor: 'rewriting' stamp: 'lr 8/2/2010 17:33'!
rewrite: aNode using: aRewriter
	"Apply aRewriter repeatedly to aNode until no more changes can be performed."

	| tree |
	tree := aNode.
	[ aRewriter executeTree: tree ]
		whileTrue: [ tree := aRewriter tree ].
	^ tree! !

!PPJit methodsFor: 'rewriting' stamp: 'lr 8/2/2010 17:51'!
rewriteEmptyBlock
	| rewriter |
	rewriter := RBParseTreeRewriter new.
	rewriter
		replace: '[ ``.object ] value'
			with: '``.object'
			when: [ :aNode | aNode parent isCascade not ];
		replace: '| `@temps | ``@.Stmts1. [ | `@bTemps | ``@.bStmts ] value. ``@.Stmts2'
			with: '| `@temps `@bTemps | ``@.Stmts1. ``@.bStmts. ``@.Stmts2'.
	^ rewriter! !

!PPJit methodsFor: 'rewriting' stamp: 'lr 8/2/2010 17:51'!
rewriteEmtpyIfTrue
	| rewriter |
	rewriter := RBParseTreeRewriter new.
	rewriter
		replace: '``@boolean ifTrue: [ ] ifFalse: [ | `@temps | ``@.Stmts ]'
			with: '``@boolean ifFalse: [ |`@temps | ``@.Stmts ]';
		replace: '``@boolean ifFalse: [ ] ifTrue: [ | `@temps | ``@.Stmts ]'
			with: '``@boolean ifTrue: [ |`@temps | ``@.Stmts ]';
		replace: '``@boolean ifTrue: [ | `@temps | ``@.Stmts ] ifFalse: [ ]'
			with: '``@boolean ifTrue: [ |`@temps | ``@.Stmts ]';
		replace: '``@boolean ifFalse: [ | `@temps | ``@.Stmts ] ifTrue: [ ]'
			with: '``@boolean ifFalse: [ |`@temps | ``@.Stmts ]'.
	^ rewriter! !

!PPJit methodsFor: 'rewriting' stamp: 'lr 8/2/2010 17:33'!
rewriteGuardClause
	| rewriter |
	rewriter := RBParseTreeRewriter new.
	rewriter
		replaceMethod: '`@methodName: `@args | `@temps | `@.s1. `@boolean ifTrue: [| `@t1 | `@.Stmts1. ^`@r1]. `@.s2. ^`@r2'
			with: '`@methodName: `@args | `@temps | `@.s1. `@boolean ifTrue: [| `@t1 | `@.Stmts1. ^`@r1] ifFalse: [`@.s2. ^`@r2]';
		replaceMethod: '`@methodName: `@args | `@temps | `@.s1. `@boolean ifFalse: [| `@t1 | `@.Stmts1. ^`@r1]. `@.s2. ^`@r2'
			with: '`@methodName: `@args | `@temps | `@.s1. `@boolean ifTrue: [`@.s2. ^`@r2] ifFalse: [| `@t1 | `@.Stmts1. ^`@r1]';
		replaceMethod: '`@methodName: `@args | `@temps | `@.s1. `@boolean ifTrue: [| `@t1 | `@.Stmts1. ^`@r1]. `@.s2'
			with: '`@methodName: `@args | `@temps | `@.s1. `@boolean ifTrue: [| `@t1 | `@.Stmts1. ^`@r1] ifFalse: [`@.s2. ^self]';
		replaceMethod: '`@methodName: `@args | `@temps | `@.s1. `@boolean ifFalse: [| `@t1 | `@.Stmts1. ^`@r1]. `@.s2'
			with: '`@methodName: `@args | `@temps | `@.s1. `@boolean ifTrue: [`@.s2. ^self] ifFalse: [| `@t1 | `@.Stmts1. ^`@r1]'.
	^ rewriter! !

!PPJit methodsFor: 'rewriting' stamp: 'lr 8/2/2010 17:32'!
rewriteIfTrue
	| rewriter |
	rewriter := RBParseTreeRewriter new.
	rewriter
		replace: '| `@temps | ``@.s1. ``@boolean ifTrue: [| `@t1 | ``@.Stmts1. ^`@r1]. ``@.s2. ^``@r2'
			with: '| `@temps | ``@.s1. ``@boolean ifTrue: [| `@t1 | ``@.Stmts1. ^`@r1] ifFalse: [``@.s2. ^``@r2]';
		replace: '| `@temps | ``@.s1. ``@boolean ifFalse: [| `@t1 | ``@.Stmts1. ^`@r1]. ``@.s2. ^``@r2'
			with: '| `@temps | ``@.s1. ``@boolean ifTrue: [``@.s2. ^``@r2] ifFalse: [| `@t1 | ``@.Stmts1. ^`@r1]'.
	^ rewriter! !

!PPJit methodsFor: 'rewriting' stamp: 'lr 8/2/2010 18:01'!
rewriteParserBlocks
	| rewriter |
	rewriter := RBParseTreeRewriter new.
	rewriter
		replace: '| `@temps1 | `@.stmts1. [ `collection size < 0 ] whileTrue: [ | `@temps2 | `@.stmts2 ]. `@.stmts3'
			with: '| `@temps1 | `@.stmts1. `@.stmts3';
		replace: '| `@temps1 | `@.stmts1. [ `collection size < 1 ] whileTrue: [ | `@temps2 | `@.stmts2 ]. `@.stmts3'
			with: '| `@temps1 `@temps2 | `@.stmts1. `@.stmts2. `@.stmts3';
		replace: '| `@temps1 | `@.stmts1. [ `collection size < 1073741823 ] whileTrue: [ | `@temps2 | `@.stmts2 ]. `@.stmts3'
			with: '| `@temps1 | `@.stmts1. [ | `@temps2 | `@.stmts2 ] repeat'.
	^ rewriter! !

!PPJit methodsFor: 'rewriting' stamp: 'lr 8/2/2010 17:32'!
rewriteReturns
	| rewriter |
	rewriter := RBParseTreeRewriter new.
	rewriter
		replace: '^``@boolean ifTrue: [| `@t1 | `@.Stmts1. ^``@r1] ifFalse: [| `@t2 | `@.Stmts2. ^``@r2]'
			with: '^``@boolean ifTrue: [| `@t1 | `@.Stmts1. ``@r1] ifFalse: [| `@t2 | `@.Stmts2. ``@r2]';
		replace: '^``@boolean ifFalse: [| `@t1 | `@.Stmts1. ^``@r1] ifTrue: [| `@t2 | `@.Stmts2. ^``@r2]'
			with: '^``@boolean ifFalse: [| `@t1 | `@.Stmts1. ``@r1] ifTrue: [| `@t2 | `@.Stmts2. ``@r2]';
		replace: '^``@boolean ifTrue: [| `@t1 | `@.Stmts1. ``@r1] ifFalse: [| `@t2 | `@.Stmts2. ^``@r2]'
			with: '^``@boolean ifTrue: [| `@t1 | `@.Stmts1. ``@r1] ifFalse: [| `@t2 | `@.Stmts2. ``@r2]';
		replace: '^``@boolean ifFalse: [| `@t1 | `@.Stmts1. ``@r1] ifTrue: [| `@t2 | `@.Stmts2. ^``@r2]'
			with: '^``@boolean ifFalse: [| `@t1 | `@.Stmts1. ``@r1] ifTrue: [| `@t2 | `@.Stmts2. ``@r2]';
		replace: '^``@boolean ifTrue: [| `@t1 | `@.Stmts1. ^``@r1] ifFalse: [| `@t2 | `@.Stmts2. ``@r2]'
			with: '^``@boolean ifTrue: [| `@t1 | `@.Stmts1. ``@r1] ifFalse: [| `@t2 | `@.Stmts2. ``@r2]';
		replace: '^``@boolean ifFalse: [| `@t1 | `@.Stmts1. ^``@r1] ifTrue: [| `@t2 | `@.Stmts2. ``@r2]'
			with: '^``@boolean ifFalse: [| `@t1 | `@.Stmts1. ``@r1] ifTrue: [| `@t2 | `@.Stmts2. ``@r2]';
		replace: '``@boolean ifTrue: [| `@t1 | `@.Stmts1. ^``@r1] ifFalse: [| `@t2 | `@.Stmts2. ^``@r2]'
			with: '^``@boolean ifTrue: [| `@t1 | `@.Stmts1. ``@r1] ifFalse: [| `@t2 | `@.Stmts2. ``@r2]';
		replace: '``@boolean ifFalse: [| `@t1 | `@.Stmts1. ^``@r1] ifTrue: [| `@t2 | `@.Stmts2. ^``@r2]'
			with: '^``@boolean ifFalse: [| `@t1 | `@.Stmts1. ``@r1] ifTrue: [| `@t2 | `@.Stmts2. ``@r2]'.
	^ rewriter! !

!PPJit methodsFor: 'configuration' stamp: 'lr 8/1/2010 08:52'!
rootParserClass
	^ PPParser! !

Object subclass: #PPOptimizer
	instanceVariableNames: 'rewriter'
	classVariableNames: ''
	poolDictionaries: ''
	category: 'PetitBeta-Processor'!

!PPOptimizer commentStamp: '<historical>' prior: 0!
PPOptimizer improves the internal structure of a grammar without touching its behavior.

Instance Variables:
	rewriter	<PPRewriter>	The rewriter that knows how to optimize a grammar.!

!PPOptimizer methodsFor: 'optimizations-choice' stamp: 'lr 4/29/2010 21:40'!
emptyChoice
	<optimize>

	rewriter
		replace: PPChoiceParser new
		with: PPEpsilonParser new! !

!PPOptimizer methodsFor: 'optimizations' stamp: 'lr 4/29/2010 21:41'!
identityWrapper
	<optimize>
	
	rewriter
		replace: (PPPattern kind: PPDelegateParser)
		withValueFrom: [ :parser | parser children first ]! !

!PPOptimizer methodsFor: 'optimizations' stamp: 'lr 4/29/2010 21:41'!
idepotentDelegate
	<optimize>
	
	rewriter
		replace: PPPattern any
		withValueFrom: [ :parser | parser children first ]
		when: [ :parser |
			parser children size = 1
				and: [ parser class = parser children first class
				and: [ #(PPAndParser PPNotParser PPEndOfInputParser PPFlattenParser PPTokenParser PPMemoizedParser PPTrimmingParser)
					includes: parser class name ] ] ]! !

!PPOptimizer methodsFor: 'initialization' stamp: 'lr 4/29/2010 21:01'!
initialize
	rewriter := PPRewriter new.
	(Pragma allNamed: #optimize in: self class)
		do: [ :each | self perform: each selector ]! !

!PPOptimizer methodsFor: 'optimizations-choice' stamp: 'lr 5/3/2010 21:50'!
nestedChoice
	<optimize>
	
	| before inside after |
	before := PPListPattern any.
	inside := PPListPattern any.
	after := PPListPattern any.
	rewriter
		replace: before / (PPChoiceParser with: inside) / after
		with: before / inside / after! !

!PPOptimizer methodsFor: 'optimizations-choice' stamp: 'lr 4/29/2010 21:40'!
nulledChoice
	<optimize>
	
	| before parser after |
	before := PPListPattern any.
	parser := PPPattern any.
	after := PPListPattern any.
	rewriter
		replace: before / PPEpsilonParser new / parser / after
		with: before / PPEpsilonParser new! !

!PPOptimizer methodsFor: 'public' stamp: 'lr 4/29/2010 21:29'!
optimize: aParser
	"Transform aParser by applying all the matching optimization rules. Repeatedly apply the rules until no more changes can be done."
	
	| current |
	current := aParser.
	[ current := rewriter execute: current.
	  rewriter hasChanged ]
			whileTrue.
	^ current! !

!PPOptimizer methodsFor: 'optimizations-choice' stamp: 'lr 4/29/2010 23:19'!
prefixedChoice
	<optimize>
	
	| before prefix body1 body2 postfix after |
	before := PPListPattern any.
	prefix := PPPattern any.
	body1 := PPListPattern any.
	body2 := PPListPattern any.
	postfix := PPPattern any.
	after := PPListPattern any.
	rewriter
		replace: before / (prefix , body1) / (prefix , body2) / after
		with: before / (prefix , (body1 / body2)) / after.
	rewriter
		replace: before / (body1 , postfix) / (body2 , postfix) / after
		with: before / ((body1 / body2) , postfix) / after! !

!PPOptimizer methodsFor: 'optimizations-choice' stamp: 'lr 4/29/2010 21:41'!
repeatedChoice
	<optimize>
	
	| before parser between after |
	before := PPListPattern any.
	parser := PPPattern any.
	between := PPListPattern any.
	after := PPListPattern any.
	rewriter
		replace: before / parser / between / parser / after
		with: before / parser / between / after! !

!PPOptimizer methodsFor: 'optimizations-choice' stamp: 'lr 5/3/2010 21:50'!
singleChoice
	<optimize>

	| parser |
	parser := PPPattern any.
	rewriter
		replace: (PPChoiceParser with: parser)
		with: parser! !

Object subclass: #PPVisitor
	instanceVariableNames: 'dispatcher'
	classVariableNames: ''
	poolDictionaries: ''
	category: 'PetitBeta-Compiler'!

PPVisitor subclass: #PPCompiler
	instanceVariableNames: 'model selectors parser class removals'
	classVariableNames: ''
	poolDictionaries: ''
	category: 'PetitBeta-Compiler'!

!PPCompiler methodsFor: 'accepting' stamp: 'lr 8/7/2010 18:50'!
acceptChoice: aParser
	<accept: #PPChoiceParser>
	
	| method |
	method := RBMethodNode
		selector: (self uniqueSelectorFor: aParser)
		arguments: (Array with: self streamVariable)
		body: RBSequenceNode new.
	method body addTemporaryNamed: 'element'.
	aParser children
		do: [ :each | self addExpression: 'element := self ' , (self uniqueSelectorFor: each) , ' aStream' to: method body ]
		separatedBy: [ self addExpression: 'element isPetitFailure ifFalse: [ ^ element ]' to: method body ].
	method body addNode: (RBParser parseExpression: '^ element').
	^ method! !

!PPCompiler methodsFor: 'accepting' stamp: 'lr 8/8/2010 13:06'!
acceptParser: aParser
	<accept: #PPParser>
	
	| selector tree |
	selector := self uniqueSelectorFor: aParser.
	tree := (model classNamed: aParser class name)
		parseTreeFor: #parseOn:.
	tree renameSelector: selector andArguments: tree arguments.
	self inlineAll: tree for: aParser.
	^ self rewrite: tree using: (RBParseTreeRewriter new
		replace: '| `@temps1 | `@.stmts1. [ :`arg2 | | `@temps2 | `@.stmts2 ] value: `@expr2. `@.stmts3'
			with: '| `@temps1 `arg2 `@temps2 | `@.stmts1. `arg2 := `@expr2. `@.stmts2. `@.stmts3';
		replace: '| `@temps1a `var1 `@temps1b | `var1 := `@expr1. `var1 `@msg2: `@args2'
			with: '| `@temps1a `@temps1b | `@expr1 `@msg2: `@args2';
		yourself)! !

!PPCompiler methodsFor: 'accepting' stamp: 'lr 8/7/2010 19:44'!
acceptRepetition: aParser continue: aContinuation
	<accept: #PPRepeatingParser>
	
	^ self rewrite: aContinuation value using: (RBParseTreeRewriter new
		replace: '| `@temps1 | `@.stmts1. [ `collection size < 0 ] whileTrue: [ | `@temps2 | `@.stmts2 ]. `@.stmts3'
			with: '| `@temps1 | `@.stmts1. `@.stmts3';
		replace: '| `@temps1 | `@.stmts1. [ `collection size < 1 ] whileTrue: [ | `@temps2 | `@.stmts2 ]. `@.stmts3'
			with: '| `@temps1 `@temps2 | `@.stmts1. `@.stmts2. `@.stmts3';
		replace: '| `@temps1 | `@.stmts1. [ `collection size < 1073741823 ] whileTrue: [ | `@temps2 | `@.stmts2 ]. `@.stmts3'
			with: '| `@temps1 | `@.stmts1. [ | `@temps2 | `@.stmts2 ] repeat';
		yourself)! !

!PPCompiler methodsFor: 'accepting' stamp: 'lr 8/8/2010 11:18'!
acceptSequence: aParser
	<accept: #PPSequenceParser>
	
	| method |
	method := RBMethodNode
		selector: (self uniqueSelectorFor: aParser)
		arguments: (Array with: self streamVariable)
		body: RBSequenceNode new.
	self 
		addExpression: '
			| start elements element |
			start := aStream position.
			elements := Array new: ' , aParser children size asString
		to: method body.
	aParser children withIndexDo: [ :each :index |
		self 
			addExpression: '
				element := self ' , (self uniqueSelectorFor: each) , ' aStream.
				element isPetitFailure
					ifTrue: [ aStream position: start. ^ element ].
				elements at: ' , index asString , ' put: element' 
			to: method body ].
	self addExpression: '^ elements' to: method body.
	^ method! !

!PPCompiler methodsFor: 'utilities' stamp: 'lr 8/7/2010 18:02'!
addExpression: aString to: aSequenceNode
	| tree |
	tree := RBParser
		parseExpression: aString
		onError: [ :msg :pos | self error: msg ].
	tree isSequence
		ifFalse: [ aSequenceNode addNode: tree ]
		ifTrue: [
			aSequenceNode addTemporariesNamed: tree temporaryNames.
			aSequenceNode addNodes: tree statements ]! !

!PPCompiler methodsFor: 'accessing' stamp: 'lr 8/8/2010 11:06'!
class: aClassOrSymbol
	class := model classNamed: (aClassOrSymbol isBehavior 
		ifTrue: [ aClassOrSymbol theNonMetaClass name ]
		ifFalse: [ aClassOrSymbol asSymbol ])! !

!PPCompiler methodsFor: 'utilities' stamp: 'lr 8/8/2010 12:55'!
compile: aMethodNode classified: aSelector
	(class parseTreeFor: aMethodNode selector asSymbol) = aMethodNode
		ifFalse: [ class compile: aMethodNode newSource classified: aSelector ].
	removals remove: aMethodNode selector ifAbsent: [ nil ]! !

!PPCompiler methodsFor: 'transformation' stamp: 'lr 8/8/2010 12:32'!
execute
	class selectors do: [ :selector |
		(class protocolsFor: selector) do: [ :protocol |
			(protocol beginsWith: self protocol)
				ifTrue: [ removals add: selector ] ] ].
	parser allParsersDo: [ :each | self generate: each ].
	removals do: [ :each | class removeMethod: each ].
	model changes open! !

!PPCompiler methodsFor: 'transformation' stamp: 'lr 8/8/2010 12:52'!
generate: aParser
	self
		compile: (self visit: aParser)
		classified: (aParser name isEmptyOrNil
			ifTrue: [ self protocolUnnamed ]
			ifFalse: [ self protocolNamed ])! !

!PPCompiler methodsFor: 'initialization' stamp: 'lr 8/8/2010 11:14'!
initialize
	super initialize.
	model := RBNamespace new.
	selectors := Dictionary new.
	removals := Set new! !

!PPCompiler methodsFor: 'inlining' stamp: 'lr 8/8/2010 13:31'!
inlineAll: aMethodNode for: aParser
	^ RBParseTreeRewriter new
		replace: 'parser parseOn: aStream'
			withValueFrom: [ :node | self inlineParser: node for: aParser ];
		replace: 'self `@message: ``@arguments'
			withValueFrom: [ :node | self inlineSelf: node for: aParser ];
		replace: 'super `@message: ``@arguments'
			withValueFrom: [ :node | self inlineSuper: node for: aParser ];
		replace: '`variable'
			withValueFrom: [ :node | self inlineVariable: node for: aParser ];
		executeTree: aMethodNode;
		tree
	! !

!PPCompiler methodsFor: 'inlining' stamp: 'lr 8/8/2010 12:13'!
inlineBlock: aNode for: aParser value: aBlock
	| tree context rewriter |
	tree := RBParser
		parseExpression: aBlock asString
		onError: [ :msg :pos | self error: aParser printString , ' unable to parse block.' ].
	aBlock numCopiedValues isZero
		ifTrue: [ ^ tree ].
	context := aBlock asContext.
	rewriter := RBParseTreeRewriter new.
	1 to: aBlock numCopiedValues do: [ :index |
		(aBlock at: index) isLiteral
			ifFalse: [ self error: aParser printString , ' captures non literal value.' ].
		rewriter
			replaceTree: (RBVariableNode named: (context tempNames at: index))
			withTree: (RBLiteralNode value: (aBlock at: index)) ].
	^ self rewrite: tree using: rewriter! !

!PPCompiler methodsFor: 'inlining' stamp: 'lr 8/8/2010 13:28'!
inlineGlobal: aNode for: aParser value: anObject
	^ RBVariableNode named: anObject name! !

!PPCompiler methodsFor: 'inlining' stamp: 'lr 8/8/2010 11:39'!
inlineLiteral: aNode for: aParser value: aLiteral
	^ RBLiteralNode value: aLiteral! !

!PPCompiler methodsFor: 'inlining' stamp: 'lr 8/8/2010 13:32'!
inlineParser: aNode for: aParser
	^ RBMessageNode
		receiver: (RBVariableNode named: 'self')
		selector: (self uniqueSelectorFor: aParser children first)
		arguments: (Array with: self streamVariable)! !

!PPCompiler methodsFor: 'inlining' stamp: 'lr 8/8/2010 13:21'!
inlineSelf: aNode for: aParser
	| method |
	method := (model classNamed: aParser class name)
		parseTreeFor: aNode selector.
	self inlineAll: method for: aParser.
	self compile: method classified: self protocolUtilities.
	^ aNode! !

!PPCompiler methodsFor: 'inlining' stamp: 'lr 8/8/2010 14:59'!
inlineSuper: aNode for: aParser
	| method |
	self halt.
	method := (model classNamed: aParser class name) superclass 
		parseTreeFor: aNode selector.
	method selector: 'super' , aParser class name , method selector.
	self inlineAll: method for: aParser.
	self compile: method classified: self protocolUtilities.
	^ aNode receiver: (RBVariableNode named: 'self'); selector: method selector! !

!PPCompiler methodsFor: 'inlining' stamp: 'lr 8/8/2010 13:28'!
inlineVariable: aNode for: aParser
	| value |
	value := self lookupValue: aNode in: aParser ifAbsent: [ ^ aNode ].
	value isLiteral
		ifTrue: [ ^ self inlineLiteral: aNode for: aParser value: value ].
	value isBlock
		ifTrue: [ ^ self inlineBlock: aNode for: aParser value: value ].
	value isBehavior
		ifTrue: [ ^ self inlineGlobal: aNode for: aParser value: value ].
	^ aNode! !

!PPCompiler methodsFor: 'utilities' stamp: 'lr 8/8/2010 13:26'!
lookupValue: aNode in: aParser ifAbsent: aBlock
	| index |
	(aNode whoDefines: aNode name) notNil
		ifTrue: [ ^ aBlock value ].
	index := aParser class allInstVarNames
		indexOf: aNode name
		ifAbsent: [ nil ].
	index isNil
		ifFalse: [ ^ aParser instVarAt: index ].
	(aParser class bindingOf: aNode name) isNil
		ifFalse: [ ^ aParser class bindingOf: aNode name ].
	^ aBlock value! !

!PPCompiler methodsFor: 'accessing' stamp: 'lr 8/7/2010 10:39'!
parser: aParser
	parser := aParser! !

!PPCompiler methodsFor: 'configuration' stamp: 'lr 8/8/2010 12:31'!
protocol
	^ 'generated'! !

!PPCompiler methodsFor: 'configuration' stamp: 'lr 8/8/2010 12:52'!
protocolNamed
	^ self protocol , '-parser'! !

!PPCompiler methodsFor: 'configuration' stamp: 'lr 8/8/2010 12:32'!
protocolUnnamed
	^ self protocol , '-unnamed'! !

!PPCompiler methodsFor: 'configuration' stamp: 'lr 8/8/2010 12:32'!
protocolUtilities
	^ self protocol , '-utilities'! !

!PPCompiler methodsFor: 'utilities' stamp: 'lr 8/7/2010 19:44'!
rewrite: aNode using: aRewriter
	"Apply aRewriter repeatedly to aNode until no more changes can be performed."

	| tree |
	tree := aNode.
	[ aRewriter executeTree: tree ]
		whileTrue: [ tree := aRewriter tree ].
	^ tree! !

!PPCompiler methodsFor: 'configuration' stamp: 'lr 8/7/2010 17:51'!
streamVariable
	^ RBVariableNode named: 'aStream'! !

!PPCompiler methodsFor: 'transformation' stamp: 'lr 8/7/2010 20:00'!
uniqueSelectorFor: aParser
	| baseName counter |
	selectors at: aParser ifPresent: [ :selector | ^ selector ].
	baseName := aParser name.
	(baseName isNil or: [ baseName isEmpty ])
		ifTrue: [ baseName := 'Unnamed' ]
		ifFalse: [ 
			baseName := baseName select: [ :each | each isAlphaNumeric ].
			baseName isEmpty
				ifFalse: [ baseName at: 1 put: baseName first asUppercase ] ].
	baseName := 'parse' , baseName.
	(selectors values includes: baseName , 'On:')
		ifFalse: [ ^ selectors at: aParser put: baseName , 'On:' ].
	counter := 1.
	[ selectors values includes: baseName , (counter asString padded: #left to: 4 with: $0) , 'On:' ]
		whileTrue: [ counter := counter + 1 ].
	^ selectors at: aParser put: baseName , (counter asString padded: #left to: 4 with: $0) , 'On:'! !

!PPVisitor methodsFor: 'initialization' stamp: 'lr 8/7/2010 18:44'!
initialize
	dispatcher := IdentityDictionary new.
	(Pragma allNamed: #accept: from: self class to: PPVisitor)
		do: [ :each | dispatcher at: each arguments first put: each selector ]! !

!PPVisitor methodsFor: 'visiting' stamp: 'lr 8/7/2010 18:45'!
visit: anObject
	^ self visit: anObject class: anObject class! !

!PPVisitor methodsFor: 'visiting' stamp: 'lr 8/7/2010 18:53'!
visit: anObject class: aClass
	| selector |
	aClass isNil
		ifTrue: [ ^ nil ].
	selector := dispatcher
		at: aClass name
		ifAbsent: [ ^ self visit: anObject class: aClass superclass ].
	^ selector numArgs = 1
		ifTrue: [ self perform: selector with: anObject ]
		ifFalse: [ self perform: selector with: anObject with: [ self visit: anObject class: aClass superclass ] ]! !