## Embedding

### Embedding Reference

#### `CL_CATCH_ALL`

Create a protected region.

##### C Macro

      cl_env_ptr env = ecl_process_env();
      CL_CATCH_ALL_BEGIN(env) {
        /*
         * Code that is protected. Uncaught lisp conditions, THROW,
         * signals such as SIGSEGV and SIGBUS may cause jump to
         * this region.
         */
      } CL_CATCH_ALL_IF_CAUGHT {
        /*
         * If the exception, lisp condition or other control transfer
         * is caught, this code is executed.
         */
      } CL_CATCH_ALL_END
      /*
       * In all cases we exit here.
       */

##### Description

This is a set of three macros that create an `UNWIND-PROTECT` region that prevents any nonlocal transfer of control to outer loops. In the Lisp speak, the previous code is equivalent to

    (block nil
      (unwind-protect
         (progn
            ;; Code that is protected
    	)
        (return nil)))

As explained in ,it is normally advisable to set up an unwind-protect frame to avoid the embedded lisp code to perform arbitary transfers of control.

##### See also

`cl_unwind_protect`

#### `CL_UNWIND_PROTECT`

Create a protected region.

##### C Macro

      cl_env_ptr env = ecl_process_env();
      CL_UNWIND_PROTECT_BEGIN(env) {
        /*
         * Code that is protected. Uncaught lisp conditions, THROW,
         * signals such as SIGSEGV and SIGBUS may cause jump to
         * this region.
         */
      } CL_UNWIND_PROTECT_EXIT {
        /*
         * If the exception, lisp condition or other control transfer
         * is caught, this code is executed. After this code, the
         * process will jump to the original destination of the
         * THROW, GOTO or other control statement that was interrupted.
         */
      } CL_UNWIND_PROTECT_END
      /*
       * We only exit here if NO nonlocal jump was interrupted.
       */

##### Description

When embedding &ECL; it is normally advisable to set up an unwind-protect frame to avoid the embedded lisp code to perform arbitary transfers of control. Furthermore, the unwind protect form will be used in at least in the following ocasions:

- In a normal program exit, caused by `ext:quit`, &ECL; unwinds up to the outermost frame, which may be an or macro.

Besides this, normal mechanisms for exit, such as `ext:quit`, and uncaught exceptions, such as serious signals (), are best handled using unwind-protect blocks.

##### See also

#### `cl_boot`

Setup the lisp environment.

##### Function

        int cl_boot
        int argc
        char **argv

argc

  An integer with the number of arguments to this program.

argv

  A vector of strings with the arguments to this program.

##### Description

This function must be called before any other function from the &ECL; library, including the creation of any lisp object or evaluating any lisp code. The only exception are and .

#### `cl_shutdown`

Close the lisp environment.

##### Function

        int cl_shutdown
        void

##### Description

This function must be called before exiting a program that uses the &ECL; environment. It performs some cleaning, including the execution of any finalizers, unloading shared libraries and deleting temporary files that were created by the compiler.

#### `ecl_set_option`

Set a boot option.

##### Function

        void ecl_set_option
        int option
        cl_fixnum value

option

  An integer from .

value

  A cl_index value for this option.

##### Description

This functions sets the value of different options that have to be customized before &ECL; boots. The table of options and default values [] shows that some of them are boolean, and some of them are unsigned integers.

We distinguish three sets of values. The first set determines whether &ECL; handles certain exceptions, such as access to forbidden regions of memory, interrupts via Ctrl-C, floating point exceptions, etc.

The second set is related to the sizes of different stacks. Currently &ECL; uses four stacks: a bind stack for keeping assignments to special variables; a frame stack for implementing blocks, tagbodys and catch points; an interpreter stack for evaluating bytecodes, and finally the machine or C stack, of the computer we run in. We can set the expected size of these stacks, together with the size of a safety area which, if penetrated, will lead to the generation of a correctable error.

###### Boot options for embedded &ECL;

Name (`ECL_OPT_*`) | Type | Default | Description
--- | --- | --- | ---
`INCREMENTAL_GC` | boolean | `TRUE` | Activate generational garbage collector.
`TRAP_SIGSEGV` | boolean | `TRUE` | Capture SIGSEGV signals.
`TRAP_SIGFPE` | boolean | `TRUE` | Capture floating point exceptions.
`TRAP_SIGINT` | boolean | `TRUE` | Capture user interrupts.
`TRAP_SIGILL` | boolean | `TRUE` | Capture SIGILL exception.
`TRAP_INTERRUPT_SIGNAL` | boolean | `TRUE` | Capture the signal that implements `mp:interrupt-process`.
`SIGNAL_HANDLING_THREAD` | boolean | `TRUE` | Create a signal to capture and process asynchronous threads (See ).
`BOOTED` | boolean | `TRUE/FALSE` | Has &ECL; booted (read only).
`BIND_STACK_SIZE` | cl_index | `8192` | Size of stack for binding special variables.
`BIND_STACK_SAFETY_AREA` | cl_index | `128` |
`FRAME_STACK_SIZE` | cl_index | `2048` | Size of stack for nonlocal jumps.
`FRAME_STACK_SAFETY_AREA` | cl_index | `128` |
`LISP_STACK_SIZE` | cl_index | `32768` | Size of interpreter stack.
`LISP_STACK_SAFETY_AREA` | cl_index | `128` |
`C_STACK_SIZE` | cl_index | `131072` | Size of C stack (not exact).
`C_STACK_SAFETY_AREA` | cl_index | `4192` |
`THREAD_INTERRUPT_SIGNAL` | unsigned int | `0` | If nonzero, specify the unix signal which is used to communicate different Lisp threads.

#### `ecl_get_option`

Read the value of a boot option.

##### Function

        cl_fixnum ecl_get_option
        int option

option

  An integer from .

##### Description

This functions reads the value of different options that have to be customized before &ECL; boots. The table of options and default values is .

#### `ecl_clear_interrupts`

Clear all pending signals and exceptions.

##### Macro

        ecl_clear_interrupts

##### Description

This macro clears all pending interrupts.

##### See also

and .

#### `ecl_disable_interrupts`

Postpone handling of signals and exceptions.

##### Macro

        ecl_disable_interrupts

##### Description

This macro sets a thread-local flag indicating that all received signals should be queued for later processing.

##### See also

and .

#### `ecl_enable_interrupts`

Activate handling of signals and exceptions.

##### Macro

        ecl_enable_interrupts

##### Description

This macro sets a thread-local flag indicating that all received signals can be handled. If there are any pending signals, they will be immediately processed.

##### See also

and .