Behavior.st
changeset 92 0c73b48551ac
parent 91 b3971c7dc731
child 127 6625c77d890f
--- a/Behavior.st	Sun Jul 10 00:59:39 1994 +0200
+++ b/Behavior.st	Fri Aug 05 02:55:07 1994 +0200
@@ -22,6 +22,8 @@
 Behavior comment:'
 COPYRIGHT (c) 1988 by Claus Gittinger
               All Rights Reserved
+
+$Header: /cvs/stx/stx/libbasic/Behavior.st,v 1.18 1994-08-05 00:53:55 claus Exp $
 '!
 
 !Behavior class methodsFor:'documentation'!
@@ -42,7 +44,7 @@
 
 version
 "
-$Header: /cvs/stx/stx/libbasic/Behavior.st,v 1.17 1994-07-09 22:59:39 claus Exp $
+$Header: /cvs/stx/stx/libbasic/Behavior.st,v 1.18 1994-08-05 00:53:55 claus Exp $
 "
 !
 
@@ -180,7 +182,6 @@
      ** Do not redefine this method in any class **"
 
 %{  /* NOCONTEXT */
-
     OBJ new();
     REGISTER OBJ newobj;
     REGISTER char *nextPtr;
@@ -194,7 +195,7 @@
      * allocation methods in the system
      */
     nInstVars = _intVal(_INST(instSize));
-    instsize = OHDR_SIZE + nInstVars * sizeof(OBJ);
+    instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
 
     newobj = (OBJ) newNextPtr;
     nextPtr = ((char *)newobj) + instsize;
@@ -223,7 +224,7 @@
         _InstPtr(newobj)->o_class = self;
 
         if (nInstVars) {
-#if defined(memset4)
+#if defined(FAST_OBJECT_MEMSET4)
             memset4(_InstPtr(newobj)->i_instvars, nil, nInstVars);
 #else
             REGISTER OBJ *op;
@@ -236,7 +237,7 @@
              */
 #  if defined(FAST_OBJECT_MEMSET_DOUBLES_UNROLLED)
             if (nInstVars > 8) {
-                *op++ = nil;	/* for alignment */
+                *op++ = nil;    /* for alignment */
                 nInstVars--;
                 while (nInstVars >= 8) {
                     *(double *)op = 0.0;
@@ -247,14 +248,14 @@
                     nInstVars -= 8;
                 }
             }
-            while (nInstVars) {
+            while (nInstVars != 0) {
                 *op++ = 0;
                 nInstVars--;
             }
 #  else
 #   if defined(FAST_OBJECT_MEMSET_LONGLONG_UNROLLED)
             if (nInstVars > 8) {
-                *op++ = nil;	/* for alignment */
+                *op++ = nil;    /* for alignment */
                 nInstVars--;
                 while (nInstVars >= 8) {
                     *(long long *)op = 0;
@@ -265,7 +266,7 @@
                     nInstVars -= 8;
                 }
             }
-            while (nInstVars) {
+            while (nInstVars != 0) {
                 *op++ = 0;
                 nInstVars--;
             }
@@ -284,31 +285,48 @@
                 op += 8;
                 nInstVars -= 8;
             }
-            while (nInstVars) {
-                *op++ = 0;
+            while (nInstVars != 0) {
+                *op++ = nil;
                 nInstVars--;
             }
 #    else
 #     if defined(FAST_MEMSET)
-            memset(_InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
+            memset(_InstPtr(newobj)->i_instvars, 0, instsize-OHDR_SIZE);
 #     else
             do {
                 *op++ = nil;
-            } while (--nInstVars);
+                nInstVars--;
+            } while (nInstVars != 0);
 #     endif
 #    endif
 #   endif
 #  endif
 # else /* nil could be ~~ 0 */
-            do {
+            while (nInstVars >= 8) {
+                *op = nil;
+                *(op+1) = nil;
+                *(op+2) = nil;
+                *(op+3) = nil;
+                *(op+4) = nil;
+                *(op+5) = nil;
+                *(op+6) = nil;
+                *(op+7) = nil;
+                op += 8;
+                nInstVars -= 8;
+            }
+            while (nInstVars != 0) {
                 *op++ = nil;
-            } while (--nInstVars);
+                nInstVars--;
+            }
 # endif
 #endif
         }
         RETURN ( newobj );
     }
 
+    /*
+     * the slow case - a GC will occur
+     */
     PROTECT_CONTEXT
     newobj = new(instsize, SENDER);
     UNPROTECT_CONTEXT
@@ -335,9 +353,9 @@
 %{  /* NOCONTEXT */
 
     OBJ newobj;
-    INT instsize, nInstVars, nindexedinstvars;
-    INT flags;
-#if ! defined(FAST_MEMSET) || defined(NEGATIVE_ADDRESSES)
+    unsigned INT instsize, nInstVars, nindexedinstvars;
+    unsigned INT flags;
+#if ! defined(FAST_ARRAY_MEMSET) || defined(NEGATIVE_ADDRESSES)
     REGISTER char *cp;
     short *sp;
     long *lp;
@@ -350,21 +368,43 @@
     if (_isSmallInteger(anInteger)) {
         nindexedinstvars = _intVal(anInteger);
         if (nindexedinstvars >= 0) {
-            PROTECT_CONTEXT
             nInstVars = _intVal(_INST(instSize));
             flags = _intVal(_INST(flags)) & ARRAYMASK;
             switch (flags) {
                 case BYTEARRAY:
-                    instsize = OHDR_SIZE + 
-                               nInstVars * sizeof(OBJ) 
-                               + nindexedinstvars * sizeof(char);
+                    instsize = OHDR_SIZE + nindexedinstvars;
+                    if (nInstVars == 0) {
+                        if (_CanDoQuickNew(instsize)) {
+                            /*
+                             * the most common case
+                             */
+                            _qCheckedNew(newobj, instsize);
+                            _InstPtr(newobj)->o_class = self;
+#if defined(FAST_ARRAY_MEMSET) && ! defined(NEGATIVE_ADDRESSES)
+                            memset(_InstPtr(newobj)->i_instvars, 0, nindexedinstvars);
+#else
+                            cp = (char *)_InstPtr(newobj)->i_instvars;
+                            while (nindexedinstvars >= sizeof(long)) {
+                                *(long *)cp = 0;
+                                cp += sizeof(long);
+                                nindexedinstvars -= sizeof(long);
+                            }
+                            while (nindexedinstvars--)
+                                *cp++ = '\0';
+#endif
+                            RETURN ( newobj );
+                        }
+                    } else {
+                        instsize += __OBJS2BYTES__(nInstVars);
+                    }
+                    PROTECT_CONTEXT
                     _qNew(newobj, instsize, SENDER);
                     UNPROTECT_CONTEXT
                     if (newobj == nil) {
                         break;
                     }
                     _InstPtr(newobj)->o_class = self;
-#if defined(FAST_MEMSET) && ! defined(NEGATIVE_ADDRESSES)
+#if defined(FAST_ARRAY_MEMSET) && ! defined(NEGATIVE_ADDRESSES)
                     /*
                      * knowing that nil is 0
                      */
@@ -387,15 +427,16 @@
 
                 case WORDARRAY:
                     instsize = OHDR_SIZE + 
-                               nInstVars * sizeof(OBJ) + 
+                               __OBJS2BYTES__(nInstVars) + 
                                nindexedinstvars * sizeof(short);
+                    PROTECT_CONTEXT
                     _qNew(newobj, instsize, SENDER);
                     UNPROTECT_CONTEXT
                     if (newobj == nil) {
                         break;
                     }
                     _InstPtr(newobj)->o_class = self;
-#if defined(FAST_MEMSET) && ! defined(NEGATIVE_ADDRESSES)
+#if defined(FAST_ARRAY_MEMSET) && ! defined(NEGATIVE_ADDRESSES)
                     /*
                      * knowing that nil is 0
                      */
@@ -413,21 +454,22 @@
 
                case LONGARRAY:
                     instsize = OHDR_SIZE + 
-                               nInstVars * sizeof(OBJ) + 
+                               __OBJS2BYTES__(nInstVars) + 
                                nindexedinstvars * sizeof(long);
+                    PROTECT_CONTEXT
                     _qAlignedNew(newobj, instsize, SENDER);
                     UNPROTECT_CONTEXT
                     if (newobj == nil) {
                         break;
                     }
                     _InstPtr(newobj)->o_class = self;
-#if defined(memset4) && ! defined(NEGATIVE_ADDRESSES)
+#if defined(FAST_ARRAY_MEMSET4) && ! defined(NEGATIVE_ADDRESSES)
                     /*
                      * knowing that nil is 0
                      */
                     memset4(_InstPtr(newobj)->i_instvars, 0, nInstVars + nindexedinstvars);
 #else
-# if defined(FAST_MEMSET) && ! defined(NEGATIVE_ADDRESSES)
+# if defined(FAST_ARRAY_MEMSET) && ! defined(NEGATIVE_ADDRESSES)
                     /*
                      * knowing that nil is 0
                      */
@@ -446,9 +488,10 @@
 
                case FLOATARRAY:
                     instsize = sizeof(struct floatArray) + 
-                               nInstVars * sizeof(OBJ) + 
+                               __OBJS2BYTES__(nInstVars) + 
                                (nindexedinstvars - 1) * sizeof(float);
 
+                    PROTECT_CONTEXT
                     _qNew(newobj, instsize, SENDER);
                     UNPROTECT_CONTEXT
                     if (newobj == nil) {
@@ -456,19 +499,24 @@
                     }
                     _InstPtr(newobj)->o_class = self;
                     op = _InstPtr(newobj)->i_instvars;
+# if defined(mips) /* knowin that float 0.0 is all-zeros */
+                    memset(_InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
+# else
                     while (nInstVars--)
                         *op++ = nil;
                     fp = (float *)op;
                     while (nindexedinstvars--)
                         *fp++ = 0.0;
+# endif
                     RETURN ( newobj );
                     break;
 
                case DOUBLEARRAY:
                     instsize = sizeof(struct doubleArray) + 
-                               nInstVars * sizeof(OBJ) + 
+                               __OBJS2BYTES__(nInstVars) + 
                                (nindexedinstvars - 1) * sizeof(double);
 
+                    PROTECT_CONTEXT
                     _qAlignedNew(newobj, instsize, SENDER);
                     UNPROTECT_CONTEXT
                     if (newobj == nil) {
@@ -495,31 +543,42 @@
                 case WKPOINTERARRAY:
                 case POINTERARRAY:
                     nInstVars += nindexedinstvars;
-                    instsize = OHDR_SIZE + nInstVars * sizeof(OBJ);
+                    instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
+                    PROTECT_CONTEXT
                     _qAlignedNew(newobj, instsize, SENDER);
                     UNPROTECT_CONTEXT
                     if (newobj == nil) {
                         break;
                     }
                     _InstPtr(newobj)->o_class = self;
-#if defined(memset4)
+#if defined(FAST_ARRAY_MEMSET4)
                     memset4(_InstPtr(newobj)->i_instvars, nil, nInstVars);
 #else
 # if !defined(NEGATIVE_ADDRESSES)
                     /*
                      * knowing that nil is 0
                      */
+#ifdef mips
+# define FAST_ARRAY_MEMSET_DOUBLES_UNROLLED
+# undef FAST_ARRAY_MEMSET_DOUBLES_UNROLLED
+# undef FAST_ARRAY_MEMSET_LONGLONG_UNROLLED
+# define FAST_ARRAY_MEMSET
+#endif
+#ifdef sparc
+# define FAST_ARRAY_MEMSET_DOUBLES_UNROLLED
+#endif
+
 #  if defined(FAST_ARRAY_MEMSET_DOUBLES_UNROLLED)
                     op = _InstPtr(newobj)->i_instvars;
                     if (nInstVars > 8) {
-                        *op++ = nil;	/* for alignment */
+                        *op++ = nil;    /* for alignment */
                         nInstVars--;
                         while (nInstVars >= 8) {
                             *(double *)op = 0.0;
                             ((double *)op)[1] = 0.0;
                             ((double *)op)[2] = 0.0;
                             ((double *)op)[3] = 0.0;
-                            op = (OBJ *)(((char *)op) + (sizeof(double)*4));
+                            op += 8;
                             nInstVars -= 8;
                         }
                     }
@@ -531,14 +590,14 @@
 #   if defined(FAST_ARRAY_MEMSET_LONGLONG_UNROLLED)
                     op = _InstPtr(newobj)->i_instvars;
                     if (nInstVars > 8) {
-                        *op++ = nil;	/* for alignment */
+                        *op++ = nil;    /* for alignment */
                         nInstVars--;
                         while (nInstVars >= 8) {
                             *(long long *)op = 0;
                             ((long long *)op)[1] = 0;
                             ((long long *)op)[2] = 0;
                             ((long long *)op)[3] = 0;
-                            op = (OBJ *)(((char *)op) + (sizeof(long long)*4));
+                            op += 8;
                             nInstVars -= 8;
                         }
                     }
@@ -571,7 +630,8 @@
                      * n == 0
                      */
                     if (nindexedinstvars == 0) {
-                        instsize = OHDR_SIZE + nInstVars * sizeof(OBJ);
+                        instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
+                        PROTECT_CONTEXT
                         _qAlignedNew(newobj, instsize, SENDER);
                         UNPROTECT_CONTEXT
                         if (newobj == nil) {
@@ -579,7 +639,7 @@
                         }
                         _InstPtr(newobj)->o_class = self;
                         if (nInstVars) {
-#if defined(memset4)
+#if defined(FAST_OBJECT_MEMSET4)
                             memset4(_InstPtr(newobj)->i_instvars, nil, nInstVars);
 #else
 # if defined(FAST_MEMSET) && ! defined(NEGATIVE_ADDRESSES)
@@ -713,7 +773,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( _MKSMALLINT( BYTEARRAY ) );
+    RETURN ( _MKSMALLINT(BYTEARRAY) );
 %}
 ! 
 
@@ -723,7 +783,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( _MKSMALLINT( WORDARRAY ) );
+    RETURN ( _MKSMALLINT(WORDARRAY) );
 %}
 ! 
 
@@ -733,7 +793,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( _MKSMALLINT( LONGARRAY ) );
+    RETURN ( _MKSMALLINT(LONGARRAY) );
 %}
 ! 
 
@@ -743,7 +803,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( _MKSMALLINT( FLOATARRAY ) );
+    RETURN ( _MKSMALLINT(FLOATARRAY) );
 %}
 ! 
 
@@ -753,7 +813,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( _MKSMALLINT( DOUBLEARRAY ) );
+    RETURN ( _MKSMALLINT(DOUBLEARRAY) );
 %}
 ! 
 
@@ -763,7 +823,17 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( _MKSMALLINT( POINTERARRAY ) );
+    RETURN ( _MKSMALLINT(POINTERARRAY) );
+%}
+! 
+
+flagWeakPointers
+    "return the flag code for weak pointer indexed instances (i.e. WeakArray)"
+
+%{  /* NOCONTEXT */
+    /* this is defined as a primitive to get defines from stc.h */
+
+    RETURN ( _MKSMALLINT(WKPOINTERARRAY) );
 %}
 ! 
 
@@ -773,7 +843,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( _MKSMALLINT( ARRAYMASK ) );
+    RETURN ( _MKSMALLINT(ARRAYMASK) );
 %}
 ! 
 
@@ -783,7 +853,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( _MKSMALLINT( BLOCK_INSTS ) );
+    RETURN ( _MKSMALLINT(BLOCK_INSTS) );
 %}
 ! 
 
@@ -793,7 +863,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( _MKSMALLINT( METHOD_INSTS ) );
+    RETURN ( _MKSMALLINT(METHOD_INSTS) );
 %}
 ! 
 
@@ -803,7 +873,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( _MKSMALLINT( CONTEXT_INSTS ) );
+    RETURN ( _MKSMALLINT(CONTEXT_INSTS) );
 %}
 ! 
 
@@ -813,7 +883,27 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( _MKSMALLINT( BCONTEXT_INSTS ) );
+    RETURN ( _MKSMALLINT(BCONTEXT_INSTS) );
+%}
+! 
+
+flagFloat
+    "return the flag code which marks Float-type instances"
+
+%{  /* NOCONTEXT */
+    /* this is defined as a primitive to get defines from stc.h */
+
+    RETURN ( _MKSMALLINT(FLOAT_INSTS) );
+%}
+! 
+
+flagSymbol
+    "return the flag code which marks Symbol-type instances"
+
+%{  /* NOCONTEXT */
+    /* this is defined as a primitive to get defines from stc.h */
+
+    RETURN ( _MKSMALLINT(SYMBOL_INSTS) );
 %}
 ! !
 
@@ -1107,7 +1197,7 @@
      1st argument to the methodDictionary. Since it does not flush
      any caches, this is only allowed for lazy methods."
 
-    newMethod isLazy ifFalse:[
+    newMethod isLazyMethod ifFalse:[
         self error:'operation only allowed for lazy methods'.
         ^ false
     ].