hg/stx-libbasic: comparison ExtStream.st

equal deleted inserted replaced

-:6bf3080856be
+:8e03bd717355
 other person.  No title to or ownership of the software is
 hereby transferred.
 "
 ReadWriteStream subclass:#ExternalStream
-instanceVariableNames:'filePointer mode buffered binary'
+instanceVariableNames:'filePointer mode buffered binary useCRLF'
 classVariableNames:'lobby'
 poolDictionaries:''
 category:'Streams-External'
 !
 ExternalStream is abstract; concrete classes are FileStream, PipeStream etc.
 ExternalStreams can be in two modes: text (the default) and binary.
 In text-mode, the elements read/written are characters; while in binary-mode the basic
 elements are bytes which read/write as SmallIntegers in the range 0..255.
-$Header: /cvs/stx/stx/libbasic/Attic/ExtStream.st,v 1.5 1993-11-08 02:30:14 claus Exp $
+$Header: /cvs/stx/stx/libbasic/Attic/ExtStream.st,v 1.6 1993-12-11 00:46:55 claus Exp $
 written 88 by claus
 '!
 %{
 new
 |newStream|
 newStream := self basicNew.
-newStream text.
+newStream text; buffered:true; useCRLF:false.
 ^ newStream
 ! !
 !ExternalStream methodsFor:'instance release'!
 closeFile
 "low level close - may be redefined in subclasses"
 %{  /* NOCONTEXT */
-fclose(MKFD(_INST(filePointer)));
+if (_INST(filePointer) != nil) {
+int savInt;
+extern int _immediateInterrupt;
+savInt = _immediateInterrupt;
+_immediateInterrupt = 1;
+fclose(MKFD(_INST(filePointer)));
+_immediateInterrupt = savInt;
+}
 %}
 ! !
 !ExternalStream methodsFor:'private'!
 buffered:aBoolean
 "turn buffering on or off - default is on"
 buffered := aBoolean
+!
+useCRLF:aBoolean
+"turn on or off CRLF sending (instead of LF only) - default is off"
+useCRLF := aBoolean
 !
 binary
 "switch to binary mode - default is text"
 if (_isSmallInteger(ioctlNumber)) {
 ioNum = _intVal(ioctlNumber);
 f = MKFD(_INST(filePointer));
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
-	    do {
+do {
 ret = ioctl(fileno(f), ioNum);
-	    } while ((ret < 0) && (errno == EINTR));
+} while ((ret < 0) && (errno == EINTR));
 _immediateInterrupt = savInt;
 if (ret >= 0) {
 RETURN ( _MKSMALLINT(ret) );
 }
 ErrorNumber = _MKSMALLINT(errno);
 && (_isSmallInteger(arg) || (isStructure == true))) {
 f = MKFD(_INST(filePointer));
 ioNum = _intVal(ioctlNumber);
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
-	    do {
+do {
 if (isStructure == true) {
 ret = ioctl(fileno(f), ioNum, _ByteArrayInstPtr(arg)->ba_element);
 } else {
 ret = ioctl(fileno(f), ioNum, _intVal(arg));
 }
-	    } while ((ret < 0) && (errno == EINTR));
+} while ((ret < 0) && (errno == EINTR));
 _immediateInterrupt = savInt;
 if (ret >= 0) {
 RETURN ( _MKSMALLINT(ret) );
 }
 ErrorNumber = _MKSMALLINT(errno);
 int cnt, savInt;
 extern OBJ ErrorNumber;
 extern errno;
 extern int _immediateInterrupt;
-if (_INST(filePointer) != nil) {
+if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
-if (_INST(mode) != _writeonly) {
+f = MKFD(_INST(filePointer));
-f = MKFD(_INST(filePointer));
+savInt = _immediateInterrupt;
-savInt = _immediateInterrupt;
+_immediateInterrupt = 1;
-_immediateInterrupt = 1;
+do {
-	    do {
+if (_INST(buffered) == false) {
-if (_INST(buffered) == false) {
+cnt = read(fileno(f), &byte, 1);
-cnt = read(fileno(f), &byte, 1);
+} else {
-} else {
+if (_INST(mode) == _readwrite)
-if (_INST(mode) == _readwrite)
+fseek(f, 0L, 1); /* needed in stdio */
-fseek(f, 0L, 1); /* needed in stdio */
+cnt = fread(&byte, 1, 1, f);
-cnt = fread(&byte, 1, 1, f);
+}
-}
+} while ((cnt < 0) && (errno == EINTR));
-	    } while ((cnt < 0) && (errno == EINTR));
+_immediateInterrupt = savInt;
-_immediateInterrupt = savInt;
+if (cnt == 1) {
-if (cnt == 1) {
+if (_INST(position) != nil)
-if (_INST(position) != nil)
+_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 1);
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 1);
+RETURN ( _MKSMALLINT(byte) );
-RETURN ( _MKSMALLINT(byte) );
+}
-}
+if (cnt < 0) {
-if (cnt < 0) {
+ErrorNumber = _MKSMALLINT(errno);
-ErrorNumber = _MKSMALLINT(errno);
+}
-}
+RETURN ( nil );
-RETURN ( nil );
-}
 }
 %}
 .
 filePointer isNil ifTrue:[^ self errorNotOpen].
 self errorWriteOnly
 extern OBJ ErrorNumber;
 extern errno;
 OBJ pos;
 extern int _immediateInterrupt;
-if (_INST(filePointer) != nil) {
+if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
-if (_INST(mode) != _writeonly) {
+if (_isSmallInteger(count) && _isSmallInteger(start)) {
-if (_isSmallInteger(count) && _isSmallInteger(start)) {
+cnt = _intVal(count);
-cnt = _intVal(count);
+offs = _intVal(start) - 1;
-offs = _intVal(start) - 1;
+f = MKFD(_INST(filePointer));
-f = MKFD(_INST(filePointer));
+objSize = _Size(anObject) - OHDR_SIZE;
-objSize = _Size(anObject) - OHDR_SIZE;
+if ((offs >= 0) && (cnt >= 0) && (objSize >= (cnt + offs))) {
-if ((offs >= 0) && (cnt >= 0) && (objSize >= (cnt + offs))) {
+cp = (char *)_InstPtr(anObject) + OHDR_SIZE + offs;
-cp = (char *)_InstPtr(anObject) + OHDR_SIZE + offs;
+savInt = _immediateInterrupt;
-savInt = _immediateInterrupt;
+_immediateInterrupt = 1;
-_immediateInterrupt = 1;
+do {
-		    do {
+if (_INST(buffered) == false) {
-if (_INST(buffered) == false) {
+cnt = read(fileno(f), cp, cnt);
-cnt = read(fileno(f), cp, cnt);
+} else {
-} else {
+if (_INST(mode) == _readwrite)
-if (_INST(mode) == _readwrite)
+fseek(f, 0L, 1); /* needed in stdio */
-fseek(f, 0L, 1); /* needed in stdio */
+cnt = fread(cp, 1, cnt, f);
-cnt = fread(cp, 1, cnt, f);
+}
-}
+} while ((cnt < 0) && (errno == EINTR));
-		    } while ((cnt < 0) && (errno == EINTR));
+_immediateInterrupt = savInt;
-_immediateInterrupt = savInt;
+if (cnt >= 0) {
-if (cnt >= 0) {
+pos = _INST(position);
-pos = _INST(position);
+if (pos != nil)
-if (pos != nil)
+_INST(position) = _MKSMALLINT(_intVal(pos) + cnt);
-_INST(position) = _MKSMALLINT(_intVal(pos) + cnt);
+RETURN ( _MKSMALLINT(cnt) );
-RETURN ( _MKSMALLINT(cnt) );
+}
-}
+ErrorNumber = _MKSMALLINT(errno);
-ErrorNumber = _MKSMALLINT(errno);
+RETURN ( nil );
-RETURN ( nil );
-}
 }
 }
 }
 %}
 .
 %{  /* NOCONTEXT */
 extern int _immediateInterrupt;
 int savInt;
 if (_INST(binary) == true) {
-if (_INST(filePointer) != nil) {
+if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
-if (_INST(mode) != _writeonly) {
+FILE *f;
-FILE *f;
+unsigned char hi, low;
-unsigned char hi, low;
+int cnt;
-		int cnt;
+savInt = _immediateInterrupt;
-savInt = _immediateInterrupt;
+_immediateInterrupt = 1;
-_immediateInterrupt = 1;
+f = MKFD(_INST(filePointer));
-f = MKFD(_INST(filePointer));
+do {
-		do {
+if (_INST(buffered) == false) {
-if (_INST(buffered) == false) {
+cnt = read(fileno(f), &hi, 1);
-cnt = read(fileno(f), &hi, 1);
+} else {
-} else {
+if (_INST(mode) == _readwrite)
-if (_INST(mode) == _readwrite)
+fseek(f, 0L, 1); /* needed in stdio */
-fseek(f, 0L, 1); /* needed in stdio */
+cnt = fread(&hi, 1, 1, f);
-cnt = fread(&hi, 1, 1, f);
+}
-}
+} while ((cnt < 0) && (errno == EINTR));
-		} while ((cnt < 0) && (errno == EINTR));
+if (cnt < 0) {
-		if (cnt < 0) {
-_immediateInterrupt = savInt;
-RETURN ( nil );
-}
-do {
-if (_INST(buffered) == false) {
-cnt = read(fileno(f), &low, 1);
-} else {
-if (_INST(mode) == _readwrite)
-fseek(f, 0L, 1); /* needed in stdio */
-cnt = fread(&low, 1, 1, f);
-}
-} while ((cnt < 0) && (errno == EINTR));
 _immediateInterrupt = savInt;
-if (cnt < 0) {
+RETURN ( nil );
-if (_INST(position) != nil) {
+}
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 1);
+do {
-}
+if (_INST(buffered) == false) {
-RETURN ( _MKSMALLINT(hi & 0xFF) );
+cnt = read(fileno(f), &low, 1);
-}
+} else {
+if (_INST(mode) == _readwrite)
+fseek(f, 0L, 1); /* needed in stdio */
+cnt = fread(&low, 1, 1, f);
+}
+} while ((cnt < 0) && (errno == EINTR));
+_immediateInterrupt = savInt;
+if (cnt < 0) {
 if (_INST(position) != nil) {
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 2);
+_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 1);
 }
-RETURN ( _MKSMALLINT(((hi & 0xFF)<<8) | (low & 0xFF)) );
+RETURN ( _MKSMALLINT(hi & 0xFF) );
 }
-}
+if (_INST(position) != nil) {
-}
+_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 2);
-%}
+}
-.
+RETURN ( _MKSMALLINT(((hi & 0xFF)<<8) | (low & 0xFF)) );
-%{
+}
+}
+%}
+.
+%{  /* STACK: 2000 */
 FILE *f;
 int len;
 char buffer[1024];
 int ch, savInt;
 int cnt = 0;
 extern int _immediateInterrupt;
-if (_INST(filePointer) != nil) {
+if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
-if (_INST(mode) != _writeonly) {
+f = MKFD(_INST(filePointer));
-f = MKFD(_INST(filePointer));
+savInt = _immediateInterrupt;
-savInt = _immediateInterrupt;
+_immediateInterrupt = 1;
-_immediateInterrupt = 1;
+/* text-mode */
-/* text-mode */
+for (;;) {
-for (;;) {
+ch = getc(f);
-ch = getc(f);
+cnt++;
-cnt++;
+if (ch >= ' ') break;
-if (ch >= ' ') break;
+if ((ch != ' ') && (ch != '\t') && (ch != '\r')
-if ((ch != ' ') && (ch != '\t') && (ch != '\r')
+&& (ch != '\n') && (ch != 0x0b)) break;
-&& (ch != '\n') && (ch != 0x0b)) break;
+}
-}
+ungetc(ch, f);
-ungetc(ch, f);
+cnt--;
-cnt--;
+len = 0;
-len = 0;
+for (;;) {
-for (;;) {
+ch = getc(f);
-ch = getc(f);
+if (ch == EOF)
-if (ch == EOF)
+break;
-break;
+ch &= 0xFF;
-ch &= 0xFF;
+if (! (((ch >= 'a') && (ch <= 'z')) ||
-if (! (((ch >= 'a') && (ch <= 'z')) ||
+((ch >= 'A') && (ch <= 'Z')) ||
-((ch >= 'A') && (ch <= 'Z')) ||
+((ch >= '0') && (ch <= '9')))) {
-((ch >= '0') && (ch <= '9')))) {
+ungetc(ch, f);
-ungetc(ch, f);
+break;
-break;
+}
-}
+cnt++;
-cnt++;
+buffer[len++] = ch;
-buffer[len++] = ch;
+if (len >= sizeof(buffer)-1) {
-if (len >= sizeof(buffer)-1) {
+/* emergency */
-/* emergency */
+break;
-break;
+}
 }
-}
+_immediateInterrupt = savInt;
-_immediateInterrupt = savInt;
+if (_INST(position) != nil) {
-if (_INST(position) != nil) {
+_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + cnt);
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + cnt);
+}
-}
+buffer[len] = '\0';
-buffer[len] = '\0';
+if (len != 0) {
-if (len != 0) {
+RETURN ( _MKSTRING(buffer COMMA_CON) );
-RETURN ( _MKSTRING(buffer COMMA_CON) );
+}
-}
+RETURN ( nil );
-RETURN ( nil );
-}
 }
 %}
 .
 filePointer isNil ifTrue:[^ self errorNotOpen].
 self errorWriteOnly
 %{  /* NOCONTEXT */
 int savInt;
 extern int _immediateInterrupt;
 if (_INST(binary) == true) {
-if (_INST(filePointer) != nil) {
+if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
-if (_INST(mode) != _writeonly) {
+FILE *f;
-FILE *f;
+int first, second;
-int first, second;
+short value;
-short value;
+savInt = _immediateInterrupt;
-savInt = _immediateInterrupt;
+_immediateInterrupt = 1;
-_immediateInterrupt = 1;
+f = MKFD(_INST(filePointer));
-f = MKFD(_INST(filePointer));
+first = getc(f);
-first = getc(f);
+if (first == EOF) {
-if (first == EOF) {
-_immediateInterrupt = savInt;
-RETURN ( nil );
-}
-second = getc(f);
 _immediateInterrupt = savInt;
+RETURN ( nil );
-if (second == EOF) {
+}
-RETURN ( nil );
+second = getc(f);
-}
+_immediateInterrupt = savInt;
-if (_INST(position) != nil) {
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 2);
+if (second == EOF) {
-}
+RETURN ( nil );
-if (msbFlag == true) {
+}
-RETURN ( _MKSMALLINT(((first & 0xFF)<<8) | (second & 0xFF)) );
+if (_INST(position) != nil) {
-}
+_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 2);
-RETURN ( _MKSMALLINT(((second & 0xFF)<<8) | (first & 0xFF)) );
+}
-}
+if (msbFlag == true) {
+RETURN ( _MKSMALLINT(((first & 0xFF)<<8) | (second & 0xFF)) );
+}
+RETURN ( _MKSMALLINT(((second & 0xFF)<<8) | (first & 0xFF)) );
 }
 }
 %}
 .
 filePointer isNil ifTrue:[^ self errorNotOpen].
 %{  /* NOCONTEXT */
 int savInt;
 extern int _immediateInterrupt;
 if (_INST(binary) == true) {
-if (_INST(filePointer) != nil) {
+if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
-if (_INST(mode) != _writeonly) {
+FILE *f;
-FILE *f;
+int first, second;
-int first, second;
+savInt = _immediateInterrupt;
-savInt = _immediateInterrupt;
+_immediateInterrupt = 1;
-_immediateInterrupt = 1;
+f = MKFD(_INST(filePointer));
-f = MKFD(_INST(filePointer));
+first = getc(f);
-first = getc(f);
+if (first == EOF) {
-if (first == EOF) {
-_immediateInterrupt = savInt;
-RETURN ( nil );
-}
-second = getc(f);
 _immediateInterrupt = savInt;
+RETURN ( nil );
-if (second == EOF) {
+}
-RETURN ( nil );
+second = getc(f);
-}
+_immediateInterrupt = savInt;
-if (_INST(position) != nil) {
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 2);
+if (second == EOF) {
-}
+RETURN ( nil );
-if (msbFlag == true) {
+}
-RETURN ( _MKSMALLINT(((first & 0xFF)<<8) | (second & 0xFF)) );
+if (_INST(position) != nil) {
-}
+_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 2);
-RETURN ( _MKSMALLINT(((second & 0xFF)<<8) | (first & 0xFF)) );
+}
-}
+if (msbFlag == true) {
+RETURN ( _MKSMALLINT(((first & 0xFF)<<8) | (second & 0xFF)) );
+}
+RETURN ( _MKSMALLINT(((second & 0xFF)<<8) | (first & 0xFF)) );
 }
 }
 %}
 .
 filePointer isNil ifTrue:[^ self errorNotOpen].
 %{  /* NOCONTEXT */
 int savInt;
 extern int _immediateInterrupt;
 if (_INST(binary) == true) {
-if (_INST(filePointer) != nil) {
+if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
-if (_INST(mode) != _writeonly) {
+FILE *f;
-FILE *f;
+int first, second, third, fourth;
-int first, second, third, fourth;
+int value;
-int value;
+savInt = _immediateInterrupt;
-savInt = _immediateInterrupt;
+_immediateInterrupt = 1;
-_immediateInterrupt = 1;
+f = MKFD(_INST(filePointer));
-f = MKFD(_INST(filePointer));
+first = getc(f);
-first = getc(f);
+if (first == EOF) {
-if (first == EOF) {
-_immediateInterrupt = savInt;
-RETURN ( nil );
-}
-second = getc(f);
-if (second == EOF) {
-_immediateInterrupt = savInt;
-RETURN ( nil );
-}
-third = getc(f);
-if (third == EOF) {
-_immediateInterrupt = savInt;
-RETURN ( nil );
-}
-fourth = getc(f);
 _immediateInterrupt = savInt;
-if (fourth == EOF) {
+RETURN ( nil );
-RETURN ( nil );
+}
-}
+second = getc(f);
-if (_INST(position) != nil) {
+if (second == EOF) {
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 4);
+_immediateInterrupt = savInt;
-}
+RETURN ( nil );
-if (msbFlag == true) {
+}
-value = ((first & 0xFF) << 24)
+third = getc(f);
-| ((second & 0xFF) << 16)
+if (third == EOF) {
-| ((third & 0xFF) << 8)
+_immediateInterrupt = savInt;
-| (fourth & 0xFF);
+RETURN ( nil );
-} else {
+}
-value = ((fourth & 0xFF) << 24)
+fourth = getc(f);
-| ((third & 0xFF) << 16)
+_immediateInterrupt = savInt;
-| ((second & 0xFF) << 8)
+if (fourth == EOF) {
-| (first & 0xFF);
+RETURN ( nil );
 }
-if ((value >= _MIN_INT) && (value <= _MAX_INT)) {
+if (_INST(position) != nil) {
-RETURN ( _MKSMALLINT(value));
+_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 4);
 }
-RETURN ( _makeLarge(value) );
+if (msbFlag == true) {
-}
+value = ((first & 0xFF) << 24)
+| ((second & 0xFF) << 16)
+| ((third & 0xFF) << 8)
+| (fourth & 0xFF);
+} else {
+value = ((fourth & 0xFF) << 24)
+| ((third & 0xFF) << 16)
+| ((second & 0xFF) << 8)
+| (first & 0xFF);
+}
+if ((value >= _MIN_INT) && (value <= _MAX_INT)) {
+RETURN ( _MKSMALLINT(value));
+}
+RETURN ( _makeLarge(value) );
 }
 }
 %}
 .
 filePointer isNil ifTrue:[^ self errorNotOpen].
 int savInt;
 extern int _immediateInterrupt;
 extern OBJ _makeULarge();
 if (_INST(binary) == true) {
-if (_INST(filePointer) != nil) {
+if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
-if (_INST(mode) != _writeonly) {
+FILE *f;
-FILE *f;
+int first, second, third, fourth;
-int first, second, third, fourth;
+unsigned int value;
-unsigned int value;
+savInt = _immediateInterrupt;
-savInt = _immediateInterrupt;
+_immediateInterrupt = 1;
-_immediateInterrupt = 1;
+f = MKFD(_INST(filePointer));
-f = MKFD(_INST(filePointer));
+first = getc(f);
-first = getc(f);
+if (first == EOF) {
-if (first == EOF) {
-_immediateInterrupt = savInt;
-RETURN ( nil );
-}
-second = getc(f);
-if (second == EOF) {
-_immediateInterrupt = savInt;
-RETURN ( nil );
-}
-third = getc(f);
-if (third == EOF) {
-_immediateInterrupt = savInt;
-RETURN ( nil );
-}
-fourth = getc(f);
 _immediateInterrupt = savInt;
-if (fourth == EOF) {
+RETURN ( nil );
-RETURN ( nil );
+}
-}
+second = getc(f);
-if (_INST(position) != nil) {
+if (second == EOF) {
-_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 4);
+_immediateInterrupt = savInt;
-}
+RETURN ( nil );
-if (msbFlag == true) {
+}
-value = ((first & 0xFF) << 24)
+third = getc(f);
-| ((second & 0xFF) << 16)
+if (third == EOF) {
-| ((third & 0xFF) << 8)
+_immediateInterrupt = savInt;
-| (fourth & 0xFF);
+RETURN ( nil );
-} else {
+}
-value = ((fourth & 0xFF) << 24)
+fourth = getc(f);
-| ((third & 0xFF) << 16)
+_immediateInterrupt = savInt;
-| ((second & 0xFF) << 8)
+if (fourth == EOF) {
-| (first & 0xFF);
+RETURN ( nil );
 }
-if (value <= _MAX_INT) {
+if (_INST(position) != nil) {
-RETURN ( _MKSMALLINT(value));
+_INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 4);
 }
-RETURN ( _makeULarge(value) );
+if (msbFlag == true) {
-}
+value = ((first & 0xFF) << 24)
+| ((second & 0xFF) << 16)
+| ((third & 0xFF) << 8)
+| (fourth & 0xFF);
+} else {
+value = ((fourth & 0xFF) << 24)
+| ((third & 0xFF) << 16)
+| ((second & 0xFF) << 8)
+| (first & 0xFF);
+}
+if (value <= _MAX_INT) {
+RETURN ( _MKSMALLINT(value));
+}
+RETURN ( _makeULarge(value) );
 }
 }
 %}
 .
 filePointer isNil ifTrue:[^ self errorNotOpen].
 extern errno;
 OBJ pos;
 int cnt, savInt;
 extern int _immediateInterrupt;
-if (_INST(filePointer) != nil) {
+if ((_INST(filePointer) != nil) && (_INST(mode) != _readonly)) {
-if (_INST(mode) != _readonly) {
+if (_isSmallInteger(aByteValue)) {
-if (_isSmallInteger(aByteValue)) {
+c = _intVal(aByteValue);
-c = _intVal(aByteValue);
+f = MKFD(_INST(filePointer));
-f = MKFD(_INST(filePointer));
+savInt = _immediateInterrupt;
-savInt = _immediateInterrupt;
+_immediateInterrupt = 1;
-_immediateInterrupt = 1;
+#ifdef OLD
+if (_INST(buffered) == false) {
+cnt = write(fileno(f), &c, 1);
+} else
+#endif
+{
+if (_INST(mode) == _readwrite)
+fseek(f, 0L, 1); /* needed in stdio */
+cnt = fwrite(&c, 1, 1, f);
+#ifndef OLD
 if (_INST(buffered) == false) {
-cnt = write(fileno(f), &c, 1);
+fflush(f);
-} else {
+}
-if (_INST(mode) == _readwrite)
+#endif
-fseek(f, 0L, 1); /* needed in stdio */
+}
-cnt = fwrite(&c, 1, 1, f);
+_immediateInterrupt = savInt;
-}
+if (cnt == 1) {
-_immediateInterrupt = savInt;
+pos = _INST(position);
-if (cnt == 1) {
+if (pos != nil)
-pos = _INST(position);
+_INST(position) = _MKSMALLINT(_intVal(pos) + 1);
-if (pos != nil)
+RETURN ( self );
-_INST(position) = _MKSMALLINT(_intVal(pos) + 1);
+}
-RETURN ( self );
+ErrorNumber = _MKSMALLINT(errno);
-}
+RETURN (nil);
-ErrorNumber = _MKSMALLINT(errno);
-RETURN (nil);
-}
 }
 }
 %}
 .
 filePointer isNil ifTrue:[^ self errorNotOpen].
 objSize = _Size(anObject) - OHDR_SIZE;
 if ( (offs >= 0) && (cnt >= 0) && (objSize >= (cnt + offs)) ) {
 cp = (char *)_InstPtr(anObject) + OHDR_SIZE + offs;
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
+#ifdef OLD
 if (_INST(buffered) == false) {
 cnt = write(fileno(f), cp, cnt);
-} else {
+} else
+#endif
+{
 if (_INST(mode) == _readwrite)
 fseek(f, 0L, 1); /* needed in stdio */
 cnt = fwrite(cp, 1, cnt, f);
 }
+#ifndef OLD
+if (_INST(buffered) == false) {
+fflush(f);
+}
+#endif
 _immediateInterrupt = savInt;
 if (cnt >= 0) {
 pos = _INST(position);
 if (pos != nil)
 _INST(position) = _MKSMALLINT(_intVal(pos) + cnt);
 }
 f = MKFD(_INST(filePointer));
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
+#ifdef OLD
 if (_INST(buffered) == false) {
 cnt = write(fileno(f), bytes, 2);
-} else {
+} else
+#endif
+{
 if (_INST(mode) == _readwrite)
 fseek(f, 0L, 1); /* needed in stdio */
 cnt = fwrite(bytes, 1, 2, f);
 }
+#ifndef OLD
+if (_INST(buffered) == false) {
+fflush(f);
+}
+#endif
 _immediateInterrupt = savInt;
 if (cnt == 2) {
 if (_INST(position) != nil) {
 _INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 2);
 }
 }
 f = MKFD(_INST(filePointer));
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
+#ifdef OLD
 if (_INST(buffered) == false) {
 cnt = write(fileno(f), bytes, 4);
-} else {
+} else
+#endif
+{
 cnt = fwrite(bytes, 1, 4, f);
 }
+#ifndef OLD
+if (_INST(buffered) == false) {
+fflush(f);
+}
+#endif
 _immediateInterrupt = savInt;
 if (cnt == 4) {
 if (_INST(position) != nil) {
 _INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 4);
 }
 .
 filePointer isNil ifTrue:[^ self errorNotOpen].
 (mode == #readonly) ifTrue:[^ self errorReadOnly].
 binary ifFalse:[^ self errorNotBinary].
-(aNumber isKindOf:Integer) ifTrue:[
+aNumber isInteger ifTrue:[
 (self nextShortPut:(aNumber // 16r10000) MSB:msbFlag) isNil ifTrue:[^ nil].
 ^ self nextShortPut:(aNumber \\ 16r10000) MSB:msbFlag.
 ].
 self argumentMustBeInteger
 ! !
 int savInt;
 extern int _immediateInterrupt;
 if (_INST(filePointer) != nil) {
 if (_INST(mode) != _writeonly) {
-if (_INST(buffered) == true) {
+#ifdef OLD
+if (_INST(buffered) == true)
+#endif
+{
 f = MKFD(_INST(filePointer));
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
 c = getc(f);
 _immediateInterrupt = savInt;
 if (_INST(filePointer) != nil) {
 if (_INST(mode) != _writeonly) {
 f = MKFD(_INST(filePointer));
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
-	    do {
+do {
+#ifdef OLD
 if (_INST(buffered) == false) {
 if (read(fileno(f), &ch, 1) != 1)
 c = EOF;
 else
 c = ch;
-} else {
+} else
+#endif
+{
 if (_INST(mode) == _readwrite)
 fseek(f, 0L, 1); /* needed in stdio */
 c = getc(f);
 }
-	    } while ((c < 0) && (errno == EINTR));
+} while ((c < 0) && (errno == EINTR));
 _immediateInterrupt = savInt;
 if (c != EOF) {
 pos = _INST(position);
 if (_isSmallInteger(pos)) {
 synchronizeOutput
 "write all buffered data - for buffered mode only"
 %{  /* NOCONTEXT */
-FILE *f;
 if (_INST(filePointer) != nil) {
 if (_INST(mode) != _readonly) {
 if (_INST(buffered) == true) {
-fflush(f);
+fflush( MKFD(_INST(filePointer)) );
 }
 }
 }
 %}
 !
 doWrite:
 f = MKFD(_INST(filePointer));
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
+#ifdef OLD
 if (_INST(buffered) == false) {
 cnt = write(fileno(f), &c, 1);
-} else {
+} else
+#endif
+{
 if (_INST(mode) == _readwrite)
 fseek(f, 0L, 1); /* needed in stdio */
 cnt = fwrite(&c, 1, 1, f);
 }
+#ifndef OLD
+if (_INST(buffered) == false) {
+fflush(f);
+}
+#endif
 _immediateInterrupt = savInt;
 if (cnt == 1) {
 pos = _INST(position);
 if (pos != nil) {
 _INST(position) = _MKSMALLINT(_intVal(pos) + 1);
 if (cp != NULL) {
 f = MKFD(_INST(filePointer));
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
+#ifdef OLD
 if (_INST(buffered) == false) {
 cnt = write(fileno(f), cp, len);
-} else {
+} else
+#endif
+{
 if (_INST(mode) == _readwrite)
 fseek(f, 0L, 1); /* needed in stdio */
 cnt = fwrite(cp, 1, len, f);
 }
+#ifndef OLD
+if (_INST(buffered) == false) {
+fflush(f);
+}
+#endif
 _immediateInterrupt = savInt;
 if (cnt == len) {
 pos = _INST(position);
 if (pos != nil) {
 _INST(position) = _MKSMALLINT(_intVal(pos) + len);
 index2 = len;
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
 len = index2 - index1 + 1;
+#ifdef OLD
 if (_INST(buffered) == false) {
 cnt = write(fileno(f), cp + index1 - 1, len);
-} else {
+} else
+#endif
+{
 if (_INST(mode) == _readwrite)
 fseek(f, 0L, 1); /* needed in stdio */
 cnt = fwrite(cp + index1 - 1, 1, len, f);
 }
+#ifndef OLD
+if (_INST(buffered) == false) {
+fflush(f);
+}
+#endif
 _immediateInterrupt = savInt;
 if (cnt == len) {
 if (_INST(position) != nil) {
 _INST(position) = _MKSMALLINT(_intVal(_INST(position)) + len);
 }
 if (_INST(binary) != true) {
 f = MKFD(_INST(filePointer));
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
+#ifdef OLD
 if (_INST(buffered) == false) {
 cnt = write(fileno(f), "\n", 1);
-} else {
+} else
+#endif
+{
 if (_INST(mode) == _readwrite)
 fseek(f, 0L, 1); /* needed in stdio */
 cnt = fwrite("\n", 1, 1, f);
 }
+#ifndef OLD
+if (_INST(buffered) == false) {
+fflush(f);
+}
+#endif
 _immediateInterrupt = savInt;
 if (cnt == 1) {
 if (_INST(position) != nil) {
 _INST(position) = _MKSMALLINT(_intVal(_INST(position)) + 1);
 }
 "read the next line (characters up to newline).
 Return a string containing those characters excluding the newline.
 If the previous-to-last character is a cr, this is also removed,
 so its possible to read alien (i.e. ms-dos) text as well."
-%{  /* NOCONTEXT */
+%{  /* STACK:2000 */
 FILE *f;
 int len;
-char buffer[1024*8];
+char buffer[1024];
 extern int _immediateInterrupt;
 int savInt;
 char *rslt;
 extern errno;
+int fd;
-if ((_INST(filePointer) != nil) && (_INST(filePointer) != _writeonly)) {
+if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
 if (_INST(binary) != true) {
 f = MKFD(_INST(filePointer));
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
 buffer[0] = 0;
+#ifndef OLD
+if (_INST(mode) == _readwrite)
+fseek(f, 0L, 1); /* needed in stdio */
+#endif
+#ifdef OLD
 if (_INST(buffered) == true) {
-		do {
+#endif
+do {
 rslt = fgets(buffer, sizeof(buffer), f);
-	        } while ((rslt == NULL) && (errno == EINTR));
+} while ((rslt == NULL) && (errno == EINTR));
+#ifdef OLD
 } else {
 rslt = buffer;
+fd = fileno(f);
 for (;;) {
-		    do {
+do {
-len = read(fileno(f), rslt, 1);
+len = read(fd, rslt, 1);
-		    } while ((len < 0) && (errno == EINTR));
+} while ((len < 0) && (errno == EINTR));
 if (len <= 0) {
 if (rslt == buffer) {
 rslt = NULL;
 } else {
 *rslt = '\0';
 *rslt = '\0';
 break;
 }
 }
 }
+#endif
 _immediateInterrupt = savInt;
 if (rslt != NULL) {
 len = strlen(buffer);
 if (_INST(position) != nil) {
 _INST(position) = _MKSMALLINT(_intVal(_INST(position)) + len);
 s = (char *) _stringVal(aString);
 len = _stringSize(aString);
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
+#ifdef OLD
 if (_INST(buffered) == false) {
 cnt = write(fileno(f), s, len);
-} else {
+} else
+#endif
+{
 if (_INST(mode) == _readwrite)
 fseek(f, 0L, 1); /* needed in stdio */
 cnt = fwrite(s, 1, len, f);
 }
 if (cnt == len) {
+#ifdef OLD
 if (_INST(buffered) == false) {
 cnt = write(fileno(f), "\n", 1);
-} else {
+} else
+#endif
+{
 cnt = fwrite("\n", 1, 1, f);
 }
+#ifndef OLD
+if (_INST(buffered) == false) {
+fflush(f);
+}
+#endif
 if (cnt == 1) {
 pos = _INST(position);
 if (pos != nil) {
 _INST(position) = _MKSMALLINT(_intVal(pos)+len+1);
 }
 (mode == #readonly) ifTrue:[^ self errorReadOnly].
 filePointer isNil ifTrue:[^ self errorNotOpen].
 srcFilePointer := aStream filePointer.
 srcFilePointer isNil ifTrue:[^ aStream errorNotOpen].
-%{
+%{  /* STACK:2000 */
 FILE *dst, *src;
 char *matchString;
 int matchLen = 0;
-char buffer[1024*8];
+char buffer[1024];
 extern int _immediateInterrupt;
 int savInt;
-if (_isSmallInteger(srcFilePointer) && (_INST(buffered) == true)) {
+if (_isSmallInteger(srcFilePointer)
+#ifdef OLD
+&& (_INST(buffered) == true)
+#endif
+) {
 if ((aStringOrNil == nil) || _isString(aStringOrNil)) {
 if (aStringOrNil != nil) {
 matchString = (char *) _stringVal(aStringOrNil);
 matchLen = _stringSize(aStringOrNil);
 }
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
 for (;;) {
 if (fgets(buffer, sizeof(buffer), src) == NULL) break;
 if (fputs(buffer, dst) == EOF) break;
+#ifndef OLD
+if (_INST(buffered) == false) {
+fflush(dst);
+}
+#endif
 if (matchLen) {
 if (strncmp(matchString, buffer, matchLen) == 0)
 break;
 }
 }
 do not advance position i.e. nextLine will reread this line"
 (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 filePointer isNil ifTrue:[^ self errorNotOpen].
 binary ifTrue:[^ self errorBinary].
-%{
+%{  /* STACK: 2000 */
 FILE *f;
 int l;
-char buffer[1024*8];
+char buffer[1024];
 char *cp;
 char *matchString;
 int  firstpos, lastpos;
 extern int _immediateInterrupt;
 int savInt;
 l = _stringSize(aString);
 f = MKFD(_INST(filePointer));
 firstpos = ftell(f);
 for (;;) {
+if (_INST(mode) == _readwrite)
+fseek(f, 0L, 1); /* needed in stdio */
 lastpos = ftell(f);
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
-	    do {
+do {
 cp = fgets(buffer, sizeof(buffer), f);
-	    } while ((cp == NULL) && (errno == EINTR));
+} while ((cp == NULL) && (errno == EINTR));
 _immediateInterrupt = savInt;
 if (cp == NULL) {
 fseek(f, firstpos, 0);
 RETURN ( nil );
 }
 fd := self fileDescriptor.
 sema := Semaphore new.
 [OperatingSystem readCheck:fd] whileFalse:[
-Processor enableIOSemaphore:sema on:fd.
+Processor enableSemaphore:sema onInput:fd.
+Processor currentProcess state:#ioWait.
 sema wait.
-Processor disableIOSemaphore:sema
+Processor disableSemaphore:sema
 ]
 !
 writeWait
 "suspend the current process, until the receiver
 fd := self fileDescriptor.
 sema := Semaphore new.
 [OperatingSystem writeCheck:fd] whileFalse:[
-Processor enableIOSemaphore:sema on:fd.
+Processor enableSemaphore:sema onOutput:fd.
+Processor currentProcess state:#ioWait.
 sema wait.
-Processor disableIOSemaphore:sema
+Processor disableSemaphore:sema
 ]
 ! !
 !ExternalStream methodsFor:'reimplemented for speed'!
 if (_INST(mode) != _writeonly) {
 f = MKFD(_INST(filePointer));
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
 _INST(position) = nil;
+if (_INST(mode) == _readwrite)
+fseek(f, 0L, 1); /* needed in stdio */
 for (;;) {
 c = getc(f);
 if (c == EOF) {
 _immediateInterrupt = savInt;
 RETURN (nil);
 skipLine
 "read the next line (characters up to newline) skip only;
 return nil if EOF reached. Not allowed in binary mode."
-%{  /* NOCONTEXT */
+%{  /* STACK:2000 */
 FILE *f;
-char buffer[1024*8];
+char buffer[1024];
 extern int _immediateInterrupt;
 int savInt;
 if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
 if (_INST(binary) != true) {
 f = MKFD(_INST(filePointer));
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
+if (_INST(mode) == _readwrite)
+fseek(f, 0L, 1); /* needed in stdio */
 if (fgets(buffer, sizeof(buffer), f) != NULL) {
 _immediateInterrupt = savInt;
 RETURN ( self );
 }
 _immediateInterrupt = savInt;
 int savInt;
 if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
 if (_INST(binary) != true) {
 f = MKFD(_INST(filePointer));
+if (_INST(mode) == _readwrite)
+fseek(f, 0L, 1); /* needed in stdio */
 while (1) {
 if (feof(f)) {
 RETURN ( nil );
 }
 savInt = _immediateInterrupt;
 if ((_INST(filePointer) != nil) && (_INST(mode) != _writeonly)) {
 if (_INST(binary) != true) {
 f = MKFD(_INST(filePointer));
 while (1) {
+if (_INST(mode) == _readwrite)
+fseek(f, 0L, 1); /* needed in stdio */
 if (feof(f)) {
 RETURN ( nil );
 }
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
 int inComment, inString, inPrimitive = 0;
 extern int _immediateInterrupt;
 int savInt;
 f = MKFD(_INST(filePointer));
+if (_INST(mode) == _readwrite)
+fseek(f, 0L, 1); /* needed in stdio */
 /*
 * skip spaces
 */
 savInt = _immediateInterrupt;
 _immediateInterrupt = 1;
 while (! done) {
 if (feof(f)) {
 _immediateInterrupt = savInt;
 RETURN ( nil );
 }
-	do {
+do {
 c = getc(f);
-	} while ((c < 0) && (errno == EINTR));
+} while ((c < 0) && (errno == EINTR));
 switch (c) {
 case ' ':
 case '\t':
 case '\n':
 case '\r':
 bcopy(buffer, newBuffer, index);
 free(buffer);
 buffer = newBuffer;
 currSize = currSize * 2;
 }
-	do {
+do {
 c = getc(f);
-	} while (c < 0 && (errno == EINTR));
+} while (c < 0 && (errno == EINTR));
 if (c == '%') {
 peekC = getc(f);
 ungetc(peekC, f);
 if (peekC == '{') {
 inPrimitive++;

changeset 12	8e03bd717355
parent 10	4f1f9a91e406
child 22	847106305963