"

 COPYRIGHT (c) 1988 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic' }"

"{ NameSpace: Smalltalk }"

PositionableStream subclass:#ReadStream

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	category:'Streams'

!

!ReadStream primitiveDefinitions!

%{

%}

! !

!ReadStream class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1988 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    ReadStream defines protocol for reading streamwise over collections.

    [author:]

	Claus Gittinger

"

! !

!ReadStream class methodsFor:'blocked instance creation'!

with:aCollection

    "with on readStream makes no sense

     - what do you want to read from the end of a collection?"

    <resource:#obsolete>

    self obsoleteMethodWarning:'WARNING: with: should not be used for ReadStreams - use #on:'.

    ^ super with:aCollection

! !

!ReadStream methodsFor:'Compatibility-Squeak'!

next: n into: aCollection startingAt: startIndex

    "Read n objects into the given collection.

     Return aCollection or a partial copy if less than

     n elements have been read."

    | max |

    collection notNil ifTrue:[

        max := (readLimit - position) min: n.

        aCollection

            replaceFrom: startIndex

            to: startIndex+max-1

            with: collection

            startingAt: position+1.

        position := position + max.

        max = n

            ifTrue:[^ aCollection]

            ifFalse:[^ aCollection copyFrom: 1 to: startIndex+max-1].

    ].

    ^ super next:n into:aCollection startingAt:startIndex.

    "Modified: / 12-09-2010 / 13:06:09 / Jan Vrany <jan.vrany@fit.cvut.cz>"

! !

!ReadStream methodsFor:'converting'!

readStream

    "return a readStream from the receiver. Since this is already

     a readStream, return self."

    ^ self

!

readStreamOrNil

    "return a readStream from the receiver. Since this is already

     a readStream, return self.

     This method has been defined for protocol copmatibility with Filename"

    ^ self

! !

!ReadStream methodsFor:'emphasis'!

emphasis

    "return the emphasis of the current (i.e. next returned by #next)

     element. Streams on a string will return nil for all elements.

     Streams on collections which nothing at all about emphasises,

     will report an error."

    ^ collection emphasisAt:(position + 1).

    "

     |t s|

     t := 'hello world' asText

		emphasizeFrom:1 to:5 with:#bold;

		emphasizeFrom:7 to:11 with:#italic.

     s := t readStream.

     [s atEnd] whileFalse:[

	Transcript show:(s emphasis); show:' '.

	Transcript show:''''; show:(s next); showCR:''''.

     ].

    "

    "Modified: 15.5.1996 / 17:30:33 / cg"

! !

!ReadStream methodsFor:'queries'!

collectionSize

    "return the overall number of elements in the streamed collection

     (both already read and to be read)."

    ^ collection size

    "Created: / 30-07-2013 / 20:55:51 / cg"

!

copyFrom:beginning to:end

    ^ collection copyFrom:beginning to:end

!

isReadable

    "return true, if reading is supported by the receiver.

     Here, true is always returned."

    ^ true

    "Modified: 4.10.1997 / 17:59:21 / cg"

!

isWritable

    "return true, if writing is supported by the receiver.

     This has to be redefined in concrete subclasses."

    ^ false

!

remainingSize

    "return the number of remaining elements in the streamed collection."

    ^ collection size - position

    "Created: / 30-07-2013 / 20:18:12 / cg"

!

size

    "return the number of remaining elements in the streamed collection."

    "/ will change back soon for VW and Squeak compatibility.

    "/ ^ self collectionSize.

    ^  self remainingSize

    "Modified (comment): / 30-07-2013 / 20:57:23 / cg"

! !

!ReadStream methodsFor:'reading'!

next

    "return the next element; advance read pointer.

     return nil, if there is no next element.

     - tuned for a bit more speed on String/ByteArray/Array-Streams"

    |ret|

%{  /* NOCONTEXT */

    REGISTER INT pos;

    unsigned ch;

    OBJ coll, p, l;

    coll = __INST(collection);

    p = __INST(position);

    l = __INST(readLimit);

    if (__isNonNilObject(coll) && __bothSmallInteger(p, l)) {

        pos = __intVal(p);

        if (pos >= 0 && pos < __intVal(l)) {

            OBJ cls, ret;

            cls = __qClass(coll);

            if (cls == @global(String) || cls == @global(ImmutableString) || cls == @global(Symbol)) {

                if (pos < __stringSize(coll)) {

                    ch = __stringVal(coll)[pos];

                    ret = __MKCHARACTER(ch);

                    __INST(position) = __mkSmallInteger(pos+1);

                    RETURN ( ret );

                }

            } else if (cls == @global(ByteArray)) {

                if (pos < __byteArraySize(coll)) {

                    ch = __ByteArrayInstPtr(coll)->ba_element[pos];

                    ret = __mkSmallInteger(ch);

                    __INST(position) = __mkSmallInteger(pos+1);

                    RETURN ( ret );

                }

            } else if (cls == @global(Unicode16String)) {

                if (pos < __unicode16StringSize(coll)) {

                    ch = __unicode16StringVal(coll)[pos];

                    ret = __MKUCHARACTER(ch);

                    __INST(position) = __mkSmallInteger(pos+1);

                    RETURN ( ret );

                }

            } else if (cls == @global(Array)) {

                if (pos < __arraySize(coll)) {

                    ret = __ArrayInstPtr(coll)->a_element[pos];

                    __INST(position) = __mkSmallInteger(pos+1);

                    RETURN ( ret );

                }

            }

        }

    }

%}.

    (position >= readLimit) ifTrue:[^ self pastEndRead].

    position := position + 1.

    ret := collection at:position.

    ^ ret

!

next:count

    "return the next count elements of the stream as aCollection,

     which depends on the streams type - (see #contentsSpecies)."

    |answer|

    collection notNil ifTrue:[

        self contentsSpecies == collection class ifTrue:[

            ((position + count) > readLimit) ifFalse:[

                answer := collection copyFrom:position+1 to:position+count.

                position := position+count.

                ^ answer

            ].

        ].

    ].

    ^ super next:count

    "

     #[1 2 3 4 5 6 7 8 9] readStream

        next;

        next:5;

        next.

    "

!

nextAlphaNumericWord

    "read the next word (i.e. up to non letter-or-digit).

     return a string containing those characters.

     Skips any non-alphanumeric chars first.

     - tuned for speed on String-Streams for faster scanning"

%{

    /* speedup, if collection is a string */

    INT pos, limit, sz;

    INT len;

    char quickBuffer[256];

    char *buffer = quickBuffer;

    int bufferSize = sizeof(quickBuffer);

    REGISTER unsigned char *cp;

    REGISTER unsigned ch;

    OBJ coll, p, l;

    coll = __INST(collection);

    p = __INST(position);

    l = __INST(readLimit);

    if (__isStringLike(coll) && __bothSmallInteger(p, l)) {

	OBJ retVal;

	pos = __intVal(p);

	/* make 1-based */

	pos = pos + 1;

	limit = __intVal(l);

	sz = __qSize(coll) - OHDR_SIZE;

	if (sz < limit)

	    limit = sz;

	cp = __stringVal(coll) + pos - 1;

	/* skip over non-alphanumeric characters */

	for (;;) {

	    if (pos > limit) break;

	    ch = *cp;

	    if (((ch >= 'a') && (ch <= 'z')) ||

		((ch >= 'A') && (ch <= 'Z')) ||

		((ch >= '0') && (ch <= '9')))

		break;

	    cp++;

	    pos++;

	}

	/* collect non-alphanumeric characters */

	len = 0;

	for (;;) {

	    if (pos > limit) break;

	    ch = *cp & 0xFF;

	    if (! (((ch >= 'a') && (ch <= 'z')) ||

		   ((ch >= 'A') && (ch <= 'Z')) ||

		   ((ch >= '0') && (ch <= '9'))))

		break;

	    buffer[len++] = ch;

	    if (len >= (bufferSize-1)) {

		int newBufferSize = bufferSize * 2;

		if (buffer == quickBuffer) {

		    buffer = (char *)malloc(newBufferSize);

		    memcpy(buffer, quickBuffer, bufferSize);

		} else {

		    buffer = (char *)realloc(buffer, newBufferSize);

		}

		bufferSize = newBufferSize;

	    }

	    pos++;

	    cp++;

	}

	pos = pos - 1;

	__INST(position) = __mkSmallInteger(pos);

	buffer[len] = '\0';

	if (len == 0) {

	    RETURN (nil);

	}

	retVal = __MKSTRING_L(buffer, len);

	if (buffer != quickBuffer) {

	    free((void *)buffer);

	}

	RETURN ( retVal );

    }

%}

.

    ^ super nextAlphaNumericWord

!

nextByte

    "return the next element as an integer between 0 and 255; advance read pointer.

     - tuned for a bit more speed on String/ByteArray/Array-Streams"

    |ret|

%{  /* NOCONTEXT */

    REGISTER INT pos;

    unsigned ch;

    OBJ coll, p, l;

    coll = __INST(collection);

    p = __INST(position);

    l = __INST(readLimit);

    if (__isNonNilObject(coll) && __bothSmallInteger(p, l)) {

        pos = __intVal(p);

        if (pos >= 0 && pos < __intVal(l)) {

            OBJ cls, ret;

            cls = __qClass(coll);

            if (cls == @global(String) || cls == @global(ImmutableString) || cls == @global(Symbol)) {

                if (pos < __stringSize(coll)) {

                    ch = __stringVal(coll)[pos];

                    ret = __mkSmallInteger(ch);

                    __INST(position) = __mkSmallInteger(pos+1);

                    RETURN ( ret );

                }

            } else if (cls == @global(ByteArray) || cls == @global(ImmutableByteArray)) {

                if (pos < __byteArraySize(coll)) {

                    ch = __ByteArrayInstPtr(coll)->ba_element[pos];

                    ret = __mkSmallInteger(ch);

                    __INST(position) = __mkSmallInteger(pos+1);

                    RETURN ( ret );

                }

            } else if (cls == @global(Array) || cls == @global(ImmutableArray)) {

                if (pos < __arraySize(coll)) {

                    ret = __ArrayInstPtr(coll)->a_element[pos];

                    if (!__isSmallInteger(ret) || __intVal(ret) > 255) goto out;

                    __INST(position) = __mkSmallInteger(pos+1);

                    RETURN ( ret );

                }

            }

        }

    }

out:;

%}.

    (position >= readLimit) ifTrue:[^ self pastEndRead].

    ret := (collection at:(position + 1)) asInteger.

    ret > 255 ifTrue:[

        ret := ConversionError

            raiseRequestWith:self

            errorString:' - #nextByte trying to read a non-byte'.

    ].

    position := position + 1.

    ^ ret

!

nextOrNil

    "return the next element; advance read pointer.

     return nil, if there is no next element.

     - tuned for a bit more speed on String/ByteArray/Array-Streams"

    |ret|

%{  /* NOCONTEXT */

    REGISTER INT pos;

    unsigned ch;

    OBJ coll, p, l;

    coll = __INST(collection);

    p = __INST(position);

    l = __INST(readLimit);

    if (__isNonNilObject(coll) && __bothSmallInteger(p, l)) {

        pos = __intVal(p);

        if (pos >= 0) {

            OBJ cls, ret;

            if (pos >= __intVal(l)) {

                RETURN(nil);

            }

            cls = __qClass(coll);

            if (cls == @global(String) || cls == @global(ImmutableString) || cls == @global(Symbol)) {

                if (pos < __stringSize(coll)) {

                    ch = __stringVal(coll)[pos];

                    ret = __MKCHARACTER(ch);

                    __INST(position) = __mkSmallInteger(pos + 1);

                    RETURN ( ret );

                }

            } else if (cls == @global(ByteArray)) {

                if (pos < __byteArraySize(coll)) {

                    ch = __ByteArrayInstPtr(coll)->ba_element[pos];

                    ret = __mkSmallInteger(ch);

                    __INST(position) = __mkSmallInteger(pos + 1);

                    RETURN ( ret );

                }

            } else if (cls == @global(Unicode16String)) {

                if (pos < __unicode16StringSize(coll)) {

                    ch = __unicode16StringVal(coll)[pos];

                    ret = __MKUCHARACTER(ch);