"{ Package: 'stx:libbasic2' }"!

!CharacterArray methodsFor:'matching - phonetic'!

asKoelnerPhoneticCode

    "return a koelner phonetic code.

     The koelnerPhonetic code is for the german language what the soundex code is for english;

     it returns simular strings for similar sounding words.

     There are some differences to soundex, though:

	its length is not limited to 4, but depends on the length of the original string;

	it does not start with the first character of the input.

     Caveat: this phonetic code is especially suited for german words.

	     Please have a look at the other phonetic comparison operators found

	     in PhoneticStringUtilities."

    ^ PhoneticStringUtilities koelnerPhoneticCodeOf:self

    "

     #(

	'Müller'

	'Miller'

	'Mueller'

	'Mühler'

	'Mühlherr'

	'Mülherr'

	'Myler'

	'Millar'

	'Myller'

	'Müllar'

	'Müler'

	'Muehler'

	'Mülller'

	'Müllerr'

	'Muehlherr'

	'Muellar'

	'Mueler'

	'Mülleer'

	'Mueller'

	'Nüller'

	'Nyller'

	'Niler'

	'Czerny'

	'Tscherny'

	'Czernie'

	'Tschernie'

	'Schernie'

	'Scherny'

	'Scherno'

	'Czerne'

	'Zerny'

	'Tzernie'

	'Breschnew'

     ) do:[:w |

	 Transcript show:w; show:'->'; showCR:(w asKoelnerPhoneticCode)

     ].

    "

    "

     'Breschnew' asKoelnerPhoneticCode -> '17863'

     'Breschnew' asKoelnerPhoneticCode -> '17863'

     'Breschneff' asKoelnerPhoneticCode -> '17863'

     'Braeschneff' asKoelnerPhoneticCode -> '17863'

     'Braessneff' asKoelnerPhoneticCode -> '17863'

     'Pressneff' asKoelnerPhoneticCode -> '17863'

     'Presznäph' asKoelnerPhoneticCode -> '17863'

    "

! !

!CharacterArray methodsFor:'matching - phonetic'!

asSoundexCode

    "return a soundex phonetic code or nil.

     Soundex returns similar codes for similar sounding words, making it a useful

     tool when searching for words where the correct spelling is unknown.

     (read Knuth or search the web if you don't know what a soundex code is).

     Caveat: 'similar sounding words' means: 'similar sounding in ENGLISH'

             Please have a look at the other phonetic comparison operators found

             in PhoneticStringUtilities."

    ^ PhoneticStringUtilities soundexCodeOf:self

    "

     '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

    "

! !

!CharacterArray methodsFor:'printing & storing'!

printf:args

    "Format and print the receiver with <args> formatted in C style,

     as specified in the Unix C-language manual page for printf(3).

     Return the resulting string (i.e actually, this is more like an sprintf).

     For copyright information, see goodies/String-printf_scanf.chg"

    |aStream|

    aStream := CharacterWriteStream on:(self species uninitializedNew:self size).

    self printf:args on:aStream.

    ^ aStream contents

    "

     ('%05x %d %f %o' printf:{ 123. 234*5. 1.234. 8r377 } )    

     Transcript showCR:('%05x %d %f %o' printf:{ 123. 234*5. 1.234. 8r377 } )

    "

    "

     Transcript showCR: 'Some examples:'!!

     Transcript show:'''%#x %#X %03o%*.*s'' printf: #(16rABCD 16rEF 5 9 5 ''ghijklmn'') = .'.

     Transcript show: ('%#x %#X %03o%*.*s' printf: #(16rABCD 16rEF 5 9 5 'ghijklmn')).

     Transcript showCR: '.'

     Transcript show: '''%- 10.4s%.2e'' printf: (Array with: ''abcdefghijkl'' with: Float pi) = .'.

     Transcript show: ('%- 10.4s%.2e' printf: (Array with: 'abcdefghijkl' with: Float pi)).

     Transcript showCR: '.'

     Transcript show: '''%8.3f'' printf: (Array with: 200 sqrt negated) = .'.

     Transcript show: ('%8.3f' printf: (Array with: 200 sqrt negated)).

     Transcript showCR: '.'

     Transcript show: '''%c'' printf: #(16r41) = .'.

     Transcript show: ('%c' printf: #(16r41)).

     Transcript showCR: '.'

     Transcript show: '''%f%2s%s%s%s'' sscanf: ''237.0 this is a test'' = '.

     Transcript showCR: ('%f%2s%s%s%s'  sscanf: '237.0 this is a test') printString.

     Transcript show: '''%d%f%s'' sscanf: ''25 54.32e-01 monday'' = '.

     Transcript showCR: ('%d%f%s' sscanf: '25 54.32e-01 monday') printString.

     Transcript show: '''%f%*f %8[A-F0-9]%c%d 0x%x%f'' sscanf: ''12.45 1048.73 AE40Z527 0x75BCD15 34'' = '.

     Transcript showCR: ('%f%*f %8[A-F0-9]%c%d 0x%x%f' sscanf: '12.45 1048.73 AE40Z527 0x75BCD15 34') printString.

    "

! !

!CharacterArray methodsFor:'printing & storing'!

printf:args on:outStream

    "Format and print the receiver on <outStream> with <args>

     formatted in C style, as specified in the Unix C-language manual page for printf(3).

     For copyright information, see goodies/String-printf_scanf.chg"

    |argStream inStream char escChar|

    argStream := ReadStream on:args.

    inStream := ReadStream on:self.

    [ inStream atEnd ] whileFalse:[

        (char := inStream next) == $% ifFalse:[

            char == $\ ifTrue:[

                escChar := inStream next.

                escChar == $n ifTrue:[ char := Character nl ]

                ifFalse:[ escChar == $t ifTrue:[ char := Character tab ]

                ifFalse:[ escChar == $r ifTrue:[ char := Character return ]

                ifFalse:[ char := escChar ]]]

            ].        

            outStream nextPut:char

        ] ifTrue:[

            self

                printf_printArgFrom:inStream

                to:outStream

                withData:argStream

        ]

    ]

! !

!CharacterArray methodsFor:'printing & storing'!

printfWith:arg1

    "Format and print the receiver with <arg1> formatted in C style,

     as specified in the Unix C-language manual page for printf(3).

     Return the resulting string (i.e actually, this is more like an sprintf)."

    ^ self printf:(Array with:arg1)

    "

     ('%05x' printfWith:123)

     Transcript showCR:('%05x' printfWith:123)

    "

! !

!CharacterArray methodsFor:'printing & storing'!

printfWith:arg1 with:arg2

    "Format and print the receiver with <argI> formatted in C style,

     as specified in the Unix C-language manual page for printf(3).

     Return the resulting string (i.e actually, this is more like an sprintf)."

    ^ self printf:(Array with:arg1 with:arg2)

    "

     Transcript showCR:('%d %05x' printfWith:123 with:234)

    "

! !

!CharacterArray methodsFor:'printing & storing'!

printfWith:arg1 with:arg2 with:arg3

    "Format and print the receiver with <argI> formatted in C style,

     as specified in the Unix C-language manual page for printf(3).

     Return the resulting string (i.e actually, this is more like an sprintf)."

    ^ self printf:(Array with:arg1 with:arg2 with:arg3)

    "

     Transcript showCR:('%d %05x %08o' printfWith:123 with:234 with:345)

    "

! !

!CharacterArray methodsFor:'printing & storing'!

printfWith:arg1 with:arg2 with:arg3 with:arg4

    "Format and print the receiver with <argI> formatted in C style,

     as specified in the Unix C-language manual page for printf(3).

     Return the resulting string (i.e actually, this is more like an sprintf)."

    ^ self printf:(Array with:arg1 with:arg2 with:arg3 with:arg4)

    "

     Transcript showCR:('%d %05x %08o %b' printfWith:123 with:234 with:345 with:123)

    "

! !

!CharacterArray methodsFor:'printing & storing'!

printf_formatArgCount

    "Return the number of arguments required/produced if the receiver is interpreted

     as a printf/scanf format control string.

     For copyright information, see goodies/String-printf_scanf.chg"

    |nonConsecutive count|

    nonConsecutive := true.

    count := 0.

    self do:[:c |

	c == $% ifTrue:[

	    nonConsecutive ifTrue:[

		count := count + 1.

		nonConsecutive := false

	    ] ifFalse:[

		count := count - 1.

		nonConsecutive := true

	    ]

	] ifFalse:[

	    nonConsecutive := true

	]

    ].

    ^ count

! !

!CharacterArray methodsFor:'private'!

printf_printArgFrom:inStream to:outStream withData:argStream

    "Interpret the required number of arguments from <argStream>

     according to the formatting information in <inStream>.

     Place the interpretation on <outStream>.

     The interpretation is C printf(3) style, as

     specified in the Unix C-language manual page for printf(3).

     <inStream> is assumed to be positioned just past

     $%, and a complete control string is assumed available.

     Return when the conversion control string is consumed.

     Leave <inStream> pointing past the last character in the conversion control string.

     This code assumes that <inStream> is formatted according to

     specification, and error checking is minimal.  Unexpected

     results will be obtained by illegal control strings, or when

     argument types do not match conversion codes, but it probably

     won't dump core, like C does in such cases!!

     For copyright information, see goodies/String-printf_scanf.chg"

    |nextArg ljust plus pound width precision pad char arg argString|

    nextArg := [

                    argStream atEnd ifTrue:[

                        self error:'not enough arguments for format string'

                    ].

                    argStream next

               ].

    ljust := plus := pound := false.

    width := 0.

    precision := SmallInteger maxVal.

    pad := $ .

    char := inStream peek.

    char == $% ifTrue:[

        ^ outStream nextPut:inStream next

    ].

    char == $- ifTrue:[

        ljust := true.

        inStream next.

        char := inStream peek

    ].

    char == $  ifTrue:[

        outStream space.

        inStream next.

        char := inStream peek

    ].

    char == $+ ifTrue:[

        plus := true.

        inStream next.

        char := inStream peek

    ].

    char == $# ifTrue:[

        pound := true.

        inStream next.

        char := inStream peek

    ].

    char == $* ifTrue:[

        width := nextArg value.

        inStream next.

        char := inStream peek

    ].

    char isDigit ifTrue:[

        char == $0 ifTrue:[

            pad := $0

        ].

        width := Integer readFrom:inStream.

        char := inStream peek

    ].

    char == $. ifTrue:[

        inStream next.

        char := inStream peek.

        char == $* ifTrue:[

            precision := nextArg value.

            inStream next.

        ] ifFalse:[

            precision := Integer readFrom:inStream.

        ].

        char := inStream peek

    ].

    char == $l "Ignore long specifier." ifTrue:[

        inStream next.

        char := inStream peek

    ].

    ('feg' includes:char) ifTrue:[

        arg := nextArg value asFloat.

        precision := precision min:6.

        argString := WriteStream on:''.

        char == $g ifTrue:[

            arg absPrintOn:argString digits:precision + 1

        ].

        char == $f ifTrue:[

            arg absDecimalPrintOn:argString digits:precision + arg abs log + 1

        ].

        char == $e ifTrue:[

            arg absScientificPrintOn:argString digits:precision + 1

        ].

        argString := argString contents.

        arg < 0 ifTrue:[

            argString := '-' , argString

        ] ifFalse:[

            plus ifTrue:[

                argString := '+' , argString

            ]

        ].

        (precision = 0 and:[ pound not ]) ifTrue:[

            (argString includes:$e) ifTrue:[

                "self halt"

            ] ifFalse:[

                argString := arg truncated printString

            ]

        ].

        pound ifTrue:[

            (argString includes:$e) ifTrue:[

                "self halt"

            ] ifFalse:[

                precision - (argString size - (argString indexOf:$.)) timesRepeat:[

                    argString := argString , '0'

                ]

            ]

        ].

        ljust ifTrue:[

            outStream nextPutAll:argString

        ].

        width - argString size timesRepeat:[

            outStream space

        ].

        ljust ifFalse:[

            outStream nextPutAll:argString

        ].

        ^ inStream next

    ].

    char == $c ifTrue:[

        arg := String with:nextArg value asCharacter

    ].

    char == $s ifTrue:[

        "Assume the arg is a String or Symbol. (if not, its printString is used)" 

        arg := nextArg value asString

    ].

    char == $d ifTrue:[

        arg := nextArg value asInteger printString.

        plus ifTrue:[

            arg := '+' , arg

        ]

    ].

    char == $u ifTrue:[

        arg := nextArg value asInteger abs printString

    ].

    char == $o ifTrue:[

        arg := nextArg value asInteger abs printStringRadix:8.

        pound ifTrue:[

            arg := '0' , arg

        ]

    ].

    char == $b ifTrue:[

        arg := nextArg value asInteger abs printStringRadix:2.

        pound ifTrue:[

            arg := '0' , arg

        ]

    ].

    ('xX' includes:char) ifTrue:[

        arg := nextArg value asInteger abs printStringRadix:16.

        pound ifTrue:[

            arg := '0x' , arg

        ]

    ].

    char == $x ifTrue:[

        1 to:arg size do:[:i |

            ('ABCDEF' includes:(arg at:i)) ifTrue:[

                arg at:i put:(arg at:i) asLowercase

            ]

        ]

    ].

    precision := precision min:arg size.

    ljust ifTrue:[

        outStream nextPutAll:(arg copyFrom:1 to:precision)

    ].

    width - precision timesRepeat:[

        outStream nextPut:pad

    ].

    ljust ifFalse:[

        outStream nextPutAll:(arg copyFrom:1 to:precision)

    ].

    ^ inStream next

    "Modified: / 24-07-2011 / 07:16:42 / cg"

! !

!CharacterArray methodsFor:'printing & storing'!

printf_printOn:outStream withData:args

    <resource: #obsolete>

    "Format and print the receiver on <outStream> with <args>

     formatted in C style, as specified in the Unix C-language manual page for printf(3).

     For copyright information, see goodies/String-printf_scanf.chg"

    self obsoleteMethodWarning:'use printf:on:'.

    self printf:args on:outStream

! !

!CharacterArray methodsFor:'converting'!

scanf:dataStream

    "Return a Collection of objects found in the Character Stream

     <dataStream> as interpreted according to the receiver.

     The receiver is assumed to be a conversion control string as

     specified in the Unix C-language manual page for scanf(3).

     For copyright information, see goodies/String-printf_scanf.chg"

    |results format char|

    results := OrderedCollection new.

    format := ReadStream on:self.

    [ format atEnd ] whileFalse:[

	char := format next.

	(char == Character space or:[ char == Character tab ]) ifTrue:[

	    dataStream skipSeparators.

	    format skipSeparators

	].