"{ Encoding: utf8 }"

"

 COPYRIGHT (c) 1988 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic' }"

"{ NameSpace: Smalltalk }"

CharacterArray variableByteSubclass:#String

	instanceVariableNames:''

	classVariableNames:'CRLF CR LF TAB'

	poolDictionaries:''

	category:'Collections-Text'

!

!String primitiveDefinitions!

%{

#ifndef _STDIO_H_INCLUDED_

# include <stdio.h>

# define _STDIO_H_INCLUDED_

#endif

#ifndef _STDLIB_H_INCLUDED_

# include <stdlib.h>

# define _STDLIB_H_INCLUDED_

#endif

#ifndef _CTYPE_H_INCLUDED_

# include <ctype.h>

# define _CTYPE_H_INCLUDED_

#endif

#ifdef LINUX

# define __STRINGDEFS__

# include <linuxIntern.h>

#endif

#if defined(__osx__) || defined(__MINGW__)

# ifndef _STRING_H_INCLUDED_

#  include <string.h>

#  define _STRING_H_INCLUDED_

# endif

#endif

/*

 * old st/x creates strings with spaces in it;

 * new st/x will fill it with zeros (for st-80 compatibility)

 * the define below sets old behavior.

 */

#define INITIALIZE_WITH_SPACE

#ifdef FAST_MEMCHR

// # if !defined(__osx__) && !defined(__win32__)

// extern void *memchr();

// # endif

#endif

%}

! !

!String primitiveFunctions!

%{

static int

nextOnKeyboard(int char1, int char2)

{

    /* compare two characters if they are next to each other on a (US-) keyboard */

    static char *us_keys[] = { "1234567890-",

			    "*qwertyuiop",

			    "**asdfghjkl:",

			    "***zxcvbnm",

			    0 };

    static char *de_keys[] = { "1234567890-",

			    "*qwertzuiop",

			    "**asdfghjkl:",

			    "***yxcvbnm",

			    0 };

    char **keys = us_keys;

    char **line1, **line2;

    char *col1, *col2;

    int diff;

    for (line1 = keys; *line1 != 0; line1++) {

	for (col1 = *line1; *col1 != 0 && *col1 != char1; col1++)

	    continue;

    }

    if (*col1 == 0)

	return(0);

    for (line2 = keys; *line2 != 0; line2++) {

	for (col2 = *line2; *col2 != 0 && *col2 != char2; col2++)

	    continue;

    }

    if (*col2 == 0)

	return(0);

    diff = col1 - col2;

    if (diff > 1 || diff < -1)

	return(0);

    diff = line1 - line2;

    if (diff > 1 || diff < -1)

	return(0);

    return(1);

}

%}

! !

!String class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1988 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    Strings are ByteArrays storing Characters.

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

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

    in the string's size, and is not accessible from the Smalltalk level.

    This guarantees, that a Smalltalk string can always be passed to a

    C- or a system api function without danger 

    (of course, this does not prevent a nonsense contents...)

    You cannot add any instvars to String, since the run time system & compiler

    creates literal strings and knows that strings have no named instvars.

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

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

    A little warning though: not all Smalltalk systems allow subclassing String,

    so your program may become unportable if you do so.

    Strings have an implicit (assumed) encoding of ISO-8859-1.

    For strings with other encodings, either keep the encoding separately,

    or use instances of encodedString.

    Be careful when using the 0-byte in a String. This is not prohibited, but

    the implementations of some String methods use C functions and may

    therefore yield unexpected results (e.g. compareWith:collating:) when

    processing a String containing the 0-byte.

    [author:]

        Claus Gittinger

    [see also:]

        Text StringCollection TwoByteString JISEncodedString

        Symbol

"

! !

!String class methodsFor:'instance creation'!

basicNew:anInteger

    "return a new empty string with anInteger characters.

     In contrast to other smalltalks, this returns a string filled

     with spaces (instead of a string filled with 0-bytes).

     This makes much more sense, in that a freshly created string

     can be directly used as separator or for formatting."

%{  /* NOCONTEXT */

#ifdef __SCHTEAM__

    return context._RETURN( self.basicNew( anInteger.intValue() ));

#else

    OBJ newString;

    REGISTER INT len, instsize;

    REGISTER unsigned char *cp;

    int nInstVars;

    // fetch first; check later

    // (if not a smallInteger, value will be ignored anyway)

    len = __intVal(anInteger);

    instsize = OHDR_SIZE + len + 1;

    if (__isSmallInteger(anInteger)) {

        if (len >= 0) {

            if (self == String || self == ImmutableString) {

                if (__CanDoQuickNew(instsize)) {        /* OBJECT ALLOCATION */

                    /*

                     * the most common case

                     */

                    __qCheckedNew(newString, instsize);

                    __InstPtr(newString)->o_class = self; /* no need for PROTECT - there was no GC */

                    __qSTORE(newString, self);

                    cp = __stringVal(newString);

                fillIt:

                    // fill bytes at cp

# if defined(memset4)

                    {

                        /*

                         * no sizeof(int) here please -

                         * - memset4 (if defined) fills 4-bytes on ALL machines

                         */

                        int l4 = len >> 2;

                        if (len & 3) l4++;

                        memset4(cp, 0x20202020, l4);

                        cp[len] = '\0';

                    }

# else

#  ifdef FAST_MEMSET

                    memset(cp, ' ', len);

                    cp[len] = '\0';

#  else

                    for ( ; len >= 8; cp += 8, len -= 8) {

#   ifdef INT64

                        ((INT64 *)cp)[0] = 0x2020202020202020L;

#   else

                        ((int *)cp)[0] = 0x20202020;

                        ((int *)cp)[1] = 0x20202020;

#   endif

                    }

                    while (len--)

                        *cp++ = ' ';

                    *cp = '\0';

#  endif /* not FAST_MEMSET */

# endif /* not memset4 */

                    RETURN (newString);

                }

                nInstVars = 0;

            } else {

                nInstVars = __intVal(__ClassInstPtr(self)->c_ninstvars);

                instsize += __OBJS2BYTES__(nInstVars);

            }

            __PROTECT_CONTEXT__;

            __qNew(newString, instsize);        /* OBJECT ALLOCATION */

            __UNPROTECT_CONTEXT__;

            if (newString == nil) goto fail;

            __InstPtr(newString)->o_class = self;

            __qSTORE(newString, self);

            cp = __stringVal(newString);

            if (nInstVars) {

                OBJ *op;

                cp += __OBJS2BYTES__(nInstVars);

                /*

                 * nil-out instvars

                 */

# if defined(memset4)

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

# else

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

                /*

                 * knowing that nil is 0

                 */

                memset(__InstPtr(newString)->i_instvars, 0, __OBJS2BYTES__(nInstVars));

#  else

                op = __InstPtr(newString)->i_instvars;

                do {

                    *op++ = nil;

                } while (--nInstVars);

#  endif  /* !FAST_MEMSET */

# endif

            }

            goto fillIt;

        }

    }

fail: ;;

#endif /* not __SCHTEAM__ */

%}.

    "

     invalid argument, or out-of-memory:

     use error handling in superclass

    "

    (anInteger < 0) ifTrue:[

        "

         the argument is negative,

        "

        self argumentError:'bad (negative) argument to new:' with:anInteger.

        ^ nil

    ].

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

    "Modified: / 24-03-2019 / 10:07:43 / Claus Gittinger"

!

new:n

    "return a new empty string with n characters.

     In contrast to other smalltalks, this returns a string filled

     with spaces (instead of a string filled with 0-bytes).

     This makes much more sense, in that a freshly created string

     can be directly used as separator or for formatting.

     Redefined here with exactly the same code as in Behavior for

     better performance. "

    ^ self basicNew:n

!

readFrom:aStreamOrString onError:exceptionBlock

    "read & return the next String from the (character-)stream aStream;

     skipping all whitespace first; return the value of exceptionBlock,

     if no string can be read. The sequence of characters as read from the

     stream must be one as stored via storeOn: or storeString."

    "

     this method is not to be inherited

     (i.e. not ok for subclasses; Symbol, for example)

    "

    self ~~ String ifTrue:[

	^ super readFrom:aStreamOrString onError:exceptionBlock

    ].

    ^ self readSmalltalkStringFrom:aStreamOrString onError:exceptionBlock

    "

     String readFrom:('''hello world''' readStream)

     String readFrom:('''hello '''' world''' readStream)

     String readFrom:('1 ''hello'' ' readStream)

     String readFrom:('1 ''hello'' ' readStream) onError:['foobar']

    "

    "Modified: / 05-07-2006 / 16:41:29 / cg"

    "Modified: / 07-08-2006 / 15:03:09 / fm"

!

uninitializedNew:anInteger

    "return a new string with anInteger characters but undefined contents.

     Use this, if the string is filled anyway with new data, for example, if

     used as a stream buffer."

%{  /* NOCONTEXT */

#ifdef __SCHTEAM__

    return context._RETURN( self.basicNew( anInteger.intValue() ));

#else

    OBJ newString;

    REGISTER int len;

    REGISTER unsigned char *cp;

    REGISTER OBJ *op;

    int nInstVars, instsize;

    // fetch first; check later

    // (if not a smallInteger, value will be ignored anyway)

    len = __intVal(anInteger);

    instsize = OHDR_SIZE + len + 1;

    if (__isSmallInteger(anInteger)) {

        if (len >= 0) {

            if (self == String) {

                if (__CanDoQuickNew(instsize)) {        /* OBJECT ALLOCATION */

                    /*

                     * the most common case

                     */

                    __qCheckedNew(newString, instsize);

                    __InstPtr(newString)->o_class = self; /* no need for PROTECT - there was no GC */

                    __qSTORE(newString, self);

                    cp = __stringVal(newString);

                    cp[len] = '\0';

                    RETURN (newString);

                }

                nInstVars = 0;

            } else {

                nInstVars = __intVal(__ClassInstPtr(self)->c_ninstvars);

                instsize += __OBJS2BYTES__(nInstVars);

            }

            __PROTECT_CONTEXT__;

            __qNew(newString, instsize);        /* OBJECT ALLOCATION */

            __UNPROTECT_CONTEXT__;

            if (newString == nil) goto fail;

            __InstPtr(newString)->o_class = self;

            __qSTORE(newString, self);

            if (nInstVars) {

                /*

                 * nil-out instvars

                 */

# if defined(memset4)

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

# else

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

                /*

                 * knowing that nil is 0

                 */

                memset(__InstPtr(newString)->i_instvars, 0, __OBJS2BYTES__(nInstVars));

#  else

                op = __InstPtr(newString)->i_instvars;

                do {

                    *op++ = nil;

                } while (--nInstVars);

#  endif

# endif

                cp = __stringVal(newString) + __OBJS2BYTES__(nInstVars);

            } else {

                cp = __stringVal(newString);

            }

            cp[len] = '\0';

            RETURN (newString);

        }

    }

fail: ;;

#endif /* not __SCHTEAM__ */

%}.

    "

     invalid argument, or out-of-memory:

     use error handling in superclass

    "

    (anInteger < 0) ifTrue:[

        "

         the argument is negative,

        "

        self argumentError:'bad (negative) argument to new:' with:anInteger.

        ^ nil

    ].

    ^ self basicNew:anInteger

    "

     String uninitializedNew:100

    "

    "Modified: / 24-03-2019 / 10:08:04 / Claus Gittinger"

! !

!String class methodsFor:'Compatibility-Dolphin'!

lineDelimiter

    "Dolphin compatibility: answer CR LF"

    ^ self crlf

! !

!String class methodsFor:'Compatibility-Squeak'!

cr

    "return a string consisting of the cr-Character"

    "/ ATTENTION: you get a NL (for compatibility) here!!

    "/ please use String return  / String lf

    self breakPoint:'please make it explicit, if a return or a linefeed is wanted.'.

    "/ for now.

    "/ will be changed, when the historic UNIX baggage is removed

    "/ and all cr's are really returns (instead of nl's).

    ^ self lf

!

crlf

    "return a string consisting of the cr-lf Characters"

    CRLF isNil ifTrue:[

	CRLF := String

		    with:Character return

		    with:Character linefeed

    ].

    ^ CRLF

!

lf

    "return a string consisting of the lf Character"

    LF isNil ifTrue:[

	LF := String with:Character linefeed

    ].

    ^ LF

!