XTalk
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.
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
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 among each other:- HyperTalk
- SuperTalk
- SenseTalk
- Transcript
- LiveCode Script formerly called RevTalk or MetaTalk
xTalk-inspired languages
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:- Lingo
- ActionScript
- AppleScript
- JavaScript and ECMAScript
Language constructs
Messaging and handlers
xTalk has Smalltalk-like messaging. To send a message, write a command or function call:commandName 1,2,3
put functionName 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 and functions, which also gives access to the ignored parameters.
xTalk scripts are often attached to objects though not always. 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 command.
Central commands
All xTalks support the following basic commands:put
This is the main assignment statement. Most xTalks also support or for prefixing/suffixing values to each other. They also support a 'get
return
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
Change the property of an object 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.
Control structures
All xTalks support conditional statements of the following form:if
commands
else
commands
end if
If the line break following an statement's or token is omitted, only a single command may follow, and the 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 block may be omitted. The token may be wrapped onto the next line.
Loop statements are not quite as free-form:
repeat
commands
end repeat
repeat with
commands
end repeat
repeat while
commands
end repeat
repeat until
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,, and operators, they also support , , ,= or ,, or ,,, <=, >=,, ,,, ,, , , , , , , and ,,,, .Variables
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. 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, where all are equal to their string representations, which in the case of rects and points are comma-separated lists of numbers, 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 to import them into the current handler's scope.
Chunk expressions
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:Where supported chunk types are usually char, item, word, or line. Most xTalks support changing the delimiter to use for items using the property, and reset it at a later point,.
There are also mathematical commands like 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' and a 'window', whereas HyperCard 2.0 and LiveCode kept the 'stack' level, and instead provided new 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. 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 isif ",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.