Now on revision 111423. ------------------------------------------------------------ revno: 111423 committer: Daiki Ueno branch nick: trunk timestamp: Sat 2013-01-05 07:54:08 +0900 message: * epg.el: Silence byte-compiler warnings. diff: === modified file 'lisp/ChangeLog' --- lisp/ChangeLog 2013-01-04 22:51:52 +0000 +++ lisp/ChangeLog 2013-01-04 22:54:08 +0000 @@ -1,5 +1,11 @@ 2013-01-04 Daiki Ueno + * epg.el: Silence byte-compiler warnings. + (epg--start): Use delete-char instead of delete-backward-char. + (epg-wait-for-completion): Pass FRAME arg to redraw-frame. + +2013-01-04 Daiki Ueno + * epg.el (epg--start): Don't call "tty" program on W32 platforms. Suggested by Eli Zaretskii . === modified file 'lisp/epg.el' --- lisp/epg.el 2013-01-04 22:51:52 +0000 +++ lisp/epg.el 2013-01-04 22:54:08 +0000 @@ -1170,7 +1170,7 @@ (with-temp-buffer (condition-case nil (when (= (call-process "tty" "/dev/fd/0" t) 0) - (delete-backward-char 1) + (delete-char -1) (setq terminal-name (buffer-string))) (file-error)))) (when terminal-name @@ -1300,7 +1300,7 @@ (> (float-time (or (nth 5 (file-attributes epg-agent-file)) '(0 0 0 0))) (float-time epg-agent-mtime)))) - (redraw-frame)) + (redraw-frame (selected-frame))) (epg-context-set-result-for context 'error (nreverse (epg-context-result-for context 'error)))) ------------------------------------------------------------ revno: 111422 committer: Daiki Ueno branch nick: trunk timestamp: Sat 2013-01-05 07:51:52 +0900 message: * epg.el (epg--start): Don't call "tty" program on W32 platforms. diff: === modified file 'lisp/ChangeLog' --- lisp/ChangeLog 2013-01-04 19:22:37 +0000 +++ lisp/ChangeLog 2013-01-04 22:51:52 +0000 @@ -1,3 +1,8 @@ +2013-01-04 Daiki Ueno + + * epg.el (epg--start): Don't call "tty" program on W32 platforms. + Suggested by Eli Zaretskii . + 2013-01-04 Michael Albinus * net/tramp-sh.el (tramp-set-file-uid-gid): UID and GID must be === modified file 'lisp/epg.el' --- lisp/epg.el 2013-01-03 23:56:51 +0000 +++ lisp/epg.el 2013-01-04 22:51:52 +0000 @@ -1166,12 +1166,13 @@ ;; Set GPG_TTY and TERM for pinentry-curses. Note that we can't ;; use `terminal-name' here to get the real pty name for the child ;; process, though /dev/fd/0" is not portable. - (with-temp-buffer - (condition-case nil - (when (= (call-process "tty" "/dev/fd/0" t) 0) - (delete-backward-char 1) - (setq terminal-name (buffer-string))) - (file-error))) + (unless (memq system-type '(ms-dos windows-nt)) + (with-temp-buffer + (condition-case nil + (when (= (call-process "tty" "/dev/fd/0" t) 0) + (delete-backward-char 1) + (setq terminal-name (buffer-string))) + (file-error)))) (when terminal-name (setq process-environment (cons (concat "GPG_TTY=" terminal-name) ------------------------------------------------------------ revno: 111421 [merge] committer: Glenn Morris branch nick: trunk timestamp: Fri 2013-01-04 11:22:37 -0800 message: Merge from emacs-24; up to r111134 diff: === modified file 'ChangeLog' --- ChangeLog 2013-01-04 02:17:49 +0000 +++ ChangeLog 2013-01-04 19:22:37 +0000 @@ -1,3 +1,7 @@ +2013-01-04 Glenn Morris + + * info/dir: Add htmlfontify. + 2013-01-04 Paul Eggert Merge from gnulib, incorporating: === modified file 'doc/lispref/ChangeLog' --- doc/lispref/ChangeLog 2013-01-04 02:42:08 +0000 +++ doc/lispref/ChangeLog 2013-01-04 19:22:37 +0000 @@ -1,3 +1,7 @@ +2013-01-04 Ari Roponen (tiny change) + + * hash.texi (Defining Hash): Fix typo. (Bug#13345) + 2013-01-04 Stefan Monnier * files.texi (File Attributes): Undocument return format of file-acl. === modified file 'doc/lispref/hash.texi' --- doc/lispref/hash.texi 2013-01-01 09:11:05 +0000 +++ doc/lispref/hash.texi 2013-01-03 18:38:55 +0000 @@ -293,7 +293,7 @@ @example (defun case-fold-string= (a b) - (compare-strings a nil nil b nil nil t)) + (eq t (compare-strings a nil nil b nil nil t))) (defun case-fold-string-hash (a) (sxhash (upcase a))) === modified file 'doc/misc/ChangeLog' --- doc/misc/ChangeLog 2013-01-02 16:13:04 +0000 +++ doc/misc/ChangeLog 2013-01-04 19:22:37 +0000 @@ -1,3 +1,19 @@ +2013-01-04 Glenn Morris + + * Makefile.in (INFO_TARGETS, DVI_TARGETS, PDF_TARGETS): + Add htmlfontify. + (htmlfontify, $(buildinfodir)/htmlfontify$(INFO_EXT)) + (htmlfontify.dvi, htmlfontify.pdf): New targets. + * makefile.w32-in (INFO_TARGETS, DVI_TARGETS, clean): Add htmlfontify. + ($(infodir)/htmlfontify$(INFO_EXT), htmlfontify.dvi): New targets. + + * htmlfontify.texi: Miscellaneous fixes and updates. + Set copyright to FSF, update license to GFDL 1.3+. + +2013-01-04 Vivek Dasmohapatra + + * htmlfontify.texi: New file. + 2013-01-02 Jay Belanger * calc.texi (Free-Form Dates): Expand on the date reading === modified file 'doc/misc/Makefile.in' --- doc/misc/Makefile.in 2013-01-02 16:13:04 +0000 +++ doc/misc/Makefile.in 2013-01-04 19:22:37 +0000 @@ -43,7 +43,7 @@ INFO_TARGETS = ada-mode auth autotype bovine calc ccmode cl \ dbus dired-x ebrowse ede ediff edt eieio \ emacs-mime epa erc ert eshell eudc efaq \ - flymake forms gnus emacs-gnutls idlwave info.info \ + flymake forms gnus emacs-gnutls htmlfontify idlwave info.info \ mairix-el message mh-e newsticker nxml-mode \ org pcl-cvs pgg rcirc remember reftex sasl \ sc semantic ses sieve smtpmail speedbar srecode tramp \ @@ -75,6 +75,7 @@ forms.dvi \ gnus.dvi \ emacs-gnutls.dvi \ + htmlfontify.dvi \ idlwave.dvi \ info.dvi \ mairix-el.dvi \ @@ -129,6 +130,7 @@ flymake.pdf \ forms.pdf \ gnus.pdf \ + htmlfontify.pdf \ emacs-gnutls.pdf \ idlwave.pdf \ info.pdf \ @@ -440,6 +442,15 @@ cp gnustmp.pdf $@ rm gnustmp.* +htmlfontify : $(buildinfodir)/htmlfontify$(INFO_EXT) +$(buildinfodir)/htmlfontify$(INFO_EXT): ${srcdir}/htmlfontify.texi ${gfdl} + $(mkinfodir) + $(MAKEINFO) $(MAKEINFO_OPTS) $(INFO_OPTS) -o $@ ${srcdir}/htmlfontify.texi +htmlfontify.dvi: ${srcdir}/htmlfontify.texi ${gfdl} + $(ENVADD) $(TEXI2DVI) ${srcdir}/htmlfontify.texi +htmlfontify.pdf: ${srcdir}/htmlfontify.texi ${gfdl} + $(ENVADD) $(TEXI2PDF) ${srcdir}/htmlfontify.texi + # NB this one needs --no-split even without a .info extension. idlwave : $(buildinfodir)/idlwave$(INFO_EXT) $(buildinfodir)/idlwave$(INFO_EXT): ${srcdir}/idlwave.texi ${gfdl} === added file 'doc/misc/htmlfontify.texi' --- doc/misc/htmlfontify.texi 1970-01-01 00:00:00 +0000 +++ doc/misc/htmlfontify.texi 2013-01-04 09:39:40 +0000 @@ -0,0 +1,1609 @@ +\input texinfo +@comment %**start of header +@setfilename ../../info/htmlfontify +@settitle Htmlfontify User Manual +@exampleindent 2 +@comment %**end of header + +@copying +This manual documents Htmlfontify, a source code -> crosslinked + +formatted + syntax colorised html transformer. + +Copyright @copyright{} 2002, 2003, 2013 Free Software Foundation, Inc. + +@quotation +Permission is granted to copy, distribute and/or modify this document +under the terms of the GNU Free Documentation License, Version 1.3 or +any later version published by the Free Software Foundation; with no +Invariant Sections, with the Front-Cover texts being ``A GNU Manual,'' +and with the Back-Cover Texts as in (a) below. A copy of the license +is included in the section entitled ``GNU Free Documentation License''. + +(a) The FSF's Back-Cover Text is: ``You have the freedom to copy and +modify this GNU manual.'' +@end quotation +@end copying + +@dircategory Emacs misc features +@direntry +* Htmlfontify: (htmlfontify). Convert source code to html. +@end direntry + +@titlepage +@title Htmlfontify User Manual +@sp 4 +@subtitle Htmlfontify version 0.20 +@sp 1 +@subtitle Jun 2002 +@sp 5 +@author Vivek Dasmohapatra +@page + +@vskip 0pt plus 1filll +@noindent +@insertcopying +@end titlepage + +@contents + +@ifnottex +@node Top +@top Htmlfontify + +@insertcopying +@end ifnottex + +@menu +* Introduction:: About Htmlfontify. +* Usage & Examples:: How to use Htmlfontify. +* Customisation:: Fine-tuning Htmlfontify's behaviour. +* Requirements:: External programs used by Htmlfontify. +* GNU Free Documentation License:: The license for this documentation. +* Index:: Index of contents. +@end menu + +@node Introduction +@chapter Introduction +@cindex Introduction + +Htmlfontify provides a means of converting individual Emacs buffers, +source files, or entire source trees to html, preserving formatting +and Emacs colorisation / syntax highlighting as much as possible +through careful application of CSS stylesheets and html tags. + +It can also turn instances of functions, methods and (for some +languages) variables and other constructs and items into links +to their definitions, and create an index file (or files) of +all such symbols, also linked to their points of definition. + +Htmlfontify also provides several customisation items, which should +allow it to mesh more-or-less seamlessly with various templating or +publishing systems (in the event, for instance, that you don't want +to produce the html pages directly). + +@node Usage & Examples +@chapter Usage & Examples +@cindex Usage & Examples + +Htmlfontify can be used both interactively and as part of another +elisp function. If you're running it in a modern Emacs, it will also +run when attached to a terminal (i.e., without X) or even when in +batch mode. + +@menu +* Interactive:: Using Htmlfontify interactively. +* Non-interactive:: Using Htmlfontify from elisp. +* Variables:: Variables (other than customisation entries). +* Data Structures:: Important data structures. +* Examples:: Example(s) of Htmlfontify in use. +@end menu + +@node Interactive +@section Interactive +@cindex Interactive +@cindex functions (interactive) + +Htmlfontify provides the following interactive functions: + +@table @code +@item htmlfontify-buffer +@findex htmlfontify-buffer +@anchor{htmlfontify-buffer} + +@lisp + +(htmlfontify-buffer &optional @var{srcdir} @var{file}) +@end lisp + +Create a new buffer, named for the current buffer + a .html extension, +containing an inline CSS-stylesheet and formatted CSS-markup html that +reproduces the look of the current Emacs buffer as closely as possible. + +``Dangerous'' characters in the existing buffer are turned into html +entities, so you should even be able to do html-within-html fontified +display. + +You should, however, note that random control or eight-bit characters +such as ^L (\x0c) or ¤ (\xa4) won't get mapped yet. + +If the @var{srcdir} and @var{file} arguments are set, lookup etags +derived entries in the @ref{hfy-tags-cache} and add html anchors +and hyperlinks as appropriate. + +@item htmlfontify-run-etags +@findex htmlfontify-run-etags +@anchor{htmlfontify-run-etags} + +@lisp + +(htmlfontify-run-etags @var{srcdir}) +@end lisp + +Load the etags cache for @var{srcdir}. See @ref{hfy-load-tags-cache}. + +@item htmlfontify-copy-and-link-dir +@findex htmlfontify-copy-and-link-dir +@anchor{htmlfontify-copy-and-link-dir} + +@lisp + +(htmlfontify-copy-and-link-dir @var{srcdir} @var{dstdir} &optional @var{f-ext} @var{l-ext}) +@end lisp + +Trawl @var{srcdir} and write fontified-and-hyperlinked output in +@var{dstdir}. @var{f-ext} and @var{l-ext} specify values for +@ref{hfy-extn} and @ref{hfy-link-extn}. + +You may also want to set @ref{hfy-page-header} and @ref{hfy-page-footer}. + +@item htmlfontify-load-rgb-file +@findex htmlfontify-load-rgb-file +@anchor{htmlfontify-load-rgb-file} + +@lisp + +(htmlfontify-load-rgb-file &optional @var{file}) +@end lisp + +Load an X11 style rgb.txt file (search @code{hfy-rgb-load-path} if +@var{file} is not specified). + +Note that this is not necessary if all you want is the standard X11 +(XFree86 4.1.0) color name -> rgb triplet mapping. Htmlfontify has +a copy built in, for use when it cannot contact an X server. + +Loads the variable @code{hfy-rgb-txt-color-map}, which is used by +@ref{hfy-fallback-color-values}. + +@item htmlfontify-unload-rgb-file +@findex htmlfontify-unload-rgb-file +@anchor{htmlfontify-unload-rgb-file} + +@lisp + +(htmlfontify-unload-rgb-file) +@end lisp + +Unload the currently loaded X11 style rgb.txt file (if any). +@end table + +@node Non-interactive +@section Non-interactive +@cindex Noninteractive +@cindex functions (noninteractive) + +In addition to the aforementioned interactive methods, Htmlfontify +provides the following non-interactive ones: + +@table @code +@comment AUTOGENERATED BLOCK + +@item hfy-face-to-style +@findex hfy-face-to-style +@anchor{hfy-face-to-style} + +@lisp + +(hfy-face-to-style @var{fn}) +@end lisp + +Take @var{fn}, a font or @code{defface} style font specification, +(as returned by @code{face-attr-construct} or @ref{hfy-face-attr-for-class}) +and return a @ref{hfy-style-assoc}. + +See also: @ref{hfy-face-to-style-i}, @ref{hfy-flatten-style}. + +@item hfy-fallback-color-values +@findex hfy-fallback-color-values +@anchor{hfy-fallback-color-values} + +@lisp + +(hfy-fallback-color-values @var{color-string}) +@end lisp + +Use a fallback method for obtaining the rgb values for a color. +If @ref{htmlfontify-load-rgb-file} has been called, it uses the +color map specified, otherwise it uses Htmlfontify's built in map. + +@item hfy-combined-face-spec +@findex hfy-combined-face-spec +@anchor{hfy-combined-face-spec} + +@lisp + +(hfy-combined-face-spec @var{face}) +@end lisp + +Return a @code{defface} style alist of possible specifications for +@var{face}, with any entries resulting from user customisation +(@code{custom-set-faces}) taking precedence. + +See also: @ref{hfy-default-face-def} + +@item hfy-word-regex +@findex hfy-word-regex +@anchor{hfy-word-regex} + +@lisp + +(hfy-word-regex @var{string}) +@end lisp + +Return a regex that matches @var{string} as the first @code{match-string}, +with non word characters on either side (vaguely emulating the perl @code{\b} +regex atom). + +@item hfy-force-fontification +@findex hfy-force-fontification +@anchor{hfy-force-fontification} + +@lisp + +(hfy-force-fontification) +@end lisp + +Emacs's fontification is designed for interactive use. As such, it sometimes +does things like deferring fontification until a section of the buffer is +exposed and rendered, or until Emacs is idle for a while. Sometimes, in +non-interactive circumstances, or if it can't see X, it doesn't bother +with some of the harder stuff. While this is all great from the perspective +of a user waiting for Emacs to load a 20000 line file and colorise it, +it's a pain from the point of view from non-interactive code. This function +lies, cheats, steals and generally bullies Emacs into fontifying a buffer +from start to finish, with all the extra frills, whether it thinks it nneds +to or not. Oh yes: it operates on the current buffer. + +@item hfy-link-style-string +@findex hfy-link-style-string +@anchor{hfy-link-style-string} + +@lisp + +(hfy-link-style-string @var{style-string}) +@end lisp + +Replace the end of a CSS style declaration @var{style-string} with the contents +of the variable @ref{hfy-src-doc-link-style}, removing text matching the +regex @ref{hfy-src-doc-link-unstyle} first, if necessary. + + +@item hfy-prepare-index-i +@findex hfy-prepare-index-i +@anchor{hfy-prepare-index-i} + +@lisp + +(hfy-prepare-index-i @var{srcdir} @var{dstdir} @var{filename} &optional @var{stub} @var{map}) +@end lisp + +Prepare a tags index buffer for @var{srcdir}. +@ref{hfy-tags-cache} must already have an entry for @var{srcdir} for +this to work. @ref{hfy-page-header}, @ref{hfy-page-footer}, +@ref{hfy-link-extn} and @ref{hfy-extn} all play a part here. + +If @var{stub} is set, prepare an (appropriately named) index buffer +specifically for entries beginning with @var{stub}. + +If @var{map} is set, use that instead of @ref{hfy-tags-cache}. + +@item hfy-compile-stylesheet +@findex hfy-compile-stylesheet +@anchor{hfy-compile-stylesheet} + +@lisp + +(hfy-compile-stylesheet) +@end lisp + +Trawl the current buffer, construct and return a @ref{hfy-sheet-assoc}. + +@item hfy-css-name +@findex hfy-css-name +@anchor{hfy-css-name} + +@lisp + +(hfy-css-name @var{fn}) +@end lisp + +Strip some of the boring bits from a font-name and return a CSS style +name. If @var{fn} is a @code{defface} attribute list, either construct +a name for it, store it in the cache, and return it, or just fetch it +from the cache if it's already there. + +@item hfy-make-directory +@findex hfy-make-directory +@anchor{hfy-make-directory} + +@lisp + +(hfy-make-directory @var{dir}) +@end lisp + +Approximate equivalent of @code{mkdir -p @var{dir}}. + +@item hfy-triplet +@findex hfy-triplet +@anchor{hfy-triplet} + +@lisp + +(hfy-triplet @var{color}) +@end lisp + +Takes a color name (string) and return a CSS rgb(R, G, B) triplet string. +Uses the definition of ``white'' to map the numbers to the 0-255 range, so +if you've redefined white, (especially if you've redefined it to have +a triplet member lower than that of the color you are processing, +strange things may happen). + +@item hfy-default-footer +@findex hfy-default-footer +@anchor{hfy-default-footer} + +@lisp + +(hfy-default-footer @var{file}) +@end lisp + +Default value for @ref{hfy-page-footer} + +@item hfy-list-files +@findex hfy-list-files +@anchor{hfy-list-files} + +@lisp + +(hfy-list-files @var{directory}) +@end lisp + +Return a list of files under @var{directory}. +Strips any leading @samp{./} from each filename. + +@item hfy-color-vals +@findex hfy-color-vals +@anchor{hfy-color-vals} + +@lisp + +(hfy-color-vals @var{color}) +@end lisp + +Where @var{color} is a color name or #XXXXXX style triplet, return a list of +3 (16 bit) rgb values for said color. If a window system is unavailable, +calls @ref{hfy-fallback-color-values}. + +@item hfy-href-stub +@findex hfy-href-stub +@anchor{hfy-href-stub} + +@lisp + +(hfy-href-stub @var{this-file} @var{def-files} @var{tag}) +@end lisp + +Return an href stub for a tag href: if @var{def-files} (list of files +containing definitions for the tag in question) contains only one entry, +the href should link straight to that file. Otherwise, the link should +be to the index file. + +We are not yet concerned with the file extensions/tag line number and +so on at this point. + +If @ref{hfy-split-index} is set, and the href will be to an index file +rather than a source file, append a @samp{.X} to @ref{hfy-index-file}, where +@samp{X} is the uppercased first character of @var{tag}. + +See also: @ref{hfy-relstub}, @ref{hfy-index-file}. + +@item hfy-line-number +@findex hfy-line-number +@anchor{hfy-line-number} + +@lisp + +(hfy-line-number) +@end lisp + +Returns the line number of the point in the current buffer. + +@item hfy-merge-adjacent-spans +@findex hfy-merge-adjacent-spans +@anchor{hfy-merge-adjacent-spans} + +@lisp + +(hfy-merge-adjacent-spans @var{face-map}) +@end lisp + +Where @var{face-map} is a @ref{hfy-facemap-assoc} for the current buffer, +this function merges adjacent style blocks which are of the same value +and are separated by nothing more interesting than whitespace. + +@code{narf brain} + +(as interpreted from @var{face-map}) would become: + +@code{narf brain} + +Returns a modified copy of @var{face-map} (also a @ref{hfy-facemap-assoc}). + +@item hfy-mark-tag-names +@findex hfy-mark-tag-names +@anchor{hfy-mark-tag-names} + +@lisp + +(hfy-mark-tag-names @var{srcdir} @var{file}) +@end lisp + +Mark tags in @var{file} (lookup @var{srcdir} in @ref{hfy-tags-cache}) with the +@code{hfy-anchor} property, with a value of @samp{tag.line-number}. + +@item hfy-weight +@findex hfy-weight +@anchor{hfy-weight} + +@lisp + +(hfy-weight @var{weight}) +@end lisp + +Derive a font-weight CSS specifier from an Emacs weight specification symbol. + +@item hfy-size +@findex hfy-size +@anchor{hfy-size} + +@lisp + +(hfy-size @var{height}) +@end lisp + +Derive a CSS font-size specifier from an Emacs font @code{:height} attribute. +Does not cope with the case where height is a function to be applied to +the height of the underlying font. + +@item hfy-default-header +@findex hfy-default-header +@anchor{hfy-default-header} + +@lisp + +(hfy-default-header @var{file} @var{style}) +@end lisp + +Default value for @ref{hfy-page-header} + +@item hfy-family +@findex hfy-family +@anchor{hfy-family} + +@lisp + +(hfy-family @var{family}) +@end lisp + +Derives a CSS font-family specifier from an Emacs @code{:family} attribute. + +@item hfy-mark-tag-hrefs +@findex hfy-mark-tag-hrefs +@anchor{hfy-mark-tag-hrefs} + +@lisp + +(hfy-mark-tag-hrefs @var{srcdir} @var{file}) +@end lisp + +Mark href start points with the @code{hfy-link} property (value: href string). + +Mark href end points with the @code{hfy-endl} property (value @code{t}). + +Avoid overlapping links, and mark links in descending length of +tag name in order to prevent subtags from usurping supertags; +e.g., ``term'' for ``terminal''). + +@item hfy-box +@findex hfy-box +@anchor{hfy-box} + +@lisp + +(hfy-box @var{box}) +@end lisp + +Derive CSS border-* attributes from the Emacs @code{:box} attribute. + +@item hfy-box-to-style +@findex hfy-box-to-style +@anchor{hfy-box-to-style} + +@lisp + +(hfy-box-to-style @var{spec}) +@end lisp + +Convert a complex @code{:box} Emacs font attribute set to a list of +CSS border-* attributes. Don't call this directly---it is called by +@ref{hfy-box} when necessary. + +@item hfy-html-enkludge-buffer +@findex hfy-html-enkludge-buffer +@anchor{hfy-html-enkludge-buffer} + +@lisp + +(hfy-html-enkludge-buffer) +@end lisp + +Mark dangerous @samp{["<>]} characters with the @code{hfy-quoteme} property. + +See also @ref{hfy-html-dekludge-buffer}. + +@item hfy-buffer +@findex hfy-buffer +@anchor{hfy-buffer} + +@lisp + +(hfy-buffer) +@end lisp + +Generate and return an Htmlfontify html output buffer for the current +buffer. May trample an existing buffer. + +@item hfy-fontified-p +@findex hfy-fontified-p +@anchor{hfy-fontified-p} + +@lisp + +(hfy-fontified-p) +@end lisp + +@code{font-lock} doesn't like to say a buffer's been fontified when in +batch mode, but we want to know if we should fontify or raw copy, so in +batch mode we check for non-default face properties. Otherwise we test +@code{font-lock-mode} and @code{font-lock-fontified} for truth. + +@item hfy-lookup +@findex hfy-lookup +@anchor{hfy-lookup} + +@lisp + +(hfy-lookup @var{face} @var{style}) +@end lisp + +Where @var{style} is a @ref{hfy-sheet-assoc} and @var{face} is an Emacs face, +return the relevant @var{css} style name. + +@item hfy-fontify-buffer +@findex hfy-fontify-buffer +@anchor{hfy-fontify-buffer} + +@lisp + +(hfy-fontify-buffer &optional @var{srcdir} @var{file}) +@end lisp + +Implement the guts of @ref{htmlfontify-buffer}. + +@item hfy-color +@findex hfy-color +@anchor{hfy-color} + +@lisp + +(hfy-color @var{color}) +@end lisp + +Convert an Emacs :foreground property to a CSS color property. + +@item hfy-flatten-style +@findex hfy-flatten-style +@anchor{hfy-flatten-style} + +@lisp + +(hfy-flatten-style @var{style}) +@end lisp + +Take @var{style} (see @ref{hfy-face-to-style-i}, @ref{hfy-face-to-style}) +and merge any multiple attributes appropriately. Currently only font-size is +merged down to a single occurrence---others may need special handling, but I +haven't encountered them yet. Returns a @ref{hfy-style-assoc}. + +@item hfy-size-to-int +@findex hfy-size-to-int +@anchor{hfy-size-to-int} + +@lisp + +(hfy-size-to-int @var{spec}) +@end lisp + +Convert @var{spec}, a CSS font-size specifier, back to an Emacs +@code{:height} attribute value. Used while merging multiple font-size +attributes. + +@item hfy-sprintf-stylesheet +@findex hfy-sprintf-stylesheet +@anchor{hfy-sprintf-stylesheet} + +@lisp + +(hfy-sprintf-stylesheet @var{css} @var{file}) +@end lisp + +Generates a header, via @ref{hfy-page-header}, for @var{file}, containing the +stylesheet derived from @var{css}, which is a @ref{hfy-sheet-assoc}. Returns a +string containing the same. + +@item hfy-relstub +@findex hfy-relstub +@anchor{hfy-relstub} + +@lisp + +(hfy-relstub @var{file} &optional @var{start}) +@end lisp + +Return a @samp{../} stub of the appropriate length for the current source +tree depth (as determined from @var{file}). @c iyswim. + +@item hfy-compile-face-map +@findex hfy-compile-face-map +@anchor{hfy-compile-face-map} + +@lisp + +(hfy-compile-face-map) +@end lisp + +Compile and return a @ref{hfy-facemap-assoc} for the current buffer. + +@item hfy-prepare-index +@findex hfy-prepare-index +@anchor{hfy-prepare-index} + +@lisp + +(hfy-prepare-index @var{srcdir} @var{dstdir}) +@end lisp + +Return as list of index buffer(s), as determined by @ref{hfy-split-index}. +Uses @ref{hfy-prepare-index-i} to do this. + +@item hfy-prepare-tag-map +@findex hfy-prepare-tag-map +@anchor{hfy-prepare-tag-map} + +@lisp + +(hfy-prepare-tag-map @var{srcdir} @var{dstdir}) +@end lisp + +Prepare the counterpart(s) to the index buffer(s)---a list of buffers with +the same structure, but listing (and linking to) instances of tags (as +opposed to their definitions). + +See also: @ref{hfy-prepare-index}, @ref{hfy-split-index} + +@item hfy-subtract-maps +@findex hfy-subtract-maps +@anchor{hfy-subtract-maps} + +@lisp + +(hfy-subtract-maps @var{srcdir}) +@end lisp + +Internal function---strips definitions of tags from the instance map. +See: @ref{hfy-tags-cache} and @ref{hfy-tags-rmap} + +@item hfy-face-to-style-i +@findex hfy-face-to-style-i +@anchor{hfy-face-to-style-i} + +@lisp + +(hfy-face-to-style-i @var{fn}) +@end lisp + +The guts of @ref{hfy-face-to-style}. @var{fn} should be a @code{defface} +font specification, as returned by @code{face-attr-construct} or +@ref{hfy-face-attr-for-class}. Note that this function does not get +font-sizes right if they are based on inherited modifiers (via the +:inherit) attribute, and any other modifiers that are cumulative if they +appear multiple times need to be merged by the user---@ref{hfy-flatten-style} +should do this. + +@item hfy-face-to-css +@findex hfy-face-to-css +@anchor{hfy-face-to-css} + +@lisp + +(hfy-face-to-css @var{fn}) +@end lisp + +Take @var{fn}, a font or @code{defface} specification (c.f. +@code{face-attr-construct}) and return a CSS style specification. + +See also: @ref{hfy-face-to-style} + +@item hfy-html-quote +@findex hfy-html-quote +@anchor{hfy-html-quote} + +@lisp + +(hfy-html-quote @var{char-string}) +@end lisp + +Map a string (usually 1 character long) to an html safe string +(entity) if need be. + +@item hfy-link-style +@findex hfy-link-style +@anchor{hfy-link-style} + +@lisp + +(hfy-link-style @var{style-string}) +@end lisp + +Convert the CSS style spec @var{style-string} to its equivalent +hyperlink style. + +See: @ref{hfy-link-style-fun}. + +@item hfy-p-to-face +@findex hfy-p-to-face +@anchor{hfy-p-to-face} + +@lisp + +(hfy-p-to-face @var{props}) +@end lisp + +Given @var{props}, a list of text-properties, return the value of the +face property, or nil. + +@item hfy-box-to-border-assoc +@findex hfy-box-to-border-assoc +@anchor{hfy-box-to-border-assoc} + +@lisp + +(hfy-box-to-border-assoc @var{spec}) +@end lisp + +Helper function for @ref{hfy-box-to-style}. + +@item hfy-face-attr-for-class +@findex hfy-face-attr-for-class +@anchor{hfy-face-attr-for-class} + +@lisp + +(hfy-face-attr-for-class @var{face} &optional @var{class}) +@end lisp + +Return the face attributes for @var{face}. If @var{class} is set, it +must be a @code{defface} alist key [see below]. Prior to version 0.18, +the first face specification returned by @ref{hfy-combined-face-spec} +which @emph{didn't} clash with @var{class} was returned. In versions +from 0.18 onwards, each font attribute list is scored, and the +non-conflicting list with the highest score is returned. (A specification +with a class of @code{t} is considered to match any class you specify. +This matches Emacs's behaviour when deciding on which face attributes to +use, to the best of my understanding ). + +If @var{class} is nil, then you just get get whatever +@code{face-attr-construct} returns; i.e., the current specification in +effect for @var{face}. + +See @ref{hfy-display-class} for details of valid values for @var{class}. + +@item hfy-face-at +@findex hfy-face-at +@anchor{hfy-face-at} + +@lisp + +(hfy-face-at P) +@end lisp + +Find face in effect at point P. If overlays are to be considered +(see @ref{hfy-optimisations}) then this may return a @code{defface} style +list of face properties instead of a face symbol. + +@item hfy-bgcol +@findex hfy-bgcol +@anchor{hfy-bgcol} + +@lisp + +(hfy-bgcol @var{color}) +@end lisp + +As per @ref{hfy-color} but for background colors. + +@item hfy-kludge-cperl-mode +@findex hfy-kludge-cperl-mode +@anchor{hfy-kludge-cperl-mode} + +@lisp + +(hfy-kludge-cperl-mode) +@end lisp + +cperl mode does its damndest not to do some of its fontification when not +in a windowing system---we try to trick it@dots{} + +@item hfy-href +@findex hfy-href +@anchor{hfy-href} + +@lisp + +(hfy-href @var{this-file} @var{def-files} @var{tag} @var{tag-map}) +@end lisp + +Return a relative href to the tag in question, based on + +@var{this-file} @ref{hfy-link-extn} @ref{hfy-extn} @var{def-files} @var{tag} and @var{tag-map} + +@var{this-file} is the current source file +@var{def-files} is a list of file containing possible link endpoints for @var{tag} +@var{tag} is the @var{tag} in question +@var{tag-map} is the entry in @ref{hfy-tags-cache}. + +@item hfy-shell +@findex hfy-shell +@anchor{hfy-shell} + +@lisp + +(hfy-shell) +@end lisp + +Returns a best guess at a Bourne compatible shell to use: If the current +shell doesn't look promising, fall back to @ref{hfy-shell-file-name}. + +@item hfy-load-tags-cache +@findex hfy-load-tags-cache +@anchor{hfy-load-tags-cache} + +@lisp + +(hfy-load-tags-cache @var{srcdir}) +@end lisp + +Run @ref{hfy-etags-cmd} on @var{srcdir}: load @ref{hfy-tags-cache} and @ref{hfy-tags-sortl}. + +@item hfy-parse-tags-buffer +@findex hfy-parse-tags-buffer +@anchor{hfy-parse-tags-buffer} + +@lisp + +(hfy-parse-tags-buffer @var{srcdir} @var{buffer}) +@end lisp + +Parse a @var{buffer} containing etags formatted output, loading the +@ref{hfy-tags-cache} and @ref{hfy-tags-sortl} entries for @var{srcdir}. + +@item hfy-interq +@findex hfy-interq +@anchor{hfy-interq} + +@lisp + +(hfy-interq @var{set-a} @var{set-b}) +@end lisp + +Return the intersection (using @code{eq}) of 2 lists. + +@item hfy-text-p +@findex hfy-text-p +@anchor{hfy-text-p} + +@lisp + +(hfy-text-p @var{srcdir} @var{file}) +@end lisp + +Is @var{srcdir}/@var{file} text? Uses @ref{hfy-istext-command} to determine this. + +@item hfy-opt +@findex hfy-opt +@anchor{hfy-opt} + +@lisp + +(hfy-opt @var{symbol}) +@end lisp + +Is @ref{hfy-optimisations} member @var{symbol} set or not? + +@item hfy-dirname +@findex hfy-dirname +@anchor{hfy-dirname} + +@lisp + +(hfy-dirname @var{file}) +@end lisp + +Return everything preceding the last @samp{/} from a relative filename, +on the assumption that this will produce a relative directory name. Hardly +bombproof, but good enough in the context in which it is being used. + +@item hfy-html-dekludge-buffer +@findex hfy-html-dekludge-buffer +@anchor{hfy-html-dekludge-buffer} + +@lisp + +(hfy-html-dekludge-buffer) +@end lisp + +Transform all dangerous characters marked with the @code{hfy-quoteme} property +using @ref{hfy-html-quote} + +See also @ref{hfy-html-enkludge-buffer}. + +@item hfy-copy-and-fontify-file +@findex hfy-copy-and-fontify-file +@anchor{hfy-copy-and-fontify-file} + +@lisp + +(hfy-copy-and-fontify-file @var{srcdir} @var{dstdir} @var{file}) +@end lisp + +Open @var{file} in @var{srcdir}---if fontified, write a fontified copy to @var{dstdir} +adding an extension of @ref{hfy-extn}. Fontification is actually done by +@ref{htmlfontify-buffer}. If the buffer is not fontified, just copy it. + +@item hfy-decor +@findex hfy-decor +@anchor{hfy-decor} + +@lisp + +(hfy-decor @var{tag} @var{val}) +@end lisp + +Derive CSS text-decoration specifiers from various Emacs font attributes. + +@item hfy-slant +@findex hfy-slant +@anchor{hfy-slant} + +@lisp + +(hfy-slant @var{slant}) +@end lisp + +Derive a font-style CSS specifier from the Emacs :slant +attribute---CSS does not define the reverse-* styles, so just maps +those to the regular specifiers. + +@item hfy-tags-for-file +@findex hfy-tags-for-file +@anchor{hfy-tags-for-file} + +@lisp + +(hfy-tags-for-file @var{srcdir} @var{file}) +@end lisp + +List of etags tags that have definitions in this @var{file}. Looks up +the tags cache in @ref{hfy-tags-cache} using @var{srcdir} as the key. + +@item hfy-width +@findex hfy-width +@anchor{hfy-width} + +@lisp + +(hfy-width @var{width}) +@end lisp + +Convert an Emacs @code{:width} attribute to a CSS font-stretch attribute. + +@comment /AUTOGENERATED BLOCK +@end table + +@node Variables +@section Variables +@cindex variables + +Important variables that are not customisation items: + +@table @code + +@item hfy-tags-cache +@vindex hfy-tags-cache +@anchor{hfy-tags-cache} + +This is an alist of the form: + +@example +(("/src/dir/0" . tag-hash0) ("/src/dir/1" tag-hash1) @dots{} ) +@end example + +Each tag hash entry then contains entries of the form: + +@example +"tag_string" => (("file/name.ext" line char) @dots{} ) +@end example + +i.e., an alist mapping (relative) file paths to line and character offsets. + +See @ref{hfy-load-tags-cache}. + +@item hfy-tags-rmap +@vindex hfy-tags-rmap +@anchor{hfy-tags-rmap} + +@code{hfy-tags-rmap} is an alist of the form: + +@lisp +(("/src/dir" . tag-rmap-hash)) +@end lisp + +Where tag-rmap-hash has entries of the form: + +@example +"tag_string" => ( "file/name.ext" line char ) +@end example + +Unlike @ref{hfy-tags-cache} these are the locations of occurrences of +tagged items, not the locations of their definitions. + +@item hfy-tags-sortl +@vindex hfy-tags-sortl +@anchor{hfy-tags-sortl} + +@code{hfy-tags-sortl} is an alist of the form: + +@example +(("/src/dir" . (tag0 tag1 tag2)) @dots{} ) +@end example + +Where the tags are stored in descending order of length. + +See: @ref{hfy-load-tags-cache}. + +@end table + +@node Data Structures +@section Data Structures +@cindex Data Structures + +Some of the (informal) data structures used in Htmlfontify are detailed here: + +@table @code + +@item hfy-style-assoc +@cindex hfy-style-assoc +@anchor{hfy-style-assoc} + +An assoc representing/describing an Emacs face. Properties may be repeated, +in which case later properties should be treated as if they were inherited +from a ``parent'' font. (For some properties, only the first encountered value +is of any importance, for others the values might be cumulative, and for +others they might be cumulative in a complex way.) + +Some examples: + +@lisp +(hfy-face-to-style 'default) => + + (("background" . "rgb(0, 0, 0)" ) + ("color" . "rgb(255, 255, 255)") + ("font-style" . "normal" ) + ("font-weight" . "500" ) + ("font-stretch" . "normal" ) + ("font-family" . "misc-fixed" ) + ("font-size" . "13pt" ) + ("text-decoration" . "none" )) + +(hfy-face-to-style 'Info-title-3-face) => + + (("font-weight" . "700" ) + ("font-family" . "helv" ) + ("font-size" . "120%" ) + ("text-decoration" . "none") ) +@end lisp + +@item hfy-sheet-assoc +@cindex hfy-sheet-assoc +@anchor{hfy-sheet-assoc} + +An assoc with elements of the form @samp{(face-name style-name . style-string)}. +The actual stylesheet for each page is derived from one of these. + +@lisp +'((default "default" . "@{ background: black; color: white@}") + (font-lock-string-face "string" . "@{ color: rgb(64,224,208) @}")) +@end lisp + +@item hfy-facemap-assoc +@cindex hfy-facemap-assoc +@anchor{hfy-facemap-assoc} + +An assoc of @code{(point . @var{face-symbol})} or +@code{(point . @code{defface} attribute list)} and @code{(point +. end)} elements, in descending order of point value (i.e., from the +file's end to its beginning). The map is in reverse order because +inserting a @samp{} text to embed in the document---the string +returned will be used as the header for the htmlfontified version of +the source file. + +See also: @ref{hfy-page-footer} + +@item hfy-src-doc-link-style +@vindex hfy-src-doc-link-style +@anchor{hfy-src-doc-link-style} + +String to add to the @samp{