SwiftScript Language Reference Manual

The characters # or // starts a comment, which terminates when a newline is encountered. The C style /* and */ pair are used for multi-line comments. For example:

// this is a single-line comment

# this is another single-line comment 

/* multi-line comment line 1
   multi-line comment line 2 */
       

An identifier starts with an alphabetic character (‘a’-‘z’, ‘A’-‘Z’, ‘_’), after which there can be arbitrary number of letters or digits. Identifiers are case sensitive, meaning upper case letters are different from lower case ones. An identifier is used to represent the name of a variable, a procedure, a procedure argument, etc, which we’ll talk in detail in later sections.

Keywords are identifiers that are reserved for system use, and may not be used otherwise. We have reserved the following identifiers for type declarations and control statements:

int float string

date boolean uri

any

true false null

namespace include type

if else

switch case default

while

foreach in step

repeat until

Swift literals are constant values that are represented as strings in the program. The types and formats of literals are drawn from the set of atomic values defined by XML Schema. The type of a literal value is implicit from its context – from the type of the variable that its being assigned to or the type of the procedure parameter that it is being passed to, or the type of value that is expected in a specific position of a statement such as an if, while, or switch.

Some literal types can be identified without being enclosed in quotes; string literals and similar types based on strings must be enclosed in quotes.

3.  .14  3.14  3.14e-6  2e100

"2005-09-25T11:30:00Z"

@“<volume><image>b1.img</image><header>b1.hdr</header></volume>”

"http://www.griphyn.org/"

Operators are used in expressions for operations that involve one or more operands. Separators are for grouping and separation. The operators and separators are as follows:

A primitive type is one of int, float, boolean, date, string, uri.

A composite type is a type composed of primitive types. We support two kinds of type constructions: Arrays and Structs. We will talk more about these in the declaration section.

An array is a data structure that contains zero or more elements that are all of the same type; this type is called the element type of the array.

Arrays are indexed by integer values, and they are 0-indexed following the C convention.

Currently only one-dimensional arrays are supported.

A struct is a data structure that can contain members of different types, where those types can be either primitive or composite types.

Global variables are the variables declared in the main body of a SwiftScript program. A global variable extends to any procedures and blocks defined in the program and can be referenced anywhere within the program. The syntax for declaring a global variable is not different from the others, it is just that its scope applies to the whole program.

A local variable occurs in a block. A block is a section of code, which consists of one or more statements that can be grouped together. Examples of a block include an if statement, a switch, or a while statement, etc. Blocks can be nested with one block inside another.

A local variable can be declared, for instance, within the body of a compound procedure, or in a while or switch statement.

A local variable may also be declared within a foreach statement as an iteration variable.

When a variable is associated with a dataset, i.e. it holds the dataset handle of that dataset; it is also called a dataset-bound variable. A dataset-bound variable usually has an associated mapping specification, for details, please look at Section ???

A scope defines the visibility of a variable. A global variable extends to any procedures and blocks defined in the program. For a local variable, if it is defined in a block, its scope is limited to that block. If it is defined at the beginning of a procedure, its scope extends to any blocks contained within the procedure, unless a contained block defines a variable with the same name.

A variable reference is an expression that refers to a variable or its sub-elements. A simple example of a variable reference is an identifier. For an array variable, subscript can be used to reference an array element. For instance if a is an int array, then a[2] is a variable reference that refers to element 3 in the array. For a struct variable, member names can be used to refer to member variables in the struct. For instance, if addr is a struct, with string members: street, city, and state, then addr.city refers to its city member variable.

An atomic procedure defines an interface to an external executable program or Web Service, and specifies how data items passed as input and output parameters are mapped to and from application program or service arguments and results. While the header of an atomic procedure specifies the name of the procedure, and the inputs and outputs to the procedure, the body of such an atomic procedure specifies how to set up its execution environment and how to assemble the call to the procedure. Thus, it is in the body of an atomic procedure that mapping operations may appear to access components of any physical dataset that is dataset-bound to data items passed as procedure parameters.

The body can specify the invocation of either an application or a Web Service, where procedure-type specifies the type of the procedure.

A compound procedure body is a block of one or more SwiftScript statements, which are executed in an order determined by their data dependencies.

The body is comprised of procedure-statement-sequence, which is just a sequence of statements:

There are several kinds of primary expressions:

Literals

A literal is a value that has an associated type. We have already discussed literals in Section .

Variables

A variable also needs to have an associated type. Variables have been described in section .

Member accesses

A member access expression is an expression that accesses a member of a struct variable. It is a variable expression followed by a dot, and then followed by the name of a struct member. It has the type of the named member of the struct.

Example:

addr.city

Element accesses []

An element access expression is an expression that accesses an element of an array. It is a primary expression followed by square brackets, containing a subscript expression. It has the type of the element type. It is also called subscription.

Example:

itemNumbers[5]

Procedure calls ()

A procedure call expression is an invocation of a procedure. It is in the form of parenthesized list of comma separated expressions, for actual output parameters; followed by a primary expression, for function name; and then followed by parenthesized list of comma separated expressions, for actual input parameters. Output parameters should have associated types explicitly defined. The acutal paramters can be optional. When there is only one output parameter specified, the parentheses can be optional.

Example:

File out = myproc1 ( 100, optional_arg = “v1” );

Parenthesized Expressions

A parenthesized expression is a primary expression enclosed in parentheses. The presence of parentheses does not affect its type, or value. Parentheses are used solely for grouping, to achieve a specific order of evaluation.

Example:

int i = (a + b) * 5;

Operators in an expression indicate what kind of operations to apply to the operands. Currently we support an assignment operator, arithmetic operators and relational operators.

The namespace statement MUST appear at the very beginning of a SwiftScript program, and the namespace must be unique. It serves similar purpose as a Java package definition, so that the type definitions and procedure definitions defined in this namespace would not collide with others defined outside. The syntax for namespace definition is as follows:

“namespace” (prefix)? ‘“’ uri ‘”’ (‘;’)?

prefix is the abbreviation of the namespace denoted by uri. If prefix is ommitted, then the namespace is regarded as the default namespace. If a default namespace is not defined in the program, it assumes the value

“http://www.griphyn.org/vds/2006/08/nonamespace”

Some examples:

  
namespace“http://www.griphyn.org/”
  
namespacefmri“http://www.fmridc.org/”
  

For the definitions that follow the namespace statement, they all belong to the default namespace unless otherwise specified.

An include statement is used to include type definitions defined in an external XML Schema document, or to include another program defined in SwiftScript, so that the type definitions and procedure definitions can be used directly within the current SwiftScript program.

An include statement is of the form:

“include” ‘“’ include-file-name ‘”’

Since the definitions in the included file may have a different namespace from the one in the current program, it is necessary to explicitly specify the namespace for those definitions when they are used in the current program.

A type definition is usually used at the beginning of a program, to define the structure of a new type, which can later be used to declare a variable. Type definitions have the form:

Where the type-name is a unique identifier and the type-specifier is either an already defined type, such as primitive types, or a struct declaration.

   type order {
       int orderNumber;
       string description;
       int itemNumbers[];
   }
  

A declaration statement declares a variable, or a physical dataset in the form of a dataset handle.

  int x, y=2;
  String s = “hello”;
  floatf[] = [1.0, 2.0, 3.0];
  intp[] = [1 : 9 : 2];  // numbers 1 3 5 7 9
  

Imageimg1<image_mapper; location=“/home/archive/images/image1.jpg”>;

Imageimg2<simple_mapper; prefix=@img1, suffix=”.2”>; 

Most statements are expression statements, they take the form:

expression ‘;’

Usually expression statements are assignments, or procedure calls.

A selection statement selects one of a number of possible statements for execution, based on the value of a boolean expression.

A loop statement repeatedly executes some statements in the loop body. It can be of one of the following statements:

The statement

“break” ‘;’

causes termination of the smallest enclosing loop, or switch statement; control passes to the statement following the terminated statement.

The statement

“continue” ‘;’

causes control to pass to the loop continuation portion of the smallest enclosing loop statement; that is to the end of the loop.