xTalk is a loosely defined family of scripting languages. The mother of all xTalk languages is HyperTalk, the language used by Apple's HyperCard environment. These languages are characterized by simple English-like syntaxes, using real-life metaphors on top of a Smalltalk-style image and message sending apparatus, with Pascal-style block boundaries, but a less rigid structure.
- 1 A sample script
- 2 xTalk languages
- 3 xTalk-inspired languages
- 4 Language constructs
- 5 Incompatibilities between dialects
- 6 Late additions to the language
- 7 References
- 8 External links
A sample script
on mouseUp go to the third card if the last word of the first line of card field 1 contains "hello" then say "Okay" repeat while the mouse is up beep end repeat end mouseUp
xTalk languages share a common set of basic data structures and commands, as well as the general object model, and thus allow for relative portability between each other:
A few programming languages bear surface similarities to HyperTalk and were inspired by it. However, they have object models that differ so substantially that porting code from another xTalk requires a complete rewrite:
xTalk languages all share the following basic constructs:
Messaging and handlers
xTalk has Smalltalk-like messaging. To send a message, write a command or function call:
put functionName(1,2,3) into theResult
like in Pascal. This message and its parameters do not require declarations, they are resolved at runtime to the correct handler. A handler looks like
on commandName param1,param2,param3 -- do things here end commandName function functionName param1,param2,param3 -- do things here end functionName
and behaves pretty much like the Pascal equivalent, except that its parameter list is variadic. If fewer parameters are passed to a handler than it declares in its first line, the remaining variables are filled with empty strings. If more are passed, they are quietly ignored. Instead of declaring parameters as a list after the handler name, they can also be accessed using the
param() functions, which also gives access to the ignored parameters.
xTalk scripts are often attached to objects (HyperTalk, SuperTalk, MediaTalk, LiveCode) though not always (e.g. CompileIt!, SenseTalk). If a script does not contain a handler for a particular message it uses, the message is passed on to the owning object's script to handle. Scripts can also manually pass on a message to the parent using the
All xTalks support the following basic commands:
put <value> into <container>
This is the main assignment statement. Most xTalks also support
before for prefixing/suffixing values to each other. They also support a 'get <value>' command that is equivalent to a put statement into a container named 'it'.
Like in Pascal, this is how a handler passes data back to the message sender. This is also valid in command handlers, where the return value will be stored in the built-in variable
set [the] <property> [of [<range> of] <object>] to <value>
Change the property of an object (or a range of text in its text contents) to a given value. This is used both to modify instance variables of objects, as well as apply text styles to text fields. If no object is specified, a global property of the host application itself is assumed.
All xTalks support conditional statements of the following form:
if <condition> then commands else commands end if
If the line break following an
else token is omitted, only a single command may follow, and the
end if statement may be omitted. This allows writing an entire if-then-else statement on a single line, and chaining conditionals as if-then-else-if-then-else chains. Also, the entire
else block may be omitted. The
then token may be wrapped onto the next line.
Loop statements are not quite as free-form:
repeat [for] <count> [times] commands end repeat repeat with <variableName> = <startNumber> [down] to <endNumber> commands end repeat repeat while <condition> commands end repeat repeat until <condition> commands end repeat
Many dialects add additional loop syntax for things like looping over chunks.
Expressions and operators
xTalks support the usual mathematic expressions. Apart from the usual
/ operators, they also support
div (integer division),
mod (remainder of integer division),
is not (unequality),
≥ (number comparison/string sort order),
is not in (substring matching),
is not within (point coordinates lie inside rectangle coordinates),
not (boolean negation),
and (logical AND for booleans),
or (logical OR for booleans),
& (string concatenation),
&& (string concatenation with a space in between),
is a and
is an (type detection),
there is a,
there is an,
there is no,
there is not a (determine file/object existence).
Variables in xTalks do not need to be declared, but are rather transparently created when a value is first put into them. If a variable name is used into which nothing has yet been put, it is treated as an unquoted string literal and evaluates to its name (thus mimicking the behavior of a line-by-line interpreter). Variables in xTalks are variants, that is they are conceptually all strings, which are interpreted internally as the data type for the current operation performed on them. However, they may have the following types: string, integer, number, point, rect, date or logical (aka boolean), where all are equal to their string representations, which in the case of rects and points are comma-separated lists of numbers (h,v resp. left,top,right,bottom), logicals are "true" or "false". It is perfectly valid to perform string operations on numbers and then immediately mathematical operations.
Global variables need to be declared using a special keyword (most often
global, but in some xTalks the word
universal is used instead) to import them into the current handler's scope.
All xTalks support chunk expressions, which are mid-level operations to extract and modify substring ranges of a variable. These expressions can be both value and container, and usually have the form:
<chunkType> <startOffset> [to <endOffset>] of <value>
Where supported chunk types are usually char(acter), item, word, or line (though some dialects add support for bytes and other chunk units). Most xTalks support changing the delimiter to use for items (by default the comma) using the
itemDelimiter property, and reset it at a later point, (though SuperTalk resets it to comma at the end of each handler, while HyperTalk resets it only at idle time, i.e. between system events).
There are also mathematical commands like
add <value> to <container> etc.
Incompatibilities between dialects
Most xTalks are based on a HyperCard 1.2-level architecture. Since HyperCard 1.2 did not support multiple windows, menus, movies or web browsers, many xTalks implement these aspects differently. E.g. SuperTalk implements multiple windows by replacing the 'stack' level of the object hierarchy with a 'project' (a script container representing the file) and a 'window' (effectively what a stack used to be, but there may be several in one project file), whereas HyperCard 2.0 and LiveCode kept the 'stack' level, and instead provided new (but different) commands that allow requesting a second stack be opened in its own window instead of replacing the current stack onscreen. HyperSense kept a similar approach, but renamed the 'card' to 'page'.
Popup buttons and menus are fully native persistent objects in the project file's image with scripts in SuperTalk, and are referenced as 'item "copy" of menu "edit"' and the like, while in HyperTalk they are transient objects that are added to a global menu bar shared by all stacks using the 'create menu' command, are referenced by 'menuItem "copy" of menu "edit"' and can only have a single-line 'menuMessage' they send when picked.
Similarly, types and styles of objects placed on a card differ greatly between xTalks at the divergence point of HyperCard 1.2.x. Most have buttons and fields but SuperCard does not let background fields have the same content on different cards (requiring the use of draw text graphics for labels instead, which HyperCard did not have). And HyperCard 2.x's compound term 'part' to subsume buttons, fields etc. on a card is also not supported by all xTalks.
Late additions to the language
Although HyperCard never provided that feature, most xTalks today implement the 'user properties' feature first introduced by SuperCard. It allows adding custom instance variables to the existing objects of the host application, which can then be used just like the built-in properties to hold any data, of any type. An example of using a user property is
if ",myProperty," is not in "," & the userProperties of me & "," then define myProperty of cd btn 1 end if set myProperty of me to "Whatever I want"
There is also an
undefine command to remove properties from an object again.
- HyperTalk Reference stack, cards "What are messages?", "Handling messages" and "The message-passing order"
- HyperTalk Reference stack, card "Using parameter variables", "paramCount" and "param"
- HyperTalk Reference stack, chapter "Operators and Constants"