"

 COPYRIGHT (c) 1994 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:#AbstractString

       instanceVariableNames:''

       classVariableNames:''

       poolDictionaries:''

       category:'Collections-Text'

!

AbstractString comment:'

COPYRIGHT (c) 1994 by Claus Gittinger

              All Rights Reserved

'!

!AbstractString class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1994 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.

"

!

version

"

$Header: /cvs/stx/stx/libbasic/Attic/CharArray.st,v 1.4 1994-06-02 11:18:12 claus Exp $

"

!

documentation

"

    AbstractString is a superclass for all kinds of Strings (i.e.

    (singleByte-)Strings, TwoByteStrings and whatever comes in the future.

"

! !

!AbstractString class methodsFor:'instance creation'!

basicNew

    "return a new empty string"

    ^ self basicNew:0

!

new

    "return a new empty string"

    ^ self basicNew:0

!

fromString:aString

    "return a copy of the argument, aString"

    ^ (self basicNew:(aString size)) replaceFrom:1 with:aString

    "TwoByteString fromString:'hello'"

! !

!AbstractString 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

!

asTwoByteString

    "return the receiver converted to a two-byte string"

    ^ TwoByteString fromString:self

!

asSingleByteString

    "return the receiver converted to a 'normal' string"

    ^ String fromString:self

!

asText

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

     BIG warning: Text is totally misnamed here 

         - ST/X's Text has nothing to do with PP's Text.

         Therefore it will be removed/renamed soon."

    ^ 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

!

asCollectionOfWords

    "return a collection containing the words (separated by whitespace) 

     of the receiver"

    |words ch

     start  "{ Class:SmallInteger }" 

     stop   "{ Class:SmallInteger }" 

     mySize "{ Class:SmallInteger }"|

    words := OrderedCollection new.

    start := 1.

    mySize := self size.

    [start <= mySize] whileTrue:[

        ch := self at:start.

        ((ch == Character space) or:[ch isSeparator]) ifTrue:[

            start := start + 1

        ] ifFalse:[

            stop := self indexOfSeparatorStartingAt:start.

            stop == 0 ifTrue:[

                words add:(self copyFrom:start to:mySize).

                ^ words

            ].

            words add:(self copyFrom:start to:(stop - 1)).

            start := stop

        ]

    ].

    ^ words

    "'hello world isnt this nice' asCollectionOfWords'"

!

asCollectionOfLines

    "return a collection containing the lines (separated by cr) 

     of the receiver."

    |lines myClass

     numberOfLines "{ Class:SmallInteger }"

     startIndex    "{ Class:SmallInteger }"

     stopIndex     "{ Class:SmallInteger }" |

    "count first, to avoid regrowing"

    numberOfLines := (self occurrencesOf:Character cr) + 1.

    lines := OrderedCollection new:numberOfLines.

    myClass := self species.

    startIndex := 1.

    1 to:numberOfLines do:[:lineNr |

        stopIndex := self indexOf:(Character cr) startingAt:startIndex.

        stopIndex == 0 ifTrue:[

            stopIndex := self size

        ] ifFalse: [

            stopIndex := stopIndex - 1.

        ].

        (stopIndex < startIndex) ifTrue: [

            lines add:(myClass new:0)

        ] ifFalse: [

            lines add:(self copyFrom:startIndex to:stopIndex)

        ].

        startIndex := stopIndex + 2

    ].

    ^ lines

    "

     '1 one\2 two\3 three\4 four\5 five' withCRs asCollectionOfLines

     '1 one\2 two\3 three\4 four\5 five' withCRs asCollectionOfWords

    "

! !

!AbstractString methodsFor:'printing & storing'!

article

    "return an article string"

    |firstChar|

    firstChar := (self at:1) asLowercase. 

    (firstChar isVowel or:[firstChar == $x]) ifTrue:[

         ^ 'an'

    ].

    ^ 'a'

!

printOn:aStream

    "print the receiver on aStream"

    aStream nextPutAll:self

!

printString

    "return a string for printing - thats myself"

    ^ self

!

displayString

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

     quotes around"

    ^ self storeString

! !

!AbstractString 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.

     In contrast to ST-80, case differences are NOT ignored, thus

     'foo' > 'Foo' will return true. 

     This may change."

    |mySize otherSize c1 c2|

    mySize := self size.

    otherSize := aString size.

    1 to:(mySize min:otherSize) do:[:index |

        c1 := self at:index.

        c2 := aString at:index.

        c1 > c2 ifTrue:[^ true].

        c1 < c2 ifTrue:[^ false].

    ].

    ^ mySize > otherSize

!

= aString

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

     receiver is equal to the argument. Otherwise return false."

    |mySize otherSize|

    mySize := self size.

    otherSize := aString size.

    mySize == otherSize ifFalse:[^ false].

    1 to:mySize do:[:index |

        (self at:index) = (aString at:index) ifFalse:[^ false].

    ].

    ^ true

!

sameAs:aString

    "Compare the receiver with the argument like =, but ignore

     case differences. Return true or false"

    |mySize otherSize|

    mySize := self size.

    otherSize := aString size.

    mySize == otherSize ifFalse:[^ false].

    1 to:mySize do:[:index |

        (self at:index) asLowercase = (aString at:index) asLowercase ifFalse:[^ false].

    ].

    ^ true

! !

!AbstractString methodsFor:'character searching'!

includesMatchCharacters

    "return true if the receiver includes any meta characters (i.e. $* or $#) 

     for match operations; false if not"

    ^ self includesAny:'*#['

!

indexOfSeparator

    "return the index of the first whitespace character"

    ^ self indexOfSeparatorStartingAt:1

    "'hello world' indexOfSeparator"

!

indexOfSeparatorStartingAt:start

    "return the index of the next whitespace character"

    start to:self size do:[:index |

        (self at:index) isSeparator ifTrue:[^ index]

    ].

    ^ 0

    "'hello world' indexOfSeparatorStartingAt:3"

! !

!AbstractString methodsFor:'substring searching'!

findString:subString 

    "find a substring. if found, return the index;

     if not found, return 0"

    ^ self findString:subString startingAt:1 ifAbsent:[0]

    "'hello world' findString:'llo'"

    "'hello world' findString:'ole'"

!

findString:subString startingAt:index

    "find a substring, starting at index. if found, return the index;

     if not found, return 0"

    ^ self findString:subString startingAt:index ifAbsent:[0]

    "'hello yello' findString:'llo' startingAt:1"

    "'hello yello' findString:'llo' startingAt:5"

    "'hello yello' findString:'llo' startingAt:15"

!

findString:subString startingAt:index ifAbsent:exceptionBlock

    "find a substring, starting at index. if found, return the index;

     if not found, return the result of evaluating exceptionBlock.

     This is a q&d hack - not very efficient"

    |firstChar found

     startIndex "{ Class: SmallInteger }"

     subSize    "{ Class: SmallInteger }"

     mySize     "{ Class: SmallInteger }"

     runIdx     "{ Class: SmallInteger }" |

    subSize := subString size.

    subSize == 0 ifTrue:[^ index]. "empty string matches"

    mySize := self size.

    firstChar := subString at:1.

    startIndex := self indexOf:firstChar startingAt:index.

    [startIndex == 0] whileFalse:[

        runIdx := startIndex.

        found := true.

        1 to:subSize do:[:i |

            runIdx > mySize ifTrue:[

                found := false

            ] ifFalse:[

                (subString at:i) ~~ (self at:runIdx) ifTrue:[

                    found := false

                ]

            ].

            runIdx := runIdx + 1

        ].

        found ifTrue:[

            ^ startIndex

        ].

        startIndex := self indexOf:firstChar startingAt:(startIndex + 1)

    ].

    ^ exceptionBlock value

! !

!AbstractString methodsFor:'pattern matching'!

from:matchStart to:matchStop match:aString from:start to:stop

    "helper for match; return true if the characters from start to stop in

     aString are matching the receivers characters from matchStart to matchStop.

     The receiver may contain meta-match characters $* (to match any string) 

     or $# (to match any character) or [...] (to match from a set of characters)."

    |matchChar 

     mStart "{ Class: SmallInteger }"

     mStop  "{ Class: SmallInteger }"

     sStart "{ Class: SmallInteger }"

     sStop  "{ Class: SmallInteger }"

     mSize  "{ Class: SmallInteger }"

     sSize  "{ Class: SmallInteger }"

     index cont matchLast

     matchSet c1 c2|

    mStart := matchStart.

    mStop := matchStop.

    sStart := start.

    sStop := stop.

    [true] whileTrue:[

        mSize := mStop - mStart + 1.

        sSize := sStop - sStart + 1.

        "empty strings match"

        (mSize == 0) ifTrue:[^ (sSize == 0)].

        matchChar := self at:mStart.

        (matchChar == $#) ifTrue:[

            "testString empty -> no match"

            (sSize == 0) ifTrue:[^ false].

            "# matches single character"

            ((sSize == 1) and:[mSize == 1]) ifTrue:[^ true].

            "cut off 1st chars and continue"

            mStart := mStart + 1.

            sStart := sStart + 1

        ] ifFalse:[

            (matchChar == $[) ifTrue:[

                "testString empty -> no match"

                (sSize == 0) ifTrue:[^ false].

                matchSet := Set new.

                c1 := nil.

                [matchChar == $]] whileFalse:[

                    mStart := mStart + 1.

                    mSize := mSize - 1.

                    matchChar := self at:mStart.

                    ((matchChar == $-) and:[c1 notNil]) ifTrue:[

                        mStart := mStart + 1.

                        mSize := mSize - 1.

                        c2 := self at:mStart.

                        (c1 to:c2) do:[:c | matchSet add:c].

                        c1 := nil

                    ] ifFalse:[

                        (matchChar == $]) ifFalse:[

                            matchSet add:matchChar.

                            c1 := matchChar.

                        ].

                    ].

                ].

                mStart := mStart + 1.