TScript

TScript is an object-oriented embeddable scripting language for C++ that supports hierarchical transient typed variables (TVariable). Its main design criterion is to create a scripting language that can interface with C++, transforming data and returning the result. This enables C++ applications to change their functionality after installation.

TScript

Developer(s)	Ekky Software
Stable release	1.4 / July 1, 2012 (2012-07-01)
Written in	C++
Operating system	Windows and Linux
Type	Scripting language
License	Free (proprietary)
Website	www.ekkysoftware.com

Hello world example

The basic "Hello World!" TScript example.

CTScript ts;
ts.SetParameter(CTScript::SOURCE_STRING,0,TEXT("main(){")
TEXT("   System::MessageBox(L\"Hello World!\");")
TEXT("}"));
ts.ExecuteStaticMethod();

TVariables

The standard variable can be formed as fixed data such as a Boolean, Integer or Decimal and a variable length variable such as an ASCII string, wide character string or a binary string. The type of the data can be used to define variable or the type can be explicitly declared, so for example the code - variable myInteger = 0; will create a variable called myInteger and assign it the value of zero. An Integer type can also be declared as - Integer myInteger; and its default value will be set to zero.

TVariable are hierarchical in nature and are very similar to XML, JavaScript and PHP variables.

The TVariable type is also transient as an Integer can be changed into an AString by assigning it a string value or by casting the variable to an AString. For example, after an integer variable has been created and used, it can be reassigned by equating it to an AString.

TVariables can also be used to hold an array of TVariables. Once a valid variable has been created, the array index subscripting notation can be used to transform it into an array, so for example the code - variable list = {0,2,4,6}; will create an array with four elements. The TVariable type for "list.type" will be that of a structure and each element of list[0].type will be an Integer.

Class in TScript are similar to array in how TVariable handle them, but use strings as array scriptures. For example, the code - variable list = {"Monday" => true, "Tuesday" => false}; will create a structured variable where list. Monday is true and list.Tuesday is false. In the native C++ code, structured TVariable elements are accessible in C++ by - list["Monday"]; or by either list.Monday or list["Monday"] in native code.

Defined variables (classes)

Supporting hierarchical variables, TScript is able to store both primitive and complex variables within the same variable structure. This removes any requirement for any unique difference between primitives and structured data, therefore making the class structure a logical grouping of functionality rather than data storage type.

TScript implements concepts of inheritance and code encapsulation through defined variables. For example, the following code snippet show a defined variables Foo and Bar that supports a constructor.

variable Bar{
   Integer minimum, maximum;
   Bar(){
      this.minimum = 1;
   }
}

variable Foo extends Bar{
   WString name;
   Foo(WString name){
      this.name = name;
      this.Bar();
   }
}

public main(){
   Foo foo(L"Goo");
   System::MessageBox(foo.ToString());
}

Function declarations

Another striking feature of TScript is the function declarations, which use output parameters rather than return values, and provide syntactic support for these. The standard function in many procedural languages, following Algol, is of the form:

[return type] <function name>([input variable], ...).

In TScript this pattern has been changed to the form:

<function name>([input variable],... :[output variable],...).

This change has done two things, first it allows multiple output variables and secondly it changed the return statement to an error handling function.

Allowing functions to have a list of input and output variables that are separated by the semi column ":", changed the normal flow of how the function are called and used. This removes some of the need for using reference pointers to return multiple variables that is common in C/C++, and the use of references in most other scripting languages is actually prevented, forcing the use of a structure or array to return multiple values.

The second noticeable thing about the calling conventions is that now all functions have an integrated error handling purpose similar to try{…}catch(…){…} and throw new Exception() of C++ and Java. In TScript since all functions return an error, the return statement operates similar to the throw statement. For example, the statement:- return error = "Have an error message"; will terminate the function and return the error message. Alternatively the blank statement;- return; will terminate the function but not return any error.

Example of multiple return values

public TextExtent(WString text : Integer width, Integer height){
   text = text.Fragment(L"\n");
   for(height = width = 0; height < text.length; height++){
      if(width < text[height].length) width = text[height].length;
   }
}

Shorthand notation

For convenience TScript offers a shorthand function calling in the situation where there is only one returned variable. This notation of will substitute the case of function(: variable); for variable = function();. This short notation prevents the calling code from catching any errors and they will automatically be return to the parental calling code.

Error handling

Error handling in many other languages is done through the use of exceptions. TScript uses a similar process of error handling, although slightly different. TScript has a global error variable similar to the traditional errno in C, although the error variable in TScript is capable to holding both an error code and a detailed error message.

In many languages that use the try{...}catch(...){...} syntax the error is returned via the catch statement and this can make the operational flow of the code awkward in situations where some errors are recoverable. TScript uses the if(...){...} else{...} notation that allows calling code to filter the error, potentially recovering from the error and returning to normal operation, or returning the error to its own calling function.

Example of return and handling errors

function(){return error = -1;}

public main(){
   if(!function()){
      if(error != -1) return error;
   }
   System::MessageBox(L"function executed correctly");
}

Run-time linking

C++ supports function overloading, which enables functions to have the same name while being differentiated by their input parameters. This causes TScript an issue while supporting loose type variables, as there is no way to tell what the type of a variable is until the software is being executed.

To counter this problem, TScript has been written with run-time linking. This is when the particular function called is dependent on the type of the variables when the function is called.

This is an unusual tactic that has some additional benefits. First it means that there is no need to declare functions before they are used, for example in C++ two functions may call one another, like void Foo(){ Bar();} and void Bar(){Bar();}. In this situation, the Bar() needs to be prototyped in order for the Foo() to call it. TScript's run-time linking means the functions can be declared in any order without the need to prototype. This can make writing code much easier for less experienced programmers, allowing them to focus on the logic of the software and not the requirements of the language.

Run-time linking also enables the language to support run-time coding with methods like AddMethod and AddDefinedVariable. This enables TScript programs to write themselves. For example, when using the SOAP interface, the remote WSDL will be encoded into the script library, allowing the functions within to be called as if they were coded at design time. Additionally it is also possible to write code that can learn for itself, writing new functions when it needs it.

Dynamically linking libraries

TScript is among a small group is scripting languages that provide the functionality to dynamically load and link to existing shared libraries. Java through its JNI and VB6 are two other scripting languages that enable code to be written that would load a third party library and execute through its native interface. This gives TScript the ability to use a wealth of pre-existing functionality and code written in different languages and this can be done without any need to change the shared library's interface or to be compiled with the source code.

Memory management

TScript uses the standard C++ class encapsulation to allocate and de-allocate memory resources. This means that all allocated memory is released when the variable containing it is destroyed and operated differently from the Garbage Collection model of Java or the reference counting model of .NET languages.

Operation system resources such as files, sockets and encryption keys are managed via a reference counting mechanism similar to .NET, so they will be released as soon as there are no variables containing their values.

Pro-active security

With the ability to load existing shared libraries, script can access all privileges granted to the user who executes it. To guard against malicious code, all resources beyond the basic memory allocation are required to be granted to each script. This also includes the ability to use message boxes to prompt the user, read and/or write access to any file or directory, or using the Internet connection.

This security architecture is designed to allow the running of scripts in a similar way to JavaScript while enabling the usefulness of more powerful scripting languages like Perl.

External links

• Introduction to TScript