hg/stx-libbasic: comparison Behavior.st

equal deleted inserted replaced

-:b09ce8542506
+:961f2b095c22
 checking for behaviors."
 %{  /* NOCONTEXT */
 /* this is defined as a primitive to get defines from stc.h */
-RETURN ( _MKSMALLINT(BEHAVIOR_INSTS) );
+RETURN ( __MKSMALLINT(BEHAVIOR_INSTS) );
 %}
 "consistency check:
 all class-entries must be behaviors;
 all behaviors must be flagged so (in its class's flags)
 checking for blocks."
 %{  /* NOCONTEXT */
 /* this is defined as a primitive to get defines from stc.h */
-RETURN ( _MKSMALLINT(BLOCK_INSTS) );
+RETURN ( __MKSMALLINT(BLOCK_INSTS) );
 %}
 !
 flagBlockContext
 "return the flag code which marks BlockContext-like instances.
 checking for blockContexts."
 %{  /* NOCONTEXT */
 /* this is defined as a primitive to get defines from stc.h */
-RETURN ( _MKSMALLINT(BCONTEXT_INSTS) );
+RETURN ( __MKSMALLINT(BCONTEXT_INSTS) );
 %}
 !
 flagBytes
 "return the flag code for byte-valued indexed instances.
 it with flagBytes."
 %{  /* NOCONTEXT */
 /* this is defined as a primitive to get defines from stc.h */
-RETURN ( _MKSMALLINT(BYTEARRAY) );
+RETURN ( __MKSMALLINT(BYTEARRAY) );
 %}
 "
 Behavior flagBytes
 "
 !
 checking for contexts."
 %{  /* NOCONTEXT */
 /* this is defined as a primitive to get defines from stc.h */
-RETURN ( _MKSMALLINT(CONTEXT_INSTS) );
+RETURN ( __MKSMALLINT(CONTEXT_INSTS) );
 %}
 !
 flagDoubles
 "return the flag code for double-valued indexed instances (i.e. 8-byte reals).
 it with flagDoubles."
 %{  /* NOCONTEXT */
 /* this is defined as a primitive to get defines from stc.h */
-RETURN ( _MKSMALLINT(DOUBLEARRAY) );
+RETURN ( __MKSMALLINT(DOUBLEARRAY) );
 %}
 "
 Behavior flagDoubles
 "
 !
 checking for floats."
 %{  /* NOCONTEXT */
 /* this is defined as a primitive to get defines from stc.h */
-RETURN ( _MKSMALLINT(FLOAT_INSTS) );
+RETURN ( __MKSMALLINT(FLOAT_INSTS) );
 %}
 !
 flagFloats
 "return the flag code for float-valued indexed instances (i.e. 4-byte reals).
 it with flagFloats."
 %{  /* NOCONTEXT */
 /* this is defined as a primitive to get defines from stc.h */
-RETURN ( _MKSMALLINT(FLOATARRAY) );
+RETURN ( __MKSMALLINT(FLOATARRAY) );
 %}
 "
 Behavior flagFloats
 "
 !
 it with flagLongs."
 %{  /* NOCONTEXT */
 /* this is defined as a primitive to get defines from stc.h */
-RETURN ( _MKSMALLINT(LONGARRAY) );
+RETURN ( __MKSMALLINT(LONGARRAY) );
 %}
 "
 Behavior flagLongs
 "
 !
 checking for methods."
 %{  /* NOCONTEXT */
 /* this is defined as a primitive to get defines from stc.h */
-RETURN ( _MKSMALLINT(METHOD_INSTS) );
+RETURN ( __MKSMALLINT(METHOD_INSTS) );
 %}
 !
 flagNonObjectInst
 "return the flag code which marks instances which have a
 (these are ignored by the garbage collector)"
 %{  /* NOCONTEXT */
 /* this is defined as a primitive to get defines from stc.h */
-RETURN ( _MKSMALLINT(NONOBJECT_INSTS) );
+RETURN ( __MKSMALLINT(NONOBJECT_INSTS) );
 %}
 !
 flagNotIndexed
 "return the flag code for non-indexed instances.
 it with flagPointers."
 %{  /* NOCONTEXT */
 /* this is defined as a primitive to get defines from stc.h */
-RETURN ( _MKSMALLINT(POINTERARRAY) );
+RETURN ( __MKSMALLINT(POINTERARRAY) );
 %}
 "
 Behavior flagPointers
 "
 !
 checking for symbols."
 %{  /* NOCONTEXT */
 /* this is defined as a primitive to get defines from stc.h */
-RETURN ( _MKSMALLINT(SYMBOL_INSTS) );
+RETURN ( __MKSMALLINT(SYMBOL_INSTS) );
 %}
 !
 flagWeakPointers
 "return the flag code for weak pointer indexed instances (i.e. WeakArray).
 it with flagWeakPointers."
 %{  /* NOCONTEXT */
 /* this is defined as a primitive to get defines from stc.h */
-RETURN ( _MKSMALLINT(WKPOINTERARRAY) );
+RETURN ( __MKSMALLINT(WKPOINTERARRAY) );
 %}
 !
 flagWords
 "return the flag code for word-valued indexed instances (i.e. 2-byte).
 it with flagWords."
 %{  /* NOCONTEXT */
 /* this is defined as a primitive to get defines from stc.h */
-RETURN ( _MKSMALLINT(WORDARRAY) );
+RETURN ( __MKSMALLINT(WORDARRAY) );
 %}
 "
 Behavior flagWords
 "
 !
 "return a mask to extract all index-type bits"
 %{  /* NOCONTEXT */
 /* this is defined as a primitive to get defines from stc.h */
-RETURN ( _MKSMALLINT(ARRAYMASK) );
+RETURN ( __MKSMALLINT(ARRAYMASK) );
 %}
 ! !
 !Behavior class methodsFor:'private '!
 * 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));
+nInstVars = __intVal(__INST(instSize));
 instsize = OHDR_SIZE + __OBJS2BYTES__(nInstVars);
 newobj = (OBJ) __newNextPtr;
 nextPtr = ((char *)newobj) + instsize;
 	    __newNextPtr = nextPtr;
 	}
 #endif
 ok:
-	_InstPtr(newobj)->o_class = self;
+	__InstPtr(newobj)->o_class = self;
 	__qSTORE(newobj, self);
 	if (nInstVars) {
 #if defined(memset4) && defined(FAST_OBJECT_MEMSET4) || defined(FAST_MEMSET4)
-	    memset4(_InstPtr(newobj)->i_instvars, nil, nInstVars);
+	    memset4(__InstPtr(newobj)->i_instvars, nil, nInstVars);
 #else
 	    REGISTER OBJ *op;
-	    op = _InstPtr(newobj)->i_instvars;
+	    op = __InstPtr(newobj)->i_instvars;
 # if !defined(NEGATIVE_ADDRESSES)
 	    /*
 	     * knowing that nil is 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;
 		nInstVars--;
 	    } while (nInstVars != 0);
 REGISTER OBJ *op;
 float *fp;
 double *dp;
 if (__isSmallInteger(anInteger)) {
-	nindexedinstvars = _intVal(anInteger);
+	nindexedinstvars = __intVal(anInteger);
 	if (nindexedinstvars >= 0) {
-	    nInstVars = _intVal(_INST(instSize));
+	    nInstVars = __intVal(__INST(instSize));
-	    flags = _intVal(_INST(flags)) & ARRAYMASK;
+	    flags = __intVal(__INST(flags)) & ARRAYMASK;
 	    switch (flags) {
 		case BYTEARRAY:
 		    instsize = OHDR_SIZE + nindexedinstvars;
 		    if (nInstVars == 0) {
 			if (__CanDoQuickNew(instsize)) {
 			    /*
 			     * the most common case
 			     */
 			    __qCheckedNew(newobj, instsize);
-			    _InstPtr(newobj)->o_class = self;
+			    __InstPtr(newobj)->o_class = self;
 #if defined(memset4) && defined(FAST_ARRAY_MEMSET4) || defined(FAST_MEMSET4)
 			    nInstVars = nindexedinstvars >> 2;
 			    if (nindexedinstvars & 3) nInstVars++;
-			    memset4(_InstPtr(newobj)->i_instvars, 0, nInstVars);
+			    memset4(__InstPtr(newobj)->i_instvars, 0, nInstVars);
 #else
 # if defined(FAST_ARRAY_MEMSET) && ! defined(NEGATIVE_ADDRESSES)
-			    memset(_InstPtr(newobj)->i_instvars, 0, nindexedinstvars);
+			    memset(__InstPtr(newobj)->i_instvars, 0, nindexedinstvars);
 # else
-			    cp = (char *)_InstPtr(newobj)->i_instvars;
+			    cp = (char *)__InstPtr(newobj)->i_instvars;
 			    while (nindexedinstvars >= sizeof(long)) {
 				*(long *)cp = 0;
 				cp += sizeof(long);
 				nindexedinstvars -= sizeof(long);
 			    }
 		    __qNew(newobj, instsize, SENDER);
 		    __UNPROTECT_CONTEXT__
 		    if (newobj == nil) {
 			break;
 		    }
-		    _InstPtr(newobj)->o_class = self;
+		    __InstPtr(newobj)->o_class = self;
 		    __qSTORE(newobj, self);
 #if defined(memset4) && defined(FAST_ARRAY_MEMSET4) || defined(FAST_MEMSET4)
 		    nInstVars = (instsize-OHDR_SIZE) >> 2;
 		    if (instsize & 3) nInstVars++;
-		    memset4(_InstPtr(newobj)->i_instvars, 0, nInstVars);
+		    memset4(__InstPtr(newobj)->i_instvars, 0, nInstVars);
 #else
 # if defined(FAST_ARRAY_MEMSET) && ! defined(NEGATIVE_ADDRESSES)
 		    /*
 		     * knowing that nil is 0
 		     */
-		    memset(_InstPtr(newobj)->i_instvars, 0, instsize-OHDR_SIZE);
+		    memset(__InstPtr(newobj)->i_instvars, 0, instsize-OHDR_SIZE);
 # else
-		    op = _InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
 		    while (nInstVars--)
 			*op++ = nil;
 		    cp = (char *)op;
 		    while (nindexedinstvars >= sizeof(long)) {
 			*(long *)cp = 0;
 		    __qNew(newobj, instsize, SENDER);
 		    __UNPROTECT_CONTEXT__
 		    if (newobj == nil) {
 			break;
 		    }
-		    _InstPtr(newobj)->o_class = self;
+		    __InstPtr(newobj)->o_class = self;
 		    __qSTORE(newobj, self);
 #if defined(FAST_ARRAY_MEMSET) && ! defined(NEGATIVE_ADDRESSES)
 		    /*
 		     * knowing that nil is 0
 		     */
-		    memset(_InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
+		    memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
 #else
-		    op = _InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
 		    while (nInstVars--)
 			*op++ = nil;
 		    sp = (short *)op;
 		    while (nindexedinstvars--)
 			*sp++ = 0;
 		    __qAlignedNew(newobj, instsize, SENDER);
 		    __UNPROTECT_CONTEXT__
 		    if (newobj == nil) {
 			break;
 		    }
-		    _InstPtr(newobj)->o_class = self;
+		    __InstPtr(newobj)->o_class = self;
 		    __qSTORE(newobj, self);
 #if defined(memset4) && defined(FAST_ARRAY_MEMSET4) || defined(FAST_MEMSET4)
 		    /*
 		     * knowing that nil is 0
 		     */
-		    memset4(_InstPtr(newobj)->i_instvars, 0, nInstVars + nindexedinstvars);
+		    memset4(__InstPtr(newobj)->i_instvars, 0, nInstVars + nindexedinstvars);
 #else
 # if defined(FAST_ARRAY_MEMSET) && ! defined(NEGATIVE_ADDRESSES)
 		    /*
 		     * knowing that nil is 0
 		     */
-		    memset(_InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
+		    memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
 # else
-		    op = _InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
 		    while (nInstVars--)
 			*op++ = nil;
 		    lp = (long *)op;
 		    while (nindexedinstvars--)
 			*lp++ = 0;
 		    __qNew(newobj, instsize, SENDER);
 		    __UNPROTECT_CONTEXT__
 		    if (newobj == nil) {
 			break;
 		    }
-		    _InstPtr(newobj)->o_class = self;
+		    __InstPtr(newobj)->o_class = self;
 		    __qSTORE(newobj, self);
-		    op = _InstPtr(newobj)->i_instvars;
+		    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);
+		    memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
 # else
 		    while (nInstVars--)
 			*op++ = nil;
 		    fp = (float *)op;
 		    while (nindexedinstvars--)
 		    __qAlignedNew(newobj, instsize, SENDER);
 		    __UNPROTECT_CONTEXT__
 		    if (newobj == nil) {
 			break;
 		    }
-		    _InstPtr(newobj)->o_class = self;
+		    __InstPtr(newobj)->o_class = self;
 		    __qSTORE(newobj, self);
-		    op = _InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
 		    while (nInstVars--)
 			*op++ = nil;
 #ifdef NEED_DOUBLE_ALIGN
 		    /*
 		     * care for double alignment
 		    __qAlignedNew(newobj, instsize, SENDER);
 		    __UNPROTECT_CONTEXT__
 		    if (newobj == nil) {
 			break;
 		    }
-		    _InstPtr(newobj)->o_class = self;
+		    __InstPtr(newobj)->o_class = self;
 		    __qSTORE(newobj, self);
 #if defined(memset4) && defined(FAST_ARRAY_MEMSET4) || defined(FAST_MEMSET4)
-		    memset4(_InstPtr(newobj)->i_instvars, nil, nInstVars);
+		    memset4(__InstPtr(newobj)->i_instvars, nil, nInstVars);
 #else
 # if !defined(NEGATIVE_ADDRESSES)
 		    /*
 		     * knowing that nil is 0
 		     */
 #ifdef sparc
 # define FAST_ARRAY_MEMSET_DOUBLES_UNROLLED
 #endif
 #  if defined(FAST_ARRAY_MEMSET_DOUBLES_UNROLLED)
-		    op = _InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
 		    if (nInstVars > 8) {
 			*op++ = nil;    /* for alignment */
 			nInstVars--;
 			while (nInstVars >= 8) {
 			    *(double *)op = 0.0;
 			*op++ = 0;
 			nInstVars--;
 		    }
 #  else
 #   if defined(FAST_ARRAY_MEMSET_LONGLONG_UNROLLED)
-		    op = _InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
 		    if (nInstVars > 8) {
 			*op++ = nil;    /* for alignment */
 			nInstVars--;
 			while (nInstVars >= 8) {
 			    *(long long *)op = 0;
 			*op++ = 0;
 			nInstVars--;
 		    }
 #   else
 #    if defined(FAST_ARRAY_MEMSET)
-		    memset(_InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
+		    memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
 #    else
-		    op = _InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
 		    while (nInstVars--)
 			*op++ = nil;
 #    endif
 #   endif
 #  endif
 # else
-		    op = _InstPtr(newobj)->i_instvars;
+		    op = __InstPtr(newobj)->i_instvars;
 		    while (nInstVars--)
 			*op++ = nil;
 # endif
 #endif
 		    RETURN ( newobj );
 			__qAlignedNew(newobj, instsize, SENDER);
 			__UNPROTECT_CONTEXT__
 			if (newobj == nil) {
 			    break;
 			}
-			_InstPtr(newobj)->o_class = self;
+			__InstPtr(newobj)->o_class = self;
 			__qSTORE(newobj, self);
 			if (nInstVars) {
 #if defined(memset4) && defined(FAST_OBJECT_MEMSET4) || defined(FAST_MEMSET4)
-			    memset4(_InstPtr(newobj)->i_instvars, nil, nInstVars);
+			    memset4(__InstPtr(newobj)->i_instvars, nil, nInstVars);
 #else
 # if defined(FAST_MEMSET) && ! defined(NEGATIVE_ADDRESSES)
 			    /*
 			     * knowing that nil is 0
 			     */
-			    memset(_InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
+			    memset(__InstPtr(newobj)->i_instvars, 0, instsize - OHDR_SIZE);
 # else
-			    op = _InstPtr(newobj)->i_instvars;
+			    op = __InstPtr(newobj)->i_instvars;
 			    do {
 				*op++ = nil;
 			    } while (--nInstVars);
 # endif
 #endif
 %{  /* NOCONTEXT */
 REGISTER int what;
-what = (INT)(_INST(flags)) & __MASKSMALLINT(ARRAYMASK);
+what = (INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK);
 RETURN (( (what == __MASKSMALLINT(BYTEARRAY))
 	     || (what == __MASKSMALLINT(WORDARRAY))) ? true : false );
 %}
 !
 "this could also be defined as:
 	^ (flags bitAnd:(Behavior maskIndexType)) == Behavior flagBytes
 "
 %{  /* NOCONTEXT */
-RETURN ( (((INT)(_INST(flags)) & __MASKSMALLINT(ARRAYMASK)) == __MASKSMALLINT(BYTEARRAY)) ? true : false );
+RETURN ( (((INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK)) == __MASKSMALLINT(BYTEARRAY)) ? true : false );
 %}
 !
 isDoubles
 "return true, if instances have indexed double instance variables"
 "this could also be defined as:
 	^ (flags bitAnd:(Behavior maskIndexType)) == Behavior flagDoubles
 "
 %{  /* NOCONTEXT */
-RETURN ( (((INT)(_INST(flags)) & __MASKSMALLINT(ARRAYMASK)) == __MASKSMALLINT(DOUBLEARRAY)) ? true : false );
+RETURN ( (((INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK)) == __MASKSMALLINT(DOUBLEARRAY)) ? true : false );
 %}
 !
 isFixed
 "return true, if instances do not have indexed instance variables"
 	^ self isVariable not
 "
 %{  /* NOCONTEXT */
-RETURN ( ((INT)(_INST(flags)) & __MASKSMALLINT(ARRAYMASK)) ? false : true );
+RETURN ( ((INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK)) ? false : true );
 %}
 !
 isFloats
 "return true, if instances have indexed float instance variables"
 "this could also be defined as:
 	^ (flags bitAnd:(Behavior maskIndexType)) == Behavior flagFloats
 "
 %{  /* NOCONTEXT */
-RETURN ( (((INT)(_INST(flags)) & __MASKSMALLINT(ARRAYMASK)) == __MASKSMALLINT(FLOATARRAY)) ? true : false );
+RETURN ( (((INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK)) == __MASKSMALLINT(FLOATARRAY)) ? true : false );
 %}
 !
 isFloatsOrDoubles
 "return true, if instances have indexed float or double instance variables"
 %{  /* NOCONTEXT */
 int what;
-what = (INT)(_INST(flags)) & __MASKSMALLINT(ARRAYMASK);
+what = (INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK);
 RETURN (( (what == __MASKSMALLINT(FLOATARRAY))
 	     || (what == __MASKSMALLINT(DOUBLEARRAY))) ? true : false );
 %}
 "
 (Object new) class isFloatsOrDoubles
 "this could also be defined as:
 	^ (flags bitAnd:(Behavior maskIndexType)) == Behavior flagLongs
 "
 %{  /* NOCONTEXT */
-RETURN ( (((INT)(_INST(flags)) & __MASKSMALLINT(ARRAYMASK)) == __MASKSMALLINT(LONGARRAY)) ? true : false );
+RETURN ( (((INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK)) == __MASKSMALLINT(LONGARRAY)) ? true : false );
 %}
 !
 isPointers
 "return true, if instances have pointer instance variables
 %{  /* NOCONTEXT */
 REGISTER int flags;
-flags = _intVal(_INST(flags)) & ARRAYMASK;
+flags = __intVal(__INST(flags)) & ARRAYMASK;
 switch (flags) {
 	default:
 	    /* normal objects */
 	    RETURN ( true );
 	^ (flags bitAnd:(Behavior maskIndexType)) ~~ 0
 "
 %{  /* NOCONTEXT */
-RETURN ( ((INT)(_INST(flags)) & __MASKSMALLINT(ARRAYMASK)) ? true : false );
+RETURN ( ((INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK)) ? true : false );
 %}
 !
 isWords
 "return true, if instances have indexed short instance variables"
 "this could also be defined as:
 	^ (flags bitAnd:(Behavior maskIndexType)) == Behavior flagWords
 "
 %{  /* NOCONTEXT */
-RETURN ( (((INT)(_INST(flags)) & __MASKSMALLINT(ARRAYMASK)) == __MASKSMALLINT(WORDARRAY)) ? true : false );
+RETURN ( (((INT)(__INST(flags)) & __MASKSMALLINT(ARRAYMASK)) == __MASKSMALLINT(WORDARRAY)) ? true : false );
 %}
 !
 lookupMethodFor:aSelector
 "return the method, which would be executed if aSelector was sent to
 nInstvars := self instSize.
 %{
 int nBytes;
-nBytes = _intVal(nInstvars) * sizeof(OBJ) + OHDR_SIZE;
+nBytes = __intVal(nInstvars) * sizeof(OBJ) + OHDR_SIZE;
 if (__isSmallInteger(n)) {
 	int nIndex;
-	nIndex = _intVal(n);
+	nIndex = __intVal(n);
-	switch (_intVal(_INST(flags)) & ARRAYMASK) {
+	switch (__intVal(__INST(flags)) & ARRAYMASK) {
 	    case BYTEARRAY:
 		nBytes += nIndex;
 		if (nBytes & (ALIGN - 1)) {
 		    nBytes = (nBytes & ~(ALIGN - 1)) + ALIGN;
 		}
 	    default:
 		nBytes += nIndex * sizeof(OBJ);
 		break;
 	}
 }
-RETURN (_MKSMALLINT(nBytes));
+RETURN (__MKSMALLINT(nBytes));
 %}
 !
 sourceCodeAt:aSelector
 "return the methods source for given selector aSelector or nil.
 ! !
 !Behavior class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/Behavior.st,v 1.65 1996-03-07 18:40:50 cg Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/Behavior.st,v 1.66 1996-04-02 21:58:42 cg Exp $'
 ! !

changeset 1133	961f2b095c22
parent 1088	989f0e510a32
child 1179	3e0f32177af4