"

 COPYRIGHT (c) 1988 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:libbasic' }"

Object subclass:#Behavior

	instanceVariableNames:'superclass flags methodDictionary lookupObject instSize'

	classVariableNames:''

	poolDictionaries:''

	category:'Kernel-Classes'

!

!Behavior class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1988 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

"

    Every class in the system inherits from Behavior (via Class, ClassDescription);

    so here is where most of the class messages end up being implemented.

    (to answer a FAQ: 'Point basicNew' will be done here :-)

    Beginners should keep in mind, that all classes are instances (of subclasses)

    of Behavior, therefore you will find the above mentioned 'basicNew:' method

    under the 'instance'-methods of Behavior - NOT under the class methods

    ('Behavior new' will create and return a new class, while sending 'new' to

    any instance of Behavior (i.e. any class) will return an instance of that class).

    Behavior provides minimum support for all classes - additional stuff is

    found in ClassDescription and Class. Behaviors provides all mechanisms needed

    to create instances, and send messages to those. However, Behavior does not provide

    all the (symbolic) information needed to compile methods for a class or to get

    useful information in inspectors.

    for experts:

    Since instances of Behavior provide all that is needed to interact with the VM's

    message dispatch mechanism, these can be used as 'light weight' classes.

    I.e. it is possible, to generate completely anonymous classes (and instances thereof)

    on the fly - 'Behavior new new' is such a thingy.

    The selectors and Methods are organized in a MethodDictionary (which is not a true

    dictionary, but an Array with alternating selector/method entries).

    This avoids the need for knowledge about Dictionaries in the runtime library (VM)

    (lookup and search in these is seldom anyway, so the added benefit from using a

     hashed dictionary is almost void).

    [Instance variables:]

	superclass        <Class>            the receivers superclass

	methodDictionary  <MethodDictionary> inst-selectors and methods

	instSize          <SmallInteger>     the number of instance variables

	flags             <SmallInteger>     special flag bits coded in a number

					     not for application use

    flag bits (see stc.h):

    NOTICE: layout known by compiler and runtime system; be careful when changing

    [author:]

	Claus Gittinger

    [see also:]

	Class ClassDescription Metaclass

	Method MethodDictionary

"

!

virtualMachineRelationship

"

    Expert info follows:

    --------------------

    NOTICE:

	the stuff described below may not be available on other

	Smalltalk implementations; be aware that these error mechanisms

	are ST/X specials and applications using these (tricks) may

	not be portable to other systems.

    WARNING:

	do not try the examples below on (some) other smalltalk systems;

	it has been reported, that some crash badly when doing this .... ;-)

    Instances of Behavior and subclasses (i.e. in sloppy words: classes)

    play a special role w.r.t. the VM. Only objects whose class-slot is marked

    as being behaviorLike (in the flag-instvar) are considered to be classLike

    and a message lookup will be done for it in the well known way.

    Thus, if an object has a class for which its class does NOT have

    this flag bit set, the VM will trigger an error on a message send.

    Why is this so:

    ---------------

    the above lets every object play the role of a class,

    which has been flagged as behaviorLike in its class's flag.

    Thus, you can create arbitrary new classLike objects and have the VM

    play with them.

    This may offer the flexibility to create a totally different object scheme

    on top of ST/X (for example: Self like objects) where any object can play

    a classRole for another object or even for itself.

    [A concrete application of this is found in the Structure class,

     which creates objects which are their own class !!

     This may look to be of theoretical value at first sight,

     however, such a construct saves memory, by not requiring an extra

     class object per Structure object.]

    Be aware, that the VM trusts the isBehaviorLike flag - IF it is set for some

    object, the VM EXPECTS the object selector and methodDictionaries to be found

    at the instance positions as defined here.

    (i.e. instanceVariables with contents and semantic corresponding to

	superclass

	flags

	methodDictionary

     must be present and have the same instVar-index as here).

    The VM (and the system) may crash badly, if this is not the case.

    Since every class in the system derives from Behavior, the flag setting

    (and instance variable layout) is correct for all 'normal' classes.

    If you experiment by creating new behaviorLike objects, please take

    care of this flag. If you want to use the VM's lookup function, the

    instVars  'superclass' and 'methodDictionary' are required

    and have to be at the same instVar index.

    (we suggest, you subclass Behavior, to make certain)

    Vice versa, defining 'dumb classes', which have the behaviorLike bit turned

    off may be useful as well; if a message is sent to an instance of such

    a thingy, the VM performs a recovery sequence, which is much like the

    #doesNotUnderstand: mechanism - however, since the instance is no good

    receiver of such a message, a #cannotSendMessage:to: is now sent to the

    class (which is not a real class), passing the original message (selector

    and arguments) along with the original receiver.

    The default behavior for this message is to raise an internalError signal -

    however, you may redefine this in your 'dum class' for recovery.

    One possible use of this is to provide new message send algorithms - the

    class may lookup a method and invoke it directly, via the #valueWithReceiver:

    interface.

    All of the above is pure expert stuff

    - You do not have to care about the above details if you are a 'normal'

    ST-programmer, though (and even most of those will never use these features).

    Examples (only of theoretical interest):

    ----------------------------------------

	take away the behaviorLike-flag from a class.

	-> The instances will not understand any messages, since the VM will

	   not recognize its class as being a class ...

	|newMeta notRecognizedAsClass someInstance|

	newMeta := Metaclass new.

	newMeta flags:0.

	notRecognizedAsClass := newMeta new.

	someInstance := notRecognizedAsClass new.

	someInstance perform:#isNil

    Of course, this is an exception which can be handled ...:

    Example:

	|newMeta notRecognizedAsClass someInstance|

	newMeta := Metaclass new.

	newMeta flags:0.

	notRecognizedAsClass := newMeta new.

	someInstance := notRecognizedAsClass new.

	Object errorSignal handle:[:ex |

	    ex return

	] do:[

	    someInstance perform:#isNil

	]

    likewise, a doesNotUnderstand-notUnderstood can be handled:

    Example:

	|newMeta funnyClass someInstance|

	newMeta := Metaclass new.

	funnyClass := newMeta new.

	funnyClass setSuperclass:nil.

	someInstance := funnyClass new.

	Object errorSignal handle:[:ex |

	     ex return

	] do:[

	    someInstance perform:#isNil

	]

    more examples, which try to trick the VM ;-):

	badly playing around with a classes internals ...

	|newClass someInstance|

	newClass := Class new.

	newClass setSuperclass:nil.

	someInstance := newClass new.

	someInstance inspect

	|newClass someInstance|

	newClass := Class new.

	newClass setSuperclass:newClass.

	someInstance := newClass new.

	someInstance inspect

	|newClass someInstance|

	newClass := Class new.

	newClass setSuperclass:1.

	someInstance := newClass new.

	someInstance inspect

    Example:

	creating totally anonymous classes:

	|newClass someInstance|

	newClass := Class new.

	someInstance := newClass new.

	someInstance inspect

    Example:

	creating totally anonymous metaclasses:

	|newMeta newClass someInstance|

	newMeta := Metaclass new.

	newClass := newMeta new.

	someInstance := newClass new.

	someInstance inspect

    PS: if you experiment with new behaviorLike objects, you may want

	to turn off the VM's debugPrintouts

	with:

		'Smalltalk debugPrinting:false'

	and:

		'Smalltalk infoPrinting:false'

    Meta-Object-Protocol support:

    -----------------------------

    the above tricks do not affect the inline caches, and are therefore somewhat slow.

    Another hook is the lookupObject which, if non-nil, is consulted to do the lookup

    instead of the hardwired VM lookup algorithm, and provide a method as return value.

    This method (if non-nil) will be put into the inline-and polymorph caches for speedy

    call the next time. If non-nil, the lookup object is sent the:

	    lookupMethodForSelector:aSelector

	    directedTo:searchClass

	    for:aReceiver

	    withArguments:argArrayOrNil

	    from:sendingContext

    message.

    'searchClass' is the object class or any of its superclasses (for directed/super sends).

    You can return any arbitrary method there - for example to implement multiple inheritance,

    selector namespace tricks or multi-dispatch on argument types (double dispatch for a method).

    Be aware, that the returned method is cached, and the lookup is not consulted again for the

    same receiver/callsite combination. So the returned method should check if it's ok to be called

    again (maybe, a synthetic method is generated and returned).

"

! !

!Behavior class methodsFor:'creating new classes'!

new

    "creates and return a new behavior (which is like a class,

     but without the symbolic & name information).

     Not for normal applications.

     Sending the returned behavior the #new message gives you

     an instance if it.

     Notice: the returned class is given a superclass of Object;

     this allows for its new instances to be inspected and the like."

    |newClass|

    newClass := self basicNew.

    newClass

	setSuperclass:Object

	methodDictionary:(MethodDictionary new)

	instSize:0

	flags:(self flagBehavior).

    ^ newClass

    "

     Behavior new               <- a new behavior

     Behavior new new           <- an instance of it

     ClassDescription new       <- a new classDescription

     ClassDescription new new   <- an instance of it

     Class new                  <- a new class

     Class new new              <- an instance of it

     Metaclass new              <- a new metaclass

     Metaclass new new          <- an instance (i.e. a class) of it

     Metaclass new new new      <- an instance of this new class

    "

    "Modified: 7.6.1996 / 15:38:58 / stefan"

! !

!Behavior class methodsFor:'flag bit constants'!

flagBehavior

    "return the flag code which marks Behavior-like instances.

     Inline C-code and the VM check this single bit in the flag value when

     checking for behaviors."

%{  /* NOCONTEXT */

    /* this is defined as a primitive to get defines from stc.h */

    RETURN ( __mkSmallInteger(BEHAVIOR_INSTS) );

%}

    "consistency check:

     all class-entries must be behaviors;

     all behaviors must be flagged so (in its class's flags)

     (otherwise, VM will bark)

     all non-behaviors may not be flagged

     |bit|

     bit := Class flagBehavior.

     ObjectMemory allObjectsDo:[:o|

       o isBehavior ifTrue:[

	 (o class flags bitTest:bit) ifFalse:[

	     self halt

	 ].

       ] ifFalse:[

	 (o class flags bitTest:bit) ifTrue:[

	     self halt

	 ].

       ].

       o class isBehavior ifFalse:[

	 self halt

       ] ifTrue:[

	 (o class class flags bitTest:bit) ifFalse:[

	     self halt

	 ]

       ]

     ]

    "

!

flagBlock

    "return the flag code which marks Block-like instances.

     The VM checks for either this bit or the blockLike bit in the flag

     value when checking for blocks to be evaluated from bytecodes.

     However, compiled code only checks for the block bit."

%{  /* NOCONTEXT */

    /* this is defined as a primitive to get defines from stc.h */

    RETURN ( __mkSmallInteger(BLOCK_INSTS) );

%}

!

flagBlockContext

    "return the flag code which marks BlockContext-like instances.

     The VM checks this single bit in the flag value when

     checking for blockContexts."

%{  /* NOCONTEXT */

    /* this is defined as a primitive to get defines from stc.h */

    RETURN ( __mkSmallInteger(BCONTEXT_INSTS) );

%}

!

flagBlockLike

    "return the flag code which marks Block-like instances

     with respect to byteCode interpretation.

     The VM checks for either this bit or the block bit in the flag

     value when checking for blocks to be evaluated from bytecodes.

     However, compiled code only checks for the block bit."

%{  /* NOCONTEXT */

    /* this is defined as a primitive to get defines from stc.h */

    RETURN ( __mkSmallInteger(BLOCKLIKE_INSTS) );

%}

!

flagBytes

    "return the flag code for byte-valued indexed instances.

     The VM masks the flag value with the indexMask (maskIndexType)

     and compares it to this flag value, when checking for byte valued

     variable instances."

%{  /* NOCONTEXT */

    /* this is defined as a primitive to get defines from stc.h */

    RETURN ( __mkSmallInteger(BYTEARRAY) );

%}

    "

     Behavior flagBytes

    "

!

flagContext

    "return the flag code which marks Context-like instances.

     The VM checks this single bit in the flag value when

     checking for contexts."

%{  /* NOCONTEXT */

    /* this is defined as a primitive to get defines from stc.h */

    RETURN ( __mkSmallInteger(CONTEXT_INSTS) );

%}

!

flagDoubles

    "return the flag code for double-valued indexed instances (i.e. 8-byte reals).

     The VM masks the flag value with the indexMask (maskIndexType)

     and compares it to this flag value, when checking for double valued

     variable instances."

%{  /* NOCONTEXT */

    /* this is defined as a primitive to get defines from stc.h */

    RETURN ( __mkSmallInteger(DOUBLEARRAY) );

%}

    "

     Behavior flagDoubles

     (ByteArray flags bitAnd:(Behavior maskIndexType)) == (Behavior flagDoubles)

     (DoubleArray flags bitAnd:(Behavior maskIndexType)) == (Behavior flagDoubles)

     (Object flags bitAnd:(Behavior maskIndexType)) == (Behavior flagDoubles)

    "

!

flagExternalBytes

    "return the flag code which marks ExternalBytes-like instances.

     Inline C-code and the VM check this single bit in the flag value when

     checking for an externalBytes-like objet."

%{  /* NOCONTEXT */

    /* this is defined as a primitive to get defines from stc.h */