anchor.diff:      (apply (function concatenate) 'string (nreverse justified))))
   
   
  -(DEFMACRO DEFTRANSLATION (TABLE TEXT LANGUAGE TRANSLATION
  -                                &REST LANGS-TRANS)
  +(defmacro deftranslation (table text language translation
  +                                &rest langs-trans)
     `(eval-when (:compile-toplevel :load-toplevel :execute)
        (unless (boundp (quote ,table))
  -       (DEFVAR ,TABLE (MAKE-HASH-TABLE :TEST (FUNCTION EQUAL))))
  -     (SETF ,@(DO ((LT (list* LANGUAGE TRANSLATION LANGS-TRANS))
  -                  (RESULT '()))
  -                 ((NULL LT) (NREVERSE RESULT))
  -                 (PUSH  `(GETHASH (CONS ,TEXT ,(POP LT)) ,TABLE) RESULT)
  -                 (push (LET ((TRANS (POP LT)))
  -                         (IF (EQ TRANS :IDEM)
  -                             `,TEXT
  -                             `,TRANS)) result)))))
  -
  -
  -(DEFUN LOCALIZE (TABLE LANGUAGE TEXT)
  +       (defvar ,table (make-hash-table :test (function equal))))
  +     (setf ,@(do ((lt (list* language translation langs-trans))
  +                  (result '()))
  +                 ((null lt) (nreverse result))
  +                 (push  `(gethash (cons ,text ,(pop lt)) ,table) result)
  +                 (push (let ((trans (pop lt)))
  +                         (if (eq trans :idem)
  +                             `,text
  +                             `,trans)) result)))))
  +
  +
  +(defun localize (table language text)
     "
   RETURN: A version of the TEXT in the given LANGUAGE, 
           or in english if LANGUAGE is not found,
  
positive.code:        :finally (return result))))
  
  
  (DEFUN EXPLODE-STRING (STRING)
    "
  return a new list containing the character in the sequence string.
  "
    (MAP 'LIST (FUNCTION CHARACTER) STRING))
  
  
  (DEFUN IMPLODE-STRING (CHAR-SEQ)
    "
  RETURN: A new string containing the characters in the sequence CHAR-SEQ.
  "
    (MAP 'STRING (FUNCTION CHARACTER) CHAR-SEQ))
  
  
  (DEFINE-COMPILER-MACRO IMPLODE-STRING (&WHOLE FORM  CHAR-SEQ)
    "
  RETURN:  An optimized form for compiled code.
  NOTE:    Unfortunately clisp does to take into account compiler-macros
           even when compiling...
  "
    (DECLARE (IGNORABLE FORM))
    (WITH-GENSYMS (SEQ)
      `(LET ((,SEQ ,CHAR-SEQ))
         (TYPECASE ,SEQ
           (STRING     (COPY-SEQ ,SEQ))
           (LIST       (DO ((RESULT (MAKE-STRING (LENGTH ,SEQ)))
                            (I 0 (1+ I))
                            (SEQU ,SEQ  (CDR SEQU)))
                           ((NULL SEQU) RESULT)
                         (SETF (CHAR RESULT I) (CHARACTER (CAR SEQU)))))
           (OTHERWISE  (DO ((RESULT (MAKE-STRING (LENGTH ,SEQ)))
                            (I 0 (1+ I))
                            (MAX (LENGTH ,SEQ)))
                           ((>= I MAX) RESULT)
                         (SETF (CHAR RESULT I) (CHARACTER (AREF ,SEQ I)))))) )))
  
  
  (DEFUN SPLIT-ESCAPED-STRING (STRING ESCAPE SEPARATOR)
    "
  DO:      Split the string on the separator character.
           It may be escaped with the escape character.
  RETURN:  A list of substrings of string.
  "
    (UNLESS (SIMPLE-STRING-P STRING)  (SETF STRING    (COPY-SEQ STRING)))
    (UNLESS (CHARACTERP ESCAPE)       (SETF ESCAPE    (CHARACTER ESCAPE)))
    (UNLESS (CHARACTERP SEPARATOR)    (SETF SEPARATOR (CHARACTER SEPARATOR)))
    (DO ((RESULT   ())
         (ESCAPED  NIL)
         (START    0)
         (CURR     0))
        ((>= CURR (LENGTH STRING))
         (IF (AND (NULL RESULT) (= 0 CURR))
             NIL
             (PROGN (PUSH (SUBSEQ STRING START CURR) RESULT)
                    (NREVERSE RESULT))))
      (IF ESCAPED
          (PROGN (INCF CURR)
                 (SETF ESCAPED NIL))
          (COND
            ((CHAR= (AREF STRING CURR) ESCAPE)   (INCF CURR) (SETF ESCAPED T))
            ((CHAR= (AREF STRING CURR) SEPARATOR)
             (PUSH (SUBSEQ STRING START CURR) RESULT)
             (INCF CURR)
             (SETF START CURR))
            (T (INCF CURR))))))
  
  
  (DEFUN SPLIT-STRING (STRING &OPTIONAL (SEPARATORS " "))
    "
  NOTE:   current implementation only accepts as separators
          a string containing literal characters.
  "
    (LET ((string     (if (SIMPLE-STRING-P STRING)
                          string
                          (COPY-SEQ STRING)))
          (SEPARATORS (if (SIMPLE-STRING-P SEPARATORS)
                          SEPARATORS
                          (COPY-SEQ SEPARATORS)))
          (CHUNKS  '())
          (POSITION 0)
          (NEXTPOS  0)
          (STRLEN   (LENGTH STRING)) )
      (DECLARE (TYPE SIMPLE-STRING STRING SEPARATORS))
      (LOOP :WHILE (< POSITION STRLEN)
            :DO (LOOP :WHILE (AND (< NEXTPOS STRLEN)
                                  (NOT (POSITION (CHAR STRING NEXTPOS) SEPARATORS)))
                      :DO (SETQ NEXTPOS (1+ NEXTPOS)))
                (PUSH (SUBSEQ STRING POSITION NEXTPOS) CHUNKS)
                (SETQ POSITION (1+ NEXTPOS))
                (SETQ NEXTPOS  POSITION))
      (NREVERSE CHUNKS)))
  
  
  (DEFUN UNSPLIT-STRING (STRING-LIST &OPTIONAL SEPARATOR)
    "
  DO:         The inverse than split-string.
              If no separator is provided then a simple space is used.
  SEPARATOR:  (OR NULL STRINGP CHARACTERP)
  "
    (COND
      ((NULL SEPARATOR)
       (SETQ SEPARATOR " "))
      ((CHARACTERP SEPARATOR)
       (SETQ SEPARATOR (MAKE-STRING 1 :INITIAL-ELEMENT SEPARATOR)))
      ((NOT (STRINGP SEPARATOR))
       (ERROR "unsplit-string: separator must be a string or a char.")))
    (APPLY 'CONCATENATE 'STRING (LIST-INSERT-SEPARATOR STRING-LIST SEPARATOR)))
  
  
  (defun string-replace (string pattern replace &key (test (function char=)))
  
negative.code:     (if (<= length slen)
          string
          (let ((result
                 (make-string length :initial-element 
                              (etypecase padchar
                                (character padchar)
                                (string (aref padchar 0))
  