出来るデキスクリップト

Lexical Conventions

Names in DekiScript can be any string of letters, digits, and underscores, not beginning with a digit. Note that any character considered alphabetic by the current locale can be used in an identifier.  Identifiers are used to refer to variables and table fields.

The following tokens are reserved and cannot be used as names: _, nil, null, true, false.  DekiScript is not case-sensitive, meaning page.path and PAGE.PATH are identical.

Syntax

A DekiScript block allows for a single expression with the following syntax: 

expr ::= simple ( call | access | default-value  | string-concat )*
simple ::= nil| bool | number | string | name | magic-id | map | list | ( expr )
map ::= { ( field ( , field )* )? }
field ::= ( name | string ) : expr
list ::= [ ( expr ( , expr )* )? ]
call ::= ( ( expr ( , expr )* )? ) | map
access ::= [ expr ] | . name
default-value ::= ?? expr
string-concat ::= .. expr
magic-id ::= @ name

Nil (1.8.1)

The empty value is represented by _, nil, and null.  All tokens are synonymous and their variations are provided for convenience.

Bool (1.8.1)

Logical values are represented by true and false.

Number (1.8.1)

Numbers must have a decimal part and may have an optional decimal exponent.  DekiScript also accepts hexadecimal constants, by prefixing them with 0x.  Numbers are stored as 64-bit floating point values.

Examples of valid numbers are:

• 3
• 3.1416
• 314.16e-2
• 0.31416E1
• 0xff
• 0xFFFFFF

String (1.8.1)

Strings can be delimited by matching single or double quotes and can contain these escape sequences: '\a' (bell), '\b' (backspace), '\f' (form feed), '\n' (newline), '\r' (carriage return), '\t' (horizontal tab), '\uXXXX' (encoded character where 'XXXX' is the hexadecimal unicode value), '\v' (vertical tab), '\\' (backslash), '/' (slash), '\"' (double quote), and '\'' (single quote).  Strings in DekiScript may contain any 16-bit value, including embedded zeros, which can be specified as '\0'.

Examples of valid strings are:

• 'Hello World!'
• 'Say "hello"!'
• "Say 'bye'!"
• 'Line 1\nLine 2'
  

Map (1.8.1)

A map is an associative array that assigns a key to an expression.  The key can either be a name or a string.  The evaluation order of expressions inside a map is non-deterministic.

map ::= { ( field ( , field )* )? }
field ::= ( name | string ) : expr

Examples of valid maps are:

• { }
• {  first: "Hi", second: "bye" }
• { "#1": "First", '#2': { } }
  

Note: Because DekiScript blocks can be enclosed inside double curly braces (i.e. {{ }} ) , care must be applied when nesting tables, as two consecutive }} will be interpreted as the end of the DekiScript block.

The values of a map are accessed by providing the key either as a name preceded by a dot (.) or as an expression surrounded by brackets ([]).  Valid examples of accessing a map are:

• map.first
• map['#1'] 

If the key is not found in the map, the expression evaluates to nil.

List (1.8.1)

A list is an indexed array of expressions.  The evaluation order of expressions inside a list is non-deterministic.

list ::= [ ( expr ( , expr )* )? ]

Examples of valid lists are:

• [ ]
• [ 1, 2, 3 ]
• [ 1, _, "hi" ]

The values of a list are accessed by using a numeric expression surrounded by brackets ([]).  The first value in a list has index 0.  Valid examples accessing a list are:

• list[0]
• list[1000]

If the index is not within range, the expression evaluates to nil.

Function Call (1.8.1)

In a function call, the prefix is evaluated first.  If the value of the prefix has type uri, the arguments are evaluated in a non-deterministic order.  Otherwise, an exception is thrown.  Arguments can be specified with two different notations, either as a list or as a map.

Valid examples of calling a function with an argument list are:

• fn()
• fn(1, 2, 3)
• fn(1, _, "hi")

Valid examples of calling a function with an argument map are:

• fn{}
• fn{ first: 1, second: 2, third: 3 }
• fn{ "arg#1": 1, 'arg#3':"hi" }

Using an argument map enables the caller to pass in arguments by name.  Unspecified arguments have value nil, while specified arguments that don't correspond to the parameter name will be ignored (but they are evaluated).

Operator .. (1.8.2)

The .. operator is used to concatenate two strings.  If the values being concatenated are not strings, they are converted to strings first.

Valid examples of the .. operator are:

• "Hello " .. "World!"
• "1+1=" .. 2
• nil .. '123' .. [ 1, 2, 3 ]
  

Operator ?? (1.8.2)

The ?? operator is used to test for nil.  First, the expression to the left of the ?? operator is evaluated.  If the resulting value is nil, the expression to the right is evaluated and returned instead.

Valid examples of the ?? operator are:

• nil ?? 123
• map.value ?? map.alternate ?? "default"

Magic Identifier (1.8.2)

A magic identifier is an automatically generated string that is guaranteed to be unique across scopes.  The scope of a magic identifier is a single page or template instance.  For example, if a page or template is loaded multiple times via inclusion, each page will have unique values for its magic identifiers.

Magic identifiers are commonly used to create channels for PubSub communication.  By using magic identifiers, the channels are guaranteed to be unique and not interfere with similarly named channels on other included pages.

Valid examples of the magic identifiers are:

• @abc
• @abc123
• @_1