"

 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 parseForCode usedInstVars usedClassVars usedVars

		modifiedInstVars modifiedClassVars modifiedGlobals usesSuper

		usedGlobals usedSymbols usedMessages localVarDefPosition

		evalExitBlock selfNode superNode hasPrimitiveCode

		hasNonOptionalPrimitiveCode primitiveNr primitiveResource logged

		warnedUndefVars warnSTXHereExtensionUsed correctedSource

		foldConstants lineNumberInfo currentNamespace

		currentUsedNamespaces warnUndeclared'

	classVariableNames:'PrevClass PrevInstVarNames PrevClassVarNames

		PrevClassInstVarNames LazyCompilation ArraysAreImmutable

		ImplicitSelfSends WarnST80Directives FoldConstants LineNumberInfo

		SuppressDoItCompilation EmptySourceNotificationSignal'

	poolDictionaries:''

	category:'System-Compiler'

!

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

"

!

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

  Constant folding:

    The parser has various modes for constant folding; by default, only numeric

    expressions involving integers and floats are constant folded

    (i.e. something like 'Float pi sin' or '1.5 + 0.3' will be reduced to a constant).

    Constant folding can be turned off completely (setting FoldConstants to nil)

    to ``secure folding'', which only folds constant numbers (#level1) or to #full. 

    In full mode, more constant expressions are folded (for example: '1.0 @ 1.0' is 

    reduced to a constant point), but the resulting code may not be compatible with other 

    smalltalk systems (consider the case, where the point is modified using #x: or #y: messages). 

    Therefore, this mode is a bit dangerous and disabled by default.

  Immutable arrays:

    Immutable arrays are experimental and being evaluated.

    Consider the case of a method returning '#(1 2 3 4)', and that array being modified

    by some other method (using #at:put:). Since the array-return is actually a return of

    a reference to the compiler created array, the next invokation of the method will

    return the modified array. These are hard to find bugs.

    By an option, the compiler can generate immutable arrays, which dont allow modification

    of its elements. For clean code, you should enable this option during development.

    As mentioned above, this is experimental. If it is reported to be a useful feature,

    the immutable feature will be extended to strings, point-literals etc. in a future version

    of st/x.

    [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

	hasNonOptionalPrimitiveCode    

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

						which is NOT flagged by the OPTIONAL directive.

	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

	ArraysAreImmutable    <Boolean>         if true, create array literals

						as instances of ImmutableArray,

						which cannot be stored into.

						Default is false, for compatibility.

						Can be turned on while developping

						new code to make certain that side

						effects are avoided.

	WarnST80Directives    <Boolean>         if true, give warnings about

						ST-80 directives (resource defs)

						which are ignored in st/x.

						defaults to false.

	FoldConstants         <Symbol>          controls how constant folding should be

						done.

						Can be one of:

							nil      - no constant folding

							#level1  - numeric optimizations only

							#level2  - secure optimizations only

							#full    - full folding

						level1:   arithmetic on constant numbers

						level2:   above PLUS array conversions with #asFloatArray,

							  #asDoubleArray, string concatenation

						full:     constant points.

    [see also:]

	ByteCodeCompiler Scanner ObjectFileLoader

	Workspace

	SystemBrowser

    [author:]

	Claus Gittinger

"

! !

!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:'ST-80 compatibility'!

parse:aString class:aClass

    "same as #parseMethod:in: for ST80 compatibility."

    |parser|

    parser := self parseMethod:aString in:aClass.

    parser notNil ifTrue:[^ parser tree].

    ^ nil

    "Modified: 19.6.1997 / 16:34:57 / cg"

! !

!Parser class methodsFor:'Signal constants'!

emptySourceNotificationSignal

    ^ EmptySourceNotificationSignal

    "Created: 14.10.1997 / 17:03:31 / cg"

! !

!Parser class methodsFor:'changes'!

flushNameCache

    "unconditional flush name caches"

    PrevClass notNil ifTrue:[

	PrevClass removeDependent:Parser

    ].

    PrevClass := nil.

    PrevInstVarNames := nil.

    PrevClassVarNames := nil.

    PrevClassInstVarNames := nil.

    "Parser flushNameCache"

!

update:something with:someArgument from:changedObject

    "aClass has changed its definition - flush name caches if we have to"

    (changedObject == PrevClass) ifTrue:[

	something == #definition ifTrue:[

	    self flushNameCache

	]

    ]

! !

!Parser class methodsFor:'controlling compilation'!

arraysAreImmutable

    "return true if arrays are immutable literals"

    ^ ArraysAreImmutable

!

arraysAreImmutable:aBoolean

    "turn on/off immutable array literals - default is false for ST-80 compatibilty."

    ArraysAreImmutable := aBoolean.

    "

     can be added to your private.rc file:

     Compiler arraysAreImmutable:true     

     Compiler arraysAreImmutable:false      

    "

!

compileLazy

    "return true if compiling lazy"

    ^ LazyCompilation.

!

compileLazy:aBoolean

    "turn on/off lazy compilation - return previous setting.

     Actually this flag belongs into the ByteCodeCompiler subclass,

     but it also controls the reporting of some errors here; therefore

     its located here"

    |oldLazy|

    oldLazy := LazyCompilation.

    LazyCompilation := aBoolean.

    ^ oldLazy

    "

     usually set in your .rc file

     Compiler compileLazy:false         

     Compiler compileLazy:true          

    "

!

foldConstants

    "return a symbol describing how constants are to be folded"

    ^ FoldConstants

    "Created: 9.2.1996 / 17:40:13 / cg"

!

foldConstants:aSymbol

    "set the symbol describing how constants are to be folded.

     It can be:

	nil             - no constant folding

	#level1         - numeric constants only

	#level2         - level1 PLUS array conversions PLUS string concatenation

	#full           - level2 PLUS constant points, constant rectangles (dangerous)"

    FoldConstants := aSymbol

    "Created: 9.2.1996 / 17:40:34 / cg"

!

implicitSelfSends

    "return true if undefined variables with

     lowercase first character are to be turned

     into implicit self sends"

    ^ ImplicitSelfSends

!

implicitSelfSends:aBoolean

    "turn on/off implicit self sends"

    ImplicitSelfSends := aBoolean

    "

     Compiler implicitSelfSends:true

     Compiler implicitSelfSends:false 

    "

!

lineNumberInfo

    ^ LineNumberInfo

!

lineNumberInfo:aBoolean

    LineNumberInfo := aBoolean

! !

!Parser class methodsFor:'defaults'!

maxLineNumber

    "return the maximum lineNumber that is possibly

     encoded in a methods byteCode debugging information.

     Since lineNumber entries only have 1 byte available,

     this is 255 for byteCode methods."

    ^ 255

    "Created: 14.2.1997 / 16:52:54 / cg"

! !

!Parser class methodsFor:'evaluating expressions'!

evaluate:aStringOrStream

    "return the result of evaluating an expression in aStringOrStream.

     No doit-entry is added to the changeLog."

    ^ self 

	evaluate:aStringOrStream 

	in:nil 

	receiver:nil 

	notifying:nil 

	logged:false

	ifFail:nil 

	compile:true

    "

     Compiler evaluate:'1 + 2'

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

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

    "

!

evaluate:aStringOrStream compile:compile

    "return the result of evaluating aString, 

     The compile argument specifies if the string should be compiled down to 

     bytecode or instead be interpreted from the parseTree.

     The first should be done for doIts etc, where a readable walkback is

     required.

     The latter is better done for constants, styleSheet and resource

     reading and simple sends, where the overhead of compilation is bigger

     than the interpretation overhead."

    ^ self 

	evaluate:aStringOrStream

	in:nil

	receiver:nil 

	notifying:nil 

	logged:false

	ifFail:nil

	compile:compile 

!

evaluate:aStringOrStream ifFail:failBlock

    "return the result of evaluating an expression in aStringOrStream.

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

     No doit-entry is added to the changeLog."

    ^ self 

	evaluate:aStringOrStream 

	in:nil 

	receiver:nil 

	notifying:nil 

	logged:false

	ifFail:failBlock 

	compile:true

    "

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

    "

!

evaluate:aStringOrStream in:aContext receiver:anObject notifying:requestor 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).

     No doIt entry is added to the change-file. 

     If the failBlock argument is non-nil, it is evaluated if an error occurs."

    ^ self 

        evaluate:aStringOrStream

        in:aContext

        receiver:anObject

        notifying:requestor

        logged:false

        ifFail:nil

        compile:true

    "Modified: / 17.1.1998 / 02:54:07 / cg"

!

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

    ^ self 

	evaluate:aStringOrStream

	in:aContext

	receiver:anObject

	notifying:requestor

	logged:logged 

	ifFail:failBlock 

	compile:true

!

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

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

     Finally, compile specifies if the string should be compiled down to 

     bytecode or instead be interpreted from the parseTree.

     The first should be done for doIts etc, where a readable walkback is

     required.

     The latter is better done for constants, styleSheet and resource

     reading and simple sends, where the overhead of compilation is bigger

     than the interpretation overhead."

    |parser tree mustBackup loggedString chgStream value s sReal spc|

    aStringOrStream isNil ifTrue:[