[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

eval to texinfo

From: Jose E. Marchesi
Subject: eval to texinfo
Date: Mon, 8 Mar 2004 12:43:57 +0100


I wrote the following function for the writing of a book about emacs. 
It dump a @lisp texinfo environment that describes the action.

It manages error conditions also.

(defun eval-to-texi (form &optional tostring)
  "Evaluates FORM, dumping a @lisp texinfo environment that 
describes action.

If TOSTRING is t, then the @lisp environment is returned into a string,
rather than being inserted into the buffer."
  (interactive "sForm to evaluate: ")

  (let (environment-text)

    (setq environment-text 


            (condition-case error-description

                (let (expression result output)

                  ;; Begin of the sample
                  (insert "@lisp\n")

                  ;; Dump the form itself into the sample
                  (let ((tform form))

                     (setq tform (replace-regexp-in-string "@" "@@" tform))
                     (setq tform (replace-regexp-in-string "{" "@{" tform))
                     (setq tform (replace-regexp-in-string "}" "@}" tform))

                     (insert tform "\n"))

                  ;; Parse the form to a valid expression
                  (setq expression (read form))

                  ;; Get the result of the eval, and the output if there is one
                  (setq output 
                          (setq result (prin1-to-string (eval expression)))))

                  ;; If there is any output, dump a @print{} entry into the 
                  (if (not (equal output ""))

                        ;; Escape texinfo special characters on the output
                        (setq output (replace-regexp-in-string "@" "@@" output))
                        (setq output (replace-regexp-in-string "{" "@{" output))
                        (setq output (replace-regexp-in-string "}" "@}" output))

                        ;; Indent multilines
                        (setq output (replace-regexp-in-string "\n" "\n         
 " output))

                        (insert "      @print{} " output "\n")))

                  ;; If the expression is a macro, dump an @expansion{}
                  (let ((macroexp (macroexpand expression)))
                    (if (not (equal macroexp expression))  ; macro-p???

                        (let ((met (prin1-to-string macroexp)))

                          ;; Escape texinfo special characters on the macro 
expansion text
                          (setq met (replace-regexp-in-string "@" "@@" met))
                          (setq met (replace-regexp-in-string "{" "@{" met))
                          (setq met (replace-regexp-in-string "}" "@}" met))

                          ;; Indent multilines
                          (setq met (replace-regexp-in-string "\n" "\n          
" met))

                          (insert "      @expansion{} " met "\n"))))

                  ;; Escape texinfo special characters on the result
                  (setq result (replace-regexp-in-string "@" "@@" result))
                  (setq result (replace-regexp-in-string "{" "@{" result))
                  (setq result (replace-regexp-in-string "}" "@}" result))

                  ;; Indent multilines
                  (setq result (replace-regexp-in-string "\n" "\n          " 

                  ;; Dump the @result{} entry into the sample
                  (insert "      @result{} " result "\n"))

              ;; Was an error => Dump an @error{} entry into the sample with 
the error
              ;; description from the interpreter
              (error (insert "      @error{} " (error-message-string 
error-description) "\n")))

            ;; End of the sample
            (insert "@end lisp")

            ;; Return buffer's contents
            (buffer-substring (point-min) (point-max))))

    (if (not tostring)
        (insert environment-text)

reply via email to

[Prev in Thread] Current Thread [Next in Thread]