// Euresys GenApi Script uses a syntax inspired by JavaScript, but is not
// exactly JavaScript. Using the extension .js for scripts is just a way to get
// proper syntax highlighting in text editors.
//
// This file describes the basics of Euresys GenApi Script. It can be executed
// by running 'gentl script <path-to-coaxlink-scripts-dir>/doc/basics.js', or
// more simply 'gentl script egrabber://doc/basics.js'.
// Euresys GenApi Script is case-sensitive.
// Statements are always separated by semicolons (JavaScript is more
// permissive).
// Single-line comment
/* Multi-line comment
(cannot be nested)
*/
// Function declaration
function multiply(a, b) {
return a * b;
}
// Functions can be nested
function sumOfSquares(a, b) {
function square(x) {
return x * x;
}
return square(a) + square(b);
}
// Variable declaration
function Variables() {
var x = 1; // 1
var y = 2 * x; // 2
var z; // undefined
}
// Data types
function DataTypes() {
// Primitive types: Boolean, Number, String, undefined
function Booleans() {
var x = true;
var y = false;
}
function Numbers() {
var x = 3.14159;
var y = -1;
var z = 6.022e23;
}
function Strings() {
var empty = "";
var x = "euresys";
var y = 'coaxlink';
var z = x + ' ' + y; // euresys coaxlink
assertEqual(x, z.slice(0, 7));
assertEqual(y, z.slice(8));
}
function Undefined() {
// undefined is the type of variables without a value
// undefined is also a special value
var x; // undefined
x = 1; // x has a value
x = undefined; // x is now again undefined
}
// Objects: Object (unordered set of key/value pairs), Array (ordered list
// of values), RegExp (regular expression)
function Objects() {
// Construction
var empty = {};
var x = { a: 1, b: 2, c: 3 };
var y = { other: x };
// Access to object properties
var sum1 = x.a + x.b + x.c; // dot notation
var sum2 = x['a'] + x['b'] + x['c']; // bracket notation
// Adding properties
x.d = 4; // x: { a: 1, b: 2, c: 3, d: 4 }
x["e"] = 5; // x: { a: 1, b: 2, c: 3, d: 4, e: 5 }
}
function Arrays() {
// Construction
var empty = [];
var x = [3.14159, 2.71828];
var mix = [1, false, "abc", {}];
// Access to array elements
var sum = x[0] + x[1]; // bracket notation
// Adding elements
x[2] = 1.61803; // x: [3.14159, 2.71828, 1.61803]
x[4] = 1.41421; // x: [3.14159, 2.71828, 1.61803, undefined, 1.41421];
}
function RegularExpressions() {
var x = /CXP[36]_X[124]/;
}
Booleans();
Numbers();
Strings();
Undefined();
Objects();
Arrays();
}
// Like JavaScript, Euresys GenApi Script is a dynamically typed language. The
// type of a variable is defined by the value it holds, which can change.
function DynamicVariables() {
var x = 1; // Number
x = "x is now a string";
}
// Object types are accessed by reference.
function References() {
var x = [3.14159, 2.71828]; // x is a reference to an array
var y = x; // y is a reference to the same array
assertEqual(x.length, y.length);
assertEqual(x[0], y[0]);
assertEqual(x[1], y[1]);
y[2] = 1.61803; // the array can be modified via any reference
assertEqual(x[2], y[2]);
function update(obj) {
// objects (including arrays) are passed by reference
obj.updated = true;
obj.added = true;
}
var z = { initialized: true, updated: false };
assertEqual(true, z.initialized);
assertEqual(false, z.updated);
assertEqual(undefined, z.added);
update(z);
assertEqual(true, z.initialized);
assertEqual(true, z.updated);
assertEqual(true, z.added);
}
// Supported operators
function Operators() {
// From lowest to highest precedence:
// Assignment operators: = += -= *= /=
var x = 3;
x += 2;
x -= 1;
x *= 3;
x /= 5;
assertEqual(2.4, x);
// Logical OR: ||
assertEqual(true, false || true);
assertEqual('ok', false || 'ok');
assertEqual('ok', 'ok' || 'ignored');
// Logical AND: &&
assertEqual(false, true && false);
assertEqual(true, true && true);
assertEqual('ok', true && 'ok');
// Identity (strict equality) and non-identity (strict inequality): === !==
assertEqual(true, 1 === 2 / 2);
assertEqual(true, 1 !== 2);
// Equality (==) and inequality (!=) JavaScript operators lead to confusing
// and inconsistent conversions of their operands. They are not implemented
// in Euresys GenApi Script.
// Relational operators: < <= > >=
assert(1 < 2);
assert(1 <= 1);
assert(2 > 1);
assert(2 >= 2);
// Addition and subtraction: + -
assertEqual(1, 3 - 2);
assertEqual(5, 2 + 3);
assertEqual("abcdef", "abc" + "def"); // if one of the operands is of type
assertEqual("abc123", "abc" + 123); // string, all operands are converted
assertEqual("123456", 123 + "456"); // to string, and concatenated
// Multiplication and division: * /
assertEqual(4.5, 3 * 3 / 2);
// Prefix operators: ++ -- ! typeof
var x = 0;
assertEqual(1, ++x);
assertEqual(1, x);
assertEqual(0, --x);
assertEqual(0, x);
assertEqual(true, !false);
assertEqual('boolean', typeof false);
assertEqual('number', typeof 0);
assertEqual('string', typeof '');
assertEqual('undefined', typeof undefined);
assertEqual('function', typeof function () {});
assertEqual('object', typeof {});
assertEqual('object', typeof []);
assertEqual('object', typeof /re/);
assertEqual('object', typeof null);
// Postfix operators: ++ --
var x = 0;
assertEqual(0, x++);
assertEqual(1, x);
assertEqual(1, x--);
assertEqual(0, x);
// Function call: ()
assertEqual(6, multiply(3, 2));
assertEqual(13, sumOfSquares(3, 2));
// Member access: . []
var obj = { a: 1 };
assertEqual(1, obj.a);
obj['4'] = 'four';
assertEqual('four', obj[2*2]);
}
// Scope of variables
function OuterFunction() {
var x = 'outer x';
function Shadowing() {
assertEqual(undefined, x);
var x = 'inner x';
assertEqual('inner x', x);
}
function Nested() {
assertEqual('outer x', x);
var y = 'not accessible outside Nested';
x += ' changed in Nested';
}
function NoBlockScope() {
var x = 1;
assertEqual(1, x);
if (true) {
// The scope of variables is the function.
// This variable x is the same as the one outside the if block.
var x = 2;
}
assertEqual(2, x);
}
assertEqual('outer x', x);
Shadowing();
assertEqual('outer x', x);
Nested();
assertEqual('outer x changed in Nested', x);
NoBlockScope();
}
// Loops
function Loops() {
// for loops
function ForLoops() {
var i;
var sum = 0;
for (i = 0; i < 6; ++i) {
sum += i;
}
assertEqual(15, sum);
}
// for..in loops: iterating over indices
function ForInLoops() {
var xs = [1, 10, 100, 1000];
var sum = 0;
for (var i in xs) {
sum += xs[i];
}
assertEqual(1111, sum);
var obj = { one: 1, two: 2 };
var sum = 0;
for (var p in obj) {
sum += obj[p];
}
assertEqual(3, sum);
var str = "Coaxlink";
var sum = "";
for (var i in str) {
sum += str[i];
}
assertEqual("Coaxlink", sum);
}
// for..of loops: iterating over values
function ForOfLoops() {
var xs = [1, 10, 100, 1000];
var sum = 0;
for (var x of xs) {
sum += x;
}
assertEqual(1111, sum);
var obj = { one: 1, two: 2 };
var sum = 0;
for (var x of obj) {
sum += x;
}
assertEqual(3, sum);
var str = "Coaxlink";
var sum = "";
for (var c of str) {
sum += c;
}
assertEqual("Coaxlink", sum);
}
function ContinueAndBreak() {
var i;
var sum = 0;
for (i = 0; i < 100; ++i) {
if (i === 3) {
continue;
} else if (i === 6) {
break;
} else {
sum += i;
}
}
assertEqual(0 + 1 + 2 + 4 + 5, sum);
}
ForLoops();
ForInLoops();
ForOfLoops();
ContinueAndBreak();
}
function Exceptions() {
var x;
var caught;
var finallyDone;
function f(action) {
x = 0;
caught = undefined;
finallyDone = false;
try {
x = 1;
if (action === 'fail') {
throw action;
} else if (action === 'return') {
return;
}
x = 2;
} catch (e) {
// Executed if a throw statement is executed.
assertEqual(1, x);
caught = e;
} finally {
// Executed regardless of whether or not a throw statement is
// executed. Also executed if a return statement causes the
// function to exit before the end of the try block.
finallyDone = true;
}
}
f('fail');
assertEqual(1, x);
assertEqual('fail', caught);
assert(finallyDone);
f('return');
assertEqual(1, x);
assert(!caught);
assert(finallyDone);
f();
assertEqual(2, x);
assert(!caught);
assert(finallyDone);
}
function CharCode() {
assertEqual(0x41, "ABC".charCodeAt());
assertEqual(0x42, "ABC".charCodeAt(1));
assertEqual(0x43, "ABC".charCodeAt(2));
assertEqual("A", String.fromCharCode(0x41));
assertEqual("ABC", String.fromCharCode(0x41, 0x42, 0x43));
}
// Run tests
Variables();
DynamicVariables();
DataTypes();
References();
Operators();
OuterFunction();
Loops();
Exceptions();
CharCode();
function assertEqual(expected, actual) {
if (expected !== actual) {
throw 'expected: ' + expected + ', actual: ' + actual;
}
}
function assert(condition) {
if (!condition) {
throw 'failed assertion';
}
}
The