"

 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.

"

Object subclass:#Behavior

	 instanceVariableNames:'superclass flags selectorArray methodArray otherSuperclasses

		instSize'

	 classVariableNames:'SubclassInfo'

	 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.

    In contrast to other ST implementations, the methods have been separated

    from the selectors (there is no Dictionary, but two separate Arrays)

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

    For ST-80 compatibility, this will be replaced by a single instance of

    MethodDictionary (which will NOT be a true dictionary, but an Array with

    alternating selector/method entries).

    To be prepared for this change, please do NOT directly use the methodArray 

    and selectorArray instVars.

    Instance variables:

	superclass        <Class>           the receivers superclass

	otherSuperclasses <Array of Class>  experimental: other superclasses

					    a hook for experimental multiple inheritance

					    implementations

	selectorArray     <Array of Symbol> the selectors for which inst-methods are defined here

	methodArray       <Array of Method> the inst-methods corresponding to the selectors

	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

"

!

virtualMachineRelationship 

"

    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.

    However, the VM trusts the isBehaviorLike flag - if it is set for some

    object, it 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 selectorArray methodArray

     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', 'selectorArray' and 'methodArray' are required

    and have to be at the same instVar index.

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

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

    ST-programmer, though.

    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 setSelectorArray:nil.

	someInstance := newClass new.

	someInstance inspect

	|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'

"

! !

!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

		 selectors:#() "/ (Array new:0)

		   methods:#() "/ (Array new:0)

		  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

    "

! !

!Behavior class methodsFor:'flag bit constants'!

flagBehavior

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

     You have to 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 ( _MKSMALLINT(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.

     You have to check this single bit in the flag value when

     checking for blocks."

%{  /* NOCONTEXT */

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

    RETURN ( _MKSMALLINT(BLOCK_INSTS) );

%}

!

flagBlockContext

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

     You have to check 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 ( _MKSMALLINT(BCONTEXT_INSTS) );

%}

!

flagBytes

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

     You have to mask the flag value with indexMask when comparing

     it with flagBytes."

%{  /* NOCONTEXT */

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

    RETURN ( _MKSMALLINT(BYTEARRAY) );

%}

    "

     Behavior flagBytes    

    "

!

flagContext

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

     You have to check 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 ( _MKSMALLINT(CONTEXT_INSTS) );

%}

!

flagDoubles

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

     You have to mask the flag value with indexMask when comparing

     it with flagDoubles."

%{  /* NOCONTEXT */

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

    RETURN ( _MKSMALLINT(DOUBLEARRAY) );

%}

    "

     Behavior flagDoubles    

    "

!

flagFloat

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

     You have to check this single bit in the flag value when

     checking for floats."

%{  /* NOCONTEXT */

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

    RETURN ( _MKSMALLINT(FLOAT_INSTS) );

%}

!

flagFloats

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

     You have to mask the flag value with indexMask when comparing

     it with flagFloats."

%{  /* NOCONTEXT */

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

    RETURN ( _MKSMALLINT(FLOATARRAY) );

%}

    "

     Behavior flagFloats    

    "

!

flagLongs

    "return the flag code for long-valued indexed instances (i.e. 4-byte).

     You have to mask the flag value with indexMask when comparing

     it with flagLongs."

%{  /* NOCONTEXT */

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

    RETURN ( _MKSMALLINT(LONGARRAY) );

%}

    "

     Behavior flagLongs    

    "

!

flagMethod

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

     You have to check this single bit in the flag value when

     checking for methods."

%{  /* NOCONTEXT */

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

    RETURN ( _MKSMALLINT(METHOD_INSTS) );

%}

!

flagNonObjectInst

    "return the flag code which marks instances which have a

     non-object instance variable (in slot 1).

     (these are ignored by the garbage collector)"

%{  /* NOCONTEXT */

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

    RETURN ( _MKSMALLINT(NONOBJECT_INSTS) );

%}

!

flagNotIndexed

    "return the flag code for non-indexed instances.

     You have to mask the flag value with indexMask when comparing

     it with flagNotIndexed."

    ^ 0

!

flagPointers

    "return the flag code for pointer indexed instances (i.e. Array of object).

     You have to mask the flag value with indexMask when comparing

     it with flagPointers."

%{  /* NOCONTEXT */

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

    RETURN ( _MKSMALLINT(POINTERARRAY) );

%}

    "

     Behavior flagPointers    

    "

!

flagSymbol

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

     You have to check this single bit in the flag value when

     checking for symbols."