xTalk

From HandWiki

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:

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:

Language constructs

xTalk languages all share the following basic constructs:

Messaging and handlers

xTalk has Smalltalk-like messaging.[1] To send a message, write a command or function call: 

   commandName 1,2,3

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.[2] 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 paramCount() and 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 pass command.

Central commands

All xTalks support the following basic commands: 

   put <value> into <container>

This is the main assignment statement. Most xTalks also support after or 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 the result. 

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.

Control structures

All xTalks support conditional statements of the following form: 

if <condition> then
       commands
    else
       commands
    end if

If the line break following an if statement's then or 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.[3] Apart from the usual +, -, * and / operators, they also support div (integer division), ^ (exponent), mod (remainder of integer division), = or is (equality), <>, ≠ or is not (unequality), <, >, <=, >=, ≤, ≥ (number comparison/string sort order), contains, is in, is not in (substring matching), is within, 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

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 ( ), 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.

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: 

   <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.

See also

References

  1. ↑ HyperTalk Reference stack, cards "What are messages?", "Handling messages" and "The message-passing order"
  2. ↑ HyperTalk Reference stack, card "Using parameter variables", "paramCount" and "param"
  3. ↑ HyperTalk Reference stack, chapter "Operators and Constants"

External links




Retrieved from "https://handwiki.org/wiki/index.php?title=XTalk&oldid=2640390"