UIOP/IMAGE

*LISP-INTERACTION* names a special variable:
  Value: T
  Documentation:
    Is this an interactive Lisp environment, or is it batch processing?

• Set by
  • UIOP/IMAGE:RESTORE-IMAGE
• Referenced by
  • UIOP/IMAGE:RESTORE-IMAGE
  • UIOP/IMAGE:HANDLE-FATAL-CONDITION

CREATE-IMAGE names a compiled function:
  Lambda-list: (DESTINATION LISP-OBJECT-FILES &KEY KIND OUTPUT-NAME
                PROLOGUE-CODE EPILOGUE-CODE EXTRA-OBJECT-FILES
                (PRELUDE NIL PRELUDEP) (POSTLUDE NIL POSTLUDEP)
                (ENTRY-POINT NIL ENTRY-POINT-P) BUILD-ARGS NO-UIOP)
  Derived type: (FUNCTION
                 (T T &KEY (:KIND T) (:OUTPUT-NAME T) (:PROLOGUE-CODE T)
                  (:EPILOGUE-CODE T) (:EXTRA-OBJECT-FILES T) (:PRELUDE T)
                  (:POSTLUDE T) (:ENTRY-POINT T) (:BUILD-ARGS T) (:NO-UIOP T))
                 *)
  Documentation:
    On ECL, create an executable at pathname DESTINATION from the specifiedOBJECT-FILES and options
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

RAW-PRINT-BACKTRACE names a compiled function:
  Lambda-list: (&KEY (STREAM *DEBUG-IO*) COUNT CONDITION)
  Derived type: (FUNCTION (&KEY (:STREAM T) (:COUNT T) (:CONDITION T)) *)
  Documentation:
    Print a backtrace, directly accessing the implementation
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • PRINT-BACKTRACE

CALL-IMAGE-DUMP-HOOK names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL *)
  Documentation:
    Call the hook functions registered to be run before to dump an image
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/IMAGE:DUMP-IMAGE

PRINT-CONDITION-BACKTRACE names a compiled function:
  Lambda-list: (CONDITION &KEY (STREAM *STDERR*) COUNT)
  Derived type: (FUNCTION (T &KEY (:STREAM T) (:COUNT T)) *)
  Documentation:
    Print a condition after a backtrace triggered by that condition
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/IMAGE:HANDLE-FATAL-CONDITION

DUMP-IMAGE names a compiled function:
  Lambda-list: (FILENAME &KEY OUTPUT-NAME EXECUTABLE
                (POSTLUDE *IMAGE-POSTLUDE*) (DUMP-HOOK *IMAGE-DUMP-HOOK*)
                COMPRESSION)
  Derived type: (FUNCTION
                 (T &KEY (:OUTPUT-NAME T) (:EXECUTABLE T) (:POSTLUDE T)
                  (:DUMP-HOOK T) (:COMPRESSION T))
                 *)
  Documentation:
    Dump an image of the current Lisp environment at pathname FILENAME, withvarious options.
    
    First, finalize the image, by evaluating the POSTLUDE as per EVAL-INPUT,then calling each of
     the functions in DUMP-HOOK, in reverse order of registration by REGISTER-DUMP-HOOK.
    
    If EXECUTABLE is true, create an standalone executable program that callsRESTORE-IMAGE on startup.
    
    Pass various implementation-defined options, such as PREPEND-SYMBOLS andPURITY on CCL,
    or COMPRESSION on SBCL, and APPLICATION-TYPE on SBCL/Windows.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • (PERFORM (IMAGE-OP SYSTEM))

*IMAGE-ENTRY-POINT* names a special variable:
  Value: NIL
  Documentation:
    a function with which to restart the dumped image when execution isrestored from it.

• Set by
  • (PERFORM BEFORE (PROGRAM-OP SYSTEM))
• Referenced by
  • UIOP/IMAGE:RESTORE-IMAGE

CALL-WITH-FATAL-CONDITION-HANDLER names a compiled function:
  Lambda-list: (THUNK)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Call THUNK in a context where fatal conditions are appropriately handled
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/IMAGE:RESTORE-IMAGE

FATAL-CONDITION-P names a compiled function:
  Lambda-list: (CONDITION)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Is the CONDITION fatal?
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

*IMAGE-DUMP-HOOK* names a special variable:
  Value: (UIOP/CONFIGURATION:CLEAR-CONFIGURATION)
  Documentation:
    Functions to call (in order) when before an image is dumped

• Set by
  • UIOP/IMAGE:DUMP-IMAGE
• Referenced by
  • UIOP/IMAGE:DUMP-IMAGE
  • UIOP/IMAGE:CALL-IMAGE-DUMP-HOOK

*IMAGE-RESTORE-HOOK* names a special variable:
  Value: (UIOP/CONFIGURATION::COMPUTE-USER-CACHE
          UIOP/STREAM:SETUP-TEMPORARY-DIRECTORY
          UIOP/IMAGE:SETUP-COMMAND-LINE-ARGUMENTS UIOP/STREAM:SETUP-STDERR
          UIOP/STREAM:SETUP-STDOUT UIOP/STREAM:SETUP-STDIN)
  Documentation:
    Functions to call (in reverse order) when the image is restored

• Set by
  • UIOP/IMAGE:RESTORE-IMAGE
• Referenced by
  • UIOP/IMAGE:RESTORE-IMAGE
  • UIOP/IMAGE:CALL-IMAGE-RESTORE-HOOK

RAW-COMMAND-LINE-ARGUMENTS names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES T &OPTIONAL))
  Documentation:
    Find what the actual command line for this process was.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/IMAGE:ARGV0
  • UIOP/IMAGE:COMMAND-LINE-ARGUMENTS

ARGV0 names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL *)
  Documentation:
    On supported implementations (most that matter), or when invoked by aproper wrapper script,
    return a string that for the name with which the program was invoked, i.e.argv[0] in C.
    Otherwise, return NIL.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

*IMAGE-DUMPED-P* names a special variable:
  Value: NIL
  Documentation:
    Is this a dumped image? As a standalone executable?

• Set by
  • UIOP/IMAGE:DUMP-IMAGE
• Referenced by
  • UIOP/IMAGE:ARGV0

*IMAGE-PRELUDE* names a special variable:
  Value: NIL
  Documentation:
    a form to evaluate, or string containing forms to read and evaluate
    when the image is restarted, but before the entry point is called.

• Set by
  • UIOP/IMAGE:RESTORE-IMAGE
• Referenced by
  • UIOP/IMAGE:RESTORE-IMAGE

CALL-IMAGE-RESTORE-HOOK names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL *)
  Documentation:
    Call the hook functions registered to be run when restoring a dumped image
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/IMAGE:RESTORE-IMAGE

SHELL-BOOLEAN-EXIT names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Quit with a return code that is 0 iff argument X is true
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/IMAGE:RESTORE-IMAGE

PRINT-BACKTRACE names a compiled function:
  Lambda-list: (&REST KEYS &KEY STREAM COUNT CONDITION)
  Derived type: (FUNCTION (&REST T &KEY (:STREAM T) (:COUNT T) (:CONDITION T))
                 *)
  Documentation:
    Print a backtrace
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/IMAGE:PRINT-CONDITION-BACKTRACE

*COMMAND-LINE-ARGUMENTS* names a special variable:
  Value: NIL
  Documentation:
    Command-line arguments

• Set by
  • UIOP/IMAGE:SETUP-COMMAND-LINE-ARGUMENTS

WITH-FATAL-CONDITION-HANDLER names a macro:
  Lambda-list: ((&OPTIONAL) &BODY BODY)
  Documentation:
    Execute BODY in a context where fatal conditions are appropriately handled
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Macroexpanded by
  • UIOP/IMAGE:RESTORE-IMAGE

FATAL-CONDITION names a type-specifier:
  Lambda-list: ()
  Expansion: (AND SERIOUS-CONDITION)

DIE names a compiled function:
  Lambda-list: (CODE FORMAT &REST ARGUMENTS)
  Derived type: (FUNCTION (T T &REST T) *)
  Documentation:
    Die in error with some error message
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/IMAGE:HANDLE-FATAL-CONDITION

SETUP-COMMAND-LINE-ARGUMENTS names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES T &OPTIONAL))
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

REGISTER-IMAGE-DUMP-HOOK names a compiled function:
  Lambda-list: (HOOK &OPTIONAL (CALL-NOW-P NIL))
  Derived type: (FUNCTION (T &OPTIONAL T) *)
  Documentation:
    Register a the hook function to be run before to dump an image
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

COMMAND-LINE-ARGUMENTS names a compiled function:
  Lambda-list: (&OPTIONAL (ARGUMENTS (RAW-COMMAND-LINE-ARGUMENTS)))
  Derived type: (FUNCTION (&OPTIONAL T) (VALUES T &OPTIONAL))
  Documentation:
    Extract user arguments from command-line invocation of current process.
    Assume the calling conventions of a generated script that uses --
    if we are not called from a directly executable image.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/IMAGE:SETUP-COMMAND-LINE-ARGUMENTS

REGISTER-IMAGE-RESTORE-HOOK names a compiled function:
  Lambda-list: (HOOK &OPTIONAL (CALL-NOW-P T))
  Derived type: (FUNCTION (T &OPTIONAL T) *)
  Documentation:
    Regiter a hook function to be run when restoring a dumped image
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

*IMAGE-POSTLUDE* names a special variable:
  Value: NIL
  Documentation:
    a form to evaluate, or string containing forms to read and evaluate
    before the image dump hooks are called and before the image is dumped.

• Set by
  • UIOP/IMAGE:DUMP-IMAGE
• Referenced by
  • UIOP/IMAGE:DUMP-IMAGE

RESTORE-IMAGE names a compiled function:
  Lambda-list: (&KEY (LISP-INTERACTION *LISP-INTERACTION*)
                (RESTORE-HOOK *IMAGE-RESTORE-HOOK*) (PRELUDE *IMAGE-PRELUDE*)
                (ENTRY-POINT *IMAGE-ENTRY-POINT*)
                (IF-ALREADY-RESTORED (QUOTE (CERROR RUN RESTORE-IMAGEANYWAY))))
  Derived type: (FUNCTION
                 (&KEY (:LISP-INTERACTION T) (:RESTORE-HOOK T) (:PRELUDE T)
                  (:ENTRY-POINT T) (:IF-ALREADY-RESTORED T))
                 *)
  Documentation:
    From a freshly restarted Lisp image, restore the saved Lisp environment
    by setting appropriate variables, running various hooks, and calling anyspecified entry point.
    
    If the image has already been restored or is already being restored, as per*IMAGE-RESTORED-P*,
    call the IF-ALREADY-RESTORED error handler (by default, a continuableerror), and do return
    immediately to the surrounding restore process if allowed to continue.
    
    Then, comes the restore process itself:
    First, call each function in the RESTORE-HOOK,
    in the order they were registered with REGISTER-IMAGE-RESTORE-HOOK.
    Second, evaluate the prelude, which is often Lisp text that is read,
    as per EVAL-INPUT.
    Third, call the ENTRY-POINT function, if any is specified, with noargument.
    
    The restore process happens in a WITH-FATAL-CONDITION-HANDLER, so that ifLISP-INTERACTION is NIL,
    any unhandled error leads to a backtrace and an exit with an error status.
    If LISP-INTERACTION is NIL, the process also exits when no error occurs:
    if neither restart nor entry function is provided, the program will exitwith status 0 (success);
    if a function was provided, the program will exit after the functionreturns (if it returns),
    with status 0 if and only if the primary return value of result isgeneralized boolean true,
    and with status 1 if this value is NIL.
    
    If LISP-INTERACTION is true, unhandled errors will take you to thedebugger, and the result
    of the function will be returned rather than interpreted as a booleandesignating an exit code.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/IMAGE:DUMP-IMAGE

QUIT names a compiled function:
  Lambda-list: (&OPTIONAL (CODE 0) (FINISH-OUTPUT T))
  Derived type: (FUNCTION (&OPTIONAL T T) NIL)
  Documentation:
    Quits from the Lisp world, with the given exit status if provided.
    This is designed to abstract away the implementation specific quit forms.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/IMAGE:SHELL-BOOLEAN-EXIT
  • UIOP/IMAGE:DIE

HANDLE-FATAL-CONDITION names a compiled function:
  Lambda-list: (CONDITION)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Handle a fatal CONDITION:
    depending on whether *LISP-INTERACTION* is set, enter debugger or die
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/IMAGE:CALL-WITH-FATAL-CONDITION-HANDLER