home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / lucid / lemacs-19.6 / lisp / modes / texnfo-upd.el < prev    next >
Encoding:
Text File  |  1992-06-29  |  51.5 KB  |  1,385 lines
  1. ;;;; texnfo-upd.el
  2. ;;;; A utility for updating nodes and menus in Texinfo files.
  3.  
  4. ;;;; Robert J. Chassell, 23 September 1989; 15 May 1990
  5.  
  6. ;;;; Copyright 1989, 1990 Free Software Foundation
  7.  
  8. ;; This file is part of GNU Emacs.
  9.  
  10. ;; GNU Emacs is free software; you can redistribute it and/or modify
  11. ;; it under the terms of the GNU General Public License as published by
  12. ;; the Free Software Foundation; either version 1, or (at your option)
  13. ;; any later version.
  14.  
  15. ;; GNU Emacs is distributed in the hope that it will be useful,
  16. ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18. ;; GNU General Public License for more details.
  19.  
  20. ;; You should have received a copy of the GNU General Public License
  21. ;; along with GNU Emacs; see the file COPYING.  If not, write to
  22. ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  23.  
  24. (provide 'texnfo-upd)
  25.  
  26.  
  27. ;;;; Summary
  28.  
  29. ; (Much of the following commentary ought eventually be incorporated
  30. ; into the Texinfo Manual.)
  31.  
  32. ; The node and menu updating functions automatically
  33.  
  34. ;   * insert missing `@node' lines,
  35. ;   * insert the `Next', `Previous' and `Up' pointers of a node,
  36. ;   * insert or update the menu for a section, 
  37. ;   * create a master menu for a Texinfo source file.
  38.  
  39. ; Passed an argument, the `texinfo-update-node' and
  40. ; `texinfo-make-menu' functions do their jobs in the region.
  41.  
  42. ; These functions replace doing these jobs by hand.
  43. ; You may find them helpful.
  44.  
  45. ; In brief, the functions for creating or updating nodes and menus, are:
  46. ; 
  47. ;     texinfo-update-node (&optional region-p)            
  48. ;     texinfo-every-node-update ()                        
  49. ;     texinfo-sequential-node-update (&optional region-p)
  50. ; 
  51. ;     texinfo-make-menu (&optional region-p)              
  52. ;     texinfo-all-menus-update ()                         
  53. ;     texinfo-master-menu ()
  54. ;
  55. ;     texinfo-insert-node-lines  (&optional title-p)
  56. ; 
  57. ;     texinfo-indent-menu-description (column &optional region-p)
  58.  
  59. ; The `texinfo-column-for-description' variable specifies the column to
  60. ; which menu descriptions are indented. 
  61.  
  62. ; Texinfo file structure
  63. ; ----------------------
  64.  
  65. ; To use the updating commands, you must structure your Texinfo file
  66. ; hierarchically.  Each `@node' line, with the exception of the top
  67. ; node, must be accompanied by some kind of section line, such as an
  68. ; `@chapter' or `@section' line.  Each node-line/section-line
  69. ; combination must look like this:
  70.  
  71. ;      @node    Lists and Tables, Cross References, Structuring, Top
  72. ;      @comment node-name,        next,             previous,    up
  73. ;      @chapter Making Lists and Tables
  74.  
  75. ; or like this (without the `@comment' line):
  76.  
  77. ;      @node    Lists and Tables, Cross References, Structuring, Top
  78. ;      @chapter Making Lists and Tables
  79.  
  80. ; If the file has a `top' node, it must be called `top' or `Top' and
  81. ; be the first node in the file.
  82.  
  83.  
  84. ;;;; The updating functions in detail
  85. ;    --------------------------------
  86.  
  87. ; The `texinfo-update-node' function without an argument inserts
  88. ; the correct next, previous and up pointers for the node in which
  89. ; point is located (i.e., for the node preceding point).
  90.  
  91. ; With an argument, the `texinfo-update-node' function inserts the
  92. ; correct next, previous and up pointers for the nodes inside the
  93. ; region.
  94.  
  95. ; It does not matter whether the  `@node' line has pre-existing
  96. ; `Next', `Previous', or `Up' pointers in it.  They are removed.
  97.  
  98. ; The `texinfo-every-node-update' function runs `texinfo-update-node'
  99. ; on the whole buffer.
  100.  
  101. ; The `texinfo-update-node' function inserts the immediately following
  102. ; and preceding node into the `Next' or `Previous' pointers regardless
  103. ; of their hierarchical level.  This is only useful for certain kinds
  104. ; of text, like a novel, which you go through sequentially.  
  105.  
  106. ; The `texinfo-make-menu' function without an argument creates or
  107. ; updates a menu for the section encompassing the node that follows
  108. ; point.  With an argument, it makes or updates menus for the nodes
  109. ; within or part of the marked region.
  110.  
  111. ; Whenever an existing menu is updated, the descriptions from
  112. ; that menu are incorporated into the new menu.  This is done by copying
  113. ; descriptions from the existing menu to the entries in the new menu
  114. ; that have the same node names.  If the node names are different, the
  115. ; descriptions are not copied to the new menu.
  116.  
  117. ; Menu entries that refer to other Info files are removed since they
  118. ; are not a node within current buffer.  This is a deficiency.
  119.  
  120. ; The `texinfo-all-menus-update' function runs `texinfo-make-menu'
  121. ; on the whole buffer.
  122.  
  123. ; The `texinfo-master-menu' function creates an extended menu located
  124. ; after the top node.  (The file must have a top node.)  The function
  125. ; first updates all the regular menus in the buffer (incorporating the
  126. ; descriptions from pre-existing menus), and then constructs a master
  127. ; menu that includes every entry from every other menu.  (However, the
  128. ; function cannot update an already existing master menu; if one
  129. ; exists, it must be removed before calling the function.)
  130.  
  131. ; The `texinfo-indent-menu-description' function indents every
  132. ; description in the menu following point, to the specified column.
  133. ; Non-nil argument (prefix, if interactive) means indent every
  134. ; description in every menu in the region.  This function does not
  135. ; indent second and subsequent lines of a multi-line description.
  136.  
  137. ; The `texinfo-insert-node-lines' function inserts `@node' before the
  138. ; `@chapter', `@section', and such like lines of a region in a Texinfo
  139. ; file where the `@node' lines are missing.
  140. ; 
  141. ; With a non-nil argument (prefix, if interactive), the function not
  142. ; only inserts `@node' lines but also inserts the chapter or section
  143. ; titles as the names of the corresponding nodes; and inserts titles
  144. ; as node names in pre-existing `@node' lines that lack names.
  145. ; 
  146. ; Since node names should be more concise than section or chapter
  147. ; titles, node names so inserted will need to be edited manually.
  148.  
  149.  
  150. ;;;; Menu Making Functions
  151.  
  152. (defun texinfo-make-menu (&optional region-p)
  153.   "Without any prefix argument, make or update a menu.
  154. Make the menu for the section enclosing the node found following point.
  155.  
  156. Non-nil argument (prefix, if interactive) means make or update menus
  157. for nodes within or part of the marked region.
  158.  
  159. Whenever a menu exists, and is being updated, the descriptions that
  160. are associated with node names in the pre-existing menu are
  161. incorporated into the new menu.  Otherwise, the nodes' section titles
  162. are inserted as descriptions."
  163.   
  164.   (interactive "P")
  165.   (if (not region-p)
  166.       (let ((level (texinfo-hierarchic-level)))
  167.         (texinfo-make-one-menu level)
  168.         (message "Done...updated the menu.  You may save the buffer."))
  169.     ;; else
  170.     (message "Making or updating menus... ")
  171.     (let ((beginning (region-beginning))
  172.       (region-end (region-end))
  173.           (level (progn         ; find section type following point
  174.                    (goto-char (region-beginning))
  175.                    (texinfo-hierarchic-level))))
  176.       (if (= region-end beginning)
  177.           (error "Please mark a region!"))
  178.       (save-excursion
  179.         (save-restriction
  180.           (widen)
  181.           
  182.           (while  (texinfo-find-lower-level-node level region-end)
  183.             (setq level (texinfo-hierarchic-level)) ; new, lower level
  184.             (texinfo-make-one-menu level))
  185.           
  186.           (while (and (< (point) region-end)
  187.                       (texinfo-find-higher-level-node level region-end))
  188.             (setq level (texinfo-hierarchic-level))
  189.             (while (texinfo-find-lower-level-node level region-end)
  190.               (setq level (texinfo-hierarchic-level)) ; new, lower level
  191.               (texinfo-make-one-menu level))))))
  192.     (message "Done...updated menus.  You may save the buffer.")))
  193.  
  194. (defun texinfo-make-one-menu (level)
  195.   "Make a menu of all the appropriate nodes in this section.
  196. `Appropriate nodes' are those associated with sections that are 
  197. at the level specified by LEVEL.  Point is left at the end of menu."
  198.   (let*
  199.       ((case-fold-search t)
  200.        (beginning (texinfo-update-menu-region-beginning level))
  201.        (end (texinfo-update-menu-region-end level))
  202.        (first (texinfo-menu-first-node beginning end))
  203.        (node-name (progn
  204.                     (goto-char beginning)
  205.                     (texinfo-copy-node-name)))
  206.        (new-menu-list (texinfo-make-menu-list beginning end level)))
  207.     (if (texinfo-old-menu-p beginning first)
  208.         (progn
  209.           (texinfo-incorporate-descriptions new-menu-list)
  210.           (texinfo-delete-old-menu beginning first)))
  211.     (texinfo-insert-menu new-menu-list node-name)))
  212.  
  213. (defun texinfo-all-menus-update (&optional update-all-nodes-p)
  214.   "Update every regular menu in a Texinfo file.
  215. You must remove the detailed part of a pre-existing master menu before
  216. running this command, lest it be partly duplicated.
  217.  
  218. If called with a non-nil argument, this function first updates all the
  219. nodes in the buffer before updating the menus."
  220.   (interactive "P")
  221.   (save-excursion
  222.     (mark-whole-buffer)
  223.     (message "Checking for a master menu... ")
  224.     (save-excursion
  225.       (if (re-search-forward texinfo-master-menu-header nil t)
  226.           (error
  227.            "Please remove existing master menu, lest it be partly duplicated!")))
  228.  
  229.   (if update-all-nodes-p
  230.       (progn
  231.         (message "First updating all nodes... ")
  232.         (sleep-for 2)
  233.         (mark-whole-buffer)
  234.         (texinfo-update-node t)))
  235.  
  236.     (message "Updating all menus... ")
  237.     (sleep-for 2)
  238.     (texinfo-make-menu t)
  239.     (message "Done...updated all the menus.  You may save the buffer.")))
  240.  
  241. (defun texinfo-find-lower-level-node (level region-end)
  242.   "Search forward from point for node at any level lower than LEVEL.
  243. Search is limited to the end of the marked region, REGION-END, 
  244. and to the end of the menu region for the level.
  245.  
  246. Return t if the node is found, else nil.  Leave point at the beginning
  247. of the node if one is found; else do not move point."
  248.  
  249.   (if (and (< (point) region-end)
  250.            (re-search-forward
  251.             (concat
  252.              "\\(^@node\\).*\n"         ; match node line
  253.              "\\(\\(^@c\\).*\n\\)?"     ; match comment line, if any
  254.              (eval (cdr (assoc level texinfo-update-menu-lower-regexps))))
  255.             ;; the next higher level node marks the end of this
  256.             ;; section, and no lower level node will be found beyond
  257.             ;; this position even if region-end is farther off
  258.             (texinfo-update-menu-region-end level) 
  259.             t))
  260.       (goto-char (match-beginning 1))))
  261.  
  262. (defun texinfo-find-higher-level-node (level region-end)
  263.   "Search forward from point for node at any higher level than argument LEVEL.
  264. Search is limited to the end of the marked region, REGION-END.
  265.  
  266. Return t if the node is found, else nil.  Leave point at the beginning
  267. of the node if one is found; else do not move point."
  268.  
  269.   (if (and (< (point) region-end)
  270.            (re-search-forward
  271.             (concat
  272.              "\\(^@node\\).*\n"         ; match node line
  273.              "\\(\\(^@c\\).*\n\\)?"     ; match comment line, if any
  274.              (eval                      ; (won't ever find a `top' node)
  275.               (cdr (assoc level texinfo-update-menu-higher-regexps))))
  276.             nil
  277.             t))
  278.       (goto-char (match-beginning 1))))
  279.  
  280.  
  281. ;;;; Making the list of new menu entries
  282.  
  283. (defun texinfo-make-menu-list (beginning end level)
  284.   "Make a list of node names and their descriptions.
  285. Point is left at the end of the menu region, but the menu is not inserted.
  286.  
  287. First argument is position from which to start making menu list; 
  288. second argument is end of region in which to try to locate entries;
  289. third argument is the level of the nodes that are the entries.
  290.  
  291. Node names and descriptions are dotted pairs of strings.  Each pair is
  292. an element of the list.  If the description does not exist, the
  293. element consists only of the node name."
  294.   (goto-char beginning)
  295.   (let (new-menu-list)
  296.     (while (texinfo-menu-locate-entry-p level end)
  297.       (setq new-menu-list 
  298.             (cons (cons 
  299.                    (texinfo-copy-node-name)
  300.                    (texinfo-copy-section-title))
  301.                   new-menu-list)))
  302.     (reverse new-menu-list)))
  303.  
  304. (defun texinfo-menu-locate-entry-p (level search-end)
  305.   "Find a node that will be part of menu for this section.
  306. First argument is a string such as \"section\" specifying the general
  307. hierarchical level of the menu; second argument is a postion
  308. specifying the end of the search.
  309.  
  310. The function returns t if the node is found, else nil.  It searches
  311. forward from point, and leaves point at the beginning of the node.
  312.  
  313. The function finds entries of the same type.  Thus `subsections' and
  314. `unnumberedsubsecs' will appear in the same menu."
  315.   (if (re-search-forward
  316.        (concat
  317.         "\\(^@node\\).*\n"            ; match node line
  318.         "\\(\\(^@c\\).*\n\\)?"        ; match comment line, if any
  319.         (eval
  320.          (cdr (assoc level texinfo-update-menu-same-level-regexps))))
  321.        search-end
  322.        t)
  323.       (goto-char (match-beginning 1))))
  324.  
  325. (defun texinfo-copy-node-name ()
  326.   "Return the node name as a string.
  327.  
  328. Start with point at the beginning of the node line; copy the text
  329. after the node command up to the first comma on the line, if any, and
  330. return the text as a string.  Leaves point at the beginning of the
  331. line.  If there is no node name, returns an empty string."
  332.   
  333.   (save-excursion
  334.     (buffer-substring
  335.      (progn (forward-word 1)              ; skip over node command
  336.             (skip-chars-forward " \t")    ; and over spaces
  337.             (point))
  338.      (if (search-forward
  339.           ","
  340.           (save-excursion (end-of-line) (point)) t) ; bound search
  341.          (1- (point))
  342.        (end-of-line) (point)))))
  343.  
  344. (defun texinfo-copy-section-title ()
  345.   "Return the title of the section as a string.
  346. The title is used as a description line in the menu when one does not
  347. already exist.
  348.  
  349. Move point to the beginning of the appropriate section line by going
  350. to the start of the text matched by last regexp searched for, which
  351. must have been done by `texinfo-menu-locate-entry-p'."
  352.  
  353.   ;; could use the same re-search as in `texinfo-menu-locate-entry-p'
  354.   ;; instead of using `match-beginning'; such a variation would be
  355.   ;; more general, but would waste information already collected
  356.  
  357.   (goto-char (match-beginning 4))       ; match section name 
  358.  
  359.   (buffer-substring
  360.    (progn (forward-word 1)              ; skip over section type
  361.           (skip-chars-forward " \t")    ; and over spaces
  362.           (point))
  363.    (progn (end-of-line) (point))))
  364.  
  365.  
  366. ;;;; Handling the old menu
  367.  
  368. (defun texinfo-old-menu-p (beginning first)
  369.   "Move point to the beginning of the menu for this section, if any.
  370. Otherwise move point to the end of the first node of this section.
  371. Return t if a menu is found, nil otherwise.
  372.  
  373. First argument is the position of the beginning of the section in which
  374. the menu will be located; second argument is the position of the first
  375. node within the section.
  376.  
  377. If no menu is found, the function inserts two newlines just before the
  378. end of the section, and leaves point there where a menu ought to be."
  379.   (goto-char beginning)
  380.   (if (not (re-search-forward "^@menu" first 'goto-end))
  381.       (progn (insert "\n\n") (forward-line -2) nil)
  382.     t))
  383.  
  384. (defun texinfo-incorporate-descriptions (new-menu-list)
  385.   "Copy the old menu line descriptions that exist to the new menu.
  386.  
  387. Point must be at beginning of old menu.
  388.  
  389. If the node-name of the new menu entry cannot be found in the old
  390. menu, use the new section title for the description, but if the
  391. node-name of the new menu is found in the old menu, replace the
  392. section title with the old description, whatever it may be.
  393.  
  394. For this function, the new menu is a list made up of lists of dotted
  395. pairs in which the first element of the pair is the node name and the
  396. second element the description. The new menu is changed destructively.
  397. The old menu is the menu as it appears in the texinfo file."
  398.   
  399.   (let ((new-menu-list-pointer new-menu-list)
  400.         (end-of-menu (texinfo-menu-end)))
  401.     (while new-menu-list
  402.       (save-excursion                   ; keep point at beginning of menu 
  403.         (if (search-forward
  404.              (concat "\* "              ; so only menu entries are found
  405.                      (car (car new-menu-list)))
  406.              end-of-menu
  407.              t) 
  408.             (setcdr (car new-menu-list) 
  409.                     (texinfo-menu-copy-old-description end-of-menu))))
  410.       (setq new-menu-list (cdr new-menu-list))) 
  411.     (setq new-menu-list new-menu-list-pointer)))
  412.  
  413. (defun texinfo-menu-copy-old-description (end-of-menu)
  414.   "Return description field of old menu line as string.
  415. Point must be located just after the node name.  Point left before description.
  416. Single argument, END-OF-MENU, is position limiting search."
  417.   (skip-chars-forward "[:.,\t\n ]+")
  418.   ;; don't copy a carriage return at line beginning with asterisk!
  419.   ;; do copy a description that begins with an `@'!
  420.   (if (and (looking-at "\\(\\w+\\|@\\)")    
  421.            (not (looking-at "\\(^\\* \\|^@end menu\\)")))  
  422.       (buffer-substring
  423.        (point)
  424.        (save-excursion
  425.          (re-search-forward "\\(^\\* \\|^@end menu\\)" end-of-menu t)
  426.          (forward-line -1)
  427.          (end-of-line)                  ; go to end of last description line
  428.          (point)))
  429.     ""))
  430.  
  431. (defun texinfo-menu-end ()
  432.   "Return position of end of menu. Does not change location of point.
  433. Signal an error if not end of menu."
  434.   (save-excursion
  435.     (if (re-search-forward "^@end menu" nil t)
  436.         (point)
  437.       (error "Menu does not have an end."))))
  438.  
  439. (defun texinfo-delete-old-menu (beginning first)
  440.   "Delete the old menu.  Point must be in or after menu.
  441. First argument is position of the beginning of the section in which
  442. the menu will be located; second argument is the position of the first
  443. node within the section."
  444.   ;; No third arg to search, so error if search fails.
  445.   (re-search-backward "^@menu" beginning)
  446.   (delete-region (point)
  447.                  (save-excursion
  448.                    (re-search-forward "^@end menu" first)
  449.                    (point))))
  450.  
  451.  
  452. ;;;; Inserting new menu
  453.  
  454. ;; try 32, but perhaps 24 is better
  455. (defvar texinfo-column-for-description 32
  456.   "*Column at which descriptions start in a Texinfo menu.")
  457.  
  458. (defun texinfo-insert-menu (menu-list node-name)
  459.   "Insert formatted menu at point.
  460. Indents the first line of the description, if any, to the value of
  461. texinfo-column-for-description.
  462.  
  463. MENU-LIST has form:
  464.  
  465.     \(\(\"node-name1\" . \"description\"\) 
  466.     \(\"node-name\" . \"description\"\) ... \)
  467.  
  468. However, there does not need to be a description field."
  469.   
  470.   (insert "@menu\n")
  471.   (while menu-list
  472.     (if (cdr (car menu-list))       ; menu-list has description entry
  473.         (progn
  474.           (insert 
  475.            (format "* %s::" (car (car menu-list)))) ; node-name entry
  476.           (indent-to texinfo-column-for-description 2)
  477.           (insert 
  478.            (format "%s\n" (cdr (car menu-list)))))  ; description entry
  479.         ;; else menu-list lacks description entry
  480.       (insert
  481.        (format "* %s::\n" (car (car menu-list)))))  ; node-name entry
  482.     (setq menu-list (cdr menu-list)))
  483.   (insert "@end menu")
  484.   (message
  485.    "Updated \"%s\" level menu following node: %s ... "
  486.    level node-name))
  487.  
  488.  
  489. ;;;; Handling description indentation
  490.  
  491. ; Since the make-menu functions indent descriptions, these functions
  492. ; are useful primarily for indenting a single menu specially.
  493.  
  494. (defun texinfo-indent-menu-description (column &optional region-p)
  495.   "Indent every description in menu following point to COLUMN.  
  496. Non-nil argument (prefix, if interactive) means indent every
  497. description in every menu in the region.  Does not indent second and
  498. subsequent lines of a multi-line description."
  499.   
  500.   (interactive
  501.    "nIndent menu descriptions to (column number): \nP")
  502.   (save-excursion
  503.     (save-restriction
  504.       (widen)
  505.       (if (not region-p)
  506.           (progn
  507.             (re-search-forward "^@menu")
  508.             (texinfo-menu-indent-description column)
  509.             (message
  510.              "Indented descriptions in menu.  You may save the buffer."))
  511.         ;;else
  512.         (message "Indenting every menu description in region... ")
  513.         (goto-char (region-beginning))
  514.         (while (and (< (point) (region-end))
  515.                     (texinfo-locate-menu-p))
  516.           (forward-line 1)
  517.           (texinfo-menu-indent-description column))
  518.         (message "Indenting done.  You may save the buffer.")))))
  519.  
  520. (defun texinfo-menu-indent-description (to-column-number)
  521.   "Indent the Texinfo file menu description to TO-COLUMN-NUMBER.
  522. Start with point just after the word `menu' in the `@menu' line and
  523. leave point on the line before the `@end menu' line.  Does not indent
  524. second and subsequent lines of a multi-line description."
  525.   (let* ((beginning-of-next-line (point)))
  526.     (while (< beginning-of-next-line
  527.               (save-excursion     ; beginning of end menu line
  528.                 (goto-char (texinfo-menu-end))
  529.                 (beginning-of-line)
  530.                 (point)))
  531.       (if (search-forward "::" (texinfo-menu-end) t)
  532.           (progn
  533.             (let ((beginning-white-space (point)))
  534.               (skip-chars-forward " \t")  ; skip over spaces
  535.               (if (looking-at "\\(@\\|\\w\\)+") ; if there is text
  536.                   (progn
  537.                     ;; remove pre-existing indentation
  538.                     (delete-region beginning-white-space (point))
  539.                     (indent-to-column to-column-number))))))
  540.       ;; position point at beginning of next line
  541.       (forward-line 1)                  
  542.       (setq beginning-of-next-line (point)))))
  543.  
  544.  
  545. ;;;; Making the master menu
  546.  
  547. (defun texinfo-master-menu (update-all-nodes-menus-p)
  548.   "Make a master menu for a whole Texinfo file.
  549. Non-nil argument (prefix, if interactive) means first update all
  550. existing nodes and menus.  Remove pre-existing master menu, if there is one.
  551.  
  552. This function creates a master menu that follows the top node.  The
  553. master menu includes every entry from all the other menus.  It
  554. replaces any existing ordinary menu that follows the top node.
  555.  
  556. If called with a non-nil argument, this function first updates all the
  557. menus in the buffer (incorporating descriptions from pre-existing
  558. menus) before it constructs the master menu.
  559.  
  560. The function removes the detailed part of an already existing master
  561. menu.  This action depends on the pre-exisitng master menu using the
  562. standard `texinfo-master-menu-header'.
  563.  
  564. The master menu has the following format, which is adapted from the
  565. recommendation in the Texinfo Manual:
  566.  
  567.    * The first part contains the major nodes in the Texinfo file: the
  568.      nodes for the chapters, chapter-like sections, and the major
  569.      appendices.  This includes the indices, so long as they are in
  570.      chapter-like sections, such as unnumbered sections.
  571.  
  572.    * The second and subsequent parts contain a listing of the other,
  573.      lower level menus, in order.  This way, an inquirer can go
  574.      directly to a particular node if he or she is searching for
  575.      specific information.
  576.  
  577. Each of the menus in the detailed node listing is introduced by the
  578. title of the section containing the menu."
  579.  
  580.   (interactive "P")
  581.   (widen)
  582.   (goto-char (point-min))
  583.  
  584.   ;; Move point to location after `top'.
  585.   (if (not (re-search-forward "^@node [ \t]*top" nil t))
  586.       (error "This buffer needs a Top node!"))
  587.  
  588.   (let ((first-chapter                  
  589.          (save-excursion (re-search-forward "^@node") (point))))
  590.     (if (re-search-forward texinfo-master-menu-header first-chapter t)
  591.         ;; Remove detailed master menu listing
  592.         (progn
  593.            (goto-char (match-beginning 0))
  594.           (let ((end-of-detailed-menu-descriptions
  595.                  (save-excursion     ; beginning of end menu line
  596.                    (goto-char (texinfo-menu-end))
  597.                    (beginning-of-line) (forward-char -1)
  598.                    (point))))
  599.             (delete-region (point) end-of-detailed-menu-descriptions)))))
  600.  
  601.   (if update-all-nodes-menus-p
  602.       (progn
  603.         (message "Making a master menu...first updating all nodes... ")
  604.         (sleep-for 2)
  605.         (mark-whole-buffer)
  606.         (texinfo-update-node t)
  607.  
  608.         (message "Updating all menus... ")        
  609.         (sleep-for 2)
  610.         (mark-whole-buffer)
  611.         (texinfo-make-menu t)))
  612.  
  613.   (message "Now making the master menu... ")
  614.   (sleep-for 2)
  615.   (goto-char (point-min))
  616.   (texinfo-insert-master-menu-list
  617.    (texinfo-master-menu-list))
  618.  
  619.   ;; Remove extra newlines that texinfo-insert-master-menu-list
  620.   ;; may have inserted.
  621.  
  622.   (save-excursion
  623.     (goto-char (point-min))
  624.     
  625.     (re-search-forward texinfo-master-menu-header)
  626.     (goto-char (match-beginning 0))
  627.     (insert "\n")
  628.     (delete-blank-lines)
  629.     
  630.     (re-search-backward "^@menu")
  631.     (forward-line -1)
  632.     (delete-blank-lines)
  633.     
  634.     (re-search-forward "^@end menu")
  635.     (forward-line 1)
  636.     (delete-blank-lines))
  637.  
  638.   (message "Done...completed making master menu.  You may save the buffer."))
  639.  
  640. (defun texinfo-master-menu-list ()
  641.   "Return a list of menu entries and header lines for the master menu.
  642.  
  643. Start with the menu for chapters and indices and then find each
  644. following menu and the title of the node preceding that menu.
  645.  
  646. The master menu list has this form:
  647.  
  648.     \(\(\(... \"entry-1-2\"  \"entry-1\"\) \"title-1\"\)
  649.       \(\(... \"entry-2-2\"  \"entry-2-1\"\) \"title-2\"\)
  650.       ...\)
  651.  
  652. However, there does not need to be a title field."
  653.  
  654.   (let (master-menu-list)
  655.     (while (texinfo-locate-menu-p)
  656.       (setq master-menu-list 
  657.             (cons (list
  658.                    (texinfo-copy-menu)
  659.                    (texinfo-copy-menu-title))
  660.                   master-menu-list)))
  661.     (reverse master-menu-list)))
  662.  
  663. (defun texinfo-insert-master-menu-list (master-menu-list)
  664.   "Format and insert the master menu in the current buffer."
  665.   (goto-char (point-min))
  666.   (re-search-forward "^@menu")
  667.   (beginning-of-line)
  668.   (delete-region (point)        ; buffer must have ordinary top menu
  669.                  (save-excursion
  670.                    (re-search-forward "^@end menu")
  671.                    (point)))
  672.  
  673.   (save-excursion                       ; leave point at beginning of menu
  674.   ;; Handle top of menu
  675.   (insert "\n@menu\n")
  676.   ;; Insert chapter menu entries
  677.   (setq this-very-menu-list (reverse (car (car master-menu-list))))
  678.   ;;; Tell user what is going on.
  679.   (message "Inserting chapter menu entry: %s ... " this-very-menu-list)
  680.   (while this-very-menu-list
  681.     (insert "* " (car this-very-menu-list) "\n")
  682.     (setq this-very-menu-list (cdr this-very-menu-list)))
  683.   
  684.   (setq master-menu-list (cdr master-menu-list))
  685.  
  686.   (insert texinfo-master-menu-header)
  687.   
  688.   ;; Now, insert all the other menus
  689.  
  690.   ;; The menu master-menu-list has a form like this:
  691.   ;; ((("beta"  "alpha") "title-A")
  692.   ;;  (("delta" "gamma") "title-B"))
  693.  
  694.   (while master-menu-list
  695.  
  696.     (message
  697.      "Inserting menu for %s .... " (car (cdr (car master-menu-list))))
  698.     ;; insert title of menu section
  699.     (insert "\n" (car (cdr (car master-menu-list))) "\n\n")
  700.  
  701.     ;; insert each menu entry
  702.     (setq this-very-menu-list (reverse (car (car master-menu-list))))
  703.     (while this-very-menu-list
  704.       (insert "* " (car this-very-menu-list) "\n")
  705.       (setq this-very-menu-list (cdr this-very-menu-list)))
  706.     
  707.     (setq master-menu-list (cdr master-menu-list)))
  708.   
  709.   ;; Finish menu
  710.   (insert "@end menu\n\n")))
  711.  
  712. (defvar texinfo-master-menu-header
  713.   "\n --- The Detailed Node Listing ---\n"
  714.   "String inserted before lower level entries in Texinfo master menu.
  715. It comes after the chapter-level menu entries.")
  716.  
  717. (defun texinfo-locate-menu-p ()
  718.   "Find the next menu in the texinfo file.
  719. If found, leave point after word `menu' on the `@menu' line, and return t.
  720. If a menu is not found, do not move point and return nil."
  721.   (re-search-forward "\\(^@menu\\)" nil t))
  722.  
  723. (defun texinfo-copy-menu-title  ()
  724.   "Return the title of the section preceding the menu as a string.
  725. If such a title cannot be found, return an empty string.  Do not move
  726. point."
  727.   (save-excursion
  728.     (if (re-search-backward
  729.          (concat
  730.           "\\(^@node\\).*\n"            ; match node line
  731.           "\\(\\(^@c\\).*\n\\)?"        ; match comment line, if any
  732.           (eval
  733.            (cdr
  734.             (assoc (texinfo-hierarchic-level)
  735.                    texinfo-update-menu-higher-regexps))))
  736.          nil
  737.          t)
  738.         (texinfo-copy-section-title)
  739.       " ")))
  740.  
  741. (defun texinfo-copy-menu ()
  742.   "Return the entries of an existing menu as a list.
  743. Start with point just after the word `menu' in the `@menu' line
  744. and leave point on the line before the `@end menu' line."
  745.   (let* (this-menu-list
  746.          (end-of-menu (texinfo-menu-end)) ; position of end of `@end menu'
  747.          (last-entry (save-excursion      ; position of beginning of
  748.                                           ; last `* ' entry
  749.                       (goto-char end-of-menu)
  750.                       (re-search-backward "^\* ") ; handle multi-line desc.
  751.                       (point))))
  752.     (while (< (point) last-entry)
  753.       (if (re-search-forward  "^\* " end-of-menu t)
  754.           (progn
  755.             (setq this-menu-list
  756.                   (cons
  757.                    (buffer-substring 
  758.                     (point)
  759.                     ;; copy multi-line descriptions
  760.                     (save-excursion
  761.                       (re-search-forward "\\(^\* \\|^@e\\)" nil t)
  762.                       (- (point) 3)))
  763.                    this-menu-list)))))
  764.     this-menu-list))
  765.  
  766.  
  767. ;;;; Determining the hierarchical level in the texinfo file
  768.  
  769. (defun texinfo-specific-section-type () 
  770.   "Return the specific type of next section, as a string.
  771. For example, \"unnumberedsubsec\".  Return \"top\" for top node.
  772.  
  773. Searches forward for a section.  Hence, point must be before the
  774. section whose type will be found.  Does not move point.  Signal an
  775. error if the node is not the top node and a section is not found."
  776.   (save-excursion
  777.     (cond
  778.      ((re-search-forward "^@node [ \t]*top" nil t)
  779.       "top")
  780.      ((re-search-forward texinfo-section-types-regexp nil t)
  781.       (buffer-substring (progn (beginning-of-line) ; copy its name
  782.                                (1+ (point)))
  783.                         (progn (forward-word 1)
  784.                                (point))))
  785.      (t
  786.       (error
  787.        "texinfo-specific-section-type: Chapter or section not found.")))))
  788.  
  789. (defun texinfo-hierarchic-level ()
  790.   "Return the general hierarchal level of the next node in a texinfo file.
  791. Thus, a subheading or appendixsubsec is of type subsection."
  792.   (cdr (assoc
  793.         (texinfo-specific-section-type)
  794.         texinfo-section-to-generic-alist)))
  795.  
  796.  
  797. ;;;; Locating the major positions
  798.  
  799. (defun texinfo-update-menu-region-beginning (level)  
  800.   "Locate beginning of higher level section this section is within.
  801. Return position of the beginning of the node line; do not move point.
  802. Thus, if this level is subsection, searches backwards for section node.
  803. Only argument is a string of the general type of section."
  804.   
  805.   (cond
  806.    ((string-equal "top" level)
  807.     (save-excursion
  808.       (re-search-forward "^@node [ \t]*top" nil t) (point)))
  809.    ((string-equal "chapter" level)
  810.     (save-excursion
  811.       (re-search-backward "^@node [ \t]*top" nil t) (point)))
  812.    (t
  813.     (save-excursion
  814.       (re-search-backward
  815.        (concat
  816.         "\\(^@node\\).*\n"            ; match node line
  817.         "\\(\\(^@c\\).*\n\\)?"        ; match comment line, if any
  818.         (eval
  819.          (cdr (assoc level texinfo-update-menu-higher-regexps))))
  820.        nil
  821.        'goto-beginning)
  822.       (point)))))
  823.  
  824. (defun texinfo-update-menu-region-end (level)  
  825.   "Locate end of higher level section this section is within.
  826. Return position; do not move point.  Thus, if this level is a
  827. subsection, find the node for the section this subsection is within.
  828. If level is top or chapter, returns end of file.  Only argument is a
  829. string of the general type of section."
  830.  
  831.   (save-excursion
  832.     (if (re-search-forward
  833.          (concat
  834.           "\\(^@node\\).*\n"            ; match node line
  835.           "\\(\\(^@c\\).*\n\\)?"        ; match comment line, if any
  836.           (eval
  837.            (cdr (assoc level texinfo-update-menu-higher-regexps))))
  838.          nil
  839.          'goto-end)
  840.         (match-beginning 1)
  841.       (point-max))))
  842.  
  843. (defun texinfo-menu-first-node (beginning end)
  844.   "Locate first node of the section the menu will be placed in.  
  845. Return position; do not move point.
  846. The menu will be located just before this position.  
  847.  
  848. First argument is the position of the beginning of the section in
  849. which the menu will be located; second argument is the position of the
  850. end of that region; it limits the search."
  851.   
  852.   (save-excursion
  853.     (goto-char beginning)
  854.     (forward-line 1)
  855.     (re-search-forward "^@node" end t)
  856.     (beginning-of-line)
  857.     (point)))
  858.  
  859.  
  860. ;;;; Alists and regular expressions for defining hierarchical levels
  861.  
  862. (defvar texinfo-section-to-generic-alist
  863.   '(("top" . "top")
  864.  
  865.     ("chapter" . "chapter")
  866.     ("unnumbered" . "chapter")
  867.     ("majorheading" . "chapter")
  868.     ("chapheading" . "chapter")
  869.     ("appendix" . "chapter")
  870.     
  871.     ("section" . "section")
  872.     ("unnumberedsec" . "section")
  873.     ("heading" . "section")
  874.     ("appendixsec" . "section")
  875.     
  876.     ("subsection" . "subsection")
  877.     ("unnumberedsubsec" . "subsection")
  878.     ("subheading" . "subsection")
  879.     ("appendixsubsec" . "subsection")
  880.     
  881.     ("subsubsection" . "subsubsection")
  882.     ("unnumberedsubsubsec" . "subsubsection")
  883.     ("subsubheading" . "subsubsection")
  884.     ("appendixsubsubsec" . "subsubsection"))
  885.   "*An alist of specific and corresponding generic Texinfo section types.
  886. The keys are strings specifying specific types of section; the values
  887. are strings of their corresponding general types.")
  888.  
  889. (defvar texinfo-section-types-regexp
  890.   "^@\\(chapter \\|sect\\|sub\\|unnum\\|major\\|heading \\|appendix\\)"
  891.   "Regexp matching chapter, section, other headings (but not the top node).")
  892.  
  893. (defvar texinfo-chapter-level-regexp 
  894.   "chapter\\|unnumbered \\|appendix \\|majorheading\\|chapheading"
  895.   "Regular expression matching just the Texinfo chapter level headings.")
  896.  
  897. (defvar texinfo-section-level-regexp 
  898.   "section\\|unnumberedsec\\|heading \\|appendixsec"
  899.   "Regular expression matching just the Texinfo section level headings.")
  900.  
  901. (defvar texinfo-subsection-level-regexp 
  902.   "subsection\\|unnumberedsubsec\\|subheading\\|appendixsubsec"
  903.   "Regular expression matching just the Texinfo subsection level headings.")
  904.  
  905. (defvar texinfo-subsubsection-level-regexp
  906.   "subsubsection\\|unnumberedsubsubsec\\|subsubheading\\|appendixsubsubsec"
  907.   "Regular expression matching just the Texinfo subsubsection level headings.")
  908.  
  909. (defvar texinfo-update-menu-same-level-regexps
  910.   '(("top" . "top[ \t]+")
  911.     ("chapter" . 
  912.      (concat "\\(^@\\)\\(" texinfo-chapter-level-regexp "\\)[ \t]*"))
  913.     ("section" . 
  914.      (concat "\\(^@\\)\\(" texinfo-section-level-regexp "\\)[ \t]*"))
  915.     ("subsection" .  
  916.      (concat "\\(^@\\)\\(" texinfo-subsection-level-regexp "\\)[ \t]+"))
  917.     ("subsubsection" . 
  918.      (concat "\\(^@\\)\\(" texinfo-subsubsection-level-regexp "\\)[ \t]+")))
  919.   "*Regexps for searching for same level sections in a Texinfo file.
  920. The keys are strings specifying the general hierarchical level in the
  921. document; the values are regular expressions.")
  922.  
  923. (defvar texinfo-update-menu-higher-regexps
  924.   '(("top" . "^@node [ \t]*DIR") 
  925.     ("chapter" . "^@node [ \t]*top")
  926.     ("section" .
  927.      (concat 
  928.       "\\(^@\\("
  929.       texinfo-chapter-level-regexp
  930.       "\\)[ \t]*\\)"))
  931.     ("subsection" .
  932.      (concat 
  933.       "\\(^@\\("
  934.       texinfo-section-level-regexp
  935.       "\\|"
  936.       texinfo-chapter-level-regexp
  937.       "\\)[ \t]*\\)"))
  938.     ("subsubsection" .
  939.      (concat 
  940.       "\\(^@\\("
  941.       texinfo-subsection-level-regexp
  942.       "\\|"
  943.       texinfo-section-level-regexp
  944.       "\\|"
  945.       texinfo-chapter-level-regexp
  946.       "\\)[ \t]*\\)")))
  947.   "*Regexps for searching for higher level sections in a Texinfo file.
  948. The keys are strings specifying the general hierarchical level in the
  949. document; the values are regular expressions.")
  950.  
  951. (defvar texinfo-update-menu-lower-regexps
  952.   '(("top" . 
  953.      (concat 
  954.       "\\(^@\\("
  955.       texinfo-chapter-level-regexp
  956.       "\\|"
  957.       texinfo-section-level-regexp
  958.       "\\|"
  959.       texinfo-subsection-level-regexp
  960.       "\\|"
  961.       texinfo-subsubsection-level-regexp
  962.       "\\)[ \t]*\\)"))
  963.     ("chapter" . 
  964.      (concat 
  965.       "\\(^@\\("
  966.       texinfo-section-level-regexp
  967.       "\\|"
  968.       texinfo-subsection-level-regexp
  969.       "\\|"
  970.       texinfo-subsubsection-level-regexp
  971.       "\\)[ \t]*\\)"))
  972.     ("section" .
  973.      (concat 
  974.       "\\(^@\\("
  975.       texinfo-subsection-level-regexp
  976.       "\\|"
  977.       texinfo-subsubsection-level-regexp
  978.       "\\)[ \t]+\\)"))
  979.     ("subsection" .
  980.      (concat 
  981.       "\\(^@\\("
  982.       texinfo-subsubsection-level-regexp
  983.       "\\)[ \t]+\\)"))
  984.     ("subsubsection" . "nothing lower"))
  985.   "*Regexps for searching for lower level sections in a Texinfo file.
  986. The keys are strings specifying the general hierarchical level in the
  987. document; the values are regular expressions.")
  988.  
  989.  
  990. ;;;; Updating a Node
  991.  
  992. (defun texinfo-update-node (&optional region-p)
  993.   "Without any prefix argument, update the node in which point is located.
  994. Non-nil argument (prefix, if interactive) means update the nodes in the
  995. marked region.
  996.  
  997. The functions for creating or updating nodes and menus, and their
  998. keybindings, are:
  999.  
  1000.     texinfo-update-node (&optional region-p)    \\[texinfo-update-node]
  1001.     texinfo-every-node-update ()                \\[texinfo-every-node-update]
  1002.     texinfo-sequential-node-update (&optional region-p)
  1003.  
  1004.     texinfo-make-menu (&optional region-p)      \\[texinfo-make-menu]
  1005.     texinfo-all-menus-update ()                 \\[texinfo-all-menus-update]
  1006.     texinfo-master-menu ()
  1007.  
  1008.     texinfo-indent-menu-description (column &optional region-p)
  1009.  
  1010. The `texinfo-column-for-description' variable specifies the column to
  1011. which menu descriptions are indented. Its default value is 24."
  1012.   
  1013.   (interactive "P")
  1014.   (if (not region-p)
  1015.       (let ((auto-fill-hook nil)) ; update a single node
  1016.         (if (not (re-search-backward "^@node" (point-min) t))
  1017.             (error "Node line not found before this position."))
  1018.         (texinfo-update-the-node)
  1019.         (message "Done...updated the node.  You may save the buffer."))
  1020.     ;; else
  1021.     (let ((auto-fill-hook nil)
  1022.           (beginning (region-beginning))
  1023.       (end (region-end)))
  1024.       (if (= end beginning)
  1025.           (error "Please mark a region!"))
  1026.       (save-restriction
  1027.     (narrow-to-region beginning end)
  1028.     (goto-char beginning)
  1029.         (push-mark)
  1030.     (while (re-search-forward "^@node" (point-max) t)
  1031.           (beginning-of-line)            
  1032.           (texinfo-update-the-node))
  1033.         (message "Done...updated nodes in region.  You may save the buffer.")))))
  1034.  
  1035. (defun texinfo-every-node-update ()
  1036.   "Update every node in a Texinfo file."
  1037.   (interactive)
  1038.   (save-excursion
  1039.     (mark-whole-buffer)
  1040.     (texinfo-update-node t)
  1041.     (message "Done...updated every node.       You may save the buffer.")))
  1042.  
  1043. (defun texinfo-update-the-node ()
  1044.   "Update one node.  Point must be at the beginning of node line.  
  1045. Leave point at the end of the node line."
  1046.   (texinfo-check-for-node-name)
  1047.   (texinfo-delete-existing-pointers)
  1048.   (message "Updating node: %s ... " (texinfo-copy-node-name))
  1049.   (save-restriction
  1050.     (widen)
  1051.     (let*
  1052.         ((case-fold-search t)
  1053.          (level (texinfo-hierarchic-level))
  1054.          (beginning (texinfo-update-menu-region-beginning level))
  1055.          (end (texinfo-update-menu-region-end level)))
  1056.       (if (string-equal level "top")
  1057.           (texinfo-top-pointer-case)
  1058.         ;; else
  1059.         (texinfo-insert-pointer beginning end level 'next)
  1060.         (texinfo-insert-pointer beginning end level 'previous)
  1061.         (texinfo-insert-pointer beginning end level 'up)
  1062.         (texinfo-clean-up-node-line)))))
  1063.  
  1064. (defun texinfo-top-pointer-case ()
  1065.   "Insert pointers in the Top node.  This is a special case.
  1066.  
  1067. The `Next' pointer is a pointer to a chapter or section at a lower
  1068. hierarchical level in the file.  The `Previous' and `Up' pointers are
  1069. to `(dir)'.  Point must be at the beginning of the node line, and is
  1070. left at the end of the node line."
  1071.  
  1072.   (texinfo-clean-up-node-line)
  1073.   (insert ", " 
  1074.           (save-excursion
  1075.             ;; There may be an @chapter or other such command between
  1076.             ;; the top node line and the next node line, as a title
  1077.             ;; for an `ifinfo' section. This @chapter command must
  1078.             ;; must be skipped.  So the procedure is to search for
  1079.             ;; the next `@node' line, and then copy its name.
  1080.             (if (re-search-forward "^@node" nil t)
  1081.                 (progn
  1082.                   (beginning-of-line)
  1083.                   (texinfo-copy-node-name))
  1084.               " "))
  1085.           ", (dir), (dir)"))
  1086.  
  1087. (defun texinfo-check-for-node-name ()
  1088.   "Determine whether the node has a node name.  Prompt for one if not.
  1089. Point must be at beginning of node line.  Does not move point."
  1090.   (save-excursion
  1091.     (forward-word 1)                    ; skip over node command
  1092.     (skip-chars-forward " \t")          ; and over spaces
  1093.     (if (not (looking-at "[^,\t\n ]+")) ; regexp based on what info looks for
  1094.                                         ; alternatively, use "[a-zA-Z]+"
  1095.         (let ((node-name (read-from-minibuffer "Node name: ")))
  1096.           (insert " " node-name)))))
  1097.  
  1098. (defun texinfo-delete-existing-pointers ()
  1099.   "Delete `Next', `Previous', and `Up' pointers.  
  1100. Starts from the current position of the cursor, and searches forward
  1101. on the line for a comma and if one is found, deletes the rest of the
  1102. line, including the comma.  Leaves point at beginning of line."
  1103.   (if (search-forward "," (save-excursion (end-of-line) (point)) t)
  1104.       (progn
  1105.         (goto-char (1- (point)))
  1106.         (kill-line nil)))
  1107.   (beginning-of-line))
  1108.  
  1109. (defun texinfo-find-pointer (beginning end level direction)
  1110.   "Move point to section associated with next, previous, or up pointer.
  1111. Return type of pointer (either 'normal or 'no-pointer).
  1112.  
  1113. The first and second arguments bound the search for a pointer to the
  1114. beginning and end, respectively, of the enclosing higher level
  1115. section.  The third argument is a string specifying the general kind
  1116. of section such as \"chapter\ or \"section\".  When looking for the
  1117. `Next' pointer, the section found will be at the same hierarchical
  1118. level in the Texinfo file; when looking for the `Previous' pointer,
  1119. the section found will be at the same or higher hierarchical level in
  1120. the Texinfo file; when looking for the `Up' pointer, the section found
  1121. will be at some level higher in the Texinfo file.  The fourth argument
  1122. (one of 'next, 'previous, or 'up) specifies whether to find the
  1123. `Next', `Previous', or `Up' pointer."
  1124.  
  1125.   (cond ((eq direction 'next)
  1126.          (forward-line 3)             ; skip over current node
  1127.          (if (re-search-forward
  1128.               (eval
  1129.                (cdr (assoc level texinfo-update-menu-same-level-regexps)))
  1130.               end
  1131.               t)
  1132.              'normal
  1133.            'no-pointer))
  1134.         ((eq direction 'previous)
  1135.          (if (re-search-backward
  1136.               (concat
  1137.                "\\("
  1138.                (eval
  1139.                 (cdr (assoc level texinfo-update-menu-same-level-regexps)))
  1140.                "\\|"
  1141.                (eval
  1142.                 (cdr (assoc level texinfo-update-menu-higher-regexps)))
  1143.                "\\)")
  1144.               beginning
  1145.               t)
  1146.              'normal
  1147.            'no-pointer))
  1148.         ((eq direction 'up)
  1149.          (if (re-search-backward
  1150.              (eval (cdr (assoc level texinfo-update-menu-higher-regexps)))
  1151.               beginning
  1152.               t)
  1153.              'normal
  1154.            'no-pointer))
  1155.         (t
  1156.          (error "texinfo-find-pointer: lack proper arguments"))))
  1157.  
  1158. (defun texinfo-pointer-name (kind)
  1159.   "Return the node name preceding the section command.
  1160. The argument is the kind of section, either normal or no-pointer."
  1161.   (let (name)
  1162.     (cond ((eq kind 'normal)
  1163.            (end-of-line)                ; this handles prev node top case
  1164.            (re-search-backward          ; when point is already 
  1165.             "^@node"                    ; at the beginning of @node line
  1166.             (save-excursion (forward-line -3))
  1167.             t)
  1168.            (setq name (texinfo-copy-node-name)))
  1169.       ((eq kind 'no-pointer)
  1170.        (setq name " ")))    ; put a blank in the pointer slot
  1171.     name))
  1172.  
  1173. (defun texinfo-insert-pointer (beginning end level direction)
  1174.   "Insert the `Next', `Previous' or `Up' node name at point.
  1175. Move point forward.  
  1176.  
  1177. The first and second arguments bound the search for a pointer to the
  1178. beginning and end, respectively, of the enclosing higher level
  1179. section.  The third argument is the hierarchical level of the Texinfo
  1180. file, a string such as \"section\".  The fourth argument is direction
  1181. towards which the pointer is directed, one of `next, `previous, or
  1182. 'up."
  1183.  
  1184.   (end-of-line)
  1185.   (insert
  1186.    ", "
  1187.    (save-excursion
  1188.      (texinfo-pointer-name
  1189.       (texinfo-find-pointer beginning end level direction)))))
  1190.  
  1191. (defun texinfo-clean-up-node-line ()
  1192.   "Remove extra commas, if any, at end of node line."
  1193.   (end-of-line)
  1194.   (skip-chars-backward ", ")
  1195.   (delete-region (point) (save-excursion (end-of-line) (point))))
  1196.  
  1197.  
  1198. ;;;; Updating nodes sequentially
  1199. ; These sequential update functions insert `Next' or `Previous'
  1200. ; pointers that point to the following or preceding nodes even if they
  1201. ; are at higher or lower hierarchical levels.  This means that if a
  1202. ; section contains one or more subsections, the section's `Next'
  1203. ; pointer will point to the subsection and not the following section.
  1204. ; (The subsection to which `Next' points will most likely be the first
  1205. ; item on the section's menu.)
  1206.  
  1207. (defun texinfo-sequential-node-update (&optional region-p)
  1208.   "Update one node (or many) in a Texinfo file with sequential pointers.
  1209.  
  1210. This function causes the `Next' or `Previous' pointer to point to the
  1211. immediately preceding or following node, even if it is at a higher or
  1212. lower hierarchical level in the document.  Continually pressing `n' or
  1213. `p' takes you straight through the file.
  1214.  
  1215. Without any prefix argument, update the node in which point is located.
  1216. Non-nil argument (prefix, if interactive) means update the nodes in the
  1217. marked region.
  1218.  
  1219. This command makes it awkward to navigate among sections and
  1220. subsections; it should be used only for those documents that are meant
  1221. to be read like a novel rather than a reference, and for which the
  1222. Info `g*' command is inadequate."
  1223.   
  1224.   (interactive "P")
  1225.   (if (not region-p)
  1226.       (let ((auto-fill-hook nil))   ; update a single node
  1227.         (if (not (re-search-backward "^@node" (point-min) t))
  1228.             (error "Node line not found before this position."))
  1229.         (texinfo-sequentially-update-the-node)
  1230.         (message 
  1231.          "Done...sequentially updated the node .  You may save the buffer."))
  1232.     ;; else
  1233.     (let ((auto-fill-hook nil)
  1234.           (beginning (region-beginning))
  1235.           (end (region-end)))
  1236.       (if (= end beginning)
  1237.           (error "Please mark a region!"))
  1238.       (save-restriction
  1239.         (narrow-to-region beginning end)
  1240.         (goto-char beginning)
  1241.         (push-mark)
  1242.         (while (re-search-forward "^@node" (point-max) t)
  1243.           (beginning-of-line)            
  1244.           (texinfo-sequentially-update-the-node))
  1245.         (message 
  1246.          "Done...updated the nodes in sequence.  You may save the buffer.")))))
  1247.  
  1248. (defun texinfo-sequentially-update-the-node ()
  1249.   "Update one node such that the pointers are sequential. 
  1250. A `Next' or `Previous' pointer points to any preceding or following node,
  1251. regardless of its hierarchical level."
  1252.  
  1253.         (texinfo-check-for-node-name)
  1254.         (texinfo-delete-existing-pointers)
  1255.         (message 
  1256.          "Sequentially updating node: %s ... " (texinfo-copy-node-name))
  1257.         (save-restriction
  1258.           (widen)
  1259.           (let*
  1260.               ((case-fold-search t)
  1261.                (level (texinfo-hierarchic-level)))
  1262.             (if (string-equal level "top")
  1263.                 (texinfo-top-pointer-case)
  1264.               ;; else
  1265.               (texinfo-sequentially-insert-pointer level 'next)
  1266.               (texinfo-sequentially-insert-pointer level 'previous)
  1267.               (texinfo-sequentially-insert-pointer level 'up)
  1268.               (texinfo-clean-up-node-line)))))
  1269.  
  1270. (defun texinfo-sequentially-find-pointer (level direction)
  1271.   "Find next or previous pointer sequentially in Texinfo file, or up pointer.
  1272. Move point to section associated with the pointer.  Find point even if
  1273. it is in a different section.
  1274.  
  1275. Return type of pointer (either 'normal or 'no-pointer).
  1276.  
  1277. The first argument is a string specifying the general kind of section
  1278. such as \"chapter\ or \"section\".  The section found will be at the
  1279. same hierarchical level in the Texinfo file, or, in the case of the up
  1280. pointer, some level higher.  The second argument (one of 'next,
  1281. 'previous, or 'up) specifies whether to find the `Next', `Previous',
  1282. or `Up' pointer."
  1283.   
  1284.   (cond ((eq direction 'next)
  1285.          (forward-line 3)             ; skip over current node
  1286.          (if (re-search-forward 
  1287.               texinfo-section-types-regexp
  1288.               (point-max)
  1289.               t)
  1290.              'normal
  1291.            'no-pointer))
  1292.         ((eq direction 'previous)
  1293.          (if (re-search-backward 
  1294.               texinfo-section-types-regexp
  1295.               (point-min)
  1296.               t)
  1297.              'normal
  1298.            'no-pointer))
  1299.         ((eq direction 'up)
  1300.          (if (re-search-backward
  1301.               (eval (cdr (assoc level texinfo-update-menu-higher-regexps)))
  1302.               beginning
  1303.               t)
  1304.              'normal
  1305.            'no-pointer))
  1306.         (t
  1307.          (error "texinfo-sequential-find-pointer: lack proper arguments"))))
  1308.  
  1309. (defun texinfo-sequentially-insert-pointer (level direction)
  1310.   "Insert the `Next', `Previous' or `Up' node name at point.
  1311. Move point forward.  
  1312.  
  1313. The first argument is the hierarchical level of the Texinfo file, a
  1314. string such as \"section\".  The second argument is direction, one of
  1315. `next, `previous, or 'up."
  1316.  
  1317.   (end-of-line)
  1318.   (insert
  1319.    ", "
  1320.    (save-excursion
  1321.      (texinfo-pointer-name
  1322.       (texinfo-sequentially-find-pointer level direction)))))
  1323.  
  1324.  
  1325. ;;;; Inserting `@node' lines
  1326. ; The `texinfo-insert-node-lines' function inserts `@node' lines as needed
  1327. ; before the `@chapter', `@section', and such like lines of a region
  1328. ; in a Texinfo file.
  1329.  
  1330. (defun texinfo-insert-node-lines (&optional title-p)
  1331.   "Insert missing `@node' lines in region of Texinfo file.
  1332. Non-nil argument (prefix, if interactive) means also to insert the
  1333. section titles as node names; and also to insert the section titles as
  1334. node names in pre-existing @node lines that lack names."
  1335.   (interactive "P")
  1336.   (save-excursion
  1337.     (let ((begin-region  (region-beginning))
  1338.           (end-region (region-end)))
  1339.       (goto-char begin-region)
  1340.       (while (< (point) end-region)
  1341.         (re-search-forward texinfo-section-types-regexp nil 'end)
  1342.         ;; copy title, since most often, we will need it
  1343.         (let ((title
  1344.                (progn
  1345.                  (beginning-of-line)
  1346.                  (forward-word 1)
  1347.                  (skip-chars-forward " \t")
  1348.                  (buffer-substring
  1349.                   (point)
  1350.                   (save-excursion (end-of-line) (point))))))
  1351.           ;; insert a node if necessary
  1352.           (if (re-search-backward
  1353.                "^@node"
  1354.                (save-excursion
  1355.                  (forward-line -3)
  1356.                  (point))
  1357.                t)
  1358.               ;;  @node present, and point at beginning of that line
  1359.               (forward-word 1)
  1360.             ;; else @node missing, insert one
  1361.             (progn
  1362.               (beginning-of-line)       ; beginning of `@section' line
  1363.               (insert "@node\n")
  1364.               (backward-char 1)))       ; leave point just after `@node'
  1365.           ;; insert a title if warranted
  1366.           (if title-p
  1367.               (progn
  1368.                 (skip-chars-forward " \t")
  1369.                 ;; use regexp based on what info looks for
  1370.                 ;; (alternatively, use "[a-zA-Z]+")
  1371.                 (if (not (looking-at "[^,\t\n ]+")) 
  1372.                     (progn
  1373.                       (beginning-of-line) 
  1374.                       (forward-word 1)
  1375.                       (insert " " title)
  1376.                       (message "Inserted title %s ... " title)))))
  1377.           ;; in any case, go forward beyond current section title
  1378.           (forward-line 3)))))
  1379.   (if title-p
  1380.       (message
  1381.        "Done inserting node lines and titles.  You may save the buffer.")
  1382.     (message "Done inserting node lines.  You may save the buffer.")))
  1383.  
  1384. ;;;;;;;;;;;;;;;; end texnfo-upd.el ;;;;;;;;;;;;;;;;
  1385.