anchor.diff:      (MAPC #'(LAMBDA (X) (FORMAT Out "~S~%~%" X)) Code)
       File))
   
  -(DEFUN import-lsp (File)
  -  (LET ((LspFile (FORMAT NIL "~A.lsp" File))
  -        (ObjFile (FORMAT NIL "~A~A~A" NATIVE-PATH File COMPILED-SUFFIX)))
  -    (COMPILE-FILE LspFile :OUTPUT-FILE ObjFile)
  -    (LOAD ObjFile)))
  -
  -(COMPILE 'read-in-kl)
  +(COMPILE 'read-kl-file)
   (COMPILE 'kl-cycle)
  -(COMPILE 'flip)
  -(COMPILE 'write-out-kl)
  +(COMPILE 'write-lsp-file)
   
   (ENSURE-DIRECTORIES-EXIST NATIVE-PATH)
   
  
positive.code:   (DECLAIM (SB-EXT:MUFFLE-CONDITIONS SB-EXT:COMPILER-NOTE))
    (SETF SB-EXT:*MUFFLED-WARNINGS* T))
  
  (DEFUN import-kl (File)
    (LET ((KlFile       (FORMAT NIL "./kernel/klambda/~A.kl" File))
          (IntermedFile (FORMAT NIL "~A~A.intermed" NATIVE-PATH File))
          (LspFile      (FORMAT NIL "~A~A.lsp" NATIVE-PATH File))
          (ObjFile      (FORMAT NIL "~A~A~A" NATIVE-PATH File COMPILED-SUFFIX)))
      (prepare-kl KlFile IntermedFile)
      (translate-kl IntermedFile LspFile)
      (COMPILE-FILE LspFile)
      (LOAD ObjFile)))
  
  (DEFUN prepare-kl (KlFile IntermedFile)
    (write-out-kl IntermedFile (read-in-kl KlFile)))
  
  (DEFUN read-in-kl (File)
    (WITH-OPEN-FILE
      (In File :DIRECTION :INPUT)
      (kl-cycle (READ-CHAR In NIL NIL) In NIL 0)))
  
  (DEFUN kl-cycle (Char In Chars State)
    (IF (NULL Char)
      (REVERSE Chars)
      (kl-cycle
        (READ-CHAR In NIL NIL)
        In
        (IF (AND (MEMBER Char '(#\: #\; #\,) :TEST 'CHAR-EQUAL) (= State 0))
          (APPEND (LIST #\| Char #\|) Chars)
          (CONS Char Chars))
        (IF (CHAR-EQUAL Char #\")
          (flip State)
          State))))
  
  (DEFUN flip (State)
    (IF (ZEROP State) 1 0))
  
  (DEFUN write-out-kl (File Chars)
    (WITH-OPEN-FILE
      (Out File
        :DIRECTION         :OUTPUT
        :IF-EXISTS         :SUPERSEDE
        :IF-DOES-NOT-EXIST :CREATE)
      (FORMAT Out "~{~C~}" Chars)))
  
  (DEFUN translate-kl (InputFile OutputFile)
    (LET* ((KlCode (open-kl-file InputFile))
           (LispCode (MAPCAR #'(LAMBDA (X) (shen.kl-to-lisp NIL X)) KlCode)))
      (write-lsp-file OutputFile LispCode)))
  
  (DEFUN open-kl-file (File)
    (WITH-OPEN-FILE (In File :DIRECTION :INPUT)
      (DO ((R T) (Rs NIL))
          ((NULL R) (NREVERSE (CDR Rs)))
          (SETQ R (READ In NIL NIL))
          (PUSH R Rs))))
  
  (DEFUN write-lsp-file (File Code)
    (WITH-OPEN-FILE
  
negative.code: (import-lsp "overwrite")
  (load "platform.shen")
  
  (FMAKUNBOUND 'read-kl-file)
  (FMAKUNBOUND 'translate-kl)
  (FMAKUNBOUND 'write-lsp-file)
  (FMAKUNBOUND 'import-lsp)
  (FMAKUNBOUND 'import-kl)
  