PHP Manual

PEAR Manual

Smarty Manual

PostgreSQL

MySQL Manual

Perl Manual

postgresql 8.2devel documentation
prevfast backwardappendix g. documentationfast forwardnext

g.3. building the documentation

once you have everything set up, change to the directory doc/src/sgml and run one of the commands described in the following subsections to build the documentation. (remember to use gnu make.)

g.3.1. html

to build the html version of the documentation: 

doc/src/sgml$ gmake html

this is also the default target.

when the html documentation is built, the process also generates the linking information for the index entries. thus, if you want your documentation to have a concept index at the end, you need to build the html documentation once, and then build the documentation again in whatever format you like.

to allow for easier handling in the final distribution, the files comprising the html documentation are stored in a tar archive that is unpacked at installation time. to create the html documentation package, use the commands 

cd doc/src gmake postgres.tar.gz

in the distribution, these archives live in the doc directory and are installed by default with gmake install.

g.3.2. manpages

we use the docbook2man utility to convert docbook refentry pages to *roff output suitable for man pages. the man pages are also distributed as a tar archive, similar to the html version. to create the man page package, use the commands 

cd doc/src gmake man.tar.gz

which will result in a tar file being generated in the doc/src directory.

to generate quality man pages, it might be necessary to use a hacked version of the conversion utility or do some manual postprocessing. all man pages should be manually inspected before distribution.

g.3.3. print output via jadetex

if you want to use jadetex to produce a printable rendition of the documentation, you can use one of the following commands:

  • to make a dvi version: 

    doc/src/sgml$ gmake postgres.dvi

  • to generate postscript from the dvi: 

    doc/src/sgml$ gmake postgres.ps

  • to make a pdf: 

    doc/src/sgml$ gmake postgres.pdf

    (of course you can also make a pdf version from the postscript, but if you generate pdf directly, it will have hyperlinks and other enhanced features.)

g.3.4. print output via rtf

you can also create a printable version of the postgresql documentation by converting it to rtf and applying minor formatting corrections using an office suite. depending on the capabilities of the particular office suite, you can then convert the documentation to postscript of pdf. the procedure below illustrates this process using applixware.

note: it appears that current versions of the postgresql documentation trigger some bug in or exceed the size limit of openjade. if the build process of the rtf version hangs for a long time and the output file still has size 0, then you may have hit that problem. (but keep in mind that a normal build takes 5 to 10 minutes, so don't abort too soon.)

applixware rtf cleanup

openjade omits specifying a default style for body text. in the past, this undiagnosed problem led to a long process of table of contents generation. however, with great help from the applixware folks the symptom was diagnosed and a workaround is available.

  1. generate the rtf version by typing: 

    doc/src/sgml$ gmake postgres.rtf

  2. repair the rtf file to correctly specify all styles, in particular the default style. if the document contains refentry sections, one must also replace formatting hints which tie a preceding paragraph to the current paragraph, and instead tie the current paragraph to the following one. a utility, fixrtf, is available in doc/src/sgml to accomplish these repairs: 

    doc/src/sgml$ ./fixrtf --refentry postgres.rtf

    the script adds {\s0 normal;} as the zeroth style in the document. according to applixware, the rtf standard would prohibit adding an implicit zeroth style, though microsoft word happens to handle this case. for repairing refentry sections, the script replaces \keepn tags with \keep.

  3. open a new document in applixware words and then import the rtf file.

  4. generate a new table of contents (toc) using applixware.

    1. select the existing toc lines, from the beginning of the first character on the first line to the last character of the last line.

    2. build a new toc using tools->book building->create table of contents. select the first three levels of headers for inclusion in the toc. this will replace the existing lines imported in the rtf with a native applixware toc.

    3. adjust the toc formatting by using format->style, selecting each of the three toc styles, and adjusting the indents for first and left. use the following values:

      stylefirst indent (inches)left indent (inches)
      toc-heading 10.40.4
      toc-heading 20.80.8
      toc-heading 31.21.2

  5. work through the document to:

    • adjust page breaks.

    • adjust table column widths.

  6. replace the right-justified page numbers in the examples and figures portions of the toc with correct values. this only takes a few minutes.

  7. delete the index section from the document if it is empty.

  8. regenerate and adjust the table of contents.

    1. select the toc field.

    2. select tools->book building->create table of contents.

    3. unbind the toc by selecting tools->field editing->unprotect.

    4. delete the first line in the toc, which is an entry for the toc itself.

  9. save the document as native applixware words format to allow easier last minute editing later.

  10. "print" the document to a file in postscript format.

g.3.5. plain text files

several files are distributed as plain text, for reading during the installation process. the install file corresponds to chapter 14, with some minor changes to account for the different context. to recreate the file, change to the directory doc/src/sgml and enter gmake install. this will create a file install.html that can be saved as text with netscape navigator and put into the place of the existing file. netscape seems to offer the best quality for html to text conversions (over lynx and w3m).

the file history can be created similarly, using the command gmake history. for the file src/test/regress/readme the command is gmake regress_readme.

g.3.6. syntax check

building the documentation can take very long. but there is a method to just check the correct syntax of the documentation files, which only takes a few seconds: 

doc/src/sgml$ gmake check

prevhomenext
tool setsupdocumentation authoring