View source for XTalk

{{lowercase}}
'''xTalk''' is a loosely defined family of scripting languages. The mother of all xTalk languages is [[HyperTalk]], the language used by Apple's [[Software:HyperCard|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==
<source lang="applescript">
    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
</source>

== 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|LiveCode Script]], formerly called RevTalk and 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 (programming language)|Lingo]] (with old syntax)
* [[ActionScript]]
* [[AppleScript]]
* [[JavaScript]]  and [[ECMAScript]]
* [https://hyperscript.org Hyperscript]

==Language constructs==

xTalk languages all share the following basic constructs:

===Messaging and handlers===

xTalk has Smalltalk-like messaging.<ref>HyperTalk Reference stack, cards "What are messages?", "Handling messages" and "The message-passing order"</ref> To send a message, write a command or function call:

    commandName 1,2,3
<source lang="applescript">
    put functionName(1,2,3) into theResult
</source>

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

<source lang="applescript">
    on commandName param1,param2,param3
      -- do things here
    end commandName
    
    function functionName param1,param2,param3
      -- do things here
    end functionName
</source>

and behaves pretty much like the Pascal equivalent, except that its parameter list is variadic.<ref>HyperTalk Reference stack, card "Using parameter variables", "paramCount" and "param"</ref> 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 {{code|paramCount()}} and {{code|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 {{code|pass}} command.

===Central commands===

All {{Proper name|xTalks}} support the following basic commands:

    put <value> into <container>

This is the main assignment statement. Most {{Proper name|xTalks}} also support {{code|after}} or {{code|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'.

    return <value>

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 {{code|the result}}.
<source lang="applescript">
    set [the] <property> [of [<range> of] <object>] to <value>
</source>
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.

===Control structures===

All {{Proper name|xTalks}} support conditional statements of the following form:
<source lang="applescript">
    if <condition> then
       commands
    else
       commands
    end if
</source>
If the line break following an {{code|if}} statement's {{code|then}} or {{code|else}} token is omitted, only a single command may follow, and the {{code|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 {{code|else}} block may be omitted. The {{code|then}} token may be wrapped onto the next line.

Loop statements are not quite as free-form:
<source lang="applescript">
    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
</source>
Many dialects add additional loop syntax for things like looping over chunks.

===Expressions and operators===

{{Proper name|xTalks}} support the usual mathematic expressions.<ref>HyperTalk Reference stack, chapter "Operators and Constants"</ref> Apart from the usual {{code|+}}, {{code|-}}, {{code|*}} and {{code|/}} operators, they also support {{code|div}} (integer division), {{code|^}} (exponent), {{code|mod}} (remainder of integer division), <code>=</code> or {{code|is}} (equality), {{code|<>}}, {{code|≠}} or {{code|is not}} (unequality), {{code|<}}, {{code|>}}, <code><=</code>, <code>>=</code>, {{code|≤}}, {{code|≥}} (number comparison/string sort order), {{code|contains}}, {{code|is in}}, {{code|is not in}} (substring matching), {{code|is within}}, {{code|is not within}} (point coordinates lie inside rectangle coordinates), {{code|not}} (boolean negation), {{code|and}} (logical AND for booleans), {{code|or}} (logical OR for booleans), {{code|&}} (string concatenation), {{code|&&}} (string concatenation with a space in between), {{code|is a}} and {{code|is an}} (type detection), {{code|there is a}}, {{code|there is an}}, {{code|there is no}}, {{code|there is not a}} (determine file/object existence).

===Variables===

Variables in {{Proper name|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 {{Proper name|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 ( ), 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 {{code|global}}, but in some {{Proper name|xTalks}} the word {{code|universal}} is used instead) to import them into the current handler's scope.

===Chunk expressions===

All {{Proper name|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 {{Proper name|xTalks}} support changing the delimiter to use for items (by default the comma) using the {{code|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 {{code|add <value> to <container>}} etc.

==Incompatibilities between dialects==
Most {{Proper name|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 {{Proper name|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 '{{Not a typo|menuMessage}}' they send when picked.

Similarly, types and styles of objects placed on a card differ greatly between {{Proper name|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 {{Proper name|xTalks}}.

==Late additions to the language==
Although HyperCard never provided that feature, most {{Proper name|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
<source lang="applescript">
    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"
</source>
There is also an <code>undefine</code> command to remove properties from an object again.

==See also==
* [[ClearTalk]]

==References==
{{reflist}}

==External links==
* [http://www.fourthworld.com/embassy/articles/scriptstyle.html Xtalk Scripting Style Guide]

[[Category:Scripting languages]]

{{Sourceattribution|XTalk|1}}