"

 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

!

!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 will vanish)

    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:

	maxStackDepth   <SmallInteger>          stack need of method

	relocList       <Array>                 used temporary for relocation

    Class variables:

	JumpToAbsJump   <Dictionary>            internal table to map opcodes

"

! !

!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

    "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 lits symbolicCodeArray oldMethod lazy silencio 

    aString isNil ifTrue:[^ nil].

    silencio := silent or:[Smalltalk silentLoading == true].

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

    compiler notifying:requestor.

    silent ifTrue:[

"/        compiler ignoreErrors.

    ].

    compiler nextToken.

    (compiler parseMethodSpec == #Error) ifTrue:[

    ] ifFalse:[

"/                            aClass updateRevisionString.

    ].

    sel := compiler selector.

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

    ].

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

     sel isNil ifTrue:[

    ].

    "

     freak-out support ...

    "

    (compiler hasNonOptionalPrimitiveCode 

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

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

    ].

    "

     EXPERIMENTAL: quick loading

     only create a lazyMethod, which has no byteCode and will 

     compile itself when first called.

    "

    lazy ifTrue:[

    ].

    (primNr := compiler primitiveNumber) isNil ifTrue:[

    ].

    "

     finally create the new method-object

    "

    newMethod := Method new.

    lits := compiler literalArray.

    lits notNil ifTrue:[

    ].

    primNr notNil ifTrue:[

    ] ifFalse:[

    ].

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

    ] ifFalse:[

    ].

    newMethod category:cat.

    Project notNil ifTrue:[

    ].

    install ifTrue:[

    ].

    silencio ifFalse:[

    ].

    ^ newMethod

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

!

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"

    |m|

    m := self 

	   compile:textOrStream

	  forClass:aClass 

	inCategory:'others'

	 notifying:requestor 

	   install:true

	skipIfSame:false

	    silent:false.

    m == #Error ifTrue:[

	^ exceptionBlock value

    ].

     ^ m

! !

!ByteCodeCompiler class methodsFor:'constants'!

byteCodeFor:aSymbol

    "only some exported codes handled here (for BlockNode)"

    (aSymbol == #retNil) ifTrue:[^ 1].

    (aSymbol == #retTrue) ifTrue:[^ 2].

    (aSymbol == #retFalse) ifTrue:[^ 3].

    (aSymbol == #ret0) ifTrue:[^ 4].

    (aSymbol == #retTop) ifTrue:[^ 0].

    (aSymbol == #push0) ifTrue:[^120].

    (aSymbol == #push1) ifTrue:[^121].

    (aSymbol == #push2) ifTrue:[^139].

    (aSymbol == #pushMinus1) ifTrue:[^122].

    (aSymbol == #pushNil) ifTrue:[^ 10].

    (aSymbol == #pushTrue) ifTrue:[^ 11].

    (aSymbol == #pushFalse) ifTrue:[^ 12].

    (aSymbol == #pushSelf) ifTrue:[^ 15].

    self error

! !

!ByteCodeCompiler class methodsFor:'stc compilation defaults'!

canCreateMachineCode

    "return true, if compilation to machine code is supported.

     Currently, all SYSV4 and Linux systems do so;

     REAL/IX, AIX and HPUX do not (due to the need for dynamic loading 

     of object files, which is not supported by those).

     MIPS ULTRIX is almost finished, but not yet released.

     However, if no compiler is around (i.e. the demo distribution),

     there is no chance ..."

    |canDo|

    ObjectFileLoader isNil ifTrue:[^ false].

    ObjectFileLoader canLoadObjectFiles ifFalse:[^ false].

    "/ no chance, if no stc is available

    ^ self incrementalStcPath notNil

    "

     Compiler canCreateMachineCode     

    "

    "Modified: 13.9.1995 / 15:15:11 / claus"

!

incrementalStcPath 

    "return the path to the stc command for incremental method compilation, 

     or nil if not found."

    |f|

    (f := self stcPathOf:'stc') notNil ifTrue:[^ f].

    ^ self stcPathOf:'demostc'

    "

     Compiler incrementalStcPath     

    "