"

 COPYRIGHT (c) 1988 by Claus Gittinger

 COPYRIGHT (c) 2009-2010 Jan Vrany

 COPYRIGHT (c) 2015 Jan Vrany

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

String variableByteSubclass:#Symbol

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	category:'Collections-Text'

!

!Symbol class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1988 by Claus Gittinger

 COPYRIGHT (c) 2009-2010 Jan Vrany

 COPYRIGHT (c) 2015 Jan Vrany

	      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

"

    Symbols represent unique strings - every symbol with same printString

    exists exactly once in the system; Symbols are used for selectors, global

    variable-keys etc. Symbols can also be used to represent things which are

    enumeration type values in other programming languages (since symbols are

    created at compile time, comparing them using == is a fast pointer compare).

    A symbol may not change its characters - i.e. it is constant over its lifetime.

    Other than that, symbols behave much like strings.

    The most prominent use of symbols is as key for message sending: methods are stored

    in a classes method dictionary, where symbols are used as key to map names to methods.

    Also, symbols are used as key to map class names (global names) to actual class objects.

    Special ST/X feature:

	The ST/X VM method lookup supports selector namespaces for method extensions.

	This means, that a class may contain method extensions in another namespace,

	which are only seen and invoked if called from a class within that namespace.

	Technically, this is done by storing the method under a special namespace-selector,

	which is a symbol consisting of the user visible name, prefixed by ':<ns>::'.

	The VM's method lookup algorithm contains special handling code for such constructs.

	Thus, if two methods are stored as 'foo' and ':NS::foo' are present in a class,

	any send of 'foo' from wthin the NS-namespace will invoke the second method.

	Any other send will invoke the first one.

    [author:]

	Claus Gittinger

"

! !

!Symbol class methodsFor:'instance creation'!

basicNew:size

    "redefined to return a string instead of a symbol -

     this allows all copy methods inherited from String to

     return strings containing the symbols characters.

     Real symbols are only created with #intern: or #asSymbol."

    ^ String new:size

    "Modified: 26.2.1996 / 12:51:38 / cg"

!

fromString:aString

    "same as intern: for Symbol, but may be used to create interned instances

     of subclasses.

     Notice: this fails, if you try to intern an instance of a subclass, AND

     a symbol with the same name already exists. In this case, the original

     symbol is returned. To use it for enum-type symbols, make certain, that the

     names are unique (for example by including the classes name as a prefix-string)."

    |sym len|

    sym := aString asSymbolIfInterned.

    sym notNil ifTrue:[

	^ sym

    ].

    "

     create a new uninterned instance first

    "

    len := aString size.

    sym := super basicNew:len.

    sym replaceFrom:1 to:len with:aString.

    "now, intern it"

%{

    sym = __INTERNSYMBOL(sym, (OBJ *)0, __context);

%}.

    ^ sym

!

intern:aString

    "return a unique symbol with printname taken from the String-argument"

%{  /* NOCONTEXT */

    OBJ newSymbol;

    if (__isSymbol(aString)) {

	RETURN (aString);

    }

    if (__isStringLike(aString)) {

	newSymbol = __MKSYMBOL(__stringVal(aString), (OBJ *)0);

	if (newSymbol != nil) {

	    RETURN (newSymbol);

	}

    }

%}.

    (aString class ~~ String and:[aString class ~~ ImmutableString]) ifTrue:[

	"only allowed to intern strings"

	^ self mustBeString

    ].

    ^ AllocationFailure raise.

!

internCharacter:aCharacter

    "return a unique symbol with printname taken from the Character-argument"

    ^ self intern:(aCharacter asString)

!

new:size

    "redefined to return a string instead of a symbol -

     this allows all copy methods inherited from String to

     return strings containing the symbols characters.

     Real symbols are only created with intern: or asSymbol."

    ^ String new:size

! !

!Symbol class methodsFor:'queries'!

findInterned:aString

    "for ST-80 compatibility - if the argument, aString is known

     as Symbol, return this symbol. Otherwise return nil."

    ^ aString asSymbolIfInterned

!

hasInterned:aString

    "return true, if the argument, aString is known as Symbol;

     false otherwise"

    ^ aString knownAsSymbol

!

hasInterned:aString ifTrue:trueBlock

    "for ST-80 compatibility - if the argument, aString is known

     as Symbol, evaluate the block with the corresponding symbol

     as argument and return true; otherwise return false"

    |sym|

    (sym := aString asSymbolIfInterned) notNil ifTrue:[

	trueBlock value:sym.

	^ true

    ].

    ^ false

!

hasSharedInstances

    "return true if this class has shared instances, that is, instances

     with the same value are identical.

     True returned here - there is only one of each symbol (per contents)."

    ^ true

! !

!Symbol methodsFor:'Compatibility-Squeak'!

precedence

    "the precedence in an expression; 0 is highest;

	unary < binary < keyword"

    self size = 0

	ifTrue: [^ 0].

    self first isLetter

	ifFalse: [^ 2].

    self last = $:

	ifTrue: [^ 3].

    ^ 1

    "

     self assert:(#foo precedence < #+ precedence).

     self assert:(#+ precedence < #key: precedence).

     self assert:(#foo precedence < #key: precedence).

    "

    "Created: / 12-09-2011 / 14:53:54 / cg"

! !

!Symbol methodsFor:'Compatibility-VW'!

<< catalogID

    "create and return a new UserMessage, with the receiver as key,

     and the argument as cataglogID.

     VW compatibility."

    ^ UserMessage key:self catalogID:catalogID

    "

     (#theFooMessage << #myMessages)

     (#theFooMessage << #myMessages >> 'cannot read subclass of metaclass')

     (#theFooMessage >> 'cannot read subclass of metaclass')

    "

!

>> aString

    "create and return a new UserMessage, with the receiver as key,

     and the argument as defaultString.

     VW compatibility."

    ^ UserMessage key:self defaultString:aString

    "

     (#theFooMessage << #myMessages)

     (#theFooMessage << #myMessages >> 'cannot read subclass of metaclass')

     (#theFooMessage >> 'cannot read subclass of metaclass')

    "

! !

!Symbol methodsFor:'accessing'!

basicAt:index put:something

    "report an error if an interned symbol is about to be changed

     - interned symbols may NOT be changed.

     For uninterned symbols, this is allowed."

    self knownAsSymbol ifTrue:[

	self noModificationError.

	"Even if you hit continue - you cannot change symbols.

	 Raise again non-resumable"

	NoModificationError raiseWith:self errorString:' - interned symbols cannot be changed'.

    ].

    "

     uninterned - allow change

    "

    ^ super basicAt:index put:something

    "Modified: 19.4.1996 / 11:16:10 / cg"

!

nameSpace

    "if I have the format of a namespace-selector,

     retrieve the namespace. Otherwise, return nil.

     Also return nil, if that namespace does not exist (in contrast to nameSpacePart).

     Namespace selectors have a special, fix defined format, which is also known in the VM.

     They must be of the form :<ns>::<sel>,

     where <ns> is the namespace and <sel> is the raw selector.

     This special format (a symbol starting with a colon) was chosen, because almost every other selector

     is legal, and this can be checked quickly by just looking at the first character."

     |nsPart|

     nsPart := self nameSpaceAndSelectorParts first.

     nsPart isNil ifTrue:[^ nil].

     ^ Smalltalk at:nsPart asSymbol

    "

     #':foo:' nameSpace       -> nil (bad format)

     #':foo::bar' nameSpace   -> nil (non existing)

     #':Tools::bar' nameSpace -> Tools

     #'bar' nameSpace -> nil

     #'bar:' nameSpace -> nil

    "

    "Created: / 20-07-2010 / 10:41:53 / Jan Vrany <jan.vrany@fit.cvut.cz>"

!

nameSpaceAndSelector

    "return a two element tuple consisting of the namespace and the raw selector.

     If I do not have the format of a namespace-selector, or the namespace is non-existing,

     the first element of the returned tuple will be nil.

     Namespace selectors have a special, fix defined format, which is also known in the VM.

     They must be of the form :<ns>::<sel>,

     where <ns> is the namespace and <sel> is the raw selector.

     This special format (a symbol starting with a colon) was chosen, because almost every other selector

     is legal, and this can be checked quickly by just looking at the first character."

    |parts ns|

    self isNameSpaceSelector ifFalse:[

	^ Array with:nil with:self

    ].

    parts := self nameSpaceAndSelectorParts.

    ns := Smalltalk at:parts first asSymbol.

    ^ Array with:ns with:parts second

    "

     #':foo:bar' nameSpaceAndSelector     -> #(nil #':foo:bar')

     #':foo::bar' nameSpaceAndSelector    -> #(nil #bar)

     #':Tools::foo' nameSpaceAndSelector  -> #(Tools (* NameSpace *) #foo)

    "

    "Created: / 20-07-2010 / 10:23:36 / Jan Vrany <jan.vrany@fit.cvut.cz>"

!

nameSpaceAndSelectorParts

    "return a two element tuple consisting of the namespace name and the raw selector.

     If I do not have the format of a namespace-selector,

     the first element of the returned tuple will be nil.

     Namespace selectors have a special, fix defined format, which is also known in the VM.

     They must be of the form :<ns>::<sel>,

     where <ns> is the namespace and <sel> is the raw selector.

     This special format (a symbol starting with a colon) was chosen, because almost every other selector

     is legal, and this can be checked quickly by just looking at the first character."

     |nsPart selPart idx|

    self isNameSpaceSelector ifFalse:[

	^ Array with:nil with:self

    ].

    idx := self indexOf:$: startingAt:3.

    nsPart := self copyFrom:2 to:idx - 1.

    selPart := self copyFrom:idx + 2.

    ^ Array with:nsPart with:selPart asSymbol

    "

     #':foo:bar' nameSpaceAndSelectorParts     -> #(nil #':foo:bar')

     #':foo:bar' nameSpaceAndSelector          -> #(nil #':foo:bar')

     #':foo::bar' nameSpaceAndSelectorParts    -> #('foo' #bar)

     #':foo::bar' nameSpaceAndSelector         -> #(nil #bar)

     #'bar' nameSpaceAndSelectorParts          -> #(nil #bar)

     #'bar' nameSpaceAndSelector               -> #(nil #bar)

     #':Tools::foo' nameSpaceAndSelectorParts  -> #('Tools' #foo)

     #':Tools::foo' nameSpaceAndSelector       -> #(Tools (* NameSpace *) #foo)

    "

    "Created: / 20-07-2010 / 10:23:36 / Jan Vrany <jan.vrany@fit.cvut.cz>"

!

nameSpacePart

    "if I have the format of a namespace-selector,

     retrieve the namespace name. Otherwise, return nil.

     Namespace selectors have a special, fix defined format, which is also known in the VM.

     They must be of the form :<ns>::<sel>,

     where <ns> is the namespace and <sel> is the raw selector.

     This special format (a symbol starting with a colon) was chosen, because almost every other selector

     is legal, and this can be checked quickly by just looking at the first character."

     ^ self nameSpaceAndSelectorParts first.

    "

     #':foo:' nameSpacePart       -> nil (bad format)

     #':foo::bar' nameSpacePart   -> 'foo'

     #':Tools::bar' nameSpacePart -> 'Tools'

    "

!

selector

    <resource: #obsolete>

    "if I have the format of a namespace-selector, retrieve the raw selector.

     Otherwise, return myself.

     Namespace selectors have a special, fix defined format, which is also known in the VM.

     They must be of the form :<ns>::<sel>,

     where <ns> is the namespace and <sel> is the raw selector.

     This special format (a symbol starting with a colon) was chosen,

     because almost every other selector is legal,

     and this can be checked quickly in the VM, by just looking at the first character."

     self obsoleteMethodWarning:'use selectorWithoutNameSpace'.

    ^ self selectorWithoutNameSpace

!

selectorWithoutNameSpace

    "if I have the format of a namespace-selector, retrieve the raw selector.

     Otherwise, return myself.

     Namespace selectors have a special, fix defined format, which is also known in the VM.

     They must be of the form :<ns>::<sel>,

     where <ns> is the namespace and <sel> is the raw selector.

     This special format (a symbol starting with a colon) was chosen, because almost every other selector

     is legal, and this can be checked quickly by just looking at the first character."

     ^ self nameSpaceAndSelectorParts second

    "

     #':foo:' selectorWithoutNameSpace       -> #':foo:' (bad format)

     #':foo::bar' selectorWithoutNameSpace   -> bar

     #':Tools::bar' selectorWithoutNameSpace -> bar

    "

    "Created: / 20-07-2010 / 10:41:32 / Jan Vrany <jan.vrany@fit.cvut.cz>"

! !

!Symbol methodsFor:'comparing'!

= something

    "return true, if the receiver and argument consist of the same characters.

     Redefined here, for more efficient comparison of symbols

     (which can to be compared using #==).

     If the argument is a symbol, we use a quick pointer compare, instead of

     the inherited value compare."

%{   /* NOCONTEXT */

#ifdef __SCHTEAM__

    if (something.isSymbol()) {

	return context._RETURN ( self == something ? STObject.True : STObject.False );

    }

    if (something.isSTString()) {

	return context._RETURN ( something.isStringEqual(self) ? STObject.True : STObject.False );

    }

    if (something == STObject.Nil) {

	return context._RETURN_false ( );

    }

#else

    OBJ cls;

    if (something == self) RETURN(true);

    if (! __isNonNilObject(something)) RETURN(false);

    if ((cls = __qClass(something)) == Symbol) {

	RETURN (false);

    }

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

	RETURN (strcmp(__stringVal(self), __stringVal(something)) == 0 ? true : false);

    }

#endif

%}.

    "fall back; could be a TwoByteString, or a collection of Characters"

    ^ super = something

!

hash

    "return an integer useful as a hash-key.

     This default method uses whichever hash algorithm

     used in the ST/X VM (which is actually fnv-1a)"

%{  /* NOCONTEXT */

#ifdef __SCHTEAM__

    STString me = self.asSTString();

    long h = me.hash_fnv1a();

    return __c__._RETURN(STInteger._new(h));

#else

    extern unsigned int __symbolHash(char *);

    unsigned char *cp;

    unsigned int h;

    cp = __stringVal(self);

    if (__qClass(self) == Symbol) {    

	cont:

	/* Use __symbolHash() to make sure it's the same used by the VM */

	h = __symbolHash(cp);

	RETURN(__mkSmallInteger(h));

    } else {

	int n = __OBJS2BYTES__(__intVal(__ClassInstPtr(__qClass(self))->c_ninstvars));

	cp += n;    

	goto cont;

    }

#endif /* not SCHTEAM */

%}.