"

 COPYRIGHT (c) 1989 by Claus Gittinger

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

Scanner subclass:#Parser

       instanceVariableNames:'classToCompileFor selfValue

                              contextToEvaluateIn

                              selector

                              methodArgs methodArgNames 

                              methodVars methodVarNames 

                              tree

                              currentBlock

                              usedInstVars usedClassVars usedVars

                              modifiedInstVars modifiedClassVars

                              localVarDefPosition

                              evalExitBlock

                              selfNode superNode 

                              hasPrimitiveCode primitiveNr logged

                              warnedUndefVars

                              correctedSource'

       classVariableNames:'PrevClass PrevInstVarNames 

                           PrevClassVarNames PrevClassInstVarNames

                           LazyCompilation'

       poolDictionaries:''

       category:'System-Compiler'

!

Parser comment:'

COPYRIGHT (c) 1989 by Claus Gittinger

             All Rights Reserved

'!

!Parser class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1989 by Claus Gittinger

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

version

"

"

!

documentation

"

    Parser is used for both parsing and evaluating smalltalk expressions;

    it first builds a parseTree which is then interpreted (evaluate) or

    compiled. Compilation is done in the subclass ByteCodeCompiler and/or

    the (planned) MachineCodeCompiler.

    methods of main interrest are:

        Parser evaluateExpression:...

    and:

        Parser parseExpression:...

        Parser parseMethod:...

    there is protocol to parse complete methods, selector specs, body only etc.

    Parser is also used to find the referenced/modified inst/classvars of

    a method - this is done by sending parseXXX message to a parser and asking

    the parser for referencedXVars or modifiedXVars (see SystemBrowser).

    You can also use parsers for all kinds of other things (ChangesBrowser for

    example analyzes the expressions in the changelist ...) by looking at the

    parsers tree. (Although this is somewhat dangerous, since it exports the

    compilers internals ... better style is to add specialized query methods here,

    which will be done incrementally.)

    One instance of Parser is created to parse one method or expression - i.e.

    its not suggested to reuse parsers.

    Instance variables:

        classToCompileFor   <Class>             the class (or nil) we are compiling for

        selfValue           <any>               value to use as self when interpreting

        contextToEvaluateIn <Context>           the context (or nil) when interpreting

        selector            <Symbol>            the selector of the parsed method

                                                (valid after parseMethodSpecification)

        methodArgs                              internal

        methodArgNames      <Collection>        the names of the arguments

                                                (valid after parseMethodSpecification)

        methodVars                              internal

        methodVarNames      <Collection>        the names of the method locals

                                                (valid after parseMethodBodyVarSpec)

        tree                <ParseTree>         the parse tree - valid after parsing

        currentBlock                            if currently parsing for a block

        usedInstVars                            set of all accessed instances variables

                                                (valid after parsing)

        usedClassVars                           same for classVars

        usedVars                                all used variables (inst, class & globals)

        modifiedInstVars                        set of all modified instance variables

        modifiedClassVars                       same for clasVars

        localVarDefPosition <Integer>           the character offset of the local variable

                                                def. (i.e. the first '|' if any)

                                                Not yet used - prepared for automatic add of

                                                undefined variables

        evalExitBlock                           internal for interpretation

        selfNode            <Node>              cached one-and-only 'self' node

        superNode           <Node>              cached one-and-only 'super' node

        hasPrimitiveCode    <Boolean>           true, if it contains ST/X style primitive code

        primitiveNr         <Integer>           the parsed ST-80 type primitive number (or nil)

        logged

        warnedUndefVars     <Set>               set of all variables which the parser has

                                                already output a warning (to avoid multiple

                                                warnings about the same variable)

    Class variables:

        PrevClass           <Class>             class, of which properties are

                                                cached in:

        PrevInstVarNames      <Collection>      instance variablenames of cached class

        PrevClassVarNames     <Collection>      class variablenames of cached class

        PrevClassInstVarNames <Collection>      class instance variablenames of cached class

        LazyCompilation     <Boolean>           EXPERIMENTAL: lazy compilation

"

! !

!Parser class methodsFor:'evaluating expressions'!

evaluate:aStringOrStream

    "return the result of evaluating an expression in aStringOrStream"

    ^ self 

        evaluate:aStringOrStream 

        in:nil 

        receiver:nil 

        notifying:nil 

        logged:false

        ifFail:nil 

    "

     Compiler evaluate:'1 + 2'

     Compiler evaluate:'''hello world'' asSortedCollection displayString printNL'

     Compiler evaluate:'''hello world'' asSortedCollection printNL'

    "

!

evaluate:aStringOrStream ifFail:failBlock

    "return the result of evaluating an expression in aStringOrStream.

     In case of any syntax errors, return the value of failBlock."

    ^ self 

        evaluate:aStringOrStream 

        in:nil 

        receiver:nil 

        notifying:nil 

        logged:false

        ifFail:failBlock 

    "

     Compiler evaluate:'1 +' ifFail:['oops']   

    "

!

evaluate:aStringOrStream logged:logged

    "return the result of evaluating an expression in aStringOrStream"

    ^ self 

        evaluate:aStringOrStream 

        in:nil 

        receiver:nil 

        notifying:nil 

        logged:logged

        ifFail:nil 

!

evaluate:aStringOrStream notifying:requestor

    "return the result of evaluating aString, 

     errors are reported to requestor"

    ^ self 

        evaluate:aStringOrStream 

        in:nil 

        receiver:nil 

        notifying:requestor

        logged:false

        ifFail:nil 

!

evaluate:aStringOrStream receiver:anObject notifying:requestor

    "return the result of evaluating aString, 

     errors are reported to requestor. Allow access to

     anObject as self and to its instVars (used in the inspector)"

    ^ self 

        evaluate:aStringOrStream

        in:nil

        receiver:anObject

        notifying:requestor

        logged:false

        ifFail:nil

!

evaluate:aStringOrStream in:aContext receiver:anObject 

                                    notifying:requestor

                                       ifFail:failBlock

    ^ self 

        evaluate:aStringOrStream

        in:nil

        receiver:anObject

        notifying:requestor

        logged:false

        ifFail:nil

!

evaluate:aStringOrStream in:aContext receiver:anObject notifying:requestor logged:logged ifFail:failBlock

    "return the result of evaluating aStringOrStream, errors are reported to requestor. 

     Allow access to anObject as self and to its instVars (used in the inspector).

     If logged is true, an entry is added to the change-file. If the failBlock argument

     is non-nil, it is evaluated if an error occurs."

    "XXX: logging is not yet implemented"

    |parser tree mustBackup|

    aStringOrStream isNil ifTrue:[^ nil].

    aStringOrStream isStream ifTrue:[

        parser := self for:aStringOrStream.

        mustBackup := true

    ] ifFalse:[

        parser := self for:(ReadStream on:aStringOrStream).

        mustBackup := false

    ].

    parser setSelf:anObject.

    parser setContext:aContext.

    parser notifying:requestor.

    parser nextToken.

    tree := parser parseMethodBodyOrNil.

    "if reading from a stream, backup for next expression"

    mustBackup ifTrue:[

        parser backupPosition

    ].

    (parser errorFlag or:[tree == #Error]) ifTrue:[

        failBlock notNil ifTrue:[

            ^ failBlock value

        ].

        ^ #Error

    ].

    tree notNil ifTrue:[

        parser evalExitBlock:[:value | ^ value].

        ^ tree evaluate

    ].

    ^ nil

! !

!Parser class methodsFor:'instance creation'!

    |parser|

    parser setClassToCompileFor:aClass.

    ^ parser

! !

!Parser class methodsFor:'parsing'!

selectorInExpression:aString

    |tree parser|

    (aString isNil or:[aString isEmpty]) ifTrue:[^ nil].

    (tree notNil and:[tree ~~ #Error]) ifTrue:[

        tree isAssignment ifTrue:[

            tree expression isMessage ifTrue:[

                tree := tree expression

            ]

        ].

        tree isMessage ifTrue:[

            ^ tree selector

        ].

    ].

    parser := self for:(ReadStream on:aString).

    parser ignoreErrors.

    parser nextToken.

    ^ parser degeneratedKeywordExpressionForSelector

"

    Parser selectorInExpression:'foo at:1 put:(5 * bar)'     

    Parser selectorInExpression:'(foo at:1) at:1'           

    Parser selectorInExpression:'1 + 4'                     

    Parser selectorInExpression:'1 negated'                 

    Parser selectorInExpression:'at:1 put:5'            

    Parser selectorInExpression:'a := foo at:1 put:5'    

"

!

parseExpression:aString

!

withSelf:anObject parseExpression:aString notifying:someOne 

    "parse aString as an expression with self set to anObject;

!

withSelf:anObject parseExpression:aString notifying:someOne ignoreErrors:ignore

    "parse aString as an expression with self set to anObject;

    |parser tree|

    aString isNil ifTrue:[^ nil].

    parser := self for:(ReadStream on:aString).

    parser setSelf:anObject.

    parser notifying:someOne.

    parser nextToken.

    tree := parser expression.

    (parser errorFlag or:[tree == #Error]) ifTrue:[^ #Error].

    ^ tree

!

parseMethodSpecification:aString

    "parse a methods selector & arg specification; 

    ^ self parseMethodSpecification:aString in:nil

    "

     |p|

     p := Parser parseMethodSpecification:'foo:arg1 bar:arg2 baz:arg3'.

     'nArgs: ' print. p numberOfMethodArgs printNL.

     'args:  ' print. p methodArgs printNL.

     'sel:   ' print. p selector printNL

    "

!

parseMethodSpecification:aString in:aClass

    "parse a methods selector & arg spec for a given class;

    |parser tree|

    aString isNil ifTrue:[^ nil].

    parser := self for:(ReadStream on:aString) in:aClass.

    parser nextToken.

    tree := parser parseMethodSpec.

    (parser errorFlag or:[tree == #Error]) ifTrue:[^ #Error].

    ^ parser

!

parseMethodArgAndVarSpecification:aString

    ^ self parseMethodArgAndVarSpecification:aString in:nil

    "

     |p|

     'nArgs:  ' print. p numberOfMethodArgs printNL.

     'args:   ' print. p methodArgs printNL.

     'sel:    ' print. p selector printNL.

     'nLocal: ' print. p numberOfMethodVars printNL.

     'locals: ' print. p methodVars printNL.

    "

!

parseMethodArgAndVarSpecification:aString in:aClass

    |parser|

    aString isNil ifTrue:[^ nil].

    parser := self for:(ReadStream on:aString) in:aClass.

    parser nextToken.

    (parser parseMethodSpec == #Error) ifTrue:[^ nil].

    (parser parseMethodBodyVarSpec == #Error) ifTrue:[^ nil].

    parser errorFlag ifTrue:[^ nil].

    ^ parser

!

parseMethod:aString