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

"{ NameSpace: Smalltalk }"

Object subclass:#PPCScanner

	instanceVariableNames:'match matchPosition matches tokens stream currentChar

		maxSymbolNumber position'

	classVariableNames:''

	poolDictionaries:''

	category:'PetitCompiler-Scanner'

!

!PPCScanner class methodsFor:'as yet unclassified'!

acceptsLoggingOfCompilation

"	^ self == PPCScanner"

    ^ true

! !

!PPCScanner methodsFor:'accessing'!

maxSymbolNumber

    ^ maxSymbolNumber

!

maxSymbolNumber: value

    maxSymbolNumber := value

!

position

    "returns the start position before the scan method..."

    ^ position

!

stream

    ^ stream

!

stream: anObject

    stream := anObject

! !

!PPCScanner methodsFor:'initialization'!

initialize

    super initialize.

    maxSymbolNumber := self class classVarNamed: #MaxSymbolNumber.

    tokens := self class classVarNamed: #Tokens.

    matches := Array new: maxSymbolNumber withAll: -2.

    position := 0.

!

reset

    matchPosition := nil. "This flag says that multimode run the last time"

    position := stream position.

"	matches := Array new: maxSymbolNumber."

!

reset: tokenList

    "Method should not be used, it is here for debugging and testing purposes"

    self error: 'deprecated'.

    matchPosition := nil. "This flag says that multimode run the last time"

    tokens := tokenList.

    matches := Array new: tokens size.

!

resetDistinct

"	matches := IdentityDictionary new.	"

    match := nil.

    matchPosition := -1.						"this is a flag that the distnict mode was running"

"	matches := nil."

    position := stream position.

! !

!PPCScanner methodsFor:'results'!

backtrack

    matchPosition := nil.

    match := nil.

    matches := Array new: maxSymbolNumber withAll: -2.

    position := 0.

!

backtrackDistinct

    matchPosition := nil.

    match := nil.

    position := 0.

!

backtracked

    ^ position == 0

!

indexOf: symbol

    (1 to: tokens size) do: [ :index | (tokens at: index) == symbol ifTrue: [^ index ] ]. 

!

match

"	^ match isNil not."

    ^ match isNotNil

"	^ matchPosition isNil not"

!

match: symbolNumber

"	matches isNil ifTrue: [ ^ false ]."

    "

        The general idea here is optimization. I cannot initialize 

        the matches before each token, it would be too expensive.

    "

    ^ (matches at: symbolNumber) > position

!

matchSymbol: symbol

    matches isNil ifTrue: [ ^ false ].

    (1 to: tokens size) do: [ :index | (tokens at: index) == symbol ifTrue: [

        ^ (matches at: index) > position

    ] ]. 

!

polyResult

    | dictionary |

    "TODO JK: refactor"	

    self isSingleMatch ifFalse: [ 

        dictionary := IdentityDictionary new.

        (1 to: matches size) do: [ :index | 

            (self match: index) ifTrue: [ 

                dictionary 

                    at: (tokens at: index)

                    put: (matches at: index)

            ]

        ].

        ^ dictionary

    ].

    dictionary := IdentityDictionary new.

    match isNil ifFalse: [ 

        dictionary at: match put: matchPosition.

    ].

    ^ dictionary

!

result

    ^ match

!

resultPosition

    ^ matchPosition

!

resultPosition: symbolNumber

    ^ matches at: symbolNumber

!

resultPositionForSymbol: symbol

    tokens isNil ifTrue: [ ^ false ].

    (1 to: tokens size) do: [ :index | (tokens at: index) == symbol ifTrue: [

        ^ matches at: index

    ] ]. 

! !

!PPCScanner methodsFor:'results - distinct'!

recordDistinctMatch: matchValue

    match := matchValue.

    matchPosition := stream position.

!

recordDistinctMatch: matchValue offset: offset

    match := matchValue.

    currentChar isNil ifFalse: [ 

        matchPosition := stream position - offset.

    ] ifTrue: [ 

        matchPosition := stream position.

    ]

!

returnDistinct

    ^ match isNotNil

! !

!PPCScanner methodsFor:'results - universal'!

recordFailure: index

    matches at: index put: -1.

!

recordFailure: index offset: offset

    matches at: index put: -1.

!

recordMatch: index

 	matches at: index put: stream position.

!

recordMatch: index offset: offset

    currentChar isNil ifFalse: [ 

        matches at: index put: stream position - offset.

    ] ifTrue: [ 

        matches at: index put: stream position.

    ].

!

return

    ^ matches

! !

!PPCScanner methodsFor:'scanning'!

next

    self error: 'deprecated?'.

    stream next

!

peek

    ^ currentChar

!

peekBetween: start and: stop

    (currentChar == nil) ifTrue: [ ^ false ].

    ^ (start <= currentChar codePoint) and: [ currentChar codePoint <= stop ]

!

step

    currentChar := stream next

! !

!PPCScanner methodsFor:'testing'!

isSingleMatch

    ^ (matchPosition == nil) not

! !