"

 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

			      usesSuper  

			      localVarDefPosition

			      evalExitBlock

			      selfNode superNode 

			      hasPrimitiveCode primitiveNr logged

			      warnedUndefVars warnSTXHereExtensionUsed

			      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."

    |parser tree mustBackup loggedString chgStream value|

    aStringOrStream isNil ifTrue:[^ nil].

    aStringOrStream isStream ifTrue:[

	parser := self for:aStringOrStream.

	mustBackup := true

    ] ifFalse:[

	loggedString := aStringOrStream.

	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:[

	(logged

	and:[loggedString notNil

	and:[Smalltalk logDoits]]) ifTrue:[

	    chgStream := Class changesStream.

	    chgStream notNil ifTrue:[

		chgStream nextChunkPut:loggedString.

		chgStream cr.

		chgStream close

	    ].

	].

	"

	 if the parse tree is that of a constant, quickly return its value

	"

	tree isConstant ifTrue:[

	    ^ tree evaluate

	] ifFalse:[

	    "

	     if I am the ByteCodeCompiler,

	     generate a dummy method, execute it and return the value.

	     otherwise, just evaluate the tree; slow, but not too bad ...

	    "

"/            self == Parser ifTrue:[

		parser evalExitBlock:[:value | parser release. ^ value].

		value := tree evaluate

"/            ] ifFalse:[

"/            ]

	]

    ].

    parser release.

    ^ value

! !

!Parser class methodsFor:'instance creation'!

for:aStringOrStream in:aClass

    "return a new parser, reading code for aClass from aStringOrStream"

    |parser|

    parser := self for:aStringOrStream.

    parser setClassToCompileFor:aClass.

    ^ parser

! !

!Parser class methodsFor:'parsing'!

selectorInExpression:aString

    "parse an expression - return the selector. Even malformed expressions

     (such as missing receiver or missing arg are parsed.

     Used for the SystemBrowsers implementors/senders query-box initial text.

     Returns nil if unparsable."

    |tree parser|

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

    tree := self withSelf:nil 

		 parseExpression:aString 

		 notifying:nil 

		 ignoreErrors:true 

		 ignoreWarnings:true. 

    "

     special: take the expression of the right side, if its an

     assignment or return

    "

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

	tree isAssignment ifTrue:[

	    tree expression isMessage ifTrue:[

		tree := tree expression

	    ]

	].

	tree isReturnNode ifTrue:[

	    tree expression isMessage ifTrue:[

		tree := tree expression

	    ]

	].

	tree isMessage ifTrue:[

	    ^ tree selector

	].

    ].

    "

     mhmh, try expression without receiver

    "

    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:'a + 4'                     

    Parser selectorInExpression:'a negated'                 

    Parser selectorInExpression:'at:1 put:5'            

    Parser selectorInExpression:'at:1 put:'            

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

    Parser selectorInExpression:'a at:1 put:'            

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

"

!

parseExpression:aString

    "parse aString as an expression; 

     Return the parseTree (if ok), nil (for an empty string 

     or comment only) or #Error (syntactic error)."

    ^ self withSelf:nil 

	   parseExpression:aString 

	   notifying:nil 

	   ignoreErrors:true       "silence on Transcript"

	   ignoreWarnings:true 

!

withSelf:anObject parseExpression:aString notifying:someOne 

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

     Return the parseTree (if ok), nil (for an empty string 

     or comment only ) or #Error (syntactic error).

     Errors and warnings are forwarded to someOne (usually some

     codeView) which can highlight it and show a popup box."

    ^ self withSelf:anObject 

	   parseExpression:aString 

	   notifying:someOne 

	   ignoreErrors:false 

	   ignoreWarnings:false 

!

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

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

     Return the parseTree (if ok), nil (for an empty string 

     or comment only ) or #Error (syntactic error).

     Errors and warnings are forwarded to someOne (usually some

     codeView) which can highlight it and show a popup box."

    ^ self withSelf:anObject

	   parseExpression:aString 

	   notifying:someOne 

	   ignoreErrors:ignore 

	   ignoreWarnings:ignore 

!

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

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

     Return the parseTree (if ok), nil (for an empty string 

     or comment only ) or #Error (syntactic error).

     Errors and warnings are forwarded to someOne (usually some

     codeView) which can highlight it and show a popup box,

     iff ignoreErrors/ignoreWarnings is true respectively."

    |parser tree token|

    aString isNil ifTrue:[^ nil].

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

    parser setSelf:anObject.

    parser notifying:someOne.

    ignoreErrors ifTrue:[parser ignoreErrors].

    ignoreWarnings ifTrue:[parser ignoreWarnings].

    token := parser nextToken.

    (token == $^) ifTrue:[

	parser nextToken.

    ].

    tree := parser expression.

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

    ^ tree

!

parseMethodSpecification:aString

    "parse a methods selector & arg specification; 

     Return a parser (if ok), nil (empty) or #Error (syntax).

     The parser can be queried for selector, receiver etc."

    ^ 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;

     Return a parser (if ok), nil (empty) or #Error (syntax).

     The parser can be queried for selector, receiver etc."

    ^ self parseMethodSpecification:aString 

	   in:aClass 

	   ignoreErrors:false

	   ignoreWarnings:false 

!

parseMethodSpecification:aString in:aClass ignoreErrors:noErrors ignoreWarnings:noWarnings 

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