• COM.INFORMATIMAGO.COMMON-LISP.PACKAGE
    Exports a DEFINE-PACKAGE macro and LOAD-PACKAGE function
    (amongst others) that map packages names (styled as:
    COM.INFORMATIMAGO.COMMON-LISP.PACKAGE to logical pathnames in
    the "PACKAGES" virtual host:
    "PACKAGES:COM;INFORMATIMAGO;COMMON-LISP;PACKAGE.LISP"
    The object files are mapped to:
    "PACKAGES:COM;INFORMATIMAGO;COMMON-LISP;~
    OBJ-${IMPL_TYPE}-${IMPL_VERS}-${MACH_TYPE} ;PACKAGE.${OBJECT-TYPE}"
    
    Improvements over DEFPACKAGE include:
    
    - allow to specify packages refered to (used) while not
    importing ("inheriting") any of it symbols; (:USE package)
    - allow to do it while renaming (nicknaming) the package;
    (:USE package :AS nickname)
    - allow to specify that all symbols exported by a given package
    are to be imported. (:FROM package :IMPORT :ALL)
    The first and second points help declare package dependencies without
    using the deprecated REQUIRE, PROVIDE and *MODULES*.  This is done
    by implementing a systematic way to load packages (from a PACKAGE:
    logical host with logical pathname translations).
    This allows MAKE-DEPENDS to build automatically the dependency graph,
    and LOAD-PACKAGE to load automatically the dependencies without
    the need to write an ASDF or DEFSYSTEM file.
    The last point, along with the (:FROM package :IMPORT symbol...) form
    correct the naming of the :USE clause of DEFPACKAGE.
    Other more obscure clauses of DEFPACKAGE (:SHADOW,
    :SHADOWING-IMPORT-FROM, :INTERN) have no equivalent
    to provide a more controled package management.
    
  • COM.INFORMATIMAGO.COMMON-LISP.SOURCE-FORM
    This package exports functions to parse and manipulate
    Common Lisp sources as lisp forms (such as in macros).
    
  • COM.INFORMATIMAGO.COMMON-LISP.READER
    Implements the Common Lisp Reader.
    
    We implement a Common Lisp Reader to be able to read lisp sources.
    First, we implement a complete standard compliant lisp reader,
    with additionnal hooks (token parser).
    A READTABLE-PARSE-TOKEN function takes a TOKEN as argument, and
    must return two values:
    - A boolean indicating whether the it could parse the token,
    - a parsed lisp object it could, or an error message (string) if not.
    See also the TOKEN functions, CONSTITUENT-TRAIT, SYNTAX-TABLE and
    CHARACTER-DESCRIPTION...
    
  • COM.INFORMATIMAGO.COMMON-LISP.SOURCE-TEXT
    This package exports functions to read and manipulate
    Common Lisp sources.  Most of the text source properties
    are kept (file position, line number, comments, feature
    tests, etc), while no package is created and no symbol is
    interned (TODO: but perhaps keywords?)
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.VERSION
    This package exports functions to get and compare lisp
    implementation versions.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.SCRIPT
    This file defines utilities for lisp scripts.
    
  • COM.INFORMATIMAGO.COMMON-LISP.UTILITY
    This package exports some utility & syntactic sugar functions & macros.
    
  • COM.INFORMATIMAGO.COMMON-LISP.ASCII
    Some ASCII code utilities.
    Examples:
    (bytes= buffer #.(ascii-bytes "HELO ") :end1 (min 5 (length buffer)))
    (bytes= buffer #"HELO "                :end1 (min 5 (length buffer)))
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.ECMA048
    This package loads the ECMA-048 standard text and from
    this specifications can generate functions returning
    the control sequences defined in the standard.
    The user must call for example:
    (generate-all-functions :verbose *compile-verbose*
    :compile t
    :export  t
    :8-bit   t
    :print   nil
    :result-type '(vector (unsigned-byte 8))))
    to get the code function defined in the current package (*package*).
    Note: ECMA-048 should be identical to ISO-6429.
    
  • COM.INFORMATIMAGO.COMMON-LISP.LIST
    This module exports some list utility functions.
    
  • COM.INFORMATIMAGO.COMMON-LISP.DLL
    A doubly-linked list.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.QUEUE
    This module exports a queue type. This is a structure optimized for
    FIFO operations, keeping a pointer to the head and the tail of a list.
    
  • COM.INFORMATIMAGO.COMMON-LISP.ARRAY
    This package exports some array utility functions.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.STRING
    This package exports some string utility functions.
    
  • COM.INFORMATIMAGO.COMMON-LISP.STREAM
    This package exports some stream utility functions.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.FILE
    This package exports some file utility functions.
    
    binary-file-contents, sexp-file-contents, text-file-contents, and
    string-list-text-file-contents are accessors.
    They can be used with setf to store data into the file.
    (push 'hi (sexp-file-contents file :if-does-not-exist '()))
    (incf (sexp-file-contents version-file :if-does-not-exist 0))
    
  • COM.INFORMATIMAGO.COMMON-LISP.PEEK-STREAM
    This package exports a class named PEEK-STREAM that encapsulates
    a stream and a buffer in such a way that reading, peeking or
    unreading characters can be done in any number and in any order.
    
    We don't use gray stream to keep it pure Common-Lisp.
    The I/O methods are GETCHAR, UNGETCHAR and NEXTCHAR to avoid
    name clashes with un-generic READ-CHAR, UNREAD-CHAR and PEEK-CHAR.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.SCANNER
    An abstract scanner class.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.PARSER
    An abstract parser class.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.LLRBTREE
    Implementation of Left Leaning Red Black Trees.
    Robert Sedgewick's algorithms.
    http://www.cs.princeton.edu/~rs
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.BSET
    Set of (integer 0 *) implemented with array of bitsets.
    (Inspired by Modula-2 cocktail-9309/reuse/src/Set.md)
    
  • COM.INFORMATIMAGO.COMMON-LISP.BRELATION
    This package implements a relation abstract data type
    based on an array of bset.
    It can represent only relations between two positive
    and bounded integers.
    (Inspired by Modula-2 cocktail-9309/reuse/src/Relations.md).
    
  • COM.INFORMATIMAGO.COMMON-LISP.GRAPH
    Graph class.
    This is a CLOS based implementation of graphs.
    It comes from an emacs/eieio implementation used to analyze
    CVS versioning graph.
    Subclasses exist to generate dot files, and Diagram! files.
    
  • COM.INFORMATIMAGO.COMMON-LISP.GRAPH-DOT
    Generate dot files from graphs (graph-class).
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.GRAPH-DIAGRAM
    Generate dot files from graphs (graph-class). incomplete
    
  • COM.INFORMATIMAGO.COMMON-LISP.COMBINATION
    This package exports three classes to generate lazily combinations,
    and arrangement with and without repeatition (permutations).
    (Sorry about the comments that are untranslated from C++ to Lisp).
    
  • COM.INFORMATIMAGO.COMMON-LISP.PMATCH
    Sexp Pattern Matcher.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.PICTURE
    ASCII-ART primitives.
    A  picture is an array of characters.
    There are primitives to draw points, lines, rectangles,
    circles and ellipses, and strings.
    The coordinate system is the direct one:
    - x increases toward the right,
    - y increases toward the top. Bottom left is (0,0).
    
  • COM.INFORMATIMAGO.COMMON-LISP.MEMORY
    This packages exports a memory abstract class
    and a concrete subclass implemented as a lisp array of unsigned bytes.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.HEAP
    This package implements a heap for "common" data
    in shared memory segments.
    There is a garbage collector, and lisp data types.
    
  • COM.INFORMATIMAGO.COMMON-LISP.ACTIVITY
    This package implements a kind of co-routine monitor.
    An activity is a closure that is called at specified times (T+k*P).
    It should return before processing can go on.  This package is
    implemented in pure Common Lisp and allows to schedule independent
    "tasks" portably, as long as you can split each task in small chunks,
    timewise.
    See the comment at the end of this file for a example of use.
    
  • COM.INFORMATIMAGO.COMMON-LISP.MESSAGE-QUEUE
    Abstract interface to a message queue.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.FLOAT-BINIO
    This package encodes and decodes arrays of float into arrays
    of signed-byte 32 in order to do binary I/O.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.DATA-ENCODING
    This package exports functions to encode and decode data
    in a byte vector buffer.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.CONS-TO-ASCII
    This packages draws ASCIi art cons cell diagrams.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.TREE-TO-ASCII
    This modules draws a tree onto an ASCII-ART picture (pict.lisp)
    The tree drawn is a list whose car is the node displayed, and
    whose cdr is the list of children.
    
  • COM.INFORMATIMAGO.COMMON-LISP.TREE-TO-DIAGRAM
    This module generates a Diagram text file drawing a tree.
    The tree drawn is a list whose car is the node displayed, and
    whose cdr is the list of children.
    
  • COM.INFORMATIMAGO.COMMON-LISP.RFC2822
    RFC0822/RFC2822 support funtions.
    
    RFC822      STANDARD FOR THE FORMAT OF ARPA INTERNET TEXT MESSAGES
    RFC2822     Internet Message Format
    
    RFC822 in fixnum words:
    
    In transmission, message lines are separated by CRLF.
    Header lines are separated from body lines by an empty line (CRLFCRLF).
    Header lines may be cut by replacing any space or tab by CRLF, (space or tab).
    Field name consists of any ASCII printable character but space and colon,
    followed by a colon.
    Field body begins immediately after the colon. (Customary space included).
    NOTE: rfc2822 forbid spaces between field name and colon,
    but it IS possible in rfc822 to insert spaces here.
    (For example, see Annex A of RFC822).
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.RFC3548
    This packages exports functions to encode an decode text blocks
    according to the encoding described in:
    RFC3548: The Base16, Base32, and Base64 Data Encodings
    
    BASE64-ENCODE     (READ-BYTE WRITE-CHAR)
    BASE64-DECODE     (READ-CHAR WRITE-BYTE &KEY (IGNORE-INVALID-INPUT NIL))
    FILEBASE64-ENCODE (READ-BYTE WRITE-CHAR)
    FILEBASE64-DECODE (READ-CHAR WRITE-BYTE &KEY (IGNORE-INVALID-INPUT NIL))
    BASE32-ENCODE     (READ-BYTE WRITE-CHAR)
    BASE32-DECODE     (READ-CHAR WRITE-BYTE &KEY (IGNORE-INVALID-INPUT NIL))
    BASE16-ENCODE     (READ-BYTE WRITE-CHAR)
    BASE16-DECODE     (READ-CHAR WRITE-BYTE &KEY (IGNORE-INVALID-INPUT NIL))
    
    READ-BYTE:  A FUNCTION TAKING NO ARGUMENT AND RETURNING A
    BYTE (INTEGER 0 255) OR NIL FOR EOF.  IT MAY BE
    CALLED SEVERAL TIMES AFTER EOF AND SHOULD KEEP
    RETURNING NIL.
    
    WRITE-BYTE: A FUNCTION TAKING ONE BYTE (INTEGER 0 255) ARGUMENT
    USED TO COLLECT DECODED BYTES.
    
    READ-CHAR:  A FUNCTION TAKING NO ARGUMENT AND RETURNING A
    CHARACTER OR NIL FOR EOF.  IT MAY BE CALLED
    SEVERAL TIMES AFTER EOF AND SHOULD KEEP RETURNING
    NIL.  ONLY CHARACTERS WHOSE CODE IS BETWEEN 0 AND
    255 SHOULD BE RETURNED.
    
    WRITE-CHAR: A FUNCTION TAKING ONE CHARACTER ARGUMENT, USED TO
    COLLECT ENCODED BYTES.
    
    IGNORE-INVALID-INPUT:
    WHEN TRUE, ANY INVALID CHARACTER OR PADDING IS IGNORED
    AND PROCESSING CONTINUES AS IF IT DID NOT OCCUR.
    WHEN NIL, SUCH AN OCCURENCE WOULD RAISE AN ERROR.
    
    
    BASE64-ENCODE-BYTES     (BYTES   &KEY LINE-WIDTH (NEW-LINE +NEW-LINE+))
    BASE64-DECODE-BYTES     (ENCODED &KEY IGNORE-CRLF IGNORE-INVALID-INPUT)
    FILEBASE64-ENCODE-BYTES (BYTES   &KEY LINE-WIDTH (NEW-LINE +NEW-LINE+))
    FILEBASE64-DECODE-BYTES (ENCODED &KEY IGNORE-CRLF IGNORE-INVALID-INPUT)
    BASE32-ENCODE-BYTES     (BYTES   &KEY LINE-WIDTH (NEW-LINE +NEW-LINE+))
    BASE32-DECODE-BYTES     (ENCODED &KEY IGNORE-CRLF IGNORE-INVALID-INPUT)
    BASE16-ENCODE-BYTES     (BYTES   &KEY LINE-WIDTH (NEW-LINE +NEW-LINE+))
    BASE16-DECODE-BYTES     (ENCODED &KEY IGNORE-CRLF IGNORE-INVALID-INPUT)
    
    BYTES:      A VECTOR OF (UNSIGNED-BYTE 8).
    ENCODED:    A STRING.
    LINE-WIDTH: NIL OR AN INTEGER INDICATING THE LINE WIDTH.
    THE STRING NEW-LINE WILL BE INSERTED AFTER THAT
    MANY CHARACTERS HAVE BEEN WRITTEN ON A GIVEN LINE.
    NEW-LINE:   A STRING CONTAIING THE NEW-LINE CHARACTER OR CHARACTERS.
    THE DEFAULT +NEW-LINE+ IS (FORMAT NIL "~%").
    IGNORE-CRLF:
    When true, ASCII characters LF and CR are not passed to
    the decoding function. When NIL, they're passed, and
    if invalid input is not ignored, an error would be raised.
    IGNORE-INVALID-INPUT:
    Passed to the decoding function. See above.
    
    The encoding functions take a vector of bytes
    and return an encoded string.
    
    The decoding functions take an encoded string
    and return a vector of bytes.
    
    To encode a string, characters must be converted to bytes, and
    to decode a string, bytes must be converted to characters.
    This must be done accordingly to the characeter set encoding.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.ISO639A
    This package exports functions and data to process
    iso639a language codes.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.ISO3166
    This package exports functions and data to process
    iso3166 country codes.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.ISO4217
    This package exports functions and data to process
    iso4217 currency codes.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.CHARACTER-SETS
    This package exports functions to manage character-sets,
    character encodings, coding systems and external format.
    It's all the same, but each everybody likes to have his own terms...
    
    The base character set repertoire will be the IANA one, published at:
    http://www.iana.org/assignments/character-sets
    
  • COM.INFORMATIMAGO.COMMON-LISP.HTML-ENTITIES
    ISO 8879:1986 SGML entities (HTML 3.2).
    (Related to, but distinct from: ISO 8859-1).
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.HTML
    Generating HTML pages.
    See also:
    cliki HTML from sexpr
    
  • COM.INFORMATIMAGO.COMMON-LISP.HQUERY
    This packages exports utility routines for web applications.
    
  • COM.INFORMATIMAGO.COMMON-LISP.DATABASE
    A Lisp Database access layer.
    This package defines a generic API to access databases.
    
  • COM.INFORMATIMAGO.COMMON-LISP.PARSE-HTML
    A Simple HTML parser.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.CACHE
    A generic disk-based cache.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.ALIASES
    This package exports a function to read sendmail aliases files.
    
    (setf db (load-aliases [file]))
    (save-aliases db [file])
    (db-records db) --> list-of-records
    (make-alias name address-list) --> record
    (make-comment text) --> record
    (find-record-if db predicate) --> record
    (alias-record   db name) --> record
    (comment-record-containing db substring) --> record
    (insert-record  db record [:before record] [:after record])
    (delete-record  db record)
    (list-all-aliases db) --> ("name1" "name2" ...)
    (alias-addresses db name) --> list
    (setf (alias-addresses db name) list)
    (insert-alias db name type value [:before record] [:after record])
    (delete-alias db name)
    
  • COM.INFORMATIMAGO.COMMON-LISP.PASSWD
    This package exports a function to read unix passwd files.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.GROUP
    This package exports a function to read unix group files.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.PRIMES
    Compute primes and factorize numbers.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.TEA
    Implementation of the TEA
    Tiny Encryption Algorith
    
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.RAIDEN
    Implements the Raiden block cipher.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.MAKE-DEPENDS
    This script generates dependencies for lisp sources, based on
    (require) sexps, a load-path, a set of logical pathname translations
    and ad-hoc processing.
    
    Object files can be either elisp compiled (.elc) or clisp compiled
    (.fas), cmucl compiled (.x86f), or sbcl compiled (.fasl).
    and source files can be either elisp (.el) or clisp or cmucl (.lisp,
    .lsp, .cl), and elisp sources may (require) common-lisp files
    (.lisp, .lsp, .cl extensions for sources, but .elc compiled form).
    
  • COM.INFORMATIMAGO.COMMON-LISP.CXX
    Parsing C++ sources.
    This is a restricted parser, used just to analyze
    the call graph of C++ functions and methods.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.CSV
    This package reads and writes CSV files.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.IBAN
    This class is an Internationnal Bank Account Number,
    according to European standard.
    IBAN Format
    
  • COM.INFORMATIMAGO.COMMON-LISP.RIB
    This class is a French "Relevé d'Identité Banquaire", composed of
    three codes and a control key value: (banque, branch-code, account-
    number, check-digits).
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.INVOICE
    This package exports classes and functions used for accounting:
    invoices, customers/providers, movements, taxes...
    
  • COM.INFORMATIMAGO.COMMON-LISP.BROWSER
    This package exports a function to browse the directory hierarchy
    and load lisp files, and a few interactive commands:
    CD, PWD, PUSHD, POPD, MKDIR,
    LS, CAT, MORE, CP, MV, MAKE, GREP.
    
    
  • COM.INFORMATIMAGO.COMMON-LISP.ED
    ed(1) in COMMON-LISP.
    Real men do it with magnets.  ed is for girly men.
    This is a clone of the unix ed(1) editor written in pure Common-Lisp.
    Since Common-Lisp does not define any process management functions,
    all !command forms are taken as Lisp forms instead of sh(1) commands.
    These forms are executed within a (LAMBDA (*INPUT*) command) with
    the *INPUT* argument bound to a mutable list of inmutable input strings,
    one per line.  The result of the returning form in command must be
    a list of string, the list of resulting lines to be inserted into the
    buffer or to be printed on the terminal.
    For the rest, the aim is to be 100% user-interface compatible with ed(1).
    Ed, man! !man ed
    Can you imagine that some Common-Lisp implementations DON'T provide
    any editor (in conformity with the Common-Lisp specifications)?
    Not complete (waiting for a REGEXP package). But otherwise
    functional enough.
    
  • COM.INFORMATIMAGO.COMMON-LISP.INTERACTIVE
    This package defines various interactive commands.
    It also re-exports some functions from BROWSER and PACKAGE.