## 17 System Definitions ¶

Function: SOCKET (port :host host) ¶

  Package:SI

  GCL specific: Open a socket connection to HOST at PORT.

Function: OPEN-NAMED-SOCKET (port) ¶

  Package:SI

  GCL specific: Open a socket on PORT, returning (cons fd portname) where fd is a small fixnum which is the write file descriptor for the socket. If PORT is zero do automatic allocation of port.

Function: ACCEPT-SOCKET-CONNECTION (NAMED_SOCKET) ¶

  Package:SI

  GCL specific: Wait for a connection on NAMED_SOCKET and return (list* named_socket fd name1) when one is established.

Function: ALLOCATE-CONTIGUOUS-PAGES (number &optional (really-allocate nil)) ¶

  Package:SI

  GCL specific: Sets the maximum number of pages for contiguous blocks to NUMBER. If REALLY-ALLOCATE is non-NIL, then the specified number of pages will be allocated immediately.

Function: FREEZE-DEFSTRUCT (name) ¶

  Package:SI

  The inline defstruct type checker will be made more efficient, in that it will only check for types which currently include NAME. After calling this the defstruct should not be altered.

Function: ALLOCATED-RELOCATABLE-PAGES () ¶

  Package:SI

  GCL specific: Returns the number of pages currently allocated for relocatable blocks.

Function: PUTPROP (symbol value indicator) ¶

  Package:SI

  Give SYMBOL the VALUE on INDICATOR property.

Function: ALLOCATE-RELOCATABLE-PAGES (number) ¶

  Package:SI

  GCL specific: Sets the maximum number of pages for relocatable blocks to NUMBER.

Function: ALLOCATED-CONTIGUOUS-PAGES () ¶

  Package:SI

  GCL specific: Returns the number of pages currently allocated for contiguous blocks.

Function: MAXIMUM-CONTIGUOUS-PAGES () ¶

  Package:SI

  GCL specific: Returns the current maximum number of pages for contiguous blocks.

Function: GET-HOLE-SIZE () ¶

  Package:SI

  GCL specific: Returns as a fixnum the size of the memory hole (in pages).

Function: SPECIALP (symbol) ¶

  Package:SI

  GCL specific: Returns T if the SYMBOL is a globally special variable; NIL otherwise.

Function: OUTPUT-STREAM-STRING (string-output-stream) ¶

  Package:SI

  GCL specific: Returns the string corresponding to the STRING-OUTPUT-STREAM.

Function: GET-STRING-INPUT-STREAM-INDEX (string-input-stream) ¶

  Package:SI

  GCL specific: Returns the current index of the STRING-INPUT-STREAM.

Function: STRING-CONCATENATE (&rest strings) ¶

  Package:SI

  GCL specific: Returns the result of concatenating the given STRINGS.

Function: BDS-VAR (i) ¶

  Package:SI

  GCL specific: Returns the symbol of the i-th entity in the bind stack.

Function: ERROR-SET (form) ¶

  Package:SI

  GCL specific: Evaluates the FORM in the null environment. If the evaluation of the FORM has successfully completed, SI:ERROR-SET returns NIL as the first value and the result of the evaluation as the rest of the values. If, in the course of the evaluation, a non-local jump from the FORM is atempted, SI:ERROR-SET traps the jump and returns the corresponding jump tag as its value.

Function: COMPILED-FUNCTION-NAME (compiled-function-object) ¶

  Package:SI

  GCL specific: Returns the name of the COMPILED-FUNCTION-OBJECT.

Function: STRUCTUREP (object) ¶

  Package:SI

  GCL specific: Returns T if the OBJECT is a structure; NIL otherwise.

Function: IHS-VS (i) ¶

  Package:SI

  GCL specific: Returns the value stack index of the i-th entity in the invocation history stack.

Function: UNIVERSAL-ERROR-HANDLER (error-name correctable function-name continue-format-string error-format-string &rest args) ¶

  Package:SI

  GCL specific: Starts the error handler of GCL. When an error is detected, GCL calls SI:UNIVERSAL-ERROR-HANDLER with the specified arguments. ERROR-NAME is the name of the error. CORRECTABLE is T for a correctable error and NIL for a fatal error. FUNCTION-NAME is the name of the function that caused the error. CONTINUE-FORMAT-STRING and ERROR-FORMAT-STRING are the format strings of the error message. ARGS are the arguments to the format strings. To change the error handler of GCL, redefine SI:UNIVERSAL-ERROR- HANDLER.

Variable: *CODE-BLOCK-RESERVE* ¶

  Package:SI GCL specific: Set this variable to a static array (supply :static t to ’make-array) to reserve space for loading code in low memory as the heap grows large. On large systems, it may prove impossible without this to find unallocated memory below, for example, the 2Gb limit required for the default ’medium model’ code produced by gcc on x86_64 systems.

Variable: *FAST-LINK-WARNINGS* ¶

  Package:SI GCL specific: Set to non-NIL to trace function calls that cannot proceed through a simple pointer dereference, usually because the signature of the callee is substantially different than that assumed when compiling the caller.

Variable: *ANNOTATE* ¶

  Package:COMPILER GCL specific: Set to non-NIL to add comments in the generated C code indicating lisp function inlining.

Variable: *DEFAULT-PROF-P* ¶

  Package:COMPILER GCL specific: Set to non-NIL to add the :prof t option to compile file by default to indicate code which should be prepared for gprof profiling.

Variable: *DEFAULT-LARGE-MEMORY-MODEL-P* ¶

  Package:COMPILER GCL specific: Set to non-NIL to add the :large-memory-model t option to compile file by default to instruct gcc to produce code that can be loaded at any address, typically at a 10% performance penalty.

Variable: *DEFAULT-C-FILE* ¶

  Package:COMPILER GCL specific: Set to non-NIL to add the :c-file t option to compile file by default to keep the intermediate generated C file.

Variable: *DEFAULT-H-FILE* ¶

  Package:COMPILER GCL specific: Set to non-NIL to add the :h-file t option to compile file by default to keep the intermediate generated header file.

Variable: *DEFAULT-DATA-FILE* ¶

  Package:COMPILER GCL specific: Set to non-NIL to add the :data-file t option to compile file by default to keep the intermediate generated data file.

Variable: *DEFAULT-SYSTEM-P* ¶

  Package:COMPILER GCL specific: Set to non-NIL to add the :system-p t option to compile file by default to write a reference to the system cmpinclude.h file in the generated C code as opposed to inserting its contents in the file directly.

Variable: *FASD-DATA* ¶

  Package:COMPILER GCL specific: Set to NIL to write the data file in human readable format.

Variable: *KEEP-GAZ* ¶

  Package:COMPILER GCL specific: Set to non-NIL to preserve anonymous “gazonk” .o files.

Variable: *DISASSEMBLE-OBJDUMP* ¶

  Package:COMPILER GCL specific: When set to non-NIL, ’disassemble will report assembly instructions output by objdump in addition to the C code output by GCL.

Function: FILE ¶

  Package:SI GCL specific: Return the source file from which the designated function was loaded.

Function: SIGNATURE ¶

  Package:SI GCL specific: Return the call signature of the designated function.

Function: INTERPRET ¶

  Package:COMPILER GCL specific: Just as (compile ’foo) will replace an interpreted function designated by ’foo with a compiled one, (compiler::interpret ’foo) will do the reverse. Both functions are idempotent operations.

Function: WATCH ¶

  Package:COMPILER GCL specific: (watch ’foo) will trace compiler logic pertaining to ’foo. (watch ’compiler::tail-recursion) will trace the compiler’s treatment of tail recursion optimization. Other useful options include ’compiler::type-inference, ’compiler::branch-elimination, and ’compiler::inline.

Function: UNWATCH ¶

  Package:COMPILER GCL specific: (unwatch ’foo) will stop tracing ’foo. (unwatch) will stop all compiler tracing.

Variable: *INTERRUPT-ENABLE* ¶

  Package:SI GCL specific: If the value of SI:*INTERRUPT-ENABLE* is non-NIL, GCL signals an error on the terminal interrupt (this is the default case). If it is NIL, GCL ignores the interrupt and assigns T to SI:*INTERRUPT-ENABLE*.

Function: CHDIR (pathname) ¶

  Package:SI

  GCL/UNIX specific: Changes the current working directory to the specified pathname.

Function: COPY-STREAM (in-stream out-stream) ¶

  Package:SI

  GCL specific: Copies IN-STREAM to OUT-STREAM until the end-of-file on IN- STREAM.

Function: INIT-SYSTEM () ¶

  Package:SI

  GCL specific: Initializes the library and the compiler of GCL. Since they have already been initialized in the standard image of GCL, calling SI:INIT- SYSTEM will cause an error.

Variable: *INDENT-FORMATTED-OUTPUT* ¶

  Package:SI GCL specific: The FORMAT directive ~% indents the next line if the value of this variable is non-NIL. If NIL, ~% simply does Newline.

Function: SET-HOLE-SIZE (fixnum) ¶

  Package:SI

  GCL specific: Sets the size of the memory hole (in pages).

Function: FRS-BDS (i) ¶

  Package:SI

  GCL specific: Returns the bind stack index of the i-th entity in the frame stack.

Function: IHS-FUN (i) ¶

  Package:SI

  GCL specific: Returns the function value of the i-th entity in the invocation history stack.

Function: *MAKE-CONSTANT (symbol value) ¶

  Package:SI

  GCL specific: Makes the SYMBOL a constant with the specified VALUE.

Function: FIXNUMP (object) ¶

  Package:SI

  GCL specific: Returns T if the OBJECT is a fixnum; NIL otherwise.

Function: BDS-VAL (i) ¶

  Package:SI

  GCL specific: Returns the value of the i-th entity in the bind stack.

Function: STRING-TO-OBJECT (string) ¶

  Package:SI

  GCL specific: (SI:STRING-TO-OBJECT STRING) is equivalent to (READ-FROM-STRING STRING), but much faster.

Variable: *SYSTEM-DIRECTORY* ¶

  Package:SI GCL specific: Holds the name of the system directory of GCL.

Function: FRS-IHS (i) ¶

  Package:SI

  GCL specific: Returns the invocation history stack index of the i-th entity in the frame stack.

Function: RESET-GBC-COUNT () ¶

  Package:SI

  GCL specific: Resets the counter of the garbage collector that records how many times the garbage collector has been called for each implementation type.

Function: RESET-STACK-LIMITS () ¶

  Package:SI

  GCL specific: Resets the stack limits to the normal state. When a stack has overflowed, GCL extends the limit for the stack in order to execute the error handler. After processing the error, GCL resets the stack limit by calling SI:RESET-STACK-LIMITS.

Variable: *GBC-MESSAGE* ¶

  Package:SI GCL specific: If the value of SI:*GBC-MESSAGE* is non-NIL, the garbage collector prints some information on the terminal. Usually SI:*GBC-MESSAGE* should be set NIL.

Variable: *NOTIFY-GBC* ¶

  Package:SI GCL specific: If the value is non-NIL, the garbage collector prints a very brief one line message about the area causing the collection, and the time spent in internal time units.

Variable: *AFTER-GBC-HOOK* ¶

  Package:SI Defaults to nil, but may be set to a function of one argument TYPE which is a lisp variable indicating the TYPE which caused the current collection.

Function: ALLOCATED (type) ¶

  Package:SI

  Returns 6 values:

  nfree

    number free

  npages

    number of pages

  maxpage

    number of pages to grow to

  nppage

    number per page

  gbccount

    number of gc’s due to running out of items of this size

  nused

    number of items used

  Note that all items of the same size are stored on similar pages. Thus for example on a 486 under linux the following basic types are all the same size and so will share the same allocated information: CONS BIGNUM RATIO COMPLEX STRUCTURE.

Function: *MAKE-SPECIAL (symbol) ¶

  Package:SI

  GCL specific: Makes the SYMBOL globally special.

Function: MAKE-STRING-OUTPUT-STREAM-FROM-STRING (string) ¶

  Package:SI

  GCL specific: Creates a string-output-stream corresponding to the STRING and returns it. The STRING should have a fill-pointer.

Variable: *IGNORE-EOF-ON-TERMINAL-IO* ¶

  Package:SI GCL specific: If the value of SI:*IGNORE-EOF-ON-TERMINAL-IO* is non-NIL, GCL ignores the eof-character (usually ^D) on the terminal and the terminal never becomes end-of-file. The default value of SI:*IGNORE-EOF-ON-TERMINAL-IO* is NIL.

Function: ADDRESS (object) ¶

  Package:SI

  GCL specific: Returns the address of the OBJECT as a fixnum. The address of an object depends on the version of GCL. E.g. (SI:ADDRESS NIL) returns 1879062044 on GCL/AOSVS dated March 14, 1986.

Variable: *LISP-MAXPAGES* ¶

  Package:SI GCL specific: Holds the maximum number of pages (1 page = 2048 bytes) for the GCL process. The result of changing the value of SI:*LISP-MAXPAGES* is unpredictable.

Function: ARGC () ¶

  Package:SI

  GCL specific: Returns the number of arguments on the command line that invoked the GCL process.

Function: NANI (fixnum) ¶

  Package:SI

  GCL specific: Returns the object in the address FIXNUM. This function is the inverse of SI:ADDRESS. Although SI:ADDRESS is a harmless operation, SI:NANI is quite dangerous and should be used with care.

Variable: *NOTIFY-GBC* ¶

  Package:SI GCL specific: If the value of this variable is non-NIL, then the garbage collector notifies that it begins to run whenever it is invoked. Otherwise, garbage collection begins silently.

Function: SAVE-SYSTEM (pathname) ¶

  Package:SI

  GCL specific: Saves the current GCL core imange into a program file specified by PATHNAME. This function differs from SAVE in that the contiguous and relocatable areas are made permanent in the saved image. Usually the standard image of GCL interpreter/compiler is saved by SI:SAVE-SYSTEM. This function causes an exit from lisp. Various changes are made to the memory of the running system, such as closing files and resetting io streams. It would not be possible to continue normally.

Function: VS (i) ¶

  Package:SI

  GCL specific: Returns the i-th entity in the value stack.

Function: DISPLACED-ARRAY-P (array) ¶

  Package:SI

  GCL specific: Returns T if the ARRAY is a displaced array; NIL otherwise.

Function: ARGV (fixnum) ¶

  Package:SI

  GCL specific: Returns the FIXNUM-th argument on the command line that invoked the GCL process.

Function: GETENV (string) ¶

  Package:SI

  GCL/UNIX specific: Returns the environment with the name STRING as a string; if the environment specified by STRING is not found, returns NIL.

Function: FASLINK (file string) ¶

  Package:SI

  GCL/BSD specific: Loads the FASL file FILE while linking the object files and libraries specified by STRING. For example, (faslink "foo.o" "bar.o boo.o -lpixrect") loads foo.o while linking two object files (bar.o and boo.o) and the library pixrect. Usually, foo.o consists of the C language interface for the functions defined in the object files or the libraries.

  A more portable way of making references to C code, is to build it in at the time of the original make. If foo.c references things in -lpixrect, and foo.o is its compilation in the gcl/unixport directory

  (cd gcl/unixport ; make "EXTRAS= foo.o -lpixrect ")

  should add them. If EXTRAS was already joe.o in the unixport/makefile you should of course add joe.o to the above "EXTRAS= joe.o foo.o.."

  Faslink does not work on most UNIX systems which are derived from SYS V or AIX.

Function: TOP-LEVEL () ¶

  Package:SI

  GCL specific: Starts the standard top-level listener of GCL. When the GCL process is invoked, it calls SI:TOP-LEVEL by (FUNCALL ’SI:TOP-LEVEL). To change the top-level of GCL, redefine SI:TOP-LEVEL and save the core imange in a file. When the saved imange is invoked, it will start the redefined top-level.

Function: FRS-VS (i) ¶

  Package:SI

  GCL specific: Returns the value stack index of the i-th entity in the frame stack.

Function: CATCH-FATAL (i) ¶

  Package:SI

  Sets the value of the C variable catch_fatal to I which should be an integer. If catch_fatal is 1, then most unrecoverable fatal errors will be caught. Upon catching such an error catch_fatal becomes -1, to avoid recursive errors. The top level loop automatically sets catch_fatal to 1, if the value is less than zero. Catching can be turned off by making catch_fatal = 0.

Variable: *MULTIPLY-STACKS* ¶

  Package:SI

  If this variable is set to a positive fixnum, then the next time through the TOP-LEVEL loop, the loop will be exited. The size of the stacks will be multiplied by the value of *multiply-stacks*, and the TOP-LEVEL will be called again. Thus to double the size of the stacks:

  >(setq si::*multiply-stacks* 2) [exits top level and reinvokes it, with the new stacks in place] >

  We must exit TOP-LEVEL, because it and any other lisp functions maintain many pointers into the stacks, which would be incorrect when the stacks have been moved. Interrupting the process of growing the stacks, can leave you in an inconsistent state.

Function: GBC-TIME (&optional x) ¶

  Package:SI

  Sets the internal C variable gc_time to X if X is supplied and then returns gc_time. If gc_time is greater or equal to 0, then gc_time is incremented by the garbage collector, according to the number of internal time units spent there. The initial value of gc_time is -1.

Function: FWRITE (string start count stream) ¶

  Package:SI

  Write from STRING starting at char START (or 0 if it is nil) COUNT characters (or to end if COUNT is nil) to STREAM. STREAM must be a stream such as returned by FP-OUTPUT-STREAM. Returns nil if it fails.

Function: FREAD (string start count stream) ¶

  Package:SI

  Read characters into STRING starting at char START (or 0 if it is nil) COUNT characters (or from start to length of STRING if COUNT is nil). Characters are read from STREAM. STREAM must be a stream such as returned by FP-INPUT-STREAM. Returns nil if it fails. Return number of characters read if it succeeds.

Function: SGC-ON (&optional ON) ¶

  Package:SI

  If ON is not nil then SGC (stratified garbage collection) is turned on. If ON is supplied and is nil, then SGC is turned off. If ON is not supplied, then it returns T if SGC is on, and NIL if SGC is off.

  The purpose of SGC is to prevent paging activity during garbage collection. It is efficient if the actual number of pages being written to form a small percentage of the total image size. The image should be built as compactly as possible. This can be accomplished by using a settings such as (si::allocate-growth ’cons 1 10 50 20) to limit the growth in the cons maxpage to 10 pages per time. Then just before calling si::save-system to save your image you can do something like:

  (si::set-hole-size 500)(gbc nil) (si::sgc-on t) (si::save-system ..)

  This makes the saved image come up with SGC on. We have set a reasonably large hole size. This is so that allocation of pages either because they fill up, or through specific calls to si::allocate, will not need to move all the relocatable data. Moving relocatable data requires turning SGC off, performing a full gc, and then turning it back on. New relocatable data is collected by SGC, but moving the old requires going through all pages of memory to change pointers into it.

  Using si::*notify-gbc* gives information about the number of pages used by SGC.

  Note that SGC is only available on operating systems which provide the mprotect system call, to write protect pages. Otherwise we cannot tell which pages have been written too.

Function: ALLOCATE-SGC (type min-pages max-pages percent-free) ¶

  Package:SI

  If MIN-PAGES is 0, then this type will not be swept by SGC. Otherwise this is the minimum number of pages to make available to SGC. MAX-PAGES is the upper limit of such pages. Only pages with PERCENT-FREE objects on them, will be assigned to SGC. A list of the previous values for min, max and percent are returned.

Function: ALLOCATE-GROWTH (type min max percent percent-free) ¶

  Package:SI

  The next time after a garbage collection for TYPE, if PERCENT-FREE of the objects of this TYPE are not actually free, and if the maximum number of pages for this type has already been allocated, then the maximum number will be increased by PERCENT of the old maximum, subject to the condition that this increment be at least MIN pages and at most MAX pages. A list of the previous values for min, max, percent, and percent-free for the type TYPE is returned. A value of 0 means use the system default, and if an argument is out of range then the current values are returned with no change made.

  Examples: (si::allocate-growth ’cons 1 10 50 10) would insist that after a garbage collection for cons, there be at least 10% cons’s free. If not the number of cons pages would be grown by 50% or 10 pages which ever was smaller. This might be reasonable if you were trying to build an image which was ‘full’, ie had few free objects of this type.

  (si::allocate-growth ’fixnum 0 10000 30 40) would grow space till there were normally 40% free fixnums, usually growing by 30% per time.

  (si::allocate-growth ’cons 0 0 0 40) would require 40% free conses after garbage collection for conses, and would use system defaults for the the rate to grow towards this goal.

  (si::allocate-growth ’cons -1 0 0 0) would return the current values, but not make any changes.

Function: OPEN-FASD (stream direction eof-value table) ¶

  Package:SI

  Given file STREAM open for input or output in DIRECTION, set it up to start writing or reading in fasd format. When reading from this stream the EOF-VALUE will be returned when the end a fasd end of dump marker is encountered. TABLE should be an eq hashtable on output, a vector on input, or nil. In this last case a default one will be constructed.

  We shall refer to the result as a ‘fasd stream’. It is suitable as the arg to CLOSE-FASD, READ-FASD-TOP, and as the second second arg to WRITE-FASD. As a lisp object it is actually a vector, whose body coincides with:

  struct fasd { object stream; /* lisp object of type stream */ object table; /* hash table used in dumping or vector on input*/ object eof; /* lisp object to be returned on coming to eof mark */ object direction; /* holds Cnil or Kinput or Koutput */ object package; /* the package symbols are in by default */ object index; /* integer. The current_dump index on write */ object filepos; /* nil or the position of the start */ object table_length; /* On read it is set to the size dump array needed or 0 */ object macro ; }

  We did not use a defstruct for this, because we want the compiler to use this and it makes bootstrapping more difficult. It is in "cmpnew/fasdmacros.lsp"

Function: WRITE-FASD-TOP (X FASD-STREAM) ¶

  Package:SI

  Write X to FASD-STREAM.

Function: READ-FASD-TOP (FASD-STREAM) ¶

  Package:SI

  Read the next object from FASD-STREAM. Return the eof-value of FASD-STREAM if we encounter an eof marker put out by CLOSE-FASD. Encountering end of actual file stream causes an error.

Function: CLOSE-FASD (FASD-STREAM) ¶

  Package:SI

  On output write an eof marker to the associated file stream, and then make FASD-STREAM invalid for further output. It also attempts to write information to the stream on the size of the index table needed to read from the stream from the last open. This is useful in growing the array. It does not alter the file stream, other than for writing this information to it. The file stream may be reopened for further use. It is an error to OPEN-FASD the same file or file stream again with out first calling CLOSE-FASD.

Function: FIND-SHARING-TOP (x table) ¶

  Package:SI

  X is any lisp object and TABLE is an eq hash table. This walks through X making entries to indicate the frequency of symbols,lists, and arrays. Initially items get -1 when they are first met, and this is decremented by 1 each time the object occurs. Call this function on all the objects in a fasd file, which you wish to share structure.

Variable: *LOAD-PATHNAME* ¶

  Package:SI Load binds this to the pathname of the file being loaded.

Macro: DEFINE-INLINE-FUNCTION (fname vars &body body) ¶

  Package:SI

  This is equivalent to defun except that VARS may not contain &optional, &rest, &key or &aux. Also a compiler property is added, which essentially saves the body and turns this into a let of the VARS and then execution of the body. This last is done using si::DEFINE-COMPILER-MACRO Example: (si::define-inline-function myplus (a b c) (+ a b c))

Macro: DEFINE-COMPILER-MACRO (fname vars &body body) ¶

  Package:SI

  FNAME may be the name of a function, but at compile time the macro expansion given by this is used.

  (si::define-compiler-macro mycar (a) ‘(car ,a))

Function: DBL () ¶

  Package:SI

  Invoke a top level loop, in which debug commands may be entered. These commands may also be entered at breaks, or in the error handler. See SOURCE-LEVEL-DEBUG

Function: NLOAD (file) ¶

  Package:SI

  Load a file with the readtable bound to a special readtable, which permits tracking of source line information as the file is loaded. see SOURCE-LEVEL-DEBUG

Function: BREAK-FUNCTION (function &optional line absolute) ¶

  Package:SI

  Set a breakpoint for a FUNCTION at LINE if the function has source information loaded. If ABSOLUTE is not nil, then the line is understood to be relative to the beginning of the buffer. See also dbl-break-function, the emacs command.

Function: XDR-OPEN (stream) ¶

  Package:SI

  Returns an object suitable for passing to XDR-READ if the stream is an input stream, and XDR-WRITE if it was an output stream. Note the stream must be a unix stream, on which si::fp-input-stream or si::fp-output-stream would act as the identity.

Function: FP-INPUT-STREAM (stream) ¶

  Package:SI

  Return a unix stream for input associated to STREAM if possible, otherwise return nil.

Function: FP-OUTPUT-STREAM (stream) ¶

  Package:SI

  Return a unix stream for output associated to STREAM if possible, otherwise return nil.

Function: XDR-READ (stream element) ¶

  Package:SI

  Read one item from STREAM of type the type of ELEMENT. The representation of the elements is machine independent. The xdr routines are what is used by the basic unix rpc calls.

Function: XDR-WRITE (stream element) ¶

  Package:SI

  Write to STREAM the given ELEMENT.

Variable: *TOP-LEVEL-HOOK* ¶

  Package:SI If this variable is has a function as its value at start up time, then it is run immediately after the init.lsp file is loaded. This is useful for starting up an alternate top level loop.

Function: RUN-PROCESS (string arglist) ¶

  Package:SI

  Execute the command STRING in a subshell passing the strings in the list ARGLIST as arguments to the command. Return a two way stream associated to this. Use si::fp-output-stream to get an associated output stream or si::fp-input-stream.

  Bugs: It does not properly deallocate everything, so that it will fail if you call it too many times.

Variable: *CASE-FOLD-SEARCH* ¶

  Package: SI Non nil means that a string-match should ignore case

Function: STRING-MATCH (pattern string &optional start end) ¶

  Package: SI Match regexp PATTERN in STRING starting in string starting at START and ending at END. Return -1 if match not found, otherwise return the start index of the first matches. The variable *MATCH-DATA* will be set to a fixnum array of sufficient size to hold the matches, to be obtained with match-beginning and match-end. If it already contains such an array, then the contents of it will be over written.

  The form of a regexp pattern is discussed in See Regular Expressions.

Function: MATCH-BEGINNING (index) ¶

  Returns the beginning of the I’th match from the previous STRING-MATCH, where the 0th is for the whole regexp and the subsequent ones match parenthetical expressions. -1 is returned if there is no match, or if the *match-data* vector is not a fixnum array.

Function: MATCH-END (index) ¶

  Returns the end of the I’th match from the previous STRING-MATCH

Function: SOCKET (port &key host server async myaddr myport daemon) ¶

  Establishes a socket connection to the specified PORT under a variety of circumstances.

  If HOST is specified, then it is a string designating the IP address of the server to which we are the client. ASYNC specifies that the connection should be made asynchronously, and the call return immediately. MYADDR and MYPORT can specify the IP address and port respectively of a client connection, for example when the running machine has several network interfaces.

  If SERVER is specified, then it is a function which will handle incoming connections to this PORT. DAEMON specifies that the running process should be forked to handle incoming connections in the background. If DAEMON is set to the keyword PERSISTENT, then the backgrounded process will survive when the parent process exits, and the SOCKET call returns NIL. Any other non-NIL setting of DAEMON causes the socket call to return the process id of the backgrounded process. DAEMON currently only works on BSD and Linux based systems.

  If DAEMON is not set or nil, or if the socket is not a SERVER socket, then the SOCKET call returns a two way stream. In this case, the running process is responsible for all I/O operations on the stream. Specifically, if a SERVER socket is created as a non-DAEMON, then the running process must LISTEN for connections, ACCEPT them when present, and call the SERVER function on the stream returned by ACCEPT.

Function: ACCEPT (stream) ¶

  Creates a new two-way stream to handle an individual incoming connection to STREAM, which must have been created with the SOCKET function with the SERVER keyword set. ACCEPT should only be invoked when LISTEN on STREAM returns T. If the STREAM was created with the DAEMON keyword set in the call to SOCKET, ACCEPT is unnecessary and will be called automatically as needed.