"

 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.

"

Parser subclass:#ByteCodeCompiler

	instanceVariableNames:'codeBytes codeIndex litArray stackDelta extra lineno extraLiteral

		maxStackDepth relocList methodTempVars numTemp maxNumTemp'

	classVariableNames:'JumpToAbsJump SequenceNumber STCCompilationDefines

		STCCompilationIncludes STCCompilationOptions STCCompilation

		ShareCode STCKeepSTIntermediate STCKeepCIntermediate

		STCModulePath CCCompilationOptions CC ListCompiledMethods'

	poolDictionaries:''

	category:'System-Compiler'

!

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

"

    This class performs compilation into ByteCodes.

    First, parsing is done using superclass methods,

    then the parse-tree is converted into an array of symbolic codes

    and a relocation table; 

    these two are finally combined into a byteArray of the codes.

    (the intermediate step through symbolic codes is for debugging

     only - it may vanish in future releases)

    There are many dependencies to the run-time-system (especially the

    interpreter) in here - be careful when playing around ...

    [Instance variables:]

        codeBytes       <ByteArry>              bytecodes

        codeIndex       <SmallInteger>          next index to put into code array

        litArray        <OrderedCollection>     literals

        stackDelta      <SmallInteger>          return value of byteCodeFor:

        extra           <Symbol>                return value of byteCodeFor:

        lineno          <Boolean>               return value of byteCodeFor:

        extraLiteral    <Symbol>                return value of byteCodeFor:

        maxStackDepth   <SmallInteger>          stack need of method

        relocList       <Array>                 used temporary for relocation

    [Class variables:]

        JumpToAbsJump   <Dictionary>            internal table to map opcodes

        SequenceNumber  <Integer>               counting intermediate stc-compiled

                                                objects (for unique o-file naming)

        STCCompilationDefines                   passed to stc as command line arguments

        STCCompilationIncludes

        STCCompilationOptions

                        <String>                

        STCCompilation  <Symbol>                #always, #primitiveOnly or #never

                                                controls when stc compilation is wanted

        ShareCode       <Boolean>               reuse byteArrays for common (simple) code sequences

                                                This is normally a 'good' optimization,

                                                expect if you plan to modify the byteCodes.

    [author:]

        Claus Gittinger

"

! !

!ByteCodeCompiler class methodsFor:'initialization'!

initialize

    ShareCode := true.

    STCKeepCIntermediate := false.

    STCKeepSTIntermediate := false.

    STCModulePath := './modules'.

    ListCompiledMethods := false.

    "Modified: 31.8.1997 / 08:47:49 / cg"

! !

!ByteCodeCompiler class methodsFor:'compiling methods'!

compile:methodText forClass:classToCompileFor

    "compile a source-string for a method in classToCompileFor"

    ^ self compile:methodText

	  forClass:classToCompileFor

	inCategory:'others'

	 notifying:nil

	   install:true

	skipIfSame:false

	    silent:false

!

compile:aString forClass:aClass inCategory:cat

    "compile a source-string for a method in classToCompileFor.

     The method will get cat as category"

    ^ self compile:aString

	  forClass:aClass

	inCategory:cat

	 notifying:nil

	   install:true

	skipIfSame:false

	    silent:false

!

compile:aString forClass:aClass inCategory:cat notifying:requestor

    "compile a source-string for a method in classToCompileFor.

     errors are forwarded to requestor.

     The method will get cat as category"

    ^ self compile:aString

	  forClass:aClass

	inCategory:cat

	 notifying:requestor

	   install:true

	skipIfSame:false

	    silent:false

!

compile:aString forClass:aClass inCategory:cat notifying:requestor install:install

    "compile a source-string for a method in classToCompileFor.

     The install-argument controls if the method is to be installed into the

     classes method-dictionary, or just to be compiled and a method object to be returned.

     Errors are forwarded to requestor. The method will get cat as category"

    ^ self compile:aString

	  forClass:aClass

	inCategory:cat

	 notifying:requestor

	   install:install

	skipIfSame:false

	    silent:false

!

compile:aString forClass:aClass inCategory:cat notifying:requestor

		 install:install skipIfSame:skipIfSame

    "compile a source-string for a method in classToCompileFor.

     The install-argument controls if the method is to be installed into the

     classes method-dictionary, or just to be compiled and a method object to be returned.

     Errors are forwarded to requestor. The method will get cat as category.

     If skipIsSame is true, and the source is the same as an existing

     methods source, this is a noop (for fast fileIn)."

    ^ self compile:aString

	  forClass:aClass

	inCategory:cat

	 notifying:requestor

	   install:install

	skipIfSame:skipIfSame

	    silent:false

!

compile:aString forClass:aClass inCategory:cat notifying:requestor

		 install:install skipIfSame:skipIfSame silent:silent

    ^ self

	compile:aString

	forClass:aClass

	inCategory:cat

	notifying:requestor

	install:install

	skipIfSame:skipIfSame

	silent:silent

	foldConstants:true

!

compile:aString forClass:aClass inCategory:cat notifying:requestor

                 install:install skipIfSame:skipIfSame silent:silent foldConstants:fold

    "the basic workhorse method for compiling:

     compile a source-string for a method in classToCompileFor.

     errors are forwarded to requestor (report on Transcript and return

     #Error, if requestor is nil).

     The new method will get cat as category. 

     If install is true, the method will go into the classes method-table, 

     otherwise the method is simply returned (for anonymous methods).

     If skipIsSame is true, and the source is the same as an existing

     methods source, this is a noop (for fast fileIn).

     The argument, silent controls if errors are to be reported."

    |compiler newMethod tree symbolicCodeArray oldMethod lazy silencio 

     sourceFile sourceStream newSource primNr pos sel keptOldCode msg answer

     pkg|

    aString isNil ifTrue:[^ nil].

    silencio := silent 

                or:[Smalltalk silentLoading == true

                or:[ListCompiledMethods == false]].

    "lazy compilation is EXPERIMENTAL"

    lazy := (LazyCompilation == true) and:[install].

    "create a compiler, let it parse and create the parsetree"

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

    compiler parseForCode.

    fold ifFalse:[compiler foldConstants:nil].

    compiler notifying:requestor.

    silent ifTrue:[

"/        compiler ignoreErrors.

    ].

"/    compiler nextToken.

    (compiler parseMethodSpec == #Error) ifTrue:[

        compiler parseError:'syntax error in method specification'.

        tree := #Error

    ] ifFalse:[

        lazy ifTrue:[

            "/

            "/ that one method IS required

            "/

            (aClass isMeta and:[compiler selector == #version]) ifTrue:[

                lazy := false

            ]

        ].

        lazy ifFalse:[

            "check if same source"

            (skipIfSame and:[(sel := compiler selector) notNil]) ifTrue:[

                oldMethod := aClass compiledMethodAt:sel.

                oldMethod notNil ifTrue:[

                    oldMethod source = aString ifTrue:[

                        oldMethod isInvalid ifFalse:[

                            silencio ifFalse:[

                                Transcript showCR:('    unchanged: ',aClass name,' ',compiler selector)

                            ].

                            "

                             same. however, category may be different

                            "

                            (cat notNil and:[cat ~= oldMethod category]) ifTrue:[

                                oldMethod category:cat.

                                oldMethod changed:#category.    

"/                                aClass updateRevisionString.

                                aClass addChangeRecordForMethodCategory:oldMethod category:cat.

                                silencio ifFalse:[

                                    Transcript showCR:('    (category change only)')

                                ].

                            ].

                            "

                             and package may be too.

                            "

                            pkg := Class packageQuerySignal raise.

                            (pkg notNil and:[pkg ~~ oldMethod package]) ifTrue:[

                                oldMethod package:pkg.

                                silencio ifFalse:[

                                    Transcript showCR:('    (package-id change only)')

                                ].

                            ].

                            ^ oldMethod

                        ]

                    ]

                ]

            ].

            tree := compiler parseMethodBody.

            compiler tree:tree.

        ]

    ].

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

        compiler showErrorMessageForClass:aClass.

        ^ #Error

    ].

    sel := compiler selector.

    "if no error and also no selector ..."

     sel isNil ifTrue:[

        "... it was just a comment or other empty stuff"

        ^ nil

    ].

    lazy ifFalse:[

        "

         freak-out support ...

        "

        (compiler hasNonOptionalPrimitiveCode 

        or:[(compiler hasPrimitiveCode and:[self canCreateMachineCode])

        or:[STCCompilation == #always and:[sel  ~~ #doIt]]]) ifTrue:[

            newMethod := compiler 

                            compileToMachineCode:aString 

                            forClass:aClass 

                            inCategory:cat 

                            notifying:requestor

                            install:install 

                            skipIfSame:skipIfSame 

                            silent:silent.

            newMethod == #Error ifTrue:[

                compiler showErrorMessageForClass:aClass.

                ^ #Error

            ].

            (newMethod == #CannotLoad) ifTrue:[

                newMethod := compiler trappingStubMethodFor:aString inCategory:cat.

                keptOldCode := false.

                install ifTrue:[

                    "/

                    "/ be very careful with existing methods

                    "/ (otherwise, you could easily make your system unusable in systems which cannot load)

                    "/

                    sel notNil ifTrue:[

                        oldMethod := aClass compiledMethodAt:sel 

                    ].

                    (oldMethod notNil and:[oldMethod code ~= newMethod code]) ifTrue:[

                        answer := Dialog

                                     confirm:'installation of binary code is not possible or disabled.

Shall I use the old methods functionality

or instead create a dummy trap method for it ?

Hint:

  if that method is needed by the system, you better leave the

  original functionality in the system.

Close this warnBox to abort the compilation.

'

                                     yesLabel:'trap code'

                                     noLabel:'keep old'.

                        answer isNil ifTrue:[

                            ^ #Error

                        ].

                        answer == false ifTrue:[

                            newMethod code:(oldMethod code).

                            keptOldCode := true.

                        ].

                    ].

                    aClass addSelector:sel withMethod:newMethod

                ].

                Transcript show:'*** '.

                sel notNil ifTrue:[

                    Transcript show:(sel ,' ')

                ].

                keptOldCode ifTrue:[

                    msg := 'not really compiled - method still shows previous behavior'.

                ] ifFalse:[

                    msg := 'not compiled to machine code - created a stub instead.'.

                ].

                Transcript showCR:msg.

            ].

            ^ newMethod

        ].

    ].

    "

     EXPERIMENTAL: quick loading

     only create a lazyMethod, which has no byteCode and will 

     compile itself when first called.

    "

    lazy ifTrue:[

        newMethod := LazyMethod new.

        (ClassCategoryReader sourceMode == #sourceReference) ifTrue:[

            sourceFile := ObjectMemory nameForSources.

            sourceFile notNil ifTrue:[    

                sourceStream := sourceFile asFilename appendingWriteStream.

            ]

        ].

        sourceStream isNil ifTrue:[

            newMethod source:aString.

        ] ifFalse:[

            sourceStream setToEnd.

            pos := sourceStream position.

            sourceStream nextChunkPut:aString.

            sourceStream close.

            newMethod sourceFilename:sourceFile position:pos.

        ].

        newMethod category:cat.

        newMethod package:(Class packageQuerySignal raise).

"/        Project notNil ifTrue:[

"/            newMethod package:(Project currentPackageName)

"/        ].

        aClass addSelector:sel withLazyMethod:newMethod.

        ^ newMethod

    ].

    (primNr := compiler primitiveNumber) isNil ifTrue:[

        "

         produce symbolic code first

        "

        symbolicCodeArray := compiler genSymbolicCode.

        (symbolicCodeArray == #Error) ifTrue:[

            Transcript show:'    '.

            sel notNil ifTrue:[

                Transcript show:(sel ,' ')

            ].

            Transcript showCR:'translation error'.

            ^ #Error

        ].

        "

         take this, producing bytecode 

         (someone willin' to make machine code :-)

        "

        ((compiler genByteCodeFrom:symbolicCodeArray) == #Error) ifTrue:[

            Transcript show:'    '.

             sel notNil ifTrue:[

                Transcript show:(sel ,' ')

            ].

            Transcript showCR:'relocation error - must be simplified'.

            ^ #Error

        ].

    ].

    "

     finally create the new method-object

    "

    newMethod := compiler createMethod.

    primNr notNil ifTrue:[

        newMethod code:(compiler checkForPrimitiveCode:primNr).

    ] ifFalse:[

        newMethod byteCode:(compiler code).

    ].

"/    newMethod numberOfMethodVars:(compiler numberOfMethodVars).

"/    newMethod numberOfMethodArgs:(compiler numberOfMethodArgs).

"/    newMethod stackSize:(compiler maxStackDepth).

    "

     if there where any corrections, install the updated source

    "

    (newSource := compiler correctedSource) notNil ifTrue:[

        newMethod source:newSource 

    ] ifFalse:[

        newMethod source:aString.

    ].

    newMethod category:cat.

    newMethod package:(Class packageQuerySignal raise).

"/    Project notNil ifTrue:[

"/        newMethod package:(Project currentPackageName)

"/    ].

    install ifTrue:[

        aClass addSelector:sel withMethod:newMethod

    ].

    silencio ifFalse:[

        Transcript showCR:('    compiled: ', aClass name,' ', sel)

    ].

    ^ newMethod

    "Created: 29.10.1995 / 19:59:36 / cg"

    "Modified: 24.6.1996 / 12:41:13 / stefan"

!

compile:methodText forClass:classToCompileFor notifying:requestor

    "compile a source-string for a method in classToCompileFor.

     Errors are forwarded to requestor."

    ^ self compile:methodText

	  forClass:classToCompileFor

	inCategory:'others'

	 notifying:requestor

	   install:true

	skipIfSame:false

	    silent:false

!

compile:textOrStream in:aClass notifying:requestor ifFail:exceptionBlock

    "name alias for ST-80 compatibility"