"

 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:#CharacterArray

	 instanceVariableNames:''

	 classVariableNames:'PreviousMatch'

	 poolDictionaries:''

	 category:'Collections-Text'

!

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

"

!

documentation

"

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

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

    As the name already implies, this class is abstract, meaning that there are

    no instances of it. All this class does is provide common protocol for 

    concrete subclasses.

"

!

version

    ^ '$Header: /cvs/stx/stx/libbasic/Attic/CharArray.st,v 1.38 1995-11-23 01:23:53 cg Exp $'

! !

!CharacterArray class methodsFor:'instance creation'!

basicNew

    "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'"

!

fromStringCollection:aCollectionOfStrings

    "return new string formed by concatenating a copy of the argument, aString"

    ^ self fromStringCollection:aCollectionOfStrings separatedBy:''

    "

     String fromStringCollection:#('hello' 'world' 'how' 'about' 'this')

    "

    "Created: 20.11.1995 / 15:26:59 / cg"

!

fromStringCollection:aCollectionOfStrings separatedBy:aSeparatorString

    "return new string formed by concatenating a copy of the argument, aString"

    |newString first|

    newString := ''.

    first := true.

    aCollectionOfStrings do:[:s | 

	first ifFalse:[

	    newString := newString , aSeparatorString

	] ifTrue:[

	    first := false

	].

	newString := newString , s

    ].

    ^ newString

    "

     String fromStringCollection:#('hello' 'world' 'how' 'about' 'this') separatedBy:' '

    "

    "Created: 20.11.1995 / 15:32:17 / cg"

!

new

    "return a new empty string"

    ^ self basicNew:0

! !

!CharacterArray class methodsFor:'code tables'!

decoderTableFor:encoding

    "this is an experimental interface - unfinished"

    |table|

    table := (0 to:255) asByteArray.

    encoding == #mac ifTrue:[

	table at:8r232+1 put:246. "/ german umlaut o

	table at:8r212+1 put:228. "/ german umlaut a

	table at:8r237+1 put:252. "/ german umlaut u

	table at:8r206+1 put:220. "/ german umlaut U

	"/ more needed here - need info to do it ....

    ].

    "/ more encodings needed here ....

    ^ table

    "Created: 20.10.1995 / 23:04:43 / cg"

! !

!CharacterArray class methodsFor:'pattern matching'!

matchScan:matchScanArray from:matchStart to:matchStop with:aString from:start to:stop ignoreCase:ignoreCase

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

     aString are matching the scan in matchScan from matchStart to matchStop.

     The matchScan is as created by asMatchScanArray.

     This algorithm is not at all the most efficient; 

     for heavy duty pattern matching, an interface (primitive) to the regex 

     pattern matching package should be added."

    |matchEntry 

     mStart "{ Class: SmallInteger }"

     mStop  "{ Class: SmallInteger }"

     sStart "{ Class: SmallInteger }"

     sStop  "{ Class: SmallInteger }"

     mSize  "{ Class: SmallInteger }"

     sSize  "{ Class: SmallInteger }"

     index  "{ Class: SmallInteger }"

     quickCheck matchLast

     matchSet checkChar included|

    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)].

	matchEntry := matchScanArray at:mStart.

	"/ the most common case first:

	(sSize ~~ 0 

	and:[(checkChar := (aString at:sStart)) == matchEntry]) ifTrue:[

	    "advance by one and continue"

	    mStart := mStart + 1.

	    sStart := sStart + 1

	] ifFalse:[

	    (matchEntry == #any) ifTrue:[

		"restString empty -> no match"

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

		"# matches single character"

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

		"advance by one and continue"

		mStart := mStart + 1.

		sStart := sStart + 1

	    ] ifFalse:[

		(matchEntry == #anyString) ifTrue:[

		    "* alone matches anything"

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

		    "restString empty & matchString not empty -> no match"

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

		    "

		     try to avoid some of the recursion by checking last

		     character and continue with shortened strings if possible

		    "

		    quickCheck := false.

		    (mStop >= mStart) ifTrue:[

			matchLast := matchScanArray at:mStop.

			(matchLast ~~ #anyString) ifTrue:[

			    (matchLast == #any) ifTrue:[

				quickCheck := true

			    ] ifFalse:[

				matchLast == (aString at:sStop) ifTrue:[

				    quickCheck := true

				] ifFalse:[

				    matchLast isString ifTrue:[

					quickCheck := matchLast includes:(aString at:sStop)

				    ]

				]

			    ]

			]

		    ].

		    quickCheck ifFalse:[

			"

			 no quick check possible;

			 loop over all possible substrings

			"

			index := sStart.

			[index <= sStop] whileTrue:[

			    (self matchScan:matchScanArray 

				  from:(mStart + 1) 

				  to:mStop 

				  with:aString 

				  from:index 

				  to:stop 

				  ignoreCase:ignoreCase) ifTrue:[

				^ true

			    ].

			    index := index + 1

			].

			^ false

		    ].

		    "

		     quickCheck ok, advance from the right

		    "

		    mStop := mStop - 1.

		    sStop := sStop - 1

		] ifFalse:[

		    (matchEntry isString) ifTrue:[

			"testString empty -> no match"

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

			included := false.

			"/ checkChar := aString at:sStart.

			included := matchEntry includes:checkChar.

			included ifFalse:[

			    ignoreCase ifTrue:[

				checkChar isUppercase ifTrue:[

				    included := matchEntry includes:checkChar asLowercase.

				] ifFalse:[

				    included := matchEntry includes:checkChar asUppercase.

				]

			    ].

			].

			mStart := mStart + 1.

			mSize := mSize - 1.

			included ifFalse:[^ false].

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

			"cut off 1st char and continue"

			sStart := sStart + 1

		    ] ifFalse:[

			"/ must be single character

			"testString empty ?"

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

			"first characters equal ?"

			"/ checkChar := aString at:sStart.

			ignoreCase ifFalse:[^ false].

			(checkChar asUppercase ~~ matchEntry asUppercase) ifTrue:[^ false].

			"advance and continue"

			mStart := mStart + 1.

			sStart := sStart + 1

		    ]

		]

	    ]

	]

    ]

!

matchScanArrayFrom:aString

    "scan a pattern string and decompose it into a scanArray.

     This is processed faster (especially with character ranges), and

     can also be reused later. (if the same pattern is to be searched again)"

    |coll 

     idx "{ Class: SmallInteger }"

     end c1 c2 matchSet previous|

    coll := OrderedCollection new.

    idx := 1. end := aString size.

    [idx <= end] whileTrue:[

	|char this|

	char := aString at:idx.

	char == $* ifTrue:[

	    previous ~~ #anyString ifTrue:[

		this := #anyString

	    ]

	] ifFalse:[

	    char == $# ifTrue:[

		previous ~~ #anyString ifTrue:[

		    this := #any

		]

	    ] ifFalse:[

		char == $[ ifTrue:[

		    matchSet := IdentitySet new.

		    idx := idx + 1.

		    idx > end ifTrue:[^ nil].

		    char := aString at:idx.

		    c1 := nil.

		    [char ~~ $]] whileTrue:[

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

			    idx := idx + 1.

			    idx > end ifTrue:[^ nil].

			    c2 := aString at:idx.

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

			    c1 := nil.

			    idx := idx + 1.

			] ifFalse:[

			    (char ~~ $]) ifTrue:[

				matchSet add:char.

				c1 := char.

				idx := idx + 1

			    ]

			].

			idx > end ifTrue:[^ nil].

			char := aString at:idx

		    ].

		    this := matchSet asString

		] ifFalse:[

		    this := char

		]

	    ]

	].

	this notNil ifTrue:[coll add:this. previous := this].

	idx := idx + 1

    ].

    ^ coll asArray

    "

     String matchScanArrayFrom:'*ute*'  

     String matchScanArrayFrom:'**ute**'  

     String matchScanArrayFrom:'*uter'   

     String matchScanArrayFrom:'[cC]#mpute[rR]'  

     String matchScanArrayFrom:'[abcd]*'      

     String matchScanArrayFrom:'[a-k]*'      

     String matchScanArrayFrom:'*some*compl*ern*' 

     String matchScanArrayFrom:'[a-'  

     String matchScanArrayFrom:'[a-zA-Z]'  

     String matchScanArrayFrom:'[a-z01234A-Z]'  

    "

! !

!CharacterArray methodsFor:'Compatibility - ST/V'!

byteAt:index put:aByte

    "store a byte at given index.

     This is an ST/V compatibility method."

    (aByte == 0) ifTrue:[

	"store a space instead"

	^ super basicAt:index put:(Character space)

    ].

    ^ super at:index put:(Character value:aByte)

!

replChar:oldChar with:newChar

    "return a copy of the receiver, with all oldChars replaced

     by newChar.

     This is an ST/V compatibility method."

    ^ self copy replaceAll:oldChar by:newChar

    "

     '12345678901234567890' replChar:$0 with:$* 

    "

!

replChar:oldChar withString:newString

    "return a copy of the receiver, with all oldChars replaced

     by newString (i.e. slice in the newString in place of the oldChar).

     This is an ST/V compatibility method."

    |tmpStream|

    tmpStream := WriteStream on:(self class new).

    self do:[:element |

	element = oldChar ifTrue:[

	    tmpStream nextPutAll:newString

	] ifFalse:[

	    tmpStream nextPut:element 

	].

    ].

    ^ tmpStream contents

   "

     '12345678901234567890' replChar:$0 withString:'foo' 

     'a string with spaces' replChar:$  withString:' foo '  

    "

!

trimBlanks

    "return a copy of the receiver without leading

     and trailing spaces.

     This is an ST/V compatibility method."

    ^ self withoutSpaces

    "

     '    spaces at beginning' trimBlanks     

     'spaces at end    ' trimBlanks           

     '    spaces at beginning and end     ' trimBlanks    

     'no spaces' trimBlanks              

    "

! !

!CharacterArray methodsFor:'Compatibility - VisualAge'!

addLineDelimiter

    "replace all '\'-characters by line delimiter (cr) - characters.

     This has been added for VisualAge compatibility."

    ^ self withCRs

!

bindWith:aString

    "return a copy of the receiver, where a '%1' escape is

     replaced by aString.

     This has been added for VisualAge compatibility."

    ^ self expandPlaceholdersWith:(Array with:aString)

    "

     'do you like %1 ?' bindWith:'smalltalk'

    "

!

bindWith:string1 with:string2

    "return a copy of the receiver, where a '%1' escape is

     replaced by string1 and '%2' is replaced by string2.

     This has been added for VisualAge compatibility."

    ^ self expandPlaceholdersWith:(Array with:string1 with:string2)

    "

     'do you prefer %1 or rather %2 ?'

	bindWith:'smalltalk' with:'c++'

    "

!

bindWith:str1 with:str2 with:str3

    "return a copy of the receiver, where a '%1', '%2' and '%3' escapes

     are replaced by str1, str2 and str3 respectively.

     This has been added for VisualAge compatibility."

    ^ self expandPlaceholdersWith:(Array with:str1 with:str2 with:str3)

    "

     'do you prefer %1 or rather %2 (not talking about %3) ?'

	bindWith:'smalltalk' with:'c++' with:'c'

    "

!

bindWith:str1 with:str2 with:str3 with:str4

    "return a copy of the receiver, where a '%1', '%2', '%3' and '%4' escapes

     are replaced by str1, str2, str3 and str4 respectively.

     This has been added for VisualAge compatibility."

    ^ self expandPlaceholdersWith:(Array with:str1 with:str2 with:str3 with:str4)

    "

     'do you prefer %1 or rather %2 (not talking about %3 or even %4) ?'

	bindWith:'smalltalk' with:'c++' with:'c' with:'assembler'

    "

!

bindWithArguments:anArrayOfStrings

    "return a copy of the receiver, where a '%i' escape

     is replaced by the coresponding string from the argument array.

     'i' may be between 1 and 9 (i.e. a maximum of 9 placeholders is allowed).

     This has been added for VisualAge compatibility."

    ^ self expandPlaceholdersWith:anArrayOfStrings

    "

     'do you prefer %1 or rather %2 (not talking about %3) ?'

	bindWithArguments:#('smalltalk' 'c++' 'c')

    "

!

subStrings

    "return an array consisting of all words contained in the receiver.

     Words are separated by whitespace.

     This has been added for VisualAge compatibility."