The basics

• Functions are reusable blocks of code. To call a function means to do what's specified in the function.

function printText()
{
	println( "text" );
}
printText();

• Basic function definitions have the following syntax: function <name> ( <argument-list> ) { <code> }
• Argument list is a comma-separated list of names or nothing.
• Names, also called "identifiers", can have the folowing symbols: a-z, A-Z, _, 0-9, but they cannot start with a digit, because only numbers can start with a digit.
• User-defined names cannot collide with so-called keywords - special names, like function

y = 15.51;
x = 3 * y + 10;
x * y;

• Each expression statement ends with ";".
• Useful expression statements include an assignment operator or a function call, or both.
• All expression statements presented so far - except the last one - are useful.
• The assignment operator is "=". It simply assigns the value on the right side to the item on the left side.
• Numbers use the point (".") as decimal digit separator.
• There are arithmetic operators available that take two items at each side (called "binary operators").
• The operators used in the example are those of addition ("+") and multiplication ("*").

include "math";
function sinc( x )
{
	xpi = x * M_PI;
	return sin( xpi ) / xpi;
}
sinc3 = sinc( 3 );

• Functions may return with or without data. When they do return data, that data can be retrieved from the call.
• A basic function call has the syntax <name> <subexpression>
• A subexpression has the syntax ( <expression-list> )
• Expression list is a comma-separated list of expressions or nothing.
• The include statement loads a library or a code file.
• math is one of the few built-in libraries. In this example, it defines the function sin and the constant M_PI

x = 1; y = 2;
x += y;
++x;
--y;

• Shortcuts exist for common operations: combined assignment operators and increment/decrement operators.
• Most non-assignment binary operators have their assignment counterparts. The difference is that they assign the calculated value to the left side of the expression.
• Increment/decrement operators are shortcuts for x += 1 and x -= 1, respectively.
  • There are alternative versions of these operators that will be covered later.

x = 5; y = 3;
x *= y * ( y + x );
y -= x + x * y;
y += 5 * y += y;
printvar( y );
println( dumpvar( x ) );

• There's very few limits on how the expressions can be combined so it's up to you to write them in a way the meaning is clear both to you and the compiler.
• A very useful tool for finding out the contents of a variable are the printvar / dumpvar functions.
• println is a function that prints the given variables to standard output and moves write cursor to the next line.
• Order of arithmetic operations is mathematically correct: sub-expressions ( .. ) are evaluated first, then multiplication * / division / / modulo (remainder) % , and then - addition + and subtraction - .

x = 5;
global y = 6;
function z()
{
	a = 7;
	global b = 8;
	function c(){}
}

• Variables are the currency of this language.
• There are 4 types of variable storage, two of which are covered in the example: local and global variables.
• In the example, variables x, a, c are local and y, z, b are global.
  • All new variables are local by default.
  • The keyword global specifies a list of variables that are global and allows to assign their values.
  • A function definition creates a global function variable outside other functions, local otherwise.

// testing the assignment operator
a = 5;
/* this ----------
-- should print --
------------- 5 */
println( a ); ////

• Code can contain comments. They can be used to communicate between various users and maybe even compilers of the code.
  • The SGScript compiler completely ignores comments.
• There are two types of comments: single-line comments // ... and multiline comments / ... /