Next: , Previous: Data types and constants defined by GH, Up: GH

5.22.5 Starting and controlling the interpreter

In almost every case, your first gh_ call will be:

— Function: void gh_enter (int argc, char *argv[], void (*main_prog)())

Starts up a Scheme interpreter with all the builtin Scheme primitives. gh_enter() never exits, and the user's code should all be in the main_prog() function. argc and argv will be passed to main_prog.

— Function: void main_prog (int argc, char *argv[])

This is the user's main program. It will be invoked by gh_enter() after Guile has been started up.

Note that you can use gh_repl inside gh_enter (in other words, inside the code for main-prog) if you want the program to be controlled by a Scheme read-eval-print loop.

A convenience routine which enters the Guile interpreter with the standard Guile read-eval-print loop (REPL) is:

— Function: void gh_repl (int argc, char *argv[])

Enters the Scheme interpreter giving control to the Scheme REPL. Arguments are processed as if the Guile program guile were being invoked.

Note that gh_repl should be used inside gh_enter, since any Guile interpreter calls are meaningless unless they happen in the context of the interpreter.

Also note that when you use gh_repl, your program will be controlled by Guile's REPL (which is written in Scheme and has many useful features). Use straight C code inside gh_enter if you want to maintain execution control in your C program.

You will typically use gh_enter and gh_repl when you want a Guile interpreter enhanced by your own libraries, but otherwise quite normal. For example, to build a Guile–derived program that includes some random number routines GSL (GNU Scientific Library), you would write a C program that looks like this: 

     #include <guile/gh.h>
     #include <gsl_ran.h>
     
     /* random number suite */
     SCM gw_ran_seed(SCM s)
     {
       gsl_ran_seed(gh_scm2int(s));
       return SCM_UNSPECIFIED;
     }
     
     SCM gw_ran_random()
     {
       SCM x;
     
       x = gh_ulong2scm(gsl_ran_random());
       return x;
     }
     
     SCM gw_ran_uniform()
     {
       SCM x;
     
       x = gh_double2scm(gsl_ran_uniform());
       return x;
     }
     SCM gw_ran_max()
     {
       return gh_double2scm(gsl_ran_max());
     }
     
     void
     init_gsl()
     {
       /* random number suite */
       gh_new_procedure("gsl-ran-seed", gw_ran_seed, 1, 0, 0);
       gh_new_procedure("gsl-ran-random", gw_ran_random, 0, 0, 0);
       gh_new_procedure("gsl-ran-uniform", gw_ran_uniform, 0, 0, 0);
       gh_new_procedure("gsl-ran-max", gw_ran_max, 0, 0, 0);
     }
     
     void
     main_prog (int argc, char *argv[])
     {
       init_gsl();
     
       gh_repl(argc, argv);
     }
     
     int
     main (int argc, char *argv[])
     {
       gh_enter (argc, argv, main_prog);
     }

Then, supposing the C program is in guile-gsl.c, you could compile it with gcc -o guile-gsl guile-gsl.c -lguile -lgsl.

The resulting program guile-gsl would have new primitive procedures gsl-ran-random, gsl-ran-gaussian and so forth.