This is Info file seer.inf, produced by Makeinfo version 1.67 from the
input file seer.txi.

START-INFO-DIR-ENTRY
* SeeR: (seer). The SeeR C-scripting library.
END-INFO-DIR-ENTRY
This is the Info version of the SeeR manual

By Przemek Podsiadly


File: seer.inf,  Node: Top,  Prev: (dir),  Up: (dir)

               ____         ______
              /    \         \   \\
             |               |     |   Scripting engine
              \____  ____ ___|     |
                   \/   \\  \\____/      v 0.94a
             /      |_____|___|   \
            |      /\    \   |     |
             \____/  \___/\___/     \
     
               by Przemyslaw Podsiadly 1998-99

#include <std_disclaimer.h>

"I do not accept responsibility for any effects, adverse or otherwise,
that this code may have on you, your computer, your sanity, your dog,
and anything else that you can think of. Use it at your own risk."
The idea was to make a script engine for any purpose you would need.
This can be for AI in the game, for macros in an editor or whatever.
This is for things you cannot (or don't want to) have compiled
(hard-coded) inside your program. The idea was to make it easy to
learn, and though it's a C library, SeeR is (or will be) an almost
complete C/C++ compiler.

* Menu:

* Using::                   Using SeeR
* How::                     How do I set up SeeR
* Basics::                  Basics
* Compilation::             Compilation
* Instance::                Instance
* Multitasking::            Multitasking
* Error::                   Error reporting
* Scripting::               Scripting language quick reference
* Builtin::                 Builtin internal headers
* Conclusion::              Conclusion
* Index::                   Index


File: seer.inf,  Node: Using,  Next: How,  Up: Top

Using SeeR
**********

For GENERAL RELEASE INFORMATION see readme.txt.  There you will find
general introduction, copyright details, and information about how to
install SeeR and link your program with it.  There is all about seerc
compiler, examples and so on.

This document is only the manual of SeeR the scripting lib.


File: seer.inf,  Node: How,  Next: Basics,  Prev: Using,  Up: Top

How do I set up SeeR
********************

But first I would like to explain some vocabulary. So:
program - the normal C/C++ program, in which you may
load/compile/execute scripts;  script source - that's difficult - the
source code of the script;  script - the script source after
compilation;  instance - the script prepared for execution - with
allocated space for stack, data, registers. Only instance you can
execute. You can do this as many time as you wish. You do this by
calling script's functions. Between such calls the contents of global
variables is preserved.

The first thing you shouldn't forget is to include SeeR header:

     #include < seer.h >

Then init SeeR (some functions may try to initialize SeeR if you
haven't done this before, like compilation routines, but some may
crash!):


     scInit_SeeR();

Using scSeeR_Get(...) and scSeeR_Set(...) functions you may get some
SeeR informations, like SeeR version and release mode (release, debug),
the number of lines compiled recently. There are also some options you
may alter, like optimization flags, dispatcher functions, callback
function etc.

What next? You may export all symbols your scripts may use.  SeeR can
use any main-program function or variable (I call them symbols) you
give him.  Use scAdd_External_Symbol (scAddExtSym for shorter) or
scAdd_Member_Symbol to do this.Examples:


     scAdd_External_Symbol("printf",printf);
     scAddExtSym(scanf);//this is the shorter version
     scAdd_External_Symbol("cls",my_clear_screen);//the names can differ

In the script you can import also class member functions. But to import
such a function your main program does not have to be written in C++.
With non-objective C you can have objective scripts without any
problems.  Below you see two member-functions imported: from the normal
C++ member and from the C function pretending to be member-function.


     scAdd_Member_Symbol("string.append",string::append);
     scAdd_Member_Symbol("string.operator[]",string_operatorINDEX);

You may also make some internal headers. In a script you can #include
files (like #include "file.h") or include special internal headers
(#include internal). The internal header is just a string (char *) in
the program, which contains what a normal header files use to.

You can provide also custom dispatchers (quite advanced, only for
experienced, but see exclassc for details).

When you have a script-source, you may compile it. The compiled script
is stored in a variable of type scScript. There are two special
functions for this : scCompile_File and scCompile_Text.  Examples:

     scScript s1,s2;
     
     s1=scCompile_File("script.sc");
     
     if (!s1)
      {printf("Error during compilation:\n%s\nIn line:%s\n",scErrorMsg,scErrorLine);
       exit(scErrorNo);
      }

or the text version

     s2=scCompile_Text(
     "#title \"The textual script\"\n"
     
     "import int printf(char *,...);\n"
     
     "export Info;\n"
     "export life;\n"
     
     "int life=21;\n"
     
     "int Info(int age)\n"
     "{\n"
     " life+=age;\n"
     " printf(\"I'm Goldfryd. I'm %d years old.\",life);\n"
     " return life;\n"
     "}\n"
     );
     
     if (!s2)
      {printf("Error during compilation:\n%s\nIn line:%s\n",scErrorMsg,scErrorLine);
       exit(scErrorNo);
      }

Now create instances (scCreate_Instance) for the scripts (each script
can have plenty of them). The instance is of type scInstance. Here the
script s2 has two instances: in1 and in2.


     scInstance *in1,*in2;
     
     in1=scCreate_Instance(s2,"");
     
     if (scErrorNo) //in scErrorNo there is an error numer
        printf("Runtime error :\n%s\n",scErrorMsg);
     
     in2=scCreate_Instance(s2,"");
     
     if (scErrorNo)
        printf("Runtime error :\n%s\n",scErrorMsg);

Since now you can access variables from the instances, call functions,
and so on. You can do even multitasking (several instances running
together in peace).
The first thing is that the symbol has to be exported.  That is done in
the script-source using keyword export:

     export life;
     int life=21;

To access such a function/variable, the program has to find out its
address. You do it with scGet_Symbol.
To access a variable:

     scVar(in1,scGet_Symbol(in1,"life"),int)=24;
      or
     scNameVar(in1,"life",int)=24;

Or, when you access the variable more often, you can get the address
only once to make it faster:

     int address=scGet_Symbol(in1,"life");
     
     for(i=0;i
        scVar(in1,address,int)=i;

To call a function:

     i=scCall_Instance(in1,scGet_Symbol(in1,"Info"),1);

Above, the 1 is the parameter to script-function Info.  This is the
normal way of calling. In this situation SeeR knows how many arguments
the function Info needs.
But when you want to call a function with variable number of arguments,
SeeR does not know how many arguments you really pass. In those
situations you should use the other, more general way, where you
explicitly give the size (in bytes) of arguments:

     int argument=1;
     i=scVCall_Instance(in1,scGet_Symbol(in1,"Info"),sizeof(int),&argument);

This function does not take the arguments to script-function explicitly,
but needs the pointer to arguments. That's why &argument is given.

When you are finished with this, you can deallocate instance with

     scFree_Instance(in1);
     scFree_Instance(in2);

The script you deallocate with standard C free:

     free(s1);
     free(s2);

So, peace!


File: seer.inf,  Node: Basics,  Next: Compilation,  Prev: How,  Up: Top

Basics
******

* Menu:

* SeeR_VERSION::
* scInit_SeeR::
* scSeeR_Get::
* scSeeR_Set::
* scSeeR_Set and scSeeR_Get examples::
* scToggle_Debug::
* scOpen_Debug::
* scClose_Debug::


File: seer.inf,  Node: SeeR_VERSION,  Next: scInit_SeeR,  Up: Basics

#define SeeR_VERSION          100
#define SeeR_VERSION_STR      "1.00"
#define SeeR_DATE             20000101
#define SeeR_DATE_STR         "2000-01-01"
     The SeeR defines SeeR version and date. To obtain numeric version,
     write:

          SeeR_VERSION/100.0

     SeeR_DATE stores the date in yyyymmdd format.  There are also
     string versions of above (*_STR).


File: seer.inf,  Node: scInit_SeeR,  Next: scSeeR_Get,  Prev: SeeR_VERSION,  Up: Basics

void scInit_SeeR(void)
     Initialises the SeeR library. A good thing is to call this before
     any play with SeeR. But you may also forget it. Some functions
     just check if SeeR has been inited, and if not they init it (so
     call this function).


File: seer.inf,  Node: scSeeR_Get,  Next: scSeeR_Set,  Prev: scInit_SeeR,  Up: Basics

int scSeeR_Get(int,...);
     This function is provided for common unified method of getting
     state of SeeR.
     The first parameter is the option which state you want to get.
     Following parameters are just parameters to those options.

     This is the list of valid get-only options. If it is not stated
     explicitly what parameters they require, they take no parameters.

        * scSeeR_Version       - returns SeeR_VERSION
        * scSeeR_Build         - returns build version, that is:
          scSeeR_Build_Release - SeeR may not debug, but is fastest
          scSeeR_Build_Debug   - SeeR may generate debug files
        * scSeeR_LinesCompiled - returns number of lines compiled during
          latest compilation
        * scSeeR_ParamCount - returns the size in bytes of parameters
          passed to imported function
     This is the list of other options, which can be both set and get.
     When get:

        * scSeeR_SafeMode       - if SeeR restricts user from using
          some unsafe features (like pointers - in future)
          (UNIMPLEMENTED)

        * scSeeR_Debugging      - if debugging is on

        * scSeeR_Dispatcher     - get function dispatcher,
          parameter:int nr

        * scSeeR_ExprOpcode     - if SeeR outputs statement separator
          opcode EXPR

        * scSeeR_StackSize      - get stack size in bytes

See also:
*Note scSeeR_Set::.
*Note scSeeR_Set and scSeeR_Get examples::.

File: seer.inf,  Node: scSeeR_Set,  Next: scSeeR_Set and scSeeR_Get examples,  Prev: scSeeR_Get,  Up: Basics

bool scSeeR_Set(int,...);
     This function is provided for common unified method of setting
     options to SeeR.
     The first parameter is the option which state you want to set.
     Following parameters are just parameters to those options.

     This is the list of valid set-only options. If it is not stated
     explicitly what parameters they require, they take no parameters.

        * scSeeR_OpenDebug - open debug file, starts debugging
          parameter:char *filename
        * scSeeR_CloseDebug - close file,Stop debugging

     This is the list of other options, which can be both set and get.
     When set:

        * scSeeR_SafeMode       - if SeeR restricts user from using
          some unsafe features (like pointers - in future)
          (UNIMPLEMENTED)
          parameter:int mode

        * scSeeR_Debugging      - if debugging is on
          parameter:int on

        * scSeeR_Dispatcher     - set function dispatcher,
          parameter:int nr,void *scFunctionDispatcher

        * scSeeR_ExprOpcode     - output statement separator opcode
          (EXPR), false - execution is faster, but in multitasking
          script may not be interrupted every X instructions
          parameter:bool EXPR

        * scSeeR_StackSize      - set stack size for next compiled
          script, in bytes
          parameter:int stack_size_in_bytes

See also:
*Note scSeeR_Get::.
*Note scSeeR_Set and scSeeR_Get examples::.

File: seer.inf,  Node: scSeeR_Set and scSeeR_Get examples,  Next: scToggle_Debug,  Prev: scSeeR_Set,  Up: Basics

     scSeeR_Set and scSeeR_Get Examples:

          if (!scSeeR_Set(scSeeR_OpenDebug,"debug.txt"))
             {printf("Unable to start debugging.!\n");exit(1);}
          
          if (scSeeR_Get(scSeeR_Debugging))
             {scSeeR_Set(scSeeR_CloseDebug);}
          
          scSeeR_Set(scSeeR_StackSize,512);


File: seer.inf,  Node: scToggle_Debug,  Next: scOpen_Debug,  Prev: scSeeR_Set and scSeeR_Get examples,  Up: Basics

void scToggle_Debug(bool debon);
     Toggles debugging on and off. When debugging is on, compilation and
     execution process is described in a debug file (this is done by
     SeeRC for example). This can be also done with ->scSeeR_Set.
     Debugging makes compilation and execution a lot slower, so you
     should have this in mind when using this.

     WARNING: Debug does work only in debug version of library. In
     release version these 3 functions do completely NOTHING. This
     restriction is set for speed reasons.


File: seer.inf,  Node: scOpen_Debug,  Next: scClose_Debug,  Prev: scToggle_Debug,  Up: Basics

void scOpen_Debug(char *filename);
     Opens a debug file named filename and toggles debugging on.  This
     can be also done with ->scSeeR_Set.


File: seer.inf,  Node: scClose_Debug,  Next: scCompile_File,  Prev: scOpen_Debug,  Up: Basics

void scClose_Debug();
     Closes debug file and also turns debugging off.  This can be also
     done with ->scSeeR_Set.


File: seer.inf,  Node: Compilation,  Next: Instance,  Prev: Basics,  Up: Top

Compilation
***********

* Menu:

* scCompile_File::
* scLoad_Script::


File: seer.inf,  Node: scCompile_File,  Next: scLoad_Script,  Prev: scClose_Debug,  Up: Compilation

scScript scCompile_File(char *);
scScript scCompile_Text(char *);
     Compiles the source loaded from File or from memory (stored simply
     as char* ended with 0).  Return the compiled script in scScript
     (which is btw. simply a char*).

     If return NULL, that means something went wrong. The scErrorNo
     contains the info on this.


File: seer.inf,  Node: scLoad_Script,  Next: scCreate_Instance,  Prev: scCompile_File,  Up: Compilation

scScript scLoad_Script(char *);
     This one only loads precompiled (e.g using SeeRC) script to
     memory. It's now ready to be used as instance.  It can be useful
     when you have many scripts and compilation of them take some time
     or you don't want final users to change them. In these situations
     you simply compile the script using SeeRC (or WSeeRC) or with your
     custom- built "level-designer", or something...

     This function is very simple thingy. As this loads only from
     normal files, you may be in need of loading a script from for
     example datafile. You may implement it very easly. Follow this (I
     hope I'm not wrong somewhere there):


          scScript MyLoad(char *filename)
          {int size=my_file_size(filename);
           scScript JA=malloc(size+1);
           MyFile *f=my_open_file(filename);
           my_fileread(f,JA,size);
           my_close_file(f);
           JA[size]=0;//remember to add this!!
          }

     (if you have problems, see to the sources before mailing me;-)


File: seer.inf,  Node: Instance,  Next: Multitasking,  Prev: Compilation,  Up: Top

Instance
********

* Menu:

* scCreate_Instance::
* scFree_Instance::
* scGet_Script_Size::
* scGet_This::
* scActual_Instance::
* scGet_Symbol::
* scCall_Instance::
* scVCall_Instance::
* scStart_Instance::
* scVar::
* scNameVar::
* scAdd_Internal_Header::
* scAdd_External_Symbol::
* scAdd_Member_Symbol::
* scExport_Kernel::
* scGet_Title::
* scStandardDispatcher::
* scIgnore_Rights::
* scSet_Priority::
* scGet_Priority::
* scGet_Actual_Priority::
* scPriorityGuard::
* scKernelOnly::


File: seer.inf,  Node: scCreate_Instance,  Next: scFree_Instance,  Prev: scLoad_Script,  Up: Instance

scInstance* scCreate_Instance(scScript script,char* variables,...);
     To run a script, first you have to create instance of it using
     this routine.  Having an instance, you can then call any function,
     access any variable from the script.  (Not implemented:) Variables
     is a list of variables in script you want to initialize with
     specific values,like this:


          Character* Human[2];
          Human[1].inst=scCreate_Instance(scrpt,"this group",&Human[1],1);

     (with `Character* this' and 'int group' in the script)


File: seer.inf,  Node: scFree_Instance,  Next: scGet_Script_Size,  Prev: scCreate_Instance,  Up: Instance

void scFree_Instance(scInstance *sci);
     Frees memory allocated to the instance (WARNING:first it should be
     killed if in multitasking mode!!!).


File: seer.inf,  Node: scGet_Script_Size,  Next: scGet_This,  Prev: scFree_Instance,  Up: Instance

int scGet_Script_Size(scScript);
     Returns size of script in bytes (e.g. for storing in file), or 0
     if not a valid SeeR script.


File: seer.inf,  Node: scGet_This,  Next: scActual_Instance,  Prev: scGet_Script_Size,  Up: Instance

scInstance* scGet_This();
     Returns scActual_Instance, that is an instance being actually run
     (the instance that called an imported function calling scGet_This).
     If none is actually running, it returns NULL.


File: seer.inf,  Node: scActual_Instance,  Next: scGet_Symbol,  Prev: scGet_This,  Up: Instance

scInstance* scActual_Instance;
     This is set every time you call scCall_Instance, scVCall_Instance
     and for every instance in scContinue_Instances. When these
     functions exit, it's set to NULL. It points to an instance being
     actually executed.


File: seer.inf,  Node: scGet_Symbol,  Next: scCall_Instance,  Prev: scActual_Instance,  Up: Instance

int scGet_Symbol(scInstance*,char *);
     Returns an address of specified symbol in instance - not a valid
     pointer, just address relative to the script address. It may be
     different for two different instances of the same script, but
     doesn't change in time.  So you can read address only once per
     instance, and then use stored address (that will significantly
     increase speed of accessing variables and calling functions).  If
     symbol hasn't been found in the instance, it returns -1.


File: seer.inf,  Node: scCall_Instance,  Next: scVCall_Instance,  Prev: scGet_Symbol,  Up: Instance

int scCall_Instance(scInstance*,int address,...);
     Starts a function from specified address in the script. Parameters
     after address are parameters to this function. The function
     address can be obtained using scGet_Symbol(...),e.g.

          x=scCall_Instance(inst,scGet_Symbol(inst,"move"),10);//10 is a parameter

     The function returns the return value of this function (only if
     it's 4-bytes long, so it cant be long long, double or struct). It
     also sets ->scErrorNo if any error happens during execution.


File: seer.inf,  Node: scVCall_Instance,  Next: scStart_Instance,  Prev: scCall_Instance,  Up: Instance

int scVCall_Instance(scInstance* inst,int address,int paramc,int *params);
     Alike previous function it calls a function, but parameters are
     passed via params pointer(paramc is size of parameters in BYTES).


File: seer.inf,  Node: scStart_Instance,  Next: scVar,  Prev: scVCall_Instance,  Up: Instance

void scStart_Instance(scInstance *,...);
     Starts `main' function in the script.


File: seer.inf,  Node: scVar,  Next: scNameVar,  Prev: scStart_Instance,  Up: Instance

macro scVar(scInstance* inst,int adr,type)
     Macro for accessing a variable exported in script of inst-instance.
     e.g x=scVar(inst,scGet_Symbol(inst,"x"),int); or
     scVar(inst,scGet_Symbol(inst,"x"),int)=5;

See also:
*Note scNameVar::.

File: seer.inf,  Node: scNameVar,  Next: scAdd_Internal_Header,  Prev: scVar,  Up: Instance

macro scNameVar(scInstance *ins,char *name,type)
     This macro is just shortcut for:
     scVar(ins,scGet_Symbol(ins,name),type).

See also:
*Note scVar::.

File: seer.inf,  Node: scAdd_Internal_Header,  Next: scAdd_External_Symbol,  Prev: scNameVar,  Up: Instance

void scAdd_Internal_Header(char *name,char *contents);
     Specifies the include contents of a header "file" that can be
     included in script using #include name (without ""!).


File: seer.inf,  Node: scAdd_External_Symbol,  Next: scAdd_Member_Symbol,  Prev: scAdd_Internal_Header,  Up: Instance

void scAdd_External_Symbol(char *,void *);
     Specifies the symbol (function or variable) you give (export to)
     your scripts.  This affects all instances & scripts.  e.g.

          Add_External_Symbol("printf",printf);       //for a function
          Add_External_Symbol("gamelogic",&gamelogic);// for a variable

See also:
*Note scAdd_Member_Symbol::.

File: seer.inf,  Node: scAdd_Member_Symbol,  Next: scExport_Kernel,  Prev: scAdd_External_Symbol,  Up: Instance

void scAdd_Member_Symbol(char *,...);
     Does the same as scAdd_External_Symbol, you can give it anything.
     Also class-members (hence the name). You can even forget about the
     previous(scAdd_External_Symbol).  The must example:

          Add_Member_Symbol("NPC.move",NPC::move);

See also:
*Note scAdd_External_Symbol::.

File: seer.inf,  Node: scExport_Kernel,  Next: scGet_Title,  Prev: scAdd_Member_Symbol,  Up: Instance

void scExport_Kernel();
     Sets up an internal header `Kernel' and adds all external symbol
     it lists. (->Builtin internal headers)


File: seer.inf,  Node: scGet_Title,  Next: scStandardDispatcher,  Prev: scExport_Kernel,  Up: Instance

char* scGet_Title(scScript);
char* scGet_Author(scScript);
char* scGet_Instance_Title(scInstance*);
     Retrieves author and title information out of the script or
     instance.  Not existing scGet_Instance_Author(i) would be
     equivalent to scGet_Author(i->code).


File: seer.inf,  Node: scStandardDispatcher,  Next: scIgnore_Rights,  Prev: scGet_Title,  Up: Instance

void scStandardDispatcher (int *result,void *function,int *params,int paramcount,unsigned int options);
     Dispatchers have been introduced in SeeR 0.93. It happened that I
     wanted SeeR to be used in a bigger project. And they wanted it to
     be portable.  Problem! While I had written routines for calling
     functions/member functions for GCC and VC on Intels only, to make
     it portable I wrote some C equivalents.  But they are still not
     portable (they would although work on many systems).  That's why I
     made DISPATCHERs. This is the way to let the user implement the
     calling convention mechanism himself.

     When you import a function normally, the dispatcher # 0 will be
     used to call it (which is btw scStandardDispatcher). But when you
     use "import(1)",  the dispatcher # 1 will be used. SeeR implements
     both dispatchers number 0 and 1.  You may implement some more
     dispatchers - up to 15 (14 should be enough for everyone ;-).

     So the dispatcher must be something like this:

          typedef void (*scFunctionDispatcher)
            (int *result,void *function,int *params,int paramcount,unsigned int options);

     What the arguments mean:

        * result is pointer to something, where you should store the
          result of the function, e.g. int or double (don't care that
          it's defined as int *, it may be equally good double *);

        * function is a pointer to function, that should be called;

        * params is a table of parameters to function (it's part of the
          stack);

        * paramcount is the size of parameters in bytes;

        * options:
          options & scDispatch_Double - true, if result is a double,
          not int;
          options & scDispatch_Member - true, if the function is member
          of a class; in this situation the first parameter is 'this'
          (a pointer to the object).
     Example taken from SeeR's source distribution:

          void scCDispatcher
          (int *result,void *function,int *params,int paramcount,unsigned int options)
          {
            if (options&scDispatch_Member)
            {//C++ call - convert to typical C call, so 'this' is the first param.
                  options^=scDispatch_Member;//erase member flag
            }
            //call the default dispatcher
            scStandardDispatcher(result,function,params,paramcount,options);
          }

     and somewhere below I set scCDispatcher as dispatcher # 1:

          scSeeR_Set(scSeeR_Dispatcher,1,scCDispatcher);

     Since version 0.94, SeeR provides some classes, which use this
     dispatcher (because SeeR is written in pure C, it cannot use
     dispatcher 0 for calling member functions).

See also:
*Note import::.

File: seer.inf,  Node: scIgnore_Rights,  Next: scSet_Priority,  Prev: scStandardDispatcher,  Up: Instance

bool scIgnore_Rights;
     If true, makes all the functions ignore priorities at all, even if
     they check the priority via scPriority_Guard or scKernel_Only.


File: seer.inf,  Node: scSet_Priority,  Next: scGet_Priority,  Prev: scIgnore_Rights,  Up: Instance

void scSet_Priority(scInstance*, int priority_level);
     Sets the priority to an instance. Priority is simply an int number.
     Here are the standard values:

          scrights_USER        0       lowest priority
          scrights_KERNEL      256
          scrights_TOP         MAXINT  maximum priority - no instance is being run


File: seer.inf,  Node: scGet_Priority,  Next: scGet_Actual_Priority,  Prev: scSet_Priority,  Up: Instance

int scGet_Priority(scInstance* ins);
     Gets priority of an instance. If ins==NULL returns scNONE.


File: seer.inf,  Node: scGet_Actual_Priority,  Next: scPriorityGuard,  Prev: scGet_Priority,  Up: Instance

int scGet_Actual_Priority();
     =scGet_Priority(scActual_Instance);


File: seer.inf,  Node: scPriorityGuard,  Next: scKernelOnly,  Prev: scGet_Actual_Priority,  Up: Instance

#define scPriorityGuard(priority,rets)
     This macro is to be used in functions that are protected, i.e that
     cannot be called by instances that do not have enough priority.
     This sets a runtime error and returns rets (can be `;' for
     functions returning void). See exmulti.


File: seer.inf,  Node: scKernelOnly,  Next: scGet_Scheduler,  Prev: scPriorityGuard,  Up: Instance

#define scKernelOnly(rets)
     =scPriorityGuard(scrights_KERNEL,rets);


File: seer.inf,  Node: Multitasking,  Next: Error,  Prev: Instance,  Up: Top

Multitasking
************

Multitasking mode is a simple way to run many instance at the same
time. For example, when you make RPG engine, each character (NPC) has
it's own instance running. He is also able to have more instances of
the same script operating on the same data (by forking).

The scheduler (scScheduler) contains list of all running instances
(processes). It is used by scContinue_Instances() to run all of them.
Now you are able to switch schedulers, so you can set up two or more
schedulers being run in different frequency. For example you can have
scheduler for real-time instances, that move characters, and more rare
ones, that do more complex operations, like working out the main
tactics and sending orders to computer's characters.  In
regulation-systems this is called a layer model (OK, maybe it has a
different term in English, I only know the Polish terms in this matter
:-(.

* Menu:

* scGet_Scheduler::
* scSet_Scheduler::
* scPause_Instance::
* scKill_Instance::
* scGet_Instance_Status::
* scVLaunch_Instance::
* scLaunch_Instance::
* scContinue_Instances::
* Forking::
* scFork_Instance::
* scGet_Forked::
* scGet_Actual_Forked::
* scKill_Forked_Instances::
* scGet_Forked_Status::


File: seer.inf,  Node: scGet_Scheduler,  Next: scSet_Scheduler,  Prev: scKernelOnly,  Up: Multitasking

scScheduler* scGet_Scheduler();
     Returns actual scheduler.


File: seer.inf,  Node: scSet_Scheduler,  Next: scPause_Instance,  Prev: scGet_Scheduler,  Up: Multitasking

scScheduler* scSet_Scheduler(scScheduler*);
     Sets new scheduler. It returns the previous one.  If you pass NULL
     to it, it'll create a new empty one.


File: seer.inf,  Node: scPause_Instance,  Next: scKill_Instance,  Prev: scSet_Scheduler,  Up: Multitasking

void scPause_Instance(scInstance*,int pause);
     If (pause) freezes the instance in scheduler queue, else unfreezes.
     Freezed (paused) instance is not processed by the scheduler.


File: seer.inf,  Node: scKill_Instance,  Next: scGet_Instance_Status,  Prev: scPause_Instance,  Up: Multitasking

void scKill_Instance(scInstance*);
     Removes an instance from the scheduler queue - it won't run in all
     further calls of scContinue_Instance until next scLaunch_Instance.


File: seer.inf,  Node: scGet_Instance_Status,  Next: scVLaunch_Instance,  Prev: scKill_Instance,  Up: Multitasking

int scGet_Instance_Status(scInstance *);
     Returns status of an instance:

          scstatus_FREE    - instance is not run or does not exist
          scstatus_RUNNING - it's in scheduler and is not paused
          scstatus_PAUSED  - it's paused


File: seer.inf,  Node: scVLaunch_Instance,  Next: scLaunch_Instance,  Prev: scGet_Instance_Status,  Up: Multitasking

int scVLaunch_Instance(scInstance* inst,int spd,int address,int paramc,int *params);
     This function is the same to scLaunch_Instance like function
     scVCall_Instance to scCall_Instance.  It does the same as
     scLaunch_Instance, but here we pass parameters via params, and
     size in _BYTES_ of parameters should be in paramc.


File: seer.inf,  Node: scLaunch_Instance,  Next: scContinue_Instances,  Prev: scVLaunch_Instance,  Up: Multitasking

int scLaunch_Instance(scInstance* inst,int spd,int address,...);
     Tells SeeR scheduler that you want the instance and function at
     address to be processed in multitasking mode. It's not executed
     yet. You have to call scContinue_Instances to execute the
     scheduler - a list of instances (you can launch many
     simoultanously running different instances).  WARNING:You cannot
     launch previously launched and not killed instance!!!  (to launch
     instance twice at the same time, use forking-desc. below) The
     error will be returned.  The spd parameter is speed of instance
     running (ie spd=10 - every 10th instruction or WAIT instruction,
     scheduler freezes instance and calls next one in
     scContinue_Instances function).


File: seer.inf,  Node: scContinue_Instances,  Next: Forking,  Prev: scLaunch_Instance,  Up: Multitasking

int scContinue_Instances(void);
     Continues running all previously launched instances. Returns
     number of running instances (ie 0 if none). If it returns -1 - an
     error must have occured during process of running any instance.
     Flag scErrorNo is then set to appropriate error value. The
     instance that caused a problem is removed (killed) from the
     running queue and scheduler doesn't process further instances till
     the next call of scContinue_Instances.


File: seer.inf,  Node: Forking,  Next: scFork_Instance,  Prev: scContinue_Instances,  Up: Multitasking

     Fork is a way to create instances from already existing instance
     (parent).  But these instances aren't typical - they use the same
data segment as it's parent. There are many ways to fork an instance
and operate on them.  Each forked instance has it's number.


File: seer.inf,  Node: scFork_Instance,  Next: scGet_Forked,  Prev: Forking,  Up: Multitasking

scInstance* scFork_Instance(scInstance*);
     It's one of the ways to create a forked instance. It returns
     forked instance, that has it's number (identifying it). Now these
     instances (parent and child) can be executed independently. They
     share only common data segment (global script variables).


File: seer.inf,  Node: scGet_Forked,  Next: scGet_Actual_Forked,  Prev: scFork_Instance,  Up: Multitasking

scInstance* scGet_Forked(scInstance* parent,int no);
     Returns instance forked from parent and has number no. If there is
     not such an instance, it returns NULL.


File: seer.inf,  Node: scGet_Actual_Forked,  Next: scKill_Forked_Instances,  Prev: scGet_Forked,  Up: Multitasking

scInstance* scGet_Actual_Forked(int);
     The same as scGet_Forked, but for actually running instance
     (scGet_This()).


File: seer.inf,  Node: scKill_Forked_Instances,  Next: scGet_Forked_Status,  Prev: scGet_Actual_Forked,  Up: Multitasking

void scKill_Forked_Instances(scInstance* parent);
     Kills and frees (scFree_Instance) all instances forked from
     parent. Of course you can also kill each forked one by one. When
     you kill an instance that has children (forks), one of children
     will become a parent of others.


File: seer.inf,  Node: scGet_Forked_Status,  Next: scErrorNo,  Prev: scKill_Forked_Instances,  Up: Multitasking

int scGet_Forked_Status(int);
void scKill_My_Forked_Instances();
void scKill_Forked(int);
     All these functions operate on scActual_Instance. They do what is
     done by scGet_Instance_Status, scKill_Forked_Instances and
     scKill_Instance, but operate on scActual_Instance or it's forks.


File: seer.inf,  Node: Error,  Next: Scripting,  Prev: Multitasking,  Up: Top

Error reporting
***************

When the compilation finishes, in scErrorNo holds the status of
operation.  Also after creating or executing an instance scErrorNo is
set.

WARNING: all compile, run (call & continueing intance) instructions
clear scErrorNo flag at their begining!

* Menu:

* scErrorNo::
* scErrorMsg::
* scErrorLine::


File: seer.inf,  Node: scErrorNo,  Next: scErrorMsg,  Prev: scGet_Forked_Status,  Up: Error

int scErrorNo;
     May holds following value:

        * scOK if operation was successful

        * other if it wasn't - then you should report it somehow (or
          whatever)


File: seer.inf,  Node: scErrorMsg,  Next: scErrorLine,  Prev: scErrorNo,  Up: Error

char *scErrorMsg;
     Here SeeR stors an error message, like "Script( 31):parse error"
     (in brackets there is a line number). The debug version of SeeR
     generates some more information (SeeR's source file and line, that
     reported that error).


File: seer.inf,  Node: scErrorLine,  Next: import,  Prev: scErrorMsg,  Up: Error

char *scErrorLine;
     Here is stored a copy of line that caused an error (valid if error
     appeared during compilation).


File: seer.inf,  Node: Scripting,  Next: Builtin,  Prev: Error,  Up: Top

Scripting language quick reference
**********************************

The language is almost like C. See restrictions for not implemented
features of the language.

NOTE: when I write something in {}, it does not mean you have to put
this in {}, but I want to accent that it's not a keyword.  So

     import {declaration}
may extend to

     import int x;
and not

     import {int x;}

New keywords:

* Menu:

* import::
* export::
* secured::
* __vcpu::
* fork::
* author::
* title::
* typeof::
* script::
* SeeR::
* include::
* Structures::
* Restrictions::


File: seer.inf,  Node: import,  Next: export,  Prev: scErrorLine,  Up: Scripting

keyword import
     Usage:
     import {declaration}
     import (dispatcher_number) {declaration}
     import (dispatcher_number)(import_name) {declaration}
     The declaration of imported from outside (the program) function or
     variable. Default import uses dispatcher 0.

     In the second version (with a number) you can explicitly put the
     dispatcher number. See also dispatcher.

     WARNING:dispatcher 0 and 1 are both implemented in SeeR and we
     recommend you don't change them. Use 2nd and above (up to 15).

     If you want to import functions with the same name, but different
     parameters, you will have problem with import names (they will be
     the same). In such situation you use the third variant, where you
     can explicitly state the import name. Example:

          class string{
          import string operator+(string& x);
          import(operator+(char*)) string operator+(char *x);
          };


File: seer.inf,  Node: export,  Next: secured,  Prev: import,  Up: Scripting

keyword export
     Usage:
     export {name}
     Specifies symbol (function or variable) that can be accessed from
     outside the script.  Example: script.sc

          export main;
          int go() {printf("go()\n");return 0;}
          int main() {printf("main()\n");return 1;}

     In prog.c you may use

          i=scCall_Instance(in,scGet_Symbol(in,"main"));
      but not

          i=scCall_Instance(in,scGet_Symbol(in,"go"));
      (where in is a valid scInstance* ).


File: seer.inf,  Node: secured,  Next: __vcpu,  Prev: export,  Up: Scripting

keyword secured
     Usage:
     secured statement
     The group of instructions specified after `secured' are embrased
     with CLI ... STI (virtual opcodes, not processor) - this group
     (and all functions called inside) cannot be interrupted while
     multitasking. This can be helpful when you compute some numbers
     inside a script, and while doing so script is interrupted and you
     use those numbers, they may contain quite undefined values.


File: seer.inf,  Node: __vcpu,  Next: fork,  Prev: secured,  Up: Scripting

keyword __vcpu
     Usage:
     __vcpu(i1,...)
     Generate VCPU opcode(s) specified as integers, eg.  56 - wait 57 -
     cli 58 - sti 61 - nop

     CAUTION: wait (opcode 56) has to be passed alone, e.g
     __vcpu(57,56,58); won't work OK(but separately 3 x __vcpu will)!!!

     WARNING: Better not use it other way that via macro WAIT. The
     numbers, that SeeRVitualCPU stores its instructions may change in
     next version of SeeR.


File: seer.inf,  Node: fork,  Next: author,  Prev: __vcpu,  Up: Scripting

keyword fork
     Usage:
     fork statement
     fork (int_variable) statement
     Only in multitasking mode: creates fork instance that will execute
     the statement and exit while actual instance continues.

     See also forking in Multitasking section above.

     The int_variable will contain the number of forked instance, so
     later we can check if it has finished.

     Example

          int main(int c)
          {int i,x,y;
           fork(i) //creates new process
            {int l;
             for (l=0;l
            }
           y=5*c+12;
           while (scGet_Forked_Status(i));//wait till fork ends.
           //we can also fork like below, when we don't care about the number of forked inst.
           fork y+=x;//equal to: fork {y+=x;}
          }


File: seer.inf,  Node: author,  Next: title,  Prev: fork,  Up: Scripting

directive #author
     Usage:
     #author "Author full name"
     #author one_word_nick
     Sets the author to be stored in script. This information may be
     retrieved with scGet_Author.

     Examples:

          #author "William Shakespeare"

     or

          #author Billy

     (but not #author William Shakespeare! (that's more than one word)
See also:
*Note title::.
*Note scGet_Title::.

File: seer.inf,  Node: title,  Next: typeof,  Prev: author,  Up: Scripting

directive #title
     Usage:
     #title "The Long Title"
     #title one_word_title
     Sets the title to be stored in script. This information is used in
     error-reporting. It may be retrieved with scGet_Title.

See also:
*Note author::.
*Note scGet_Title::.

File: seer.inf,  Node: typeof,  Next: script,  Prev: title,  Up: Scripting

keyword typeof
     Usage:
     typeof(type-declaration)
     Returns text description of a type, e.g.

          "int"
          "double*"
          "char[256]"
          "struct{int int int}"
          "script{name name name}"

     It was created specially for the type script. When you initialize
     the script, you have to pass the 'typeof' to the function that
     does it, so that it knows which functions or variables you may
     need.


File: seer.inf,  Node: script,  Next: SeeR,  Prev: typeof,  Up: Scripting

type script
     There was always a problem how to easy communicate between scripts.
     To solve this I created the script type.

     Built-in macros:


File: seer.inf,  Node: SeeR,  Next: include,  Prev: script,  Up: Scripting

#define SeeR "1.00" // the current version
#define WAIT __vcpu(56)
#define NULL (void *)0
#define c_import import(1)
     Differences to C:


File: seer.inf,  Node: include,  Next: Structures,  Prev: SeeR,  Up: Scripting

directive #include
     Usage:
     #include "file"
     #include internal-header
     Internal headers is a feature of SeeR, that lets you make a
     header-file inside your program as (char *) variable. Use
     scAdd_Internal_Header to let SeeR know about specific header (and
     to assign it a name).


File: seer.inf,  Node: Structures,  Next: Restrictions,  Prev: include,  Up: Scripting

     Structures can be declared in C++ way:

          struct TYPE_NAME{
          ...
          };

     However, they shouldn't be accessed as `struct TYPE_NAME', like

          void Foo(struct TYPE_NAME x);

     but simply in a C++ way

          void Foo(TYPE_NAME x);

     So all those typedefs to make the life easy are now unnecessary.


File: seer.inf,  Node: Restrictions,  Next: Instances,  Prev: Structures,  Up: Scripting

     List of unimplemented C features:

        * old function declaration scheme,

        * unions, bitfields and enums,

        * goto instruction and labels,

        * static variables in functions

     List of unimplemented C++ features:

        * templates,

        * exceptions,

        * class inheritance,

        * static members,

        * operator new/delete,

        * and many other that came with ANSI C++(like namespaces,etc.)

     So you see the implementation of C++ is quite limited.


File: seer.inf,  Node: Builtin,  Next: Conclusion,  Prev: Scripting,  Up: Top

Builtin internal headers
************************

* Menu:

* Instances::
* Kernel::
* stdlib::


File: seer.inf,  Node: Instances,  Next: Kernel,  Prev: Restrictions,  Up: Builtin

#include Instances
     This header is used to make some operations on SeeR instances
     (other than fork) available in scripts as a standard. The
     instructions don't operate on true scInstance*, so they seem safe
     that one instance won't kill all the others.

          char *hdrInstances=
          "
          #ifndef SeeR_Internal_Instances
          #define scstatus_FREE    0
          #define scstatus_RUNNING 1
          #define scstatus_PAUSED  2
          
          import void scKill_My_Forked_Instances();
          import void scKill_Forked(int);
          import int scGet_Forked_Status(int);
          import int scGet_Actual_Priority();
          #define SeeR_Internal_Instances
          #endif
          ";


File: seer.inf,  Node: Kernel,  Next: stdlib,  Prev: Instances,  Up: Builtin

#include Kernel
     Does not require any priority (before v0.8 it required scKernel
     right) to run any specified function. To make the functions
     accessible, scExport_Kernel() function should be used in your main
     program, which will export all required functions. These functions
     give great freedom to the script, so use it with care!

          char *hdrKernel=
          "
          #ifndef SeeR_Internal_Kernel
          #include Instances
          //can call all imported kernel API function
          #define scrights_KERNEL 256
          //cannot ---
          #define scrights_USER     0
          //when no instance is being run:
          #define scrights_TOP MAXINT
          
          typedef void scInstance;
          typedef void* scScript;
          import scInstance* scCreate_Instance(scScript,char*,...);
          import scInstance* scFork_Instance(scInstance*);
          import void scFree_Instance(scInstance *);
          
          import scScript scCompile_File(char *);
          import scScript scCompile_Text(char *);
          import scScript scLoad_Script(char *);
          
          import scInstance* scGet_This();
          import scInstance* scGet_Forked(scInstance*,int);
          import scInstance* scGet_Actual_Forked(int);
          import void scPause_Instance(scInstance*,int);
          import void scKill_Instance(scInstance*);
          import void scKill_Forked_Instances(scInstance*);
          
          import int scGet_Script_Size(scScript);
          import int scCall_Instance(scInstance*,int address,...);
          import int scVCall_Instance(scInstance*,int,int,int*);
          import int scStart_Instance(scInstance *,...);
          import int scGet_Symbol(scInstance*,char*);
          import int scLaunch_Instance(scInstance* inst,int spd,int address,...);
          
          import void scSet_Priority(scInstance*, int priority_level);
          import int scGet_Priority(scInstance*);
          
          #define SeeR_Internal_Kernel
          #endif
          ";


File: seer.inf,  Node: stdlib,  Prev: Kernel,  Up: Builtin

#include stdlib
     This header contains some classes ready to use by every SeeR
     script.  That is:
        * class string - for easy string operation, like concatention,
          substrings, comparison, conversion etc. Example:

               string x,y="eagle";
               x=y+" is flying";
               //You can normally pass it as char*.
               printf("%s\n",x);
               if (y=="eagle") y="hawk";
               x=y+" and "+x;
               printf("%s\n",x(5,3));//"and"
               if (x(9,5)=="eagle") is_eagle=1;

        * class vector - for easy use of 3d vectors. Example:

               vector x(1,2,3),y(3,4,5);
               x+=y;
               if (x+y>vector(10,11,12)) {x-=y;}
               else {x+=y;}

        * class hashInt - for easy use of hashes:unlimited-size arrays
          using hash-functions. Unimplemented. Example:

               hashInt x;
               (int)x[1000000]=1;
               (int)x[-100000]=-1;
               if (x.exists(1000000)) printf("OK.\n");

        * class hashStr - for easy use of hashes:arrays indexed with
          strings. Unimplemented. Example:

               hashStr x;
               (int)x["Jola"]=1;
               (int)x["Jas"]=-1;
               if (x.exists("Yaga")) printf("Danger\n");


          char *hdrStdLib=
          "
          #ifndef SeeR_Internal_StdLib
          #include Instances
          
          /* class string */
          class string{
          
          public:
          
           char *cstr;
          
           c_import(string) string();
           c_import(string_SZ) string(char *x);
           c_import(string_I) string(int x);
           c_import(stringCC) string(string& f);
          
           c_import ~string();
          
           c_import(operator=(int)) string& operator=(int x);
           c_import string& operator=(string& s);
           c_import(operator=(char*)) string& operator=(char *s);
          
           c_import string operator+(string& x);
           c_import(operator+(char*)) string operator+(char *s);
          
           c_import string sub(int start,int len);
           c_import string operator()(int start,int len);
          
           c_import int cmp(string& x);
           c_import bool operator==(string& x);
           c_import bool operator!=(string& x);
           c_import(operator==(char*)) bool operator==(char *x);
           c_import bool operator>(string& x);
           c_import bool operator
           c_import bool operator>=(string& x);
           c_import bool operator
           c_import void operator+=(string& x);
           c_import(operator+=(char*)) void operator+=(char* x);
          
           c_import void del(int start,int len);
           c_import void insert(int start,string& x);
          //index of first found occurance
           c_import int find(string& x);
          //returns number of replaces
          //when global==false, it replaces only once
           c_import int replace(string& what,string& with,bool global=false);
          //returns length of a string
           c_import int length();
          
          /* operators */
           c_import int toInt();//toint
           c_import int operator(int)();//toint
           c_import char& operator[](int idx);
          /* for future, actually does nothing */
           c_import void reconstruct();
          
          // class hashInt
          class hashInt{
          public:
           c_import hashInt();
           c_import ~hashInt();
          
           c_import void*& operator[](int id);
          
           c_import void add(int id,void *data);
           c_import bool exists(int id);
           c_import void *remove(int id);
           c_import void *get(int id);
          
           c_import bool empty();
          
           c_import int first();
           c_import int next();
          
          };
          
          // class hashStr
          class hashStr{
          public:
           c_import hashStr();
           c_import ~hashStr();
          
           c_import void*& operator[](char *id);
          
           c_import void add(char* id,void *data);
           c_import bool exists(char* id);
           c_import void *remove(char* id);
           c_import void *get(char* id);
          
           c_import bool empty();
          
           c_import char *first();
           c_import char *next();
          };
          
          struct vector{
           double x,y,z;
          public:
           c_import(vectorVOID) vector();
           c_import vector(double,double,double);
           c_import(vectorCC) vector(vector& v);
          
           c_import vector& operator=(vector& v);
          
           c_import vector operator+(vector& v);
           c_import vector operator-(vector& v);
           c_import vector operator*(vector& v);//cross product
          
           c_import void operator+=(vector& v);
           c_import void operator-=(vector& v);
           c_import void operator*=(vector& v);
          
           c_import bool operator==(vector& v);
           c_import bool operator
           c_import bool operator>(vector& v);
           c_import bool operator
           c_import bool operator>=(vector& v);
          
           c_import void normalize();
           c_import double length();
          
          };
          
          #define SeeR_Internal_StdLib
          #endif
          "


File: seer.inf,  Node: Conclusion,  Next: Index,  Prev: Builtin,  Up: Top

Conclusion
**********

That's all for now (sorry if you find it not complete).  If you find
something unclear in the documentation, first look at the examples.
They show almost every feature of SeeR. Then, if you're still confused,
email me.
Enjoy !!!
I'd be happy to see what you've used it for...
By Przemyslaw Podsiadly (just Przemek)
12 Modrzewiowa Street,
08-110 Siedlce, Poland.
ppodsiad@elka.pw.edu.pl

http://home.elka.pw.edu.pl/~ppodsiad/seer/


File: seer.inf,  Node: Index,  Prev: Conclusion,  Up: Top

Index
*****

* Menu:

* __vcpu::
* author::
* export::
* fork::
* Forking::
* import::
* include::
* Instances::
* Kernel::
* Restrictions::
* scActual_Instance::
* scAdd_External_Symbol::
* scAdd_Internal_Header::
* scAdd_Member_Symbol::
* scCall_Instance::
* scClose_Debug::
* scCompile_File::
* scContinue_Instances::
* scCreate_Instance::
* scErrorLine::
* scErrorMsg::
* scErrorNo::
* scExport_Kernel::
* scFork_Instance::
* scFree_Instance::
* scGet_Actual_Forked::
* scGet_Actual_Priority::
* scGet_Forked::
* scGet_Forked_Status::
* scGet_Instance_Status::
* scGet_Priority::
* scGet_Scheduler::
* scGet_Script_Size::
* scGet_Symbol::
* scGet_This::
* scGet_Title::
* scIgnore_Rights::
* scInit_SeeR::
* scKernelOnly::
* scKill_Forked_Instances::
* scKill_Instance::
* scLaunch_Instance::
* scLoad_Script::
* scNameVar::
* scOpen_Debug::
* scPause_Instance::
* scPriorityGuard::
* script::
* scSeeR_Get::
* scSeeR_Set::
* scSeeR_Set and scSeeR_Get examples::
* scSet_Priority::
* scSet_Scheduler::
* scStandardDispatcher::
* scStart_Instance::
* scToggle_Debug::
* scVar::
* scVCall_Instance::
* scVLaunch_Instance::
* secured::
* SeeR::
* SeeR_VERSION::
* stdlib::
* Structures::
* title::
* typeof::



Tag Table:
Node: Top246
Node: Using1761
Node: How2139
Node: Basics7694
Node: SeeR_VERSION7950
Node: scInit_SeeR8397
Node: scSeeR_Get8746
Node: scSeeR_Set10290
Node: scSeeR_Set and scSeeR_Get examples11852
Node: scToggle_Debug12288
Node: scOpen_Debug12941
Node: scClose_Debug13186
Node: Compilation13406
Node: scCompile_File13558
Node: scLoad_Script14007
Node: Instance15160
Node: scCreate_Instance15737
Node: scFree_Instance16390
Node: scGet_Script_Size16652
Node: scGet_This16891
Node: scActual_Instance17217
Node: scGet_Symbol17577
Node: scCall_Instance18195
Node: scVCall_Instance18835
Node: scStart_Instance19158
Node: scVar19340
Node: scNameVar19677
Node: scAdd_Internal_Header19930
Node: scAdd_External_Symbol20223
Node: scAdd_Member_Symbol20705
Node: scExport_Kernel21152
Node: scGet_Title21396
Node: scStandardDispatcher21773
Node: scIgnore_Rights24650
Node: scSet_Priority24922
Node: scGet_Priority25362
Node: scGet_Actual_Priority25573
Node: scPriorityGuard25754
Node: scKernelOnly26152
Node: Multitasking26327
Node: scGet_Scheduler27624
Node: scSet_Scheduler27794
Node: scPause_Instance28063
Node: scKill_Instance28359
Node: scGet_Instance_Status28655
Node: scVLaunch_Instance29025
Node: scLaunch_Instance29484
Node: scContinue_Instances30366
Node: Forking30958
Node: scFork_Instance31335
Node: scGet_Forked31746
Node: scGet_Actual_Forked32026
Node: scKill_Forked_Instances32269
Node: scGet_Forked_Status32686
Node: Error33097
Node: scErrorNo33515
Node: scErrorMsg33792
Node: scErrorLine34136
Node: Scripting34347
Node: import34987
Node: export36016
Node: secured36581
Node: __vcpu37123
Node: fork37646
Node: author38505
Node: title38982
Node: typeof39325
Node: script39852
Node: SeeR40084
Node: include40303
Node: Structures40694
Node: Restrictions41131
Node: Builtin41737
Node: Instances41915
Node: Kernel42738
Node: stdlib44871
Node: Conclusion50408
Node: Index50939

End Tag Table
