[[BackLinksMenu]]
= All About SGI =
[[TOC]]
It does what it's on the tin, it interprets generation scripts. It has the C-Code like grammar, but in the tradition of BCPL it's typeless. There are however some considerable exceptions.

A full syntax, [wiki:SGISyntax here], with some semantic explanation, follows ... 

== SGI Pre-Processing ==
SGI has a C-Code style pre-processing, ie has
|| '''Syntax''' || '''Description''' || ''' Example ''' ||
|| || || ||
||#include string||includes a file for interpreteation starting at the %vbron%\gen base directory||#include "PreFatApp//extracode.gen" ||
||#define ident string-to-eol||define a-la C-Code||#define HEADER_INCLUDED 1||
||#define ident(params)||define a-la C-Code||#define macro(_here) _here||
||#ifdef ident ... #else ... #endif||conditional compilation a-la C-Code ... the ident is a macro, not a SGI variable||#ifdef HEADER_INCLUDED[[BR]] #define macro(_here)[[BR]]#else[[BR]] #define macro(_here) _here[[BR]]#endif||

== SGI Meta Syntactic Variables ==
These are a set of what appear to be variables but control functions within the interpreter.

These are ...
||Variable||Range||Value||Meaning||
|| || || || ||
||debugLevel||0-7||1||Trace all function call entry and exit||
|| || ||2||Trace locals, aliases and parameters||
|| || ||4||Trace all assignments||
|| || ||8||Trace filename and line number recognised when "pre-compiling" into intrinsic functions||
|| || ||16||Trace the execution of all intrinsic functions||
|| || || || ||
||autoIndent||0+|| ||The number of tabstops ejected after each "\n" [[BR]]This value can be incremented with the ">>"(!1) command [[BR]]and decremented with the "<<" (!2) command [[BR]]or with autoIndent++; and autoIndent--;||
||lines||0+|| ||The number of lines ejected so far||
||columns||0+|| ||The current column number of the output||
||pageWidth||40+||80||This is the default page width, used to offer automatic page formatting ( no line going over the pageWidth )||
||tabWidth||1+||4||The expected size of a tab character||
||tabReqd||0-1||0||Tabs produced as spaces or tabs produced as tab characters||
|| || || || ||
|| || || || ||
|| || || ||(!1) not to be confused with the ">>" operator[[BR]](!2) not to be confused with the "<<" operator||
|| || || || ||

== Simple Output ==
Anything inside "\[" "\]" will be evaluated and output to stdout.

{{{
#!c
three = "two";
["Hello the " three " of you\n" ]
}}}

will result in
{{{
#!c
Hello to the two of you
}}}

appearing on standard out.

== SGI Scope ==
Scoping in SGI is similar to Pascal.

{{{
#!c
b = 2;

function fn2()
{
    [ b "\n" ]
}

function fn1()
{
    local b;

    b = "one";
    fn2();
}

[ "A) " ] fn1();
[ "B) " ] fn2();
}}}

will produce
{{{
#!c
A) one
B) 2
}}}
The call to fn2() within the fn1() call will produce "one" because the local "b" in fn1() has scope.[[BR]]
The call to fn2() ... will produce "2" because the local "b" from fn1() is no longer in scope and the global "b" is uncovered.[[BR]]
Scope is maintained on a stack frame basis, ie where local variables and parameters are pushed on the stack frame and only the latest one is visible.

A function needs to be declared before it is used, NB declared but not necessarily written. Each time a function is declared it's old code is deleted ... to this end, any function can be re-defined "on the fly" using the 'exec' function.

== SGI Lazy Evaluation ==
In the "expression" and "andClause"s, SGI is now (like C) decision optimising.

in the expression
{{{
 a = b() ? c() : d();
}}}
if b() is true then only c() is executed
if b() is false then only d() is executed
a is assigned either c() or d() ... and not assigned to one or the other after the execution of both c() and d().

in the expression
{{{
 a = b() || c() || d();
}}}

If b() is true then neither c() nor d() are executed. If b() is false however c() is executed. If c() is true then d() is not executed, however if c() is also false then d() is finally executed.

and finally in the expression
{{{
 a = b() && c() && d();
}}}

If b() is false then neither c() nor d() are executed. If b() is true however c() is executed. If c() is false then d() is not executed, however if c() is also true then d() is finally executed.

{{{
#!c
function logicalNot( val )
{
    [ "NOT " ]
    return val ? 0 : 1;
}

function hello( name )
{
    [ "Hello " name "\n" ]
    return 1;
}

[ logicalNot( 1 ) ? hello( "Colin" ) : hello("James") ]

}}}
will create
{{{
#!c
NOT Hello James
}}}

== SGI External Debugging ==
As well as the debegLevel support, there is an SGI Debugger, that allows you to single step through yout SGI code. This can be turned on and off from within the code with the
{{{
#!c
@debug on
}}}
and
{{{
#!c
@debug off
}}}
commands see SGISyntax below ...

== [wiki:SGISyntax SGI Statement Syntax] ==