Annotation of OpenXM_contrib/gnuplot/docs/doc2texi.el, Revision 1.1
1.1 ! maekawa 1: ;;;; doc2texi.el -- generate a texinfo file from the gnuplot doc file
! 2:
! 3: ;; Copyright (C) 1999 Bruce Ravel
! 4:
! 5: ;; Author: Bruce Ravel <ravel@phys.washington.edu>
! 6: ;; Maintainer: Bruce Ravel <ravel@phys.washington.edu>
! 7: ;; Created: March 23 1999
! 8: ;; Updated: May 28 1999
! 9: ;; Version: 0.2
! 10: ;; Keywords: gnuplot, document, info
! 11:
! 12: ;; This file is not part of GNU Emacs.
! 13:
! 14: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
! 15: ;; This lisp script 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.
! 18: ;;
! 19: ;; Permission is granted to distribute copies of this lisp script
! 20: ;; provided the copyright notice and this permission are preserved in
! 21: ;; all copies.
! 22: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
! 23: ;; send bug reports to the author (ravel@phys.washington.edu)
! 24: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
! 25: ;;; Commentary:
! 26: ;;
! 27: ;; I suppose the most immediate question to ask is "Why do this in
! 28: ;; emacs lisp???" While it is true that the gnuplot.doc file lends
! 29: ;; itself to processing by a 1 pass filter, there are some aspects of
! 30: ;; texinfo files that are a bit tricky and would require 2 or perhaps
! 31: ;; three passes. Specifically, getting all of the cross references
! 32: ;; made correctly is a lot of work. Fortunately, texinfo-mode has
! 33: ;; functions for building menus and updating nodes. This saves a lot
! 34: ;; of sweat and is the principle reason why I decided to write this is
! 35: ;; emacs lisp.
! 36: ;;
! 37: ;; Everything else in gnuplot is written in C for the sake of
! 38: ;; portability. Emacs lisp, of course, requires that you have emacs.
! 39: ;; For many gnuplot users, that is not a good assumption. However,
! 40: ;; the likelihood of needing info files in the absence of emacs is
! 41: ;; very, very slim. I think it is safe to say that someone who needs
! 42: ;; info files has emacs installed and thus will be able to use this
! 43: ;; program.
! 44: ;;
! 45: ;; Since this is emacs, I am not treating the gnuplot.doc file as a
! 46: ;; text stream. It seems much more efficient in this context to treat
! 47: ;; it as a buffer. All of the work is done by the function
! 48: ;; `d2t-doc-to-texi'. Each of the conversion chores is handled by an
! 49: ;; individual function. Each of thse functions is very similar in
! 50: ;; structure. They start at the top of the buffer, search forward for
! 51: ;; a line matching the text element being converted, perform the
! 52: ;; replacement in place, and move on until the end of the buffer.
! 53: ;; These text manipulations are actually quite speedy. The slow part
! 54: ;; of the process is using the texinfo-mode function to update the
! 55: ;; nodes and menus. However, using these slow functions has one
! 56: ;; advantage -- the texinfo-mode functions for doing menus and nodes
! 57: ;; are certain to do the job correctly. Although rather slow, this
! 58: ;; approach doesn't totally suck compared to the time cost of
! 59: ;; compiling and running a C program. And the output from this is
! 60: ;; much more useful than the output from the doc2info program.
! 61: ;;
! 62: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
! 63: ;;; Use:
! 64: ;;
! 65: ;; Customize the variables at the start of the executable code. Then
! 66: ;; I intend that this be used from the command line or from a Makefile
! 67: ;; like so:
! 68: ;;
! 69: ;; emacs -batch -l doc2texi.el -f d2t-doc-to-texi
! 70: ;;
! 71: ;; or
! 72: ;;
! 73: ;; emacs -batch -l doc2texi.el -f d2t-doc-to-texi-verbosely
! 74: ;;
! 75: ;; This will start emacs in batch mode, load this file, run the
! 76: ;; converter, then quit. This takes about 30 seconds my 133 MHz
! 77: ;; Pentium. It also sends a large number of mesages to stderr, so you
! 78: ;; may want to redirect stderr to /dev/null or to a file.
! 79: ;;
! 80: ;; Then you can do
! 81: ;;
! 82: ;; makeinfo gnuplot.info
! 83: ;;
! 84: ;; You may want to use the --no-split option.
! 85: ;;
! 86: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
! 87: ;;; History:
! 88: ;;
! 89: ;; 0.1 Mar 23 1999 <BR> Initial version
! 90: ;; 0.2 May 28 1999 <BR>
! 91: ;; 0.3 Jun 2 1999 <BR> Added terminal information, fixed uref problem.
! 92: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
! 93: ;;; Acknowledgements:
! 94: ;;
! 95: ;; Lars Hecking asked me to look into the doc -> info problem. Silly
! 96: ;; me, I said "ok." This is what I came up with.
! 97: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
! 98: ;;; To do:
! 99: ;;
! 100: ;; -- internal cross-references: these are not perfect due to
! 101: ;; inconsistencies in the use of `` and case inconsistencies in
! 102: ;; the text. The latter can be fixed. Also I need a way to not
! 103: ;; make the @ref if point is currently in that region.
! 104: ;; -- catch errors gracefully, particularly when looking for files.
! 105: ;; -- are guesses about OS specific terminal information correct?
! 106: ;; -- turn the lists in the "What's New" and "xlabel" sections into
! 107: ;; proper lists. "^\\([0-9]\\)+\." finds the list items. If
! 108: ;; (match-string 1) is "1" then insert "@enumerate\n@item\n", else
! 109: ;; insert "@item\n". also use (replace-match ""). need to find
! 110: ;; the end somehow.
! 111: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
! 112: ;;; Code:
! 113:
! 114: ;;; You may need to customize these variables:
! 115: (defvar d2t-doc-file-name "gnuplot.doc"
! 116: "Name of the gnuplot.doc file.")
! 117: (defvar d2t-terminal-directory (expand-file-name "../term/")
! 118: "Location of .trm files in gnuplot source tree.")
! 119:
! 120:
! 121: ;;; You should not need to touch anything below here ;;;;;;;;;;;;;;;;;;;;;
! 122:
! 123: (require 'cl)
! 124: (eval-and-compile ; need split-string to do xrefs
! 125: (if (fboundp 'split-string)
! 126: ()
! 127: (defun split-string (string &optional pattern)
! 128: "Return a list of substrings of STRING which are separated by PATTERN.
! 129: If PATTERN is omitted, it defaults to \"[ \\f\\t\\n\\r\\v]+\"."
! 130: (or pattern
! 131: (setq pattern "[ \f\t\n\r\v]+"))
! 132: (let (parts (start 0))
! 133: (while (string-match pattern string start)
! 134: (setq parts (cons (substring string start (match-beginning 0)) parts)
! 135: start (match-end 0)))
! 136: (nreverse (cons (substring string start) parts)))) ))
! 137:
! 138: (defconst d2t-work-buffer-name "*doc2texi*"
! 139: "Name of scratch buffer where the doc file will be converted into a
! 140: texi file.")
! 141: (defconst d2t-scratch-buffer-name "*doc2texi-output*")
! 142: (defconst d2t-terminal-buffer-name "*doc2texi-terminal*")
! 143: (defvar d2t-verbose nil)
! 144: (defconst d2t-texi-filename "gnuplot.texi")
! 145:
! 146: (defconst d2t-texi-header
! 147: "\\input texinfo @c -*-texinfo-*-
! 148:
! 149: @c %**start of header
! 150: @setfilename gnuplot.info
! 151: @settitle Gnuplot: An Interactive Plotting Program
! 152: @setchapternewpage odd
! 153: @c %**end of header
! 154:
! 155: @c define the command and options indeces
! 156: @defindex cm
! 157: @defindex op
! 158: @defindex tm
! 159:
! 160: @direntry
! 161: * GNUPLOT: (gnuplot). An Interactive Plotting Program
! 162: @end direntry
! 163:
! 164: @ifnottex
! 165: @node Top, gnuplot, (dir), (dir)
! 166: @top Master Menu
! 167: @end ifnottex
! 168:
! 169: @example
! 170: GNUPLOT
! 171:
! 172: An Interactive Plotting Program
! 173: Thomas Williams & Colin Kelley
! 174: Version 3.7 organized by: David Denholm
! 175:
! 176: Copyright (C) 1986 - 1993, 1998 Thomas Williams, Colin Kelley
! 177:
! 178: Mailing list for comments: info-gnuplot@@dartmouth.edu
! 179: Mailing list for bug reports: bug-gnuplot@@dartmouth.edu
! 180:
! 181: This manual was prepared by Dick Crawford
! 182: 3 December 1998
! 183:
! 184:
! 185: Major contributors (alphabetic order):
! 186: @end example
! 187:
! 188: "
! 189: "Texinfo header.")
! 190:
! 191: (defconst d2t-main-menu
! 192: "@menu
! 193: @end menu"
! 194: "Main menu.")
! 195:
! 196: (defconst d2t-texi-footer
! 197: "@node Concept_Index, Command_Index, Bugs, Top
! 198: @unnumbered Concept Index
! 199: @printindex cp
! 200:
! 201: @node Command_Index, Option_Index, Concept_Index, Top
! 202: @unnumbered Command Index
! 203: @printindex cm
! 204:
! 205: @node Options_Index, Function_Index, Command_Index, Top
! 206: @unnumbered Options Index
! 207: @printindex op
! 208:
! 209: @node Function_Index, Terminal_Index, Options_Index, Top
! 210: @unnumbered Function Index
! 211: @printindex fn
! 212:
! 213: @node Terminal_Index, , Options_Index, Top
! 214: @unnumbered Terminal Index
! 215: @printindex tm
! 216:
! 217: @c @shortcontents
! 218: @contents
! 219: @bye
! 220: "
! 221: "Texinfo file terminator.")
! 222:
! 223: (defvar d2t-level-1-alist nil
! 224: "Alist of level 1 tags and markers.")
! 225: (defvar d2t-level-2-alist nil
! 226: "Alist of level 2 tags and markers.")
! 227: (defvar d2t-level-3-alist nil
! 228: "Alist of level 3 tags and markers.")
! 229: (defvar d2t-level-4-alist nil
! 230: "Alist of level 4 tags and markers.")
! 231: (defvar d2t-level-5-alist nil
! 232: "Alist of level 5 tags and markers.")
! 233: (defvar d2t-commands-alist nil
! 234: "Alist of commands and markers.")
! 235: (defvar d2t-set-show-alist nil
! 236: "Alist of options and markers.")
! 237: (defvar d2t-functions-alist nil
! 238: "Alist of functions and markers.")
! 239: (defvar d2t-terminals-alist nil
! 240: "Alist of terminal types and markers.")
! 241: (defvar d2t-node-list nil
! 242: "List of nodes.")
! 243:
! 244: (defvar d2t-terminal-list ())
! 245: (setq d2t-terminal-list
! 246: '("ai"
! 247: "cgm"
! 248: "corel"
! 249: "dumb"
! 250: "dxf"
! 251: "eepic"
! 252: "epson"
! 253: "fig"
! 254: "gif"
! 255: "hp26"
! 256: "hp2648"
! 257: "hp500c"
! 258: "hpgl"
! 259: "hpljii"
! 260: "hppj"
! 261: "imagen"
! 262: "latex"
! 263: "metafont"
! 264: "mif"
! 265: "pbm"
! 266: "png"
! 267: "post"
! 268: "pslatex"
! 269: "pstricks"
! 270: "qms"
! 271: "table"
! 272: "tek"
! 273: "texdraw"
! 274: "tkcanvas"
! 275: "tpic"))
! 276:
! 277: (defun d2t-doc-to-texi-verbosely ()
! 278: "Run `d2t-doc-to-texi' noisily"
! 279: (interactive)
! 280: (setq d2t-verbose t)
! 281: (d2t-doc-to-texi))
! 282:
! 283: (defun d2t-doc-to-texi ()
! 284: "This is the doc to texi converter function.
! 285: It calls a bunch of other functions, each of which handles one
! 286: particular conversion chore."
! 287: (interactive)
! 288: (setq d2t-level-1-alist nil ;; initialize variables
! 289: d2t-level-2-alist nil
! 290: d2t-level-3-alist nil
! 291: d2t-level-4-alist nil
! 292: d2t-level-5-alist nil
! 293: d2t-commands-alist nil
! 294: d2t-set-show-alist nil
! 295: d2t-functions-alist nil
! 296: d2t-terminals-alist nil
! 297: d2t-node-list nil)
! 298: ;; open the doc file and get some data about its contents
! 299: (d2t-prepare-workspace)
! 300: (message "Inserting help for terminals ...")
! 301: (d2t-get-terminals)
! 302: (message "Analyzing doc file ...")
! 303: (d2t-get-levels)
! 304: (d2t-get-commands)
! 305: (d2t-get-set-show)
! 306: (d2t-get-functions)
! 307: ;; convert the buffer from doc to texi, one element at a time
! 308: (message "Converting to texinfo ...")
! 309: (d2t-braces-atsigns) ;; this must be the first conversion function
! 310: (d2t-comments) ;; delete comments
! 311: (d2t-sectioning) ;; chapters, sections, etc
! 312: (d2t-indexing) ;; index markup
! 313: (d2t-tables) ;; fix up tables
! 314: (d2t-handle-html) ;; fix up html markup
! 315: (d2t-first-column) ;; left justify normal text
! 316: (d2t-enclose-examples) ;; turn indented text into @examples
! 317: (message "Menus, nodes, xrefs ...")
! 318: (d2t-make-refs)
! 319: ;(d2t-make-menus)
! 320: ;(d2t-set-nodes)
! 321: (save-excursion ;; fix a few more things explicitly
! 322: (goto-char (point-min))
! 323: (insert d2t-texi-header)
! 324: (search-forward "@node")
! 325: ;; (beginning-of-line)
! 326: ;; (insert "\n\n" d2t-main-menu "\n\n")
! 327: (search-forward "@node Old_bugs") ; `texinfo-all-menus-update' seems
! 328: (beginning-of-line) ; to miss this one. how odd.
! 329: (insert "@menu\n* Old_bugs::\t\t\t\n@end menu\n\n")
! 330: (goto-char (point-max))
! 331: (insert d2t-texi-footer))
! 332: (load-library "texinfo") ;; now do the hard stuff with texinfo-mode
! 333: (texinfo-mode)
! 334: (let ((message-log-max 0)
! 335: (standard-output (get-buffer-create d2t-scratch-buffer-name)))
! 336: (message "Making texinfo nodes ...\n")
! 337: (texinfo-every-node-update)
! 338: (message "Making texinfo menus ...\n")
! 339: (texinfo-all-menus-update))
! 340: (write-file d2t-texi-filename) ) ; save it and done!
! 341:
! 342: (defun d2t-prepare-workspace ()
! 343: "Create a scratch buffer and populate it with gnuplot.doc."
! 344: (and d2t-verbose (message " Doing d2t-prepare-workspace ..."))
! 345: (if (get-buffer d2t-work-buffer-name)
! 346: (kill-buffer d2t-work-buffer-name))
! 347: (if (get-buffer d2t-texi-filename)
! 348: (kill-buffer d2t-texi-filename))
! 349: (if (get-buffer d2t-terminal-buffer-name)
! 350: (kill-buffer d2t-terminal-buffer-name))
! 351: (get-buffer-create d2t-terminal-buffer-name)
! 352: (set-buffer (get-buffer-create d2t-work-buffer-name))
! 353: (insert-file-contents d2t-doc-file-name)
! 354: (goto-char (point-min)))
! 355:
! 356:
! 357: (defun d2t-get-terminals ()
! 358: "Insert all appropriate terminal help."
! 359: (let ((case-fold-search t))
! 360: (if (string-match "linux" system-configuration)
! 361: (setq d2t-terminal-list (append d2t-terminal-list
! 362: '("linux"))))
! 363: (if (string-match "amiga" system-configuration)
! 364: (setq d2t-terminal-list (append d2t-terminal-list
! 365: '("amiga"))))
! 366: (if (string-match "atari" system-configuration)
! 367: (setq d2t-terminal-list (append d2t-terminal-list
! 368: '("atarivdi" "multitos" "atariaes"))))
! 369: (if (string-match "mac" system-configuration)
! 370: (setq d2t-terminal-list (append d2t-terminal-list
! 371: '("mac"))))
! 372: (if (string-match "beos" system-configuration)
! 373: (setq d2t-terminal-list (append d2t-terminal-list
! 374: '("be"))))
! 375: (if (string-match "dos" system-configuration)
! 376: (setq d2t-terminal-list (append d2t-terminal-list
! 377: '("emxvga" "djsvga" "fg" "pc"))))
! 378: (if (string-match "windows" (format "%s" system-type))
! 379: (setq d2t-terminal-list (append d2t-terminal-list
! 380: '("win"))))
! 381: (if (string-match "next" system-configuration)
! 382: (setq d2t-terminal-list (append d2t-terminal-list
! 383: '("next"))))
! 384: (if (string-match "os2" system-configuration)
! 385: (setq d2t-terminal-list (append d2t-terminal-list
! 386: '("pm" "emxvga"))))
! 387: (if (string-match "irix" system-configuration)
! 388: (setq d2t-terminal-list (append d2t-terminal-list
! 389: '("iris4d"))))
! 390: (if (string-match "sco" system-configuration)
! 391: (setq d2t-terminal-list (append d2t-terminal-list
! 392: '("cgi"))))
! 393: (if (string-match "sun" system-configuration)
! 394: (setq d2t-terminal-list (append d2t-terminal-list
! 395: '("sun"))))
! 396: (if (string-match "vms" system-configuration)
! 397: (setq d2t-terminal-list (append d2t-terminal-list
! 398: '("vws"))))
! 399: (unless (member* system-configuration '("dos" "windows" "atari" "amiga")
! 400: :test 'string-match)
! 401: (setq d2t-terminal-list
! 402: (append d2t-terminal-list
! 403: '("x11" "tgif" "gpic" "regis" "t410x" "tex" "xlib")))) )
! 404: (setq d2t-terminal-list (sort d2t-terminal-list 'string<))
! 405: (let ((list d2t-terminal-list) file node marker)
! 406: (save-excursion
! 407: (when (re-search-forward "^<4" (point-max) t)
! 408: (beginning-of-line)
! 409: (insert "@c ")
! 410: (forward-line 1)
! 411: (while list
! 412: (and d2t-verbose (message " %s ..." (car list)))
! 413: (setq file (concat d2t-terminal-directory (car list) ".trm"))
! 414: (when (file-exists-p file)
! 415: (set-buffer d2t-terminal-buffer-name)
! 416: (erase-buffer)
! 417: (insert-file-contents file)
! 418: ;; find the terminal help
! 419: (when (search-forward "START_HELP" (point-max) "to_end")
! 420: (forward-line 1)
! 421: (delete-region (point-min) (point-marker))
! 422: (search-forward "END_HELP" (point-max) "to_end")
! 423: (beginning-of-line)
! 424: (delete-region (point-marker) (point-max))
! 425: ;; tidy up the terminal help content
! 426: (goto-char (point-min))
! 427: (while (re-search-forward "\",[ \t]*$" nil t)
! 428: (replace-match "" nil nil))
! 429: (goto-char (point-min))
! 430: (while (re-search-forward "^\"" nil t)
! 431: (replace-match "" nil nil))
! 432: (goto-char (point-min))
! 433: (while (re-search-forward "\\\\\"" nil t)
! 434: (replace-match "\"" nil nil))
! 435: (goto-char (point-min))
! 436: (while (re-search-forward "^1[ \t]+\\(.+\\)$" nil t)
! 437: (setq node (match-string 1)
! 438: marker (point-marker))
! 439: (replace-match (concat "4 " node) nil nil))
! 440: (goto-char (point-min))
! 441: (while (re-search-forward "^2" nil t)
! 442: (replace-match "5 " nil nil))
! 443: (goto-char (point-min))
! 444: ;; set up terminals index
! 445: (while (re-search-forward "^\?\\([^ ]+\\)$" nil t)
! 446: (let ((word (match-string 1)))
! 447: (unless (string-match "_\\|command-line-options" word)
! 448: (setq d2t-terminals-alist
! 449: (append d2t-terminals-alist
! 450: (list (cons word (point-marker))))))))
! 451: ;; and cram it into the doc buffer
! 452: (set-buffer d2t-work-buffer-name)
! 453: (insert-buffer-substring d2t-terminal-buffer-name)
! 454: ))
! 455: (setq list (cdr list))
! 456: )))))
! 457:
! 458: ;;; functions for obtaining lists of nodes in the document
! 459:
! 460: (defun d2t-get-levels ()
! 461: "Find positions of all nodes in the doc."
! 462: (and d2t-verbose (message " Doing d2t-get-levels ..."))
! 463: (let ((list '("1" "2" "3" "4" "5")) str)
! 464: (while list
! 465: (setq str (concat "d2t-level-" (car list) "-alist"))
! 466: (and d2t-verbose (message " %s ..." str))
! 467: (save-excursion
! 468: (while (not (eobp))
! 469: (when (re-search-forward (concat "^" (car list) " \\(.+\\)$")
! 470: (point-max) "to_end")
! 471: (beginning-of-line)
! 472: (set (intern str)
! 473: (append (eval (intern str))
! 474: (list (cons (match-string 1) (point-marker)))))
! 475: (forward-line 1))))
! 476: (setq list (cdr list)))))
! 477:
! 478:
! 479: (defun d2t-get-commands ()
! 480: "Find all commands in the doc."
! 481: (and d2t-verbose (message " Doing d2t-get-commands ..."))
! 482: (save-excursion
! 483: (let ((alist d2t-level-1-alist) start end)
! 484: (while alist
! 485: (if (string= (caar alist) "Commands")
! 486: (setq start (cdar alist) ;; location of "1 Commands"
! 487: end (cdadr alist) ;; location of next level 1 heading
! 488: alist nil)
! 489: (setq alist (cdr alist))))
! 490: ;;(message "%S %S" start end)
! 491: (goto-char start)
! 492: (while (< (point) end)
! 493: (when (re-search-forward "^2 \\(.+\\)$" (point-max) "to_end")
! 494: (beginning-of-line)
! 495: (unless (> (point) end)
! 496: (setq d2t-commands-alist
! 497: (append d2t-commands-alist
! 498: (list (cons (match-string 1) (point-marker))))))
! 499: (forward-line 1))) )))
! 500:
! 501: (defun d2t-get-set-show ()
! 502: "Find all set-show options in the doc."
! 503: (and d2t-verbose (message " Doing d2t-get-set-show ..."))
! 504: (save-excursion
! 505: (let ((alist d2t-commands-alist) start end)
! 506: (while alist
! 507: (if (string= (caar alist) "set-show")
! 508: (setq start (cdar alist) ;; location of "1 set-show"
! 509: end (cdadr alist) ;; location of next level 2 heading
! 510: alist nil)
! 511: (setq alist (cdr alist))))
! 512: ;;(message "%S %S" start end)
! 513: (goto-char start)
! 514: (while (< (point) end)
! 515: (when (re-search-forward "^3 \\(.+\\)$" (point-max) "to_end")
! 516: (beginning-of-line)
! 517: (unless (> (point) end)
! 518: (setq d2t-set-show-alist
! 519: (append d2t-set-show-alist
! 520: (list (cons (match-string 1) (point-marker))))))
! 521: (forward-line 1))) )))
! 522:
! 523:
! 524: (defun d2t-get-functions ()
! 525: "Find all functions in the doc."
! 526: (and d2t-verbose (message " Doing d2t-get-functions ..."))
! 527: (let (begin end)
! 528: (save-excursion ; determine bounds of functions
! 529: (when (re-search-forward "^3 Functions" (point-max) "to_end")
! 530: (beginning-of-line)
! 531: (setq begin (point-marker))
! 532: (forward-line 1)
! 533: (when (re-search-forward "^3 " (point-max) "to_end")
! 534: (beginning-of-line)
! 535: (setq end (point-marker))))
! 536: (goto-char begin)
! 537: (while (< (point) end)
! 538: (when (re-search-forward "^4 \\(.+\\)$" (point-max) "to_end")
! 539: (beginning-of-line)
! 540: (unless (> (point) end)
! 541: (setq d2t-functions-alist
! 542: (append d2t-functions-alist
! 543: (list (cons (match-string 1) (point-marker))))))
! 544: (forward-line 1))) )))
! 545:
! 546: ;; buffer manipulation functions
! 547:
! 548: ;; this can probably be made faster using a let-scoped alist rather
! 549: ;; than the big cons block
! 550: (defun d2t-sectioning ()
! 551: "Find all lines starting with a number.
! 552: These are chapters, sections, etc. Delete these lines and insert the
! 553: appropriate sectioning and @node commands."
! 554: (and d2t-verbose (message " Doing d2t-sectioning ..."))
! 555: (save-excursion
! 556: (while (not (eobp))
! 557: (re-search-forward "^\\([1-9]\\) +\\(.+\\)$" (point-max) "to_end")
! 558: (unless (eobp)
! 559: (let* ((number (match-string 1))
! 560: (word (match-string 2))
! 561: (node (substitute ?_ ? word :test 'char-equal))
! 562: (eol (save-excursion (end-of-line) (point-marker))))
! 563: ;; some node names appear twice. make the second one unique.
! 564: ;; this will fail to work if a third pops up in the future!
! 565: (if (member* node d2t-node-list :test 'string=)
! 566: (setq node (concat node "_")))
! 567: (setq d2t-node-list (append d2t-node-list (list node)))
! 568: (beginning-of-line)
! 569: (delete-region (point-marker) eol)
! 570: (if (string-match "[1-4]" number) (insert "\n@node " node "\n"))
! 571: (cond ((string= number "1")
! 572: (insert "@chapter " word "\n"))
! 573: ((string= number "2")
! 574: (insert "@section " word "\n"))
! 575: ((string= number "3")
! 576: (insert "@subsection " word "\n"))
! 577: ((string= number "4")
! 578: (insert "@subsubsection " word "\n"))
! 579: (t
! 580: (insert "\n\n@noindent --- " (upcase word) " ---\n")) ) )))))
! 581:
! 582: (defun d2t-indexing ()
! 583: "Find all lines starting with a question mark.
! 584: These are index references. Delete these lines and insert the
! 585: appropriate indexing commands. Only index one word ? entries,
! 586: comment out the multi-word ? entries."
! 587: (and d2t-verbose (message " Doing d2t-indexing ..."))
! 588: (save-excursion
! 589: (while (not (eobp))
! 590: (re-search-forward "^\\\?\\([^ \n]+\\) *$" (point-max) "to_end")
! 591: (unless (eobp)
! 592: (let ((word (match-string 1))
! 593: (eol (save-excursion (end-of-line) (point-marker))))
! 594: (beginning-of-line)
! 595: (delete-region (point-marker) eol)
! 596: (insert "@cindex " word "\n")
! 597: (cond ((assoc word d2t-commands-alist)
! 598: (insert "@cmindex " word "\n\n"))
! 599: ((assoc word d2t-set-show-alist)
! 600: (insert "@opindex " word "\n\n"))
! 601: ((assoc word d2t-terminals-alist)
! 602: (insert "@tmindex " word "\n\n"))
! 603: ((assoc word d2t-functions-alist)
! 604: (insert "@findex " word "\n\n"))) )))
! 605: (goto-char (point-min))
! 606: (while (not (eobp))
! 607: (re-search-forward "^\\\?" (point-max) "to_end")
! 608: (unless (eobp)
! 609: (if (looking-at "functions? \\(tm_\\w+\\)")
! 610: (progn
! 611: (beginning-of-line)
! 612: (insert "@findex " (match-string 1) "\n@c "))
! 613: (beginning-of-line)
! 614: (insert "@c ")))) ))
! 615:
! 616: (defun d2t-comments ()
! 617: "Delete comments and lines beginning with # or %.
! 618: # and % lines are used in converting tables into various formats."
! 619: (and d2t-verbose (message " Doing d2t-comments ..."))
! 620: (save-excursion
! 621: (while (not (eobp))
! 622: (re-search-forward "^[C#%]" (point-max) "to_end")
! 623: (unless (eobp)
! 624: (let ((eol (save-excursion (end-of-line)
! 625: (forward-char 1)
! 626: (point-marker))))
! 627: (beginning-of-line)
! 628: (delete-region (point-marker) eol) )))))
! 629:
! 630: (defun d2t-first-column ()
! 631: "Justify normal text to the 0th column.
! 632: This must be run before `d2t-enclose-examples'.
! 633: This is rather slow since there are almost 9000 lines of text."
! 634: (and d2t-verbose (message " Doing d2t-first-column ..."))
! 635: (save-excursion
! 636: (while (not (eobp))
! 637: (and (char-equal (char-after (point)) ? )
! 638: (delete-char 1))
! 639: (forward-line))))
! 640:
! 641: (defun d2t-braces-atsigns ()
! 642: "Prepend @ to @, {, or } everywhere in the doc.
! 643: This MUST be the first conversion function called in
! 644: `d2t-doc-to-texi'."
! 645: (and d2t-verbose (message " Doing d2t-braces-atsigns ..."))
! 646: (save-excursion
! 647: (while (not (eobp))
! 648: (re-search-forward "[@{}]" (point-max) "to_end")
! 649: (unless (eobp)
! 650: (backward-char 1)
! 651: (insert "@")
! 652: (forward-char 1)))))
! 653:
! 654: (defun d2t-tables ()
! 655: "Remove @start table and @end table tags.
! 656: These will be made into @example's by `d2t-enclose-examples'.
! 657: Thus, the plain text formatting already in the doc is used."
! 658: (and d2t-verbose (message " Doing d2t-tables ..."))
! 659: (save-excursion
! 660: (while (not (eobp))
! 661: (re-search-forward "^ *@+start table" (point-max) "to_end")
! 662: (unless (eobp)
! 663: (let ((eol (save-excursion (end-of-line) (point-marker))))
! 664: (beginning-of-line)
! 665: (delete-region (point-marker) eol))))
! 666: ;;(insert "@example")
! 667: (goto-char (point-min))
! 668: (while (not (eobp))
! 669: (re-search-forward "^ *@+end table" (point-max) "to_end")
! 670: (unless (eobp)
! 671: (let ((eol (save-excursion (end-of-line) (point-marker))))
! 672: (beginning-of-line)
! 673: (delete-region (point-marker) eol))))))
! 674: ;;(insert "@end example")
! 675:
! 676:
! 677: (defun d2t-enclose-examples ()
! 678: "Turn indented text in the doc into @examples.
! 679: This must be run after `d2t-first-column'."
! 680: (and d2t-verbose (message " Doing d2t-enclose-examples ..."))
! 681: (save-excursion
! 682: (while (not (eobp))
! 683: (re-search-forward "^ +[^ \n]" (point-max) "to_end")
! 684: (unless (eobp)
! 685: (beginning-of-line)
! 686: (insert "@example\n")
! 687: (forward-line 1)
! 688: (re-search-forward "^[^ ]" (point-max) "to_end")
! 689: (beginning-of-line)
! 690: (insert "@end example\n\n") ))))
! 691:
! 692: (defun d2t-handle-html ()
! 693: "Deal with all of the html markup in the doc."
! 694: (and d2t-verbose (message " Doing d2t-handle-html ..."))
! 695: (save-excursion
! 696: (while (not (eobp))
! 697: (let ((rx (concat "^" (regexp-quote "^")
! 698: " *\\(<?\\)\\([^ \n]+\\)" )))
! 699: (re-search-forward rx (point-max) "to_end")
! 700: (unless (eobp)
! 701: (let ((bracket (match-string 1))
! 702: (tag (match-string 2))
! 703: (eol (save-excursion (end-of-line) (point-marker))))
! 704: (beginning-of-line)
! 705: (cond
! 706: ;; comment out images
! 707: ((and (string= bracket "<") (string= tag "img"))
! 708: (insert "@c "))
! 709: ;; tyepset anchors
! 710: ((and (string= bracket "<") (string-match "^/?a" tag))
! 711: ;(insert "@c fix me!! ")
! 712: (beginning-of-line)
! 713: (if (looking-at (concat "\\^\\s-*<a\\s-+href=" ; opening tag
! 714: "\"\\([^\"]+\\)\">\\s-*" ; url
! 715: "\\([^<]+\\)" ; text
! 716: "[ \t]*\\^?</a>" ; closing tag
! 717: ))
! 718: (replace-match (concat "@uref{"
! 719: (match-string 1)
! 720: ","
! 721: (remove* ?^ (match-string 2)
! 722: :test 'char-equal)
! 723: "}"))))
! 724: ;; translate <ul> </ul> to @itemize environment
! 725: ((and (string= bracket "<") (string-match "^ul" tag))
! 726: (delete-region (point) eol)
! 727: (insert "\n@itemize @bullet"))
! 728: ((and (string= bracket "<") (string-match "/ul" tag))
! 729: (delete-region (point) eol)
! 730: (insert "@end itemize\n"))
! 731: ;; list items
! 732: ((and (string= bracket "<") (string-match "^li" tag))
! 733: (delete-char 5)
! 734: (delete-horizontal-space)
! 735: (insert "@item\n"))
! 736: ;; fix up a few miscellaneous things
! 737: (t ;;(looking-at ".*Terminal Types")
! 738: (insert "@c ")) )
! 739: (forward-line))) ))))
! 740:
! 741:
! 742: (defvar d2t-dont-make-ref
! 743: "^fit f\(x\)\\|gnuplot\\|help\\s-+plotting")
! 744: (defun d2t-make-refs ()
! 745: "Make cross-references in the text."
! 746: (and d2t-verbose (message " Doing d2t-make-refs ..."))
! 747: (let ((big-alist (append d2t-level-1-alist
! 748: d2t-level-2-alist
! 749: d2t-level-3-alist
! 750: d2t-level-4-alist)))
! 751: (save-excursion
! 752: (while (not (eobp))
! 753: (re-search-forward "\\(`\\([^`]+\\)`\\)" (point-max) "to_end")
! 754: (unless (eobp)
! 755: (let* ((b (match-beginning 1))
! 756: (e (match-end 1))
! 757: (list (split-string (match-string 2)))
! 758: (last (car (reverse list)))
! 759: (text (concat "@ref{" last "}")))
! 760: ;;(message "%s %s" (match-string 1) last)
! 761: (when (and (equal t (try-completion last big-alist))
! 762: (not (string= last "gnuplot")))
! 763: (delete-region b e)
! 764: (insert text))))
! 765: ))))
! 766:
! 767: ;;; doc2texi.el ends here
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to doc2texi.el CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot / docs