"

 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.

"

ByteArray subclass:#String

       instanceVariableNames:''

       classVariableNames:''

       poolDictionaries:''

       category:'Collections-Text'

!

String comment:'

COPYRIGHT (c) 1988 by Claus Gittinger

             All Rights Reserved

'!

%{

#include <stdio.h>

#include <ctype.h>

%}

!String class methodsFor:'documentation'!

documentation

"

Strings are ByteArrays storing Characters.

Strings are kind of kludgy: to allow for easy handling by c-functions,

there is always one 0-byte added at the end, which is not counted

in size. also, the at:put: method does not allow for storing 0-bytes.

(to do this, the basicAt:put: and basicNew: methods are redefined)

You cannot add any instvars to String, since the code (also in the run time

system & compiler) knows that strings have no named instvars. 

If you really need strings with instVars, you have to create a subclass 

of String (the access functions defined here can handle this).

"

! !

!String class methodsFor:'queries'!

isBuiltInClass

    "this class is known by the run-time-system"

    ^ self == String

! !

!String class methodsFor:'instance creation'!

basicNew:anInteger

    "return a new empty string with anInteger characters"

%{  /* NOCONTEXT */

    OBJ newString;

    REGISTER int len;

    REGISTER unsigned char *cp;

    REGISTER OBJ *op;

    int nInstVars, instsize;

    extern OBJ new();

    if (_isSmallInteger(anInteger)) {

        len = _intVal(anInteger);

        if (len >= 0) {

            nInstVars = _intVal(_ClassInstPtr(self)->c_ninstvars);

            instsize = OHDR_SIZE + (nInstVars * sizeof(OBJ)) + len + 1;

            PROTECT_CONTEXT

            _qNew(newString, instsize, SENDER);

            UNPROTECT_CONTEXT

            if (newString != nil) {

                _InstPtr(newString)->o_class = self;

                if (nInstVars) {

#if defined(memset4)

                    memset4(_InstPtr(newString)->i_instvars, nil, nInstVars);

#else

# if defined(FAST_MEMSET) && ! defined(NEGATIVE_ADDRESSES)

                    /*

                     * knowing that nil is 0

                     */

                    memset(_InstPtr(newString)->i_instvars, 0, instsize - OHDR_SIZE);

# else

                    op = _InstPtr(newString)->i_instvars;

                    do {

                        *op++ = nil;

                    } while (--nInstVars);

# endif

#endif

                    cp = _stringVal(newString) + (nInstVars * sizeof(OBJ));

                } else

                    cp = _stringVal(newString);

#ifdef FAST_MEMSET

                memset(cp, ' ', len);

                *(cp + len) = '\0';

#else

                while (len--)

                    *cp++ = ' ';

                *cp = '\0';

#endif

                RETURN (newString);

            }

        }

    }

%}

.

    ^ (super basicNew:anInteger) atAllPut:(Character space)

!

basicNew

    "return a new empty string"

    ^ self basicNew:0

!

new

    "return a new empty string"

    ^ self basicNew:0

!

unititializedNew:anInteger

    "redefine it back - strings must have a 0-byte at the end"

    ^ self basicNew:anInteger

!

fromString:aString

    "return a copy of the argument, aString"

    ^ aString copyFrom:1 to:(aString size)

! !

!String methodsFor:'accessing'!

basicSize

    "return the number of characters in myself.

     Redefined here to exclude the 0-byte at the end."

%{  /* NOCONTEXT */

    if ((_qClass(self) == String) || (_qClass(self) == Symbol)) {

        RETURN ( _MKSMALLINT(_stringSize(self)) );

    }

%}

.

    ^ super basicSize - 1

!

basicAt:index

    "return the character at position index, an Integer

     - reimplemented here since we return characters"

%{  /* NOCONTEXT */

    REGISTER int indx;

    int len;

    if (_isSmallInteger(index)) {

        indx = _intVal(index);

        if (_qClass(self) != String)

            indx += _intVal(_ClassInstPtr(_qClass(self))->c_ninstvars) * sizeof(OBJ);

        len = _stringSize(self);

        if ((indx > 0) && (indx <= len)) {

            RETURN ( _MKCHARACTER(_stringVal(self)[indx-1] & 0xFF) );

        }

    }

%}

.

    self subscriptBoundsError

!

basicAt:index put:aCharacter

    "store the argument, aCharacter at position index, an Integer

     - reimplemented here since we store characters"

%{  /* NOCONTEXT */

    REGISTER int value, indx;

    int len;

    if (_isCharacter(aCharacter)) {

        value = _intVal(_characterVal(aCharacter));

        if (value && _isSmallInteger(index)) {

            indx = _intVal(index);

            if (_qClass(self) != String)

                indx += _intVal(_ClassInstPtr(_qClass(self))->c_ninstvars) * sizeof(OBJ);

            len = _stringSize(self);

            if ((indx > 0) && (indx <= len)) {

                _stringVal(self)[indx-1] = value;

                RETURN ( aCharacter );

            }

        }

    }

%}

.

    (aCharacter isMemberOf:Character) ifFalse:[

        self elementNotCharacter

    ] ifTrue:[

        (aCharacter asciiValue == 0) ifTrue:[

            self elementBoundsError

        ] ifFalse:[

            self subscriptBoundsError

        ]

    ]

! !

!String methodsFor:'converting'!

asUppercase

    "return a copy of myself in uppercase letters"

    |newStr

     mySize "{ Class: SmallInteger }" |

    mySize := self size.

    newStr := self species new:mySize.

    1 to:mySize do:[:i |

        newStr at:i put:(self at:i) asUppercase

    ].

    ^newStr

!

asLowercase

    "return a copy of myself in lowercase letters"

    |newStr

     mySize "{ Class: SmallInteger }" |

    mySize := self size.

    newStr := self species new:mySize.

    1 to:mySize do:[:i |

        newStr at:i put:(self at:i) asLowercase

    ].

    ^newStr

!

asString

    "return myself - I am a string"

    ^ self

!

asSymbol

    "return a unique symbol with name taken from myself.

     The argument must be a String, subclass instances are not allowed."

%{

    if (_qClass(self) == String) {

        RETURN ( _MKSYMBOL(_stringVal(self), (OBJ *)0, __context) );

    }

%}

.

    self primitiveFailed

!

asText

    "return a Text-object (collection of lines) from myself"

    ^ Text from:self

!

asNumber

    "read a number from the receiver"

    ^ Number readFromString:self

    "'123' asNumber"

    "'123.567' asNumber"

    "'(5/6)' asNumber"

!

asFilename

    "return a Filename with pathname taken from the receiver"

    ^ Filename named:self

! !

!String class methodsFor:'binary storage'!

binaryDefinitionFrom: stream manager: manager

    ^ (stream next: (stream nextNumber: 4)) asString

! !

!String methodsFor:'printing & storing'!

isLiteral

    "return true, if the receiver can be used as a literal

     (i.e. can be used in constant arrays)"

    ^ true

!

printOn:aStream

    "print the receiver on aStream"

    aStream nextPutAll:self

!

printString

    "return a string for printing - thats myself"

    ^ self

!

print

    "print the receiver on standard output - for debugging only"

%{  /* NOCONTEXT */

    if (_qClass(self) == String) {

        printf("%s", _stringVal(self));

        RETURN (self);

    }

%}

.

    super print

!

printfPrintString:formatString

    "non-portable but sometimes useful.

     Return a printed representation of the receiver as specified by formatString, 

     which is defined by printf.

     No checking on overrunning the buffer."

%{  /* STACK: 1000 */

    char buffer[800];

    char *cp;

    if (_isString(formatString)) {

        /*

         * actually only needed on sparc: since thisContext is

         * in a global register, which gets destroyed by printf,

         * manually save it here - very stupid ...

         */

        OBJ sav = __thisContext;

        cp = (char *)_stringVal(self);

        if (_qClass(self) != String)

            cp += _intVal(_ClassInstPtr(_qClass(self))->c_ninstvars) * sizeof(OBJ);

        sprintf(buffer, (char *)_stringVal(formatString), cp);

        __thisContext = sav;

        RETURN ( _MKSTRING(buffer COMMA_SND) );

    }

%}

.

    self primitiveFailed

    "'hello' printfPrintString:'%%s -> %s'"

    "'hello' printfPrintString:'%%10s -> %10s'"

    "'hello' printfPrintString:'%%-10s -> %-10s'"

!

displayString

    "return a string to display the receiver - use storeString to have

     quotes around"

    ^ self storeString

!

storeString

    "return a String for storing myself"

        self do:[:thisChar |

        ].

        ^ s

    ].

    ^ '''' asString , self , '''' asString

!

storeOn:aStream

    "put the storeString of myself on aStream"

    aStream nextPut: $'.

    (self includes:$') ifTrue:[

        self do:[:thisChar |

            (thisChar == $') ifTrue:[aStream nextPut:thisChar].

            aStream nextPut:thisChar

        ]

    ] ifFalse:[

        aStream nextPutAll:self

    ].

    aStream nextPut:$'

! !

!String methodsFor:'comparing'!

hash

    "return an integer useful as a hash-key"

%{  /* NOCONTEXT */

    REGISTER int g, val;

    REGISTER unsigned char *cp, *cp0;

    int l;

    cp = _stringVal(self);

    l = _stringSize(self);

    if (_qClass(self) != String) {

        int n = _intVal(_ClassInstPtr(_qClass(self))->c_ninstvars) * sizeof(OBJ);

        cp += n;

        l -= n;

    }

    /*

     * this is the dragon-book algorithm with a funny start

     * value (to give short strings a number above 8192)

     */

    val = 12345;

    for (cp0 = cp, cp += l - 1; cp >= cp0; cp--) {

        val = (val << 5) + (*cp & 0x1F);

        if (g = (val & 0x3E000000))

            val ^= g >> 25 /* 23 */ /* 25 */;

        val &= 0x3FFFFFFF;

    }

    if (l) {

        l |= 1; 

        val = (val * l) & 0x3FFFFFFF;

    }

    RETURN ( _MKSMALLINT(val) );

%}

!

<= something

    "Compare the receiver with the argument and return true if the

     receiver is less than or equal to the argument. Otherwise return false."

    ^ (self > something) not

!

< something

    "Compare the receiver with the argument and return true if the

     receiver is less than the argument. Otherwise return false."

    ^ (something > self)

!

>= something

    "Compare the receiver with the argument and return true if the

     receiver is greater than or equal to the argument.

     Otherwise return false."

    ^ (something > self) not

!

> aString

    "Compare the receiver with the argument and return true if the

     receiver is greater than the argument. Otherwise return false."

%{  /* NOCONTEXT */

    int len1, len2, cmp;

    REGISTER OBJ s = aString;

    char *cp1, *cp2;

    if (_isNonNilObject(s)

     && ((_qClass(s) == String) || (_qClass(s) == Symbol) || (_qClass(s) == _qClass(self)))) {

        cp1 = (char *) _stringVal(self);

        len1 = _stringSize(self);

        if (_qClass(self) != String) {

            int n = _intVal(_ClassInstPtr(_qClass(self))->c_ninstvars) * sizeof(OBJ);

            cp1 += n;

            len1 -= n;

        }

        cp2 = (char *) _stringVal(s);

        len2 = _stringSize(s);

        if (_qClass(s) != String) {

            int n = _intVal(_ClassInstPtr(_qClass(s))->c_ninstvars) * sizeof(OBJ);

            cp2 += n;

            len2 -= n;

        }

        if (len1 <= len2)

            cmp = strncmp(cp1, cp2, len1);

        else

            cmp = strncmp(cp1, cp2, len2);

        if (cmp > 0) {

            RETURN ( true );

        }

        if ((cmp == 0) && (len1 > len2)) {

            RETURN ( true );

        }

        RETURN ( false );

    }

%}

.