Common Lisp Package: SCLF

README:

FUNCTION

Public

ADD-DAYS (DAYS EPOCH)

Add DAYS to EPOCH, which is an universal time. DAYS can be negative.

ADD-MONTHS (MONTHS EPOCH &OPTIONAL TIME-ZONE)

Add MONTHS to EPOCH, which is a universal time. MONTHS can be negative.

ALIST->PLIST (ALIST)

Convert an association list into a property list. The alist elements are assumed to be lists of just two elements: the key and the value. If the element list is longer this function doesn't work.

BEGINNING-OF-FIRST-WEEK (YEAR &OPTIONAL TIME-ZONE)

Return the epoch of the first week of YEAR. As the first week of the year needs to have Thursday in this YEAR, the returned time can actually fall in the previous year.

BEGINNING-OF-WEEK (WEEK YEAR &OPTIONAL TIME-ZONE)

Return the epoch of the beginning of WEEK of YEAR.

BYTE-VECTOR->STRING (VECTOR &KEY START END)

Convert a vector of (unsigned-byte 8) elements into a string of characters.

BYTES-SIMPLE-STRING (N &OPTIONAL IMPLY-BYTES)

Return a string describing N using a unit of measure multiple of a byte that is most apporpriate for the magnitude of N. A kilobyte is 1024 not 1000 bytes, everything follows.

CEILING-TO (X AIM)

Round X up to the nearest multiple of AIM.

CIRCULAR-LIST (&REST ELEMENTS)

Return a circular list of ELEMENTS.

CURRENT-DIRECTORY

Return the pathname of the current directory.

D+ (PATH &REST REST)

Concatenate directory pathname parts and return a pathname.

DAY (EPOCH &OPTIONAL TIME-ZONE)

Return the day of EPOCH.

DAY-OF-THE-YEAR (TIME &OPTIONAL TIME-ZONE)

Return the day within the year of TIME starting from 1 up to 365 (or 366).

DELETE-DIRECTORY (PATHNAME)

Remove directory PATHNAME. Return PATHNAME.

DELETE-DIRECTORY-TREE (PATHNAME)

Recursively delete PATHNAME and all the directory structure below it. WARNING: depending on the way the DIRECTORY function is implemented on your Lisp system this function may follow Unix symbolic links and thus delete files outside the PATHNAME hierarchy. Check this before using this function in your programs.

DIRECTORY-P (PATHNAME)

Return true if PATHNAME names a directory on the filesystem.

DLE-NEXT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

DLE-PREVIOUS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

DLE-REMOVE (DLE-OBJECT)

Remove the DLE-OBJECT from its current position in the list of elements agjusting the pointer of dle-objects before and after this one (if any).

DLE-VALUE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

END-OF-LAST-WEEK (YEAR &OPTIONAL TIME-ZONE)

Return the epoch of the last week of YEAR. As the last week of the year needs to have Thursday in this YEAR, the returned time can fall in the next year.

END-OF-WEEK (WEEK YEAR &OPTIONAL TIME-ZONE)

Return the epoch of the beginning of WEEK of YEAR.

ENSURE-DIRECTORY (PATHNAME &KEY VERBOSE (MODE 511))

Just like ENSURE-DIRECTORIES-EXIST but, in some situations, it's faster.

ENSURE-HOME-TRANSLATIONS

Ensure that the logical pathname translations for the host "home" are defined.

FILE-CREATION-TIME (FILE)

Return the creation time of FILE as Lisp Universal Time, which is not the same as the Unix time.

FILE-MODIFICATION-TIME (FILE)

Return the modification time of FILE as Lisp Universal Time, which is not the same as the Unix time.

FIND-ANY (BAG SEQUENCE &REST FIND-ARGS)

Find any element of bag in sequence. Accept any argument accepted by the FIND function.

FIND-FILES (ROOT-PATHNAME MATCHER-FUNCTION &KEY TRUENAMEP)

In the directory tree rooted at ROOT-PATHNAME, find files that when the pathname is applied to MATCHER-FUNCTION will return true. Return the list of files found. Unless TRUENAMEP is true this function doesn't try to lookup the truename of files. Finding the truename may be a superfluous and noxious activity expecially when you expect broken symbolic links in your filesystem. (This may not apply to your particular lisp system.)

FIND-UID (NAME)

Find the user id of NAME. Return an integer.

FLOOR-TO (X AIM)

Round X down to the nearest multiple of AIM.

FORGET-DOCUMENTATION (PACKAGES)

Remove documentation from all known symbols in PACKAGES. If PACKAGES is NIL remove documentations from all packages. This may not make sense if your Lisp image has been built so that existing objects don't get garbage collected. It may work for your own code, though. Locked packages are left alone. If you need to do those too, unlock them first.

FORMAT-AMOUNT

Return a string formatted as fixed decimal point number of DECIMALS adding commas every COMMA-STANCE places before the decimal point.

FULL-WEEKS-IN-SPAN (START END &OPTIONAL TIME-ZONE)

Return the number of full weeks in time span START to END. A full week starts on Monday and ends on Sunday.

GET-LOGNAME (&OPTIONAL UID)

Return the login id of the user. This is a string and it is not the Unix uid, which is a number.

GET-USER-NAME (&OPTIONAL UID)

Return the user name, taken from the GCOS field of the /etc/passwd file.

GETENV (VAR)

Return the string associate to VAR in the system environment.

GETUID

Return the Unix user id. This is an integer.

GLOB->REGEX (STRING)

Convert a shell glob expression into a regular expression string.

HOUR (EPOCH &OPTIONAL TIME-ZONE)

Return the hour of EPOCH.

INSERT-IN-ORDER (ITEM SEQ &KEY (TEST #'<) KEY)

Destructively insert ITEM in LIST in order by TEST. Return the new list. This is a simple wrapper around MERGE.

ISO-TIME-STRING (TIME &KEY TIME-ZONE WITH-TIMEZONE-P)

Return an ISO 8601 string representing TIME. The time zone is included if WITH-TIMEZONE-P is true.

LAST-DAY-OF-MONTH (MONTH YEAR)

Return the last day of the month as integer.

LAST-MEMBER (ITEM LIST &KEY KEY (TEST #'EQ))

Return the last sublist in LIST that is prefixed by ITEM.

LEAP-YEAR-P (YEAR)

Return true if YEAR is a leap year.

LIST->STRING (LIST)

Coerce a list of characters into a string.

LIST-DIRECTORY (PATHNAME &KEY TRUENAMEP)

List content of directory PATHNAME. If TRUENAMEP is true don't try to follow symbolic links.

LOAD-COMPILED (PATHNAME &OPTIONAL COMPILED-PATHNAME)

Make sure to compile PATHNAME before loading it. Don't compile if the compiled version is more recent than its source.

LOCATE-SYSTEM-PROGRAM (NAME)

Given the NAME of a system program try to find it through the search of the environment variable PATH. Return the full pathname.

MAKE-DIRECTORY (PATHNAME &OPTIONAL (MODE 511))

Create a new directory in the filesystem. Permissions MODE will be assigned to it. Return PATHNAME.

MAKE-LOCK-FILES (PATHNAMES &KEY (SLEEP-TIME 7) RETRIES (SUSPEND 13) EXPIRATION)

Create semaphore files. If it can't create all the specified files in the specified order, it waits SLEEP-TIME seconds and retries the last file that didn't succeed. You can specify the number of RETRIES to do until failure is returned. If the number of retries is NIL this function will retry forever. If it tries RETRIES times without success, this function signal an error and removes all the lock files it created until then. All files created by lock file will be read-only. If you specify a EXPIRATION then an existing lock file will be removed by force after EXPIRATION seconds have passed since the lock file was last modified/created (most likely by some other program that unexpectedly died without cleaning up its lock files). After a lock file has been removed by force, a suspension of SUSPEND seconds is taken into account, in order to prevent the inadvertent immediate removal of any newly created lock file by another program.

MAKE-TEMP-DIRECTORY (&OPTIONAL (DEFAULT-PATHNAME *TMP-FILE-DEFAULTS*) (MODE 511))

Create a new directory and return its pathname. If DEFAULT-PATHNAME is specified and not NIL it's used as defaults to produce the pathname of the directory. Return the pathname of the temporary directory.

MAP-DIRECTORY-TREE (PATHNAME FUNCTION)

Apply FUNCTION to every file in a directory tree starting from PATHNAME. Return the list of results.

MINUTE (EPOCH &OPTIONAL TIME-ZONE)

Return the minute of EPOCH.

MONTH (EPOCH &OPTIONAL TIME-ZONE)

Return the month of EPOCH.

MONTH->STRING (MONTH)

Return the month string corresponding to MONTH number.

MOVE-FILE (OLD NEW)

Just like RENAME-FILE, but doesn't carry on to NEW file the type of OLD file, if NEW doesn't specify one. It does what most people would expect from a rename function, which RENAME-FILE doesn't do. So (MOVE-FILE "foo.bar" "foo") does rename foo.bar to foo, losing the "bar" type; RENAME-FILE wouldn't allow you that.

NEXT-MONDAY (EPOCH &OPTIONAL TIME-ZONE)

Return the universal time of the next Monday starting from EPOCH.

NEXT-WEEK-DAY (EPOCH WEEK-DAY &OPTIONAL TIME-ZONE)

Return the universal time of the next WEEK-DAY starting from epoch.

NOT-EMPTY (SEQUENCE)

Return SEQUENCE if it's not empty, otherwise NIL. NIL is indeed empty.

OPEN-TEMP-FILE (&OPTIONAL DEFAULT-PATHNAME &REST OPEN-ARGS)

Open a new temporary file and return a stream to it. This function makes sure the pathname of the temporary file is unique. OPEN-ARGS are arguments passed verbatim to OPEN. If OPEN-ARGS specify the :DIRECTION it should be either :OUTPUT (default) or :IO; any other value causes an error. If DEFAULT-PATHNAME is specified and not NIL it's used as defaults to produce the pathname of the temporary file, otherwise *TMP-FILE-DEFAULTS* is used.

OUTDATED-P (FILE DEPENDENCIES)

Check if FILE has been modified before any of its DEPENDENCIES.

PARSE-AMOUNT (STRING &KEY (START 0) END)

Parse STRING as if it was formatted with FORMAT-AMOUNT and return the parsed number. Return NIL if STRING is malformed. Leading or trailing spaces must be removed from the string in advance.

PARSE-ISO-TIME-STRING (TIME-STRING)

Parse an ISO 8601 formated string and return the universal time.

PATHNAME-AS-DIRECTORY (PATHNAME)

Converts PATHNAME to directory form and return it.

PATHNAME-AS-FILE (PATHNAME)

Converts PATHNAME to file form and return it.

PLIST->ALIST (PLIST &OPTIONAL PAIRS-P)

Convert a property list into an association list. The alist elements wiil be lists of just two elements: the key and the value. If PAIRS-P is true the alist elements will be pairs.

POSITION-ANY (BAG SEQUENCE &REST POSITION-ARGS)

Find any element of bag in sequence and return its position. Accept any argument accepted by the POSITION function.

PROCESS-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PROCESS-STATE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PROCESS-WHOSTATE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

READ-FILE (PATHNAME &KEY (ELEMENT-TYPE 'CHARACTER) (IF-DOES-NOT-EXIST ERROR) DEFAULT)

Read the whole content of file and return it as a sequence which can be a string, a vector of bytes, or whatever you specify as ELEMENT-TYPE.

READ-FROM-FILE (PATHNAME &KEY (ON-ERROR ERROR) DEFAULT)

Similar to READ-FROM-STRING but for files. Read the first Lisp object in file and return it. If file does not exist or does not contain a readable Lisp object, ON-ERROR tells what to do. If ON-ERROR is :ERROR, an error is signalled. If ON-ERROR is :VALUE, DEFAULT is returned.

READ-LINES (STREAM &OPTIONAL N)

Read N lines from stream and return them as a list of strings. If N is NIL, read the whole stream til the end. If the stream ends before N lines a read, this function will return those without signalling an error.

READ-WHOLE-STREAM (STREAM)

Read stream until the end and return it as a string.

RESET-LAZY-SLOTS (OBJECT)

Unbind all the lazy slots in OBJECT so that they will be re-evaluated next time their value is requested again.

ROUND-TO (X AIM)

Round X to the nearest multiple of AIM.

RUN-ASYNC-SHELL-COMMAND (FMT &REST ARGS)

Run a Bourne Shell command asynchronously. Return a process object if provided by your Lisp implementation.

RUN-PIPE (DIRECTION PROGRAM ARGUMENTS &KEY ERROR)

Run PROGRAM with a list of ARGUMENTS and according to DIRECTION return the input and output streams and process object of that process.

RUN-PROGRAM (PROGRAM ARGUMENTS &KEY (WAIT T) PTY INPUT OUTPUT ERROR)

Run PROGRAM with ARGUMENTS (a list) and return a process object.

RUN-SHELL-COMMAND (FMT &REST ARGS)

Run a Bourne Shell command. Return the exit status of the command.

S+ (&REST STRINGS)

Return a string which is made of the concatenation of STRINGS.

SETUID (ID)

Set the Unix real user id.

SOUNDEX (WORD &OPTIONAL (KEY-LENGTH 4))

Knuth's Soundex algorithm. Returns a string representing the sound of a certain word (English). Different words will thus yield the same output string. To compare two string by the sound, simply do: (string= (soundex str1) (soundex str2)) Examples: (soundex "Knuth") => "K530" (soundex "Kant") => "K530" (soundex "Lloyd") => "L300" (soundex "Ladd") => "L300"

SPLIT-AT (BAG SEQUENCE &KEY (START 0) KEY)

Split SEQUENCE at occurence of any element from BAG. Contiguous occurences of elements from BAG are considered atomic; so no empty sequence is returned.

SPLIT-STRING-AT-CHAR (STRING SEPARATOR &KEY ESCAPE SKIP-EMPTY)

Split STRING at SEPARATORs and return a list of the substrings. If SKIP-EMPTY is true then filter out the empty substrings. If ESCAPE is not nil then split at SEPARATOR only if it's not preceded by ESCAPE.

STAT-ATIME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STAT-BLKSIZE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STAT-BLOCKS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STAT-CTIME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STAT-DEVICE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STAT-GID (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STAT-INODE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STAT-MODE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STAT-MODIFICATION-TIME (STAT)

Return the modification time of the STAT structure as Lisp Universal Time, which is not the same as the Unix time.

STAT-MTIME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STAT-SIZE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STAT-UID (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

STRING->BYTE-VECTOR (STRING &KEY START END)

Convert a string of characters into a vector of (unsigned-byte 8) elements.

STRING-CONCAT (LIST &OPTIONAL (SEPARATOR ))

Concatenate the strings in LIST interposing SEPARATOR (default nothing) between them.

STRING-ENDS-WITH (POSTFIX STRING &OPTIONAL (COMPARE #'STRING=))

Return true if STRING's last characters are the same as POSTFIX.

STRING-ESCAPE (STRING CHARACTER &KEY (ESCAPE-CHARACTER \) (ESCAPE-ESCAPE T))

Prepend all occurences of CHARACTER in STRING with a ESCAPE-CHARACTER.

STRING-SUBSTITUTE (FROM TO SEQUENCE &KEY (START 0) END (TEST #'EQL))

Replace in SEQUENCE occurrences of FROM with TO. FROM and TO don't need to be the same length.

STRING-TRUNCATE (STRING MAX-LENGTH)

If STRING is longer than MAX-LENGTH, return a shorter version. Otherwise return the same string unchanged.

SUPER-USER-P (&OPTIONAL ID)

Return true if the user ID is zero. ID defaults to the current user id.

SYSPROC-SET-SIGNAL-CALLBACK (SIGNAL HANDLER)

Arrange HANDLER function to be called when receiving the system signal SIGNAL.

TEMP-FILE-NAME (&OPTIONAL (DEFAULT *TMP-FILE-DEFAULTS*))

Create a random pathname based on DEFAULT. No effort is made to make sure that the returned pathname doesn't identify an already existing file. If missing DEFAULT defaults to *TMP-FILE-DEFAULTS*.

TIME-STRING (TIME &OPTIONAL TIME-ZONE)

Return a string representing TIME in the form: Tue Jan 25 12:55:40 2005

TRAVERSE-DIRECTORY-TREE (ROOT-PATHNAME PROC &KEY TRUENAMEP TEST DEPTH-FIRST)

Call PROC on all pathnames under ROOT-PATHNAME, both files and directories. Unless TRUENAMEP is true, this function doesn't try to lookup the truename of files, as finding the truename may be a superfluous and noxious activity expecially when you expect broken symbolic links in your filesystem.

WEEK (TIME &OPTIONAL TIME-ZONE)

Return the number of the week and the year TIME referes to. Week is an integer from 1 to 52. Due to the way the first week of the year is calculated a day in one year could actually be in the last week of the previous or next year.

WEEK-DAY (EPOCH &OPTIONAL TIME-ZONE)

Return the day of the week of EPOCH.

WEEK-DAY->STRING (DAY &OPTIONAL SUNDAY-FIRST)

Return the weekday string corresponding to DAY number.

WRITE-FILE (PATHNAME CONTENTS &KEY (IF-EXISTS ERROR))

Read the whole content of file and return it as a sequence which can be a string, a vector of bytes, or whatever you specify as ELEMENT-TYPE.

WRITE-TO-FILE (OBJECT PATHNAME &KEY (IF-EXISTS ERROR) PRETTY)

Similar to WRITE-TO-STRING but for files. Write OBJECT to a file with pathname PATHNAME.

YEAR (EPOCH &OPTIONAL TIME-ZONE)

Return the year of EPOCH.

Undocumented

ALL-PROCESSES

BEGINNING-OF-MONTH (MONTH YEAR &OPTIONAL TIME-ZONE)

CONDITION-NOTIFY (CV)

CONDITION-WAIT (CV LOCK &OPTIONAL TIMEOUT)

CONS-DLE (VALUE PREVIOUS NEXT)

COPY-FILE (FILE COPY-FILE &KEY (IF-EXISTS ERROR))

COPY-STREAM (IN OUT)

CURRENT-PROCESS

DESTROY-PROCESS (PROCESS)

DISABLE-PROCESS (PROCESS)

DLE-MAP (FUNCTION DLE-OBJECT)

SETFDLE-NEXT (NEW-VALUE INSTANCE)

SETFDLE-PREVIOUS (NEW-VALUE INSTANCE)

SETFDLE-VALUE (NEW-VALUE INSTANCE)

DOUBLE-LINKED-ELEMENT-P (OBJECT)

EMPTY-DIRECTORY-P (PATHNAME)

ENABLE-PROCESS (PROCESS)

END-OF-MONTH (MONTH YEAR &OPTIONAL TIME-ZONE)

EXIT-CODE (PROCESS)

FILE-EXECUTABLE-P (PATHNAME)

FILE-READABLE-P (PATHNAME)

FILE-SIZE (PATHNAME)

FORCE (PROMISE)

FORCED-P (PROMISE)

GET-UNIX-TIME

GET-USER-HOME (&OPTIONAL UID)

SETFGETENV (VALUE NAME)

GETPID

KEYWORDIFY (STRING)

MAKE-CONDITION-VARIABLE

MAKE-DOUBLE-LINKED-ELEMENT (&KEY ((PREVIOUS DUM1071) NIL) ((VALUE DUM1072) NIL) ((NEXT DUM1073) NIL))

MAKE-LOCK (&OPTIONAL NAME)

MAKE-PROCESS (FUNCTION &KEY NAME)

MAKE-QUEUE (&KEY ((FIRST DUM2545) NIL) ((LAST DUM2546) NIL))

MAKE-RECURSIVE-LOCK (&OPTIONAL NAME)

MONTH-STRING->NUMBER (MONTH)

NATIVE-FILE-NAMESTRING (PATHNAME)

NATIVE-NAMESTRING (PATHNAME)

NATIVE-PATHNAME (THING)

PARSE-NATIVE-NAMESTRING (STRING &OPTIONAL HOST (DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*) &KEY (START 0) END JUNK-ALLOWED)

PROCESS-ALIVE-P (PROCESS)

PROCESS-EXECUTE (PROCESS FUNCTION)

PROCESS-INTERRUPT (PROCESS FUNCTION)

PROCESS-JOIN (PROCESS)

SETFPROCESS-NAME (NEW-VALUE INSTANCE)

PROCESS-PROPERTY-LIST (PROCESS)

SETFPROCESS-PROPERTY-LIST (VALUE PROCESS)

SETFPROCESS-STATE (NEW-VALUE INSTANCE)

PROCESS-WAIT (REASON PREDICATE)

PROCESS-WAIT-WITH-TIMEOUT (REASON TIMEOUT PREDICATE)

SETFPROCESS-WHOSTATE (NEW-VALUE INSTANCE)

PROCESS-YIELD

PROCESSP (OBJECT)

REMOVE-EMPTY-DIRECTORIES (ROOT)

RESTART-PROCESS (P)

SEQ-WHITESPACE-P (SEQUENCE)

SETFSTAT-ATIME (NEW-VALUE INSTANCE)

SETFSTAT-BLKSIZE (NEW-VALUE INSTANCE)

SETFSTAT-BLOCKS (NEW-VALUE INSTANCE)

SETFSTAT-CTIME (NEW-VALUE INSTANCE)

SETFSTAT-DEVICE (NEW-VALUE INSTANCE)

SETFSTAT-GID (NEW-VALUE INSTANCE)

SETFSTAT-INODE (NEW-VALUE INSTANCE)

SETFSTAT-MODE (NEW-VALUE INSTANCE)

SETFSTAT-MTIME (NEW-VALUE INSTANCE)

SETFSTAT-SIZE (NEW-VALUE INSTANCE)

SETFSTAT-UID (NEW-VALUE INSTANCE)

STRING-LEFT-TRIM-WHITESPACE (STRING)

STRING-RIGHT-TRIM-WHITESPACE (STRING)

STRING-SOUNDEX= (STRING1 STRING2)

STRING-STARTS-WITH (PREFIX STRING &OPTIONAL (COMPARE #'STRING=))

STRING-TRIM-WHITESPACE (STRING)

SYSPROC-ALIVE-P (PROCESS)

SYSPROC-EXIT-CODE (PROCESS)

SYSPROC-INPUT (PROCESS)

SYSPROC-KILL (PROCESS SIGNAL)

SYSPROC-OUTPUT (PROCESS)

SYSPROC-P (THING)

SYSPROC-PID (PROCESS)

SYSPROC-WAIT (PROCESS)

UNIVERSAL->UNIX-TIME (TIME)

UNIX->UNIVERSAL-TIME (TIME)

UNIX-STAT (PATHNAME)

WHITESPACE-P (CHAR)

Private

DROP-LAST-CACHE-ELEMENT (CACHE)

Drop the last element in the list of the cache object.

LRUC-SLOT-KEY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LRUC-SLOT-NEXT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LRUC-SLOT-PREVIOUS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LRUC-SLOT-VALUE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MOVE-IN-FRONT-OF-CACHE-LIST (SLOT CACHE)

Relocate slot to the front of the elements list in cache. This will stretch its lifespan in the cache.

PROCESS-FUNCTION (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PROCESS-THREAD (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PROMISE-PROCEDURE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PROMISE-VALUE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

QUEUE-FIRST (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

QUEUE-LAST (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

SETEUID (ID)

Set the Unix effective user id.

STAT-CREATION-TIME (STAT)

Return the creation time of the STAT structure as Lisp Universal Time, which is not the same as the Unix time.

Undocumented

%MAKE-PROCESS (&KEY ((NAME DUM0) NIL) ((STATE DUM1) NIL) ((WHOSTATE DUM2) NIL) ((FUNCTION DUM3) NIL) ((THREAD DUM4) NIL))

ADD-TO-CACHE (SLOT CACHE)

BITS-SET-P (X BITS)

COPY-DOUBLE-LINKED-ELEMENT (INSTANCE)

COPY-LRU-CACHE-SLOT (INSTANCE)

COPY-PROCESS (INSTANCE)

COPY-PROMISE (INSTANCE)

COPY-QUEUE (INSTANCE)

COPY-UNIX-FILE-STAT (INSTANCE)

DLL-MEMBER-P (DLE LIST)

LRU-CACHE-SLOT-P (OBJECT)

SETFLRUC-SLOT-KEY (NEW-VALUE INSTANCE)

SETFLRUC-SLOT-NEXT (NEW-VALUE INSTANCE)

SETFLRUC-SLOT-PREVIOUS (NEW-VALUE INSTANCE)

SETFLRUC-SLOT-VALUE (NEW-VALUE INSTANCE)

MAKE-LRU-CACHE-SLOT (&KEY ((PREVIOUS DUM1667) NIL) ((VALUE DUM1668) NIL) ((NEXT DUM1669) NIL) ((KEY DUM1670) NIL))

MAKE-PROMISE (&KEY ((PROCEDURE DUM0) NIL) ((VALUE DUM1) NIL))

MAKE-UNIX-FILE-STAT (&KEY ((DEVICE DUM345) NIL) ((INODE DUM346) NIL) ((LINKS DUM347) NIL) ((ATIME DUM348) NIL) ((MTIME DUM349) NIL) ((CTIME DUM350) NIL) ((SIZE DUM351) NIL) ((BLKSIZE DUM352) NIL) ((BLOCKS DUM353) NIL) ((UID DUM354) NIL) ((GID DUM355) NIL) ((MODE DUM356) NIL))

PACKAGE-LOCKED-P (PACKAGE)

SETFPROCESS-FUNCTION (NEW-VALUE INSTANCE)

PROCESS-KILL-THREAD (PROCESS)

SETFPROCESS-THREAD (NEW-VALUE INSTANCE)

PROMISE-P (OBJECT)

SETFPROMISE-PROCEDURE (NEW-VALUE INSTANCE)

SETFPROMISE-VALUE (NEW-VALUE INSTANCE)

SETFQUEUE-FIRST (NEW-VALUE INSTANCE)

SETFQUEUE-LAST (NEW-VALUE INSTANCE)

QUEUE-P (OBJECT)

SECONDS-FROM-BEGINNING-OF-THE-YEAR (TIME &OPTIONAL TIME-ZONE)

SETENV (NAME VALUE &OPTIONAL (OVERWRITE T))

SIGNAL-NUMBER (SIGNAL-NAME)

UNIX-FILE-STAT-P (OBJECT)

UNSETENV (NAME)

MACRO

Public

BE (&REST BINDINGS-AND-BODY)

Less-parenthetic let.

BE* (&REST BINDINGS-AND-BODY)

Less-parenthetic let*.

CACHED (CACHE KEY VALUE)

If KEY is found in CACHE return the associated object. Otherwise store VALUE for later re-use.

DEFUN-MEMOIZED (NAME ARGS &BODY FORMS)

Define function NAME and make it memoizable. Then the MEMOIZED macro can be used to call this function and memoize its results. The function NAME must accept only one argument and return just one argument; more complicated cases are not considered. The hash table test function is the default 'EQL.

DO-DIRECTORY-TREE ((FILE ROOT-PATHNAME &KEY TRUENAMEP TEST DEPTH-FIRST) &BODY BODY)

Call TRAVERSE-DIRECTORY-TREE with BODY es procedure.

DO-DLE ((VAR DLE &OPTIONAL (RESULT NIL)) &BODY BODY)

Iterate over a list of DOUBLE-LINKED-ELEMENTs and map body to each element's value. Bind VAR to the value on each iteration.

DO-DLE* ((VAR DLE &OPTIONAL (RESULT NIL)) &BODY BODY)

Same as DO-DLE but VAR is a symbol macro, so that BODY can modify the element's value.

DO-DLL ((VAR LIST &OPTIONAL (RESULT NIL)) &BODY BODY)

Iterate over a sorted-list and map body to each element's value. Bind VAR to the value on each iteration.

DO-DLL* ((VAR LIST &OPTIONAL (RESULT NIL)) &BODY BODY)

Same as DO-DLL but VAR is a symbol macro, so that BODY can modify the element's value.

F++ (X &OPTIONAL (DELTA 1))

Same as INCF but hopefully optimised for fixnums.

GCASE ((VALUE &OPTIONAL (TEST 'EQUALP)) &REST CASES)

Generic CASE macro. Match VALUE to CASES as if by the normal CASE but use TEST as the comparison function, which defaults to EQUALP.

LET-PLACES (PLACES-AND-VALUES &BODY BODY)

Execute BODY binding temporarily some places to new values and restoring the original values of these places on exit of BODY. The syntax of this macro is identical to LET. The difference is that instead of new variable names this macro binds values to existing places (variables).

LET-SLOTS (ACCESSOR/NEW-VALUE-PAIRS OBJECT &BODY BODY)

Execute BODY with some OBJECT's slots temporary sets to new values as described in ACCESSOR/NEW-VALUE-PAIRS. The latter should be an alist of accessor names and the value to be assigned to that slot. On exit from BODY, those slots are restored to their original value. See LET-PLACES.

MEMOIZE-FUNCTION (NAME &KEY TEST)

Make function NAME memoized. TEST is passed to MAKE-HASH-TABLE.

MEMOIZED (FUNCTION ARG)

If necessary call FUNCTION passing ARG so that its return value is memoized. The next time this form is executed with the same argument value, the memoized result is returned instead of executing FUNCTION.

ON-ERROR (FORM &BODY ERROR-FORMS)

Execute FORM and in case of error execute ERROR-FORMS too. This does _not_ stop the error from propagating.

SAVE-FILE-EXCURSION ((STREAM &OPTIONAL POSITION) &BODY FORMS)

Execute FORMS returning, on exit, STREAM to the position it was before FORMS. Optionally POSITION can be set to the starting offset.

SHOW (&REST THINGS)

Debugging macro to show the name and content of variables. You can also specify forms, not just variables.

SWAP (X Y)

Swap values of places X and Y.

WITH-EUID (UID &BODY FORMS)

Switch temporarely to Unix user id UID, while performing FORMS.

WITH-GENSYMS ((&REST SYMBOLS) &BODY BODY)

Gensym all SYMBOLS and make them available in BODY. See also LET-GENSYMS.

WITH-HIDDEN-TEMP-FILE ((STREAM &REST OPEN-ARGS) &BODY BODY)

Just like WITH-TEMP-FILE but unlink (delete) the temporary file before the execution of BODY. As such BODY won't be able to manipulate the file but through STREAM, and no other program is able to see it. Once STREAM is closed the temporary file blocks are automatically relinquished by the operating system. This works at least on Unix filesystems. I don't know about MS-OSs where the system may likely decide to crash, take all your data with it and, in the meanwhile, report you to the NSA as terrorist.

WITH-LOCK-FILES ((LOCK-FILES &REST LOCK-ARGS) &BODY BODY)

Execute BODY after creating LOCK-FILES. Remove the lock files on exit. LOCK-ARGS are passed to MAKE-LOCK-FILES.

WITH-OPEN-PIPE ((IN OUT PROGRAM ARGUMENTS &KEY (PROCESS (GENSYM)) ERROR PTY) &BODY FORMS)

Run BODY with IN and OUT bound respectively to an input and an output stream connected to a system process created by running PROGRAM with ARGUMENTS. If IN or OUT are NIL, then don't create that stream.

WITH-TEMP-DIRECTORY ((PATH &REST MAKE-TEMP-DIRECTORY-ARGS) &BODY BODY)

Execute BODY with PATH bound to the pathname of a new unique temporary directory. On exit of BODY the directory tree starting from PATH will be automatically removed from the filesystem. Return what BODY returns. BODY is _not_ executed within the PATH directory; the working directory is never changed.

WITH-TEMP-FILE ((STREAM &REST OPEN-TEMP-ARGS) &BODY BODY)

Execute BODY within a dynamic extent where STREAM is bound to a STREAM open on a unique temporary file name. OPEN-TEMP-ARGS are passed verbatim to OPEN-TEMP-FILE.

Undocumented

AAND (&REST ARGS)

ACASE (CONDITION &BODY FORMS)

ACOND (&BODY FORMS)

AIF (TEST THEN &OPTIONAL ELSE)

ATOMIC-DECF (PLACE)

ATOMIC-INCF (PLACE)

AWHEN (TEST &BODY THEN)

DEFLAZY (NAME VALUE &OPTIONAL DOCUMENTATION)

LAZY (FORM)

UNTIL (TEST &BODY BODY)

WITH-LOCK-HELD ((PLACE &KEY STATE (WAIT T) TIMEOUT) &BODY BODY)

WITH-PACKAGE (NAME &BODY BODY)

WITH-RECURSIVE-LOCK-HELD ((PLACE &OPTIONAL STATE (WAIT T) TIMEOUT) &BODY BODY)

WITH-SYSTEM-ENVIRONMENT ((&REST VAR-AND-VALUES) &BODY BODY)

WITHOUT-SCHEDULING (&BODY BODY)

Private

Undocumented

RECONSTRUCT-OBJECT (CLASS &REST ARGS)

GENERIC-FUNCTION

Public

GETCACHE (KEY CACHE)

Get an item with KEY from a CACHE.

SETFGETCACHE (VALUE KEY CACHE)

Set or add an item with KEY in a CACHE.

INSERT (ITEM SORTED-LIST)

Insert an item in a sorted-list.

POP-FIRST (DOUBLE-LINKED-LIST)

Pop the first element of a double-linked-list.

POP-LAST (DOUBLE-LINKED-LIST)

Pop the last element of a double-linked-list.

PUSH-FIRST (ITEM DOUBLE-LINKED-LIST)

Push an item in front of a double-linked-list.

PUSH-LAST (ITEM DOUBLE-LINKED-LIST)

Append an item to a double-linked-list.

Undocumented

DLL-FIND (OBJECT DLL &KEY TEST KEY (TEST #'EQL) (KEY #'IDENTITY))

DLL-FIND-CURSOR (OBJECT DLL &KEY TEST KEY (TEST #'EQL) (KEY #'IDENTITY))

DLL-REMOVE (CURSOR DLL)

QUEUE-APPEND (QUEUE OBJECTS)

QUEUE-EMPTY-P (QUEUE)

QUEUE-POP (QUEUE)

Private

LIST-MAP (FUNCTION DOUBLE-LINKED-LIST)

Map a function to a double-linked-list.

REMCACHE (KEY CACHE)

Remove an item with KEY from a CACHE.

Undocumented

COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (CLASS DIRECT-SLOTDS)

SLOT-ACCESSOR

Public

SIZE (OBJECT)

Current number of elements in the cache.

Private

MAX-SIZE (OBJECT)

Maximum number of elements that the cache can fit.

Undocumented

LAZY-SLOT-FUNCTION (OBJECT)

VARIABLE

Public

*RUN-VERBOSE*

If true system commands are displayed before execution and standard error is not discarded.

Undocumented

*BOURNE-SHELL*

*DECIMAL-POINT*

*THOUSANDS-COMMA*

*TMP-FILE-DEFAULTS*

Private

*DEFAULT-CACHE-SIZE*

Default size of a LRU cache if it's not specified at instantiation time.

*PROCESS-PLISTS*

Hash table mapping processes to a property list. This is used by PROCESS-PLIST.

Undocumented

*ALL-PROCESSES*

*ALL-PROCESSES-LOCK*

*ATOMIC-LOCK*

*CURRENT-PROCESS*

*PERMANENT-QUEUE*

CLASS

Public

DOUBLE-LINKED-LIST

A double linked list where elements can be added or removed from either end.

LAZY-METACLASS

Metaclass for object having lazy slots. Lazy slots should be specified with the :LAZY keyword which must be a function of one argument. If required this function will be called once to get the value to memoize in the slot. Lazy slots can also be set/read as any other.

LIMITED-LIST

A double linked list where the maximum number of elements can be limited.

LRU-CACHE

An objects cache that keeps the elements used more often and drops those that are used less often. The usage is similar to an hash table. Elements are added to the list up to MAX-SIZE, then any new element will drop the less used one in the cache. Every time an element is set or retrieved it goes in front of a list. Those which get at the end of the list are dropped when more room is required.

SORTED-LIST

A double linked list where elements are inserted in a sorted order.

Undocumented

DOUBLE-LINKED-ELEMENT

PRINTABLE-OBJECT-MIXIN

PROMISE

QUEUE

UNIX-FILE-STAT

Private

LAZY-SLOT-MIXIN

Slot for LAZY-METACLASS classes. Lazy slots must be declared with the argument :LAZY which must be a function accepting the object instance as argument.

Undocumented

LAZY-DIRECT-SLOT-DEFINITION

LAZY-EFFECTIVE-SLOT-DEFINITION

LRU-CACHE-SLOT

PROCESS

CONSTANT

Public

Undocumented

+MONTH-NAMES+

+WHITESPACE+

Private

+UNIX-LISP-TIME-DIFFERENCE+

Time difference between Unix epoch and Common Lisp epoch. The former is 1st January 1970, while the latter is the beginning of the XX century.