"

 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.

"

"{ Package: 'stx:libcomp' }"

ParseNode subclass:#MessageNode

	instanceVariableNames:'receiver selector argArray lineNr selectorPosition'

	classVariableNames:''

	poolDictionaries:''

	category:'System-Compiler-Support'

!

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

"

    node for parse-trees, representing message sends

    This is a helper class for the compiler.

    [author:]

	Claus Gittinger

"

! !

!MessageNode class methodsFor:'instance creation'!

receiver:recNode selector:selectorString 

    ^ (self basicNew) receiver:recNode selector:selectorString args:nil lineno:0

!

receiver:recNode selector:selectorString arg1:arg1Node arg2:arg2Node

    ^ self receiver:recNode selector:selectorString arg1:arg1Node arg2:arg2Node fold:nil

!

receiver:recNode selector:selectorString arg1:argNode1 arg2:argNode2 fold:folding

    |result recVal argVal selector|

    "

     This is just a demonstration - of how complex constants can be folded.

     This was inspired by some discussion in c.l.s about enhancing the language - I prefer

     enhancing the compiler ....

     The following optimization will convert '#(...) with:#(...) collect:[...]' into an array constant,

     allowing constant arrays of complex objects.

     Notice: this method is normally disabled - its just a demo after all.

    "

    folding notNil ifTrue:[

        "/

        "/ do constant folding ...

        "/

        (recNode isConstant and:[argNode1 isConstant]) ifTrue:[

            "check if we can do it ..."

            selector := selectorString asSymbolIfInterned.

            selector notNil ifTrue:[

                recVal := recNode evaluate.

                (recVal respondsTo:selector) ifTrue:[

                    "

                     we could do much more here - but then, we need a dependency from

                     the folded selectors method to the method we generate code for ...

                     limit optimizations to those that will never change

                     (or - if you change them - you will crash so bad ...)

                    "

                    argVal := argNode1 evaluate.

                    ((recVal isMemberOf:Array) and:[argVal isMemberOf:Array]) ifTrue:[

                        folding == #full ifTrue:[

                            (selector == #with:collect:) ifTrue:[

                                (argNode2 isBlock) ifTrue:[

                                    SignalSet anySignal handle:[:ex |

                                        ^ ParseErrorNode errorString:'error in constant expression (' , ex description , ')'

                                    ] do:[

                                        result := recVal perform:selector with:argVal with:(argNode2 evaluate).

                                    ].

                                    ^ ConstantNode type:(ConstantNode typeOfConstant:result) value:result

                                ]

                            ]

                        ]

                    ]

                ]

            ]

        ]

    ].

    ^ (self basicNew) receiver:recNode selector:selectorString args:(Array with:argNode1 with:argNode2) lineno:0

    "Modified: 28.6.1997 / 15:16:01 / cg"

!

receiver:recNode selector:selectorString arg:argNode

    ^ self receiver:recNode selector:selectorString arg:argNode fold:nil

!

receiver:recNode selector:selectorString arg:argNode fold:folding

    |result recVal argVal selector globalName canFold|

   "

     The constant folding code can usually not optimize much

     - this may change when some kind of constant/macro declaration is added to smalltalk,

     so that constant classVars can be inlined.

    "

    folding notNil ifTrue:[

        selector := selectorString asSymbolIfInterned.

        selector notNil ifTrue:[

            "/

            "/ do constant folding ...

            "/

            canFold := false.

            (recNode isGlobal and:[argNode isConstant]) ifTrue:[

                globalName := recNode name.

                recVal := recNode evaluate.

                (globalName = 'SmallInteger') ifTrue:[

                    ( #( bitMaskFor: ) includes:selector)

                    ifTrue:[

                        canFold := true

                    ]

                ].

            ].

            (recNode isConstant and:[argNode isConstant]) ifTrue:[

                "check if we can do it ..."

                recVal := recNode evaluate.

                "

                 we could do much more here - but then, we need a dependency from

                 the folded selectors method to the method we generate code for ...

                 limit optimizations to those that will never change

                 (or - if you change them - you will crash so bad ...)

                "

                argVal := argNode evaluate.

                (recVal respondsToArithmetic and:[argVal respondsToArithmetic]) ifTrue:[

                    ( #( + - * / // \\ min: max: quo:) includes:selector) ifTrue:[

                        (#( / // \\ ) includes:selector) ifTrue:[

                            argVal = 0 ifTrue:[

                                ^ ParseErrorNode errorString:'division by zero in constant expression'

                            ].

                        ].

                        canFold := true

                    ].

                    ( #( @ ) includes:selector) ifTrue:[

                        canFold := (folding == #full)

                    ]

                ].

                (recVal isInteger and:[argVal isInteger]) ifTrue:[

                    ( #( bitShift: bitOr: bitAnd: ) includes:selector) ifTrue:[

                        canFold := true

                    ]

                ].

                (recVal isMemberOf:String) ifTrue:[

                    (argVal isInteger and:[selector == #at:]) ifTrue:[

                        canFold := folding isSymbol

                                   and:[(folding >= #level2) or:[folding == #full]].

                    ].

                    selector == #',' ifTrue:[

                        (argVal isMemberOf:String) ifTrue:[

                            canFold := folding isSymbol

                                       and:[(folding >= #level2) or:[folding == #full]].

                        ].

                        (argVal isMemberOf:Character) ifTrue:[

                            canFold := folding isSymbol

                                       and:[(folding >= #level2) or:[folding == #full]].

                        ].

                    ]

                ].

            ].

            canFold ifTrue:[

                (recVal respondsTo:selector) ifTrue:[

                    SignalSet anySignal handle:[:ex |

                        ^ ParseErrorNode errorString:'error in constant expression (' , ex description , ')'

                    ] do:[

                        result := recVal perform:selector with:argVal.

                    ].

                    ^ ConstantNode type:(ConstantNode typeOfConstant:result) value:result

                ]

            ]

        ].

        "/

        "/ #perform with a constant selector

        "/

        (selector == #perform: 

        and:[argNode isConstant]) ifTrue:[

            argVal := argNode evaluate.

            argVal isSymbol ifTrue:[

                ^ UnaryNode receiver:recNode selector:argVal fold:folding

            ]

        ].

    ].

    ^ (self basicNew) receiver:recNode selector:selectorString args:(Array with:argNode) lineno:0

    "Modified: / 16.11.1999 / 21:50:33 / cg"

!

receiver:recNode selector:selectorString args:anArray

    ^ self receiver:recNode selector:selectorString args:anArray fold:nil

!

receiver:recNode selector:selectorString args:argArray fold:folding

    |numArgs arg1 arg1Val|

    folding notNil ifTrue:[

        numArgs := argArray size.

        numArgs > 0 ifTrue:[

            arg1 := (argArray at:1).

            (numArgs == 1) ifTrue:[

                ^ self receiver:recNode selector:selectorString arg:arg1 fold:folding 

            ].

            "/

            "/ #perform:... with a constant selector

            "/

            numArgs <= 6 ifTrue:[

                (#(nil

                   #'perform:with:'

                   #'perform:with:with:'

                   #'perform:with:with:with:'

                   #'perform:with:with:with:with:'

                   #'perform:with:with:with:with:with:'

                   #'perform:with:with:with:with:with:with:'

                ) at:numArgs) = selectorString 

                ifTrue:[

                    arg1 isConstant ifTrue:[    

                        arg1Val := arg1 evaluate.

                        arg1Val isSymbol ifTrue:[

                            ^ MessageNode 

                                    receiver:recNode 

                                    selector:arg1Val

                                    args:(argArray copyFrom:2)

                                    fold:folding

                        ]

                    ]

                ]

            ].

        ].

        (numArgs == 2) ifTrue:[

            ^ self receiver:recNode selector:selectorString arg1:arg1 arg2:(argArray at:2) fold:folding 

        ].

        numArgs > Method maxNumberOfArguments ifTrue:[

            ^ ParseErrorNode errorString:'too many arguments for current VM implementation'.

        ].

    ].

    ^ (self basicNew) receiver:recNode selector:selectorString args:argArray lineno:0

    "Modified: / 3.9.1995 / 16:41:39 / claus"

    "Modified: / 15.5.1998 / 15:32:05 / cg"

! !

!MessageNode methodsFor:'accessing'!

arg1

    ^ argArray at:1

!

args

    ^ argArray

!

arguments

    ^ argArray ? #()

    "Created: 19.6.1997 / 17:31:14 / cg"

    "Modified: 19.6.1997 / 17:32:25 / cg"

!

lineNumber

     ^ lineNr

!

lineNumber:num

     lineNr := num

!

receiver

    ^ receiver

!

receiver:r selector:s args:a lineno:l

    receiver := r.

"/ create the symbol only, if the symbol is already known in the system.

"/ otherwise a lot of partial symbols will be created by the SyntaxHighlighter

"/ during typing

"/    selector := s asSymbol.

    selector := s asSymbolIfInterned ? s.

    argArray := a.

    lineNr := l.

    self checkInlinability.

    "Modified: 2.7.1997 / 17:01:24 / cg"

!

selector

    ^ selector

!

selector:s

"/ create the symbol only, if the symbol is already known in the system.

"/ otherwise a lot of partial symbols will be created by the SyntaxHighlighter

"/ during typing

"/    selector := s asSymbol.

    selector := s asSymbolIfInterned ? s.

"/    selector := s asSymbol.

!

selectorPosition

    "return the value of the instance variable 'selectorPosition' (automatically generated)"

    ^ selectorPosition

    "Created: 5.8.1997 / 02:49:27 / cg"

!

selectorPosition:something

    "set the value of the instance variable 'selectorPosition' (automatically generated)"

    selectorPosition := something.

    "Created: 5.8.1997 / 02:49:27 / cg"

! !

!MessageNode methodsFor:'checks'!

checkCondition

    |args lastArg|

    receiver isBlock ifTrue:[

        (Block canUnderstand:selector) ifFalse:[

            ^ 'blocks usually do not respond to ' , selector , ' messages'

        ].

    ].

    "/ (rr keyw:ra = a) ifTrue:[ ...]

    receiver isMessage ifTrue:[

        (receiver numArgs > 0) ifTrue:[

            (receiver selector isKeyword) ifTrue:[

                (args := receiver arguments) notEmptyOrNil ifTrue:[

                    (lastArg := args last) isMessage ifTrue:[

                        lastArg parenthized ifFalse:[

                            (#( #'=' #'~=' #'==' #'~~' '>' '<' '>=' '<=') 

                            includes:(lastArg selector)) ifTrue:[

                            ]

                        ]

                    ]

                ]

            ]

        ].

    ].

    ^ nil

!

checkInlinability

    "early check for possible inlinability"

    |numArgs arg1 arg2 arg3|

    (numArgs := argArray size) >= 1 ifTrue:[

        arg1 := argArray at:1.

    ].

    numArgs == 0 ifTrue:[

        (selector == #whileTrue 

        or:[selector == #whileFalse]) ifTrue:[

            receiver isBlock ifTrue:[

                receiver possiblyInlined:true

            ].

        ].

        (selector == #value) ifTrue:[

            receiver isBlock ifTrue:[

                receiver possiblyInlined:true

            ].

        ].

        ((selector == #repeat) or:[selector == #loop]) ifTrue:[

            receiver isBlock ifTrue:[

                receiver possiblyInlined:true

            ].

        ].

    ].

    numArgs == 1 ifTrue:[

        (selector == #or: 

        or:[selector == #and:]) ifTrue:[

            arg1 isBlock ifTrue:[

                arg1 possiblyInlined:true

            ].

        ].

        (selector == #ifTrue: 

        or:[selector == #ifFalse:

        or:[selector == #ifNil:

        or:[selector == #ifNotNil:]]]) ifTrue:[

            arg1 isBlock ifTrue:[

                arg1 possiblyInlined:true

            ].

        ].

        (selector == #whileTrue: 

        or:[selector == #whileFalse:]) ifTrue:[

            arg1 isBlock ifTrue:[

                arg1 possiblyInlined:true

            ].

            receiver isBlock ifTrue:[

                receiver possiblyInlined:true

            ].

        ].

        selector == #timesRepeat: ifTrue:[

            arg1 isBlock ifTrue:[

                arg1 possiblyInlined:true withSelector:selector.

            ]

        ].

        ^ self

    ].

    numArgs >= 2 ifTrue:[

        arg2 := argArray at:2.

    ].    

    numArgs == 2 ifTrue:[

        (selector == #ifTrue:ifFalse:

        or:[selector == #ifFalse:ifTrue:

        or:[selector == #ifNil:ifNotNil:

        or:[selector == #ifNotNil:ifNil:]]]) ifTrue:[

            (arg1 isBlock 

            and:[arg2 isBlock]) ifTrue:[

                arg1 possiblyInlined:true.

                arg2 possiblyInlined:true.

            ].

        ].

        selector == #to:do: ifTrue:[

            arg2 isBlock ifTrue:[

                arg2 possiblyInlined:true withSelector:selector.

            ].

        ].

        ^ self

    ].

    numArgs >= 3 ifTrue:[

        arg3 := argArray at:3.

    ].    

    numArgs == 3 ifTrue:[

        selector == #to:by:do: ifTrue:[

            arg3 isBlock ifTrue:[

                arg3 possiblyInlined:true withSelector:selector.

            ].

        ].

        ^ self

    ].

    ^ self

    "Created: / 2.7.1997 / 17:01:10 / cg"

    "Modified: / 2.4.1998 / 19:08:54 / cg"

!

plausibilityCheck

    |rec arg1 arg2 arg1Value operand msg|

    (argArray size > 0) ifTrue:[

        arg1 := argArray at:1

    ].

    "

     it once took me almost an hour, to find a '==' which

     should have been an '=' (you cannot compare floats with ==)