home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / pcl / docs.lha / latexinfo / elisp / latexinfo.el < prev    next >
Encoding:
Text File  |  1992-02-24  |  81.0 KB  |  2,406 lines
  1. ;; Convert latexinfo files to info files.
  2. ;; Copyright (C) 1985, 1986, 1988 Free Software Foundation, Inc.
  3. ;; Copyleft  (C) 1988, 1989, 1990, 1991 Michael E. Clarkson
  4.  
  5. ;; This file is not yet a part of GNU Emacs.
  6.  
  7. ;; GNU Emacs is distributed in the hope that it will be useful,
  8. ;; but WITHOUT ANY WARRANTY.  No author or distributor
  9. ;; accepts responsibility to anyone for the consequences of using it
  10. ;; or for whether it serves any particular purpose or works at all,
  11. ;; unless he says so in writing.  Refer to the GNU Emacs General Public
  12. ;; License for full details.
  13.  
  14. ;; Everyone is granted permission to copy, modify and redistribute
  15. ;; GNU Emacs, but only under the conditions described in the
  16. ;; GNU Emacs General Public License.   A copy of this license is
  17. ;; supposed to have been given to you along with GNU Emacs so you
  18. ;; can know your rights and responsibilities.  It should be in a
  19. ;; file named COPYING.  Among other things, the copyright notice
  20. ;; and this notice must be preserved on all copies.
  21.  
  22. (defvar latexinfo-formats-directory
  23.   (file-name-as-directory (or (getenv "LATEXINFO") ".")))
  24.  
  25. (defvar latexinfo-texinputs
  26.   (let ((texinputs (or (getenv "TEXINPUTS")
  27.                (concat ".:" latexinfo-formats-directory
  28.                    ":/usr/local/lib/tex/inputs")))
  29.     (dirlist) (i 0) (l) (s) (sepchar ?:))
  30.     (if (eq system-type 'vax-vms) (setq sepchar ?,)) ; emacs.c
  31.     (setq l (length texinputs))
  32.     (while (< i l)
  33.       (setq s i)
  34.       (while (and (< i l) (not (char-equal (aref texinputs i) sepchar)))
  35.     (setq i (1+ i)))
  36.       (if (> i s)
  37.       (setq dirlist (append dirlist (list (substring texinputs s i)))))
  38.       (setq  i (1+ i)))
  39.     dirlist))
  40.  
  41. (defvar latexinfo-always-refill nil)
  42.  
  43. (if (not (memq latexinfo-formats-directory
  44.            load-path))
  45.     (setq load-path (cons
  46.              latexinfo-formats-directory
  47.              load-path)))
  48.  
  49. (if (not (memq "." load-path))    ; add the current directory to load-path
  50.     (setq load-path (cons "." load-path)))
  51.  
  52. (defvar latexinfo-known-document-styles
  53.       '(latexinfo 11pt 12pt twoside titlepage A4 a4 dina4 psfonts format))
  54.  
  55. (autoload 'latexinfo-mode "latexnfo-mde"
  56.         "Major mode for editing latexinfo files." t)
  57.  
  58. (autoload 'Info-tagify "informat" "Info Tagify" t)
  59. (autoload 'Info-split "informat" "Info Split" t)
  60.  
  61. (put 'latexinfoversion 'latexinfo-format 'latexinfo-format-latexinfoversion)
  62. (defun latexinfo-format-latexinfoversion ()
  63.   (latexinfo-parse-noarg)
  64.   (insert "1.7"))
  65.  
  66. (defvar latexinfo-vindex-old nil)
  67. (defvar latexinfo-findex-old nil)
  68. (defvar latexinfo-cindex-old nil)
  69. (defvar latexinfo-cpsubindex-old nil)
  70. (defvar latexinfo-pindex-old nil)
  71. (defvar latexinfo-tindex-old nil)
  72. (defvar latexinfo-kindex-old nil)
  73. (defvar latexinfo-refindex-old nil)
  74.  
  75. (defvar latexinfo-format-syntax-table nil)
  76.  
  77. (progn
  78.     (setq latexinfo-format-syntax-table (make-syntax-table))
  79.     (modify-syntax-entry ?* "w" latexinfo-format-syntax-table)
  80.     (modify-syntax-entry ?& "w" latexinfo-format-syntax-table)
  81.  
  82.     (modify-syntax-entry ?\\ "\\" latexinfo-format-syntax-table)
  83.     (modify-syntax-entry ?\^q "\\" latexinfo-format-syntax-table)
  84.  
  85.     (modify-syntax-entry ?{ "(}" latexinfo-format-syntax-table)
  86.     (modify-syntax-entry ?} "){" latexinfo-format-syntax-table)
  87.     (modify-syntax-entry ?\[ "(]" latexinfo-format-syntax-table) ; changed
  88.     (modify-syntax-entry ?\] ")[" latexinfo-format-syntax-table) ; changed
  89.  
  90.     (modify-syntax-entry ?\" " " latexinfo-format-syntax-table)
  91.     (modify-syntax-entry ?\( " " latexinfo-format-syntax-table)
  92.     (modify-syntax-entry ?\) " " latexinfo-format-syntax-table)
  93.  
  94.     ;; punctuation characters are important to \alwaysrefill
  95.     (modify-syntax-entry ?!  "." latexinfo-format-syntax-table)
  96.     (modify-syntax-entry ?.  "." latexinfo-format-syntax-table)
  97.     (modify-syntax-entry ?:  "." latexinfo-format-syntax-table)
  98.     (modify-syntax-entry ?\' "." latexinfo-format-syntax-table)
  99. )
  100.  
  101. (defun latexinfo-format-buffer (&optional notagify)
  102.   "Process the current buffer as latexinfo code, into an Info file.
  103. The Info file output is generated in a buffer visiting the Info file
  104. names specified in the \\setfilename command.
  105.  
  106. Non-nil argument (prefix, if interactive) means don't make tag table
  107. and don't split the file if large.  You can use Info-tagify and
  108. Info-split to do these manually.
  109.  
  110. Returns a list:
  111.  
  112.     (list outfile
  113.       latexinfo-cindex latexinfo-vindex latexinfo-findex 
  114.       latexinfo-pindex latexinfo-tindex latexinfo-kindex
  115.           latexinfo-refindex)"
  116.   (interactive "P")
  117.   (let ((lastmessage "Formatting Info file..."))
  118.     (message lastmessage)
  119.     (let ((retval (latexinfo-format-buffer-1)))
  120.       (setq latexinfo-cindex-old (nth 1 retval))
  121.       (setq latexinfo-vindex-old (nth 2 retval))
  122.       (setq latexinfo-findex-old (nth 3 retval))
  123.       (setq latexinfo-pindex-old (nth 4 retval))
  124.       (setq latexinfo-tindex-old (nth 5 retval))
  125.       (setq latexinfo-kindex-old (nth 6 retval))
  126.       (setq latexinfo-refindex-old (nth 7 retval)))
  127.     (if notagify nil (latexinfo-split))
  128.     (if (interactive-p) (message (concat lastmessage
  129.                      "done.  Now save it." "done.")))))
  130.  
  131. (defun latexinfo-split ()
  132.   (if (> (buffer-size) 30000)
  133.       (progn
  134.     (message (setq lastmessage "Making tags table for Info file..."))
  135.     (Info-tagify)))
  136.   (if (> (buffer-size) 100000)
  137.       (progn
  138.     (message (setq lastmessage "Splitting Info file..."))
  139.     (Info-split))))
  140.  
  141. (defun latexinfo-format-buffer-1 ()
  142.   (let (latexinfo-format-filename
  143.     latexinfo-example-start
  144.     latexinfo-command-start
  145.     latexinfo-command-end
  146.     latexinfo-command-name
  147.     latexinfo-last-node
  148.         latexinfo-last-node-pos
  149.     latexinfo-vindex
  150.     latexinfo-findex
  151.     latexinfo-cindex
  152.     latexinfo-cpsubindex
  153.     latexinfo-pindex
  154.     latexinfo-tindex
  155.     latexinfo-kindex
  156.     latexinfo-refindex
  157.     latexinfo-stack
  158.     latexinfo-node-names
  159.     (latexinfo-table-number 0)
  160.     (latexinfo-footnote-number 0)
  161.     outfile
  162.     (fill-column (1- fill-column))
  163.     (input-buffer (current-buffer))
  164.     (input-directory default-directory))
  165.     (save-excursion
  166.       (goto-char (point-min))
  167.       (re-search-forward "^\\\\setfilename")
  168.       (setq latexinfo-command-end (point))
  169.       (setq outfile (latexinfo-parse-line-arg)))
  170.     (find-file outfile)
  171.     (latexinfo-mode)
  172.     (set-syntax-table latexinfo-format-syntax-table)
  173.     (erase-buffer)
  174.     (insert-buffer-substring input-buffer)
  175.     (goto-char (point-min))
  176.     (latexinfo-run-documentstyle-hooks)
  177.     ;; Run this after latexinfo-run-documentstyle-hooks
  178.     (goto-char (point-min))
  179.     (re-search-forward "^\\\\setfilename")
  180.     (beginning-of-line)
  181.     (let ((end (point)))
  182.       (goto-char (point-min))
  183.       (if (re-search-forward "^\\\\alwaysrefill" end t)
  184.       (setq latexinfo-always-refill t)
  185.     (setq latexinfo-always-refill nil))
  186.       (delete-region (point-min) end))
  187.     ;; Remove \end{document} at end of file, if it is there.
  188.     (goto-char (point-max))
  189.     (if (search-backward "\\end{document}" nil t)
  190.     (delete-region (point) (point-max))
  191.       (error "Missing \\end{document}"))
  192.     ;; Make sure buffer ends in a newline.
  193.     (or (= (preceding-char) ?\n)
  194.     (insert "\n"))
  195.     ;; Scan the whole buffer, converting to Info format.
  196.     (goto-char (point-min))
  197.     (latexinfo-format-scan-noverbatim)
  198.     ;; Return data for indices.
  199.     (goto-char (point-min))
  200.     (list outfile
  201.       latexinfo-cindex latexinfo-vindex latexinfo-findex 
  202.       latexinfo-pindex latexinfo-tindex latexinfo-kindex
  203.           latexinfo-refindex)
  204.     ))
  205.  
  206. (defvar latexinfo-region-buffer-name "*Info Region*"
  207.   "*Name of the temporary buffer used by \\[latexinfo-format-region].")
  208.  
  209. (defun latexinfo-format-region (region-beginning region-ending)
  210.   "Convert the the current region of the Latexinfo file to Info format.
  211. This lets you see what that part of the file will look like in Info.
  212. The command is bound to \\[latexinfo-format-region].  The text that is
  213. converted to Info is stored in a temporary buffer."
  214.   (interactive "r")
  215.   (message "Converting region to Info format...")
  216.   (let (latexinfo-command-start
  217.     latexinfo-command-end
  218.     latexinfo-command-name
  219.     latexinfo-vindex
  220.     latexinfo-findex
  221.     latexinfo-cindex
  222.     latexinfo-pindex
  223.     latexinfo-tindex
  224.     latexinfo-kindex
  225.     latexinfo-refindex
  226.     latexinfo-stack
  227.     latexinfo-format-filename
  228.     latexinfo-example-start
  229.     latexinfo-last-node-pos
  230.     latexinfo-last-node
  231.     latexinfo-node-names
  232.     (latexinfo-table-number 0)
  233.     (latexinfo-footnote-number 0)
  234.     (fill-column (1- fill-column))
  235.     (input-buffer (current-buffer))
  236.     (input-directory default-directory)
  237.     filename-beginning
  238.     filename-ending)
  239.  
  240.     ;; Find a buffer to use.
  241.     (switch-to-buffer (get-buffer-create latexinfo-region-buffer-name))
  242.     ;; Insert the region into the buffer.
  243.     (erase-buffer)
  244.  
  245.     (save-excursion
  246.       (set-buffer input-buffer)
  247.       (save-excursion
  248.     (save-restriction
  249.       (widen)
  250.       (goto-char (point-min))
  251.       ;; Initialize the buffer with the filename
  252.       ;; or else explain that a filename is needed.
  253.       (or (re-search-forward "^\\\\setfilename"
  254.                  (save-excursion (forward-line 100) (point)) t)
  255.           (error "The latexinfo file needs a line saying: \\setfilename <name>"))
  256.       (beginning-of-line)
  257.       (setq filename-beginning (point))
  258.       (forward-line 1)
  259.       (setq filename-ending (point)))))
  260.  
  261.     ;; Insert the \\setfilename line into the buffer.
  262.     (insert-buffer-substring input-buffer
  263.                  (min filename-beginning region-beginning)  
  264.                  filename-ending)
  265.     
  266.     ;; Insert the region into the buffer.
  267.     (insert-buffer-substring input-buffer
  268.                  (max region-beginning filename-ending)
  269.                  region-ending)
  270.  
  271.     (latexinfo-mode)
  272.  
  273.     ;; Install a syntax table useful for scanning command operands.
  274.     (set-syntax-table latexinfo-format-syntax-table)
  275.     
  276.     ;; If the region includes the effective end of the data,
  277.     ;; discard everything after that.
  278.     (goto-char (point-max))
  279.     (if (search-backward "\\end{document}" nil t)
  280.     (delete-region (point) (point-max)))
  281.     ;; Make sure buffer ends in a newline.
  282.     (or (= (preceding-char) ?\n)
  283.     (insert "\n"))
  284.     (goto-char (point-max))
  285.     ;; Now convert for real.
  286.     (goto-char (point-min))
  287.     (latexinfo-format-scan-noverbatim)
  288.     (goto-char (point-min)))
  289.   )
  290.  
  291. ;; Only look at the beginning of the line to avoid \c \input{foo}
  292. (defvar latexinfo-special-regexp 
  293.   "^[ \t]*\\\\\\(begin{verbatim}\\|begin{smallverbatim}\\|verb\\|input{\\)")
  294.  
  295. (defun latexinfo-format-scan-noverbatim ()
  296.   (if (re-search-forward latexinfo-special-regexp nil t)
  297.       (let ((start (point-min))
  298.         (end nil)
  299.         str)
  300.     (goto-char start)
  301.     (while (re-search-forward latexinfo-special-regexp nil t)
  302.       (setq str (buffer-substring (match-beginning 0) (match-end 0)))
  303.       ;; Handle LaTeX \input{filename} commands by inserting them now.
  304.       ;; Only look at the beginning of the line to avoid \c \input{foo}
  305.       ;; Protect the verbatim areas from global substitutions.
  306.       (cond 
  307.        ((string-equal str "\\input{")
  308.         (latexinfo-insert-input-files)
  309.         )
  310.        ((string-equal str "\\begin{verbatim}")
  311.         (setq end (point))
  312.         (latexinfo-do-global-substitutions start end)
  313.         (re-search-forward "\\\\end{verbatim}" nil nil) 
  314.         (setq start (point))
  315.         )
  316.        ((string-equal str "\\begin{smallverbatim}")
  317.         (setq end (point))
  318.         (latexinfo-do-global-substitutions start end)
  319.         (re-search-forward "\\\\end{smallverbatim}" nil nil) 
  320.         (setq start (point))
  321.         )
  322.        ((string-equal str "\\verb")
  323.         (setq end (point))
  324.         (latexinfo-do-global-substitutions start end)
  325.         (setq str (buffer-substring (point) (1+ (point))))
  326.         (forward-char 1)
  327.         (search-forward str nil nil) 
  328.         (forward-char 1)
  329.         (setq start (point))
  330.         )
  331.        )
  332.       )
  333.     (if end (latexinfo-do-global-substitutions start (point-max)))
  334.     )
  335.     (latexinfo-do-global-substitutions (point-min) (point-max))
  336.     )
  337.   (latexinfo-format-scan))
  338.  
  339. (defun latexinfo-insert-input-files ()
  340.   (save-excursion
  341.     ;;    (skip-chars-forward " \t{")
  342.     (let ((file-name
  343.        (buffer-substring 
  344.         (point)
  345.         (progn (skip-chars-forward "^     }\n")
  346.            (point))))
  347.       (dirlist latexinfo-texinputs)
  348.       (the-file nil))
  349.       (while (and (not the-file) dirlist)
  350.     (let ((dir (car dirlist)))
  351.       (setq the-file  
  352.         (cond ((file-readable-p (expand-file-name
  353.                      file-name dir))
  354.                (expand-file-name file-name dir))
  355.               ((file-readable-p (expand-file-name
  356.                      (concat file-name ".tex") dir))
  357.                (expand-file-name
  358.             (concat file-name ".tex") dir))
  359.               (t nil)
  360.               ))
  361.       (setq dirlist (cdr dirlist))))
  362.       (setq file-name the-file)
  363.       (beginning-of-line 1)
  364.       (if (file-readable-p file-name)
  365.       (progn
  366.         (delete-region (point) (progn (forward-line 1) (point)))
  367.         (message "Inserting file %s..." file-name) (sit-for 1)
  368.         (insert-file file-name)
  369.         (message "Inserting file %s...done" file-name))
  370.     (error "I can't find the file %s" file-name))
  371.       )
  372.     )
  373.   )
  374.  
  375. (defun latexinfo-do-global-substitutions (min max)
  376.   (save-excursion
  377.     (narrow-to-region min max)
  378.     (goto-char (point-min))
  379.     (let ((start nil))
  380.       (while (re-search-forward "^\\\\begin{ignore}" nil t)
  381.     (beginning-of-line 1)
  382.     (setq start (point))
  383.     (re-search-forward "^\\\\end{ignore}" nil)
  384.     (forward-line 1)
  385.     (delete-region start (point))))
  386.     ;; LaTeX sometimes uses \\ to force a new-line
  387.     (goto-char (point-min))
  388.     (quietly-replace-regexp "\\\\\\\\$" "")
  389.     ;; Convert left and right quotes to typewriter font quotes.
  390.     (goto-char (point-min))
  391.     (while (search-forward "``" nil t)
  392.       (replace-match "\""))
  393.     (goto-char (point-min))
  394.     (while (search-forward "''" nil t)
  395.       (replace-match "\""))
  396.     (if latexinfo-always-refill
  397.     (latexinfo-do-refill)
  398.       )
  399.     (widen)
  400.     )
  401.   )
  402.  
  403. (defun latexinfo-do-refill ()
  404.   (let ((start (point-min))
  405.     (end nil))
  406.     (goto-char start)
  407.     (while (re-search-forward "^\\\\begin{menu}" nil t)
  408.       (narrow-to-region start (point))
  409.       ;; Would a regexp be too slow?
  410.       (goto-char (point-min))
  411.       (quietly-replace-string ".\n\n" ".\\refill\n\n" nil)
  412.       (goto-char (point-min))
  413.       (quietly-replace-string ":\n\n" ":\\refill\n\n" nil)
  414.       (goto-char (point-min))
  415.       (quietly-replace-string ".\n\\end" ".\\refill\n\\end" nil)
  416.       (narrow-to-region min max)
  417.       (re-search-forward "\\\\end{menu}" nil nil) 
  418.       (setq start (point))
  419.       )
  420.     )
  421.   )
  422.  
  423. (defun latexinfo-format-scan ()
  424.   ;; Scan for \\-commands.
  425.   (set-syntax-table latexinfo-format-syntax-table)
  426.   (goto-char (point-min))
  427.   (let ((foochar nil))
  428.     (while (search-forward "\\" nil t)
  429.     ;;; EMACS BUG (looking-at "[*{}^'` \t---.:%\"\\\\]") TRUE for &
  430.       ;; Handle a few special \-followed-by-one-char commands.
  431.       (setq foochar (following-char))
  432.       (cond ((memq foochar '(?* ?\\ ?- ?:))
  433.          ;; \* has no effect, since we are not filling.
  434.          ;; \" can't be reproduced on ascii terminals
  435.          (delete-region (1- (point)) (1+ (point))))
  436.         ((memq foochar '(?^ ?' ?` ?\"))
  437.          (latexinfo-parse-accent))
  438.         ((memq foochar '(?* ?\{ ?} ?^ ?\  ?\t ?\. ?: ?% ?\\))
  439.          ;; The other characters are simply quoted.  Delete the \.
  440.          (delete-char -1)
  441.          (forward-char 1))
  442.         (t
  443.          ;; \ is followed by a command-word; find the end of the word.
  444.          (setq latexinfo-command-start (1- (point)))
  445.          ;; (if (= (char-syntax (following-char)) ?w) . (forward-char 1))
  446.         (forward-word 1)
  447.         (setq latexinfo-command-end (point))
  448.         ;; Call the handler for this command.
  449.         (setq latexinfo-command-name
  450.           (intern (buffer-substring (1+ latexinfo-command-start)
  451.                         latexinfo-command-end)))
  452.         (let ((cmd (get latexinfo-command-name 'latexinfo-format)))
  453.           (if cmd (funcall cmd)
  454.         (latexinfo-unsupported))))
  455.       )
  456.     )
  457.   (cond (latexinfo-stack
  458.      (goto-char (nth 2 (car latexinfo-stack)))
  459.      (error "Unterminated \\begin{%s}" (car (car latexinfo-stack)))))
  460.   )
  461. )
  462.  
  463. (defun latexinfo-parse-accent ()
  464.   (latexinfo-delete-whitespace)
  465.   (cond ((looking-at ".{")
  466.      (delete-region (1- (point)) (+ 2 (point)))
  467.      (skip-chars-forward "^}")
  468.      (delete-char 1)        ; }
  469.      )
  470.     (t                ; this should not happen
  471.      (delete-region (1- (point)) (1+ (point)))        ; \c
  472.      )
  473.     )
  474.   )
  475.  
  476. (put 'begin 'latexinfo-format 'latexinfo-format-begin)
  477. (defun latexinfo-format-begin ()
  478.   (latexinfo-format-begin-end 'latexinfo-format))
  479.  
  480. (put 'end 'latexinfo-format 'latexinfo-format-end)
  481. (defun latexinfo-format-end ()
  482.   (latexinfo-format-begin-end 'latexinfo-end))
  483.  
  484. (defun latexinfo-format-begin-end (prop)
  485.   (setq latexinfo-command-name (intern (latexinfo-parse-line-arg)))
  486.   (setq cmd (get latexinfo-command-name prop))
  487.   (if cmd (funcall cmd)
  488.     (latexinfo-unsupported)))
  489.  
  490. (defvar latexinfo-format-syntax-table-a nil)
  491.  
  492. (progn
  493.   (setq latexinfo-format-syntax-table-a 
  494.     (copy-syntax-table latexinfo-format-syntax-table))
  495.   (modify-syntax-entry ?\[ "." latexinfo-format-syntax-table-a)
  496.   (modify-syntax-entry ?\] "." latexinfo-format-syntax-table-a)
  497.   )
  498.  
  499. ;;Fundamental change
  500. (defun safe-forward-list (arg)
  501.   (cond ((string-equal "}" arg)
  502.      (set-syntax-table latexinfo-format-syntax-table-a)
  503.      (forward-sexp 1)
  504.      (set-syntax-table latexinfo-format-syntax-table)
  505.      )
  506.     ((string-equal "]" arg)
  507.      (forward-list 1))
  508.     (t (forward-list 1))
  509.     )
  510.   )
  511.  
  512. (defun latexinfo-parse-line-arg ()
  513.   "Returns the command that takes up the rest of the line."
  514.   (goto-char latexinfo-command-end)
  515.   (let ((start (point)))
  516.     (cond ((looking-at " ")
  517.        (skip-chars-forward " ")
  518.        (setq start (point))
  519.        (end-of-line)
  520.            (skip-chars-backward " ")
  521.            (delete-region (point) (progn (end-of-line) (point)))
  522.        (setq latexinfo-command-end (1+ (point))))
  523.       ((looking-at "{")
  524.        (setq start (1+ (point)))
  525.        (safe-forward-list "}")
  526.        (setq latexinfo-command-end (point))
  527.        (forward-char -1))
  528.       ((looking-at "\\[")
  529.        (setq start (1+ (point)))
  530.        (safe-forward-list "]")
  531.        (setq latexinfo-command-end (point))
  532.        (forward-char -1))
  533.       (t
  534.        (error "Invalid latexinfo command arg format")))
  535.     (prog1 (buffer-substring start (point))
  536.        (if (eolp) (forward-char 1)))))
  537.  
  538. (defun latexinfo-parse-expanded-arg ()
  539.   (goto-char latexinfo-command-end)
  540.   (let ((start (point))
  541.     marker)
  542.     (cond ((looking-at " ")
  543.        (skip-chars-forward " ")
  544.        (setq start (point))
  545.        (end-of-line)
  546.        (setq latexinfo-command-end (1+ (point))))
  547.       ((or (looking-at "{") (looking-at "\\["))
  548.        (setq start (1+ (point)))
  549.        (forward-list 1)
  550.        (setq latexinfo-command-end (point))
  551.        (forward-char -1))
  552.       (t
  553.        (error "Invalid latexinfo command arg format")))
  554.     (setq marker (move-marker (make-marker) latexinfo-command-end))
  555.     (latexinfo-format-expand-region start (point))
  556.     (setq latexinfo-command-end (marker-position marker))
  557.     (move-marker marker nil)
  558.     (prog1 (buffer-substring start (point))
  559.        (if (eolp) (forward-char 1)))))
  560.  
  561. (defun latexinfo-parse-arg-discard ()
  562.   (prog1 (latexinfo-parse-line-arg)
  563.      (latexinfo-discard-command)))
  564.  
  565. (defun latexinfo-discard-command ()
  566.   ;;LaTeX gobbles the next whitespace. Should Info?
  567.   (delete-region latexinfo-command-start latexinfo-command-end))
  568.  
  569. (defun latexinfo-parse-noarg ()
  570.   (goto-char latexinfo-command-end)
  571.   (cond ((looking-at "{}") (delete-char 2))
  572.     ;; TeX gobbles the next whitespace.
  573.     ((eolp) (delete-char 1))
  574.     ((looking-at "[ \t]")
  575.      (setq latexinfo-command-end
  576.             (save-excursion
  577.               (skip-chars-forward " \t") (point))))
  578.     )
  579.   (delete-region latexinfo-command-start latexinfo-command-end)
  580.   )
  581.  
  582. ;; New parsing functions
  583. (defun latexinfo-parse-required-argument ()
  584.   ;; TeX gobbles the next whitespace.
  585.   (goto-char latexinfo-command-end)
  586.   (latexinfo-delete-whitespace)
  587.   (cond ((looking-at "{")
  588.      (setq latexinfo-command-end
  589.            (save-excursion
  590.          (forward-sexp 1) (point))))
  591.     (t (error "latexinfo-parse-required-argument: no argument provided"))
  592.     )
  593.   (prog1 (buffer-substring (1+ (point)) (1- latexinfo-command-end))
  594.     (latexinfo-delete-command ))
  595.   )
  596.  
  597. (defun latexinfo-delete-whitespace ()
  598.   (if (looking-at "[ \t\n]")
  599.       (delete-region (point) (save-excursion 
  600.                    (skip-chars-forward " \t\n")
  601.                    (point)))))
  602.  
  603. (defun latexinfo-insert-required-argument ()
  604.   (save-excursion (insert (latexinfo-parse-required-argument))))
  605.  
  606. (defun latexinfo-delete-command ()
  607.   (delete-region latexinfo-command-start latexinfo-command-end))
  608.  
  609. (defun latexinfo-format-expand-region (start end)
  610.   (save-restriction
  611.     (narrow-to-region start end)
  612.     (let (latexinfo-command-start
  613.       latexinfo-command-end
  614.       latexinfo-command-name
  615.       latexinfo-stack)
  616.       (latexinfo-format-scan))
  617.     (goto-char (point-max))))
  618.  
  619. (defun latexinfo-format-parse-line-args ()
  620.   (let ((start (1- (point)))
  621.     next beg end
  622.     args)
  623.     (skip-chars-forward " ")
  624.     (while (not (eolp))
  625.       (setq beg (point))
  626.       (re-search-forward "[\n,]")
  627.       (setq next (point))
  628.       (if (bolp) (setq next (1- next)))
  629.       (forward-char -1)
  630.       (skip-chars-backward " ")
  631.       (setq end (point))
  632.       (setq args (cons (if (> end beg) (buffer-substring beg end))
  633.                args))
  634.       (goto-char next)
  635.       (skip-chars-forward " "))
  636.     (if (eolp) (forward-char 1))
  637.     (setq latexinfo-command-end (point))
  638.     (nreverse args)))
  639.  
  640. (defun latexinfo-format-parse-args ()
  641.   (let ((start (1- (point)))
  642.     next beg end
  643.     args)
  644.     (search-forward "{")
  645.     (while (/= (preceding-char) ?\})
  646.       (skip-chars-forward " \t\n")
  647.       (setq beg (point))
  648.       (re-search-forward "[},]")
  649.       (setq next (point))
  650.       (forward-char -1)
  651.       (skip-chars-backward " \t\n")
  652.       (setq end (point))
  653.       (cond ((< beg end)
  654.          (goto-char beg)
  655.          (while (search-forward "\n" end t)
  656.            (replace-match " "))))
  657.       (setq args (cons (if (> end beg) (buffer-substring beg end))
  658.                args))
  659.       (goto-char next))
  660.     (if (eolp) (forward-char 1))
  661.     (setq latexinfo-command-end (point))
  662.     (nreverse args)))
  663.  
  664.  
  665.  
  666. (put 'document 'latexinfo-format 'latexinfo-discard-line)
  667. (put 'document 'latexinfo-end 'latexinfo-discard-line)
  668.  
  669. (put 'setfilename 'latexinfo-format 'latexinfo-format-setfilename)
  670. (defun latexinfo-format-setfilename ()
  671.   (let ((arg (latexinfo-parse-arg-discard)))
  672.     (setq latexinfo-format-filename
  673.       (file-name-nondirectory (expand-file-name arg)))
  674.     (insert "Info file: "
  675.         latexinfo-format-filename ",    -*-Text-*-\n"
  676.         "produced by latexinfo-format-buffer\nfrom "
  677.         (if (buffer-file-name input-buffer)
  678.         (concat "file: "
  679.             (file-name-sans-versions
  680.              (file-name-nondirectory
  681.               (buffer-file-name input-buffer))))
  682.           (concat "buffer " (buffer-name input-buffer)))
  683.         "\n\n")))
  684.  
  685. (put 'node 'latexinfo-format 'latexinfo-format-node)
  686. (defun latexinfo-format-node ()
  687.   (let* ((args (latexinfo-format-parse-line-args))
  688.      (name (nth 0 args))
  689.      (next (nth 1 args))
  690.      (prev (nth 2 args))
  691.      (up (nth 3 args)))
  692.     (latexinfo-discard-command)
  693.     (setq latexinfo-last-node name)
  694.     (let ((tem (downcase name)))
  695.       (if (assoc tem latexinfo-node-names)
  696.       (error "Duplicate node name: %s" name)
  697.     (setq latexinfo-node-names (cons tem latexinfo-node-names))))
  698.     (or (bolp)
  699.     (insert ?\n))
  700.     (insert "\^_\nFile: " latexinfo-format-filename
  701.         "  Node: " name)
  702.     (if prev
  703.     (insert ", Prev: " prev))
  704.     (if up
  705.     (insert ", Up: " up))
  706.     (if next
  707.     (insert ", Next: " next))
  708.     (insert ?\n)
  709.     (setq latexinfo-last-node-pos (point))
  710.     ))
  711.  
  712. (put 'menu 'latexinfo-format 'latexinfo-format-menu)
  713. (defun latexinfo-format-menu ()
  714.   (latexinfo-discard-line)
  715.   (insert "* Menu:\n\n"))
  716.  
  717. (put 'menu 'latexinfo-end 'latexinfo-discard-command)
  718.  
  719. (defun latexinfo-discard-line ()
  720.   (goto-char latexinfo-command-end)
  721.   (skip-chars-forward " \t")
  722.   (or (eolp)
  723.       (error "Extraneous text at end of command line."))
  724.   (delete-region latexinfo-command-start (progn (forward-line 1) (point))))
  725.  
  726. (defun latexinfo-discard-to-eoline ()
  727.   (goto-char latexinfo-command-end)
  728.   (skip-chars-forward " \t")
  729.   (or (eolp)
  730.       (error "Extraneous text at end of command line."))
  731.   (delete-region latexinfo-command-start (point)))
  732.  
  733. ; \xref {NODE, FNAME, NAME, FILE, DOCUMENT}
  734. ; -> *Note FNAME: (FILE)NODE
  735. ;   If FILE is missing,
  736. ;    *Note FNAME: NODE
  737. ;   If FNAME is empty and NAME is present
  738. ;    *Note NAME: Node
  739. ;   If both NAME and FNAME are missing
  740. ;    *Note NODE::
  741. ;   latexinfo ignores the DOCUMENT argument.
  742. ; -> See section <xref to NODE> [NAME, else NODE], page <xref to NODE>
  743. ;   If FILE is specified, (FILE)NODE is used for xrefs.
  744. ;   If fifth argument DOCUMENT is specified, produces
  745. ;    See section <xref to NODE> [NAME, else NODE], page <xref to NODE>
  746. ;    of DOCUMENT
  747. ; \nxref is a reference that does not put `See' or `see' in
  748. ;                  the hardcopy and is the same as \xref in Info
  749.  
  750. (put 'nxref 'latexinfo-format 'latexinfo-format-xref)
  751. (put 'xref 'latexinfo-format 'latexinfo-format-xref)
  752. (defun latexinfo-format-xref ()
  753.   (let ((args (latexinfo-format-parse-args)))
  754.     (latexinfo-discard-command)
  755.     (insert "*Note ")
  756.     (let ((fname (or (nth 1 args) (nth 2 args))))
  757.       (if (null (or fname (nth 3 args)))
  758.       (insert (car args) "::")
  759.     (insert (or fname (car args)) ": ")
  760.     (if (nth 3 args)
  761.         (insert "(" (nth 3 args) ")"))
  762.     (insert (car args))))))
  763.  
  764. (put 'pxref 'latexinfo-format 'latexinfo-format-pxref)
  765. (defun latexinfo-format-pxref ()
  766.   (latexinfo-format-xref)
  767.   (or (save-excursion
  768.     (forward-char -2)
  769.     (looking-at "::"))
  770.       (insert ".")))
  771.  
  772. ;\inforef{NODE, FNAME, FILE}
  773. ;Like \xref{NODE, FNAME,,FILE} in latexinfo.
  774. ;In LaTeX, generates "See Info file FILE, node NODE"
  775. (put 'inforef 'latexinfo-format 'latexinfo-format-inforef)
  776. (defun latexinfo-format-inforef ()
  777.   (let ((args (latexinfo-format-parse-args)))
  778.     (latexinfo-discard-command)
  779.     (if (nth 1 args)
  780.         (insert "*Note " (nth 1 args) ": (" (nth 2 args) ")" (car args))
  781.       (insert "*Note " "(" (nth 2 args) ")" (car args) "::"))))
  782.  
  783. (put 'appendix 'latexinfo-format 'latexinfo-parse-noarg)
  784. (put 'onecolumn 'latexinfo-format 'latexinfo-parse-noarg)
  785. (put 'twocolumn 'latexinfo-format 'latexinfo-parse-noarg)
  786. ;;(put 'threecolumn 'latexinfo-format 'latexinfo-parse-noarg)
  787.  
  788. (put 'chapter 'latexinfo-format 'latexinfo-format-chapter)
  789. (put 'chapter* 'latexinfo-format 'latexinfo-format-chapter)
  790. (put 'unnumbered 'latexinfo-format 'latexinfo-format-chapter)
  791. (defun latexinfo-format-chapter ()
  792.   (latexinfo-format-chapter-1 ?*))
  793.  
  794. (put 'section 'latexinfo-format 'latexinfo-format-section)
  795. (put 'section* 'latexinfo-format 'latexinfo-format-section)
  796. (put 'unnumberedsec 'latexinfo-format 'latexinfo-format-section)
  797. (defun latexinfo-format-section ()
  798.   (latexinfo-format-chapter-1 ?=))
  799.  
  800. (put 'subsection 'latexinfo-format 'latexinfo-format-subsection)
  801. (put 'subsection* 'latexinfo-format 'latexinfo-format-subsection)
  802. (put 'unnumberedsubsec 'latexinfo-format 'latexinfo-format-subsection)
  803. (defun latexinfo-format-subsection ()
  804.   (latexinfo-format-chapter-1 ?-))
  805.  
  806. (put 'subsubsection 'latexinfo-format 'latexinfo-format-subsubsection)
  807. (put 'subsubsection* 'latexinfo-format 'latexinfo-format-subsubsection)
  808. (put 'unnumberedsubsubsec 'latexinfo-format 'latexinfo-format-subsubsection)
  809. (defun latexinfo-format-subsubsection ()
  810.   (latexinfo-format-chapter-1 ?.))
  811.  
  812. (defun latexinfo-format-chapter-1 (belowchar)
  813.   (let ((arg (latexinfo-parse-arg-discard)))
  814.     (message "Formatting: %s ... " arg)    ; So we can see where we are.
  815.     (insert ?\n arg ?\n "\\SectionPAD " belowchar ?\n)
  816.     (if (not (looking-at "\n")) (insert "\n"))
  817.     (goto-char latexinfo-command-start)))
  818.  
  819. (put 'SectionPAD 'latexinfo-format 'latexinfo-format-sectionpad)
  820. (defun latexinfo-format-sectionpad ()
  821.   (let ((str (latexinfo-parse-arg-discard)))
  822.     (forward-char -1)
  823.     (let ((column (current-column)))
  824.       (forward-char 1)
  825.       (while (> column 0)
  826.     (insert str)
  827.     (setq column (1- column))))
  828.     (insert ?\n)
  829.     (if (not (looking-at "\n")) (insert "\n"))
  830. ))
  831.  
  832. (put 'paragraph 'latexinfo-format 'latexinfo-format-var)
  833. (put 'subparagraph 'latexinfo-format 'latexinfo-format-noop)
  834. (put 'paragraph* 'latexinfo-format 'latexinfo-format-var)
  835. (put 'subparagraph* 'latexinfo-format 'latexinfo-format-noop)
  836.  
  837. (put '\. 'latexinfo-format 'latexinfo-format-\.)
  838. (defun latexinfo-format-\. ()
  839.   (latexinfo-discard-command)
  840.   (insert "."))
  841.  
  842. (put '\\ 'latexinfo-format 'latexinfo-format-\\)
  843. (defun latexinfo-format-\\ ()
  844.   (latexinfo-discard-command)
  845.   (insert "\n"))
  846.  
  847. (put '\: 'latexinfo-format 'latexinfo-format-\:)
  848. (defun latexinfo-format-\: ()
  849.   (latexinfo-discard-command))
  850.  
  851. (put '_ 'latexinfo-format 'latexinfo-format-_)
  852. (defun latexinfo-format-_ ()
  853.   (latexinfo-parse-noarg)
  854.   (insert "_"))
  855.  
  856. (put '$ 'latexinfo-format 'latexinfo-format-$)
  857. (defun latexinfo-format-$ ()
  858.   (latexinfo-parse-noarg)
  859.   (insert "$"))
  860.  
  861. (put '@ 'latexinfo-format 'latexinfo-format-@)
  862. (defun latexinfo-format-@ ()
  863.   (latexinfo-parse-noarg)
  864.   (insert "@"))
  865.  
  866. (put '~ 'latexinfo-format 'latexinfo-format-~)
  867. (defun latexinfo-format-~ ()
  868.   (latexinfo-parse-noarg)
  869.   (insert "~"))
  870.  
  871. (put '^ 'latexinfo-format 'latexinfo-format-^)
  872. (defun latexinfo-format-^ ()
  873.   (latexinfo-parse-noarg)
  874.   (insert "^"))
  875.  
  876. (put '/ 'latexinfo-format 'latexinfo-format-/)
  877. (defun latexinfo-format-/ ()
  878.   (latexinfo-parse-noarg))
  879.  
  880. (put '\  'latexinfo-format 'latexinfo-format-space)
  881. (defun latexinfo-format-space ()
  882.   (latexinfo-parse-noarg)
  883.   (insert "    "))
  884.  
  885. ;; Use \tie when you need one.
  886. (put 'tie 'latexinfo-format 'latexinfo-format-tie)
  887. (defun latexinfo-format-tie ()
  888.   (latexinfo-parse-noarg)
  889.   (insert " "))
  890.  
  891. (put 'sp 'latexinfo-format 'latexinfo-format-sp)
  892. (defun latexinfo-format-sp ()
  893.   (let ((arg (read (latexinfo-parse-expanded-arg))))
  894.     (latexinfo-discard-command)
  895.     ;; Delete eol if the space command is the only thing on a line
  896.     (if (and (eolp) (bolp) (not (eobp))) (delete-char 1))
  897.     (while (> arg 0)
  898.       (insert "\n")
  899.       (setq arg (1- arg)))))
  900.  
  901. ;;; \footnote  and  \footnotestyle
  902.  
  903. ; In Latexinfo, footnotes are created with the `\footnote' command.
  904. ; This command is followed immediately by a left brace, then by the text of
  905. ; the footnote, and then by a terminating right brace.  The
  906. ; template for a footnote is:
  907. ; 
  908. ;      \footnote{TEXT}
  909. ;
  910. ; Info has two footnote styles:
  911. ; 
  912. ;    * In the End of node style, all the footnotes for a single node
  913. ;      are placed at the end of that node.  The footnotes are
  914. ;      separated from the rest of the node by a line of dashes with
  915. ;      the word `Footnotes' within it.
  916. ; 
  917. ;    * In the Separate node style, all the footnotes for a single node
  918. ;      are placed in an automatically constructed node of their own.
  919.  
  920. ; Footnote style is specified by the \footnotestyle command, either
  921. ;    \footnotestyle{separate}
  922. ; or
  923. ;    \footnotestyle{end}
  924. ; 
  925. ; The default is  separate
  926.  
  927. (defvar latexinfo-footnote-style "separate" 
  928.   "Footnote style, either separate or end.")
  929.  
  930. (put 'footnotestyle 'latexinfo-format 'latexinfo-footnotestyle)
  931. (defun latexinfo-footnotestyle ()
  932.   "Specify whether footnotes are at end of node or in separate nodes.
  933. Argument is either end or separate."
  934.   (setq latexinfo-footnote-style (latexinfo-parse-arg-discard)))
  935.  
  936. (defvar latexinfo-footnote-number)
  937.  
  938. (put 'footnote 'latexinfo-format 'latexinfo-format-footnote)
  939. (defun latexinfo-format-footnote ()
  940.   "Format a footnote in either end of node or separate node style.
  941. The   latexinfo-footnote-style  variable controls which style is used."
  942.   (setq latexinfo-footnote-number (1+ latexinfo-footnote-number))
  943.   (cond ((string= latexinfo-footnote-style "end")
  944.          (latexinfo-format-end-node))
  945.         ((string= latexinfo-footnote-style "separate")
  946.          (latexinfo-format-separate-node))))
  947.  
  948. (defun latexinfo-format-separate-node ()
  949.   "Format footnote in Separate node style, with notes in own node.
  950. The node is constructed automatically."
  951.   (let* (start
  952.          (arg (latexinfo-parse-line-arg))
  953.          (node-name-beginning
  954.           (save-excursion
  955.             (re-search-backward
  956.              "^File: \\w+\\(\\w\\|\\s_\\|\\.\\|,\\)*[ \t]+Node:")
  957.             (match-end 0)))
  958.          (node-name
  959.           (save-excursion
  960.             (buffer-substring
  961.              (progn (goto-char node-name-beginning) ; skip over node command
  962.                     (skip-chars-forward " \t")  ; and over spaces
  963.                     (point))
  964.              (if (search-forward
  965.                   ","
  966.                   (save-excursion (end-of-line) (point)) t) ; bound search
  967.                  (1- (point))
  968.                (end-of-line) (point))))))
  969.     (latexinfo-discard-command)  ; remove or insert whitespace, as needed
  970.     (delete-region (save-excursion (skip-chars-backward " \t\n") (point))
  971.                    (point))
  972.     (insert (format " (%d) (*Note %s-Footnotes::)"
  973.             latexinfo-footnote-number node-name))
  974.     (fill-paragraph nil)
  975.     (save-excursion
  976.     (if (re-search-forward "^\\\\node" nil 'move)
  977.         (forward-line -1))
  978.  
  979.     ;; two cases: for the first footnote, we must insert a node header;
  980.     ;; for the second and subsequent footnotes, we need only insert 
  981.     ;; the text of the  footnote.
  982.  
  983.     (if (save-excursion
  984.          (re-search-backward
  985.           (concat node-name "-Footnotes, Up: ")
  986.           node-name-beginning
  987.           t))
  988.         (progn   ; already at least one footnote
  989.           (setq start (point))
  990.           (insert (format "\n(%d)  %s\n" latexinfo-footnote-number arg))
  991.           (fill-region start (point)))
  992.       ;; else not yet a footnote
  993.       (insert "\n\^_\nFile: "  latexinfo-format-filename
  994.               "  Node: " node-name "-Footnotes, Up: " node-name "\n")
  995.       (setq start (point))
  996.       (insert (format "\n(%d)  %s\n" latexinfo-footnote-number arg))
  997.       (fill-region start (point))))))
  998.  
  999. (defun latexinfo-format-end-node ()
  1000.   "Format footnote in the End of node style, with notes at end of node."
  1001.   (let (start
  1002.         (arg (latexinfo-parse-line-arg)))
  1003.     (latexinfo-discard-command)  ; remove or insert whitespace, as needed
  1004.     (delete-region (save-excursion (skip-chars-backward " \t\n") (point))
  1005.                    (point))
  1006.     (insert (format " (%d) " latexinfo-footnote-number))
  1007.     (fill-paragraph nil)
  1008.     (save-excursion
  1009.       (if (search-forward "\n--------- Footnotes ---------\n" nil t)
  1010.           (progn ; already have footnote, put new one before end of node
  1011.             (if (re-search-forward "^\\\\node" nil 'move)
  1012.                 (forward-line -1))
  1013.             (setq start (point))
  1014.             (insert (format "\n(%d)  %s\n" latexinfo-footnote-number arg))
  1015.             (fill-region start (point)))
  1016.         ;; else no prior footnote
  1017.         (if (re-search-forward "^\\\\node" nil 'move)
  1018.             (forward-line -1))
  1019.         (insert "\n--------- Footnotes ---------\n")
  1020.         (setq start (point))
  1021.         (insert (format "\n(%d)  %s\n" latexinfo-footnote-number arg))))))
  1022.  
  1023.  
  1024. ;; \begin{itemize} pushes (itemize "COMMANDS" STARTPOS) on latexinfo-stack.
  1025. ;; \begin{enumerate} pushes (enumerate 0 STARTPOS).
  1026. ;; \item dispatches to the latexinfo-item prop of the first elt of the list.
  1027. ;; For itemize, this puts in and rescans the COMMANDS.
  1028. ;; For enumerate, this increments the number and puts it in.
  1029. ;; In either case, it puts a Backspace at the front of the line
  1030. ;; which marks it not to be indented later.
  1031. ;; All other lines get indented by 5 when the \end is reached.
  1032.  
  1033. (defvar latexinfo-stack-depth 0
  1034.   "Count of number of unpopped latexinfo-push-stack calls.
  1035. Used by \\refill indenting command to avoid indenting within lists, etc.")
  1036.  
  1037. (defun latexinfo-push-stack (check arg)
  1038.   (setq latexinfo-stack-depth (1+ latexinfo-stack-depth))
  1039.   (setq latexinfo-stack
  1040.     (cons (list check arg latexinfo-command-start)
  1041.           latexinfo-stack)))
  1042.  
  1043. (defun latexinfo-pop-stack (check)
  1044.   (setq latexinfo-stack-depth (1- latexinfo-stack-depth))
  1045.   (if (null latexinfo-stack)
  1046.       (error "Unmatched \\end{%s}" check))
  1047.   (if (not (eq (car (car latexinfo-stack)) check))
  1048.       (error "\\end{%s} matches \\begin{%s}"
  1049.          check (car (car latexinfo-stack))))
  1050.   (prog1 (cdr (car latexinfo-stack))
  1051.      (setq latexinfo-stack (cdr latexinfo-stack))))
  1052.  
  1053. (put 'itemize 'latexinfo-format 'latexinfo-itemize)
  1054. (defun latexinfo-itemize ()
  1055.   (latexinfo-push-stack 'itemize "*")
  1056.   (setq fill-column (- fill-column 5))
  1057.   (latexinfo-discard-line))
  1058.  
  1059. (put 'itemize 'latexinfo-end 'latexinfo-end-itemize)
  1060. (defun latexinfo-end-itemize ()
  1061.   (setq fill-column (+ fill-column 5))
  1062.   (latexinfo-discard-command)
  1063.   (let ((stacktop
  1064.      (latexinfo-pop-stack 'itemize)))
  1065.     (latexinfo-do-itemize (nth 1 stacktop))))
  1066.  
  1067. (put 'enumerate 'latexinfo-format 'latexinfo-enumerate)
  1068. (defun latexinfo-enumerate ()
  1069.   (latexinfo-push-stack 'enumerate 0)
  1070.   (setq fill-column (- fill-column 5))
  1071.   (latexinfo-discard-line))
  1072.  
  1073. (put 'enumerate 'latexinfo-end 'latexinfo-end-enumerate)
  1074. (defun latexinfo-end-enumerate ()
  1075.   (setq fill-column (+ fill-column 5))
  1076.   (latexinfo-discard-command)
  1077.   (let ((stacktop
  1078.      (latexinfo-pop-stack 'enumerate)))
  1079.     (latexinfo-do-itemize (nth 1 stacktop))))
  1080.  
  1081. (put 'center 'latexinfo-format 'latexinfo-format-center)
  1082. (defun latexinfo-format-center ()
  1083.   (latexinfo-push-stack 'center 0)
  1084.   (latexinfo-discard-line))
  1085.  
  1086. (put 'center 'latexinfo-end 'latexinfo-end-center)
  1087. (defun latexinfo-end-center ()
  1088.   (latexinfo-discard-command)
  1089.   (let ((stacktop
  1090.      (latexinfo-pop-stack 'center)))
  1091.     (latexinfo-do-center (nth 1 stacktop))))
  1092.  
  1093. (defun latexinfo-do-center (from)
  1094.   (let ((indent-tabs-mode nil))
  1095.     (if (not (or (eobp) (bolp))) (forward-line 1))
  1096.     (while (progn (forward-line -1)
  1097.           (>= (point) from))
  1098.       (let ((indent-tabs-mode nil))
  1099.     (center-line)))))
  1100.  
  1101. (put 'caption 'latexinfo-format 'latexinfo-caption)
  1102. (defun latexinfo-caption ()
  1103.     (insert
  1104.      (format "Table %d : %s" latexinfo-table-number
  1105.          (latexinfo-parse-arg-discard)))
  1106.     (center-line)
  1107.     (goto-char latexinfo-command-start))
  1108.  
  1109. ;;; Tables and figures
  1110. ;;; & is a special character for the tabular environment.  
  1111. ;;; Use \& if you want to insert an & in a table.
  1112. (put '& 'latexinfo-format 'latexinfo-format-&)
  1113. (defun latexinfo-format-& ()
  1114.   (if (not (assoc 'tabular latexinfo-stack)) ; if we're not inside tabular
  1115.       (progn
  1116.     (latexinfo-parse-noarg)
  1117.     (insert "&"))))
  1118.  
  1119.  
  1120. ;; Math tabular environments are ignored.
  1121. (put 'displaymath 'latexinfo-format 'latexinfo-format-displaymath)
  1122. (put 'displaymath 'latexinfo-end 'latexinfo-discard-command)
  1123. (defun latexinfo-format-displaymath ()
  1124.   (delete-region latexinfo-command-start
  1125.          (progn (re-search-forward "\\\\end[ {]displaymath[ }\n]")
  1126.             (point))))
  1127.  
  1128. (put 'equation 'latexinfo-format 'latexinfo-format-equation)
  1129. (put 'equation 'latexinfo-end 'latexinfo-discard-command)
  1130. (defun latexinfo-format-equation ()
  1131.   (delete-region latexinfo-command-start
  1132.          (progn (re-search-forward "\\\\end[ {]equation[ }\n]")
  1133.             (point))))
  1134.  
  1135. (put 'eqnarray 'latexinfo-format 'latexinfo-format-eqnarray)
  1136. (put 'eqnarray 'latexinfo-end 'latexinfo-discard-command)
  1137. (defun latexinfo-format-eqnarray ()
  1138.   (delete-region latexinfo-command-start
  1139.          (progn (re-search-forward "\\\\end[ {]eqnarray[ }\n]")
  1140.             (point))))
  1141.  
  1142.  
  1143. (put 'array 'latexinfo-format 'latexinfo-format-array)
  1144. (put 'array 'latexinfo-end 'latexinfo-discard-command)
  1145. (defun latexinfo-format-array ()
  1146.   (delete-region latexinfo-command-start
  1147.          (progn (re-search-forward "\\\\end[ {]array[ }\n]")
  1148.             (point))))
  1149.  
  1150.  
  1151.  
  1152. ;;; The tabular environment
  1153. (put 'tabular 'latexinfo-format 'latexinfo-format-tabular)
  1154. (put 'tabular 'latexinfo-end 'latexinfo-end-tabular)
  1155. (defun latexinfo-format-tabular ()
  1156.   (latexinfo-push-stack 'tabular nil)
  1157.   (latexinfo-discard-line-with-args))
  1158.  
  1159. (defun latexinfo-end-tabular ()
  1160.   (latexinfo-discard-command)
  1161.   (let ((stacktop
  1162.      (latexinfo-pop-stack 'tabular)))
  1163.     (latexinfo-do-tabular (nth 1 stacktop))))
  1164.  
  1165. (put 'hline 'latexinfo-format 'latexinfo-format-hline)
  1166. (put 'rule 'latexinfo-format 'latexinfo-format-hline)
  1167. (defun latexinfo-format-hline ()
  1168.     (let ((dashes (make-string fill-column ?-)))
  1169.       (latexinfo-discard-line-with-args)
  1170.       (if (not (bolp)) (insert "\n"))
  1171.       (insert dashes "\n")))
  1172.  
  1173. (defun latexinfo-do-tabular (from)
  1174.   (let ((end (point)))
  1175.     (save-excursion
  1176.       (narrow-to-region from end)
  1177.       (goto-char from)
  1178.       (while (search-forward "&" end t)
  1179.     (if (save-excursion
  1180.           (forward-char -2)
  1181.           (not (looking-at "\\\\")))
  1182.         (progn
  1183.           (delete-char -1)
  1184.           (insert " "))
  1185.       (progn
  1186.         (delete-char -2)
  1187.         (insert "&"))))
  1188.       (goto-char from)
  1189.       (quietly-replace-regexp "\\\\\\\\$" "")
  1190.       (untabify from end)
  1191.       ;; Give it some boundaries to protect from centering
  1192. ;;      (goto-char from)
  1193. ;;      (replace-regexp "^" "| ")
  1194.       (widen)
  1195.       )))
  1196.  
  1197. (put 'table 'latexinfo-format 'latexinfo-format-table)
  1198. (put 'table* 'latexinfo-format 'latexinfo-format-table)
  1199. (put 'table 'latexinfo-end 'latexinfo-discard-command)
  1200. (defun latexinfo-format-table ()
  1201.   (latexinfo-discard-line-with-args)
  1202.   (setq latexinfo-table-number (1+ latexinfo-table-number)))
  1203.  
  1204. ;; Figures are ignored for now
  1205. (put 'figure 'latexinfo-format 'latexinfo-format-figure)
  1206. (put 'figure* 'latexinfo-format 'latexinfo-format-figure)
  1207. (put 'figure 'latexinfo-end 'latexinfo-discard-command)
  1208. (defun latexinfo-format-figure ()
  1209.   (delete-region latexinfo-command-start
  1210.          (progn (re-search-forward "\\\\end[ {]figure[ }]*\n")
  1211.             (point))))
  1212.  
  1213. (put 'description 'latexinfo-format 'latexinfo-description)
  1214. (defun latexinfo-description ()
  1215.   (latexinfo-push-stack 'description "")
  1216.   (setq fill-column (- fill-column 5))
  1217.   (latexinfo-discard-line))
  1218.  
  1219. (put 'description 'latexinfo-end 'latexinfo-end-description)
  1220. (defun latexinfo-end-description ()
  1221.   (setq fill-column (+ fill-column 5))
  1222.   (latexinfo-discard-command)
  1223.   (let ((stacktop
  1224.      (latexinfo-pop-stack 'description)))
  1225.     (latexinfo-do-itemize (nth 1 stacktop))))
  1226.  
  1227. (put 'description 'latexinfo-item 'latexinfo-description-item)
  1228. (defun latexinfo-description-item ()
  1229.   (let ((arg (latexinfo-parse-arg-discard)))
  1230.     (insert ?\b arg "\n     \n"))
  1231.   (forward-line -2))
  1232.  
  1233. ;; At the \end, indent all the lines within the construct
  1234. ;; except those marked with backspace.  FROM says where
  1235. ;; construct started.
  1236. (defun latexinfo-do-itemize (from)
  1237.   (save-excursion
  1238.     (while (progn (forward-line -1)
  1239.           (>= (point) from))
  1240.       (if (= (following-char) ?\b)
  1241.       (save-excursion
  1242.         (delete-char 1)
  1243.         (end-of-line)
  1244.         (delete-char 6))
  1245.     (save-excursion 
  1246.       ;; not  delete trailing whitespace
  1247.       (and nil (if (looking-at "[ \t]")
  1248.                (delete-region (point) 
  1249.                       (progn (skip-chars-forward " \t") 
  1250.                          (point)))))
  1251.       (insert "     "))))))
  1252.  
  1253. (put 'item 'latexinfo-format 'latexinfo-item)
  1254. (defun latexinfo-item ()
  1255.   (funcall (get (car (car latexinfo-stack)) 'latexinfo-item)))
  1256.  
  1257. (put 'itemize 'latexinfo-item 'latexinfo-itemize-item)
  1258. (defun latexinfo-itemize-item ()
  1259.   (latexinfo-parse-noarg)
  1260.   (insert "\b   " (nth 1 (car latexinfo-stack)) " \n")
  1261.   (forward-line -1))
  1262.  
  1263. (put 'enumerate 'latexinfo-item 'latexinfo-enumerate-item)
  1264. (defun latexinfo-enumerate-item ()
  1265.   (latexinfo-parse-noarg)
  1266.   (let ((next (1+ (car (cdr (car latexinfo-stack))))))
  1267.     (setcar (cdr (car latexinfo-stack)) next)
  1268.     (insert ?\b (format "%3d. " next) ?\n))
  1269.   (forward-line -1))
  1270.  
  1271.  
  1272. (put 'ifinfo 'latexinfo-format 'latexinfo-discard-line)
  1273. (put 'ifinfo 'latexinfo-end 'latexinfo-discard-command)
  1274.  
  1275. (put 'iftex 'latexinfo-format 'latexinfo-format-iftex)
  1276. (defun latexinfo-format-iftex ()
  1277.   (delete-region latexinfo-command-start
  1278.          (progn (re-search-forward "\\\\end[ {]iftex[ }\n]")
  1279.             (point))))
  1280.  
  1281. (put 'tex 'latexinfo-format 'latexinfo-format-tex)
  1282. (defun latexinfo-format-tex ()
  1283.   (delete-region latexinfo-command-start
  1284.          (progn (re-search-forward "\\end[ {]tex[     }\n]")
  1285.             (point))))
  1286.  
  1287. (put 'ignore 'latexinfo-format 'latexinfo-format-ignore)
  1288. (defun latexinfo-format-ignore ()
  1289.   (delete-region latexinfo-command-start
  1290.          (progn (re-search-forward "\\\\end[ {]ignore[     }\n]")
  1291.             (point))))
  1292.  
  1293. (put 'endignore 'latexinfo-format 'latexinfo-discard-line)
  1294.  
  1295. (put 'VAR 'latexinfo-format 'latexinfo-format-var)
  1296. (put 'var 'latexinfo-format 'latexinfo-format-var)
  1297. (defun latexinfo-format-var ()
  1298.   (insert (upcase (latexinfo-parse-arg-discard)))
  1299.   (goto-char latexinfo-command-start))
  1300.  
  1301. (put 'b 'latexinfo-format 'latexinfo-format-noop)
  1302. (put 'r 'latexinfo-format 'latexinfo-format-noop)
  1303. (put 'scap 'latexinfo-format 'latexinfo-format-noop)
  1304. (put 'n 'latexinfo-format 'latexinfo-format-noop)
  1305. (put 't 'latexinfo-format 'latexinfo-format-noop)
  1306. (put 'i 'latexinfo-format 'latexinfo-format-noop)
  1307. (put 'key 'latexinfo-format 'latexinfo-format-noop)
  1308. (put 'dmn 'latexinfo-format 'latexinfo-format-noop)
  1309. (put 'w 'latexinfo-format 'latexinfo-format-noop)
  1310.  
  1311. (defun latexinfo-format-noop ()
  1312.   (insert (latexinfo-parse-arg-discard))
  1313.   (goto-char latexinfo-command-start))
  1314.  
  1315. (put 'CODE 'latexinfo-format 'latexinfo-format-code)
  1316. (put 'code 'latexinfo-format 'latexinfo-format-code)
  1317. (put 'samp 'latexinfo-format 'latexinfo-format-code)
  1318. (put 'file 'latexinfo-format 'latexinfo-format-code)
  1319. (put 'kbd 'latexinfo-format 'latexinfo-format-code)
  1320. (defun latexinfo-format-code ()
  1321.   (insert "`" (latexinfo-parse-arg-discard) "'")
  1322.   (goto-char latexinfo-command-start))
  1323.  
  1324. (put 'emph 'latexinfo-format 'latexinfo-format-emph)
  1325. (put 'strong 'latexinfo-format 'latexinfo-format-emph)
  1326. (defun latexinfo-format-emph ()
  1327.   (insert "*" (latexinfo-parse-arg-discard) "*")
  1328.   (goto-char latexinfo-command-start))
  1329.  
  1330. (put 'defn 'latexinfo-format 'latexinfo-format-defn)
  1331. (put 'dfn 'latexinfo-format 'latexinfo-format-defn)
  1332. (defun latexinfo-format-defn ()
  1333.   (insert "\"" (latexinfo-parse-arg-discard) "\"")
  1334.   (goto-char latexinfo-command-start))
  1335.  
  1336. (put 'bullet 'latexinfo-format 'latexinfo-format-bullet)
  1337. (defun latexinfo-format-bullet ()
  1338.   (latexinfo-parse-noarg)
  1339.   (insert "*"))
  1340.  
  1341. (put 'smallexample 'latexinfo-format 'latexinfo-format-example)
  1342. (put 'example 'latexinfo-format 'latexinfo-format-example)
  1343. (put 'quotation 'latexinfo-format 'latexinfo-format-example)
  1344. (put 'quote 'latexinfo-format 'latexinfo-format-example)
  1345. (put 'abstract 'latexinfo-format 'latexinfo-format-example)
  1346. (put 'display 'latexinfo-format 'latexinfo-format-example)
  1347. (defun latexinfo-format-example ()
  1348.   (latexinfo-push-stack 'example nil)
  1349.   (setq fill-column (- fill-column 5))
  1350.   (latexinfo-discard-to-eoline))
  1351.  
  1352. (put 'smallexample 'latexinfo-end 'latexinfo-end-example)
  1353. (put 'example 'latexinfo-end 'latexinfo-end-example)
  1354. (put 'quotation 'latexinfo-end 'latexinfo-end-example)
  1355. (put 'quote 'latexinfo-end 'latexinfo-end-example)
  1356. (put 'abstract 'latexinfo-end 'latexinfo-end-example)
  1357. (put 'display 'latexinfo-end 'latexinfo-end-example)
  1358. (defun latexinfo-end-example ()
  1359.   (setq fill-column (+ fill-column 5))
  1360.   (latexinfo-discard-command)
  1361.   (let ((stacktop
  1362.      (latexinfo-pop-stack 'example)))
  1363.     (latexinfo-do-itemize (nth 1 stacktop))))
  1364.  
  1365.  
  1366. (put 'smalllisp 'latexinfo-format 'latexinfo-format-lisp)
  1367. (put 'lisp 'latexinfo-format 'latexinfo-format-lisp)
  1368. (defun latexinfo-format-lisp ()
  1369.   (latexinfo-push-stack 'lisp nil)
  1370.   (setq fill-column (- fill-column 5))
  1371.   (latexinfo-discard-to-eoline))
  1372.  
  1373. (put 'smalllisp 'latexinfo-end 'latexinfo-end-lisp)
  1374. (put 'lisp 'latexinfo-end 'latexinfo-end-lisp)
  1375. (defun latexinfo-end-lisp ()
  1376.   (setq fill-column (+ fill-column 5))
  1377.   (latexinfo-discard-command)
  1378.   (let ((stacktop
  1379.      (latexinfo-pop-stack 'lisp)))
  1380.     (untabify (nth 1 stacktop) (point))
  1381.     (latexinfo-do-itemize (nth 1 stacktop))))
  1382.  
  1383. (put 'exdent 'latexinfo-format 'latexinfo-format-exdent)
  1384. (defun latexinfo-format-exdent ()
  1385.   (latexinfo-discard-command)
  1386.   (delete-region (point)
  1387.          (progn
  1388.           (skip-chars-forward " ")
  1389.           (point)))
  1390.   (insert ?\b)
  1391.   ;; Cancel out the deletion that latexinfo-do-itemize
  1392.   ;; is going to do at the end of this line.
  1393.   (save-excursion
  1394.     (end-of-line)
  1395.     (insert "\n     ")))
  1396.  
  1397. (put 'smallverbatim 'latexinfo-format 'latexinfo-format-smallverbatim)
  1398. (put 'smallverbatim 'latexinfo-end 'latexinfo-end-smallverbatim)
  1399. (defun latexinfo-end-smallverbatim ()
  1400.   (error "Nested verbatim environments are not supported"))
  1401.  
  1402. (put 'verbatim 'latexinfo-format 'latexinfo-format-verbatim)
  1403. (defun latexinfo-format-verbatim ()
  1404.   (latexinfo-discard-line)
  1405.   (untabify (point)
  1406.         (progn (re-search-forward  "\\\\end{verbatim}" nil nil)
  1407.            (point)))
  1408.   (beginning-of-line 1)
  1409.   (delete-region (point) (save-excursion (forward-line 1) (point))))
  1410.  
  1411. (put 'smallverbatim 'latexinfo-format 'latexinfo-format-smallverbatim)
  1412. (defun latexinfo-format-smallverbatim ()
  1413.   (latexinfo-discard-line)
  1414.   (untabify (point)
  1415.         (progn (re-search-forward  "\\\\end{smallverbatim}" nil nil)
  1416.            (point)))
  1417.   (beginning-of-line 1)
  1418.   (delete-region (point) (save-excursion (forward-line 1) (point))))
  1419.   
  1420.  
  1421. (put 'verbatimfile 'latexinfo-format 'latexinfo-format-verbatimfile)
  1422. (defun latexinfo-format-verbatimfile ()
  1423.   (let ((from (point)))
  1424.     (forward-char 1)
  1425.     (latexinfo-insert-input-files)
  1426.     (untabify (point)
  1427.           (progn     (re-search-forward  "\\\\end{verbatim}" nil nil)
  1428.             (point)))
  1429.     (beginning-of-line 1)
  1430.     (delete-region (point) (save-excursion (forward-line 1) (point)))))
  1431.  
  1432. (put 'smallverbatimfile 'latexinfo-format 'latexinfo-format-smallverbatimfile)
  1433. (defun latexinfo-format-smallverbatimfile ()
  1434.   (let ((from (point)))
  1435.     (forward-char 1)
  1436.     (latexinfo-insert-input-files)
  1437.     (untabify (point)
  1438.           (progn     (re-search-forward  "\\\\end{smallverbatim}" nil nil)
  1439.             (point)))
  1440.     (beginning-of-line 1)
  1441.     (delete-region (point) (save-excursion (forward-line 1) (point)))))
  1442.  
  1443. (put 'verbatim 'latexinfo-end 'latexinfo-end-verbatim)
  1444. (defun latexinfo-end-verbatim ()
  1445.   (error "Nested verbatim environments are not supported"))
  1446.  
  1447. (put 'verb 'latexinfo-format 'latexinfo-format-verb)
  1448. (defun latexinfo-format-verb ()
  1449.   "Handle the LaTeX \\verb command."
  1450.    (delete-region latexinfo-command-start latexinfo-command-end)
  1451.    (let ((the-char (buffer-substring (point) (+ 1 (point)))))
  1452.      (delete-char 1)
  1453.      (skip-chars-forward (concat "^" the-char))
  1454.      (delete-char 1)
  1455.      )
  1456.    )
  1457.  
  1458.  
  1459. ; The \cartouche command is a noop in Info; in a printed manual,
  1460. ; it makes a box with rounded corners.
  1461. (put 'cartouche 'latexinfo-format 'latexinfo-discard-line)
  1462. (put 'cartouche 'latexinfo-end 'latexinfo-discard-command)
  1463.  
  1464. ;;; flushleft and format environments
  1465. ; The flushleft environment command left justifies every line but leaves the
  1466. ; right end ragged.  As far as Info is concerned, \flushleft is a
  1467. ; `do-nothing' command.
  1468. ; The \begin{format} command is similar to \begin{example} except that
  1469. ; it does not indent; this means that in Info, format is similar to flushleft.
  1470.  
  1471. (put 'format 'latexinfo-format 'latexinfo-format-flushleft)
  1472. (put 'flushleft 'latexinfo-format 'latexinfo-format-flushleft)
  1473. (defun latexinfo-format-flushleft ()
  1474.   (latexinfo-discard-line))
  1475.  
  1476. (put 'format 'latexinfo-end 'latexinfo-end-flushleft)
  1477. (put 'flushleft 'latexinfo-end 'latexinfo-end-flushleft)
  1478. (defun latexinfo-end-flushleft ()
  1479.   (latexinfo-discard-command))
  1480.  
  1481.  
  1482. ;;; \begin{flushright}
  1483. ; The \begin{flushright} command right justifies every line but leaves the
  1484. ; left end ragged.  Spaces and tabs at the right ends of lines are
  1485. ; removed so that visible text lines up on the right side.
  1486.  
  1487. (put 'flushright 'latexinfo-format 'latexinfo-format-flushright)
  1488. (defun latexinfo-format-flushright ()
  1489.   (latexinfo-push-stack 'flushright nil)
  1490.   (latexinfo-discard-line))
  1491.  
  1492. (put 'flushright 'latexinfo-end 'latexinfo-end-flushright)
  1493. (defun latexinfo-end-flushright ()
  1494.   (latexinfo-discard-command)
  1495.   (let ((stacktop
  1496.          (latexinfo-pop-stack 'flushright)))
  1497.     (latexinfo-do-flushright (nth 1 stacktop))))
  1498.  
  1499. (defun latexinfo-do-flushright (from)
  1500.   (save-excursion
  1501.     (while (progn (forward-line -1)
  1502.           (>= (point) from))
  1503.       (beginning-of-line)
  1504.       (insert
  1505.        (make-string
  1506.     (- fill-column
  1507.        (save-excursion
  1508.          (end-of-line) 
  1509.          (skip-chars-backward " \t")
  1510.          (delete-region (point) (progn (end-of-line) (point)))
  1511.          (current-column)))  
  1512.     ? )))))
  1513.  
  1514. (put 'beforenoterule 'latexinfo-format 'latexinfo-format-hline)
  1515. (put 'afternoterule 'latexinfo-format 'latexinfo-format-hline)
  1516. (put 'betweennoterule 'latexinfo-format 'latexinfo-format-hline)
  1517.  
  1518. (put 'implementation 'latexinfo-format 'latexinfo-format-note)
  1519. (put 'rationale 'latexinfo-format 'latexinfo-format-note)
  1520. (put 'sideremark 'latexinfo-format 'latexinfo-format-note)
  1521. (put 'note 'latexinfo-format 'latexinfo-format-note)
  1522. (defun latexinfo-format-note ()
  1523.   (latexinfo-push-stack 'example nil)
  1524.   (setq fill-column (- fill-column 5))
  1525.   (latexinfo-discard-line)
  1526. )
  1527.  
  1528. (put 'implementation 'latexinfo-end 'latexinfo-end-note)
  1529. (put 'rationale 'latexinfo-end 'latexinfo-end-note)
  1530. (put 'sideremark 'latexinfo-end 'latexinfo-end-note)
  1531. (put 'note 'latexinfo-end 'latexinfo-end-note)
  1532. (defun latexinfo-end-note ()
  1533.   (setq fill-column (+ fill-column 5))
  1534.   (latexinfo-discard-command)
  1535.   (let ((stacktop
  1536.      (latexinfo-pop-stack 'example)))
  1537.     (latexinfo-do-itemize (nth 1 stacktop)))
  1538. )
  1539.  
  1540. ;;; \ctrl, \TeX, \copyright, \minus, \dots
  1541. (put 'ctrl 'latexinfo-format 'latexinfo-format-ctrl)
  1542. (defun latexinfo-format-ctrl ()
  1543.   (let ((str (latexinfo-parse-arg-discard)))
  1544.     (insert "^" str)))
  1545.     ;;    (insert (logand 31 (aref str 0)))))
  1546.  
  1547. (put 'TeX 'latexinfo-format 'latexinfo-format-TeX)
  1548. (defun latexinfo-format-TeX ()
  1549.   (latexinfo-parse-noarg)
  1550.   (insert "TeX"))
  1551.  
  1552. (put 'copyright 'latexinfo-format 'latexinfo-format-copyright)
  1553. (defun latexinfo-format-copyright ()
  1554.   (latexinfo-parse-noarg)
  1555.   (insert "(C)"))
  1556.  
  1557. (put 'minus 'latexinfo-format 'latexinfo-format-minus)
  1558. (defun latexinfo-format-minus ()
  1559.   (latexinfo-parse-noarg)
  1560.   (insert "-"))
  1561.  
  1562. (put 'DOTS 'latexinfo-format 'latexinfo-format-dots)
  1563. (put 'dots 'latexinfo-format 'latexinfo-format-dots)
  1564. (defun latexinfo-format-dots ()
  1565.   (latexinfo-parse-noarg)
  1566.   (insert "..."))
  1567.  
  1568. ;;; Refilling and indenting:  \refill, \paragraphindent, \noindent
  1569. ;;; Indent only those paragraphs that are refilled as a result of an
  1570. ;;; \refill command.  
  1571.  
  1572. ;    * If the value is `asis', do not change the existing indentation at
  1573. ;      the starts of paragraphs.
  1574.  
  1575. ;    * If the value zero, delete any existing indentation.
  1576.  
  1577. ;    * If the value is greater than zero, indent each paragraph by that
  1578. ;      number of spaces.
  1579.  
  1580. ;;; But do not refill paragraphs with an \refill command that are
  1581. ;;; preceded by \noindent or are part of a table, list, or deffn.
  1582.  
  1583. (defvar latexinfo-paragraph-indent "asis"
  1584.   "Number of spaces for \\refill to indent a paragraph; else to leave as is.")
  1585.  
  1586. (put 'paragraphindent 'latexinfo-format 'latexinfo-paragraphindent)
  1587. (defun latexinfo-paragraphindent ()
  1588.   "Specify the number of spaces for \refill to indent a paragraph.
  1589. Default is to leave the number of spaces as is."
  1590.   (let ((arg  (latexinfo-parse-arg-discard)))
  1591.     (if (string= "asis" arg)
  1592.         (setq latexinfo-paragraph-indent "asis")
  1593.       (setq latexinfo-paragraph-indent (string-to-int arg)))))
  1594.  
  1595. (put 'refill 'latexinfo-format 'latexinfo-format-refill)
  1596. (defun latexinfo-format-refill ()
  1597.   "Refill paragraph. Also, indent first line as set by \\paragraphindent.
  1598. Default is to leave paragraph indentation as is."
  1599.   (latexinfo-discard-command)
  1600.   (forward-paragraph -1)     
  1601.   (if (looking-at "[ \t\n]*$") (forward-line 1))
  1602.   ;; Do not indent if an entry in a list, table, or deffn,
  1603.   ;; or if paragraph is preceded by \noindent.
  1604.   ;; Otherwise, indent
  1605.   (cond 
  1606.    ;; delete a \\noindent line and do not indent paragraph
  1607.    ((save-excursion (forward-line -1)
  1608.                     (looking-at "^\\\\noindent")) 
  1609.     (forward-line -1)
  1610.     (delete-region (point) (progn (forward-line 1) (point))))
  1611.    ;; do nothing if "asis"
  1612.    ((equal latexinfo-paragraph-indent "asis"))
  1613.    ;; do no indenting in list, etc.
  1614.    ((> latexinfo-stack-depth 0))   
  1615.    ;; otherwise delete existing whitespace and indent
  1616.    (t 
  1617.     (delete-region (point) (progn (skip-chars-forward " \t") (point)))
  1618.     (insert (make-string latexinfo-paragraph-indent ? ))))
  1619.   (forward-paragraph 1) 
  1620.   (forward-line -1)
  1621.   (end-of-line)
  1622.   (fill-paragraph nil))
  1623.  
  1624. (put 'noindent 'latexinfo-format 'latexinfo-noindent)
  1625. (defun latexinfo-noindent ()  
  1626.   (save-excursion 
  1627.     (forward-paragraph 1)
  1628.     (if (search-backward "\\refill"
  1629.                             (save-excursion (forward-line -1) (point)) t)
  1630.         () ; leave \noindent command so \refill command knows not to indent
  1631.       ;; else
  1632.       (latexinfo-discard-line))))
  1633.  
  1634.  
  1635. ;; Index generation
  1636.  
  1637. (put 'vindex 'latexinfo-format 'latexinfo-format-vindex)
  1638. (defun latexinfo-format-vindex ()
  1639.   (latexinfo-index 'latexinfo-vindex))
  1640.  
  1641. (put 'cindex 'latexinfo-format 'latexinfo-format-cindex)
  1642. (defun latexinfo-format-cindex ()
  1643.   (latexinfo-index 'latexinfo-cindex))
  1644.  
  1645. (put 'findex 'latexinfo-format 'latexinfo-format-findex)
  1646. (defun latexinfo-format-findex ()
  1647.   (latexinfo-index 'latexinfo-findex))
  1648.  
  1649. (put 'pindex 'latexinfo-format 'latexinfo-format-pindex)
  1650. (defun latexinfo-format-pindex ()
  1651.   (latexinfo-index 'latexinfo-pindex))
  1652.  
  1653. (put 'tindex 'latexinfo-format 'latexinfo-format-tindex)
  1654. (defun latexinfo-format-tindex ()
  1655.   (latexinfo-index 'latexinfo-tindex))
  1656.  
  1657. (put 'kindex 'latexinfo-format 'latexinfo-format-kindex)
  1658. (defun latexinfo-format-kindex ()
  1659.   (latexinfo-index 'latexinfo-kindex))
  1660.  
  1661. (put 'label 'latexinfo-format 'latexinfo-format-refindex)
  1662. (defun latexinfo-format-refindex ()
  1663.   (latexinfo-index 'latexinfo-refindex))
  1664.  
  1665. (defun latexinfo-index (indexvar)
  1666.   (let ((arg (latexinfo-parse-expanded-arg)))
  1667.     (latexinfo-discard-command)
  1668.     ;; Delete eol if the index command is the only thing on a line
  1669.     (if (and (eolp) (bolp) (not (eobp))) (delete-char 1))
  1670.     (set indexvar
  1671.      (cons (list arg
  1672.                      latexinfo-last-node
  1673.                      ;; Region formatting may not provide last node position.
  1674.              (if latexinfo-last-node-pos
  1675.                          (1+ (count-lines latexinfo-last-node-pos (point)))
  1676.                        1))
  1677.            (symbol-value indexvar)))))
  1678.  
  1679. (put 'pageref 'latexinfo-format 'latexinfo-format-ref)
  1680. (put 'ref 'latexinfo-format 'latexinfo-format-ref)
  1681. (defun latexinfo-format-ref ()
  1682.   (latexinfo-format-do-ref 
  1683.    (latexinfo-parse-arg-discard) 'latexinfo-refindex))
  1684.  
  1685. (defun latexinfo-format-do-ref (arg index)
  1686.   (let ((entry (assoc arg (symbol-value index))))
  1687.     (if (and entry (cdr entry) (car (cdr entry)))
  1688.     (insert "*Note " (car (cdr entry)) "::")
  1689.       (let ((entry (assoc arg (symbol-value 
  1690.                    (intern (concat (symbol-name index) "-old"))))))
  1691.     (if (and entry (cdr entry) (car (cdr entry)))
  1692.         (insert "*Note " (car (cdr entry)) "::")
  1693.       (insert "?"))))))
  1694.  
  1695. (defconst latexinfo-indexvar-alist
  1696.   '(("cp" . latexinfo-cindex)
  1697.     ("fn" . latexinfo-findex)
  1698.     ("vr" . latexinfo-vindex)
  1699.     ("tp" . latexinfo-tindex)
  1700.     ("pg" . latexinfo-pindex)
  1701.     ("ky" . latexinfo-kindex)))
  1702.  
  1703. (put 'printindex 'latexinfo-format 'latexinfo-format-printindex)
  1704. (defun latexinfo-format-printindex ()
  1705.   (let ((indexelts (symbol-value
  1706.             (cdr (assoc (latexinfo-parse-arg-discard)
  1707.                 latexinfo-indexvar-alist))))
  1708.     opoint)
  1709.     (insert "\n* Menu:\n\n")
  1710.     (setq opoint (point))
  1711.     (latexinfo-print-index nil indexelts)
  1712.     (if (eq system-type 'vax-vms) 
  1713.     (latexinfo-sort-region opoint (point))
  1714.       (shell-command-on-region opoint (point) "sort -fd" 1))))
  1715.  
  1716. (defun latexinfo-print-index (file indexelts)
  1717.   (while indexelts
  1718.     (if (stringp (car (car indexelts)))
  1719.     (insert "* " (car (car indexelts))
  1720.         ": " (if file (concat "(" file ")") "")
  1721.         (nth 1 (car indexelts)) ".\n")
  1722.       ;; index entries from \include'd file
  1723.       (latexinfo-print-index (nth 1 (car indexelts))
  1724.                (nth 2 (car indexelts))))
  1725.     (setq indexelts (cdr indexelts))))
  1726.  
  1727.  
  1728. ;;;; Lisp Definitions have been moved out into the elisp style.
  1729.  
  1730. ;;; \set, \clear, \ifset, \ifclear
  1731.  
  1732. ;; If a flag is set with \set FLAG, then text between \ifset and \end
  1733. ;; ifset is formatted normally, but if the flag is is cleared with
  1734. ;; \clear FLAG, then the text is not formatted; it is ignored.
  1735.  
  1736. ;; If a flag is cleared with \clear FLAG, then text between \ifclear
  1737. ;; and \end ifclear is formatted normally, but if the flag is is set with
  1738. ;; \set FLAG, then the text is not formatted; it is ignored.  \ifclear
  1739. ;; is the opposite of \ifset.
  1740.  
  1741. (put 'clear 'latexinfo-format 'latexinfo-clear)
  1742. (defun latexinfo-clear ()
  1743.   "Clear the value of the flag."
  1744.   (let ((arg (latexinfo-parse-line-arg)))
  1745.     (if (not (boundp (intern arg)))
  1746.       (error  "\\clear flag `%s' is not defined by a \\set command." arg))
  1747.     (latexinfo-discard-command)
  1748.     (set (intern arg) nil)))
  1749.  
  1750. (put 'set 'latexinfo-format 'latexinfo-set)
  1751. (defun latexinfo-set ()
  1752.   "Set the value of the flag."
  1753.   (let ((arg (latexinfo-parse-arg-discard)))
  1754.     (make-local-variable (intern arg))
  1755.     (set (intern arg) t)))
  1756.  
  1757. (put 'ifset 'latexinfo-end 'latexinfo-discard-command)
  1758. (put 'ifset 'latexinfo-format 'latexinfo-if-set)
  1759. (defun latexinfo-if-set ()
  1760.   "If set, continue formatting; else do not format region up to \\end{ifset}"
  1761.   (let ((arg (latexinfo-parse-line-arg)))
  1762.     (if (not (boundp (intern arg)))
  1763.       (error  "\\ifset flag `%s' is not defined by a \\set command." arg))
  1764.     (latexinfo-discard-command)
  1765.     (if  (symbol-value (intern arg))
  1766.         ;; (message  "%s is true." arg)
  1767.         () 
  1768.       ;; (message  "%s is false." arg)
  1769.       (delete-region latexinfo-command-start
  1770.                      (progn (re-search-forward "\\\\end[ {]ifset[ }\t]*\n")
  1771.                             (point))))))
  1772.  
  1773. (put 'ifclear 'latexinfo-end 'latexinfo-discard-command)
  1774. (put 'ifclear 'latexinfo-format 'latexinfo-if-clear)
  1775. (defun latexinfo-if-clear ()
  1776.   "If clear, do not format up to \\end{ifclear}; else continue formatting."
  1777.   (let ((arg (latexinfo-parse-line-arg)))
  1778.     (if (not (boundp (intern arg)))
  1779.       (error  "\\ifclear flag `%s' is not defined by a \\set command." arg))
  1780.     (latexinfo-discard-command)
  1781.     (if  (symbol-value (intern arg))
  1782.       (delete-region latexinfo-command-start
  1783.                      (progn (re-search-forward "\\\\end[ {]ifset[ }\t]*\n")
  1784.                             (point))))))
  1785.  
  1786. ;; process included files
  1787. (put 'include 'latexinfo-format 'latexinfo-format-include)
  1788. (defun latexinfo-format-include ()
  1789.   (let ((filename (latexinfo-parse-arg-discard))
  1790.     (default-directory input-directory)
  1791.     subindex)
  1792.     (setq subindex
  1793.       (save-excursion
  1794.         (progn (find-file
  1795.             (cond ((file-readable-p filename)
  1796.                filename)
  1797.               ((file-readable-p (concat filename ".latexinfo"))
  1798.                (concat filename ".latexinfo"))
  1799.               ((file-readable-p (concat filename ".tex"))
  1800.                (concat filename ".tex"))
  1801.               ((file-readable-p filename)
  1802.                filename)
  1803.               (t (error "\\include'd file %s not found"
  1804.                     filename))))
  1805.            (latexinfo-format-buffer-1))))
  1806.     (latexinfo-subindex 'latexinfo-vindex (car subindex) (nth 1 subindex))
  1807.     (latexinfo-subindex 'latexinfo-findex (car subindex) (nth 2 subindex))
  1808.     (latexinfo-subindex 'latexinfo-cindex (car subindex) (nth 3 subindex))
  1809.     (latexinfo-subindex 'latexinfo-pindex (car subindex) (nth 4 subindex))
  1810.     (latexinfo-subindex 'latexinfo-tindex (car subindex) (nth 5 subindex))
  1811.     (latexinfo-subindex 'latexinfo-kindex (car subindex) (nth 6 subindex))))
  1812.  
  1813. (defun latexinfo-subindex (indexvar file content)
  1814.   (set indexvar (cons (list 'recurse file content)
  1815.               (symbol-value indexvar))))
  1816.  
  1817. ;; Sort an index which is in the current buffer between START and END.
  1818. ;; Used on VMS, where the `sort' utility is not available.
  1819. (defun latexinfo-sort-region (start end)
  1820.   (require 'sort)
  1821.   (save-restriction
  1822.     (narrow-to-region start end)
  1823.     (sort-subr nil 'forward-line 'end-of-line 'latexinfo-sort-startkeyfun)))
  1824.  
  1825. ;; Subroutine for sorting an index.
  1826. ;; At start of a line, return a string to sort the line under.
  1827. (defun latexinfo-sort-startkeyfun ()
  1828.   (let ((line
  1829.      (buffer-substring (point) (save-excursion (end-of-line) (point)))))
  1830.     ;; Canonicalize whitespace and eliminate funny chars.
  1831.     (while (string-match "[ \t][ \t]+\\|[^a-z0-9 ]+" line)
  1832.       (setq line (concat (substring line 0 (match-beginning 0))
  1833.              " "
  1834.              (substring line (match-end 0) (length line)))))
  1835.     line))
  1836.  
  1837. ;; Some cannot be handled - just ignore them and junk the line
  1838.  
  1839. (defun latexinfo-unsupported ()
  1840.   (message "Unsupported LaTeXinfo command: %s"
  1841.    (buffer-substring latexinfo-command-start latexinfo-command-end))
  1842.   (latexinfo-parse-noarg)
  1843.   )
  1844.  
  1845. (defun batch-latexinfo-format ()
  1846.   "Runs  latexinfo-format-buffer  on the files remaining on the command line.
  1847. Must be used only with -batch, and kills emacs on completion.
  1848. Each file will be processed even if an error occurred previously.
  1849. For example, invoke
  1850.   \"emacs -batch -funcall batch-latexinfo-format $docs/ ~/*.tex\"."
  1851.   (if (not noninteractive)
  1852.       (error "batch-latexinfo-format may only be used -batch."))
  1853.   (let ((version-control t)
  1854.     (auto-save-default nil)
  1855.     (find-file-run-dired nil)
  1856.     (kept-old-versions 259259)
  1857.     (kept-new-versions 259259))
  1858.     (let ((error 0)
  1859.       file
  1860.       (files ()))
  1861.       (while command-line-args-left
  1862.     (setq file (expand-file-name (car command-line-args-left)))
  1863.     (cond ((not (file-exists-p file))
  1864.            (message ">> %s does not exist!" file)
  1865.            (setq error 1
  1866.              command-line-args-left (cdr command-line-args-left)))
  1867.           ((file-directory-p file)
  1868.            (setq command-line-args-left
  1869.              (nconc (directory-files file)
  1870.                 (cdr command-line-args-left))))
  1871.           (t
  1872.            (setq files (cons file files)
  1873.              command-line-args-left (cdr command-line-args-left)))))
  1874.       (while files
  1875.     (setq file (car files)
  1876.           files (cdr files))
  1877.     (condition-case err
  1878.         (progn
  1879.           (if buffer-file-name (kill-buffer (current-buffer)))
  1880.           (find-file file)
  1881.           (buffer-flush-undo (current-buffer))
  1882.           (set-buffer-modified-p nil)
  1883.           (latexinfo-mode)
  1884.           (message "Latexinfo formatting %s..." file)
  1885.           (latexinfo-format-buffer nil)
  1886.           (if (buffer-modified-p)
  1887.           (progn (message "Saving modified %s" (buffer-file-name))
  1888.              (save-buffer))))
  1889.       (error
  1890.        (message ">> Error: %s" (prin1-to-string err))
  1891.        (message ">>  point at")
  1892.        (let ((s (buffer-substring (point)
  1893.                       (min (+ (point) 100)
  1894.                        (point-max))))
  1895.          (tem 0))
  1896.          (while (setq tem (string-match "\n+" s tem))
  1897.            (setq s (concat (substring s 0 (match-beginning 0))
  1898.                    "\n>>  "
  1899.                    (substring s (match-end 0)))
  1900.              tem (1+ tem)))
  1901.          (message ">>  %s" s)))
  1902.       (setq error 1)))
  1903.       (kill-emacs error))))
  1904.  
  1905. ;;; LaTeX additions
  1906.  
  1907. (defun latexinfo-run-documentstyle-hooks ()
  1908.   "Foreach \\documentstyle-argument DOCSTYLE, look for DOCSTYLE-fmt.[el,elc]
  1909. in the current directory or load-path. If DOCSTYLE-fmt-hook is bound, run it."
  1910.   (goto-char (point-min))
  1911.   (search-forward "\\documentstyle")
  1912.   (if (looking-at "\\[")
  1913.       (let ((begin (1+ (point)))
  1914.             (end (save-excursion (search-forward "]") (point)))
  1915.             (options-list nil))
  1916.         (if (null latexinfo-formats-directory)
  1917.             (setq latexinfo-formats-directory default-directory))
  1918.         (while (re-search-forward ",\\|]" end t)
  1919.           (setq options-list (cons (buffer-substring begin (1- (point)))
  1920.                    options-list))
  1921.           (setq begin (point)))
  1922.         (setq options-list (nreverse options-list))
  1923.         (while options-list
  1924.       (let ((option (car options-list))
  1925.                 (filename nil))
  1926.             (if (not (memq (intern option) latexinfo-known-document-styles))
  1927.                 (progn
  1928.                   (message "Checking formatting option %s" option) ;(sit-for 2)
  1929.                   (if (load (concat option "-fmt") t) ; dont report errors
  1930.                       (let ((option-symbol
  1931.                              (intern (concat option "-fmt-hook"))))
  1932.             (if (fboundp option-symbol)
  1933.                 (progn
  1934.                   (message "Running %s formatting hooks" option)
  1935.                   (sit-for 1) 
  1936.                   (funcall option-symbol)))
  1937.                         (message (concat "Done loading file %s" option))
  1938.                     ; (sit-for 1) ; we want it fast
  1939.                         )
  1940.                     (message (concat option "-fmt not found"))
  1941.                     )
  1942.                   )
  1943.               )
  1944.         (setq options-list (cdr options-list)))))))
  1945.  
  1946. (put 'BACK 'latexinfo-format 'latexinfo-format-backslash)
  1947. (put 'back 'latexinfo-format 'latexinfo-format-backslash)
  1948. (defun latexinfo-format-backslash ()
  1949.   "replace \\back by \\"
  1950.   (latexinfo-parse-noarg)
  1951.   (insert "\\"))
  1952.  
  1953. (put 'same 'latexinfo-format 'latexinfo-discard-command)
  1954. (put 'same 'latexinfo-end 'latexinfo-discard-command)
  1955.  
  1956. (put 'cite 'latexinfo-format 'latexinfo-format-cite)
  1957. (defun latexinfo-format-cite ()
  1958.   (if (looking-at "[\\[]")
  1959.       (save-excursion
  1960.     (let ((here (point)) (str nil))
  1961.           (forward-sexp 1)
  1962.           (setq str (buffer-substring (1+ here) (- (point) 1)))
  1963.           (delete-region here (point))
  1964.           (if (eolp) (delete-char 1))
  1965.           (insert "[" (latexinfo-parse-arg-discard) ", " str "]")))
  1966.     (insert "[" (latexinfo-parse-arg-discard) "]"))
  1967.   (goto-char latexinfo-command-start))
  1968.  
  1969. (put 'hfill 'latexinfo-format 'latexinfo-format-hfill)
  1970. (defun latexinfo-format-hfill ()
  1971.   (latexinfo-parse-arg-discard)
  1972.   (insert-char ?\  (- fill-column
  1973.               (save-excursion
  1974.             (end-of-line 1)
  1975.             (current-column)))))
  1976.  
  1977. (put 'S 'latexinfo-format 'latexinfo-format-S)
  1978. (defun latexinfo-format-S ()
  1979.   (latexinfo-parse-noarg)
  1980.   (insert "Section"))
  1981.  
  1982. ;;; Some European support
  1983.  
  1984. ;;; \ss
  1985. (put 'ss 'latexinfo-format 'latexinfo-format-ss)
  1986. (defun latexinfo-format-ss ()
  1987.   (latexinfo-parse-noarg)
  1988.   (insert "ss"))
  1989.  
  1990. (put 'LaTeX 'latexinfo-format 'latexinfo-format-LaTeX)
  1991. (defun latexinfo-format-LaTeX ()
  1992.   (latexinfo-parse-noarg)
  1993.   (insert "LaTeX"))
  1994.  
  1995. (put 'BibTeX 'latexinfo-format 'latexinfo-format-BibTeX)
  1996. (defun latexinfo-format-BibTeX ()
  1997.   (latexinfo-parse-noarg)
  1998.   (insert "BibTeX"))
  1999.  
  2000. (put 'arrow 'latexinfo-format 'latexinfo-format-arrow)
  2001. (put 'result 'latexinfo-format 'latexinfo-format-arrow)
  2002. (defun latexinfo-format-arrow ()
  2003.   (latexinfo-parse-noarg)
  2004.   (insert "=> "))
  2005.  
  2006. (put 'leq 'latexinfo-format 'latexinfo-format-leq)
  2007. (defun latexinfo-format-leq ()
  2008.   (latexinfo-parse-noarg)
  2009.   (insert "<="))
  2010.  
  2011. (put 'geq 'latexinfo-format 'latexinfo-format-geq)
  2012. (defun latexinfo-format-geq ()
  2013.   (latexinfo-parse-noarg)
  2014.   (insert ">="))
  2015.  
  2016. (put 'pi 'latexinfo-format 'latexinfo-format-pi)
  2017. (defun latexinfo-format-pi ()
  2018.   (latexinfo-parse-noarg)
  2019.   (insert "pi"))
  2020.  
  2021. (put 'quad 'latexinfo-format 'latexinfo-format-quad)
  2022. (defun latexinfo-format-quad ()
  2023.   (latexinfo-parse-noarg)
  2024.   (insert "    "))
  2025.  
  2026. (put 'qquad 'latexinfo-format 'latexinfo-format-qquad)
  2027. (defun latexinfo-format-qquad ()
  2028.   (latexinfo-parse-noarg)
  2029.   (insert "      "))
  2030.  
  2031. (put 'pm 'latexinfo-format 'latexinfo-format-pm)
  2032. (defun latexinfo-format-pm ()
  2033.   (latexinfo-parse-noarg)
  2034.   (insert "+/-"))
  2035.  
  2036. ;;; Glyphs: \equiv, \error, etc
  2037.  
  2038. ;; \equiv           to show that two expressions are equivalent
  2039. ;; \error           to show an error message
  2040. ;; \expansion       to show what a macro expands to
  2041. ;; \point           to show the location of point in an example
  2042. ;; \print           to show what an evaluated expression prints
  2043. ;; \result          to indicate the value returned by an expression
  2044.  
  2045. (put 'equiv 'latexinfo-format 'latexinfo-format-equiv)
  2046. (defun latexinfo-format-equiv ()
  2047.   "Indicate the exact equivalence of two forms; special glyph: =="
  2048.   (latexinfo-parse-noarg)
  2049.   (insert "=="))
  2050.  
  2051. (put 'error 'latexinfo-format 'latexinfo-format-error)
  2052. (defun latexinfo-format-error ()
  2053.   "Indicate that the following text is an error message: error-->"
  2054.   (latexinfo-parse-noarg)
  2055.   (insert "error-->"))
  2056.  
  2057. (put 'expansion 'latexinfo-format 'latexinfo-format-expansion)
  2058. (defun latexinfo-format-expansion ()
  2059.   "Indicate the result of a macro expansion; special glyph: ==>"
  2060.   (latexinfo-parse-noarg)
  2061.   (insert "==>"))
  2062.  
  2063. (put 'point 'latexinfo-format 'latexinfo-format-point)
  2064. (defun latexinfo-format-point ()
  2065.   "Indicate the position of point; special glyph: -!-"
  2066.   (latexinfo-parse-noarg)
  2067.   (insert "-!-"))
  2068.  
  2069. (put 'print 'latexinfo-format 'latexinfo-format-print)
  2070. (defun latexinfo-format-print ()
  2071.   "Indicate printed output; special glyph: -|"
  2072.   (latexinfo-parse-noarg)
  2073.   (insert "-|"))
  2074.  
  2075.  
  2076. (put 'c 'latexinfo-format 'latexinfo-discard-commment-line)
  2077. (put 'comment 'latexinfo-format 'latexinfo-discard-commment-line)
  2078. (defun latexinfo-discard-commment-line ()
  2079.   "Discards commment lines, but tries to be more TeX like by deleting 
  2080. the following whitespace."
  2081.   (latexinfo-discard-line-with-args)
  2082.   (latexinfo-delete-whitespace)
  2083.   )
  2084.  
  2085. ;; Lots of bolio constructs do nothing in latexinfo.
  2086. (defun latexinfo-discard-line-with-args ()
  2087.   (goto-char latexinfo-command-start)
  2088.   (delete-region (point) (progn (forward-line 1) (point))))
  2089.  
  2090. (put 'need 'latexinfo-format 'latexinfo-discard-line-with-args)
  2091. (put 'newindex 'latexinfo-format 'latexinfo-discard-line-with-args)
  2092. (put 'synindex 'latexinfo-format 'latexinfo-discard-line-with-args)
  2093. (put 'syncodeindex 'latexinfo-format 'latexinfo-discard-line-with-args)
  2094. (put 'parindent 'latexinfo-format 'latexinfo-discard-line-with-args)
  2095. (put 'lispnarrowing 'latexinfo-format 'latexinfo-discard-line-with-args)
  2096. (put 'itemindent 'latexinfo-format 'latexinfo-discard-line-with-args)
  2097.  
  2098. (put 'PROTECT 'latexinfo-format 'latexinfo-parse-protected-argument)
  2099. (put 'protect 'latexinfo-format 'latexinfo-parse-protected-argument)
  2100. (defun latexinfo-parse-protected-argument ()
  2101.   ;; TeX gobbles the next whitespace.
  2102.   (goto-char latexinfo-command-end)
  2103.   (latexinfo-delete-whitespace)
  2104.   (cond ((looking-at "{")
  2105.      (setq latexinfo-command-end
  2106.            (save-excursion
  2107.          (forward-sexp 1) (point))))
  2108.     )
  2109.   (insert (prog1 (buffer-substring (1+ (point)) (1- latexinfo-command-end))
  2110.     (latexinfo-delete-command)))
  2111.   )
  2112.  
  2113. (put 'protect 'latexinfo-format 'latexinfo-parse-noarg)
  2114. (put 'PROTECT 'latexinfo-format 'latexinfo-parse-noarg)
  2115.  
  2116. ;; LaTeX noops
  2117. (put 'hsize 'latexinfo-format 'latexinfo-discard-line-with-args)
  2118. (put 'clearpage 'latexinfo-format 'latexinfo-discard-line-with-args)
  2119. (put 'newpage 'latexinfo-format 'latexinfo-discard-line-with-args)
  2120. (put 'includeonly 'latexinfo-format 'latexinfo-discard-line-with-args)
  2121.  
  2122. (put 'cleardoublepage 'latexinfo-format 'latexinfo-discard-line-with-args)
  2123. (put 'tableofcontents 'latexinfo-format 'latexinfo-discard-line-with-args)
  2124. (put 'listoftables 'latexinfo-format 'latexinfo-discard-line-with-args)
  2125. (put 'listoffigures 'latexinfo-format 'latexinfo-discard-line-with-args)
  2126. (put 'vspace 'latexinfo-format 'latexinfo-discard-line-with-args)
  2127. (put 'vspace* 'latexinfo-format 'latexinfo-discard-line-with-args)
  2128. (put 'markboth 'latexinfo-format 'latexinfo-discard-line-with-args)
  2129. (put 'markright 'latexinfo-format 'latexinfo-discard-line-with-args)
  2130. (put 'index 'latexinfo-format 'latexinfo-parse-arg-discard)
  2131. (put 'bibliographystyle 'latexinfo-format 'latexinfo-discard-line-with-args)
  2132. (put 'pagestyle 'latexinfo-format 'latexinfo-discard-line-with-args)
  2133. (put 'pagenumbering 'latexinfo-format 'latexinfo-discard-line-with-args)
  2134. (put 'part 'latexinfo-format 'latexinfo-discard-line-with-args)
  2135.  
  2136. (put 'cpsubindex 'latexinfo-format 'latexinfo-discard-line-with-args)
  2137.  
  2138. ;;; Catchall for latexinfo-format-region
  2139. (put 'documentstyle 'latexinfo-format 'latexinfo-discard-line-with-args)
  2140.  
  2141. ;;; Titlepage commands 
  2142.  
  2143. ;; Author
  2144. (put 'author 'latexinfo-format 'latexinfo-format-author)
  2145. (defun latexinfo-format-author ()
  2146.   (latexinfo-format-atd "author"))
  2147.  
  2148. (put 'and 'latexinfo-format 'latexinfo-format-and)
  2149. ;; This should really only be valid in titles.
  2150. (defun latexinfo-format-and ()
  2151.   (latexinfo-parse-noarg)
  2152.   (insert ?\n))
  2153.  
  2154. ;; title
  2155. (put 'title 'latexinfo-format 'latexinfo-format-title)
  2156. (defun latexinfo-format-title ()
  2157.   (latexinfo-format-atd "title"))
  2158.  
  2159. (put 'date 'latexinfo-format 'latexinfo-format-date)
  2160. (defun latexinfo-format-date ()
  2161.   (latexinfo-format-atd "date"))
  2162.  
  2163. (defun latexinfo-format-atd (atd)
  2164.   (delete-region latexinfo-command-start latexinfo-command-end)
  2165.   (latexinfo-push-stack 'center 0)
  2166.   (if (looking-at "{")
  2167.       (save-excursion
  2168.     (let ((here (point)) (str nil))
  2169.       (forward-sexp 1)
  2170.       (delete-char -1)
  2171.       (insert ?\n "\\end{center}")
  2172.       (goto-char here)
  2173.       (delete-char 1))
  2174.     (goto-char latexinfo-command-start))
  2175.     (error "No argument specified to the %s command" atd))
  2176.   )
  2177.  
  2178. ;;\today
  2179. (put 'today 'latexinfo-format 'latexinfo-format-today)
  2180. (defun latexinfo-format-today ()
  2181.   (delete-region latexinfo-command-start latexinfo-command-end)  
  2182.   (let* ((date-string (current-time-string))
  2183.      (month-alist   '(("Jan" . "January") ("Feb" . "February") 
  2184.               ("Mar" . "March") ("Apr" . "April")
  2185.               ("May" . "May") ("Jun" . "June") 
  2186.               ("Jul" . "July") ("Aug" . "August")
  2187.               ("Sep" . "September") ("Oct" . "October")
  2188.               ("Nov" . "November") ("Dec" . "December")))
  2189.      )
  2190.     (string-match "\\(...\\) \\(...\\) \\(..\\).*\\(19..\\)"
  2191.           (current-time-string) nil)
  2192.     (insert
  2193.      (concat (cdr (assoc (substring date-string 
  2194.                     (match-beginning 2) (match-end 2))
  2195.              month-alist))
  2196.          " " (substring date-string (match-beginning 3) (match-end 3))
  2197.          ", " (substring date-string (match-beginning 4) (match-end 4))
  2198.          ))
  2199.     )
  2200.   )
  2201.  
  2202. (put 'maketitle 'latexinfo-format 'latexinfo-format-maketitle)
  2203. (defun latexinfo-format-maketitle ()
  2204.   (latexinfo-parse-noarg))
  2205.  
  2206. (put 'finalout 'latexinfo-format 'latexinfo-format-finalout)
  2207. (defun latexinfo-format-finalout ()
  2208.   (latexinfo-parse-noarg))
  2209.  
  2210. (put 'sloppy 'latexinfo-format 'latexinfo-format-sloppy)
  2211. (defun latexinfo-format-sloppy ()
  2212.   (latexinfo-parse-noarg))
  2213.  
  2214. ;;; Bibliography
  2215. (put 'bibliography 'latexinfo-format 'latexinfo-format-bibliography)
  2216. (defun latexinfo-format-bibliography ()
  2217.   (let* ((arg (latexinfo-parse-arg-discard))
  2218.      (latexinfo-bbl-filename  (expand-file-name (concat arg ".bbl")))
  2219.      (here (point)))
  2220.     (eat-sexp)
  2221.     ;; This should be a chapter or a section.
  2222.     (insert "\\chapter*{References}" ?\n ?\n)
  2223.     (if (file-exists-p latexinfo-bbl-filename)
  2224.     (progn
  2225.       (insert-file latexinfo-bbl-filename)
  2226.       (exchange-point-and-mark)
  2227.       (narrow-to-region here (point))
  2228.       (goto-char (point-min))
  2229.       (quietly-replace-string "{\\em " "\\var{")
  2230.       (goto-char (point-min))
  2231.       (quietly-replace-string "{\\it " "\\emph{")
  2232.       (goto-char (point-min))
  2233.       (quietly-replace-string "{ " "\\r{")
  2234.       (widen)
  2235.       (goto-char latexinfo-command-start)
  2236.       )
  2237.       (message "Formatted bibliography file not found: %s" latexinfo-bbl-filename))
  2238.     )
  2239.   )
  2240.  
  2241. (put 'thebibliography 'latexinfo-format 'latexinfo-thebibliography)
  2242. (defun latexinfo-thebibliography ()
  2243.   (if (looking-at "}") (forward-char 1))
  2244.   (eat-sexp)
  2245.   (latexinfo-push-stack 'description "")
  2246.   (setq fill-column (- fill-column 5))
  2247.   (latexinfo-discard-line))
  2248.  
  2249. (put 'thebibliography 'latexinfo-end 'latexinfo-end-description)
  2250. (put 'bibitem 'latexinfo-format 'latexinfo-description-bibitem)
  2251. (defun latexinfo-description-bibitem ()
  2252.   (if (looking-at "}") (forward-char 1))
  2253.   (eat-sexp)
  2254.   (let ((arg (latexinfo-parse-arg-discard)))
  2255.     (insert ?\b arg "\n     \n"))
  2256.   (forward-line -2))
  2257.  
  2258. (put 'newblock 'latexinfo-format 'latexinfo-parse-noarg)
  2259.  
  2260. (defun eat-sexp ()
  2261.   (delete-region (point) (save-excursion (forward-sexp 1) (point))))
  2262.  
  2263. (provide 'latexinfo)
  2264.  
  2265. ;;; Shut Emacs up about setting the mark.
  2266. (defun quietly-replace-string (from-string to-string &optional delimited)
  2267.   "\
  2268. Replace occurrences of FROM-STRING with TO-STRING.
  2269. Preserve case in each match if  case-replace  and  case-fold-search
  2270. are non-nil and FROM-STRING has no uppercase letters.
  2271. Third arg DELIMITED (prefix arg if interactive) non-nil means replace
  2272. only matches surrounded by word boundaries."
  2273.   (quietly-perform-replace from-string to-string nil nil delimited)
  2274.   )
  2275.  
  2276. (defun quietly-replace-regexp (regexp to-string &optional delimited)
  2277.   "\
  2278. Replace things after point matching REGEXP with TO-STRING.
  2279. Preserve case in each match if case-replace and case-fold-search
  2280. are non-nil and REGEXP has no uppercase letters.
  2281. Third arg DELIMITED (prefix arg if interactive) non-nil means replace
  2282. only matches surrounded by word boundaries.
  2283. In TO-STRING, \\& means insert what matched REGEXP,
  2284. and \\=\\<n> means insert what matched <n>th \\(...\\) in REGEXP."
  2285.   (quietly-perform-replace regexp to-string nil t delimited)
  2286.   )
  2287.  
  2288.  
  2289. (defun quietly-push-mark (&optional location nomsg)
  2290.   "Set mark at LOCATION (point, by default) and push old mark on mark ring.
  2291. Displays \"Mark set\" unless the optional second arg NOMSG is non-nil."
  2292.   (if (null (mark))
  2293.       nil
  2294.     (setq mark-ring (cons (copy-marker (mark-marker)) mark-ring))
  2295.     (if (> (length mark-ring) mark-ring-max)
  2296.         (progn
  2297.           (move-marker (car (nthcdr mark-ring-max mark-ring)) nil)
  2298.           (setcdr (nthcdr (1- mark-ring-max) mark-ring) nil))))
  2299.   (set-mark (or location (point)))
  2300.   )
  2301.  
  2302.  
  2303. (defun quietly-perform-replace (from-string to-string
  2304.                 query-flag regexp-flag delimited-flag)
  2305.   (let ((nocasify (not (and case-fold-search case-replace
  2306.                 (string-equal from-string
  2307.                       (downcase from-string)))))
  2308.     (literal (not regexp-flag))
  2309.     (search-function (if regexp-flag 're-search-forward 'search-forward))
  2310.     (search-string from-string)
  2311.     (keep-going t)
  2312.     (lastrepl nil))            ;Position after last match considered.
  2313.     (if delimited-flag
  2314.     (setq search-function 're-search-forward
  2315.           search-string (concat "\\b"
  2316.                     (if regexp-flag from-string
  2317.                       (regexp-quote from-string))
  2318.                     "\\b")))
  2319.     (quietly-push-mark (point) t)
  2320.     (quietly-push-mark (point) t)
  2321.     (while (and keep-going
  2322.         (not (eobp))
  2323.         (progn
  2324.          (set-mark (point))
  2325.          (funcall search-function search-string nil t)))
  2326.       ;; Don't replace the null string 
  2327.       ;; right after end of previous replacement.
  2328.       (if (eq lastrepl (point))
  2329.       (forward-char 1)
  2330.     (undo-boundary)
  2331.     (if (not query-flag)
  2332.         (replace-match to-string nocasify literal)
  2333.       (let (done replaced)
  2334.         (while (not done)
  2335.           ;; Preserve the match data.  Process filters and sentinels
  2336.           ;; could run inside read-char..
  2337.           (let ((data (match-data))
  2338.             (help-form
  2339.              '(concat "Query replacing "
  2340.                   (if regexp-flag "regexp " "")
  2341.                   from-string " with " to-string ".\n\n"
  2342.                   (substitute-command-keys query-replace-help))))
  2343.         (setq char help-char)
  2344.         (while (= char help-char)
  2345.           (message "Query replacing %s with %s: " from-string to-string)
  2346.           (setq char (read-char))
  2347.           (if (= char ??)
  2348.               (setq unread-command-char help-char char help-char)))
  2349.         (store-match-data data))
  2350.           (cond ((or (= char ?\e)
  2351.              (= char ?q))
  2352.              (setq keep-going nil)
  2353.              (setq done t))
  2354.             ((= char ?^)
  2355.              (goto-char (mark))
  2356.              (setq replaced t))
  2357.             ((or (= char ?\ )
  2358.              (= char ?y))
  2359.              (or replaced
  2360.              (replace-match to-string nocasify literal))
  2361.              (setq done t))
  2362.             ((= char ?\.)
  2363.              (or replaced
  2364.              (replace-match to-string nocasify literal))
  2365.              (setq keep-going nil)
  2366.              (setq done t))
  2367.             ((= char ?\,)
  2368.              (if (not replaced)
  2369.              (progn
  2370.                (replace-match to-string nocasify literal)
  2371.                (setq replaced t))))
  2372.             ((= char ?!)
  2373.              (or replaced
  2374.              (replace-match to-string nocasify literal))
  2375.              (setq done t query-flag nil))
  2376.             ((or (= char ?\177)
  2377.              (= char ?n))
  2378.              (setq done t))
  2379.             ((= char ?\C-l)
  2380.              (recenter nil))
  2381.             ((= char ?\C-r)
  2382.              (store-match-data
  2383.                (prog1 (match-data)
  2384.              (save-excursion (recursive-edit)))))
  2385.             ((= char ?\C-w)
  2386.              (delete-region (match-beginning 0) (match-end 0))
  2387.              (store-match-data
  2388.                (prog1 (match-data)
  2389.              (save-excursion (recursive-edit))))
  2390.              (setq replaced t))
  2391.             (t
  2392.              (setq keep-going nil)
  2393.              (setq unread-command-char char)
  2394.              (setq done t))))))
  2395.     (setq lastrepl (point))))
  2396.     (pop-mark)
  2397.     keep-going))
  2398.  
  2399.  
  2400. ;; The overall process is one of:
  2401. ;;  (latexinfo-insert-node-lines (point-min) (point-max) t)
  2402. ;;  (mark-whole-buffer)
  2403. ;;  (latexinfo-sequential-node-update t)
  2404. ;;  (latexinfo-all-menus-update)
  2405. ;;  (latexinfo-master-menu nil)
  2406. ;;  (latexinfo-format-buffer t)