"

 COPYRIGHT (c) 1988 by Claus Gittinger

 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 otherSuperclasses

       classVariableNames:''

       poolDictionaries:''

       category:'Kernel-Classes'

!

Behavior comment:'

COPYRIGHT (c) 1988 by Claus Gittinger

'!

!Behavior class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1988 by Claus Gittinger

 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.

"

!

version

"

"

!

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

    Instance variables:

    flag bits (see stc.h):

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

"

! !

!Behavior class methodsFor:'queries'!

isBuiltInClass

    "this class is known by the run-time-system"

    ^ true

! !

!Behavior class methodsFor:'creating new classes'!

new

    "creates and return a new class"

    |newClass|

    newClass := self basicNew.

    newClass setSuperclass:Object

    ^ newClass

! !

!Behavior methodsFor:'initialization'!

initialize

    "to catch initialize for classes which do not"

    ^ self

!

reinitialize

    "to catch reinitialize for classes which do not"

    ^ self

! !

!Behavior methodsFor:'copying'!

deepCopy

    "return a deep copy of the receiver

     - return the receiver here - time will show if this is ok"

    ^ self

!

deepCopyUsing:aDictionary

    "return a deep copy of the receiver

     - return the receiver here - time will show if this is ok"

    ^ self

!

simpleDeepCopy

    "return a deep copy of the receiver

     - return the receiver here - time will show if this is ok"

    ^ self

! !

!Behavior methodsFor:'creating an instance of myself'!

uninitializedNew

    "same as new - only redefined in ByteArray"

    ^ self basicNew

!

uninitializedNew:anInteger

    "same as new:anInteger - only redefined in ByteArray"

    ^ self basicNew:anInteger

!

niceBasicNew:anInteger

    "same as basicNew:anInteger, but tries to avoid long pauses

     due to garbage collection. This method checks to see if

     allocation is possible without a pause, and does a background

     incremental garbage collect first if there is not enough memory

     available at the moment for fast allocation. 

     This is useful in low-priority background processes which like to 

     avoid disturbing any higher priority foreground process while allocating

     big amounts of memory. Of course, using this method only makes

     sense for big or huge objects (say > 200k).

     EXPERIMENTAL: this is a non-standard interface and should only 

     be used for special applications. There is no guarantee, that this

     method will be available in future ST/X releases."

    |size|

    size := self sizeOfInst:anInteger.

    (ObjectMemory checkForFastNew:size) ifFalse:[

    ].

    ^ self basicNew:anInteger

!

new

    "return an instance of myself without indexed variables"

    ^ self basicNew

!

new:anInteger

    "return an instance of myself with anInteger indexed variables"

    ^ self basicNew:anInteger

!

basicNew

    "return an instance of myself without indexed variables.

     If the receiver-class has indexed instvars, the new object will have

     a basicSize of zero - 

     i.e. 'aClass basicNew' is equivalent to 'aClass basicNew:0'.

     ** Do not redefine this method in any class **"

%{  /* NOCONTEXT */

    OBJ new();

    REGISTER OBJ newobj;

    REGISTER char *nextPtr;

    unsigned int instsize;

    REGISTER unsigned int nInstVars;

    /*

     * the following ugly code is nothing more than a new() followed

     * by a nilling of the new instance.

     * Unrolled for a bit more speed since this is one of the central object 

     * allocation methods in the system

     */

    nInstVars = _intVal(_INST(instSize));

    instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars);

    newobj = (OBJ) newNextPtr;

    nextPtr = ((char *)newobj) + instsize;

    /*

     * dont argue about the goto and the arrangement below - it saves 

     * an extra nil-compare and branch in the common case ...

     * (i.e. if no GC is needed, we fall through without a branch)

     */

    if (nextPtr < newEndPtr) {

#ifdef ALIGN4

#else

#endif

ok:

#if defined(FAST_OBJECT_MEMSET4)

#else

# if !defined(NEGATIVE_ADDRESSES)

#  if defined(FAST_OBJECT_MEMSET_DOUBLES_UNROLLED)

#  else

#   if defined(FAST_OBJECT_MEMSET_LONGLONG_UNROLLED)

#   else

#    if defined(FAST_OBJECT_MEMSET_WORDS_UNROLLED)

#    else

#     if defined(FAST_MEMSET)

#     else

#     endif

#    endif

#   endif

#  endif

# else /* nil could be ~~ 0 */

# endif

#endif

    }

    /*

     * the slow case - a GC will occur

     */

    PROTECT_CONTEXT

    newobj = new(instsize, SENDER);

    UNPROTECT_CONTEXT

    if (newobj != nil) goto ok;

%}

.

    "

     memory allocation failed.

     When we arrive here, there was no memory, even after

     a garbage collect. This means, that the VM wanted to

     get some more memory from the Operatingsystem, which

     was not kind enough to give some

    "

    ^ ObjectMemory allocationFailureSignal raise.

!

basicNew:anInteger

    "return an instance of myself with anInteger indexed variables.

     If the receiver-class has no indexed instvars, this is only allowed

     if the argument, anInteger is zero.

     ** Do not redefine this method in any class **"

%{  /* NOCONTEXT */

    OBJ newobj;

    unsigned INT flags;

#if ! defined(FAST_ARRAY_MEMSET) || defined(NEGATIVE_ADDRESSES)

    REGISTER char *cp;

    short *sp;

    long *lp;

#endif

    REGISTER OBJ *op;

    float *fp;

    double *dp;

    extern OBJ new();

    if (_isSmallInteger(anInteger)) {

#if defined(FAST_ARRAY_MEMSET) && ! defined(NEGATIVE_ADDRESSES)

#else

#endif

#if defined(FAST_ARRAY_MEMSET) && ! defined(NEGATIVE_ADDRESSES)

#else

#endif

#if defined(FAST_ARRAY_MEMSET) && ! defined(NEGATIVE_ADDRESSES)

#else

#endif