ExtStream.st
changeset 1133 961f2b095c22
parent 1119 956d62a5656c
child 1138 993e6ffdbf51
--- a/ExtStream.st	Tue Apr 02 18:30:51 1996 +0200
+++ b/ExtStream.st	Wed Apr 03 00:06:56 1996 +0200
@@ -54,16 +54,16 @@
  * All code should use the following macro before doing reads:
  */
 #define __READING__(f)                          \
-    if ((_INST(didWrite) != false)              \
-     && (_INST(mode) == @symbol(readwrite))) {  \
-	_INST(didWrite) = false;                \
+    if ((__INST(didWrite) != false)              \
+     && (__INST(mode) == @symbol(readwrite))) {  \
+	__INST(didWrite) = false;                \
 	fseek(f, 0L, SEEK_CUR); /* needed in stdio */  \
     }
 
 #define __WRITING__(f)                          \
-    if ((_INST(didWrite) != true)               \
-     && (_INST(mode) == @symbol(readwrite))) {  \
-	_INST(didWrite) = true;                 \
+    if ((__INST(didWrite) != true)               \
+     && (__INST(mode) == @symbol(readwrite))) {  \
+	__INST(didWrite) = true;                 \
 	fseek(f, 0L, SEEK_CUR); /* needed in stdio */  \
     }
 
@@ -540,7 +540,7 @@
     FILE *f;
     OBJ fp;
 
-    if ((fp = _INST(filePointer)) != nil) {
+    if ((fp = __INST(filePointer)) != nil) {
 	f = __FILEVal(fp);
 	RETURN ( __MKSMALLINT(fileno(f)) );
     }
@@ -562,7 +562,7 @@
 	__isString(openMode) &&
 	(f = fdopen(__intVal(anInteger), __stringVal(openMode))) != 0
     ) {
-	_INST(filePointer) = fp = __MKOBJ((int)f); __STORE(self, fp);
+	__INST(filePointer) = fp = __MKOBJ((int)f); __STORE(self, fp);
 	RETURN (self);
     }
 %}.
@@ -791,8 +791,8 @@
 %{
     OBJ fp;
 
-    if ((fp = _INST(filePointer)) != nil) {
-	_INST(filePointer) = nil;
+    if ((fp = __INST(filePointer)) != nil) {
+	__INST(filePointer) = nil;
 	__BEGIN_INTERRUPTABLE__
 	fclose(__FILEVal(fp));
 	__END_INTERRUPTABLE__
@@ -845,15 +845,15 @@
     OBJ fp;
     OBJ __MKSTRING_L();
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(writeonly))) {
-	if (_INST(binary) != true) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(writeonly))) {
+	if (__INST(binary) != true) {
 	    f = __FILEVal(fp);
 	    __BEGIN_INTERRUPTABLE__
 	    buffer[0] = 0;
 
-	    _buffered = (_INST(buffered) == true);
+	    _buffered = (__INST(buffered) == true);
 	    if (_buffered) {
 		__READING__(f);
 	    } else {
@@ -865,7 +865,7 @@
 	     * but seems not to work for sockets
 	     */
 #ifdef DOES_NOT_WORK
-	    if (_INST(mode) == _readwrite)
+	    if (__INST(mode) == _readwrite)
 		fseek(f, 0L, SEEK_CUR); /* needed in stdio */
 	    do {
 		rslt = fgets(buffer, sizeof(buffer), f);
@@ -894,7 +894,7 @@
 				    continue;
 				}
 			    }
-			    _INST(lastErrorNumber) = __MKSMALLINT(errno);
+			    __INST(lastErrorNumber) = __MKSMALLINT(errno);
 			}
 			len = 0;
 		    } else {
@@ -936,8 +936,8 @@
 		/* len = strlen(buffer); */
 		len = nextPtr-buffer;
 
-		if (_INST(position) != nil) {
-		    _INST(position) = __MKSMALLINT(__intVal(_INST(position)) + len);
+		if (__INST(position) != nil) {
+		    __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + len);
 		}
 		/* remove EOL character */
 		if (len != 0) {
@@ -951,9 +951,9 @@
 		RETURN ( __MKSTRING_L(buffer, len COMMA_CON) );
 	    }
 	    if (ferror(f) && (errno != 0)) {
-		_INST(lastErrorNumber) = __MKSMALLINT(errno);
+		__INST(lastErrorNumber) = __MKSMALLINT(errno);
 	    } else {
-		_INST(hitEOF) = true;
+		__INST(hitEOF) = true;
 		RETURN ( nil );
 	    }
 	}
@@ -974,18 +974,18 @@
     OBJ pos, fp;
     char *cp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil) 
-     && (_INST(mode) != @symbol(readonly))) {
-	if (_INST(binary) != true) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil) 
+     && (__INST(mode) != @symbol(readonly))) {
+	if (__INST(binary) != true) {
 	    if (__isString(aString)) {
 		f = __FILEVal(fp);
-		cp = (char *) _stringVal(aString);
-		len = _stringSize(aString);
+		cp = (char *) __stringVal(aString);
+		len = __stringSize(aString);
 
 		__BEGIN_INTERRUPTABLE__
 
-		if (_INST(buffered) == true) {
+		if (__INST(buffered) == true) {
 		    __WRITING__(f)
 		    cnt = fwrite(cp, 1, len, f);
 		} else {
@@ -997,12 +997,12 @@
 		if (cnt == len) {
 		    len1 = len;
 
-		    if (_INST(useCRLF) == true) {
+		    if (__INST(useCRLF) == true) {
 			cp = "\r\n"; len = 2;
 		    } else {
 			cp = "\n"; len = 1;
 		    }
-		    if (_INST(buffered) == true) {
+		    if (__INST(buffered) == true) {
 			cnt = fwrite(cp, 1, len, f);
 		    } else {
 			do {
@@ -1011,9 +1011,9 @@
 		    }
 
 		    if (cnt > 0) {
-			pos = _INST(position);
+			pos = __INST(position);
 			if (pos != nil) {
-			    _INST(position) = __MKSMALLINT(__intVal(pos)+len1+cnt);
+			    __INST(position) = __MKSMALLINT(__intVal(pos)+len1+cnt);
 			}
 			__END_INTERRUPTABLE__
 
@@ -1022,7 +1022,7 @@
 		}
 
 		__END_INTERRUPTABLE__
-		_INST(lastErrorNumber) = __MKSMALLINT(errno);
+		__INST(lastErrorNumber) = __MKSMALLINT(errno);
 	    }
 	}
     }
@@ -1059,14 +1059,14 @@
     int matchLen = 0;
     char buffer[1024];
 
-    _INST(lastErrorNumber) = nil;
+    __INST(lastErrorNumber) = nil;
     if (__isSmallInteger(srcFilePointer)) {
 	if ((aStringOrNil == nil) || __isString(aStringOrNil)) {
 	    if (aStringOrNil != nil) {
-		matchString = (char *) _stringVal(aStringOrNil);
-		matchLen = _stringSize(aStringOrNil);
+		matchString = (char *) __stringVal(aStringOrNil);
+		matchLen = __stringSize(aStringOrNil);
 	    }
-	    dst = __FILEVal(_INST(filePointer));
+	    dst = __FILEVal(__INST(filePointer));
 	    src = __FILEVal(srcFilePointer);
 	    __BEGIN_INTERRUPTABLE__
 	    errno = 0;
@@ -1084,14 +1084,14 @@
 		}
 		if (fputs(buffer, dst) == EOF) {
 		    if (ferror(dst)) {
-			_INST(lastErrorNumber) = __MKSMALLINT(errno);
+			__INST(lastErrorNumber) = __MKSMALLINT(errno);
 			__END_INTERRUPTABLE__
 			goto err;
 		    }
 		    break;
 		}
 #ifndef OLD
-		if (_INST(buffered) == false) {
+		if (__INST(buffered) == false) {
 		    fflush(dst);
 		}
 #endif
@@ -1101,7 +1101,7 @@
 		}
 	    }
 	    __END_INTERRUPTABLE__
-	    _INST(position) = nil;
+	    __INST(position) = nil;
 	    RETURN (self);
 	}
     }
@@ -1138,12 +1138,12 @@
     char *matchString;
     int  firstpos = -1, lastpos;
 
-    _INST(lastErrorNumber) = nil;
+    __INST(lastErrorNumber) = nil;
     if (__isString(aString)) {
-	matchString = (char *) _stringVal(aString);
-	l = _stringSize(aString);
-
-	f = __FILEVal(_INST(filePointer));
+	matchString = (char *) __stringVal(aString);
+	l = __stringSize(aString);
+
+	f = __FILEVal(__INST(filePointer));
 	__READING__(f)
 
 	for (;;) {
@@ -1159,7 +1159,7 @@
 
 	    if (cp == NULL) {
 		if (ferror(f)) {
-		    _INST(lastErrorNumber) = __MKSMALLINT(errno);
+		    __INST(lastErrorNumber) = __MKSMALLINT(errno);
 		    goto err;
 		} else {
 		    fseek(f, firstpos, SEEK_SET);
@@ -1175,7 +1175,7 @@
 	cp = buffer;
 	while (*cp && (*cp != '\n')) cp++;
 	*cp = '\0';
-	RETURN ( _MKSTRING(buffer COMMA_CON) );
+	RETURN ( __MKSTRING(buffer COMMA_CON) );
     }
 err: ;
 %}.
@@ -1275,8 +1275,8 @@
     int ret, ioNum, ioArg;
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if ((fp = _INST(filePointer)) != nil) {
+    __INST(lastErrorNumber) = nil;
+    if ((fp = __INST(filePointer)) != nil) {
 	if (__isSmallInteger(ioctlNumber)) {
 	    ioNum = __intVal(ioctlNumber);
 	    f = __FILEVal(fp);
@@ -1290,8 +1290,8 @@
 	    if (ret >= 0) {
 		RETURN ( __MKSMALLINT(ret) );
 	    }
-	    _INST(position) = nil;
-	    _INST(lastErrorNumber) = __MKSMALLINT(errno);
+	    __INST(position) = nil;
+	    __INST(lastErrorNumber) = __MKSMALLINT(errno);
 	}
     }
 #endif
@@ -1319,8 +1319,8 @@
     int ret, ioNum;
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if ((fp = _INST(filePointer)) != nil) {
+    __INST(lastErrorNumber) = nil;
+    if ((fp = __INST(filePointer)) != nil) {
 	if (__isSmallInteger(ioctlNumber) 
 	 && (__isSmallInteger(arg) || __isBytes(arg))) {
 	    f = __FILEVal(fp);
@@ -1339,8 +1339,8 @@
 	    if (ret >= 0) {
 		RETURN ( __MKSMALLINT(ret) );
 	    }
-	    _INST(position) = nil;
-	    _INST(lastErrorNumber) = __MKSMALLINT(errno);
+	    __INST(position) = nil;
+	    __INST(lastErrorNumber) = __MKSMALLINT(errno);
 	}
     }
 #endif
@@ -1396,12 +1396,12 @@
     FILE *f;
     OBJ fp;
 
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(readonly))) {
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(readonly))) {
 	if (__isSmallInteger(newSize)) {
 	    f = __FILEVal(fp);
 
-	    if (_INST(buffered) == true) {
+	    if (__INST(buffered) == true) {
 		__READING__(f)
 		fflush(f);
 		fseek(f, 0L, SEEK_END); /* needed in stdio */
@@ -1441,18 +1441,18 @@
     int cnt;
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(writeonly))) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(writeonly))) {
 	f = __FILEVal(fp);
 
-	if (_INST(buffered) == true) {
+	if (__INST(buffered) == true) {
 	    __READING__(f)
 	}
 
 	__BEGIN_INTERRUPTABLE__
 	do {
-	    if (_INST(buffered) == false) {
+	    if (__INST(buffered) == false) {
 		cnt = read(fileno(f), &byte, 1);
 	    } else {
 		cnt = fread(&byte, 1, 1, f);
@@ -1461,20 +1461,20 @@
 	__END_INTERRUPTABLE__
 
 	if (cnt == 1) {
-	    if (_INST(position) != nil)
-		_INST(position) = __MKSMALLINT(__intVal(_INST(position)) + 1);
+	    if (__INST(position) != nil)
+		__INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 1);
 	    RETURN ( __MKSMALLINT(byte) );
 	}
 	if (cnt == 0) {
-	    _INST(hitEOF) = true;
+	    __INST(hitEOF) = true;
 /*
 	    if (errno == EWOULDBLOCK) {
 		RETURN (nil);
 	    }
 */
 	}
-	_INST(position) = nil;
-	_INST(lastErrorNumber) = __MKSMALLINT(errno);
+	__INST(position) = nil;
+	__INST(lastErrorNumber) = __MKSMALLINT(errno);
     }
 %}.
     lastErrorNumber notNil ifTrue:[^ self readError].
@@ -1525,9 +1525,9 @@
     char *cp;
     OBJ pos, fp, oClass;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(writeonly))) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(writeonly))) {
 	if (__bothSmallInteger(count, start)) {
 	    f = __FILEVal(fp);
 
@@ -1552,7 +1552,7 @@
 		 * mhmh - since we are interruptable, anObject may move.
 		 * therefore, fetch the cp-pointer within the loop
 		 */
-		if (_INST(buffered) == true) {
+		if (__INST(buffered) == true) {
 		    __READING__(f)
 		}
 
@@ -1562,7 +1562,7 @@
 		     * because we are interruptable, refetch pointer
 		     */
 		    cp = (char *)__InstPtr(anObject) + nInstBytes + offs;
-		    if (_INST(buffered) == false) {
+		    if (__INST(buffered) == false) {
 			ret = read(fileno(f), cp, cnt);
 		    } else {
 			if (feof(f)) {
@@ -1589,19 +1589,19 @@
 		cnt = __intVal(count) - cnt;
 
 		if (cnt > 0) {
-		    pos = _INST(position);
+		    pos = __INST(position);
 		    if (pos != nil) {
-			_INST(position) = __MKSMALLINT(__intVal(pos) + cnt);
+			__INST(position) = __MKSMALLINT(__intVal(pos) + cnt);
 		    }
 		    RETURN (__MKSMALLINT(cnt));
 		}
 		if (cnt == 0) { 
-		    _INST(hitEOF) = true;
+		    __INST(hitEOF) = true;
 		    RETURN (__MKSMALLINT(cnt));
 		}
 
-		_INST(position) = nil;
-		_INST(lastErrorNumber) = __MKSMALLINT(errno);
+		__INST(position) = nil;
+		__INST(lastErrorNumber) = __MKSMALLINT(errno);
 	    }
 	}
     }
@@ -1674,9 +1674,9 @@
 %{
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(writeonly))) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(writeonly))) {
         FILE *f;
         int ret;
         int value;
@@ -1686,7 +1686,7 @@
         f = __FILEVal(fp);
         for (;;) {
             errno = 0;
-            if (_INST(buffered) == false) {
+            if (__INST(buffered) == false) {
                 ret = read(fileno(f), buffer+offs, cnt);
             } else {
                 if (feof(f)) {
@@ -1711,8 +1711,8 @@
         }
 
         if (cnt == 0) {
-            if (_INST(position) != nil) {
-                _INST(position) = __MKSMALLINT(__intVal(_INST(position)) + 4);
+            if (__INST(position) != nil) {
+                __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 4);
             }
             if (msbFlag == true) {
                 value = (buffer[0] & 0xFF);
@@ -1728,14 +1728,14 @@
             if ((value >= _MIN_INT) && (value <= _MAX_INT)) {
                 RETURN ( __MKSMALLINT(value));
             }
-            RETURN ( _MKLARGEINT(value) );
+            RETURN ( __MKLARGEINT(value) );
         }
 
-        if ((_INST(buffered) == false && ret < 0) || (ferror(f) && (errno != 0))) {
-            _INST(position) = nil;
-            _INST(lastErrorNumber) = __MKSMALLINT(errno);
+        if ((__INST(buffered) == false && ret < 0) || (ferror(f) && (errno != 0))) {
+            __INST(position) = nil;
+            __INST(lastErrorNumber) = __MKSMALLINT(errno);
         } else {
-            _INST(hitEOF) = true;
+            __INST(hitEOF) = true;
             RETURN (nil);
         }
     }
@@ -1756,9 +1756,9 @@
 %{
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(writeonly))) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(writeonly))) {
         FILE *f;
         int ret;
         short value;
@@ -1768,7 +1768,7 @@
         f = __FILEVal(fp);
         for (;;) {
             errno = 0;
-            if (_INST(buffered) == false) {
+            if (__INST(buffered) == false) {
                 ret = read(fileno(f), buffer+offs, cnt);
             } else {
                 if (feof(f)) {
@@ -1793,8 +1793,8 @@
         }
 
         if (cnt == 0) {
-            if (_INST(position) != nil) {
-                _INST(position) = __MKSMALLINT(__intVal(_INST(position)) + 2);
+            if (__INST(position) != nil) {
+                __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 2);
             }
             if (msbFlag == true) {
                 value = ((buffer[0] & 0xFF) << 8) | (buffer[1] & 0xFF);
@@ -1804,11 +1804,11 @@
             RETURN (__MKSMALLINT(value));
         }
 
-        if ((_INST(buffered) == false && ret < 0) || (ferror(f) && (errno != 0))) {
-            _INST(position) = nil;
-            _INST(lastErrorNumber) = __MKSMALLINT(errno);
+        if ((__INST(buffered) == false && ret < 0) || (ferror(f) && (errno != 0))) {
+            __INST(position) = nil;
+            __INST(lastErrorNumber) = __MKSMALLINT(errno);
         } else {
-            _INST(hitEOF) = true;
+            __INST(hitEOF) = true;
             RETURN (nil);
         }
     }
@@ -1829,9 +1829,9 @@
 %{
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(writeonly))) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(writeonly))) {
         FILE *f;
         int ret;
         unsigned int value;
@@ -1841,7 +1841,7 @@
         f = __FILEVal(fp);
         for (;;) {
             errno = 0;
-            if (_INST(buffered) == false) {
+            if (__INST(buffered) == false) {
                 ret = read(fileno(f), buffer+offs, cnt);
             } else {
                 if (feof(f)) {
@@ -1866,8 +1866,8 @@
         }
 
         if (cnt == 0) {
-            if (_INST(position) != nil) {
-                _INST(position) = __MKSMALLINT(__intVal(_INST(position)) + 4);
+            if (__INST(position) != nil) {
+                __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 4);
             }
             if (msbFlag == true) {
                 value = (buffer[0] & 0xFF);
@@ -1883,14 +1883,14 @@
             if (value <= _MAX_INT) {
                 RETURN ( __MKSMALLINT(value));
             }
-            RETURN ( _MKULARGEINT(value) );
+            RETURN ( __MKULARGEINT(value) );
         }
 
-        if ((_INST(buffered) == false && ret < 0) || (ferror(f) && (errno != 0))) {
-            _INST(position) = nil;
-            _INST(lastErrorNumber) = __MKSMALLINT(errno);
+        if ((__INST(buffered) == false && ret < 0) || (ferror(f) && (errno != 0))) {
+            __INST(position) = nil;
+            __INST(lastErrorNumber) = __MKSMALLINT(errno);
         } else {
-            _INST(hitEOF) = true;
+            __INST(hitEOF) = true;
             RETURN (nil);
         }
     }
@@ -1910,9 +1910,9 @@
 %{
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(writeonly))) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(writeonly))) {
         FILE *f;
         int ret;
         unsigned int value;
@@ -1922,7 +1922,7 @@
         f = __FILEVal(fp);
         for (;;) {
             errno = 0;
-            if (_INST(buffered) == false) {
+            if (__INST(buffered) == false) {
                 ret = read(fileno(f), buffer+offs, cnt);
             } else {
                 if (feof(f)) {
@@ -1947,8 +1947,8 @@
         }
 
         if (cnt == 0) {
-            if (_INST(position) != nil) {
-                _INST(position) = __MKSMALLINT(__intVal(_INST(position)) + 2);
+            if (__INST(position) != nil) {
+                __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 2);
             }
             if (msbFlag == true) {
                 value = ((buffer[0] & 0xFF) << 8) | (buffer[1] & 0xFF);
@@ -1958,11 +1958,11 @@
             RETURN (__MKSMALLINT(value));
         }
 
-        if ((_INST(buffered) == false && ret < 0) || (ferror(f) && (errno != 0))) {
-            _INST(position) = nil;
-            _INST(lastErrorNumber) = __MKSMALLINT(errno);
+        if ((__INST(buffered) == false && ret < 0) || (ferror(f) && (errno != 0))) {
+            __INST(position) = nil;
+            __INST(lastErrorNumber) = __MKSMALLINT(errno);
         } else {
-            _INST(hitEOF) = true;
+            __INST(hitEOF) = true;
             RETURN (nil);
         }
     }
@@ -1998,16 +1998,16 @@
     OBJ pos, fp;
     int cnt;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(readonly))) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(readonly))) {
 	if (__isSmallInteger(aByteValue)) {
 	    c = __intVal(aByteValue);
 	    f = __FILEVal(fp);
 	    __BEGIN_INTERRUPTABLE__
 /*
  *#ifdef OLD
- *          if (_INST(buffered) == false) {
+ *          if (__INST(buffered) == false) {
  *              cnt = write(fileno(f), &c, 1);
  *          } else 
  *#endif
@@ -2015,13 +2015,13 @@
  *              __WRITING__(f)
  *              cnt = fwrite(&c, 1, 1, f);
  *#ifndef OLD
- *              if (_INST(buffered) == false) {
+ *              if (__INST(buffered) == false) {
  *                  fflush(f);
  *              }
  *#endif
  *          }
  */
-	    if (_INST(buffered) == true) {
+	    if (__INST(buffered) == true) {
 		__WRITING__(f)
 		cnt = fwrite(&c, 1, 1, f);
 	    } else {
@@ -2032,13 +2032,13 @@
 	    __END_INTERRUPTABLE__
 
 	    if (cnt == 1) {
-		pos = _INST(position);
+		pos = __INST(position);
 		if (pos != nil)
-		    _INST(position) = __MKSMALLINT(__intVal(pos) + 1);
+		    __INST(position) = __MKSMALLINT(__intVal(pos) + 1);
 		RETURN (self);
 	    }
 	    if (cnt < 0) {
-		_INST(lastErrorNumber) = __MKSMALLINT(errno);
+		__INST(lastErrorNumber) = __MKSMALLINT(errno);
 	    }
 	}
     }
@@ -2076,9 +2076,9 @@
     char *cp;
     OBJ oClass, pos, fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(readonly))) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(readonly))) {
 	if (__bothSmallInteger(count, start)) {
 	    oClass = __Class(anObject);
 	    switch (__intVal(__ClassInstPtr(oClass)->c_flags) & ARRAYMASK) {
@@ -2101,7 +2101,7 @@
 	    if ( (offs >= 0) && (cnt >= 0) && (objSize >= (cnt + offs)) ) {
 		cp = (char *)__InstPtr(anObject) + nInstBytes + offs;
 
-		if (_INST(buffered) == true) {
+		if (__INST(buffered) == true) {
 		    /* do not handle interrupts here.
 		     * fwrite is not ineterruot capable!
 		     */
@@ -2129,12 +2129,12 @@
 		}
 
 		if (cnt >= 0) {
-		    pos = _INST(position);
+		    pos = __INST(position);
 		    if (pos != nil)
-			_INST(position) = __MKSMALLINT(__intVal(pos) + cnt);
+			__INST(position) = __MKSMALLINT(__intVal(pos) + cnt);
 		    RETURN ( __MKSMALLINT(cnt) );
 		}
-		_INST(lastErrorNumber) = __MKSMALLINT(errno);
+		__INST(lastErrorNumber) = __MKSMALLINT(errno);
 	    }
 	}
     }
@@ -2172,9 +2172,9 @@
     int cnt;
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(readonly))
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(readonly))
      && __isSmallInteger(aNumber)) {
 	num = __intVal(aNumber);
 	if (msbFlag == true) {
@@ -2192,7 +2192,7 @@
 	f = __FILEVal(fp);
 	__BEGIN_INTERRUPTABLE__
 
-	if (_INST(buffered) == true) {
+	if (__INST(buffered) == true) {
 	    __WRITING__(f)
 	    cnt = fwrite(bytes, 1, 4, f);
 	} else {
@@ -2204,12 +2204,12 @@
 	__END_INTERRUPTABLE__
 
 	if (cnt == 4) {
-	    if (_INST(position) != nil) {
-		_INST(position) = __MKSMALLINT(__intVal(_INST(position)) + 4);
+	    if (__INST(position) != nil) {
+		__INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 4);
 	    }
 	    RETURN ( self );
 	}
-	_INST(lastErrorNumber) = __MKSMALLINT(errno);
+	__INST(lastErrorNumber) = __MKSMALLINT(errno);
     }
 %}.
     filePointer isNil ifTrue:[^ self errorNotOpen].
@@ -2242,9 +2242,9 @@
     int cnt;
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(readonly))
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(readonly))
      && __isSmallInteger(aNumber)) {
         num = __intVal(aNumber);
         if (msbFlag == true) {
@@ -2258,7 +2258,7 @@
         f = __FILEVal(fp);
         __BEGIN_INTERRUPTABLE__
 
-        if (_INST(buffered) == true) {
+        if (__INST(buffered) == true) {
             __WRITING__(f)
             cnt = fwrite(bytes, 1, 2, f);
         } else {
@@ -2275,12 +2275,12 @@
         __END_INTERRUPTABLE__
 
         if (cnt == 2) {
-            if (_INST(position) != nil) {
-                _INST(position) = __MKSMALLINT(__intVal(_INST(position)) + 2);
+            if (__INST(position) != nil) {
+                __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 2);
             }
             RETURN ( self );
         }
-        _INST(lastErrorNumber) = __MKSMALLINT(errno);
+        __INST(lastErrorNumber) = __MKSMALLINT(errno);
     }
 %}.
     lastErrorNumber notNil ifTrue:[^ self writeError].
@@ -2314,11 +2314,11 @@
      && (__qClass(openmode)== @global(String))) {
 	f = (FILE *) fdopen(__intVal(aFileDescriptor), (char *)__stringVal(openmode));
 	if (f == NULL) {
-	    _INST(lastErrorNumber) = _MKSMALLINT(errno);
-	    _INST(position) = nil;
+	    __INST(lastErrorNumber) = __MKSMALLINT(errno);
+	    __INST(position) = nil;
 	} else {
-	    _INST(filePointer) = fp = __MKOBJ((int)f); __STORE(self, fp);
-	    _INST(position) = _MKSMALLINT(1);
+	    __INST(filePointer) = fp = __MKOBJ((int)f); __STORE(self, fp);
+	    __INST(position) = __MKSMALLINT(1);
 	    retVal = self;
 	}
     }
@@ -2390,19 +2390,19 @@
     OBJ pos, fp;
     unsigned char ch;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(writeonly))) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(writeonly))) {
         f = __FILEVal(fp);
         __BEGIN_INTERRUPTABLE__
 
-        if (_INST(buffered) == true) {
+        if (__INST(buffered) == true) {
             __READING__(f)
         }
 
         do {
             errno = 0;
-            if (_INST(buffered) == false) {
+            if (__INST(buffered) == false) {
                 if ((nRead = read(fileno(f), &ch, 1)) < 1)
                     c = EOF;
                 else
@@ -2415,30 +2415,30 @@
         __END_INTERRUPTABLE__
 
         if (c != EOF) {
-            pos = _INST(position);
+            pos = __INST(position);
             if (__isSmallInteger(pos)) {
-                _INST(position) = __MKSMALLINT(__intVal(pos) + 1);
+                __INST(position) = __MKSMALLINT(__intVal(pos) + 1);
             } else {
-                _INST(position) = nil;
+                __INST(position) = nil;
             }
-            if (_INST(binary) == true) {
+            if (__INST(binary) == true) {
                 RETURN ( __MKSMALLINT(c & 0xFF) );
             }
-            RETURN ( _MKCHARACTER(c & 0xFF) );
+            RETURN ( __MKCHARACTER(c & 0xFF) );
         }
 /*
         if (errno == EWOULDBLOCK) {
-            _INST(hitEOF) = true;
+            __INST(hitEOF) = true;
             RETURN(nil);
         }
 */
-        _INST(position) = nil;
+        __INST(position) = nil;
         
-        if (((_INST(buffered) == false) && (nRead < 0))
+        if (((__INST(buffered) == false) && (nRead < 0))
             || (ferror(f) && (errno != 0))) {
-            _INST(lastErrorNumber) = __MKSMALLINT(errno);
+            __INST(lastErrorNumber) = __MKSMALLINT(errno);
         } else {
-            _INST(hitEOF) = true;
+            __INST(hitEOF) = true;
             RETURN ( nil );
         }
     }
@@ -2474,11 +2474,11 @@
     REGISTER int c;
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(writeonly))) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(writeonly))) {
 #ifdef OLD
-	if (_INST(buffered) == true) 
+	if (__INST(buffered) == true) 
 #endif
 	{
 	    f = __FILEVal(fp);
@@ -2493,15 +2493,15 @@
 
 	    if (c != EOF) {
 		ungetc(c, f);
-		if (_INST(binary) == true) {
+		if (__INST(binary) == true) {
 		    RETURN ( __MKSMALLINT(c & 0xFF) );
 		}
-		RETURN ( _MKCHARACTER(c & 0xFF) );
+		RETURN ( __MKCHARACTER(c & 0xFF) );
 	    }
 	    if (ferror(f) && (errno != 0)) {
-		_INST(lastErrorNumber) = __MKSMALLINT(errno);
+		__INST(lastErrorNumber) = __MKSMALLINT(errno);
 	    } else {
-		_INST(hitEOF) = true;
+		__INST(hitEOF) = true;
 		RETURN ( nil );
 	    }
 	}
@@ -2531,8 +2531,8 @@
     OBJ fp;
     OBJ __MKSTRING_L();
 
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(writeonly))) {
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(writeonly))) {
 	f = __FILEVal(fp);
 	__BEGIN_INTERRUPTABLE__
 	__READING__(f)
@@ -2547,11 +2547,11 @@
 
 	    if (ch < 0) {
 		if (ferror(f) && (errno != 0)) {
-		    _INST(lastErrorNumber) = __MKSMALLINT(errno);
+		    __INST(lastErrorNumber) = __MKSMALLINT(errno);
 		    __END_INTERRUPTABLE__
 		    goto err;
 		}
-		_INST(hitEOF) = true;
+		__INST(hitEOF) = true;
 		break;
 	    }
 	    cnt++;
@@ -2572,11 +2572,11 @@
 	    } while ((ch < 0) && (errno == EINTR));
 	    if (ch < 0) {
 		if (ferror(f) && (errno != 0)) {
-		    _INST(lastErrorNumber) = __MKSMALLINT(errno);
+		    __INST(lastErrorNumber) = __MKSMALLINT(errno);
 		    __END_INTERRUPTABLE__
 		    goto err;
 		}
-		_INST(hitEOF) = true;
+		__INST(hitEOF) = true;
 		break;
 	    }
 
@@ -2596,8 +2596,8 @@
 	}
 	__END_INTERRUPTABLE__
 
-	if (_INST(position) != nil) {
-	    _INST(position) = __MKSMALLINT(__intVal(_INST(position)) + cnt);
+	if (__INST(position) != nil) {
+	    __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + cnt);
 	}
 	if (len != 0) {
 	    buffer[len] = '\0';
@@ -2645,13 +2645,13 @@
     int atBeginOfLine = 1, inComment, inString, inPrimitive = 0;
     OBJ __MKSTRING_L(), __MKSTRING_ST_L(), __MKEMPTYSTRING();
 
-    _INST(lastErrorNumber) = nil;
-    f = __FILEVal(_INST(filePointer));
+    __INST(lastErrorNumber) = nil;
+    f = __FILEVal(__INST(filePointer));
 
     __READING__(f)
 
     if (feof(f)) {
-	_INST(hitEOF) = true;
+	__INST(hitEOF) = true;
 	RETURN (nil);
     }
 
@@ -2680,10 +2680,10 @@
 
 	    case EOF:
 		if (ferror(f) && (errno != 0)) {
-		    _INST(lastErrorNumber) = __MKSMALLINT(errno);
+		    __INST(lastErrorNumber) = __MKSMALLINT(errno);
 		    goto err;
 		}
-		_INST(hitEOF) = true;
+		__INST(hitEOF) = true;
 		RETURN (nil);
 
 	    default:
@@ -2771,9 +2771,9 @@
 	}
 
 	if (c < 0) {
-	    _INST(hitEOF) = true;
+	    __INST(hitEOF) = true;
 	    if (ferror(f) && (errno != 0)) {
-		_INST(lastErrorNumber) = __MKSMALLINT(errno);
+		__INST(lastErrorNumber) = __MKSMALLINT(errno);
 		goto err;
 	    }
 	    break;
@@ -2825,13 +2825,13 @@
     int peekValue, c;
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(writeonly))) {
-	if ((_INST(binary) == true) && __isSmallInteger(anObject)) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(writeonly))) {
+	if ((__INST(binary) == true) && __isSmallInteger(anObject)) {
 	    peekValue = __intVal(anObject) & 0xFF;
 	} else {
-	    if ((_INST(binary) != true) && __isCharacter(anObject)) {
+	    if ((__INST(binary) != true) && __isCharacter(anObject)) {
 		peekValue = __intVal(_characterVal(anObject)) & 0xFF;
 	    } else {
 		peekValue = -1;
@@ -2839,7 +2839,7 @@
 	}
 
 	if (peekValue >= 0) {
-	    _INST(position) = nil;
+	    __INST(position) = nil;
 	    f = __FILEVal(fp);
 	    __BEGIN_INTERRUPTABLE__
 	    __READING__(f)
@@ -2852,10 +2852,10 @@
 		if (c == EOF) {
 		    __END_INTERRUPTABLE__
 		    if (ferror(f) && (errno != 0)) {
-			_INST(lastErrorNumber) = __MKSMALLINT(errno);
+			__INST(lastErrorNumber) = __MKSMALLINT(errno);
 			break;
 		    }
-		    _INST(hitEOF) = true;
+		    __INST(hitEOF) = true;
 		    RETURN (nil);
 		}
 		if (c == peekValue) {
@@ -2884,10 +2884,10 @@
     int peekValue;
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(writeonly))) {
-	if (_INST(binary) == true) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(writeonly))) {
+	if (__INST(binary) == true) {
 	    if (__isSmallInteger(anObject)) {
 		peekValue = __intVal(anObject) & 0xFF;
 	    } else {
@@ -2904,7 +2904,7 @@
 	f = __FILEVal(fp);
 
 	if (feof(f)) {
-	    _INST(hitEOF) = true;
+	    __INST(hitEOF) = true;
 	    RETURN (false);
 	}
 
@@ -2921,14 +2921,14 @@
 	__END_INTERRUPTABLE__
 
 	if (feof(f)) {
-	    _INST(hitEOF) = true;
+	    __INST(hitEOF) = true;
 	}
 
 	if (c == peekValue) {
 	    OBJ pos;
 
-	    if ((pos = _INST(position)) != nil) {
-		_INST(position) = __MKSMALLINT(__intVal(pos) + 1);
+	    if ((pos = __INST(position)) != nil) {
+		__INST(position) = __MKSMALLINT(__intVal(pos) + 1);
 	    }
 	    RETURN (true);
 	}
@@ -2938,9 +2938,9 @@
 	    RETURN (false);
 	}
 
-	_INST(hitEOF) = true;
+	__INST(hitEOF) = true;
 	if (ferror(f) && (errno != 0)) {
-	    _INST(lastErrorNumber) = __MKSMALLINT(errno);
+	    __INST(lastErrorNumber) = __MKSMALLINT(errno);
 	} else {
 	    RETURN (false);
 	}
@@ -2964,10 +2964,10 @@
     char buffer[1024];
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(writeonly))) {
-	if (_INST(binary) != true) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(writeonly))) {
+	if (__INST(binary) != true) {
 	    f = __FILEVal(fp);
             
 	    __READING__(f)
@@ -2980,9 +2980,9 @@
 	    __END_INTERRUPTABLE__
 
 	    if (ferror(f) && (errno != 0)) {
-		_INST(lastErrorNumber) = __MKSMALLINT(errno);
+		__INST(lastErrorNumber) = __MKSMALLINT(errno);
 	    } else {
-		_INST(hitEOF) = true;
+		__INST(hitEOF) = true;
 		RETURN ( nil );
 	    }
 	}
@@ -3004,14 +3004,14 @@
     REGISTER int c;
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(writeonly))) {
-	if (_INST(binary) != true) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(writeonly))) {
+	if (__INST(binary) != true) {
 	    f = __FILEVal(fp);
             
 	    if (feof(f)) {
-		_INST(hitEOF) = true;
+		__INST(hitEOF) = true;
 		RETURN ( nil );
 	    }
 
@@ -3022,7 +3022,7 @@
 		do {
 		    if (feof(f)) {
 			__END_INTERRUPTABLE__
-			_INST(hitEOF) = true;
+			__INST(hitEOF) = true;
 			RETURN ( nil );
 		    }
 		    c = getc(f);
@@ -3040,15 +3040,15 @@
 		    default:
 			__END_INTERRUPTABLE__
 			if (c < 0) {
-			    _INST(hitEOF) = true;
+			    __INST(hitEOF) = true;
 			    if (ferror(f) && (errno != 0)) {
-				_INST(lastErrorNumber) = __MKSMALLINT(errno);
+				__INST(lastErrorNumber) = __MKSMALLINT(errno);
 				goto err;
 			    }
 			    RETURN ( nil );
 			}
 			ungetc(c, f);
-			RETURN ( _MKCHARACTER(c & 0xFF) );
+			RETURN ( __MKCHARACTER(c & 0xFF) );
 		}
 	    }
 	}
@@ -3072,10 +3072,10 @@
     int c;
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(writeonly))) {
-	if (_INST(binary) != true) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(writeonly))) {
+	if (__INST(binary) != true) {
 	    f = __FILEVal(fp);
 	    __READING__(f)
 
@@ -3084,7 +3084,7 @@
                 
 		if (feof(f)) {
 		    __END_INTERRUPTABLE__
-		    _INST(hitEOF) = true;
+		    __INST(hitEOF) = true;
 		    RETURN ( nil );
 		}
 
@@ -3102,14 +3102,14 @@
 			__END_INTERRUPTABLE__
 			if (c < 0) {
 			    if (ferror(f) && (errno != 0)) {
-				_INST(lastErrorNumber) = __MKSMALLINT(errno);
+				__INST(lastErrorNumber) = __MKSMALLINT(errno);
 				goto err;
 			    }
-			    _INST(hitEOF) = true;
+			    __INST(hitEOF) = true;
 			    RETURN ( nil );
 			}
 			ungetc(c, f);
-			RETURN ( _MKCHARACTER(c & 0xFF) );
+			RETURN ( __MKCHARACTER(c & 0xFF) );
 		}
 	    }
 	}
@@ -3134,10 +3134,10 @@
     REGISTER int c, cSearch;
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(writeonly))) {
-	if (_INST(binary) == true) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(writeonly))) {
+	if (__INST(binary) == true) {
 	    /* searched for object must be a smallInteger */
 	    if (! __isSmallInteger(aCharacter)) goto badArgument;
 	    cSearch = __intVal(aCharacter);
@@ -3171,10 +3171,10 @@
 	    if (c < 0) {
 		__END_INTERRUPTABLE__
 		if (ferror(f) && (errno != 0)) {
-		    _INST(lastErrorNumber) = __MKSMALLINT(errno);
+		    __INST(lastErrorNumber) = __MKSMALLINT(errno);
 		    break;
 		} else {
-		    _INST(hitEOF) = true;
+		    __INST(hitEOF) = true;
 		    RETURN (nil);
 		}
 	    }
@@ -3277,16 +3277,16 @@
     OBJ fp;
     int c;
 
-    if (_INST(hitEOF) == true) {
+    if (__INST(hitEOF) == true) {
 	RETURN (true);
     }
-    if (_INST(buffered) == false) {
+    if (__INST(buffered) == false) {
 	RETURN (false);
     }
 
-    _INST(lastErrorNumber) = nil;
-
-    if ((fp = _INST(filePointer)) != nil) {
+    __INST(lastErrorNumber) = nil;
+
+    if ((fp = __INST(filePointer)) != nil) {
 	f = __FILEVal(fp);
 #ifdef OLD
 	RETURN ( feof(f) ? true : false );
@@ -3304,9 +3304,9 @@
 	    RETURN (false);
 	}
 	if (ferror(f) && (errno != 0)) {
-	    _INST(lastErrorNumber) = __MKSMALLINT(errno);
+	    __INST(lastErrorNumber) = __MKSMALLINT(errno);
 	} else {
-	    _INST(hitEOF) = true;
+	    __INST(hitEOF) = true;
 	    RETURN (true);
 	}
 #endif
@@ -3490,20 +3490,20 @@
     OBJ fp;
     char *cp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(readonly))) {
-	if (_INST(binary) != true) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(readonly))) {
+	if (__INST(binary) != true) {
 	    f = __FILEVal(fp);
 
-	    if (_INST(useCRLF) == true) {
+	    if (__INST(useCRLF) == true) {
 		cp = "\r\n"; len = 2;
 	    } else {
 		cp = "\n"; len = 1;
 	    }
 	    __BEGIN_INTERRUPTABLE__
 
-	    if (_INST(buffered) == true) {
+	    if (__INST(buffered) == true) {
 		__WRITING__(f)
 		cnt = fwrite(cp, 1, len, f);
 	    } else {
@@ -3515,12 +3515,12 @@
 	    __END_INTERRUPTABLE__
 
 	    if (cnt == len) {
-		if (_INST(position) != nil) {
-		    _INST(position) = __MKSMALLINT(__intVal(_INST(position)) + len);
+		if (__INST(position) != nil) {
+		    __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + len);
 		}
 		RETURN ( self );
 	    }
-	    _INST(lastErrorNumber) = __MKSMALLINT(errno);
+	    __INST(lastErrorNumber) = __MKSMALLINT(errno);
 	}
     }
 %}.
@@ -3540,10 +3540,10 @@
     int cnt;
     OBJ pos, fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil) 
-     && (_INST(mode) != @symbol(readonly))) {
-	if (_INST(binary) != true) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil) 
+     && (__INST(mode) != @symbol(readonly))) {
+	if (__INST(binary) != true) {
 	    if (__isCharacter(aCharacter)) {
 		c = __intVal(__characterVal(aCharacter)) & 0xFF;
     doWrite:
@@ -3551,7 +3551,7 @@
 
 		__BEGIN_INTERRUPTABLE__
 
-		if (_INST(buffered) == true) {
+		if (__INST(buffered) == true) {
 		    __WRITING__(f)
 
 		    do {
@@ -3566,13 +3566,13 @@
 		__END_INTERRUPTABLE__
 
 		if (cnt == 1) {
-		    pos = _INST(position);
+		    pos = __INST(position);
 		    if (pos != nil) {
-			_INST(position) = __MKSMALLINT(__intVal(pos) + 1);
+			__INST(position) = __MKSMALLINT(__intVal(pos) + 1);
 		    }
 		    RETURN ( self );
 		}
-		_INST(lastErrorNumber) = __MKSMALLINT(errno);
+		__INST(lastErrorNumber) = __MKSMALLINT(errno);
 	    }
 	} else {
 	    if (__isSmallInteger(aCharacter)) {
@@ -3601,17 +3601,17 @@
     OBJ pos, fp;
     int offs;
 
-    _INST(lastErrorNumber) = nil;
-
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(readonly))) {
+    __INST(lastErrorNumber) = nil;
+
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(readonly))) {
         cp = NULL;
         offs = 0;
         if (__isString(aCollection) || __isSymbol(aCollection)) {
-            cp = _stringVal(aCollection);
-            len = _stringSize(aCollection);
+            cp = __stringVal(aCollection);
+            len = __stringSize(aCollection);
         } else {
-            if (_INST(binary) == true) {
+            if (__INST(binary) == true) {
                 if (__isByteArray(aCollection)) {
                     cp = __ByteArrayInstPtr(aCollection)->ba_element;
                     len = _byteArraySize(aCollection);
@@ -3633,7 +3633,7 @@
             f = __FILEVal(fp);
 
 
-            if (_INST(buffered) == false) {
+            if (__INST(buffered) == false) {
                 int cc, rest;
 
                 cnt = 0;
@@ -3667,13 +3667,13 @@
 
 
             if (cnt == len) {
-                pos = _INST(position);
+                pos = __INST(position);
                 if (pos != nil) {
-                    _INST(position) = __MKSMALLINT(__intVal(pos) + len);
+                    __INST(position) = __MKSMALLINT(__intVal(pos) + len);
                 }
                 RETURN ( self );
             }
-            _INST(lastErrorNumber) = __MKSMALLINT(errno);
+            __INST(lastErrorNumber) = __MKSMALLINT(errno);
         }
     }
 %}.
@@ -3695,16 +3695,16 @@
     int offs, len, cnt, index1, index2;
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if (((fp = _INST(filePointer)) != nil)
-     && (_INST(mode) != @symbol(readonly))) {
+    __INST(lastErrorNumber) = nil;
+    if (((fp = __INST(filePointer)) != nil)
+     && (__INST(mode) != @symbol(readonly))) {
 	if (__bothSmallInteger(start, stop)) {
 	    cp = NULL;
 	    offs = 0;
-	    if (_INST(binary) != true) {
+	    if (__INST(binary) != true) {
 		if (__isString(aCollection) || __isSymbol(aCollection)) {
-		    cp = _stringVal(aCollection);
-		    len = _stringSize(aCollection);
+		    cp = __stringVal(aCollection);
+		    len = __stringSize(aCollection);
 		}
 	    } else {
 		if (__isByteArray(aCollection)) {
@@ -3739,7 +3739,7 @@
 
 		__BEGIN_INTERRUPTABLE__
 
-		if (_INST(buffered) == true) {
+		if (__INST(buffered) == true) {
 		    __WRITING__(f)
 		    cnt = fwrite(cp+index1-1, 1, len, f);
 		} else {
@@ -3752,12 +3752,12 @@
 		__END_INTERRUPTABLE__
 
 		if (cnt == len) {
-		    if (_INST(position) != nil) {
-			_INST(position) = __MKSMALLINT(__intVal(_INST(position)) + len);
+		    if (__INST(position) != nil) {
+			__INST(position) = __MKSMALLINT(__intVal(__INST(position)) + len);
 		    }
 		    RETURN ( self );
 		}
-		_INST(lastErrorNumber) = __MKSMALLINT(errno);
+		__INST(lastErrorNumber) = __MKSMALLINT(errno);
 	    }
 	}
     }
@@ -3772,10 +3772,10 @@
 %{
     OBJ fp;
 
-    _INST(lastErrorNumber) = nil;
-    if ((fp = _INST(filePointer)) != nil) {
-	if (_INST(mode) != @symbol(readonly)) {
-	    if (_INST(buffered) == true) {
+    __INST(lastErrorNumber) = nil;
+    if ((fp = __INST(filePointer)) != nil) {
+	if (__INST(mode) != @symbol(readonly)) {
+	    if (__INST(buffered) == true) {
 		__BEGIN_INTERRUPTABLE__
 		fflush( __FILEVal(fp) );
 		__END_INTERRUPTABLE__
@@ -3788,6 +3788,6 @@
 !ExternalStream class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Attic/ExtStream.st,v 1.94 1996-03-23 17:20:42 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Attic/ExtStream.st,v 1.95 1996-04-02 22:01:14 cg Exp $'
 ! !
 ExternalStream initialize!