hg/stx-libbasic: comparison CharacterArray.st

equal deleted inserted replaced

-:eecab5af2679
+:f1fdda306d51
 documentation
 "
 CharacterArray is a superclass for all kinds of Strings (i.e.
 (singleByte-)Strings, TwoByteStrings and whatever comes in the future.
 This class is abstract, meaning that there are no instances of it.
 All this class does is provide common protocol for concrete subclasses.
 [author:]
-Claus Gittinger
+	Claus Gittinger
 [see also:]
-String TwoByteString
+	String TwoByteString
-StringCollection
+	StringCollection
 "
 ! !
 !CharacterArray class methodsFor:'initialization'!
 initialize
 DecodingFailedSignal isNil ifTrue:[
-DecodingFailedSignal := DecodingError.
+	DecodingFailedSignal := DecodingError.
-DecodingFailedSignal notifierString:'error during decode'.
+	DecodingFailedSignal notifierString:'error during decode'.
-EncodingFailedSignal :=EncodingError.
+	EncodingFailedSignal :=EncodingError.
-EncodingFailedSignal notifierString:'error during encode'.
+	EncodingFailedSignal notifierString:'error during encode'.
 ]
 "
 CharacterArray initialize
 "
 |mySize nBytes newString dstIdx|
 nBytes := aByteCollection size.
 mySize := self basicNew bitsPerCharacter.
 mySize == 16 ifTrue:[
-newString := self basicNew:(nBytes // 2).
+	newString := self basicNew:(nBytes // 2).
-dstIdx := 1.
+	dstIdx := 1.
-aByteCollection pairWiseDo:[:hi :lo |
+	aByteCollection pairWiseDo:[:hi :lo |
-newString at:dstIdx put:(Character value:(hi bitShift:8)+lo).
+	    newString at:dstIdx put:(Character value:(hi bitShift:8)+lo).
-dstIdx := dstIdx + 1
+	    dstIdx := dstIdx + 1
-].
+	].
-^ newString.
+	^ newString.
 ].
 ^ (self basicNew:nBytes) replaceFrom:1 with:aByteCollection
 "
 |newString first|
 newString := ''.
 first := true.
 aCollectionOfStrings do:[:s |
 	first ifFalse:[
 	    newString := newString , aSeparatorString
 	] ifTrue:[
 	    first := false
 	].
 This only handles up-to 16bit characters"
 ^ self decodeFromUTF8:aByteCollection.
 "
 CharacterArray fromUTF8Bytes:#[ 16r41 16r42 ]
 CharacterArray fromUTF8Bytes:#[ 16rC1 16r02 ]
 CharacterArray fromUTF8Bytes:#[ 16rE0 16r81 16r02 ]
 CharacterArray fromUTF8Bytes:#[ 16rEF 16rBF 16rBF ]
 rfc2279 examples:
 CharacterArray fromUTF8Bytes:#[ 16r41 16rE2 16r89 16rA2 16rCE 16r91 16r2E ]
 CharacterArray fromUTF8Bytes:#[ 16rED 16r95 16r9C 16rEA 16rB5 16rAD 16rEC 16r96 16rB4 ]
 CharacterArray fromUTF8Bytes:#[ 16rE6 16r97 16rA5 16rE6 16r9C 16rAC 16rE8 16rAA 16r9E ]
 invalid:
 CharacterArray fromUTF8Bytes:#[ 16rC0 16r80 ]
 CharacterArray fromUTF8Bytes:#[ 16rE0 16r80 16r80 ]
 "
 !
 new
 "return a new empty string"
 This only handles up-to 16bit characters."
 ^ CharacterEncoderImplementations::ISO10646_to_UTF8 decodeString:aStringOrByteCollection
 "
 CharacterArray fromUTF8Bytes:#[ 16r41 16r42 ]
 CharacterArray fromUTF8Bytes:#[ 16rC1 16r02 ]
 CharacterArray fromUTF8Bytes:#[ 16rE0 16r81 16r02 ]
 CharacterArray fromUTF8Bytes:#[ 16rEF 16rBF 16rBF ]
 rfc2279 examples:
 CharacterArray fromUTF8Bytes:#[ 16r41 16rE2 16r89 16rA2 16rCE 16r91 16r2E ]
 CharacterArray fromUTF8Bytes:#[ 16rED 16r95 16r9C 16rEA 16rB5 16rAD 16rEC 16r96 16rB4 ]
 CharacterArray fromUTF8Bytes:#[ 16rE6 16r97 16rA5 16rE6 16r9C 16rAC 16rE8 16rAA 16r9E ]
 invalid:
 CharacterArray fromUTF8Bytes:#[ 16rC0 16r80 ]
 CharacterArray fromUTF8Bytes:#[ 16rE0 16r80 16r80 ]
 "
 ! !
 !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 }"
 mStop := matchStop.
 sStart := start.
 sStop := stop.
 [true] whileTrue:[
 "/ Transcript showCR:('match: ''' , (aString copyFrom:sStart to:sStop) ,
 "/                    ''' against:' , (matchScanArray copyFrom:mStart to:mStop) printString).
-mSize := mStop - mStart + 1.
+	mSize := mStop - mStart + 1.
-sSize := sStop - sStart + 1.
+	sSize := sStop - sStart + 1.
-"empty strings match"
+	"empty strings match"
-(mSize == 0) ifTrue:[^ (sSize == 0)].
+	(mSize == 0) ifTrue:[^ (sSize == 0)].
-matchEntry := matchScanArray at:mStart.
+	matchEntry := matchScanArray at:mStart.
-"/ the most common case first:
+	"/ the most common case first:
-(sSize ~~ 0
+	(sSize ~~ 0
-and:[(checkChar := (aString at:sStart)) = matchEntry]) ifTrue:[
+	and:[(checkChar := (aString at:sStart)) = matchEntry]) ifTrue:[
-"advance by one and continue"
+	    "advance by one and continue"
-mStart := mStart + 1.
+	    mStart := mStart + 1.
-sStart := sStart + 1
+	    sStart := sStart + 1
-] ifFalse:[
+	] ifFalse:[
-(matchEntry == #any) ifTrue:[
+	    (matchEntry == #any) ifTrue:[
-"restString empty -> no match"
+		"restString empty -> no match"
-(sSize == 0) ifTrue:[^ false].
+		(sSize == 0) ifTrue:[^ false].
-"# matches single character"
+		"# matches single character"
-((sSize == 1) and:[mSize == 1]) ifTrue:[^ true].
+		((sSize == 1) and:[mSize == 1]) ifTrue:[^ true].
-"advance by one and continue"
+		"advance by one and continue"
-mStart := mStart + 1.
+		mStart := mStart + 1.
-sStart := sStart + 1
+		sStart := sStart + 1
-] ifFalse:[
+	    ] ifFalse:[
-(matchEntry == #anyString) ifTrue:[
+		(matchEntry == #anyString) ifTrue:[
-"* alone matches anything"
+		    "* alone matches anything"
-(mSize == 1) ifTrue:[^ true].
+		    (mSize == 1) ifTrue:[^ true].
-"restString empty & matchString not empty -> no match"
+		    "restString empty & matchString not empty -> no match"
-(sSize == 0) ifTrue:[^ false].
+		    (sSize == 0) ifTrue:[^ false].
-"
+		    "
-try to avoid some of the recursion by checking last
+		     try to avoid some of the recursion by checking last
-character and continue with shortened strings if possible
+		     character and continue with shortened strings if possible
-"
+		    "
-quickCheck := false.
+		    quickCheck := false.
-(mStop >= mStart) ifTrue:[
+		    (mStop >= mStart) ifTrue:[
-matchLast := matchScanArray at:mStop.
+			matchLast := matchScanArray at:mStop.
-(matchLast ~~ #anyString) ifTrue:[
+			(matchLast ~~ #anyString) ifTrue:[
-(matchLast == #any) ifTrue:[
+			    (matchLast == #any) ifTrue:[
-quickCheck := true
+				quickCheck := true
-] ifFalse:[
+			    ] ifFalse:[
-matchLast == (aString at:sStop) ifTrue:[
+				matchLast == (aString at:sStop) ifTrue:[
-quickCheck := true
+				    quickCheck := true
-] ifFalse:[
+				] ifFalse:[
-matchLast isString ifTrue:[
+				    matchLast isString ifTrue:[
-quickCheck := matchLast includes:(aString at:sStop)
+					quickCheck := matchLast includes:(aString at:sStop)
-]
+				    ]
-]
+				]
-]
+			    ]
-]
+			]
-].
+		    ].
-quickCheck ifTrue:[
+		    quickCheck ifTrue:[
-"
+			"
-quickCheck ok, advance from the right
+			 quickCheck ok, advance from the right
-"
+			"
-mStop := mStop - 1.
+			mStop := mStop - 1.
-sStop := sStop - 1
+			sStop := sStop - 1
-] ifFalse:[
+		    ] ifFalse:[
-"/ no quick check;
+			"/ no quick check;
-"/ look for the next character(s)
+			"/ look for the next character(s)
-"/ and try matching there
+			"/ and try matching there
-"/ (to avoid recursion)
+			"/ (to avoid recursion)
-mStart < mStop ifTrue:[
+			mStart < mStop ifTrue:[
-nextMatchEntry := matchScanArray at:mStart+1.
+			    nextMatchEntry := matchScanArray at:mStart+1.
-nextMatchEntry isCharacter ifTrue:[
+			    nextMatchEntry isCharacter ifTrue:[
-sStart <= sStop ifTrue:[
+				sStart <= sStop ifTrue:[
-[true] whileTrue:[
+				    [true] whileTrue:[
-ignoreCase ifFalse:[
+					ignoreCase ifFalse:[
-index := aString indexOf:nextMatchEntry startingAt:sStart
+					    index := aString indexOf:nextMatchEntry startingAt:sStart
-] ifTrue:[
+					] ifTrue:[
-index := aString findFirst:[:c | c asLowercase = nextMatchEntry asLowercase]
+					    index := aString findFirst:[:c | c asLowercase = nextMatchEntry asLowercase]
-startingAt:sStart.
+							   startingAt:sStart.
-].
+					].
-(index == 0 or:[index > sStop]) ifTrue:[
+					(index == 0 or:[index > sStop]) ifTrue:[
-^ false
+					    ^ false
-].
+					].
-(self matchScan:matchScanArray
+					(self matchScan:matchScanArray
-from:(mStart + 1)
+					      from:(mStart + 1)
-to:mStop
+					      to:mStop
-with:aString
+					      with:aString
-from:index
+					      from:index
-to:sStop
+					      to:sStop
-ignoreCase:ignoreCase
+					      ignoreCase:ignoreCase
-) ifTrue:[
+					) ifTrue:[
-^ true
+					    ^ true
-].
+					].
-sStart := index + 1.
+					sStart := index + 1.
-]
+				    ]
-]
+				]
-]
+			    ]
-].
+			].
-"
+			"
-no quick check possible;
+			 no quick check possible;
-loop over all possible substrings
+			 loop over all possible substrings
-"
+			"
-index := sStart.
+			index := sStart.
-[index <= sStop] whileTrue:[
+			[index <= sStop] whileTrue:[
-(self matchScan:matchScanArray
+			    (self matchScan:matchScanArray
-from:(mStart + 1)
+				  from:(mStart + 1)
-to:mStop
+				  to:mStop
-with:aString
+				  with:aString
-from:index
+				  from:index
-to:sStop
+				  to:sStop
-ignoreCase:ignoreCase
+				  ignoreCase:ignoreCase
-) ifTrue:[
+			    ) ifTrue:[
-^ true
+				^ true
-].
+			    ].
-index := index + 1
+			    index := index + 1
-].
+			].
-^ false
+			^ false
-].
+		    ].
-] ifFalse:[
+		] ifFalse:[
-(matchEntry isString) ifTrue:[
+		    (matchEntry isString) ifTrue:[
-"testString empty -> no match"
+			"testString empty -> no match"
-(sSize == 0) ifTrue:[^ false].
+			(sSize == 0) ifTrue:[^ false].
-included := false.
+			included := false.
-"/ checkChar := aString at:sStart.
+			"/ checkChar := aString at:sStart.
-included := matchEntry includes:checkChar.
+			included := matchEntry includes:checkChar.
-included ifFalse:[
+			included ifFalse:[
-ignoreCase ifTrue:[
+			    ignoreCase ifTrue:[
-checkChar isUppercase ifTrue:[
+				checkChar isUppercase ifTrue:[
-included := matchEntry includes:checkChar asLowercase.
+				    included := matchEntry includes:checkChar asLowercase.
-] ifFalse:[
+				] ifFalse:[
-included := matchEntry includes:checkChar asUppercase.
+				    included := matchEntry includes:checkChar asUppercase.
-]
+				]
-].
+			    ].
-].
+			].
-mStart := mStart + 1.
+			mStart := mStart + 1.
-mSize := mSize - 1.
+			mSize := mSize - 1.
-included ifFalse:[^ false].
+			included ifFalse:[^ false].
-((sSize == 1) and:[mSize == 0]) ifTrue:[^ true].
+			((sSize == 1) and:[mSize == 0]) ifTrue:[^ true].
-"cut off 1st char and continue"
+			"cut off 1st char and continue"
-sStart := sStart + 1
+			sStart := sStart + 1
-] ifFalse:[
+		    ] ifFalse:[
-"/ must be single character
+			"/ must be single character
-"testString empty ?"
+			"testString empty ?"
-(sSize == 0) ifTrue:[^ false].
+			(sSize == 0) ifTrue:[^ false].
-"first characters equal ?"
+			"first characters equal ?"
-"/ checkChar := aString at:sStart.
+			"/ checkChar := aString at:sStart.
-ignoreCase ifFalse:[^ false].
+			ignoreCase ifFalse:[^ false].
-(checkChar asUppercase ~= matchEntry asUppercase) ifTrue:[^ false].
+			(checkChar asUppercase ~= matchEntry asUppercase) ifTrue:[^ false].
-"advance and continue"
+			"advance and continue"
-mStart := mStart + 1.
+			mStart := mStart + 1.
-sStart := sStart + 1
+			sStart := sStart + 1
-]
+		    ]
-]
+		]
-]
+	    ]
-]
+	]
 ].
 "
 |scanArray s|
 scanArray := self matchScanArrayFrom:'*hello'.
 s := 'foo bar hello world'.
 CharacterArray
-matchScan:scanArray
+	 matchScan:scanArray
-from:1
+	 from:1
-to:scanArray size
+	 to:scanArray size
-with:s
+	 with:s
-from:1
+	 from:1
-to:s size
+	 to:s size
-ignoreCase:false
+	 ignoreCase:false
 "
 "
 |scanArray s|
 scanArray := self matchScanArrayFrom:'*hello*'.
 s := 'foo bar hello world'.
 CharacterArray
-matchScan:scanArray
+	 matchScan:scanArray
-from:1
+	 from:1
-to:scanArray size
+	 to:scanArray size
-with:s
+	 with:s
-from:1
+	 from:1
-to:s size
+	 to:s size
-ignoreCase:false
+	 ignoreCase:false
 "
 "Modified: / 15.10.1998 / 13:39:25 / cg"
 !
 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 escape|
 previous := nil.
 escape := self matchEscapeCharacter.
 coll := OrderedCollection new.
 idx := 1. end := aString size.
 [idx <= end] whileTrue:[
-|char this|
+	|char this|
-char := aString at:idx.
+	char := aString at:idx.
-char == $* ifTrue:[
+	char == $* ifTrue:[
-previous ~~ #anyString ifTrue:[
+	    previous ~~ #anyString ifTrue:[
-this := #anyString
+		this := #anyString
-]
+	    ]
-] ifFalse:[
+	] ifFalse:[
-char == $# ifTrue:[
+	    char == $# ifTrue:[
-previous ~~ #anyString ifTrue:[
+		previous ~~ #anyString ifTrue:[
-this := #any
+		    this := #any
-]
+		]
-] ifFalse:[
+	    ] ifFalse:[
-char == $[ ifTrue:[
+		char == $[ ifTrue:[
-matchSet := IdentitySet new.
+		    matchSet := IdentitySet new.
-idx := idx + 1.
+		    idx := idx + 1.
-idx > end ifTrue:[^ nil].
+		    idx > end ifTrue:[^ nil].
-char := aString at:idx.
+		    char := aString at:idx.
-c1 := nil.
+		    c1 := nil.
-[char ~~ $]] whileTrue:[
+		    [char ~~ $]] whileTrue:[
-((char == $-) and:[c1 notNil]) ifTrue:[
+			((char == $-) and:[c1 notNil]) ifTrue:[
-idx := idx + 1.
+			    idx := idx + 1.
-idx > end ifTrue:[^ nil].
+			    idx > end ifTrue:[^ nil].
-c2 := aString at:idx.
+			    c2 := aString at:idx.
-c1 to:c2 do:[:c | matchSet add:c].
+			    c1 to:c2 do:[:c | matchSet add:c].
-c1 := nil.
+			    c1 := nil.
-idx := idx + 1.
+			    idx := idx + 1.
-] ifFalse:[
+			] ifFalse:[
-(char ~~ $]) ifTrue:[
+			    (char ~~ $]) ifTrue:[
-matchSet add:char.
+				matchSet add:char.
-c1 := char.
+				c1 := char.
-idx := idx + 1
+				idx := idx + 1
-]
+			    ]
-].
+			].
-idx > end ifTrue:[^ nil].
+			idx > end ifTrue:[^ nil].
-char := aString at:idx
+			char := aString at:idx
-].
+		    ].
-this := matchSet asString
+		    this := matchSet asString
-] ifFalse:[
+		] ifFalse:[
-char == escape ifTrue:[
+		    char == escape ifTrue:[
-idx := idx + 1.
+			idx := idx + 1.
-idx > end ifTrue:[
+			idx > end ifTrue:[
-"/ mhmh - what should we do here ?
+			    "/ mhmh - what should we do here ?
-this := char
+			    this := char
-] ifFalse:[
+			] ifFalse:[
-this := aString at:idx.
+			    this := aString at:idx.
-]
+			]
-] ifFalse:[
+		    ] ifFalse:[
-this := char
+			this := char
-]
+		    ]
-]
+		]
-]
+	    ]
-].
+	].
-this notNil ifTrue:[coll add:this. previous := this].
+	this notNil ifTrue:[coll add:this. previous := this].
-idx := idx + 1
+	idx := idx + 1
 ].
 ^ coll asArray
 "
 String matchScanArrayFrom:'*ute*'
 String matchScanArrayFrom:'**ute**'
 String matchScanArrayFrom:'*uter'
 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]'
 "
 "Modified: 2.4.1997 / 16:20:29 / cg"
 ! !
 |ds|
 ds := WriteStream on:(self species new).
 self do:[:eachChar |
-|repl|
+	|repl|
-repl := expandTable at:eachChar ifAbsent:nil.
+	repl := expandTable at:eachChar ifAbsent:nil.
-repl isNil ifTrue:[
+	repl isNil ifTrue:[
-ds nextPut:eachChar
+	    ds nextPut:eachChar
-] ifFalse:[
+	] ifFalse:[
-repl size == 0 ifTrue:[
+	    repl size == 0 ifTrue:[
-ds nextPut:repl
+		ds nextPut:repl
-] ifFalse:[
+	    ] ifFalse:[
-ds nextPutAll:repl
+		ds nextPutAll:repl
-]
+	    ]
-].
+	].
 ].
 ^ ds contents.
 !
 formatWith:aString
 "/    ].
 ^ super at:index put:(Character value:aByte)
 "
 'hello' copy at:1 put:$H asciiValue; yourself
 'hello' copy byteAt:1 put:72; yourself
 'hello' copy byteAt:1 put:0; yourself
 "
 "Modified: 6.5.1996 / 10:35:26 / cg"
 !
 This is an ST/V compatibility method."
 ^ self copyReplaceAll:oldChar with:newChar
 "
 '12345678901234567890' replChar:$0 with:$*
 "
 "Modified: / 18.7.1998 / 22:52:57 / cg"
 !
 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 '
 "
 !
 replString:subString withString:newString
 "return a copy of the receiver, with all sequences of subString replaced
 by newString (i.e. slice in the newString in place of the oldString)."
 ^ self copyReplaceString:subString withString:newString
 "
 '12345678901234567890' replString:'123' withString:'OneTwoThree'
 '12345678901234567890' replString:'123' withString:'*'
 '12345678901234567890' replString:'234' withString:'foo'
 ('a string with spaces' replChar:$  withString:' foo ')
-replString:'foo' withString:'bar'
+	replString:'foo' withString:'bar'
 "
 "Modified: / 12-05-2004 / 12:00:27 / cg"
 !
 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-Squeak'!
 "Many allowed forms, see Date.readFrom:"
 ^ Date readFrom: (ReadStream on: self)
 "
 '30 Apr 1999' asDate dayName capitalized
 "
 !
 capitalized
 ^ self asUppercaseFirst
 "
 !
 displayProgressAt:aPointOrNil from:start to:stop during:aBlock
 ProgressIndicator
-displayProgress:self
+	displayProgress:self
-at:aPointOrNil
+	at:aPointOrNil
-from:start
+	from:start
-to:stop
+	to:stop
-during:aBlock.
+	during:aBlock.
 "
 'dobedobedoobedoo'
-displayProgressAt:(Screen current center)
+	displayProgressAt:(Screen current center)
-from:0 to:100
+	from:0 to:100
-during:[:val |
+	during:[:val |
-0 to:100 do:[:i |
+		0 to:100 do:[:i |
-val value:i.
+		    val value:i.
-Delay waitForSeconds:0.05.
+		    Delay waitForSeconds:0.05.
-]
+		]
-]
+	       ]
 "
 !
 endsWithDigit
 "Answer whether the receiver's final character represents a digit.  3/11/96 sw"
 "cg: I am not sure, if this is really the squeak semantics (w.r.t. empty fields)"
 ^ self asCollectionOfSubstringsSeparatedByAny:delimiters
 "
 'a|b#c||e' findTokens:#($# $|)
 "
 !
 includesSubString:aString
 "return true, if a substring is contained in the receiver.
 The compare is case sensitive."
 ^ self includesString:aString
 "
 'hello world' includesSubString:'Hel'
 'hello world' includesSubString:'hel'
 'hello world' includesSubString:'llo'
 "
 !
 The argument, caseSensitive controls if case is ignored in the compare."
 "/ for now,  a q&d hack ...
 caseSensitive ifFalse:[
-^ self asLowercase includesString:aString asLowercase
+	^ self asLowercase includesString:aString asLowercase
 ].
 ^ self includesString:aString
 "
 'hello world' includesSubstring:'Hel' caseSensitive:true
 'hello world' includesSubstring:'Hel' caseSensitive:false
 "
 !
 ^ self lastIndexOfSeparator
 !
 padded:leftOrRight to:paddedSize with:padCharacter
 leftOrRight == #left ifTrue:[
-^ self leftPaddedTo:paddedSize with:padCharacter
+	^ self leftPaddedTo:paddedSize with:padCharacter
 ].
 ^ self paddedTo:paddedSize with:padCharacter
 "
 'hello' padded:#right to:10 with:$.
 'hello' padded:#left to:10 with:$.
 "
 !
 skipDelimiters:delimiters startingAt:start
 "Answer the index of the character within the receiver, starting at start,
 that does NOT match one of the delimiters.
 If the receiver does not contain any of the delimiters, answer size + 1.
 Assumes the delimiters to be a non-empty string."
 start to:self size do:[:i |
-delimiters detect:[:delim | delim = (self at:i) ] ifNone:[ ^ i ]
+	delimiters detect:[:delim | delim = (self at:i) ] ifNone:[ ^ i ]
 ].
 ^ self size + 1
 "
 '123***7890' skipDelimiters:'*' startingAt:4
 '123***7890' skipDelimiters:'*' startingAt:3
 '123***7890' skipDelimiters:'*' startingAt:10
 '123*******' skipDelimiters:'*' startingAt:10
 "
 !
 substrings
 ^ self asCollectionOfWords
 self size <= smallSize ifTrue:[^ self].
 ^ self copyFrom: 1 to: smallSize
 "
 'hello world' truncateTo:5
 'hello' truncateTo:10
 'hello world' copyTo:5
 'hello' copyTo:10
 "
 !
 withBlanksTrimmed
 "Return a copy of the receiver from which leading and trailing blanks have been trimmed."
 ^ self withoutSpaces
 "
 '  hello    world    ' withBlanksTrimmed
 "
 !
 aNumber isNumber not | (aNumber < 1) ifTrue: [self error: 'too narrow'].
 listOfLines _ OrderedCollection new.
 currentLast _ 0.
 [currentLast < self size] whileTrue:
-[currentStart _ currentLast + 1.
+	    [currentStart _ currentLast + 1.
-putativeLast _ (currentStart + aNumber - 1) min: self size.
+	    putativeLast _ (currentStart + aNumber - 1) min: self size.
-putativeLine _ self copyFrom: currentStart to: putativeLast.
+	    putativeLine _ self copyFrom: currentStart to: putativeLast.
-(crPosition _ putativeLine indexOf: Character cr) > 0 ifTrue:
+	    (crPosition _ putativeLine indexOf: Character cr) > 0 ifTrue:
-[putativeLast _ currentStart + crPosition - 1.
+		    [putativeLast _ currentStart + crPosition - 1.
-putativeLine _ self copyFrom: currentStart to: putativeLast].
+		    putativeLine _ self copyFrom: currentStart to: putativeLast].
-currentLast _ putativeLast == self size
+	    currentLast _ putativeLast == self size
-ifTrue:
+		    ifTrue:
-[putativeLast]
+			    [putativeLast]
-ifFalse:
+		    ifFalse:
-[currentStart + putativeLine lastSpacePosition - 1].
+			    [currentStart + putativeLine lastSpacePosition - 1].
-currentLast <= currentStart ifTrue:
+	    currentLast <= currentStart ifTrue:
-["line has NO spaces; baleout!!"
+		    ["line has NO spaces; baleout!!"
-currentLast _ putativeLast].
+		    currentLast _ putativeLast].
-listOfLines add: (self copyFrom: currentStart to: currentLast) withBlanksTrimmed].
+	    listOfLines add: (self copyFrom: currentStart to: currentLast) withBlanksTrimmed].
 listOfLines size > 0 ifFalse: [^ ''].
 resultString _ listOfLines first.
 2 to: listOfLines size do:
-[:i | resultString _ resultString, Character cr asString, (listOfLines at: i)].
+	    [:i | resultString _ resultString, Character cr asString, (listOfLines at: i)].
 ^ resultString
 "
 #(5 7 20) collect:
-[:i | 'Fred the bear went down to the brook to read his book in silence' withNoLineLongerThan: i]
+	[:i | 'Fred the bear went down to the brook to read his book in silence' withNoLineLongerThan: i]
 "
 ! !
 bindWith:str1 with:str2 with:str3 with:str4 with:str5 with:str6
 "return a copy of the receiver, where a '%1' .. '%6' escapes
 are replaced by str1 .. str5 respectively.
 This has been added for VisualAge compatibility."
 ^ self expandPlaceholdersWith:(Array with:str1 with:str2
-with:str3 with:str4
+					 with:str3 with:str4
-with:str5 with:str6)
+					 with:str5 with:str6)
 !
 bindWithArguments:anArrayOfStrings
 "return a copy of the receiver, where a '%i' escape
 in := self readStream.
 out := WriteStream on:(String uninitializedNew:self size).
 [in atEnd] whileFalse:[
-c := in next.
+	c := in next.
-c == $% ifTrue:[
+	c == $% ifTrue:[
-c := in next.
+	    c := in next.
-out nextPut:c
+	    out nextPut:c
-] ifFalse:[
+	] ifFalse:[
-c == $< ifTrue:[
+	    c == $< ifTrue:[
-[in peek == $<] whileTrue:[
+		[in peek == $<] whileTrue:[
-out nextPut:$<.
+		    out nextPut:$<.
-in next.
+		    in next.
-].
+		].
-in peek == $n ifTrue:[
+		in peek == $n ifTrue:[
-out nextPut:Character cr.
+		    out nextPut:Character cr.
-in next
+		    in next
-] ifFalse:[in peek == $t ifTrue:[
+		] ifFalse:[in peek == $t ifTrue:[
-out nextPut:Character tab.
+		    out nextPut:Character tab.
-in next
+		    in next
-] ifFalse:[
+		] ifFalse:[
-in peek isDigit ifFalse:[
+		    in peek isDigit ifFalse:[
-nr := 1
+			nr := 1
-] ifTrue:[
+		    ] ifTrue:[
-"/ start an argument expansion ...
+			"/ start an argument expansion ...
-nr := Integer readFrom:in onError:nil.
+			nr := Integer readFrom:in onError:nil.
-nr isNil ifTrue:[
+			nr isNil ifTrue:[
-"/ what does VW do here ?
+			    "/ what does VW do here ?
-self error:'invalid format' mayProceed:true.
+			    self error:'invalid format' mayProceed:true.
-^ self
+			    ^ self
-].
+			].
-(nr between:1 and:argArray size) ifFalse:[
+			(nr between:1 and:argArray size) ifFalse:[
-"/ what does VW do here ?
+			    "/ what does VW do here ?
-self error:'invalid format - bad argNr' mayProceed:true.
+			    self error:'invalid format - bad argNr' mayProceed:true.
-^ self
+			    ^ self
-].
+			].
-].
+		    ].
-arg := argArray at:nr.
+		    arg := argArray at:nr.
-fmt := in next.
+		    fmt := in next.
-(fmt == $p) ifTrue:[
+		    (fmt == $p) ifTrue:[
-"/ expand with args printString
+			"/ expand with args printString
-out nextPutAll:arg printString.
+			out nextPutAll:arg printString.
-] ifFalse:[ (fmt == $s) ifTrue:[
+		    ] ifFalse:[ (fmt == $s) ifTrue:[
-"/ expand with arg itself
+			"/ expand with arg itself
-arg isText ifTrue:[
+			arg isText ifTrue:[
-out := (WriteStream on:(Text new)) nextPutAll:(out contents); yourself.
+			    out := (WriteStream on:(Text new)) nextPutAll:(out contents); yourself.
-out nextPutAll:arg asText.
+			    out nextPutAll:arg asText.
-] ifFalse:[
+			] ifFalse:[
-out nextPutAll:arg asString string.
+			    out nextPutAll:arg asString string.
-]
+			]
-] ifFalse:[ (fmt == $?) ifTrue:[
+		    ] ifFalse:[ (fmt == $?) ifTrue:[
-s1 := in upTo:$:.
+			s1 := in upTo:$:.
-s2 := in nextUpTo:$>.
+			s2 := in nextUpTo:$>.
-arg ifTrue:[
+			arg ifTrue:[
-out nextPutAll:s1
+			    out nextPutAll:s1
-] ifFalse:[
+			] ifFalse:[
-out nextPutAll:s2
+			    out nextPutAll:s2
-].
+			].
-] ifFalse:[
+		    ] ifFalse:[
-"/ what does VW do here ?
+			"/ what does VW do here ?
-self error:'invalid format' mayProceed:true.
+			self error:'invalid format' mayProceed:true.
-^ self
+			^ self
-]]].
+		    ]]].
-]].
+		]].
-c := in next.
+		c := in next.
-c ~~ $> ifTrue:[
+		c ~~ $> ifTrue:[
-"/ what does VW do here ?
+		    "/ what does VW do here ?
-self error:'invalid format' mayProceed:true.
+		    self error:'invalid format' mayProceed:true.
-^ self
+		    ^ self
-]
+		]
-] ifFalse:[
+	    ] ifFalse:[
-out nextPut:c
+		out nextPut:c
-]
+	    ]
-].
+	].
 ].
 ^ out contents
 "
 'hello <1s> how are you' expandMacrosWith:(OperatingSystem getLoginName)
 'one plus one is <1p>' expandMacrosWith:2
 "
 "Modified: / 18.6.1998 / 16:04:46 / cg"
 !
 ! !
 !CharacterArray methodsFor:'character searching'!
 includesMatchCharacters
 "return true if the receiver includes any meta characters (i.e. $* or $#)
 for match operations; false if not.
 Here, do not care for $\ escapes"
 ^ self includesAny:'*#['
 "
 '*foo' includesMatchCharacters
 '\*foo' includesMatchCharacters
 '\*foo' includesUnescapedMatchCharacters
 '*foo' includesMatchCharacters
 '\\*foo' includesMatchCharacters
 'foo*' includesMatchCharacters
 'foo\*' includesMatchCharacters
 'foo\' includesMatchCharacters
 "
 "return true, if the receiver contains any whitespace characters"
 ^ (self indexOfSeparator ~~ 0)
 "
 'hello world' includesSeparator
 'helloworld' includesSeparator
 "
 !
 includesUnescapedMatchCharacters
 "return true if the receiver really includes any meta characters (i.e. $* or $#)
 for match operations; false if not.
 Here, care for $\ escapes"
 |idx sz specialChars escape|
 idx := 1.
 sz := self size.
 specialChars := '*#[\'.
 (escape := self class matchEscapeCharacter) ~~ $\ ifTrue:[
-specialChars := specialChars copy.
+	specialChars := specialChars copy.
-specialChars at:specialChars size put:escape
+	specialChars at:specialChars size put:escape
 ].
 [true] whileTrue:[
-idx := self indexOfAny:specialChars startingAt:idx.
+	idx := self indexOfAny:specialChars startingAt:idx.
-idx == 0 ifTrue:[^ false].
+	idx == 0 ifTrue:[^ false].
-(self at:idx) == escape ifFalse:[^ true].
+	(self at:idx) == escape ifFalse:[^ true].
-idx := idx + 2.
+	idx := idx + 2.
-idx > sz ifTrue:[^ false].
+	idx > sz ifTrue:[^ false].
 ].
 "
 '*foo' includesUnescapedMatchCharacters
 '\*foo' includesUnescapedMatchCharacters
 '\\foo' includesUnescapedMatchCharacters
 '\\\$foo' includesUnescapedMatchCharacters
 '*foo' includesUnescapedMatchCharacters
 '\\*foo' includesUnescapedMatchCharacters
 'foo*' includesUnescapedMatchCharacters
 'foo\*' includesUnescapedMatchCharacters
 'foo\' includesUnescapedMatchCharacters
 start := startIndex.
 mySize := self size.
 start to:mySize do:[:index |
-(self at:index) isControlCharacter ifTrue:[^ index]
+	(self at:index) isControlCharacter ifTrue:[^ index]
 ].
 ^ 0
 "
 'hello world' asTwoByteString            indexOfControlCharacterStartingAt:1
 return 0 if no non-separator was found"
 ^ self indexOfNonSeparatorStartingAt:1.
 "
 '    hello world' indexOfNonSeparator
 '    ' indexOfNonSeparator
 'a   ' indexOfNonSeparator
 'abc' indexOfNonSeparator
 ' ' indexOfNonSeparator
 '' indexOfNonSeparator
 "
 !
 indexOfNonSeparatorStartingAt:startIndex
 "return the index of the next non-whitespace character,
 start := startIndex.
 mySize := self size.
 start to:mySize do:[:index |
-(self at:index) isSeparator ifFalse:[^ index]
+	(self at:index) isSeparator ifFalse:[^ index]
 ].
 ^ 0
 "
 '    hello world' indexOfNonSeparatorStartingAt:1
 '    ' indexOfNonSeparatorStartingAt:1
 'a   ' indexOfNonSeparatorStartingAt:2
 "
 "
 |s index1 index2|
 s := '   foo    bar      baz'.
 return 0 if no separator was found"
 ^ self indexOfSeparatorStartingAt:1
 "
 'hello world' indexOfSeparator
 'helloworld' indexOfSeparator
 'hello   ' indexOfSeparator
 '   hello' indexOfSeparator
 "
 !
 indexOfSeparatorStartingAt:startIndex
 "return the index of the next whitespace character,
 start := startIndex.
 mySize := self size.
 start to:mySize do:[:index |
-(self at:index) isSeparator ifTrue:[^ index]
+	(self at:index) isSeparator ifTrue:[^ index]
 ].
 ^ 0
 "
 'hello world' indexOfSeparatorStartingAt:3
 ' hello world' indexOfSeparatorStartingAt:3
 'hello world ' indexOfSeparatorStartingAt:3
 'hello world ' indexOfSeparatorStartingAt:6
 'hello world ' indexOfSeparatorStartingAt:7
 'helloworld ' indexOfSeparatorStartingAt:7
 'helloworld' indexOfSeparatorStartingAt:7
 "
 !
 lastIndexOfSeparator
 "return the last index of the whitespace character.
 Returns 0 if no separator is found."
 ^ self lastIndexOfSeparatorStartingAt:(self size)
 "
 'hello world' lastIndexOfSeparator
 'helloworld' lastIndexOfSeparator
 'hel lo wor ld' lastIndexOfSeparator
 'hel   ' lastIndexOfSeparator 6
 "
 !
 lastIndexOfSeparatorStartingAt:startIndex
 "return the index of the previous whitespace character,
 |start  "{ Class: SmallInteger }"|
 start := startIndex.
 start to:1 by:-1 do:[:index |
-(self at:index) isSeparator ifTrue:[^ index]
+	(self at:index) isSeparator ifTrue:[^ index]
 ].
 ^ 0
 "
 'hello world' lastIndexOfSeparatorStartingAt:3
 'hello world' lastIndexOfSeparatorStartingAt:7
 'helloworld' lastIndexOfSeparatorStartingAt:7
 ' helloworld' lastIndexOfSeparatorStartingAt:7
 "
 ! !
 !CharacterArray methodsFor:'comparing'!
 < aString
 "Compare the receiver with the argument and return true if the
 receiver is greater than the argument. Otherwise return false.
 This comparison is based on the elements ascii code -
 i.e. upper/lowercase & upper/lowercase & national characters are NOT treated specially."
 |mySize    "{ Class: SmallInteger }"
 otherSize "{ Class: SmallInteger }"
 n         "{ Class: SmallInteger }"
 c1 c2|
 mySize := self size.
 otherSize := aString string size.
 n := mySize min:otherSize.
 1 to:n do:[:index |
-c1 := self at:index.
+	c1 := self at:index.
-c2 := aString at:index.
+	c2 := aString at:index.
-(c1 == c2 or:[c1 = c2]) ifFalse:[^ c1 < c2].
+	(c1 == c2 or:[c1 = c2]) ifFalse:[^ c1 < c2].
 ].
 ^ mySize < otherSize
 !
 = aString
 "Compare the receiver with the argument and return true if the
 receiver is equal to the argument. Otherwise return false.
 This compare does NOT ignore case differences,
 therefore 'foo' = 'Foo' will return false.
 Since this is incompatible to ST-80 (at least, V2.x) , this may change."
 |mySize    "{ Class: SmallInteger }"
 otherSize |
 (aString isString or:[aString species == self species]) ifFalse:[
-^ false
+	^ false
 ].
 mySize := self size.
 otherSize := aString size.
 mySize == otherSize ifFalse:[^ false].
 1 to:mySize do:[:index |
-(self at:index) = (aString at:index) ifFalse:[^ false].
+	(self at:index) = (aString at:index) ifFalse:[^ false].
 ].
 ^ true
 "
 'foo' = 'Foo'
 'foo' = 'bar'
 'foo' = 'foo'
 'foo' = 'foo' asText
 'foo' asText = 'foo'
 'foo' asText = 'foo' asText
 "
 "Modified: 22.4.1996 / 15:53:58 / cg"
 !
 > aString
 "Compare the receiver with the argument and return true if the
 receiver is greater than the argument. Otherwise return false.
 This comparison is based on the elements ascii code -
 i.e. upper/lowercase & upper/lowercase & national characters are NOT treated specially."
 |mySize    "{ Class: SmallInteger }"
 otherSize "{ Class: SmallInteger }"
 n         "{ Class: SmallInteger }"
 c1 c2|
 mySize := self size.
 otherSize := aString string size.
 n := mySize min:otherSize.
 1 to:n do:[:index |
-c1 := self at:index.
+	c1 := self at:index.
-c2 := aString at:index.
+	c2 := aString at:index.
-(c1 == c2 or:[c1 = c2]) ifFalse:[^ c1 > c2].
+	(c1 == c2 or:[c1 = c2]) ifFalse:[^ c1 > c2].
 ].
 ^ mySize > otherSize
 "Modified: 22.4.1996 / 15:55:00 / cg"
 !
 compareCaselessWith:aString
 "Compare the receiver against the argument, ignoreing case.
 Return 1 if the receiver is greater, 0 if equal and -1 if less than the argument.
 This comparison is based on the elements ascii code -
 i.e. national characters are NOT treated specially.
 'foo' compareWith: 'Foo' will return 0"
 |mySize    "{ Class: SmallInteger }"
 otherSize "{ Class: SmallInteger }"
 n         "{ Class: SmallInteger }"
 c1 c2|
 mySize := self size.
 otherSize := aString string size.
 n := mySize min:otherSize.
 1 to:n do:[:index |
-c1 := (self at:index) asLowercase.
+	c1 := (self at:index) asLowercase.
-c2 := (aString at:index) asLowercase.
+	c2 := (aString at:index) asLowercase.
-c1 > c2 ifTrue:[^ 1].
+	c1 > c2 ifTrue:[^ 1].
-c1 < c2 ifTrue:[^ -1].
+	c1 < c2 ifTrue:[^ -1].
 ].
 mySize > otherSize ifTrue:[^ 1].
 mySize < otherSize ifTrue:[^ -1].
 ^ 0
 "Modified: 22.4.1996 / 15:56:07 / cg"
 !
 compareWith:aString
 "Compare the receiver with the argument and return 1 if the receiver is
 greater, 0 if equal and -1 if less than the argument.
 This comparison is based on the elements ascii code -
 i.e. upper/lowercase & national characters are NOT treated specially.
 'foo' compareWith: 'Foo' will return 1.
 while 'foo' sameAs:'Foo' will return true"
 |mySize    "{ Class: SmallInteger }"
 otherSize "{ Class: SmallInteger }"
 n         "{ Class: SmallInteger }"
 c1 c2|
 mySize := self size.
 otherSize := aString string size.
 n := mySize min:otherSize.
 1 to:n do:[:index |
-c1 := self at:index.
+	c1 := self at:index.
-c2 := aString at:index.
+	c2 := aString at:index.
-c1 > c2 ifTrue:[^ 1].
+	c1 > c2 ifTrue:[^ 1].
-c1 < c2 ifTrue:[^ -1].
+	c1 < c2 ifTrue:[^ -1].
 ].
 mySize > otherSize ifTrue:[^ 1].
 mySize < otherSize ifTrue:[^ -1].
 ^ 0
 int l;
 cp = __stringVal(self);
 l = __stringSize(self);
 if (__qClass(self) != @global(String)) {
-int n = __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(self))->c_ninstvars));
+	int n = __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(self))->c_ninstvars));
-cp += n;
+	cp += n;
-l -= n;
+	l -= n;
 }
 /*
 * this is the dragon-book algorithm
 */
 val = 0;
 switch (l) {
 default:
-for (cp0 = cp, cp += l - 1; cp >= cp0; cp--) {
+	for (cp0 = cp, cp += l - 1; cp >= cp0; cp--) {
-val = (val << 4) + *cp;
+	    val = (val << 4) + *cp;
-if (g = (val & 0xF0000000)) {
+	    if (g = (val & 0xF0000000)) {
-val ^= g >> 24;
+		val ^= g >> 24;
-val ^= g;
+		val ^= g;
-}
+	    }
-}
+	}
-break;
+	break;
 case 7:
-val = cp[6] << 4;
+	val = cp[6] << 4;
 case 6:
-val = (val + cp[5]) << 4;
+	val = (val + cp[5]) << 4;
 case 5:
-val = (val + cp[4]) << 4;
+	val = (val + cp[4]) << 4;
 case 4:
-val = (val + cp[3]) << 4;
+	val = (val + cp[3]) << 4;
 case 3:
-val = (val + cp[2]) << 4;
+	val = (val + cp[2]) << 4;
 case 2:
-val = (val + cp[1]) << 4;
+	val = (val + cp[1]) << 4;
 case 1:
-val = val + cp[0];
+	val = val + cp[0];
 case 0:
-break;
+	break;
 }
 /*
 * multiply by large prime to spread values
 * This speeds up Set and Dictionary by a factor of 10!
 %}
 !
 sameAs:aString
 "Compare the receiver with the argument like =, but ignore case differences.
 Return true or false."
 |mySize "{ Class: SmallInteger }"
 otherSize c1 c2|
 mySize := self size.
 otherSize := aString string size.
 mySize == otherSize ifFalse:[^ false].
 1 to:mySize do:[:index |
-c1 := self at:index.
+	c1 := self at:index.
-c2 := aString at:index.
+	c2 := aString at:index.
-c1 == c2 ifFalse:[
+	c1 == c2 ifFalse:[
-(c1 sameAs:c2) ifFalse:[^ false].
+	    (c1 sameAs:c2) ifFalse:[^ false].
-]
+	]
 ].
 ^ true
 "
 'foo' sameAs: 'Foo'
 'foo' sameAs: 'bar'
 'foo' sameAs: 'foo'
 "
 "Modified: 22.4.1996 / 15:56:17 / cg"
 !
 "Compare the receiver with the argument.
 If ignoreCase is true, this is the same as #sameAs:,
 if false, this is the same as #=."
 ignoreCase ifTrue:[
-^ self sameAs:aString
+	^ self sameAs:aString
 ].
 ^ self = aString
 "
 'foo' sameAs:'Foo' ignoreCase:false
 'foo' sameAs:'foo' ignoreCase:true
 "
 !
 sameCharacters:aString
 n := self size.
 n := n min:(aString string size).
 cnt := 0.
 1 to:n do:[:index |
-c1 := self at:index.
+	c1 := self at:index.
-c2 := aString at:index.
+	c2 := aString at:index.
-((c1 == c2)
+	((c1 == c2)
-or:[c1 asLowercase = c2 asLowercase]) ifTrue:[
+	or:[c1 asLowercase = c2 asLowercase]) ifTrue:[
-cnt := cnt + 1
+	    cnt := cnt + 1
-]
+	]
 ].
 ^ cnt
 "
 'foobarbaz' sameCharacters: 'foo'
 'foobarbaz' sameCharacters: 'Foo'
 'foobarbaz' sameCharacters: 'baz'
 "
 !
 sameEmphasisAs:aStringOrText
 "compare the receivers and the arguments emphasis"
 ^ self emphasis = aStringOrText emphasis
 "
 'hello' asText sameEmphasisAs: 'hello'
 'hello' asText sameEmphasisAs: 'hello' asText
 'hello' asText allBold sameEmphasisAs: 'hello'
 'hello' asText allBold sameEmphasisAs: 'fooba' asText allBold
 'hello' asText allBold sameEmphasisAs: 'fooba' asText allItalic
 "
 !
 (self string = aStringOrText string) ifFalse:[^ false].
 self hasChangeOfEmphasis = aStringOrText hasChangeOfEmphasis ifFalse:[^ false].
 ^ self emphasis = aStringOrText emphasis
 "
 'hello' asText sameEmphasisAs: 'hello'
 'hello' asText sameEmphasisAs: 'hello' asText
 'hello' asText allBold sameEmphasisAs: 'hello'
 'hello' asText allBold sameEmphasisAs: 'fooba' asText allBold
 'hello' asText allBold sameEmphasisAs: 'fooba' asText allItalic
 'hello' sameEmphasisAs: 'hello' asText
 'hello' sameEmphasisAs: 'hello' asText allBold
 'hello' sameEmphasisAs: 'fooba'
 'hello' sameEmphasisAs: 'fooba' asText
 'hello' sameEmphasisAs: 'fooba' asText allBold
 'hello' sameEmphasisAs: 'fooba' asText allItalic
 'hello' asText sameStringAndEmphasisAs: 'hello'
 'hello' asText sameStringAndEmphasisAs: 'hello' asText
 'hello' asText allBold sameStringAndEmphasisAs: 'hello'
 'hello' asText allBold sameStringAndEmphasisAs: 'fooba' asText allBold
 'hello' asText allBold sameStringAndEmphasisAs: 'fooba' asText allItalic
 'hello' sameStringAndEmphasisAs: 'hello' asText
 'hello' sameStringAndEmphasisAs: 'hello' asText allBold
 'hello' sameStringAndEmphasisAs: 'fooba'
 'hello' sameStringAndEmphasisAs: 'fooba' asText
 'hello' sameStringAndEmphasisAs: 'fooba' asText allBold
 'hello' sameStringAndEmphasisAs: 'fooba' asText allItalic
 "
 ! !
 !CharacterArray methodsFor:'converting'!
 asCollectionOfWords."
 ^ self asCollectionOfWords asArray
 "
 '1 one two three four 5 five' asArrayOfSubstrings
 '1
 one
-two three four 5 five' asArrayOfSubstrings
+	two three four 5 five' asArrayOfSubstrings
 "
 !
 asCollectionOfLines
 "return a collection containing the lines (separated by cr)
 of the receiver. If multiple cr's occur in a row, the result will
 contain empty strings."
 ^ self asCollectionOfSubstringsSeparatedBy:Character cr
 "
 '1 one\2 two\3 three\4 four\5 five' withCRs asCollectionOfLines
 '1 one\\\\2 two\3 three' withCRs asCollectionOfLines
 "
 !
 asCollectionOfSubstringsSeparatedBy:aCharacter
 "return a collection containing the lines (separated by aCharacter)
 of the receiver. If aCharacter occurs multiple times in a row,
 the result will contain empty strings."
 ^ self asCollectionOfSubCollectionsSeparatedBy:aCharacter
 "
 '1 one:2 two:3 three:4 four:5 five' withCRs asCollectionOfSubstringsSeparatedBy:$:
 '1 one 2 two 3 three 4 four 5 five' withCRs asCollectionOfSubstringsSeparatedBy:Character space
 "
 !
 asCollectionOfSubstringsSeparatedByAll:aSeparatorString
 "return a collection containing the lines (separated by aSeparatorString)
 of the receiver. If aSeparatorString occurs multiple times in a row,
 the result will contain empty strings."
 ^ self asCollectionOfSubCollectionsSeparatedByAll:aSeparatorString
 "
 '1::2::3::4::5::' asCollectionOfSubstringsSeparatedByAll:'::'
 "
 !
 asCollectionOfSubstringsSeparatedByAny:aCollectionOfSeparators
 "return a collection containing the words (separated by any character
 ^ self asCollectionOfSubCollectionsSeparatedByAny:aCollectionOfSeparators
 "
 'hello:world:isnt:this nice' asCollectionOfSubstringsSeparatedByAny:#($:)
 'hello:world:isnt:this nice' asCollectionOfSubstringsSeparatedByAny:':'
 'hello:world:isnt:this nice' asCollectionOfSubstringsSeparatedByAny:(Array with:$: with:Character space)
 'hello:world:isnt:this nice' asCollectionOfSubstringsSeparatedByAny:': '
 'h1e2l3l4o' asCollectionOfSubstringsSeparatedByAny:($1 to: $9)
 "
 !
 asCollectionOfWords
 "return a collection containing the words (separated by whitespace)
-of the receiver. Multiple occurences of whitespace characters will
+of the receiver. Multiple occurrences of whitespace characters will
 be treated like one - i.e. whitespace is skipped."
 |words|
 words := OrderedCollection new.
 '      ' asCollectionOfWords
 "
 !
 asCollectionOfWordsDo:aBlock
 "evaluate aBlock for each word (separated by whitespace) of the receiver.
-Multiple occurences of whitespace characters will be treated like one
+Multiple occurrences of whitespace characters will be treated like one
 - i.e. whitespace is skipped.
 Returns the number of words (i.e. the number of invocations of aBlock)."
 |count  "{ Class:SmallInteger }"
 start  "{ Class:SmallInteger }"
 stop   "{ Class:SmallInteger }"
 mySize "{ Class:SmallInteger }"|
 count := 0.
 start := 1.
 mySize := self size.
 [start <= mySize] whileTrue:[
-start := self indexOfNonSeparatorStartingAt:start.
+	start := self indexOfNonSeparatorStartingAt:start.
-start == 0 ifTrue:[
+	start == 0 ifTrue:[
-^ count
+	    ^ count
-].
+	].
-stop := self indexOfSeparatorStartingAt:start.
+	stop := self indexOfSeparatorStartingAt:start.
-stop == 0 ifTrue:[
+	stop == 0 ifTrue:[
-aBlock value:(self copyFrom:start to:mySize).
+	    aBlock value:(self copyFrom:start to:mySize).
-^ count + 1
+	    ^ count + 1
-].
+	].
-aBlock value:(self copyFrom:start to:(stop - 1)).
+	aBlock value:(self copyFrom:start to:(stop - 1)).
-start := stop.
+	start := stop.
-count := count + 1
+	count := count + 1
 ].
 ^ count
 "
 'hello world isnt this nice' asCollectionOfWordsDo:[:w | Transcript showCR:w]
 '      ' asCollectionOfWordsDo:[:w | Transcript showCR:w]
 "
 !
 asComposedText
 "ST-80 compatibility
 - ST/X does not (as today) support composedTexts."
 ^ ComposedText fromString:self string
 "Modified: 27.4.1996 / 13:30:30 / cg"
 "Modified: 20.5.1996 / 09:38:15 / cg"
 !
 asFixedPoint
 "read a fixedPoint number from the receiver.
 Notice, that errors may occur during the read,
 so you better setup some signal handler when using this method."
 ^ FixedPoint readFromString:self
 "
 '0.123' asFixedPoint
 '12345' asFixedPoint
 '(1/5)' asFixedPoint
 'foo' asFixedPoint
 Object errorSignal handle:[:ex | ex return:0] do:['foo' asFixedPoint]
 "
 "Modified: / 25.10.1997 / 15:19:00 / cg"
 !
 asFixedPoint:scale
 "read a fixedPoint number with scale number of post-decimal digits
 from the receiver. Scale controls the number of displayed digits,
 not the number of actually valid digits.
 Notice, that errors may occur during the read,
 so you better setup some signal handler when using this method."
 ^ (FixedPoint readFromString:self) scale:scale
 "
 '0.123' asFixedPoint:2
 '123456' asFixedPoint:2
 ('3.14157' asFixedPoint:1) asFixedPoint:5
 '3.14157' asFixedPoint:2
 'foo' asFixedPoint:2
 "
 "Modified: / 25.10.1997 / 15:21:57 / cg"
 !
 asFloat
 "read a float number from the receiver.
 Notice, that errors may occur during the read,
 so you better setup some exception handler when using this method."
 ^ (Number readFromString:self) asFloat
 "
 '0.123' asFloat
 '12345' asFloat
 '(1/5)' asFloat
 Object errorSignal handle:[:ex | ex return:0] do:['foo' asFloat]
 "
 !
 asInteger
 "read an integer from the receiver.
 Notice, that errors may occur during the read,
 so you better setup some exception handler when using this method."
 ^ Integer readFromString:self
 "
 '12345678901234567890' asInteger
 '-1234' asInteger
 '0.123' asInteger   <- reader stops at ., returning 0 here
 '0.123' asNumber    <- returns what you expect
 Object errorSignal handle:[:ex | ex return:0] do:['foo' asInteger]
 "
 !
 asLowercase
 "return a copy of myself in lowercase letters"
 mySize := self size.
 newStr := self species new:mySize.
 bitsPerCharacter := newStr bitsPerCharacter.
 1 to:mySize do:[:i |
-c := (self at:i) asLowercase.
+	c := (self at:i) asLowercase.
-c bitsPerCharacter > bitsPerCharacter ifTrue:[
+	c bitsPerCharacter > bitsPerCharacter ifTrue:[
-newStr := c stringSpecies fromString:newStr.
+	    newStr := c stringSpecies fromString:newStr.
-].
+	].
-newStr at:i put:c
+	newStr at:i put:c
 ].
 ^ newStr
 "
 'HelloWorld' asLowercase
 'HelloWorld' asLowercaseFirst
 "
 !
 asLowercaseFirst
 "return a copy of myself where the first character is converted to lowercase."
 firstChar := (self at:1).
 firstCharAsLowercase := firstChar asLowercase.
 firstChar == firstCharAsLowercase ifTrue:[ ^ self].
 firstCharAsLowercase bitsPerCharacter > self bitsPerCharacter ifTrue:[
-newString := firstCharAsLowercase stringSpecies fromString:self.
+	newString := firstCharAsLowercase stringSpecies fromString:self.
 ] ifFalse:[
-newString := self stringSpecies fromString:self.
+	newString := self stringSpecies fromString:self.
 ].
 newString at:1 put:firstCharAsLowercase.
 ^ newString
 "
 'HelloWorld' asLowercase
 'HelloWorld' asLowercaseFirst
 "
 !
 asNumber
 "read a number from the receiver.
 Notice, that (in contrast to ST-80) errors may occur during the read,
 so you better setup some signal handler when using this method.
 This may change if ANSI specifies it."
 "/ ST-80 behavior:
 "/  ^ Number readFromString:self onError:0
 "
 '123'     asNumber
 '123.567' asNumber
 '(5/6)'   asNumber
 'foo'     asNumber
 Object errorSignal handle:[:ex | ex returnWith:0] do:['foo' asNumber]
 "
 !
 asNumberFromFormatString:ignored
 "read a number from the receiver, ignoring any nonDigit characters.
 |newString|
 newString := String new:(self size).
 1 to:self size do:[:idx |
-|char|
+	|char|
-char := self at:idx.
+	char := self at:idx.
-char codePoint <= 16rFF ifTrue:[
+	char codePoint <= 16rFF ifTrue:[
-newString at:idx put:char
+	    newString at:idx put:char
-] ifFalse:[
+	] ifFalse:[
-newString at:idx put:replacementCharacter
+	    newString at:idx put:replacementCharacter
-].
+	].
 ].
 ^ newString
 "Created: 30.6.1997 / 13:02:14 / cg"
 !
 |s d ch last lch n codes sc|
 s := self readStream.
 s skipSeparators.
 s atEnd ifTrue:[
-^ nil
+	^ nil
 ].
 ch := s next.
 ch isLetter ifFalse:[
-^ nil
+	^ nil
 ].
 n := 0.
 codes := Dictionary new.
 codes atAll:'bpfv'     put:$1.
 codes at:$l put:$4.
 codes atAll:'nm'       put:$5.
 codes at:$r put:$6.
 d := String writeStream.
 d nextPut:(ch asUppercase).
 [s atEnd] whileFalse:[
-ch := s next.
+	ch := s next.
-lch := ch asLowercase.
+	lch := ch asLowercase.
-lch = last ifFalse:[
+	lch = last ifFalse:[
-last := lch.
+	    last := lch.
-sc := codes at:ch ifAbsent:nil.
+	    sc := codes at:ch ifAbsent:nil.
-sc notNil ifTrue:[
+	    sc notNil ifTrue:[
-n < 3 ifTrue:[
+		n < 3 ifTrue:[
-d nextPut:sc.
+		    d nextPut:sc.
-n := n + 1.
+		    n := n + 1.
-]
+		]
-] ifFalse:[
+	    ] ifFalse:[
 "/                ch isLetter ifFalse:[
 "/                    "/ something else - ignore it
 "/                ] ifTrue:[
 "/                    "/ else its a vowel and we ignore it
 "/                ]
-].
+	    ].
-]
+	]
 ].
 [ n < 3 ] whileTrue:[
-d nextPut:$0.
+	d nextPut:$0.
-n := n + 1.
+	n := n + 1.
 ].
 ^ d contents
 "
 'claus' asSoundexCode
 'clause' asSoundexCode
 'close' asSoundexCode
 'smalltalk' asSoundexCode
 'smaltalk' asSoundexCode
 'smaltak' asSoundexCode
 'smaltok' asSoundexCode
 'smoltok' asSoundexCode
 'aa' asSoundexCode
 'by' asSoundexCode
 'bab' asSoundexCode
 'bob' asSoundexCode
 'bop' asSoundexCode
 "
 !
 asString
 "return myself - I am a string"
 asSymbolIfInterned
 "if a symbol with the receivers characters is already known, return it.
 Otherwise, return nil. This can be used to query for an existing
 symbol and is the same as
-self knownAsSymbol ifTrue:[self asSymbol] ifFalse:[nil]
+	self knownAsSymbol ifTrue:[self asSymbol] ifFalse:[nil]
 but slightly faster, since the symbol lookup operation is only performed once.
 The receiver must be a singleByte-String.
 TwoByte- and FourByteSymbols are (currently ?) not allowed."
 |s|
 !
 asText
 "return a Text-object (collection of lines) from myself."
 "this test allows for small non-gui apps to be built without libbasic2 (where Text is)"
 Text isNil ifTrue:[^ self].
 ^ Text fromString:self
 "Created: 12.5.1996 / 10:41:14 / cg"
 !
 mySize := self size.
 newStr := self species new:mySize.
 bitsPerCharacter := newStr bitsPerCharacter.
 1 to:mySize do:[:i |
-i == 1 ifTrue:[
+	i == 1 ifTrue:[
-c := (self at:i) asTitlecase.
+	    c := (self at:i) asTitlecase.
-] ifFalse:[
+	] ifFalse:[
-c := (self at:i) asLowercase.
+	    c := (self at:i) asLowercase.
-].
+	].
-c bitsPerCharacter > bitsPerCharacter ifTrue:[
+	c bitsPerCharacter > bitsPerCharacter ifTrue:[
-newStr := c stringSpecies fromString:newStr.
+	    newStr := c stringSpecies fromString:newStr.
-].
+	].
-newStr at:i put:c
+	newStr at:i put:c
 ].
 ^ newStr
 "
 'helloWorld' asTitlecase
 'HelloWorld' asTitlecase
 'HELLOWORLD' asTitlecase
 'helloworld' asTitlecase
 "
 !
 asTitlecaseFirst
 "return a version of the receiver, where the first character is converted to titlecase.
 (2-character glyphs), which consist of an upper- and lower-case characters.
 If the first character is already titlecase, or there is no titlecasepercase for it, return the
 receiver."
 "
 For example, in Unicode, character U+01F3 is LATIN SMALL LETTER DZ.
 (Let us write this compound character using ASCII as 'dz'.)
 This character uppercases to character U+01F1, LATIN CAPITAL LETTER DZ.
 (Which is basically 'DZ'.)
 But it titlecases to to character U+01F2, LATIN CAPITAL LETTER D WITH SMALL LETTER Z.
 (Which we can write 'Dz'.)
 character uppercase titlecase
 --------- --------- ---------
 dz        DZ        Dz
 firstChar := (self at:1).
 firstCharAsTitlecase := firstChar asTitlecase.
 firstChar == firstCharAsTitlecase ifTrue:[ ^ self].
 firstCharAsTitlecase bitsPerCharacter > self bitsPerCharacter ifTrue:[
-newString := firstCharAsTitlecase stringSpecies fromString:self.
+	newString := firstCharAsTitlecase stringSpecies fromString:self.
 ] ifFalse:[
-newString := self stringSpecies fromString:self.
+	newString := self stringSpecies fromString:self.
 ].
 newString at:1 put:firstCharAsTitlecase.
 ^ newString
 "
 'helloWorld' asTitlecaseFirst
 'HelloWorld' asTitlecaseFirst
 "
 !
 asTwoByteString
 "return the receiver converted to a two-byte string.
 !
 asURI
 "return an URI with string taken from the receiver"
 ^ URI fromString:self
 !
 asURL
 "return an URL-object from myself."
 ^ URL fromString:self
 "
 'http://www.exept.de:80/index.html' asURL host
 'http://www.exept.de:80/index.html' asURL port
 'http://www.exept.de:80/index.html' asURL method
 'http://www.exept.de:80/index.html' asURL path
 "
 !
 asUnicode16String
 "thats not really true - characters above ascii 16r7F may need special treatment"
 mySize := self size.
 newStr := self species new:mySize.
 bitsPerCharacter := newStr bitsPerCharacter.
 1 to:mySize do:[:i |
-c := (self at:i) asUppercase.
+	c := (self at:i) asUppercase.
-c bitsPerCharacter > bitsPerCharacter ifTrue:[
+	c bitsPerCharacter > bitsPerCharacter ifTrue:[
-newStr := c stringSpecies fromString:newStr.
+	    newStr := c stringSpecies fromString:newStr.
-].
+	].
-newStr at:i put:c
+	newStr at:i put:c
 ].
 ^ newStr
 "
 'helloWorld' asUppercase
 'helloWorld' asUppercaseFirst
 (Character value:16rB5) asString asUppercase   -- needs 16 bits !!
 "
 !
 asUppercaseFirst
 firstChar := (self at:1).
 firstCharAsUppercase := firstChar asUppercase.
 firstChar == firstCharAsUppercase ifTrue:[ ^ self].
 firstCharAsUppercase bitsPerCharacter > self bitsPerCharacter ifTrue:[
-newString := firstCharAsUppercase stringSpecies fromString:self.
+	newString := firstCharAsUppercase stringSpecies fromString:self.
 ] ifFalse:[
-newString := self stringSpecies fromString:self.
+	newString := self stringSpecies fromString:self.
 ].
 newString at:1 put:firstCharAsUppercase.
 ^ newString
 "
 'helloWorld' asUppercase
 'helloWorld' asUppercaseFirst
 'HelloWorld' asUppercaseFirst
 "
 !
 string
 "return the receiver - for ST-80 compatibility"
 This is nonStandard, but convenient"
 |myWidth otherWidth|
 aStringOrCharacter isCharacter ifTrue:[
-^ self copyWith:aStringOrCharacter
+	^ self copyWith:aStringOrCharacter
 ].
 aStringOrCharacter isText ifTrue:[
-^ aStringOrCharacter concatenateFromString:self
+	^ aStringOrCharacter concatenateFromString:self
 ].
 aStringOrCharacter isString ifTrue:[
-(otherWidth := aStringOrCharacter bitsPerCharacter) ~~ (myWidth := self bitsPerCharacter) ifTrue:[
+	(otherWidth := aStringOrCharacter bitsPerCharacter) ~~ (myWidth := self bitsPerCharacter) ifTrue:[
-otherWidth > myWidth ifTrue:[
+	    otherWidth > myWidth ifTrue:[
-^ (aStringOrCharacter species fromString:self) , aStringOrCharacter
+		^ (aStringOrCharacter species fromString:self) , aStringOrCharacter
-].
+	    ].
-^ self , (self species fromString:aStringOrCharacter)
+	    ^ self , (self species fromString:aStringOrCharacter)
-].
+	].
 ].
 ^ super , aStringOrCharacter
 "
 'hello' , $1
 'hello' , '1'
 'hello' , (' world' asText allBold)
 'hello' , (JISEncodedString fromString:' world')
 (JISEncodedString fromString:'hello') , ' world'
 Transcript showCR:
-(Text string:'hello' emphasis:#italic) , (Text string:' world' emphasis:#bold)
+	 (Text string:'hello' emphasis:#italic) , (Text string:' world' emphasis:#bold)
 "
 "Modified: 28.6.1997 / 00:13:17 / cg"
 !
 |tmpStream idx idx1|
 tmpStream := WriteStream on:(self class new).
 idx := 1.
 [idx ~~ 0] whileTrue:[
-idx1 := idx.
+	idx1 := idx.
-idx := self indexOfSubCollection:subString startingAt:idx.
+	idx := self indexOfSubCollection:subString startingAt:idx.
-idx ~~ 0 ifTrue:[
+	idx ~~ 0 ifTrue:[
-tmpStream nextPutAll:(self copyFrom:idx1 to:idx-1).
+	    tmpStream nextPutAll:(self copyFrom:idx1 to:idx-1).
-tmpStream nextPutAll:newString.
+	    tmpStream nextPutAll:newString.
-idx := idx + subString size
+	    idx := idx + subString size
-]
+	]
 ].
 tmpStream nextPutAll:(self copyFrom:idx1).
 ^ tmpStream contents
 "
 '12345678901234567890' replString:'123' withString:'OneTwoThree'
 '12345678901234567890' replString:'123' withString:'*'
 '12345678901234567890' replString:'234' withString:'foo'
 ('a string with spaces' replChar:$  withString:' foo ')
-replString:'foo' withString:'bar'
+	replString:'foo' withString:'bar'
 "
 "Modified: / 31-05-1999 / 12:33:59 / cg"
 "Created: / 12-05-2004 / 12:00:00 / cg"
 !
 copyWith:aCharacter
 "return a new string containing the receivers characters
 and the single new character, aCharacter.
 This is different from concatentation, which expects another string
 as argument, but equivalent to copy-and-addLast.
 The code below cares for different width characters
 (i.e. when appending a 16bit char to an 8bit string)"
 |sz newString|
 aCharacter bitsPerCharacter > self bitsPerCharacter ifTrue:[
-sz := self size.
+	sz := self size.
-newString := aCharacter stringSpecies new:sz + 1.
+	newString := aCharacter stringSpecies new:sz + 1.
-newString replaceFrom:1 to:sz with:self startingAt:1.
+	newString replaceFrom:1 to:sz with:self startingAt:1.
-newString at:sz+1 put:aCharacter.
+	newString at:sz+1 put:aCharacter.
-^ newString.
+	^ newString.
 ].
 ^ super copyWith:aCharacter
 ! !
 !CharacterArray methodsFor:'displaying'!
 |s|
 s := self string.
 opaque ifTrue:[
-aGc displayOpaqueString:s x:x y:y.
+	aGc displayOpaqueString:s x:x y:y.
 ] ifFalse:[
-aGc displayString:s x:x y:y.
+	aGc displayString:s x:x y:y.
 ].
 "Modified: 11.5.1996 / 14:42:48 / cg"
 !
 !CharacterArray methodsFor:'emphasis'!
 allBold
 "return a test object representing the receiver, but all boldified"
 "this test allows for small non-gui apps to be built without libbasic2 (where Text is)"
 Text isNil ifTrue:[^ self].
 ^ self asText allBold
 "
 Transcript showCR:'hello' asText allBold
 !
 allItalic
 "return a test object representing the receiver, but all in italic"
 "this test allows for small non-gui apps to be built without libbasic2 (where Text is)"
 Text isNil ifTrue:[^ self].
 ^ self asText allItalic
 "
 Transcript showCR:'hello' asText allItalic
 ! !
 !CharacterArray methodsFor:'encoding & decoding'!
 decodeFrom:encodingSymbol
 "given the receiver encoded as described by encodingSymbol,
 convert it into internal ST/X (unicode) encoding and return a corresponding CharacterArray."
 |myEncoding encoder|
 encodingSymbol isNil ifTrue:[^ self].
 encodeFrom:oldEncoding into:newEncoding
 ^ CharacterEncoder encodeString:self from:oldEncoding into:newEncoding
 !
 rot13
 "Usenet: from `rotate alphabet 13 places']
 The simple Caesar-cypher encryption that replaces each English
 letter with the one 13 places forward or back along the alphabet,
 so that 'The butler did it!!' becomes 'Gur ohgyre qvq vg!!'
 Most Usenet news reading and posting programs include a rot13 feature.
 It is used to enclose the text in a sealed wrapper that the reader must choose
 to open -- e.g., for posting things that might offend some readers, or spoilers.
 A major advantage of rot13 over rot(N) for other N is that it
 is self-inverse, so the same code can be used for encoding and decoding."
 ^ self species
-streamContents:[:aStream |
+	streamContents:[:aStream |
-self do:[:char |
+	    self do:[:char |
-aStream nextPut:char rot13 ]]
+		aStream nextPut:char rot13 ]]
 "
 'hello world' rot13
 'hello world' rot13 rot13
 "
 !
 utf8Decoded
 "Interpreting myself as an UTF-8 representation, decode and return the decoded string."
 is16Bit := false.
 out := WriteStream on:(String uninitializedNew:self size).
 in := self readStream.
 [in atEnd] whileFalse:[
-c := Character utf8DecodeFrom:in.
+	c := Character utf8DecodeFrom:in.
-is16Bit ifFalse:[
+	is16Bit ifFalse:[
-c codePoint > 16rFF ifTrue:[
+	    c codePoint > 16rFF ifTrue:[
-out := WriteStream with:(UnicodeString fromString:out contents).
+		out := WriteStream with:(UnicodeString fromString:out contents).
-is16Bit := true.
+		is16Bit := true.
-].
+	    ].
-].
+	].
-out nextPut:c.
+	out nextPut:c.
 ].
 ^ out contents
 "
 #[16rC8 16rA0] asString utf8Decoded
 (Character value:16r220) utf8Encoded
 (Character value:16r220) utf8Encoded utf8Decoded
 (Character value:16r800) utf8Encoded
 (Character value:16r220) utf8Encoded utf8Decoded
 "
 "test:
 |utf8Encoding original readBack|
 1 to:16rFFFF do:[:ascii |
-original := (Character value:ascii) asString.
+	original := (Character value:ascii) asString.
-utf8Encoding := original utf8Encoded.
+	utf8Encoding := original utf8Encoded.
-readBack := utf8Encoding utf8Decoded.
+	readBack := utf8Encoding utf8Decoded.
-readBack = original ifFalse:[
+	readBack = original ifFalse:[
-self halt
+	    self halt
-]
+	]
 ]
 "
 !
 utf8DecodedWithTwoByteCharactersReplacedBy:replacementCharacter
 |in out c|
 out := WriteStream on:(String uninitializedNew:self size).
 in := self readStream.
 [in atEnd] whileFalse:[
-c := Character utf8DecodeFrom:in.
+	c := Character utf8DecodeFrom:in.
-c codePoint > 16rFF ifTrue:[
+	c codePoint > 16rFF ifTrue:[
-c := replacementCharacter
+	    c := replacementCharacter
-].
+	].
-out nextPut:c.
+	out nextPut:c.
 ].
 ^ out contents
 "
 (Character value:16r220) utf8Encoded
-utf8DecodedWithTwoByteCharactersReplacedBy:(Character space)
+	utf8DecodedWithTwoByteCharactersReplacedBy:(Character space)
 "
 !
 utf8Encoded
 "Return my UTF-8 representation as a new String"
 utf8EncodedOn:aStream
 "append my UTF-8 representation to the argument, aStream."
 self do:[:c|
-c utf8EncodedOn:aStream.
+	c utf8EncodedOn:aStream.
 ].
 ! !
 !CharacterArray methodsFor:'padded copying'!
 centerPaddedTo:newSize
 "return a new string consisting of the receivers characters,
 plus spaces up to length and center the receivers characters in
 the resulting string.
 If the receivers size is equal or greater than the length argument,
 the original receiver is returned unchanged."
 ^ self centerPaddedTo:newSize with:(Character space)
 "
 'foo' centerPaddedTo:10
 123 printString centerPaddedTo:10
 "
 "Created: 25.11.1995 / 10:53:57 / cg"
 !
 centerPaddedTo:size with:padCharacter
 "return a new string of length size, which contains the receiver
 centered (i.e. padded on both sides).
 Characters are filled with padCharacter.
 If the receivers size is equal or greater than the length argument,
 the original receiver is returned unchanged."
 |len s|
 len := self size.
 	s replaceFrom:(size - len) // 2  + 1 with:self.
 	^ s
 ]
 "
 'foo' centerPaddedTo:11 with:$.
 'fooBar' centerPaddedTo:5 with:$.
 123 printString centerPaddedTo:10 with:$.
 (' ' , 123 printString) centerPaddedTo:10 with:$.
 (Float pi printString) centerPaddedTo:15 with:(Character space)
 (Float pi printString) centerPaddedTo:15 with:$-
 (' ' , Float pi class name) centerPaddedTo:15 with:$.
 "
 !
 decimalPaddedTo:size and:afterPeriod at:decimalCharacter
 "return a new string of overall length size, which contains the receiver
 aligned at the decimal-period column and afterPeriod characters to the right
 of the period. The periodCharacter is passed as arguments (allowing for US and European formats
 to be padded).
 If the receivers size is equal or greater than the length argument,
 the original receiver is returned unchanged.
 (sounds complicated ? -> see examples below)."
 ^ self
 	decimalPaddedTo:size
 	and:afterPeriod
 	at:decimalCharacter
 	withLeft:(Character space)
 	right:$0
 "
 '123' decimalPaddedTo:10 and:3 at:$.      -> '   123    '
 '123' decimalPaddedTo:10 and:3 at:$.      -> '   123.000'
 '123.' decimalPaddedTo:10 and:3 at:$.     -> '   123.000'
 '123.1' decimalPaddedTo:10 and:3 at:$.    -> '   123.100'
 '123.1' decimalPaddedTo:10 and:3 at:$.    -> '   123.1  '
 '123.123' decimalPaddedTo:10 and:3 at:$.  -> '   123.123'
 "
 "Created: 23.12.1995 / 13:11:52 / cg"
 !
 aligned at the decimal-period column and afterPeriod characters to the right
 of the period.
 Characters on the left are filled with leftPadChar.
 If rightPadChar is nil, characters on the right are filled with leftPadCharacter too;
 otherwise, if missing, a decimal point is added and right characters filled with this.
 If the receivers size is equal or greater than the length argument,
 the original receiver is returned unchanged.
 (sounds complicated ? -> see examples below)."
 |s idx n rest|
 idx := self indexOf:decimalCharacter.
 idx == 0 ifTrue:[
-"/
+	"/
-"/ no decimal point found; adjust string to the left of the period column
+	"/ no decimal point found; adjust string to the left of the period column
-"/
+	"/
-rightPadChar isNil ifTrue:[
+	rightPadChar isNil ifTrue:[
-s := self , (self species new:afterPeriod + 1 withAll:leftPadChar)
+	    s := self , (self species new:afterPeriod + 1 withAll:leftPadChar)
-] ifFalse:[
+	] ifFalse:[
-s:= self , decimalCharacter asString , (self species new:afterPeriod withAll:rightPadChar).
+	    s:= self , decimalCharacter asString , (self species new:afterPeriod withAll:rightPadChar).
-].
+	].
 ] ifFalse:[
-"/ the number of after-decimalPoint characters
+	"/ the number of after-decimalPoint characters
-n := self size - idx.
+	n := self size - idx.
-rest := afterPeriod - n.
+	rest := afterPeriod - n.
-rest > 0 ifTrue:[
+	rest > 0 ifTrue:[
-s := (self species new:rest withAll:(rightPadChar ? leftPadChar)).
+	    s := (self species new:rest withAll:(rightPadChar ? leftPadChar)).
-] ifFalse:[
+	] ifFalse:[
-s := ''
+	    s := ''
-].
+	].
-s := self , s.
+	s := self , s.
 ].
 ^ s leftPaddedTo:size with:leftPadChar
 "
 '123' decimalPaddedTo:10 and:3 at:$. withLeft:(Character space) right:nil     -> '   123    '
 '123' decimalPaddedTo:10 and:3 at:$. withLeft:(Character space) right:$0      -> '   123.000'
 '123.' decimalPaddedTo:10 and:3 at:$. withLeft:(Character space) right:$0     -> '   123.000'
 '123.1' decimalPaddedTo:10 and:3 at:$. withLeft:(Character space) right:$0    -> '   123.100'
 '123.1' decimalPaddedTo:10 and:3 at:$. withLeft:(Character space) right:nil   -> '   123.1  '
 '123.123' decimalPaddedTo:10 and:3 at:$. withLeft:(Character space) right:$0  -> '   123.123'
 "
 "Modified: 23.12.1995 / 13:08:18 / cg"
 !
 leftPaddedTo:size
 "return a new string of length size, which contains the receiver
 right-adjusted (i.e. padded on the left).
 Characters on the left are filled with spaces.
 If the receivers size is equal or greater than the length argument,
 the original receiver is returned unchanged."
 ^ self leftPaddedTo:size with:(Character space)
 "
 'foo' leftPaddedTo:10
 'fooBar' leftPaddedTo:5
 123 printString leftPaddedTo:10
 "
 !
 paddedTo:newSize
 "return a new string consisting of the receivers characters,
 plus spaces up to length.
 If the receivers size is equal or greater than the length argument,
 the original receiver is returned unchanged."
 ^ self paddedTo:newSize with:(Character space)
 "
 'foo' paddedTo:10
 123 printString paddedTo:10
 "
 ! !
 !CharacterArray methodsFor:'pattern matching'!
 This is usable with fileName pattern fields."
 ^self compoundMatch:aString ignoreCase:false
 "
 'f*' match:'foo'
 'b*' match:'foo'
 'f*;b*' match:'foo'
 'f*;b*' match:'bar'
 'f*;b*' compoundMatch:'foo'
 'f*;b*' compoundMatch:'bar'
 "
 "Modified: / 30.1.1998 / 11:40:18 / stefan"
 "Modified: / 16.12.1999 / 01:22:08 / cg"
 !
 |matchers|
 matchers := self asCollectionOfSubstringsSeparatedBy:$;.
 matchers do:[:aPattern |
-(aPattern match:aString ignoreCase:ignoreCase) ifTrue:[^ true].
+	(aPattern match:aString ignoreCase:ignoreCase) ifTrue:[^ true].
 ].
 ^ false.
 "
 'f*' match:'foo'
 'b*' match:'foo'
 'f*;b*' match:'foo'
 'f*;b*' match:'bar'
 'f*;b*' compoundMatch:'foo'
 'f*;b*' compoundMatch:'bar'
 'f*;b*' compoundMatch:'Foo' ignoreCase:true
 "
 "Modified: / 15.4.1997 / 15:50:33 / cg"
 "Modified: / 30.1.1998 / 11:40:18 / stefan"
 "Created: / 16.12.1999 / 01:21:35 / cg"
 findMatchString:matchString
 "like findString/indexOfSubCollection, but allowing match patterns.
 find matchstring; if found, return the index;
 if not found, return 0."
 ^ self findMatchString:matchString startingAt:1 ignoreCase:false ifAbsent:0
 !
 findMatchString:matchString startingAt:index
 "like findString, but allowing match patterns.
 find matchstring, starting at index. if found, return the index;
 if not found, return 0."
 ^ self findMatchString:matchString startingAt:index ignoreCase:false ifAbsent:0
 !
 findMatchString:matchString startingAt:index ignoreCase:ignoreCase ifAbsent:exceptionBlock
 "like findString, but allowing match patterns.
 find matchstring, starting at index. if found, return the index;
 matchSize := matchString size.
 matchSize == 0 ifTrue:[^ index]. "empty string matches"
 realMatchString := matchString.
 (realMatchString endsWith:$*) ifFalse:[
-realMatchString := realMatchString , '*'.
+	realMatchString := realMatchString , '*'.
-matchSize := matchSize + 1
+	matchSize := matchSize + 1
 ].
 mySize := self size.
 firstChar := realMatchString at:1.
 firstChar == self class matchEscapeCharacter ifTrue:[
-firstChar := realMatchString at:2.
+	firstChar := realMatchString at:2.
 ].
 firstChar asString includesMatchCharacters ifTrue:[
-index to:mySize do:[:col |
+	index to:mySize do:[:col |
-(realMatchString match:self from:col to:mySize ignoreCase:ignoreCase)
+	    (realMatchString match:self from:col to:mySize ignoreCase:ignoreCase)
-ifTrue:[^ col]
+	    ifTrue:[^ col]
-].
+	].
-^ exceptionBlock value.
+	^ exceptionBlock value.
 ].
 lcChar := firstChar asLowercase.
 ucChar := firstChar asUppercase.
 (ignoreCase and:[ lcChar ~= ucChar]) ifTrue:[
-firstSet := Array with:ucChar with:lcChar.
+	firstSet := Array with:ucChar with:lcChar.
-startIndex := self indexOfAny:firstSet startingAt:index.
+	startIndex := self indexOfAny:firstSet startingAt:index.
 ] ifFalse:[
-startIndex := self indexOf:firstChar startingAt:index.
+	startIndex := self indexOf:firstChar startingAt:index.
 ].
 [startIndex == 0] whileFalse:[
-(realMatchString match:self from:startIndex to:mySize ignoreCase:ignoreCase)
+	(realMatchString match:self from:startIndex to:mySize ignoreCase:ignoreCase)
-ifTrue:[^ startIndex].
+	ifTrue:[^ startIndex].
-firstSet notNil ifTrue:[
+	firstSet notNil ifTrue:[
-startIndex := self indexOfAny:firstSet startingAt:(startIndex + 1).
+	    startIndex := self indexOfAny:firstSet startingAt:(startIndex + 1).
-] ifFalse:[
+	] ifFalse:[
-startIndex := self indexOf:firstChar startingAt:(startIndex + 1).
+	    startIndex := self indexOf:firstChar startingAt:(startIndex + 1).
-].
+	].
 ].
 ^ exceptionBlock value
 "
 'one two three four' findMatchString:'o[nu]'
 'one two three four' findMatchString:'o[nu]' startingAt:3
 'one two three four one' findMatchString:'ONE' startingAt:3 ignoreCase:true ifAbsent:0
 "
 "Modified: 13.9.1997 / 06:31:22 / cg"
 !
 ^ (self findMatchString:matchString) ~~ 0
 "
 'hello world' includesMatchString:'h*'
 'hello world' includesMatchString:'h[aeiou]llo'
 'hello world' includesMatchString:'wor*'
 'hello world' includesMatchString:'woR*'
 "
 !
 match:aString
 "return true if aString matches self, where self may contain meta-match
 characters $* (to match any string) or $# (to match any character).
 or [...] to match a set of characters.
 Lower/uppercase are considered different.
 NOTICE: match-meta character interpretation is like in unix-matching,
-NOT the ST-80 meaning."
+	     NOT the ST-80 meaning."
 ^ self match:aString from:1 to:aString size ignoreCase:false
 "
 '\*f*' match:'f'
 '\*f*' match:'*f'
 '*\*f*' match:'*f'
 '*f*' match:'*f'
 '*ute*' match:'computer'
 '*uter' match:'computer'
 'uter*' match:'computer'
 '*ute*' match:''
 '[abcd]*' match:'computer'
 '[abcd]*' match:'komputer'
 '*some*compl*ern*' match:'this is some more complicated pattern match'
 '*some*compl*ern*' match:'this is another complicated pattern match'
 '*-hh' match:'anton-h'
 "
 "Modified: / 9.6.1998 / 18:50:00 / cg"
 !
 match:aString from:start to:stop ignoreCase:ignoreCase
 "return true if part of aString matches myself,
 where self may contain meta-match
 characters $* (to match any string) or $# (to match any character)
 or [...] to match a set of characters.
 If ignoreCase is true, lower/uppercase are considered the same.
 NOTICE: match-meta character interpretation is like in unix-matching,
-NOT the ST-80 meaning."
+	     NOT the ST-80 meaning."
 |matchScanArray|
 "
 keep the matchScanArray from the most recent match -
 avoids parsing the pattern over-and over if multiple searches
 are done with the same pattern.
 "
 (PreviousMatch notNil
 and:[PreviousMatch key = self]) ifTrue:[
-matchScanArray := PreviousMatch value
+	matchScanArray := PreviousMatch value
 ] ifFalse:[
-matchScanArray := self class matchScanArrayFrom:self.
+	matchScanArray := self class matchScanArrayFrom:self.
-matchScanArray isNil ifTrue:[
+	matchScanArray isNil ifTrue:[
-'CharacterArray [info]: invalid matchpattern:''' infoPrint. self infoPrint. ''' comparing for equality.' infoPrintCR.
+	    'CharacterArray [info]: invalid matchpattern:''' infoPrint. self infoPrint. ''' comparing for equality.' infoPrintCR.
-^ self = aString
+	    ^ self = aString
 "/            ^ false
-].
+	].
-PreviousMatch := self -> matchScanArray.
+	PreviousMatch := self -> matchScanArray.
 ].
 ^ self class
-matchScan:matchScanArray
+	matchScan:matchScanArray
-from:1 to:matchScanArray size
+	from:1 to:matchScanArray size
-with:aString
+	with:aString
-from:start to:stop
+	from:start to:stop
-ignoreCase:ignoreCase
+	ignoreCase:ignoreCase
 "
 '*ute*' match:'12345COMPUTER' from:1 to:5 ignoreCase:true
 '*ute*' match:'12345COMPUTER' from:6 to:13 ignoreCase:true
 "
 "Modified: / 10.11.1998 / 21:43:46 / cg"
 !
 match:aString ignoreCase:ignoreCase
 "return true if aString matches self, where self may contain meta-match
 characters $* (to match any string) or $# (to match any character)
 or [...] to match a set of characters.
 If ignoreCase is true, lower/uppercase are considered the same.
 NOTICE: match-meta character interpretation is like in unix-matching,
-NOT the ST-80 meaning."
+	     NOT the ST-80 meaning."
 ^ self match:aString from:1 to:aString size ignoreCase:ignoreCase
 "
 '*ute*' match:'COMPUTER' ignoreCase:true
 '*uter' match:'COMPUTER' ignoreCase:false
 '[abcd]*' match:'computer' ignoreCase:false
 '[abcd]*' match:'Computer' ignoreCase:false
 '[a-k]*' match:'komputer' ignoreCase:false
 '[a-k]*' match:'zomputer' ignoreCase:false
 '[a-k]*' match:'Komputer' ignoreCase:false
 '[a-k]*' match:'Komputer' ignoreCase:true
 '*some*compl*ern*' match:'this is some more complicated pattern match' ignoreCase:true
 '*some*compl*ern*' match:'this is another complicated pattern match' ignoreCase:true
 Time millisecondsToRun:[
-Symbol allInstancesDo:[:sym |
+	Symbol allInstancesDo:[:sym |
-'[ab]*' match:sym ignoreCase:false
+	    '[ab]*' match:sym ignoreCase:false
-]
+	]
 ].
 Time millisecondsToRun:[
-Symbol allInstancesDo:[:sym |
+	Symbol allInstancesDo:[:sym |
-'*at:*' match:sym ignoreCase:false
+	    '*at:*' match:sym ignoreCase:false
-]
+	]
 ].
 "
 "Modified: 2.4.1997 / 17:28:58 / cg"
 !
 matches:aPatternString
 "return true if the receiver matches aString, where aPatternString may contain meta-match
 characters $* (to match any string) or $# (to match any character).
 or [...] to match a set of characters.
 Lower/uppercase are considered different.
 NOTICE: match-meta character interpretation is like in unix-matching,
-NOT the ST-80 meaning."
+	     NOT the ST-80 meaning."
 ^ aPatternString match:self
 ! !
 article
 "return an article string for the receiver."
 |firstChar|
 firstChar := (self at:1) asLowercase.
 ((firstChar isVowel and:[firstChar ~~ $u]) or:[firstChar == $x]) ifTrue:[
-^ 'an'
+	^ 'an'
 ].
 ^ 'a'
 "
-'uboot' article.
+	'uboot' article.
-'xmas' article.
+	'xmas' article.
-'alarm' article.
+	'alarm' article.
-'baby' article.
+	'baby' article.
 "
 !
 basicStoreString
 "return a String for storing myself"
 |s n index|
 n := self occurrencesOf:$'.
 n == 0 ifFalse:[
-s := String new:(n + 2 + self size).
+	s := String new:(n + 2 + self size).
-s at:1 put:$'.
+	s at:1 put:$'.
-index := 2.
+	index := 2.
-self do:[:thisChar |
+	self do:[:thisChar |
-(thisChar == $') ifTrue:[
+	    (thisChar == $') ifTrue:[
-s at:index put:thisChar.
+		s at:index put:thisChar.
-index := index + 1.
+		index := index + 1.
-].
+	    ].
-s at:index put:thisChar.
+	    s at:index put:thisChar.
-index := index + 1.
+	    index := index + 1.
-].
+	].
-s at:index put:$'.
+	s at:index put:$'.
-^ s
+	^ s
 ].
 ^ '''' , self , ''''
 !
 displayString
 printWithQuotesDoubledOn:aStream
 "put the raw storeString of myself on aStream"
 self do:[:thisChar |
-(thisChar == $') ifTrue:[aStream nextPut:thisChar].
+	(thisChar == $') ifTrue:[aStream nextPut:thisChar].
-aStream nextPut:thisChar
+	aStream nextPut:thisChar
 ]
 "Modified: / 15.6.1998 / 17:21:17 / cg"
 "Created: / 15.6.1998 / 17:22:13 / cg"
 ! !
 !CharacterArray methodsFor:'public'!
 isUnarySelector
 "Answer true if the receiver contains only chars in an ANSI unary method selector, false otherwise."
 ^ (self first isLetter or:[ self first = $_ ])
 and:[ self allSatisfy: [ :chr | chr isLetterOrDigit ]]
 ! !
 !CharacterArray methodsFor:'queries'!
 bitsPerCharacter
 "return the underlying strings bitsPerCharacter
 (i.e. is it a regular String or a TwoByteString)"
 |string max|
 (string := self string) ~~ self ifTrue:[
-^ string bitsPerCharacter
+	^ string bitsPerCharacter
 ].
 max := 8.
 self do:[:eachCharacter |
-max := max max:(eachCharacter bitsPerCharacter)
+	max := max max:(eachCharacter bitsPerCharacter)
 ].
 ^ max
 "
 'hello' bitsPerCharacter
 'hello' asText allBold bitsPerCharacter
 "
 !
 contains8BitCharacters
 "return true, if the underlying string contains 8BitCharacters (or widers)
 (i.e. if it is non-ascii)"
 |string|
 (string := self string) ~~ self ifTrue:[
-^ string contains8BitCharacters
+	^ string contains8BitCharacters
 ].
 self do:[:eachCharacter |
-(eachCharacter codePoint > 16r7F) ifTrue:[
+	(eachCharacter codePoint > 16r7F) ifTrue:[
-^ true
+	    ^ true
-].
+	].
 ].
 ^ false
 "
 'hello' contains8BitCharacters
 'hello' asText allBold contains8BitCharacters
 "
 !
 encoding
 "return the strings encoding, as a symbol.
 Here, by default, we assume unicode-encoding.
 Notice, that iso8859-1 is a true subset of unicode,
 and that singleByteStrings are therefore both unicode AND
 8859-1 encoded."
 ^ #'unicode'
 !
 "return the size of the recevier in device units if displayed on aGC"
 ^ (aGC font onDevice:aGC device) heightOf:self
 "
 'hello world' heightOn:(View new)
 "
 "Created: 12.5.1996 / 20:09:29 / cg"
 "Modified: 12.5.1996 / 20:32:05 / cg"
 !
 scanner := Compiler new.
 scanner source:(self readStream).
 tok := scanner nextToken.
 tok ~~ #Identifier ifTrue:[
-^ false
+	^ false
 ].
 scanner tokenPosition == 1 ifFalse:[^ false].
 ^ scanner sourceStream atEnd.
 "
 'foo' isValidSmalltalkIdentifier
 '1foo' isValidSmalltalkIdentifier
 '_foo' isValidSmalltalkIdentifier
 '_foo_bar_' isValidSmalltalkIdentifier
 'foo ' isValidSmalltalkIdentifier
 ' foo' isValidSmalltalkIdentifier
 "
 !
 leftIndent
 "if the receiver starts with spaces, return the number of spaces
 end   "{Class: SmallInteger }"|
 index := 1.
 end := self size.
 [index <= end] whileTrue:[
-(self at:index) isSeparator ifFalse:[^ index - 1].
+	(self at:index) isSeparator ifFalse:[^ index - 1].
-index := index + 1
+	index := index + 1
 ].
 ^ end
 "
 '    hello' leftIndent
 'foo      ' leftIndent
 '         ' leftIndent
 "
 "Modified: 20.4.1996 / 19:28:43 / cg"
 !
 stringSpecies
 "return the underlying strings bitsPerCharacter
 (i.e. is it a regular String or a TwoByteString)"
 |string|
 (string := self string) == self ifTrue:[^ self class].
 ^ string stringSpecies
 "
 'hello' stringSpecies
 'hello' asText allBold stringSpecies
 "
 !
 widthFrom:startIndex to:endIndex on:aGC
 "return ths size of part of the recevier in device units if displayed on aGC"
 ^ (aGC font onDevice:aGC device) widthOf:self from:startIndex to:endIndex
 "
 'hello world' widthFrom:1 to:5 on:(View new)
 'hello' widthOn:(View new)
 "
 !
 widthOn:aGC
 "return ths size of the recevier in device units if displayed on aGC"
 ^ (aGC font onDevice:aGC device) widthOf:self
 "
 'hello world' widthOn:(View new)
 "
 "Created: 12.5.1996 / 20:09:29 / cg"
 "Modified: 17.4.1997 / 12:50:23 / cg"
 ! !
 "return a collection of substrings in the receiver, which match the regular expression in rxString"
 ^ rxString asRegex matchesIn: self
 "
 '1234 abcd 3456 defg' allRegexMatches:'[0-9]+'
 '[0-9]+' asRegex matchesIn:'1234 abcd 3456 defg'
 "
 !
 asRegex
 "Compile the receiver as a regex matcher.
 May raise RxParser>>syntaxErrorSignal or RxParser>>compilationErrorSignal.
 This is a part of the Regular Expression Matcher package,
-(c) 1996, 1999 Vassili Bykov.
+	(c) 1996, 1999 Vassili Bykov.
 Refer to `documentation' protocol of RxParser class for details."
 ^ Regex::RxParser preferredMatcherClass
-for: (Regex::RxParser new parse: self)
+	for: (Regex::RxParser new parse: self)
 !
 asRegexIgnoringCase
 "Compile the receiver as a regex matcher.
 May raise RxParser>>syntaxErrorSignal or RxParser>>compilationErrorSignal.
 This is a part of the Regular Expression Matcher package,
-(c) 1996, 1999 Vassili Bykov.
+	(c) 1996, 1999 Vassili Bykov.
 Refer to `documentation' protocol of RxParser class for details."
 ^ Regex::RxParser preferredMatcherClass
-for: (Regex::RxParser new parse: self)
+	    for: (Regex::RxParser new parse: self)
-ignoreCase: true
+	    ignoreCase: true
 !
 copyWithRegex: rxString matchesReplacedWith: aString
 ^ rxString asRegex copy: self replacingMatchesWith: aString
 !
 copyWithRegex: rxString matchesTranslatedUsing: aBlock
 ^ rxString asRegex copy: self translatingMatchesUsing: aBlock
 !
 matchesRegex: regexString
 "Test if the receiver matches a regex.
 May raise RxParser>>regexErrorSignal or child signals.
 This is a part of the Regular Expression Matcher package,
-(c) 1996, 1999 Vassili Bykov.
+	(c) 1996, 1999 Vassili Bykov.
 Refer to `documentation' protocol of RxParser class for details."
 ^regexString asRegex matches: self
 "
 'hello world' matchesRegex:'h.*d'.
 "
 !
 matchesRegexIgnoringCase: regexString
 "Test if the receiver matches a regex.
 May raise RxParser>>regexErrorSignal or child signals.
 This is a part of the Regular Expression Matcher package,
-(c) 1996, 1999 Vassili Bykov.
+	(c) 1996, 1999 Vassili Bykov.
 Refer to `documentation' protocol of RxParser class for details."
 ^regexString asRegexIgnoringCase matches: self
 "
 'hElLo wOrld' matchesRegexIgnoringCase:'h.*d'.
 "
 !
 prefixMatchesRegex: regexString
 "Test if the receiver's prefix matches a regex.
 May raise RxParser class>>regexErrorSignal or child signals.
 This is a part of the Regular Expression Matcher package,
-(c) 1996, 1999 Vassili Bykov.
+	(c) 1996, 1999 Vassili Bykov.
 Refer to `documentation' protocol of RxParser class for details."
 ^regexString asRegex matchesPrefix: self
 !
 prefixMatchesRegexIgnoringCase: regexString
 "Test if the receiver's prefix matches a regex.
 May raise RxParser class>>regexErrorSignal or child signals.
 This is a part of the Regular Expression Matcher package,
-(c) 1996, 1999 Vassili Bykov.
+	(c) 1996, 1999 Vassili Bykov.
 Refer to `documentation' protocol of RxParser class for details."
 ^regexString asRegexIgnoringCase matchesPrefix: self
 !
 and collect the returned values."
 ^ rxString asRegex matchesIn: self collect: aBlock
 "
 'hello world' regex:'\w+' matchesCollect:[:each | each asUppercase ].
 '1234 hello 456 world' regex:'\d+' matchesCollect:[:each | Number readFrom:each ].
 "
 !
 regex:rxString matchesDo: aBlock
 "for all substrings in the receiver which match the regular expression in rxString, evaluate aBlock"
 !CharacterArray methodsFor:'special string converting'!
 chopTo:maxLen
 "if the receivers size is less or equal to maxLen, return it.
 Otherwise, return a copy of the receiver, where some characters
 in the middle have been removed for a total string length
 of maxLen."
 |sz n1 n2|
 	].
 	^ (self copyFrom:1 to:n1) , (self copyFrom:sz - n2 + 1)
 ]
 "
 '12345678901234'   chopTo:15
 '123456789012345'  chopTo:15
 '1234567890123456' chopTo:15
 'aShortString' chopTo:15
 'aVeryLongNameForAStringThatShouldBeShortened' chopTo:15
 "
 !
 contractAtBeginningTo:maxLen
 "if the receivers size is less or equal to maxLen, return it.
 Otherwise, return a copy of the receiver, where some characters
 at the beginning have been replaced by '...' for a total string length
 of maxLen. Can be used to abbreviate long entries in tables."
 |sz|
 (sz := self size) > maxLen ifTrue:[
 	^ '...' , (self copyFrom:(sz - (maxLen - 4)))
 ]
 "
 '12345678901234' contractAtBeginningTo:15
 '123456789012345' contractAtBeginningTo:15
 '1234567890123456' contractAtBeginningTo:15
 'aShortString' contractAtBeginningTo:15
 'aVeryLongNameForAStringThatShouldBeShortened' contractAtBeginningTo:15
 "
 !
 contractAtEndTo:maxLen
 "if the receivers size is less or equal to maxLen, return it.
 Otherwise, return a copy of the receiver, where some characters
 at the end have been replaced by '...' for a total string length
 of maxLen. Can be used to abbreviate long entries in tables."
 |sz|
 	^ self copyReplaceFrom:maxLen - 3
 			    with:'...'
 ]
 "
 '12345678901234' contractAtEndTo:15
 '123456789012345' contractAtEndTo:15
 '1234567890123456' contractAtEndTo:15
 'aShortString' contractAtEndTo:15
 'aVeryLongNameForAStringThatShouldBeShortened' contractAtEndTo:15
 "
 !
 contractTo:maxLen
 "if the receivers size is less or equal to maxLen, return it.
 Otherwise, return a copy of the receiver, where some characters
 in the middle have been replaced by '...' for a total string length
 of maxLen. Can be used to abbreviate long entries in tables."
 |sz "{ SmallInteger }"
 halfSize "{ SmallInteger }"|
 			    to:sz - maxLen + halfSize + 1
 			    with:'...'
 ]
 "
 '12345678901234' contractTo:15
 '123456789012345' contractTo:15
 '1234567890123456' contractTo:15
 'aShortString' contractTo:15
 'aVeryLongNameForAStringThatShouldBeShortened' contractTo:15
 "
 !
 expandPlaceholdersWith:argArrayOrDictionary
 "return a copy of the receiver, where all %i escapes are
 expandedString := self species new:0.
 stop := self size.
 start := 1.
 [start <= stop] whileTrue:[
-idx := self indexOf:$% startingAt:start.
+	idx := self indexOf:$% startingAt:start.
-(idx == 0 or:[idx == stop]) ifTrue:[
+	(idx == 0 or:[idx == stop]) ifTrue:[
-^ expandedString , (self copyFrom:start to:stop)
+	    ^ expandedString , (self copyFrom:start to:stop)
-].
+	].
-"found a %"
+	"found a %"
-expandedString := expandedString , (self copyFrom:start to:(idx - 1)).
+	expandedString := expandedString , (self copyFrom:start to:(idx - 1)).
-next := self at:(idx + 1).
+	next := self at:(idx + 1).
-(next == $%) ifTrue:[
+	(next == $%) ifTrue:[
-expandedString := expandedString , '%'
+	    expandedString := expandedString , '%'
-] ifFalse:[
+	] ifFalse:[
-(next between:$1 and:$9) ifTrue:[
+	    (next between:$1 and:$9) ifTrue:[
-v := argArrayOrDictionary at:(next digitValue) ifAbsent:nil
+		v := argArrayOrDictionary at:(next digitValue) ifAbsent:nil
-] ifFalse:[
+	    ] ifFalse:[
-next == $( ifTrue:[
+		next == $( ifTrue:[
-idx2 := self indexOf:$) startingAt:idx+2.
+		    idx2 := self indexOf:$) startingAt:idx+2.
-key := self copyFrom:idx+2 to:idx2-1.
+		    key := self copyFrom:idx+2 to:idx2-1.
-idx := idx2 - 1.
+		    idx := idx2 - 1.
-keyAsSymbol := key asSymbolIfInterned.
+		    keyAsSymbol := key asSymbolIfInterned.
-(keyAsSymbol notNil and:[ argArrayOrDictionary includesKey:keyAsSymbol ]) ifTrue:[
+		    (keyAsSymbol notNil and:[ argArrayOrDictionary includesKey:keyAsSymbol ]) ifTrue:[
-v := argArrayOrDictionary at:keyAsSymbol
+			v := argArrayOrDictionary at:keyAsSymbol
-] ifFalse:[
+		    ] ifFalse:[
-(key conform:[:each | each isDigit]) ifTrue:[
+			(key conform:[:each | each isDigit]) ifTrue:[
-key := Number readFrom:key onError:nil.
+			    key := Number readFrom:key onError:nil.
-].
+			].
-v := argArrayOrDictionary at:key ifAbsent:nil
+			v := argArrayOrDictionary at:key ifAbsent:nil
-].
+		    ].
-] ifFalse:[
+		] ifFalse:[
-v := argArrayOrDictionary at:next ifAbsent:nil.
+		    v := argArrayOrDictionary at:next ifAbsent:nil.
-v isNil ifTrue:[
+		    v isNil ifTrue:[
-(argArrayOrDictionary includesKey:next asString) ifTrue:[
+			(argArrayOrDictionary includesKey:next asString) ifTrue:[
-v := argArrayOrDictionary at:next asString asSymbol ifAbsent:nil.
+			    v := argArrayOrDictionary at:next asString asSymbol ifAbsent:nil.
-] ifFalse:[
+			] ifFalse:[
-v := String with:$% with:next. "/ next asString.
+			    v := String with:$% with:next. "/ next asString.
-]
+			]
-].
+		    ].
-]
+		]
-].
+	    ].
-v isNil
+	    v isNil
-ifTrue:[v := '']
+		ifTrue:[v := '']
-ifFalse:[
+		ifFalse:[
-v isBlock ifTrue:[
+		    v isBlock ifTrue:[
-v := v value
+			v := v value
-]].
+		    ]].
-expandedString := expandedString , v printString
+	    expandedString := expandedString , v printString
-].
+	].
-start := idx + 2
+	start := idx + 2
 ].
 ^  expandedString
 "
 'hello %1' expandPlaceholdersWith:#('world')
 'hello %1; how is %2' expandPlaceholdersWith:#('world' 'this')
 'hello %2; how is %1' expandPlaceholdersWith:#('world' 'this')
 '%1 plus %2 gives %3 ' expandPlaceholdersWith:#(4 5 9)
 '%%(1)0 gives %(1)0' expandPlaceholdersWith:#(123)
 '%%10 gives %10' expandPlaceholdersWith:#(123)
 '%%(10) gives %(10)' expandPlaceholdersWith:#(123)
 "
 "
 |dict|
 dict := Dictionary new.
 dict at:1 put:'one'.
 dict at:$a put:'AAAAA'.
 dict at:$b put:[ Time now ].
 'hello %1 %a %b' expandPlaceholdersWith:dict
 "
 "Modified: 1.7.1997 / 00:53:24 / cg"
 !
 withEscapes
 "return a new string consisting of receivers characters
 with all \X-character escapes replaced by corresponding-characters.
 (similar to the way C-language Strings are converted).
 The following escapes are supported:
-\r      return character
+	\r      return character
-\n      newline character
+	\n      newline character
-\b      backspace character
+	\b      backspace character
-\f      formfeed character
+	\f      formfeed character
-\t      tab character
+	\t      tab character
-\e      escape character
+	\e      escape character
-\\      the \ character itself
+	\\      the \ character itself
-\nnn    three digit octal number defining the characters ascii value
+	\nnn    three digit octal number defining the characters ascii value
-\other  other
+	\other  other
 Notice, that \' is NOT a valid escape, since the general syntax of
 string constants is not affected by this method.
 Although easily implementable, this is NOT done automatically
 |sz      "{ SmallInteger }"
 newSize "{ SmallInteger }"
 srcIdx  "{ SmallInteger }"
 dstIdx  "{ SmallInteger }"
 val     "{ SmallInteger }"
 newString next hasEmphasis e|
 "
 first, count the number of escapes, to allow preallocation
 of the new string ...
 (it is faster to scan the string twice than to reallocate it multiple
 times in a WriteStream)
 "
 sz := newSize := self size.
 srcIdx := 1.
 [(srcIdx := self indexOf:$\ startingAt:srcIdx) ~~ 0] whileTrue:[
-srcIdx == sz ifFalse:[
+	srcIdx == sz ifFalse:[
-newSize := newSize - 1.
+	    newSize := newSize - 1.
-srcIdx := srcIdx + 1.
+	    srcIdx := srcIdx + 1.
-next := self at:srcIdx.
+	    next := self at:srcIdx.
-next == $0 ifTrue:[
+	    next == $0 ifTrue:[
-[srcIdx < sz and:[next isDigit]] whileTrue:[
+		[srcIdx < sz and:[next isDigit]] whileTrue:[
-newSize := newSize - 1. srcIdx := srcIdx + 1. next := self at:srcIdx.
+		    newSize := newSize - 1. srcIdx := srcIdx + 1. next := self at:srcIdx.
-]
+		]
-].
+	    ].
-].
+	].
-srcIdx := srcIdx + 1.
+	srcIdx := srcIdx + 1.
 ].
 newSize == sz ifTrue:[
-^ self
+	^ self
 ].
 newString := self species new:newSize.
 hasEmphasis := self hasChangeOfEmphasis.
 "
 copy over, replace escapes
 "
 srcIdx := dstIdx := 1.
 [srcIdx <= sz] whileTrue:[
-next := self at:srcIdx.
+	next := self at:srcIdx.
-hasEmphasis ifTrue:[
+	hasEmphasis ifTrue:[
-e := self emphasisAt:srcIdx
+	    e := self emphasisAt:srcIdx
-].
+	].
-srcIdx := srcIdx + 1.
+	srcIdx := srcIdx + 1.
-next == $\ ifTrue:[
+	next == $\ ifTrue:[
-srcIdx <= sz ifTrue:[
+	    srcIdx <= sz ifTrue:[
-next := self at:srcIdx.
+		next := self at:srcIdx.
-srcIdx := srcIdx + 1.
+		srcIdx := srcIdx + 1.
-next == $r ifTrue:[
+		next == $r ifTrue:[
-next := Character return
+		    next := Character return
-] ifFalse:[
+		] ifFalse:[
-next == $n ifTrue:[
+		    next == $n ifTrue:[
-next := Character nl
+			next := Character nl
-] ifFalse:[
+		    ] ifFalse:[
-next == $b ifTrue:[
+			next == $b ifTrue:[
-next := Character backspace
+			    next := Character backspace
-] ifFalse:[
+			] ifFalse:[
-next == $f ifTrue:[
+			    next == $f ifTrue:[
-next := Character newPage
+				next := Character newPage
-] ifFalse:[
+			    ] ifFalse:[
-next == $t ifTrue:[
+				next == $t ifTrue:[
-next := Character tab
+				    next := Character tab
-] ifFalse:[
+				] ifFalse:[
-next == $e ifTrue:[
+				    next == $e ifTrue:[
-next := Character esc
+					next := Character esc
-] ifFalse:[
+				    ] ifFalse:[
-next == $0 ifTrue:[
+					next == $0 ifTrue:[
-val := 0.
+					    val := 0.
-[next notNil and:[next isDigit]] whileTrue:[
+					    [next notNil and:[next isDigit]] whileTrue:[
-val := val * 8 + next digitValue.
+						val := val * 8 + next digitValue.
-srcIdx <= sz ifTrue:[
+						srcIdx <= sz ifTrue:[
-next := self at:srcIdx.
+						    next := self at:srcIdx.
-srcIdx := srcIdx + 1.
+						    srcIdx := srcIdx + 1.
-] ifFalse:[
+						] ifFalse:[
-next := nil
+						    next := nil
-]
+						]
-].
+					    ].
-next := Character value:val.
+					    next := Character value:val.
-]
+					]
-]
+				    ]
-]
+				]
-]
+			    ]
-]
+			]
-]
+		    ]
-].
+		].
-].
+	    ].
-].
+	].
-newString at:dstIdx put:next.
+	newString at:dstIdx put:next.
-hasEmphasis ifTrue:[
+	hasEmphasis ifTrue:[
-newString emphasisAt:dstIdx put:e
+	    newString emphasisAt:dstIdx put:e
-].
+	].
-dstIdx := dstIdx + 1.
+	dstIdx := dstIdx + 1.
 ].
 ^ newString
 "
 'hello world' withEscapes
 'hello\world' withEscapes
 'hello\world\' withEscapes
 'hello world\' withEscapes
 'hello\tworld' withEscapes
 'hello\nworld\na\n\tnice\n\t\tstring' withEscapes
 'hello\tworld\n' withEscapes
 'hello\010world' withEscapes
 'hello\r\nworld' withEscapes
 "
 "Modified: 12.5.1996 / 12:53:34 / cg"
 !
 escape := self class matchEscapeCharacter.
 in := self readStream.
 out := WriteStream on:(self species new:self size).
 [in atEnd] whileFalse:[
-c := in next.
+	c := in next.
-(c == escape or:['*[#' includes:c]) ifTrue:[
+	(c == escape or:['*[#' includes:c]) ifTrue:[
-out nextPut:$\.
+	    out nextPut:$\.
-].
+	].
-out nextPut:c.
+	out nextPut:c.
 ].
 ^ out contents.
 "
 '*foo' withMatchEscapes
 '\*foo' withMatchEscapes
 '*foo' withMatchEscapes
 '\\*foo' withMatchEscapes
 'foo*' withMatchEscapes
 'foo\*' withMatchEscapes
 'foo\' withMatchEscapes
 'f*o*o' withMatchEscapes
 "
 "Modified: 2.4.1997 / 18:13:04 / cg"
 !
 withTabs
 "return a string consisting of the receivers characters
 where leading spaces are replaced by tabulator characters (assuming 8-col tabs).
 Notice: if the receiver does not contain any tabs, it is returned unchanged;
 otherwise a new string is returned.
 Limitation: only the very first spaces are replaced
-(i.e. if the receiver contains newLine characters,
+		 (i.e. if the receiver contains newLine characters,
-no tabs are inserted after those lineBreaks)"
+		  no tabs are inserted after those lineBreaks)"
 |idx   "{ SmallInteger }"
 nTabs "{ SmallInteger }"
 newString|
 idx := self findFirst:[:c | (c ~~ Character space)].
 nTabs := (idx-1) // 8.
 nTabs <= 0 ifTrue:[^ self].
 newString atAll:(1 to:nTabs) put:(Character tab).
 newString replaceFrom:(nTabs + 1) with:self startingAt:(nTabs * 8 + 1).
 ^ newString
 "
 '12345678901234567890' withTabs
 '       8901234567890' withTabs
 '        901234567890' withTabs
 '               67890' withTabs
 '                7890' withTabs
 '                 890' withTabs
 "
 !
 withTabsExpanded
 "return a string consisting of the receivers characters,
 where all tabulator characters are expanded into spaces (assuming 8-col tabs).
 Notice: if the receiver does not contain any tabs, it is returned unchanged;
 otherwise a new string is returned.
 This does handle multiline strings."
 ^ self withTabsExpanded:8
 "
 ('1' , Character tab asString , 'x') withTabsExpanded
 ('12345' , Character tab asString , 'x') withTabsExpanded
 ('123456' , Character tab asString , 'x') withTabsExpanded
 ('1234567' , Character tab asString , 'x') withTabsExpanded
 ('12345678' , Character tab asString , 'x') withTabsExpanded
 ('123456789' , Character tab asString , 'x') withTabsExpanded
 (String with:Character tab
-with:Character tab
+	     with:Character tab
-with:$1) withTabsExpanded
+	     with:$1) withTabsExpanded
 (String with:Character tab
-with:$1
+	     with:$1
-with:Character tab
+	     with:Character tab
-with:$2) withTabsExpanded
+	     with:$2) withTabsExpanded
 (String with:Character tab
-with:$1
+	     with:$1
-with:Character cr
+	     with:Character cr
-with:Character tab
+	     with:Character tab
-with:$2) withTabsExpanded
+	     with:$2) withTabsExpanded
 "
 "Modified: 12.5.1996 / 13:05:10 / cg"
 !
 withTabsExpanded:numSpaces
 "return a string consisting of the receivers characters,
 where all tabulator characters are expanded into spaces (assuming numSpaces-col tabs).
 Notice: if the receiver does not contain any tabs, it is returned unchanged;
 otherwise a new string is returned.
 This does handle multiline strings."
 |col    "{ SmallInteger }"
 str ch
 dstIdx "{ SmallInteger }"
 newSz  "{ SmallInteger }"
 sz "{ SmallInteger }"
 hasEmphasis e|
 "/ count the new size first, instead of
 "/ multiple resizing (better for large strings)
 col := 1. newSz := 0.
 1 to:sz do:[:srcIdx |
-ch := self at:srcIdx.
+	ch := self at:srcIdx.
-ch == Character tab ifFalse:[
+	ch == Character tab ifFalse:[
-col := col + 1.
+	    col := col + 1.
-newSz := newSz + 1.
+	    newSz := newSz + 1.
-ch == Character cr ifTrue:[
+	    ch == Character cr ifTrue:[
-col := 1
+		col := 1
-].
+	    ].
-] ifTrue:[
+	] ifTrue:[
-(col \\ numSpaces) to:numSpaces do:[:ii |
+	    (col \\ numSpaces) to:numSpaces do:[:ii |
-newSz := newSz + 1.
+		newSz := newSz + 1.
-col := col + 1
+		col := col + 1
-].
+	    ].
-]
+	]
 ].
 str := self species new:newSz.
 hasEmphasis := self hasChangeOfEmphasis.
 col := 1. dstIdx := 1.
 1 to:sz do:[:srcIdx |
-ch := self at:srcIdx.
+	ch := self at:srcIdx.
-ch == Character tab ifFalse:[
+	ch == Character tab ifFalse:[
-col := col + 1.
+	    col := col + 1.
-ch == Character cr ifTrue:[
+	    ch == Character cr ifTrue:[
-col := 1
+		col := 1
-].
+	    ].
-hasEmphasis ifTrue:[
+	    hasEmphasis ifTrue:[
-e := self emphasisAt:srcIdx.
+		e := self emphasisAt:srcIdx.
-str emphasisAt:dstIdx put:e
+		str emphasisAt:dstIdx put:e
-].
+	    ].
-str at:dstIdx put:ch.
+	    str at:dstIdx put:ch.
-dstIdx := dstIdx + 1
+	    dstIdx := dstIdx + 1
-] ifTrue:[
+	] ifTrue:[
-(col \\ numSpaces) to:numSpaces do:[:ii |
+	    (col \\ numSpaces) to:numSpaces do:[:ii |
-str at:dstIdx put:Character space.
+		str at:dstIdx put:Character space.
-dstIdx := dstIdx + 1.
+		dstIdx := dstIdx + 1.
-col := col + 1
+		col := col + 1
-].
+	    ].
-]
+	]
 ].
 ^ str
 "
 ('1' , Character tab asString , 'x') withTabsExpanded
 ('1' , Character tab asString , 'x') withTabsExpanded:4
 ('12345' , Character tab asString , 'x') withTabsExpanded
 ('123456' , Character tab asString , 'x') withTabsExpanded
 ('1234567' , Character tab asString , 'x') withTabsExpanded
 ('12345678' , Character tab asString , 'x') withTabsExpanded
 ('123456789' , Character tab asString , 'x') withTabsExpanded
 (String with:Character tab
-with:Character tab
+	     with:Character tab
-with:$1) withTabsExpanded
+	     with:$1) withTabsExpanded
 (String with:Character tab
-with:$1
+	     with:$1
-with:Character tab
+	     with:Character tab
-with:$2) withTabsExpanded
+	     with:$2) withTabsExpanded
 (String with:Character tab
-with:$1
+	     with:$1
-with:Character cr
+	     with:Character cr
-with:Character tab
+	     with:Character tab
-with:$2) withTabsExpanded
+	     with:$2) withTabsExpanded
 "
 "Modified: 12.5.1996 / 13:05:10 / cg"
 !
 	^ self copyFrom:index
 ].
 ^ ''
 "
 '    foo    ' withoutLeadingSeparators
 'foo    '     withoutLeadingSeparators
 '    foo'     withoutLeadingSeparators
 '       '     withoutLeadingSeparators
 'foo'         withoutLeadingSeparators
 ('  ' , Character tab asString , ' foo   ') withoutLeadingSeparators inspect
 "
 !
 withoutMatchEscapes
 "return a copy of the receiver with all $\ removed or
 escape := self class matchEscapeCharacter.
 in := self readStream.
 out := self species writeStream.
 [in atEnd] whileFalse:[
-c := in next.
+	c := in next.
-c == escape ifTrue:[
+	c == escape ifTrue:[
-in atEnd ifFalse:[
+	    in atEnd ifFalse:[
-c := in next.
+		c := in next.
-]
+	    ]
-].
+	].
-out nextPut:c.
+	out nextPut:c.
 ].
 ^ out contents.
 "
 '*foo' withoutMatchEscapes
 '\*foo' withoutMatchEscapes
 '*foo' withoutMatchEscapes
 '\\*foo' withoutMatchEscapes
 'foo*' withoutMatchEscapes
 'foo\*' withoutMatchEscapes
 'foo\' withoutMatchEscapes
 'f\*o\*o' withoutMatchEscapes
 "
 "Modified: 30.6.1997 / 13:40:23 / cg"
 !
 withoutPrefix:aString
 "if the receiver startsWith aPrefix, return a copy without it.
 Otherwise return the receiver"
 (self startsWith:aString) ifTrue:[
-^ self copyFrom:aString size + 1
+	^ self copyFrom:aString size + 1
 ].
 ^ self
 "
 'helloworld' withoutPrefix:'hello'
 (but whiteSpace in-between is preserved)
 Whitespace is space, tab, newline, formfeed.
 Use withoutSpaces, if you want to remove spaces only."
 |startIndex "{ Class: SmallInteger }"
 endIndex   "{ Class: SmallInteger }"
 sz|
 sz := self size.
 startIndex := 1.
 endIndex := sz.
 [(startIndex < endIndex) and:[(self at:startIndex) isSeparator]] whileTrue:[
-startIndex := startIndex + 1
+	startIndex := startIndex + 1
 ].
 [(endIndex > 1) and:[(self at:endIndex) isSeparator]] whileTrue:[
-endIndex := endIndex - 1
+	endIndex := endIndex - 1
 ].
 startIndex > endIndex ifTrue:[
-^ ''
+	^ ''
 ].
 ((startIndex == 1) and:[endIndex == sz]) ifTrue:[
-^ self
+	^ self
 ].
 ^ self copyFrom:startIndex to:endIndex
 "
 '    foo    ' withoutSeparators
 '    foo' withoutSeparators
 'foo    ' withoutSeparators
 '       ' withoutSeparators
 ('  foo' , Character tab asString , '    ') withoutSeparators inspect
 "
 !
 withoutSpaces
 "return a copy of myself without leading and trailing spaces.
 (but spaces in-between are preserved)
 Notice: this does NOT remove tabs, newline or any other whitespace.
 Use withoutSeparators for this."
 |startIndex "{ Class: SmallInteger }"
 endIndex   "{ Class: SmallInteger }"
 sz|
 sz := self size.
 startIndex := 1.
 endIndex := sz.
 [(startIndex < endIndex) and:[(self at:startIndex) == Character space]] whileTrue:[
-startIndex := startIndex + 1
+	startIndex := startIndex + 1
 ].
 [(endIndex > 1) and:[(self at:endIndex) == Character space]] whileTrue:[
-endIndex := endIndex - 1
+	endIndex := endIndex - 1
 ].
 startIndex > endIndex ifTrue:[
-^ ''
+	^ ''
 ].
 ((startIndex == 1) and:[endIndex == sz]) ifTrue:[
-^ self
+	^ self
 ].
 ^ self copyFrom:startIndex to:endIndex
 "
 '    foo    ' withoutSpaces
 'foo    '     withoutSpaces
 '    foo'     withoutSpaces
 '       '     withoutSpaces
 'a     b'     withoutSpaces
 ('  foo' , Character tab asString , '    ') withoutSpaces inspect
 "
 !
 withoutTrailingSeparators
 "return a copy of myself without trailing separators.
 	index := index - 1
 ].
 ^ ''
 "
 '    foo    ' withoutTrailingSeparators
 'foo    '     withoutTrailingSeparators
 '    foo'     withoutTrailingSeparators
 '       '     withoutTrailingSeparators
 'foo'         withoutTrailingSeparators
 ('  ' , Character tab asString , ' foo   ') withoutTrailingSeparators inspect
 ('   foo' , Character tab asString) withoutTrailingSeparators inspect
 "
 ! !
 !CharacterArray methodsFor:'substring searching'!
 if not found, return 0."
 ^ self indexOfSubCollection:subString startingAt:1 ifAbsent:0
 "
 'hello world' findString:'llo'
 'hello world' findString:'ole'
 "
 !
 findString:subString ifAbsent:exceptionBlock
 "find a substring. If found, return the index;
 if not found, return 0."
 ^ self indexOfSubCollection: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;
 "return true, if a substring is contained in the receiver"
 ^ (self indexOfSubCollection:aString startingAt:1 ifAbsent:0) ~~ 0
 "
 'hello world' includesString:'hel'
 'hello world' includesString:'rld'
 'hello world' includesString:'llo'
 'hello world' includesString:'LLO'
 "
 !
 indexOfSubCollection:subString startingAt:index ifAbsent:exceptionBlock
 "find a substring, starting at index. if found, return the index;
 mySize     "{ Class: SmallInteger }"
 runIdx     "{ Class: SmallInteger }" |
 subSize := subString size.
 subSize == 0 ifTrue:[   "empty string matches"
-subString isString ifFalse:[
+	subString isString ifFalse:[
-self error:'non string argument' mayProceed:true.
+	   self error:'non string argument' mayProceed:true.
-].
+	].
-^ index
+	^ index
 ].
 mySize := self size.
 firstChar := subString at:1.
 startIndex := self indexOf:firstChar startingAt:index.
 [startIndex == 0] whileFalse:[
-runIdx := startIndex.
+	runIdx := startIndex.
-found := true.
+	found := true.
-1 to:subSize do:[:i |
+	1 to:subSize do:[:i |
-runIdx > mySize ifTrue:[
+	    runIdx > mySize ifTrue:[
-found := false
+		found := false
-] ifFalse:[
+	    ] ifFalse:[
-(subString at:i) ~= (self at:runIdx) ifTrue:[
+		(subString at:i) ~= (self at:runIdx) ifTrue:[
-found := false
+		    found := false
-]
+		]
-].
+	    ].
-runIdx := runIdx + 1
+	    runIdx := runIdx + 1
-].
+	].
-found ifTrue:[
+	found ifTrue:[
-^ startIndex
+	    ^ startIndex
-].
+	].
-startIndex := self indexOf:firstChar startingAt:(startIndex + 1)
+	startIndex := self indexOf:firstChar startingAt:(startIndex + 1)
 ].
 ^ exceptionBlock value
 "Modified: 23.2.1996 / 15:35:15 / cg"
 !
 restAfter:keyword withoutSeparators:strip
 "compare the left of the receiver with keyword,
 if it matches return the right.
 Finally, if strip is true, remove whiteSpace.
 This method is used to match and extract lines of the form:
 	something: rest
 where we are interested in rest, but only if the receiver string
 begins with something.
 You may wonder why such a specialized method exists here
 - this is so common when processing mailboxes,
 rcs files, nntp/pop3 responses, that is was considered worth
 a special method here to avoid having the code below a hundred
 	^ rest
 ].
 ^ nil
 "
 'foo: hello world' restAfter:'foo:' withoutSeparators:true
 'funny: something' restAfter:'foo:' withoutSeparators:true
 'foo:     hello world    ' restAfter:'foo:' withoutSeparators:true
 'foo:     hello world    ' restAfter:'foo:' withoutSeparators:false
 "
 "Created: 25.11.1995 / 11:04:18 / cg"
 ! !
 sz := aString size.
 idx := startIndex.
 1 to:sz do:[:i |
-(self at:idx) ~~ (aString at:i) ifTrue:[^ false].
+	(self at:idx) ~~ (aString at:i) ifTrue:[^ false].
-idx := idx + 1
+	idx := idx + 1
 ].
 ^ true
 "
 'hello world' continuesWith:'world' startingAt:6
 'hello world' continuesWith:'world' startingAt:7
 "
 "Created: 12.5.1996 / 15:46:40 / cg"
 "Modified: 26.7.1996 / 19:08:36 / cg"
 !
 "return true, if the receiver ends with something, aStringOrCharacter."
 |s|
 (s := self string) ~~ self ifTrue:[
-^ s endsWith:aStringOrCharacter
+	^ s endsWith:aStringOrCharacter
 ].
 aStringOrCharacter isCharacter ifTrue:[
-^ self last = aStringOrCharacter
+	^ self last = aStringOrCharacter
 ].
 ^ super endsWith:aStringOrCharacter
 "
 'hello world' endsWith:'world'
 'hello world' asText allBold endsWith:'world'
 "
 "Modified: 12.5.1996 / 15:49:18 / cg"
 !
 	char isLetterOrDigit ifFalse:[^ false].
 ].
 ^ true
 "
 'helloWorld' isAlphaNumeric
 'foo1234' isAlphaNumeric
 'f1234' isAlphaNumeric
 '1234' isAlphaNumeric
 '+' isAlphaNumeric
 "
 !
 isBinarySelector
 "treating the receiver as a message selector, return true if its a binary selector"
 binopChars := Scanner binarySelectorCharacters.
 ^ (self conform:[:char | (binopChars includes:char)])
 "
 'foo:bar:' isBinarySelector
 #foo:bar: isBinarySelector
 'hello' isBinarySelector
 '+' isBinarySelector
 '|' isBinarySelector
 '?' isBinarySelector
 ':' isBinarySelector
 'a:' isBinarySelector
 '->' isBinarySelector
 '<->' isBinarySelector
 '::' isBinarySelector
 "
 "Modified: 4.1.1997 / 14:16:14 / cg"
 !
 isNumeric
 "return true, if the receiver is some numeric word;
 i.e. consists only of digits."
 self size == 0 ifTrue:[
-^ false
+	^ false
 ].
 self do:[:char |
-char isDigit ifFalse:[^ false].
+	char isDigit ifFalse:[^ false].
 ].
 ^ true
 "
 'helloWorld' isNumeric
 'foo1234' isNumeric
 'f1234' isNumeric
 '1234' isNumeric
 '+' isNumeric
 "
 !
 levenshteinTo:aString
 "return the levenshtein distance to the argument, aString;
 "
 ^ self levenshteinTo:aString s:4 k:2 c:1 i:2 d:6
 "
 'computer' levenshteinTo:'computer'
 'cOmputer' levenshteinTo:'computer'
 'cOmpuTer' levenshteinTo:'computer'
 'cimputer' levenshteinTo:'computer'
 'cumputer' levenshteinTo:'computer'
 'cmputer' levenshteinTo:'computer'
 'coomputer' levenshteinTo:'computer'
 'ocmprt' levenshteinTo:'computer'
 'computer' levenshteinTo:'computer'
 'ocmputer' levenshteinTo:'computer'
 'cmputer' levenshteinTo:'computer'
 'computer' levenshteinTo:'cmputer'
 'Computer' levenshteinTo:'computer'
 "
 !
 levenshteinTo:aString s:substWeight k:kbdTypoWeight c:caseWeight i:insrtWeight d:deleteWeight
 "parametrized levenshtein.
 return the levenshtein distance to the argument, aString;
 this value corrensponds to the number of replacements that have to be
 made to get aString from the receiver.
 The arguments are the costs for
-s:substitution,
+	s:substitution,
-k:keyboard type (substitution),
+	k:keyboard type (substitution),
-c:case-change,
+	c:case-change,
-i:insertion
+	i:insertion
-d:deletion
+	d:deletion
 of a character.
 See IEEE transactions on Computers 1976 Pg 172 ff"
 |d  "delta matrix"
 len1 "{ Class: SmallInteger }"
 len2 "{ Class: SmallInteger }"
 dim  "{ Class: SmallInteger }"
 prevRow row col
 dimPlus1 "{ Class: SmallInteger }"
 min pp c1 c2|
 len1 := self size.
 len2 := aString size.
 dim := len1 max:len2.
 dimPlus1 := dim + 1.
 d := Array new:dimPlus1.
 1 to:dimPlus1 do:[:i |
-d at:i put:(Array new:dimPlus1)
+	d at:i put:(Array new:dimPlus1)
 ].
 "init help-matrix"
 (d at:1) at:1 put:0.
 row := d at:1.
 1 to:dim do:[:j |
-row at:(j + 1) put:( (row at:j) + insrtWeight )
+	row at:(j + 1) put:( (row at:j) + insrtWeight )
 ].
 1 to:dim do:[:i |
-(d at:(i + 1)) at:1 put:(  ((d at:i) at:1) + deleteWeight )
+	 (d at:(i + 1)) at:1 put:(  ((d at:i) at:1) + deleteWeight )
 ].
 1 to:len1 do:[:i |
-c1 := self at:i.
+	c1 := self at:i.
-1 to:len2 do:[:j |
+	1 to:len2 do:[:j |
-c2 := aString at:j.
+	    c2 := aString at:j.
-(c1 == c2) ifTrue:[
+	    (c1 == c2) ifTrue:[
-pp := 0
+		pp := 0
-] ifFalse:[
+	    ] ifFalse:[
-(c1 asLowercase == c2 asLowercase) ifTrue:[
+		(c1 asLowercase == c2 asLowercase) ifTrue:[
-pp := caseWeight
+		    pp := caseWeight
-] ifFalse:[
+		] ifFalse:[
-pp := substWeight.
+		    pp := substWeight.
-substWeight ~~ kbdTypoWeight ifTrue:[
+		    substWeight ~~ kbdTypoWeight ifTrue:[
-(DoWhatIMeanSupport isKey:c1 asLowercase nextTo:c2 asLowercase) ifTrue:[
+			(DoWhatIMeanSupport isKey:c1 asLowercase nextTo:c2 asLowercase) ifTrue:[
-pp := kbdTypoWeight.
+			    pp := kbdTypoWeight.
-].
+			].
-].
+		    ].
-]
+		]
-].
+	    ].
-prevRow := d at:i.
+	    prevRow := d at:i.
-row := d at:(i + 1).
+	    row := d at:(i + 1).
-col := j + 1.
+	    col := j + 1.
-min := (prevRow at:j) + pp.
+	    min := (prevRow at:j) + pp.
-min := min min:( (row at:j) + insrtWeight).
+	    min := min min:( (row at:j) + insrtWeight).
-min := min min:( (prevRow at:col) + deleteWeight).
+	    min := min min:( (prevRow at:col) + deleteWeight).
-row at:col put: min
+	    row at:col put: min
-]
+	]
 ].
 ^ (d at:(len1 + 1)) at:(len2 + 1)
 !
 "treating the receiver as a message selector, return how many arguments would it take"
 |binopChars firstChar|
 (self size > 2) ifFalse:[
-binopChars := Scanner binarySelectorCharacters.
+	binopChars := Scanner binarySelectorCharacters.
-firstChar := self at:1.
+	firstChar := self at:1.
-(self size == 1) ifTrue:[
+	(self size == 1) ifTrue:[
-(binopChars includes:firstChar) ifFalse:[^ 0].
+	    (binopChars includes:firstChar) ifFalse:[^ 0].
-^ 1
+	    ^ 1
-].
+	].
-(binopChars includes:firstChar) ifTrue:[
+	(binopChars includes:firstChar) ifTrue:[
-(binopChars includes:(self at:2)) ifTrue:[^ 1]
+	    (binopChars includes:(self at:2)) ifTrue:[^ 1]
-]
+	]
 ].
 ^ self occurrencesOf:$:
 "
 'foo:bar:' numArgs
 #foo:bar: numArgs
 'hello' numArgs
 '+' numArgs
 '|' numArgs
 '?' numArgs
 "
 "Modified: 4.1.1997 / 14:16:14 / cg"
 !
 	coll add:(self copyFrom:idx1 to:idx2).
 	idx1 := idx2 + 1
 ].
 "
 'foo:bar:' partsIfSelector
 #foo:bar: partsIfSelector
 'hello' partsIfSelector
 '+' partsIfSelector
 "
 !
 spellAgainst: aString
 "return an integer between 0 and 100 indicating how similar
 the argument is to the receiver.  No case conversion is done.
 This algorithm is much simpler (but also less exact) than the
 levenshtein distance. Experiment which is better for your
 application."
 i1 := i2 := 1.
 [i1 <= size1 and: [i2 <= size2]] whileTrue:[
 	next1 := i1 + 1.
 	next2 := i2 + 1.
 	(self at:i1) == (aString at:i2) ifTrue: [
 	    score := score+1.
 	    i1 := next1.
 	    i2 := next2
 	] ifFalse: [
 	    (i2 < size2 and: [(self at:i1) == (aString at:next2)]) ifTrue: [
 		i2 := next2
 	    ] ifFalse: [
 		(i1 < size1 and: [(self at:next1) == (aString at:i2)]) ifTrue: [
 		    i1 := next1
 		] ifFalse: [
 		    i1 := next1.
 		    i2 := next2
 		]
 	    ]
 	]
 ].
 score == maxLen ifTrue: [^ 100].
 ^ 100 * score // maxLen
 "
 'Smalltalk' spellAgainst: 'Smalltlak'
 'Smalltalk' spellAgainst: 'smalltlak'
 'Smalltalk' spellAgainst: 'smalltalk'
 'Smalltalk' spellAgainst: 'smalltlk'
 'Smalltalk' spellAgainst: 'Smalltolk'
 "
 !
 startsWith:aString
 "return true, if the receiver starts with something, aString.
 If the argument is empty, true is returned."
 |s|
 (s := self string) ~~ self ifTrue:[
-^ s startsWith:aString
+	^ s startsWith:aString
 ].
 ^ super startsWith:aString
 "
 'hello world' startsWith:'hello'
 'hello world' asText allBold startsWith:'hello'
 'hello world' asText allBold startsWith:''
 "
 "Created: 12.5.1996 / 15:46:40 / cg"
 "Modified: 12.5.1996 / 15:49:24 / cg"
 ! !
 ! !
 !CharacterArray class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/CharacterArray.st,v 1.314 2005-04-20 14:59:45 cg Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/CharacterArray.st,v 1.315 2005-04-28 17:29:30 cg Exp $'
 ! !
 CharacterArray initialize!

changeset 8874	f1fdda306d51
parent 8862	6f550a144c6a
child 8875	1d326cc89ff9