"

 COPYRIGHT (c) 1994 by Claus Gittinger

 COPYRIGHT (c) 2009-2010 Jan Vrany

	      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:libbasic' }"

"{ NameSpace: Smalltalk }"

ExecutableFunction variableSubclass:#CompiledCode

	instanceVariableNames:'flags byteCode'

	classVariableNames:''

	poolDictionaries:''

	category:'Kernel-Methods'

!

!CompiledCode class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1994 by Claus Gittinger

 COPYRIGHT (c) 2009-2010 Jan Vrany

	      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 is an abstract class, to merge common attributes of Blocks and

    Methods i.e. describe all objects consisting of either compiled or

    interpreted code.

    Instances of CompiledCode are not to be created by user code

    (the compilers create Blocks, Methods etc.)

    [Instance variables:]

      flags       <SmallInteger>    special flag bits coded in a number

      byteCode    <ByteArray>       bytecode if it's an interpreted codeobject

      The block/methods literals are stored in the indexed instance variables.

      If there is only one indexed instvar, it contains a reference to an

      Object containing the literals.

    [Class variables:]

      NoByteCodeSignal              raised if a codeObject is about to be executed

				    which has neither code nor byteCode (i.e. both are nil)

      InvalidByteCodeSignal         raised if byteCode is not an instance of ByteArray

      InvalidInstructionSignal      raised if an invalid instruction opcode is encountered

      BadLiteralsSignal             raised if literalArray is not an array

      NonBooleanReceiverSignal      raised for conditional jumps where receiver is not a boolean

      ArgumentSignal                raised if argument count is not what the codeObject expects

    all of these signals are children of ExecutionErrorSignal.

    NOTICE: layout known by runtime system and compiler - do not change

    [author:]

	Claus Gittinger

"

! !

!CompiledCode class methodsFor:'instance creation'!

new

    "create a new method with an indirect literal array

     stored in the first and only indexed instvar"

    ^ self basicNew:1.

    "Created: / 24.6.1996 / 17:21:46 / stefan"

    "Modified: / 23.1.1998 / 16:31:28 / stefan"

!

new:numberOfLiterals

    "create a new method with numberOfLiterals.

     Implementation note:

	If (self size) == 1, the only literal is an indirect literal

	containing an array of literals. Otherwise the literals

	are stored in self.

    "

    |nlits|

    nlits := numberOfLiterals.

    nlits <= 1 ifTrue:[

	nlits := nlits + 1.

    ].

    ^ self basicNew:nlits.

    "Created: 24.6.1996 / 17:20:13 / stefan"

    "Modified: 25.6.1996 / 14:25:14 / stefan"

! !

!CompiledCode class methodsFor:'Signal constants'!

wongNumberOfArgumentsSignal

    "return the signal raised when the number of arguments is wrong in a call"

    ^ WrongNumberOfArgumentsError

! !

!CompiledCode class methodsFor:'queries'!

isAbstract

    ^ self == CompiledCode

!

isBuiltInClass

    "return true if this class is known by the run-time-system.

     Here, true is returned for myself, false for subclasses."

    ^ self == CompiledCode

    "Modified: 23.4.1996 / 15:57:03 / cg"

!

maxNumberOfArguments

    "return the maximum number of arguments a method can have.

     This is a limit in the VM, which may be removed in one of

     the next versions ..."

%{  /* NOCONTEXT */

    RETURN (__mkSmallInteger(MAX_METHOD_ARGS));

%}.

    "/ fallback if no VM limit

    "/ actually: this limit is due to the single-byte encoding

    "/ in the send bytecode.

    ^ 255

!

numArgsMaskInFlags

%{  /* NOCONTEXT */

    /* made this a primitive to get define in stc.h */

    RETURN (__mkSmallInteger(F_NARGS));

%}.

    ^ nil "/ fallback if no primitive code

    "

     self numArgsMaskInFlags

    "

!

numArgsShiftInFlags

%{  /* NOCONTEXT */

    /* made this a primitive to get define in stc.h */

    RETURN (__mkSmallInteger(F_NARGSHIFT));

%}.

    ^ nil "/ fallback if no primitive code

    "

     self numArgsShiftInFlags

    "

!

numVarsMaskInFlags

%{  /* NOCONTEXT */

    /* made this a primitive to get define in stc.h */

    RETURN (__mkSmallInteger(F_NVARS));

%}.

    ^ nil "/ fallback if no primitive code

    "

     self numVarsMaskInFlags

    "

!

numVarsShiftInFlags

%{  /* NOCONTEXT */

    /* made this a primitive to get define in stc.h */

    RETURN (__mkSmallInteger(F_NVARSHIFT));

%}.

    ^ nil "/ fallback if no primitive code

    "

     self numVarsShiftInFlags

    "

! !

!CompiledCode methodsFor:'Compatibility-ANSI'!

argumentCount

    "ANSI alias for numArgs: return the number of arguments, the method expects."

%{  /* NOCONTEXT */

#ifdef __SCHTEAM__

    return __c__._RETURN( self.getNumberOfArguments() );

#else

    /* made this a primitive to get define in stc.h */

    RETURN (__mkSmallInteger((__intVal(__INST(flags)) & F_NARGS) >> F_NARGSHIFT));

#endif

%}.

    "

     The old implementation simply counted the arguments from

     the methods source - new versions include this information

     in the flag instVar, for more security in #perform:

    "

    "

     (Method compiledMethodAt:#source) numArgs

     (Method compiledMethodAt:#source:) numArgs

    "

! !

!CompiledCode methodsFor:'Compatibility-ST80'!

getSource

    "return the code object's source code, nil if none is available"

    ^ self source.

    "Created: 19.6.1997 / 16:32:15 / cg"

!

getSourceForUserIfNone:aBlock

    "return the code object's source code.

     If none is available, return the result from evaluating aBlock."

    |src|

    Screen current shiftDown ifTrue:[^ aBlock value].

    src := self source.

    src isNil ifTrue:[^ aBlock value].

    ^ src withoutTrailingSeparators

    "Modified: 19.6.1997 / 16:31:53 / cg"

!

initialPC

    ^ 1

!

methodClass

    "return the class I am defined in"

    ^ self mclass.

    "Created: 19.6.1997 / 16:32:15 / cg"

!

sourceString

    "return the code object's source code, nil if none is available"

    ^ self source.

    "Created: 19.6.1997 / 16:32:15 / cg"

!

withAllBlockMethodsDo:aBlock

    aBlock value:self

    "Created: 18.4.1997 / 20:42:07 / cg"

! !

!CompiledCode methodsFor:'Compatibility-V''Age'!

bytecodes

    ^ self byteCode

    "Created: / 05-03-2012 / 15:51:48 / cg"

! !

!CompiledCode methodsFor:'accessing'!

allLiterals

    "return a collection of all literals (includes all block literals)"

    ^ self literals ? #()

    "Modified: 19.6.1997 / 17:37:52 / cg"

!

allSymbolLiterals

    "return a collection of all symbol-literals"

    ^ self allLiterals select:[:lit | lit isSymbol]

    "Modified: / 19.6.1997 / 17:37:52 / cg"

    "Created: / 1.11.1997 / 13:14:44 / cg"

!

byteCode

    "return the bytecode (a ByteArray)"

    ^ byteCode

!

changeLiteral:aLiteral to:newLiteral

    "change aLiteral to newLiteral"

    |lits nLits "{ Class: SmallInteger }" |

    self size == 1 ifTrue:[

	lits := self at:1.

    ] ifFalse:[

	lits := self.

    ].

    nLits := lits size.

    1 to:nLits do:[:i|

	(lits at:i) == aLiteral ifTrue:[

	    lits at:i put:newLiteral.

	    ^ true.

	].

    ].

    ^ false.

    "Created: 24.6.1996 / 15:08:11 / stefan"

    "Modified: 24.6.1996 / 17:07:56 / stefan"

    "Modified: 4.7.1996 / 11:12:39 / cg"

!

decompiledSource

    "reconstruct some synthetic source by decompiling by byteCode"

    |s|

    s := String writeStream.

    self decompileTo:s.

    ^ s contents

    "Modified: / 30.1.1999 / 14:53:30 / cg"

    "Created: / 30.1.1999 / 14:54:09 / cg"

!

decompilerClass

    ^ Decompiler

    "Created: 30.7.1997 / 16:36:40 / cg"

!

do:aBlock

    "same as #literalsDo:, in order to get common protocol with Array"

    self literalsDo:aBlock

    "Modified: 25.6.1996 / 22:16:44 / stefan"

!

flags

    "return the flags (number of method variables, stacksize etc.).

     Don't depend on the values in the flag field - its interpretations

     may change without notice."

    ^ flags

    "Modified: / 30.1.1999 / 14:51:59 / cg"

!

homeMethod

    "for common protocol with blocks: if the receiver is a method,

     return the receiver; otherwise, if it's a block, return its home

     method."

    ^ self

    "Modified (comment): / 13-02-2017 / 19:58:51 / cg"

!

literalAt:index

    "return a literal element"

    ^ self literalAt:index ifAbsent:[self error:'bad literal index']

!

literalAt:index ifAbsent:exceptionalValue

    "return a literal element"

    |lits numLits "{ Class: SmallInteger }"|

    numLits := self size.

    numLits == 0 ifTrue:[

	^ exceptionalValue value

    ].

    numLits == 1 ifTrue:[

	lits := self at:1.

	lits isArray ifFalse:[

	    index == 1 ifTrue:[^ lits].

	    ^ exceptionalValue value

	].

	^ lits at:index.

    ].

    "there may be a dummy (nil) literal to make the size > 1"

    (self at:2) isNil ifTrue:[

	index == 1 ifTrue:[^ self at:1].

	^ exceptionalValue value

    ].

    ^ self at:index

!

literalAt:index put:newValue

    "change a literal slots value.

     WARNING: dangerous internal interface; only for knowledgable users"

    |lits numLits "{ Class: SmallInteger }"|

    numLits := self size.

    numLits == 0 ifTrue:[

	self error:'bad literal index'

    ].

    numLits == 1 ifTrue:[

	lits := self at:1.

	lits isArray ifFalse:[

	    index == 1 ifTrue:[^ self at:1 put:newValue.].

	    self error:'bad literal index'

	].

	^ lits at:index put:newValue.

    ].

    "there may be a dummy (nil) literal to make the size > 1"

    (self at:2) isNil ifTrue:[

	index == 1 ifTrue:[^ self at:1 put:newValue].

	self error:'bad literal index'.

    ].

    ^ self at:index put:newValue

    "Created: / 16-07-2006 / 13:01:15 / cg"

!

literals

    "return the literals as an array"

    |lits numLits "{ Class: SmallInteger }"|

    numLits := self size.

    numLits == 0 ifTrue:[

	^ #()

    ].

    numLits == 1 ifTrue:[

	lits := self at:1.

	lits isArray ifFalse:[

	    ^ Array with:lits.

	].

	^ lits.

    ].

    "there may be a dummy (nil) literal to make the size > 1"

    (self at:2) isNil ifTrue:[

	numLits := 1.

    ].

    lits := Array new:numLits.

    1 to:numLits do:[:i|

	lits at:i put:(self at:i).

    ].

    ^ lits.

    "

     (CompiledCode compiledMethodAt:#literals) literals

    "

    "Modified: / 30.1.1997 / 17:09:06 / cg"

    "Modified: / 23.1.1998 / 16:30:07 / stefan"

!

literalsDetect:aBlock ifNone:exceptionBlock

    "execute a one arg block for each of our literals.