You must assign values to both MYCFILES and CFILES.

The convention that there is a header file for each C++ file is essential for configuration system to work correctly.

Standard Targets

it, all

it and all must the default targets which are executed when no targets are given to make. Both targets it and all are required.

install.local

This target is used to perform installation operations which are specific for the local directory. \TBD{}.

Modules

• The module gt_base, which implements basic and Tcl independend data structures.
• The module gt_tcl, which implements Graphlet's Tcl interface. Most of Graphscript is implemented here.
• The module gt_algorithms implements various algorithms.

Guidelines for adding C++ modules

Example

• The initialization file of the algorithms module: \begin{quote} src/gt_algorithms/algorithms.cpp \end{quote}
• Header file of the initialization procedure of the algorithms module: \begin{quote} src/gt_algorithms/algorithms.h \end{quote}

The Initialization File

• #include
• #include
• #include

The Initialization Procedure

int GT_mod_init (Tcl_Interp* interp, GT_GraphScript* graphscript)

The naming convention is necessary to use the standard initialization macros with application_init.

Initialization procedures must never make any assumptions on the sequence in which initialization procedures are called. The only valid assumption is that Graphlet's initializations are called before any algorithm modules are initialized.

Guidelines for adding Graphscript modules

Placement

Filenames in lib/graphscript

• If there is only one Graphscript file, it should have the same name as the module (with suffix .tcl).
• If there are several files, organize them in a subdirectory with the name of the module.

GNUmakefile modifications

 
  lib/graphscript/GNUmakefile

Subdirectories do not need to have their own GNUmakefile's. Instead, add all files to lib/graphscript/GNUmakefile. Remember to use relative paths.

Initialization

1. Tcl will execute any statements at the top level of a Tcl file when it loads the file. Put initialization code here.
2. (Preferred) Implement an initialization procedure in Tcl (preferably called GT_init_name for module name) and execute that procedure in the initialization procedure of the C++ code. Here is an example:

   code = Tcl_Eval (interp, "GT_name_init");
   if (code == TCL_ERROR) {
       return code;
   }
   

   The Tcl initialization procedure should come at the end of the C++ module initialization, after all Graphscript commands have been installed.

How to determine what is installed

C++

For each module name, Graphlet defines a preprocessor symbol GT_MODULE_NAME (note the capital letters). This can be used to write code which is only executed when a specific module exists:

#ifdef GT_MODULE_NAME
  ... put code here that needs module name here ...
#endif

Graphscript

Tcl goes even one step further than C++ and allows runtime testing for installed commands with info commands. Here is an example how to use that:

if { [info commands cmd_name] != {} } {
  ... Put code here that needs command cmd_name ...
}

\begin{note} It is generally a good idea to add menu entries only for those commands which are actually installed. \end{note}

Building Graphscript Interpreters

The main procedure

int main (int argc, char **argv) 
{
    return GT_GraphScript::gt_main (argc, argv, application_init);    
}

It is legal to use the procedure Tk_main instead of GT_GraphScript:gt_main.

The procedure application_init

//
// application_init (Tcl_interp* interp)
//
// interp is the current Tcl interpreter.
//

static int application_init (Tcl_Interp *interp)
{
    //
    // Create a GraphScript handler.
    // For customization, replace the class GT_GraphScript
    // by a derived class.
    //
    
    GT_GraphScript* graphscript = new GT_GraphScript (interp);
    
    //
    // Initialize Tcl, Tk and GraphScript.
    //
    // code holds the Tcl return code.
    //
    
    int code = graphscript->application_init (interp);

    //
    // Check for an error. This step is mandatory.
    //

    if (code == TCL_ERROR) {
        return code;
    }

    //
    // Initialize other algorithm modules
    //

#ifdef GT_MODULE_ALGORITHMS
    GT_ADD_MODULE(gt_algorithms)
#endif

#ifdef GT_MODULE_LSD
    GT_ADD_MODULE(gt_lsd)
#endif GT_MODULE_LSD
    
#ifdef GT_MODULE_GRID_ALGORITHMS
    GT_ADD_MODULE(gt_grid_algorithms)
#endif GT_MODULE_LSD
    
    return code;
}

We recommend the above syntax for the initialization of other modules, provided that these modules conform to the standards described in the module documentation.

Graphlet's configuration system automatically defines a macro GT_MODULE_NAME for each installed module name (note the capital letters).

The macro GT_ADD_MODULE is provided by Graphlet and performs all actions necessary to initialize a standard module. It will exit the procedure and return TCL_ERROR if the module initialization fails.

application_init must return a Tcl error code, that is TCL_OK for a successful return or TCL_ERROR otherwise.

Because Tcl is a C library, application_init must be a procedure or a static member function.

Linking the program

Graphlet libraries
MODULES -lgt_tcl -lgt_base where MODULES is the list of modules as used in application_init above.
Tcl/Tk libraries
-ltk -ltcl
GTL libraries (release 3.4)
-lP -lG -lL
X11 and system libraries
This depends on your operating system, flavor of X11 and local installation policy. Here are some recommendations:
• On solaris systems (2.4/2.5), we recommend -L/usr/openwin/lib -lX11 -lsocket -lnsl -ldl -lm.
• On SunOS systems (4.1.*), we recommend -L/usr/openwin/lib -lX11 -lm
• On Linux systems, we recommend -L/usr/X11/lib -lX11 -ldl -lm

If you are linking with GTL 3.3.*, you need to add the library -lWx.

The order in which libraries are linked is important. We recommend to link libraries in the order indicated above.