GemStone Smalltalk Syntax

GemStone and ANSI limits

The limits in GemStone, such as the maximum length of an identifier, are generally higher than the ANSI minimum requirement. While this makes working in GemStone more flexible, adhering to the ANSI limits, or the limits for other Smalltalk dialects, makes it easier to port GemStone code to other platforms.

How to Create a New Class

Classes are created using a number of class creation methods, defined on the class Class. For example, following message expression makes a new subclass of class Object, the class at the top of the class hierarchy:

Object subclass: 'Animal'

	instVarNames: #()

	classVars: #()

	classInstVars: #()

	poolDictionaries: {}

	inDictionary: UserGlobals

This subclass creation message establishes a name (’Animal’) for the new class and installs the new class in a Dictionary called UserGlobals. The String used for the new class’s name must follow the general rule for variable names — that is, it must begin with an alphabetic character and its length must not exceed 1024 characters. Installing the class in UserGlobals makes it available for use in the future—you need only write the name Animal in your code to refer to the new class. For more on class creation, see Chapter 2.

Statements

The basic syntactic unit of a Smalltalk program is the statement. A lone statement needs no delimiters; multiple statements are separated by periods:

a := 2.

b := 3.

In a group of statements to be executed en masse, a period after the last statement is optional.

A statement contains one or more expressions, combining them to perform some reasonable unit of work, such as an assignment or retrieval of an object.

Comments

GemStone Smalltalk usually treats a string of characters enclosed in quotation marks as a comment—a descriptive remark to be ignored during compilation. Here is an example:

"This is a comment."

A quotation mark does not begin a comment in the following cases:

• Within another comment. You cannot nest comments.
• Within a string literal (String Literals). Within a GemStone Smalltalk string literal, a “comment” becomes part of the string.
• When it immediately follows a dollar sign ($). GemStone Smalltalk interprets the first character after a dollar sign as a data object called a character literal (Character Literals).

A comment terminates tokens such as numbers and variable names. For example, GemStone Smalltalk would interpret the following as two numbers separated by a space (by itself, an invalid expression):

2" this comment acts as a token terminator"345

Expressions

An expression is a sequence of characters that Smalltalk can interpret as a reference to an object. Some references are direct, and some are indirect.

Expressions that name objects directly include both variable names and literals such as numbers and strings. The values of those expressions are the objects they name.

An expression that refers to an object indirectly by specifying a message invocation has the value returned by the message’s receiver. You can use such an expression anywhere you might use an ordinary literal or a variable name. This expression:

2 negated

has the value (refers to) -2, the object that 2 returns in response to the message negated.

The following sections describe the syntax of GemStone Smalltalk expressions and tell you something about their behavior.

A GemStone Smalltalk expression can contain a combination of the following:

• a literal
• a variable name
• an assignment
• a message expression
• an array constructor
• a path
• a block

The following sections discuss each of these kinds of expression in turn.

5 + 5

5.0

8.0e2

1e-3 represents 0.001 

1.5e0 represents 1.5

8#23 

16rFF

$b  $B  $4  $?  $$

$ . "Creates the character representing a space (ASCII 32)"

'Intellectual passion drives out sensuality.'

'A difference of taste in jokes is a great strain on the affections.'

'You can''t make omelettes without breaking eggs.'

'Control characters such as line feeds are significant in literal strings.'

'Škoda'

#stuff

#nonsense

#may_24_thisYear

#'Gone With the Wind'

#('string one' 'string two' #('another' 'Array') 'string3')

#('string one' #symbolOne $c 4 true)

#[99 97 116]

Variables and Variable Names

A variable name is a sequence of characters of either or both cases. A variable name must begin with an alphabetic character or an underscore (“_”), but it can contain numerals. Spaces are not allowed, and the underscore is the only acceptable punctuation mark. Here are some permissible variable names:

zero

relationalOperator

Top10SolidGold

A_good_name_is_better_than_precious_ointment

Most Smalltalk programmers begin local variable names with lowercase letters and global variable names with uppercase letters. When a variable name contains several words, Smalltalk programmers usually begin each word with an uppercase letter (sometimes called “camelcase”). You are free to ignore either of these conventions, but remember that Smalltalk is case-sensitive. The following are all different names to Smalltalk:

VariableName

variableName

variablename

Variable names can contain up to 1024 characters.

| myTempVariable |

myTempVariable := 2.

| myTempVariable |

myTempVariable := 2. 

UserGlobals at: #MyPermanentVariable put: myTempVariable.

Assignment

Assignment statements in Smalltalk look like assignment statements in many other languages. The following statement assigns the value 2 to the variable MightySmallInteger:

MightySmallInteger := 2.

The next statement assigns the same String to two different variables (C programmers may notice the similarity to C assignment syntax):

nonmodularity := interdependence := 'No man is an island'.

Message Expressions

Smalltalk objects communicate with one another by means of messages. Most of your effort in Smalltalk programming will be spent in writing expressions in which messages are passed between objects. This subsection discusses the syntax of those message expressions.

You have already seen several examples of message expressions:

2 + 2 

5 + 5

In fact, the only GemStone Smalltalk code segments you have seen that are not message expressions are literals, variables, and simple assignments:

2                           "a literal"

variableName                "a variable"

MightySmallInteger := 2.    "an assignment"

The ubiquity of message-passing is one of the hallmarks of object-oriented programming.

Reserved and Optimized Selectors

GemStone represents selectors internally as symbols, and almost all symbols that confirm to the unary, binary, or keyword selector patterns are acceptable as a selectors. For details on legal selectors, see the BNF here.

There are a few selectors that have been reserved for the sole use of the GemStone kernel classes. The compiler will not allow you to compile methods with reserved selectors. To see the list of reserved and optimized selectors, execute:

GsNMethod optimizedSelectors

These selectors are reserved:

In addition, the following methods are optimized or inlined in the class SmallInteger:

+	-	*	=	~=	<	<=	>	>=

Messages as Expressions

In the following message expression, the object 2 is the receiver, + is the selector, and 8 is the argument:

2 + 8

When 2 sees the selector +, it looks up the selector in its private memory and finds instructions to add the argument (8) to itself and to return the result. In other words, the selector + tells the receiver 2 what to do with the argument 8. The object 2 returns another numeric object 10, which can be stored with an assignment:

myDecimal := 2 + 8.

The selectors that an object understands (that is, the selectors for which instructions are stored in an object’s instruction memory or “method dictionary”) are determined by the object’s class.

7 negated

-7

9 reciprocal.  "returns the reciprocal of 9"

myArray last.  "returns the last element of Array myArray"

DateTime now.  "returns the current date and time"

8 * 8 	"returns 64"

4 < 5 	"returns true"

myObject = yourObject "returns true if myObject and 

	yourObject have the same value"

7 rem: 3 "returns the remainder from the division of 7 by 3"

| arrayOfStrings |

arrayOfStrings := Array new: 4.

arrayOfStrings at: (2 + 1) put: 'Curly'.

"puts 'Curly' at index position 3 in the receiver"

Combining Message Expressions

In a previous example, one message expression was nested within another, and parentheses set off the inner expression to make the order of evaluation clear. It happens that the parentheses were optional in that example. However, in GemStone Smalltalk as in most other languages, you sometimes need parentheses to force the compiler to interpret complex expressions in the order you prefer.

Combinations of unary messages are quite simple; GemStone Smalltalk always groups them from left to right and evaluates them in that order. For example:

9 reciprocal negated

is evaluated as if it were parenthesized like this:

(9 reciprocal) negated

That is, the numeric object returned by 9 reciprocal is sent the message negated.

Binary messages are also invariably grouped from left to right. For example, GemStone Smalltalk evaluates:

2 + 3 * 2

as if the expression were parenthesized like this:

(2 + 3) * 2

This expression returns 10. It may be read: “Take the result of sending + 3 to 2, and send that object the message * 2.”

All binary selectors have the same precedence. Only the sequence of a string of binary selectors determines their order of evaluation; the identity of the selectors doesn’t matter.

However, when you combine unary messages with binary messages, the unary messages take precedence. Consider the following expression, which contains the binary selector + and the unary selector negated:

2 + 2 negated

0

This expression returns the result 0 because the expression 2 negated executes before the binary message expression 2 + 2. To get the result you may have expected here, you would need to parenthesize the binary expression like this:

(2 + 2) negated

-4

Finally, binary messages take precedence over keyword messages. For example:

myArrayOfNums at: 2 * 2

would be interpreted as a reference to myArrayofNums at position 4. To multiply the number at the second position in myArrayOfNums by 2, you would need to use parentheses like this:

(myArrayOfNums at: 2) * 2

Cascaded Messages

You will often want to send a series of messages to the same object. By cascading the messages, you can avoid having to repeat the name of the receiver for each message. A cascaded message expression consists of the name of the receiver, a message, a semicolon, and any number of subsequent messages separated by semicolons.

For example:

| arrayOfPoets |

arrayOfPoets := Array new.

(arrayOfPoets add: 'cummings'; add: 'Byron'; add: 'Rimbaud';

yourself)

is a cascaded message expression that is equivalent to this series of statements:

| arrayOfPoets |

arrayOfPoets := Array new.

arrayOfPoets add: 'cummings'.

arrayOfPoets add: 'Byron'.

arrayOfPoets add: 'Rimbaud'.

arrayOfPoets

You can cascade any sequence of messages to an object. And, as always, you are free to replace the receiver’s name with an expression whose value is the receiver.

Array Constructors

Most of the syntax described in this chapter so far is standard Smalltalk syntax. However, GemStone Smalltalk also includes a syntactic construct called a Array constructor. An Array constructor is similar to a literal array, but its elements can be written as nonliteral expressions as well as literals. GemStone Smalltalk evaluates the expressions in an Array constructor at run time.

Array constructors look a lot like literal Arrays; the differences are that array constructors are enclosed in braces and have their elements delimited by periods.

The following example shows an Array constructor whose last element, represented by a message expression, has the value 4.

"An Array constructor"

{'string one' . #SymbolOne . $c . 2+2}

NOTE
The Array constructor is not part of the Smalltalk standard. You should avoid its use in any code that might be ported to an other Smalltalk dialect. Instead, use a message send constructor such as Array class >> #with:, such as Array with: 'string one' with: $c with: 2+2.

Because any valid GemStone Smalltalk expression is acceptable as an array constructor element, you are free to use variable names as well as literals and message expressions:

| aString aSymbol aCharacter aNumber |

aString := 'string one'.

aSymbol := #symbolOne.

aCharacter := $c.

aNumber := 4.

{aString . aSymbol . aCharacter . aNumber}

The differences in the behavior of array constructors versus literal arrays can be subtle. For example, the literal array:

#(123 huh 456)

is interpreted as an array of three elements: a SmallInteger, aSymbol, and another SmallInteger. This is true even if you declare the value of huh to be a SmallInteger such as 88, as shown in this example:

| huh |

huh := 88.

#( 123 huh 456 )

[20176897 sz:3 cls: 66817 Array] an Array

  #1 [986 sz:0 cls: 74241 SmallInteger] 123 == 0x7b

  #2 [27086593 sz:3 cls: 110849 Symbol] huh

  #3 [3650 sz:0 cls: 74241 SmallInteger] 456 == 0x1c8

The same declaration used in an array constructor, however, produces an array of three SmallIntegers:

| huh |

huh := 88.

{ 123 . huh . 456 }

[20192001 sz:3 cls: 66817 Array] an Array

  #1 [986 sz:0 cls: 74241 SmallInteger] 123 == 0x7b

  #2 [706 sz:0 cls: 74241 SmallInteger] 88 == 0x58

  #3 [3650 sz:0 cls: 74241 SmallInteger] 456 == 0x1c8

Path Expressions

With the exception of Array constructors, most of the syntax described in this chapter so far is standard Smalltalk syntax. GemStone Smalltalk also includes a syntactic construct called a path. A path is a special kind of expression that returns the value of an instance variable.

A path is an expression that contains the names of one or more instance variables separated by periods; a path returns the value of the last instance variable in the series. The sequence of the names reflects the order of the objects’ nesting; the outermost object appears first in a path, and the innermost object appears last. The following path points to the instance variable name, which is contained in the object anEmployee:

anEmployee.name

The path in this example returns the value of instance variable name within anEmployee.

If the instance variable name contained another instance variable called last, the following expression would return the value of last:

anEmployee.name.last

NOTE
Use paths only for their intended purposes. Although you can use a path anywhere an expression is acceptable in a GemStone Smalltalk program, paths are intended for specifying indexes, formulating queries, and sorting. In other contexts, a path returns its value less efficiently than an equivalent message expression. Paths also violate the encapsulation that is one of the strengths of the object-oriented data model. Using them can circumvent the designer’s intention. Finally, paths are not standard Smalltalk syntax. Therefore, programs using them are less portable than other GemStone Smalltalk programs.

Returning Values

Previous discussions have spoken of the “value of an expression” or the “object returned by an expression.” Whenever a message is sent, the receiver of the message returns an object. You can think of this object as the message expression’s value, just as you think of the value computed by a mathematical function as the function’s value.

You can use an assignment statement to capture a returned object:

| myVariable |

myVariable := 8 + 9.    "assign 17 to myVariable" 

myVariable              "return the value of myVariable"

17

You can also use the returned object immediately in a surrounding expression:

"puts 'Moe' at position 2 in arrayOfStrings"

| arrayOfStrings |

arrayOfStrings := Array new: 4.

(arrayOfStrings at: 1+1 put: 'Moe'; yourself) at: 2

And if the message simply adds to a data structure or performs some other operation where no feedback is necessary, you may simply ignore the returned value.

Blocks with Arguments

You can build blocks that take arguments. To do so, precede each argument name with a colon, insert it at the beginning of the block, and append a vertical bar to separate the arguments from the rest of the block.

Here is a block that takes an argument named myArg:

[ :myArg | 10 + myArg]

To execute a block that takes an argument, send it value: anArgument. For example:

| myBlock |

myBlock := [ :myArg | 10 + myArg]. 

myBlock value: 10.

20

The following example creates and executes a block that takes two arguments. Notice the use of the two-keyword message value:value:.

| divider |

divider := [:arg1 :arg2 | arg1 / arg2]. 

divider value: 4 value: 2

2

A block assigns actual parameter values to block variables in the order implied by their positions. In this example, arg1 takes the value 4 and arg2 takes the value 2.

Variables used as block arguments are known only within their blocks; that is, a block variable is local to its block. A block variable’s value is managed independently of the values of any similarly named instance variables, and GemStone Smalltalk discards it after the block finishes execution. This example illustrates this:

| aVariable |

aVariable := 1. 

[:aVariable | aVariable ] value: 10. 

aVariable

1

You cannot assign to a block variable within its block. This code, for example, would elicit a compiler error:

"The following expression attempts an invalid assignment

to a block variable."

[:blockVar | blockVar := blockVar * 2] value: 10

Blocks and Conditional Execution

Most computer languages, GemStone Smalltalk included, execute program instructions sequentially unless you include special flow-of-control statements. These statements specify that some instructions are to be executed out of order; they enable you to skip some instructions or to repeat a block of instructions. Flow of control statements are usually conditional; they execute the target instructions if, until, or while some condition is met.

GemStone Smalltalk flow of control statements rely on blocks because blocks so conveniently encapsulate sequences of instructions. GemStone Smalltalk’s most important flow of control structures are message expressions that execute a block if or while some object or expression is true or false. GemStone Smalltalk also provides a control structure that executes a block a specified number of times.

5 = 5 ifTrue: ['yes, five is equal to five'].

yes, five is equal to five

5 > 10 ifFalse: ['no, five is not greater than ten'].

no, five is not greater than ten

2 < 5 ifTrue: ['two is less than five'].

two is less than five

2 < 5 ifFalse: ['two is not less than five'].

nil

2 < 5 ifTrue: ['two is less than five']

ifFalse: ['two is not less than five'].

two is less than five

| sum |

sum := 0.

[sum = 5] whileFalse: [sum := sum + 1].

sum

5

| totalPayroll numEmployees salariesAdded standardSalary |

totalPayroll := 0.00.

salariesAdded := 0.

numEmployees := 40.

standardSalary := 5000.00.

[salariesAdded < numEmployees] whileTrue:

	[totalPayroll := totalPayroll + standardSalary.

	salariesAdded := salariesAdded + 1].

totalPayroll

200000.0

| sum |

sum := 0.

[sum := sum + 1. sum = 5] untilTrue.

sum

%

5

Formatting Code

GemStone Smalltalk is a free-format language. A space, tab, line feed, form feed, or carriage return affects the meaning of a GemStone Smalltalk expression only when it separates two characters that, if adjacent to one another, would form part of a meaningful token.

In general, you are free to use whatever spacing makes your programs most readable. The following are all equivalent:

{'string one'.2+2.'string three'.$c.9*arglebargle}

{ 'string one' . 2+2 . 'string three' . $c . 9*arglebargle }

{ 'string one'.

   2 + 2.

   'string three'.

   $c.

   9 * arglebargle }

Figure A.1 GemStone Smalltalk BNF

AExpression = Primary [ AMessage { ';' ACascadeMessage } ]

ABinaryMessage = [ EnvSpecifier ] BinarySelector Primary [ UnaryMessages ]

ABinaryMessages = ABinaryMessage { ABinaryMessage }

ACascadeMessage = UnaryMessage | ABinaryMessage | AKeyWordMessage

AKeyWordMessage = [ EnvSpecifier | RubyEnvSpecifier ] AKeyWordPart { AKeyWordPart }

AKeyWordPart = KeyWord Primary UnaryMessages { ABinaryMessage }

AMessage = [ UnaryMessages ] [ ABinaryMessages ] [ AKeyWordMessage ]

AnyTerm = Operand [ Operator Operand ]

Array = '(' { ArrayItem } ')'

ArrayBuilder = '#[' [ AExpression { ',' AExpression } ] ']'

  (exists only if  System configurationAt:#GemConvertArrayBuilder  is true)

ArrayItem = Number | SymbolArrayItem | SymbolLiteral | StringLiteral |

	CharacterLiteral | Array | ArrayLiteral | ByteArrayLiteral

ArrayLiteral = '#' Array

Assignment = VariableName ':=' Statement |  VariableName ' _ ' Statement

BinaryMessage = [ EnvSpecifier | RubyEnvSpecifier ] BinarySelector Primary

	[ UnaryMessages ]

BinaryMessages = BinaryMessage { BinaryMessage }

BinaryPattern = BinarySelector VariableName

Block = '[' [ BlockParameters ] [ Temporaries ] Statements ']'

BlockParameters = { Parameter } '|'

ByteArrayLiteral = '#' '[' [ Number { Number } ] ']'

  (exists only if  System configurationAt:#GemConvertArrayBuilder is false)

CascadeMessage = UnaryMessage | BinaryMessage | KeyWordMessage

CurlyArrayBuilder = '{' [ AExpression { '.' AExpression } ] '}'

Expression = Primary [ Message { ';' CascadeMessage } ]

KeyWordMessage = [ EnvSpecifier | RubyEnvSpecifier ] KeyWordPart { KeyWordPart }

KeyWordPart = KeyWord Primary UnaryMessages { BinaryMessage }

KeyWordPattern = KeyWord VariableName { KeyWord VariableName }

KeyWordPragma = PragmaPair [ PragmaPair ]

Literal = Number | NegNumber | StringLiteral | CharacterLiteral |

	SymbolLiteral | ArrayLiteral | SpecialLiteral | ByteArrayLiteral

Message = [ UnaryMessages ] [ BinaryMessages ] [ KeyWordMessage ]

MessagePattern = UnaryPattern | BinaryPattern | KeyWordPattern

Method = MessagePattern [ Primitive ] MethodBody

MethodBody = [ Pragmas ] [ Temporaries ] [ Statements ]

NegNumber = '-' Number

Operand = Path | Literal | Identifier

Operator = '=' | '==' | '<' | '>' | '<=' | '>=' | '~=' | '~~'

ParenStatement = '(' Statement ')'

ParenTerm = '(' AnyTerm ')'

Pragma = '< PragmaBody '>'

PragmaBody =  UnaryPragma | KeyWordPragma

Pragmas =   Pragma [ Pragma ]

Predicate = ( AnyTerm | ParenTerm ) { '&' Term }

Primary = ArrayBuilder | CurlyArrayBuilder | Literal | Path | Block |

	SelectionBlock | ParenStatement | VariableName 

Primitive = '<' [ 'protected' | 'unprotected' ] [ 'primitive:' Digits ] '>'

PragmaPair =  ( KeyWordNotPrimitive | BinarySelector ) PragmaLiteral

UnaryPragmaIdentifier is any Identifier except 'protected', 'unprotected',

	'requiresVc'

PragmaLiteral = Number | NegNumber | StringLiteral | CharacterLiteral |

	SymbolLiteral | SpecialLiteral

SelectionBlock = '{' Parameter '|' Predicate '}'

Statement = Assignment | Expression

Statements = { [ Pragmas] { Statement '.' } } [ Pragmas ] [ ['^'] 

	Statement ['.' [ Pragmas ] ]] 

Temporaries = '|' { VariableName } '|'

Term = ParenTerm | Operand

UnaryMessage = [ EnvSpecifier ] Identifier

UnaryMessages = { UnaryMessage }

UnaryPattern = Identifier

UnaryPragma  = SpecialLiteral | UnaryPragmaIdentifier

GemStone Smalltalk lexical tokens are shown in Figure A.2. No white space is allowed within lexical tokens.

Figure A.2 GemStone Smalltalk Lexical Tokens

BinaryExponent = ( 'e' | 'E' | 'd' | 'D' | 'q' ) ['-'] Digits

BinarySelector =  SelectorCharacter [SelectorCharacter]

Character = Any Ascii character with ordinal value 0..255

CharacterLiteral = '$' Character

Comment = '"' { Character } '"'

DecimalExponent = ( 'f' | 'F' ) ['-'] Digits

Digit = '0' | '1' | '2' | ... | '9'

Digits = Digit {Digit}

EndOfSource = the end of the method source string

Exponent = BinaryExponent | DecimalExponent | ScaledDecimalExponent |

	FixedPointExponent

EnvSpecifier = '@env' Digits ':'    

	(no white space before or after Digits)

FractionalPart = '.' Digits [Exponent]

FixedPointExponent =  'p' [ ['-'] Digits ] 

Identifier =  SingleLetterIdentifier | MultiLetterIdentifier 

KeyWord = Identifier ':'

KeyWordNotPrimitive is any KeyWord other than 'primitive:'

Letter = 'A' | 'B' | ... | 'Z' | 'a' | 'b' | ... | 'z' | '_'

MultiLetterIdentifier = Letter ( Letter | Digit ) { Letter | Digit }

Number = RadixedLiteral | NumericLiteral

Numeric = Digit | 'A' | 'B' | ... | 'Z'

NumericLiteral = Digits ( [FractionalPart] | [Exponent] )

Numerics = Numeric { Numeric }

Parameter = ':' VariableName

	(white space allowed between : and variableName)

Path = Identifier '.' PathIdentifier { '.' PathIdentifier }

PathIdentifier  =  Identifier |  '*'

RadixedLiteral = Digits ( '#' | 'r' ) Numerics

ScaledDecimalExponent =  's' [ ['-'] Digits ]

ScdExponTerminator = '"' | WhiteSpace | ',' | ')' | ']' | '}' | '.' | 

	';' | 	EndOfSource

SelectorCharacter = '+' | '-' | '\' | '*' | '~' | '<' | '>' | '=' 

	| '|' | '/' | '&' | '@' | '%' | ',' | '?' | '!' 

SingleLetterIdentifier = Letter

SpecialLiteral = 'true' | 'false' | 'nil' | '_remoteNil' 

StringLiteral = "'" { Character | "''" } "'"

Symbol = Identifier | BinarySelector | ( Keyword { Keyword } )

SymbolArrayItem = Identifier | ( KeyWord { KeyWord } )

SymbolLiteral = '#' ( Symbol | StringLiteral )

VariableName = Identifier