diff options
| author | cinap_lenrek <cinap_lenrek@localhost> | 2011-05-03 11:25:13 +0000 |
|---|---|---|
| committer | cinap_lenrek <cinap_lenrek@localhost> | 2011-05-03 11:25:13 +0000 |
| commit | 458120dd40db6b4df55a4e96b650e16798ef06a0 (patch) | |
| tree | 8f82685be24fef97e715c6f5ca4c68d34d5074ee /sys/src/cmd/python/Doc/perl | |
| parent | 3a742c699f6806c1145aea5149bf15de15a0afd7 (diff) | |
add hg and python
Diffstat (limited to 'sys/src/cmd/python/Doc/perl')
| -rw-r--r-- | sys/src/cmd/python/Doc/perl/SynopsisTable.pm | 95 | ||||
| -rw-r--r-- | sys/src/cmd/python/Doc/perl/distutils.perl | 21 | ||||
| -rw-r--r-- | sys/src/cmd/python/Doc/perl/howto.perl | 12 | ||||
| -rw-r--r-- | sys/src/cmd/python/Doc/perl/isilo.perl | 12 | ||||
| -rw-r--r-- | sys/src/cmd/python/Doc/perl/l2hinit.perl | 801 | ||||
| -rw-r--r-- | sys/src/cmd/python/Doc/perl/ltxmarkup.perl | 67 | ||||
| -rw-r--r-- | sys/src/cmd/python/Doc/perl/manual.perl | 15 | ||||
| -rw-r--r-- | sys/src/cmd/python/Doc/perl/python.perl | 2172 |
8 files changed, 3195 insertions, 0 deletions
diff --git a/sys/src/cmd/python/Doc/perl/SynopsisTable.pm b/sys/src/cmd/python/Doc/perl/SynopsisTable.pm new file mode 100644 index 000000000..3c65a67d1 --- /dev/null +++ b/sys/src/cmd/python/Doc/perl/SynopsisTable.pm @@ -0,0 +1,95 @@ +package SynopsisTable; + +sub new{ + return bless {names=>'', info=>{}, file=>''}; +} + +sub declare{ + my($self,$name,$key,$type) = @_; + if ($self->{names}) { + $self->{names} .= ",$name"; + } + else { + $self->{names} .= "$name"; + } + $self->{info}{$name} = "$key,$type,"; +} + +# The 'file' attribute is used to store the filename of the node in which +# the table will be presented; this assumes that each table will be presented +# only once, which works for the current use of this object. + +sub set_file{ + my($self, $filename) = @_; + $self->{file} = "$filename"; +} + +sub get_file{ + my $self = shift; + return $self->{file}; +} + +sub set_synopsis{ + my($self,$name,$synopsis) = @_; + my($key,$type,$unused) = split ',', $self->{info}{$name}, 3; + $self->{info}{$name} = "$key,$type,$synopsis"; +} + +sub get{ + my($self,$name) = @_; + return split /,/, $self->{info}{$name}, 3; +} + +sub show{ + my $self = shift; + my $name; + print "names: ", $self->{names}, "\n\n"; + foreach $name (split /,/, $self->{names}) { + my($key,$type,$synopsis) = $self->get($name); + print "$name($key) is $type: $synopsis\n"; + } +} + +sub tohtml{ + my $self = shift; + my $oddrow = 1; + my $data = "<table class='synopsistable' valign='baseline'>\n"; + my $name; + foreach $name (split /,/, $self->{names}) { + my($key,$type,$synopsis) = $self->get($name); + my $link = "<a href='module-$key.html'>"; + $synopsis =~ s/<tex2html_percent_mark>/%/g; + $synopsis =~ s/<tex2html_ampersand_mark>/\&/g; + $data .= (' <tr' + . ($oddrow ? " class='oddrow'>\n " : '>') + . "<td><b><tt class='module'>$link$name</a></tt></b></td>\n" + . " <td>\ </td>\n" + . " <td class='synopsis'>$synopsis</td></tr>\n"); + $oddrow = !$oddrow; + } + $data .= "</table>\n"; + $data; +} + + +package testSynopsisTable; + +sub test{ + # this little test is mostly to debug the stuff above, since this is + # my first Perl "object". + my $st = SynopsisTable->new(); + $st->declare("sample", "sample", "standard"); + $st->set_synopsis("sample", "This is a little synopsis...."); + $st->declare("copy_reg", "copyreg", "standard"); + $st->set_synopsis("copy_reg", "pickle support stuff"); + $st->show(); + + print "\n\n"; + + my $st2 = SynopsisTable->new(); + $st2->declare("st2module", "st2module", "built-in"); + $st2->set_synopsis("st2module", "silly little synopsis"); + $st2->show(); +} + +1; # This must be the last line -- Perl is bogus! diff --git a/sys/src/cmd/python/Doc/perl/distutils.perl b/sys/src/cmd/python/Doc/perl/distutils.perl new file mode 100644 index 000000000..afc2e4aec --- /dev/null +++ b/sys/src/cmd/python/Doc/perl/distutils.perl @@ -0,0 +1,21 @@ +# LaTeX2HTML support for distutils.sty. + +package main; + +sub do_cmd_command { + return use_wrappers(@_[0], '<code class="du-command">', '</code>'); +} + +sub do_cmd_option { + return use_wrappers(@_[0], '<span class="du-option">', '</span>'); +} + +sub do_cmd_filevar { + return use_wrappers(@_[0], '<span class="du-filevar">', '</span>'); +} + +sub do_cmd_XXX { + return use_wrappers(@_[0], '<b class="du-xxx">', '</b>'); +} + +1; # Bad Perl. diff --git a/sys/src/cmd/python/Doc/perl/howto.perl b/sys/src/cmd/python/Doc/perl/howto.perl new file mode 100644 index 000000000..76791ebb2 --- /dev/null +++ b/sys/src/cmd/python/Doc/perl/howto.perl @@ -0,0 +1,12 @@ +# -*- perl -*- +# +# This implements the Python howto class. All it really needs to do it +# load the "python" style. + +package main; + +do_require_package("article"); +do_require_package("alltt"); +do_require_package("python"); + +1; # sheesh.... diff --git a/sys/src/cmd/python/Doc/perl/isilo.perl b/sys/src/cmd/python/Doc/perl/isilo.perl new file mode 100644 index 000000000..e990b36cb --- /dev/null +++ b/sys/src/cmd/python/Doc/perl/isilo.perl @@ -0,0 +1,12 @@ +package main; + +$USING_STYLES = 0; +$NO_NAVIGATION = 1; +$INDEX_COLUMNS = 1; +$MODULE_INDEX_COLUMNS = 1; + +sub child_line { + return ''; +} + +1; # stupid perl... diff --git a/sys/src/cmd/python/Doc/perl/l2hinit.perl b/sys/src/cmd/python/Doc/perl/l2hinit.perl new file mode 100644 index 000000000..7c5d1230d --- /dev/null +++ b/sys/src/cmd/python/Doc/perl/l2hinit.perl @@ -0,0 +1,801 @@ +# LaTeX2HTML support base for use with Python documentation. + +package main; + +use L2hos; + +$HTML_VERSION = 4.01; +$LOWER_CASE_TAGS = 1; +$NO_FRENCH_QUOTES = 1; + +# '' in \code{...} is still converted, so we can't use this yet. +#$USE_CURLY_QUOTES = 1; + +# Force Unicode support to be loaded; request UTF-8 output. +do_require_extension('unicode'); +do_require_extension('utf8'); +$HTML_OPTIONS = 'utf8'; + +$MAX_LINK_DEPTH = 2; +$ADDRESS = ''; + +$NO_FOOTNODE = 1; +$NUMBERED_FOOTNOTES = 1; + +# Python documentation uses section numbers to support references to match +# in the printed and online versions. +# +$SHOW_SECTION_NUMBERS = 1; + +$ICONSERVER = '.'; +$IMAGE_TYPE = 'gif'; + +# Control where the navigation bars should show up: +$TOP_NAVIGATION = 1; +$BOTTOM_NAVIGATION = 1; +$AUTO_NAVIGATION = 0; + +$BODYTEXT = ''; +$CHILDLINE = "\n<p><br /></p><hr class='online-navigation' />\n"; +$VERBOSITY = 0; + +# default # of columns for the indexes +$INDEX_COLUMNS = 2; +$MODULE_INDEX_COLUMNS = 4; + +$HAVE_MODULE_INDEX = 0; +$HAVE_GENERAL_INDEX = 0; +$HAVE_TABLE_OF_CONTENTS = 0; + +$AESOP_META_TYPE = 'information'; + + +# A little painful, but lets us clean up the top level directory a little, +# and not be tied to the current directory (as far as I can tell). Testing +# an existing definition of $mydir is needed since it cannot be computed when +# run under mkhowto with recent versions of LaTeX2HTML, since this file is +# not read directly by LaTeX2HTML any more. mkhowto is required to prepend +# the required definition at the top of the actual input file. +# +if (!defined $mydir) { + use Cwd; + use File::Basename; + ($myname, $mydir, $myext) = fileparse(__FILE__, '\..*'); + chop $mydir; # remove trailing '/' + $mydir = getcwd() . "$dd$mydir" + unless $mydir =~ s|^/|/|; +} +$LATEX2HTMLSTYLES = "$mydir$envkey$LATEX2HTMLSTYLES"; +push (@INC, $mydir); + +($myrootname, $myrootdir, $myext) = fileparse($mydir, '\..*'); +chop $myrootdir; + + +# Hackish way to get the appropriate paper-*/ directory into $TEXINPUTS; +# pass in the paper size (a4 or letter) as the environment variable PAPER +# to add the right directory. If not given, the current directory is +# added instead for use with HOWTO processing. +# +if (defined $ENV{'PAPER'}) { + $mytexinputs = "$myrootdir${dd}paper-$ENV{'PAPER'}$envkey"; +} +else { + $mytexinputs = getcwd() . $envkey; +} +$mytexinputs .= "$myrootdir${dd}texinputs"; + + +# Change this variable to change the text added in "About this document..."; +# this should be an absolute pathname to get it right. +# +$ABOUT_FILE = "$myrootdir${dd}html${dd}stdabout.dat"; + + +sub custom_driver_hook { + # + # This adds the directory of the main input file to $TEXINPUTS; it + # seems to be sufficiently general that it should be fine for HOWTO + # processing. + # + # XXX This still isn't quite right; we should actually be inserting + # $mytexinputs just before any empty entry in TEXINPUTS is one + # exists instead of just concatenating the pieces like we do here. + # + my $file = $_[0]; + my($jobname, $dir, $ext) = fileparse($file, '\..*'); + $dir = L2hos->Make_directory_absolute($dir); + $dir =~ s/$dd$//; + $TEXINPUTS = "$dir$envkey$mytexinputs"; + # Push everything into $TEXINPUTS since LaTeX2HTML doesn't pick + # this up on its own; we clear $ENV{'TEXINPUTS'} so the value set + # for this by the main LaTeX2HTML script doesn't contain duplicate + # directories. + if ($ENV{'TEXINPUTS'}) { + $TEXINPUTS .= "$envkey$ENV{'TEXINPUTS'}"; + $ENV{'TEXINPUTS'} = undef; + } + print "\nSetting \$TEXINPUTS to $TEXINPUTS\n"; + + # Not sure why we need to deal with this both here and at the top, + # but this is needed to actually make it work. + do_require_extension('utf8'); + $charset = $utf8_str; + $CHARSET = $utf8_str; + $USE_UTF = 1; +} + + +# $CUSTOM_BUTTONS is only used for the module index link. +$CUSTOM_BUTTONS = ''; + +sub make_nav_sectref($$$) { + my($label, $linktype, $title) = @_; + if ($title) { + if ($title =~ /\<[aA] /) { + $title =~ s/\<[aA] /<a class="sectref" rel="$linktype" /; + $title =~ s/ HREF=/ href=/; + } + else { + $title = "<span class=\"sectref\">$title</span>"; + } + return "<b class=\"navlabel\">$label:</b>\n$title\n"; + } + return ''; +} + +@my_icon_tags = (); +$my_icon_tags{'next'} = 'Next Page'; +$my_icon_tags{'next_page'} = 'Next Page'; +$my_icon_tags{'previous'} = 'Previous Page'; +$my_icon_tags{'previous_page'} = 'Previous Page'; +$my_icon_tags{'up'} = 'Up One Level'; +$my_icon_tags{'contents'} = 'Contents'; +$my_icon_tags{'index'} = 'Index'; +$my_icon_tags{'modules'} = 'Module Index'; + +@my_icon_names = (); +$my_icon_names{'previous_page'} = 'previous'; +$my_icon_names{'next_page'} = 'next'; + +sub get_my_icon($) { + my $name = $_[0]; + my $text = $my_icon_tags{$name}; + if ($my_icon_names{$name}) { + $name = $my_icon_names{$name}; + } + if ($text eq '') { + $name = 'blank'; + } + my $iconserver = ($ICONSERVER eq '.') ? '' : "$ICONSERVER/"; + return "<img src='$iconserver$name.$IMAGE_TYPE'\n border='0'" + . " height='32' alt='$text' width='32' />"; +} + +sub unlinkify($) { + my $text = "$_[0]"; + $text =~ s|</[aA]>||; + $text =~ s|<a\s+[^>]*>||i; + return $text; +} + +sub use_icon($$$) { + my($rel,$str,$title) = @_; + if ($str) { + my $s = "$str"; + if ($s =~ /\<tex2html_([a-z_]+)_visible_mark\>/) { + my $r = get_my_icon($1); + $s =~ s/\<tex2html_[a-z_]+_visible_mark\>/$r/; + } + $s =~ s/<[aA] /<a rel="$rel" title="$title"\n /; + $s =~ s/ HREF=/ href=/; + return $s; + } + else { + return get_my_icon('blank'); + } +} + +sub make_nav_panel() { + my $s; + # new iconic rel iconic page title + my $next = use_icon('next', $NEXT, unlinkify($NEXT_TITLE)); + my $up = use_icon('parent', $UP, unlinkify($UP_TITLE)); + my $previous = use_icon('prev', $PREVIOUS, unlinkify($PREVIOUS_TITLE)); + my $contents = use_icon('contents', $CONTENTS, 'Table of Contents'); + my $index = use_icon('index', $INDEX, 'Index'); + if (!$CUSTOM_BUTTONS) { + $CUSTOM_BUTTONS = get_my_icon('blank'); + } + $s = ('<table align="center" width="100%" cellpadding="0" cellspacing="2">' + . "\n<tr>" + # left-hand side + . "\n<td class='online-navigation'>$previous</td>" + . "\n<td class='online-navigation'>$up</td>" + . "\n<td class='online-navigation'>$next</td>" + # title box + . "\n<td align=\"center\" width=\"100%\">$t_title</td>" + # right-hand side + . "\n<td class='online-navigation'>$contents</td>" + # module index + . "\n<td class='online-navigation'>$CUSTOM_BUTTONS</td>" + . "\n<td class='online-navigation'>$index</td>" + . "\n</tr></table>\n" + # textual navigation + . "<div class='online-navigation'>\n" + . make_nav_sectref("Previous", "prev", $PREVIOUS_TITLE) + . make_nav_sectref("Up", "parent", $UP_TITLE) + . make_nav_sectref("Next", "next", $NEXT_TITLE) + . "</div>\n" + ); + # remove these; they are unnecessary and cause errors from validation + $s =~ s/ NAME="tex2html\d+"\n */ /g; + return $s; +} + +sub add_child_links { + my $toc = add_real_child_links(@_); + $toc =~ s|\s*</[aA]>|</a>|g; + $toc =~ s/ NAME=\"tex2html\d+\"\s*href=/ href=/gi; + $toc =~ s|</UL>(\s*<BR( /)?>)?|</ul>|gi; + if ($toc =~ / NAME=["']CHILD_LINKS["']/) { + return "<div class='online-navigation'>\n$toc</div>\n"; + } + return $toc; +} + +sub get_version_text() { + if ($PACKAGE_VERSION ne '' && $t_date) { + return ("<span class=\"release-info\">" + . "Release $PACKAGE_VERSION$RELEASE_INFO," + . " documentation updated on $t_date.</span>"); + } + if ($PACKAGE_VERSION ne '') { + return ("<span class=\"release-info\">" + . "Release $PACKAGE_VERSION$RELEASE_INFO.</span>"); + } + if ($t_date) { + return ("<span class=\"release-info\">Documentation released on " + . "$t_date.</span>"); + } + return ''; +} + + +sub top_navigation_panel() { + return "\n<div id='top-navigation-panel' xml:id='top-navigation-panel'>\n" + . make_nav_panel() + . "<hr /></div>\n"; +} + +sub bot_navigation_panel() { + return "\n<div class='online-navigation'>\n" + . "<p></p><hr />\n" + . make_nav_panel() + . "</div>\n" + . "<hr />\n" + . get_version_text() + . "\n"; +} + +sub add_link { + # Returns a pair (iconic link, textual link) + my($icon, $current_file, @link) = @_; + my($dummy, $file, $title) = split($delim, + $section_info{join(' ',@link)}); + if ($icon =~ /\<tex2html_([_a-z]+)_visible_mark\>/) { + my $r = get_my_icon($1); + $icon =~ s/\<tex2html_[_a-z]+_visible_mark\>/$r/; + } + if ($title && ($file ne $current_file)) { + $title = purify($title); + $title = get_first_words($title, $WORDS_IN_NAVIGATION_PANEL_TITLES); + return (make_href($file, $icon), make_href($file, "$title")) + } + elsif ($icon eq get_my_icon('up') && $EXTERNAL_UP_LINK) { + return (make_href($EXTERNAL_UP_LINK, $icon), + make_href($EXTERNAL_UP_LINK, "$EXTERNAL_UP_TITLE")) + } + elsif ($icon eq get_my_icon('previous') + && $EXTERNAL_PREV_LINK && $EXTERNAL_PREV_TITLE) { + return (make_href($EXTERNAL_PREV_LINK, $icon), + make_href($EXTERNAL_PREV_LINK, "$EXTERNAL_PREV_TITLE")) + } + elsif ($icon eq get_my_icon('next') + && $EXTERNAL_DOWN_LINK && $EXTERNAL_DOWN_TITLE) { + return (make_href($EXTERNAL_DOWN_LINK, $icon), + make_href($EXTERNAL_DOWN_LINK, "$EXTERNAL_DOWN_TITLE")) + } + return (&inactive_img($icon), ""); +} + +sub add_special_link($$$) { + my($icon, $file, $current_file) = @_; + if ($icon =~ /\<tex2html_([_a-z]+)_visible_mark\>/) { + my $r = get_my_icon($1); + $icon =~ s/\<tex2html_[_a-z]+_visible_mark\>/$r/; + } + return (($file && ($file ne $current_file)) + ? make_href($file, $icon) + : undef) +} + +# The img_tag() function seems only to be called with the parameter +# 'anchor_invisible_mark', which we want to turn into ''. Since +# replace_icon_marks() is the only interesting caller, and all it really +# does is call img_tag(), we can just define the hook alternative to be +# a no-op instead. +# +sub replace_icons_hook {} + +sub do_cmd_arabic { + # get rid of that nasty <SPAN CLASS="arabic">...</SPAN> + my($ctr, $val, $id, $text) = &read_counter_value($_[0]); + return ($val ? farabic($val) : "0") . $text; +} + + +sub gen_index_id($$) { + # this is used to ensure common index key generation and a stable sort + my($str, $extra) = @_; + sprintf('%s###%s%010d', $str, $extra, ++$global{'max_id'}); +} + +sub insert_index($$$$$) { + my($mark, $datafile, $columns, $letters, $prefix) = @_; + my $prog = "$myrootdir/tools/buildindex.py"; + my $index; + if ($letters) { + $index = `$prog --columns $columns --letters $datafile`; + } + else { + $index = `$prog --columns $columns $datafile`; + } + if (!s/$mark/$prefix$index/) { + print "\nCould not locate index mark: $mark"; + } +} + +sub add_idx() { + print "\nBuilding HTML for the index ..."; + close(IDXFILE); + insert_index($idx_mark, 'index.dat', $INDEX_COLUMNS, 1, ''); +} + + +$idx_module_mark = '<tex2html_idx_module_mark>'; +$idx_module_title = 'Module Index'; + +sub add_module_idx() { + print "\nBuilding HTML for the module index ..."; + my $key; + my $first = 1; + my $prevplat = ''; + my $allthesame = 1; + my $prefix = ''; + foreach $key (keys %Modules) { + $key =~ s/<tt>([a-zA-Z0-9._]*)<\/tt>/$1/; + my $plat = "$ModulePlatforms{$key}"; + $plat = '' + if ($plat eq $IGNORE_PLATFORM_ANNOTATION); + if (!$first) { + $allthesame = 0 + if ($prevplat ne $plat); + } + else { $first = 0; } + $prevplat = $plat; + } + open(MODIDXFILE, '>modindex.dat') || die "\n$!\n"; + foreach $key (keys %Modules) { + # dump the line in the data file; just use a dummy seqno field + my $nkey = $1; + my $moditem = "$Modules{$key}"; + my $plat = ''; + $key =~ s/<tt>([a-zA-Z0-9._]*)<\/tt>/$1/; + if ($ModulePlatforms{$key} && !$allthesame) { + $plat = (" <em>(<span class=\"platform\">$ModulePlatforms{$key}" + . '</span>)</em>'); + } + print MODIDXFILE $moditem . $IDXFILE_FIELD_SEP + . "<tt class=\"module\">$key</tt>$plat###\n"; + } + close(MODIDXFILE); + + if ($GLOBAL_MODULE_INDEX) { + $prefix = <<MODULE_INDEX_PREFIX; + +<p> This index only lists modules documented in this manual. + The <em class="citetitle"><a href="$GLOBAL_MODULE_INDEX">Global Module + Index</a></em> lists all modules that are documented in this set + of manuals.</p> +MODULE_INDEX_PREFIX + } + if (!$allthesame) { + $prefix .= <<PLAT_DISCUSS; + +<p> Some module names are followed by an annotation indicating what +platform they are available on.</p> + +PLAT_DISCUSS + } + insert_index($idx_module_mark, 'modindex.dat', $MODULE_INDEX_COLUMNS, 0, + $prefix); +} + +# replace both indexes as needed: +sub add_idx_hook { + add_idx() if (/$idx_mark/); + process_python_state(); + if ($MODULE_INDEX_FILE) { + local ($_); + open(MYFILE, "<$MODULE_INDEX_FILE"); + sysread(MYFILE, $_, 1024*1024); + close(MYFILE); + add_module_idx(); + open(MYFILE,">$MODULE_INDEX_FILE"); + print MYFILE $_; + close(MYFILE); + } +} + + +# In addition to the standard stuff, add label to allow named node files and +# support suppression of the page complete (for HTML Help use). +$MY_CONTENTS_PAGE = ''; +sub do_cmd_tableofcontents { + local($_) = @_; + $TITLE = $toc_title; + $tocfile = $CURRENT_FILE; + my($closures, $reopens) = preserve_open_tags(); + anchor_label('contents', $CURRENT_FILE, $_); # this is added + $MY_CONTENTS_PAGE = "$CURRENT_FILE"; + join('', "\\tableofchildlinks[off]", $closures + , make_section_heading($toc_title, 'h2'), $toc_mark + , $reopens, $_); +} +# In addition to the standard stuff, add label to allow named node files. +sub do_cmd_listoffigures { + local($_) = @_; + $TITLE = $lof_title; + $loffile = $CURRENT_FILE; + my($closures, $reopens) = preserve_open_tags(); + anchor_label('lof', $CURRENT_FILE, $_); # this is added + join('', "<br />\n", $closures + , make_section_heading($lof_title, 'h2'), $lof_mark + , $reopens, $_); +} +# In addition to the standard stuff, add label to allow named node files. +sub do_cmd_listoftables { + local($_) = @_; + $TITLE = $lot_title; + $lotfile = $CURRENT_FILE; + my($closures, $reopens) = preserve_open_tags(); + anchor_label('lot', $CURRENT_FILE, $_); # this is added + join('', "<br />\n", $closures + , make_section_heading($lot_title, 'h2'), $lot_mark + , $reopens, $_); +} +# In addition to the standard stuff, add label to allow named node files. +sub do_cmd_textohtmlinfopage { + local($_) = @_; + if ($INFO) { # + anchor_label("about",$CURRENT_FILE,$_); # this is added + } # + my $the_version = ''; # and the rest is + if ($t_date) { # mostly ours + $the_version = ",\n$t_date"; + if ($PACKAGE_VERSION) { + $the_version .= ", Release $PACKAGE_VERSION$RELEASE_INFO"; + } + } + my $about; + open(ABOUT, "<$ABOUT_FILE") || die "\n$!\n"; + sysread(ABOUT, $about, 1024*1024); + close(ABOUT); + $_ = (($INFO == 1) + ? join('', + $close_all, + "<strong>$t_title</strong>$the_version\n", + $about, + $open_all, $_) + : join('', $close_all, $INFO,"\n", $open_all, $_)); + $_; +} + +$GENERAL_INDEX_FILE = ''; +$MODULE_INDEX_FILE = ''; + +# $idx_mark will be replaced with the real index at the end +sub do_cmd_textohtmlindex { + local($_) = @_; + $TITLE = $idx_title; + $idxfile = $CURRENT_FILE; + $GENERAL_INDEX_FILE = "$CURRENT_FILE"; + if (%index_labels) { make_index_labels(); } + if (($SHORT_INDEX) && (%index_segment)) { make_preindex(); } + else { $preindex = ''; } + my $heading = make_section_heading($idx_title, 'h2') . $idx_mark; + my($pre, $post) = minimize_open_tags($heading); + anchor_label('genindex',$CURRENT_FILE,$_); # this is added + return "<br />\n" . $pre . $_; +} + +# $idx_module_mark will be replaced with the real index at the end +sub do_cmd_textohtmlmoduleindex { + local($_) = @_; + $TITLE = $idx_module_title; + anchor_label('modindex', $CURRENT_FILE, $_); + $MODULE_INDEX_FILE = "$CURRENT_FILE"; + $_ = ('<p></p>' . make_section_heading($idx_module_title, 'h2') + . $idx_module_mark . $_); + return $_; +} + +# The bibliography and the index should be treated as separate +# sections in their own HTML files. The \bibliography{} command acts +# as a sectioning command that has the desired effect. But when the +# bibliography is constructed manually using the thebibliography +# environment, or when using the theindex environment it is not +# possible to use the normal sectioning mechanism. This subroutine +# inserts a \bibliography{} or a dummy \textohtmlindex command just +# before the appropriate environments to force sectioning. + +# XXX This *assumes* that if there are two {theindex} environments, +# the first is the module index and the second is the standard +# index. This is sufficient for the current Python documentation, +# but that's about it. + +sub add_bbl_and_idx_dummy_commands { + my $id = $global{'max_id'}; + + if (/[\\]tableofcontents/) { + $HAVE_TABLE_OF_CONTENTS = 1; + } + s/([\\]begin\s*$O\d+$C\s*thebibliography)/$bbl_cnt++; $1/eg; + s/([\\]begin\s*$O\d+$C\s*thebibliography)/$id++; "\\bibliography$O$id$C$O$id$C $1"/geo; + my(@parts) = split(/\\begin\s*$O\d+$C\s*theindex/); + if (scalar(@parts) == 3) { + # Be careful to re-write the string in place, since $_ is *not* + # returned explicity; *** nasty side-effect dependency! *** + print "\nadd_bbl_and_idx_dummy_commands ==> adding general index"; + print "\nadd_bbl_and_idx_dummy_commands ==> adding module index"; + my $rx = "([\\\\]begin\\s*$O\\d+$C\\s*theindex[\\s\\S]*)" + . "([\\\\]begin\\s*$O\\d+$C\\s*theindex)"; + s/$rx/\\textohtmlmoduleindex $1 \\textohtmlindex $2/o; + # Add a button to the navigation areas: + $CUSTOM_BUTTONS .= ('<a href="modindex.html" title="Module Index">' + . get_my_icon('modules') + . '</a>'); + $HAVE_MODULE_INDEX = 1; + $HAVE_GENERAL_INDEX = 1; + } + elsif (scalar(@parts) == 2) { + print "\nadd_bbl_and_idx_dummy_commands ==> adding general index"; + my $rx = "([\\\\]begin\\s*$O\\d+$C\\s*theindex)"; + s/$rx/\\textohtmlindex $1/o; + $HAVE_GENERAL_INDEX = 1; + } + elsif (scalar(@parts) == 1) { + print "\nadd_bbl_and_idx_dummy_commands ==> no index found"; + $CUSTOM_BUTTONS .= get_my_icon('blank'); + $global{'max_id'} = $id; # not sure why.... + s/([\\]begin\s*$O\d+$C\s*theindex)/\\textohtmlindex $1/o; + s/[\\]printindex/\\textohtmlindex /o; + } + else { + die "\n\nBad number of index environments!\n\n"; + } + #---------------------------------------------------------------------- + lib_add_bbl_and_idx_dummy_commands() + if defined(&lib_add_bbl_and_idx_dummy_commands); +} + +# The bibliographic references, the appendices, the lists of figures +# and tables etc. must appear in the contents table at the same level +# as the outermost sectioning command. This subroutine finds what is +# the outermost level and sets the above to the same level; + +sub set_depth_levels { + # Sets $outermost_level + my $level; + #RRM: do not alter user-set value for $MAX_SPLIT_DEPTH + foreach $level ("part", "chapter", "section", "subsection", + "subsubsection", "paragraph") { + last if (($outermost_level) = /\\($level)$delimiter_rx/); + } + $level = ($outermost_level ? $section_commands{$outermost_level} : + do {$outermost_level = 'section'; 3;}); + + #RRM: but calculate value for $MAX_SPLIT_DEPTH when a $REL_DEPTH was given + if ($REL_DEPTH && $MAX_SPLIT_DEPTH) { + $MAX_SPLIT_DEPTH = $level + $MAX_SPLIT_DEPTH; + } elsif (!($MAX_SPLIT_DEPTH)) { $MAX_SPLIT_DEPTH = 1 }; + + %unnumbered_section_commands = ('tableofcontents' => $level, + 'listoffigures' => $level, + 'listoftables' => $level, + 'bibliography' => $level, + 'textohtmlindex' => $level, + 'textohtmlmoduleindex' => $level); + $section_headings{'textohtmlmoduleindex'} = 'h1'; + + %section_commands = (%unnumbered_section_commands, + %section_commands); + + make_sections_rx(); +} + + +# This changes the markup used for {verbatim} environments, and is the +# best way I've found that ensures the <dl> goes on the outside of the +# <pre>...</pre>. +# +# Note that this *must* be done in the init file, not the python.perl +# style support file. The %declarations must be set before +# initialize() is called in the main LaTeX2HTML script (which happens +# before style files are loaded). +# +%declarations = ('preform' => '<div class="verbatim"><pre></pre></div>', + %declarations); + + +# This is a modified version of what's provided by LaTeX2HTML; see the +# comment on the middle stanza for an explanation of why we keep our +# own version. +# +# This routine must be called once on the text only, +# else it will "eat up" sensitive constructs. +sub text_cleanup { + # MRO: replaced $* with /m + s/(\s*\n){3,}/\n\n/gom; # Replace consecutive blank lines with one + s/<(\/?)P>\s*(\w)/<$1P>\n$2/gom; # clean up paragraph starts and ends + s/$O\d+$C//go; # Get rid of bracket id's + s/$OP\d+$CP//go; # Get rid of processed bracket id's + s/(<!)?--?(>)?/(length($1) || length($2)) ? "$1--$2" : "-"/ge; + # Spacing commands + s/\\( |$)/ /go; + #JKR: There should be no more comments in the source now. + #s/([^\\]?)%/$1/go; # Remove the comment character + # Cannot treat \, as a command because , is a delimiter ... + s/\\,/ /go; + # Replace tilde's with non-breaking spaces + s/ *~/ /g; + + # This is why we have this copy of this routine; the following + # isn't so desirable as the author/maintainers of LaTeX2HTML seem + # to think. It's not commented out in the main script, so we have + # to override the whole thing. In particular, we don't want empty + # table cells to disappear. + + ### DANGEROUS ?? ### + # remove redundant (not <P></P>) empty tags, incl. with attributes + #s/\n?<([^PD >][^>]*)>\s*<\/\1>//g; + #s/\n?<([^PD >][^>]*)>\s*<\/\1>//g; + # remove redundant empty tags (not </P><P> or <TD> or <TH>) + #s/<\/(TT|[^PTH][A-Z]+)><\1>//g; + #s/<([^PD ]+)(\s[^>]*)?>\n*<\/\1>//g; + + #JCL(jcl-hex) + # Replace ^^ special chars (according to p.47 of the TeX book) + # Useful when coming from the .aux file (german umlauts, etc.) + s/\^\^([^0-9a-f])/chr((64+ord($1))&127)/ge; + s/\^\^([0-9a-f][0-9a-f])/chr(hex($1))/ge; +} + +# This is used to map the link rel attributes LaTeX2HTML uses to those +# currently recommended by the W3C. +sub custom_REL_hook { + my($rel,$junk) = @_; + return 'parent' if $rel eq 'up'; + return 'prev' if $rel eq 'previous'; + return $rel; +} + +# This is added to get rid of the long comment that follows the +# doctype declaration; MSIE5 on NT4 SP4 barfs on it and drops the +# content of the page. +$MY_PARTIAL_HEADER = ''; +sub make_head_and_body($$) { + my($title, $body) = @_; + $body = " $body" unless ($body eq ''); + my $DTDcomment = ''; + my($version, $isolanguage) = ($HTML_VERSION, 'EN'); + my %isolanguages = ( 'english', 'EN' , 'USenglish', 'EN.US' + , 'original', 'EN' , 'german' , 'DE' + , 'austrian', 'DE.AT', 'french' , 'FR' + , 'spanish', 'ES'); + $isolanguage = $isolanguages{$default_language}; + $isolanguage = 'EN' unless $isolanguage; + $title = &purify($title,1); + eval("\$title = ". $default_title ) unless ($title); + + # allow user-modification of the <title> tag; thanks Dan Young + if (defined &custom_TITLE_hook) { + $title = &custom_TITLE_hook($title, $toc_sec_title); + } + + if ($DOCTYPE =~ /\/\/[\w\.]+\s*$/) { # language spec included + $DTDcomment = "<!DOCTYPE html PUBLIC \"$DOCTYPE\">\n"; + } else { + $DTDcomment = "<!DOCTYPE html PUBLIC \"$DOCTYPE//" + . ($ISO_LANGUAGE ? $ISO_LANGUAGE : $isolanguage) . "\">\n"; + } + if ($MY_PARTIAL_HEADER eq '') { + my $favicon = ''; + if ($FAVORITES_ICON) { + my($myname, $mydir, $myext) = fileparse($FAVORITES_ICON, '\..*'); + my $favtype = ''; + if ($myext eq '.gif' || $myext eq '.png') { + $myext =~ s/^[.]//; + $favtype = " type=\"image/$myext\""; + } + $favicon = ( + "\n<link rel=\"SHORTCUT ICON\" href=\"$FAVORITES_ICON\"" + . "$favtype />"); + } + $STYLESHEET = $FILE.".css" unless $STYLESHEET; + $MY_PARTIAL_HEADER = join('', + ($DOCTYPE ? $DTDcomment : ''), + "<html>\n<head>", + ($BASE ? "\n<base href=\"$BASE\" />" : ''), + "\n<link rel=\"STYLESHEET\" href=\"$STYLESHEET\" type='text/css'", + " />", + $favicon, + ($EXTERNAL_UP_LINK + ? ("\n<link rel='start' href='" . $EXTERNAL_UP_LINK + . ($EXTERNAL_UP_TITLE ? + "' title='$EXTERNAL_UP_TITLE' />" : "' />")) + : ''), + "\n<link rel=\"first\" href=\"$FILE.html\"", + ($t_title ? " title='$t_title'" : ''), + ' />', + ($HAVE_TABLE_OF_CONTENTS + ? ("\n<link rel='contents' href='$MY_CONTENTS_PAGE'" + . ' title="Contents" />') + : ''), + ($HAVE_GENERAL_INDEX + ? ("\n<link rel='index' href='$GENERAL_INDEX_FILE'" + . " title='Index' />") + : ''), + # disable for now -- Mozilla doesn't do well with multiple indexes + # ($HAVE_MODULE_INDEX + # ? ("<link rel="index" href='$MODULE_INDEX_FILE'" + # . " title='Module Index' />\n") + # : ''), + ($INFO + # XXX We can do this with the Python tools since the About... + # page always gets copied to about.html, even when we use the + # generated node###.html page names. Won't work with the + # rest of the Python doc tools. + ? ("\n<link rel='last' href='about.html'" + . " title='About this document...' />" + . "\n<link rel='help' href='about.html'" + . " title='About this document...' />") + : ''), + $more_links_mark, + "\n", + ($CHARSET && $HTML_VERSION ge "2.1" + ? ('<meta http-equiv="Content-Type" content="text/html; ' + . "charset=$CHARSET\" />\n") + : ''), + ($AESOP_META_TYPE + ? "<meta name='aesop' content='$AESOP_META_TYPE' />\n" : '')); + } + if (!$charset && $CHARSET) { + $charset = $CHARSET; + $charset =~ s/_/\-/go; + } + join('', + $MY_PARTIAL_HEADER, + "<title>", $title, "</title>\n</head>\n<body$body>"); +} + +sub replace_morelinks { + $more_links =~ s/ REL=/ rel=/g; + $more_links =~ s/ HREF=/ href=/g; + $more_links =~ s/<LINK /<link /g; + $more_links =~ s/">/" \/>/g; + $_ =~ s/$more_links_mark/$more_links/e; +} + +1; # This must be the last line diff --git a/sys/src/cmd/python/Doc/perl/ltxmarkup.perl b/sys/src/cmd/python/Doc/perl/ltxmarkup.perl new file mode 100644 index 000000000..1a0f7e193 --- /dev/null +++ b/sys/src/cmd/python/Doc/perl/ltxmarkup.perl @@ -0,0 +1,67 @@ +# LaTeX2HTML support for the ltxmarkup package. Doesn't do indexing. + +package main; + + +sub ltx_next_argument{ + my $param; + $param = missing_braces() + unless ((s/$next_pair_pr_rx/$param=$2;''/eo) + ||(s/$next_pair_rx/$param=$2;''/eo)); + return $param; +} + + +sub do_cmd_macro{ + local($_) = @_; + my $macro = ltx_next_argument(); + return "<tt class='macro'>\$macro</tt>" . $_; +} + +sub do_cmd_env{ + local($_) = @_; + my $env = ltx_next_argument(); + return "<tt class='environment'>\$env</tt>" . $_; +} + +sub ltx_process_params{ + # Handle processing of \p and \op for parameter specifications for + # envdesc and macrodesc. It's done this way to avoid defining do_cmd_p() + # and do_cmd_op() functions, which would be interpreted outside the context + # in which these commands are legal, and cause LaTeX2HTML to think they're + # defined. This way, other uses of \p and \op are properly flagged as + # unknown macros. + my $s = @_[0]; + $s =~ s%\\op<<(\d+)>>(.+)<<\1>>%<tt>[</tt><var>$2</var><tt>]</tt>%; + while ($s =~ /\\p<<(\d+)>>(.+)<<\1>>/) { + $s =~ s%\\p<<(\d+)>>(.+)<<\1>>%<tt>{</tt><var>$2</var><tt>}</tt>%; + } + return $s; +} + +sub do_env_macrodesc{ + local($_) = @_; + my $macro = ltx_next_argument(); + my $params = ltx_process_params(ltx_next_argument()); + return "\n<dl class='macrodesc'>" + . "\n<dt><b><tt class='macro'>\$macro</tt></b>" + . "\n $params</dt>" + . "\n<dd>" + . $_ + . '</dd></dl>'; +} + +sub do_env_envdesc{ + local($_) = @_; + my $env = ltx_next_argument(); + my $params = ltx_process_params(ltx_next_argument()); + return "\n<dl class='envdesc'>" + . "\n<dt><tt>\begin{<b class='environment'>$env</b>}</tt>" + . "\n $params" + . "\n<br /><tt>\end{<b class='environment'>$env</b>}</tt></dt>" + . "\n<dd>" + . $_ + . '</dd></dl>'; +} + +1; # Must end with this, because Perl is bogus. diff --git a/sys/src/cmd/python/Doc/perl/manual.perl b/sys/src/cmd/python/Doc/perl/manual.perl new file mode 100644 index 000000000..ea65b36e7 --- /dev/null +++ b/sys/src/cmd/python/Doc/perl/manual.perl @@ -0,0 +1,15 @@ +# -*- perl -*- +# +# This implements the Python manual class. All it really needs to do it +# load the "python" style. The style code is not moved into the class code +# at this time, since we expect additional document class to be developed +# for the Python documentation in the future. Appropriate relocations will +# be made at that time. + +package main; + +do_require_package("report"); +do_require_package("alltt"); +do_require_package("python"); + +1; # sheesh.... diff --git a/sys/src/cmd/python/Doc/perl/python.perl b/sys/src/cmd/python/Doc/perl/python.perl new file mode 100644 index 000000000..ab93c7cf8 --- /dev/null +++ b/sys/src/cmd/python/Doc/perl/python.perl @@ -0,0 +1,2172 @@ +# python.perl by Fred L. Drake, Jr. <fdrake@acm.org> -*- perl -*- +# +# Heavily based on Guido van Rossum's myformat.perl (now obsolete). +# +# Extension to LaTeX2HTML for documents using myformat.sty. +# Subroutines of the form do_cmd_<name> here define translations +# for LaTeX commands \<name> defined in the corresponding .sty file. + +package main; + +use warnings; +use File::Basename; + + +sub next_argument{ + my $param; + $param = missing_braces() + unless ((s/$next_pair_pr_rx/$param=$2;''/eo) + ||(s/$next_pair_rx/$param=$2;''/eo)); + return $param; +} + +sub next_optional_argument{ + my($param, $rx) = ('', "^\\s*(\\[([^]]*)\\])?"); + s/$rx/$param=$2;''/eo; + return $param; +} + +sub make_icon_filename($){ + my($myname, $mydir, $myext) = fileparse($_[0], '\..*'); + chop $mydir; + if ($mydir eq '.') { + $mydir = $ICONSERVER; + } + $myext = ".$IMAGE_TYPE" + unless $myext; + return "$mydir$dd$myname$myext"; +} + +sub get_link_icon($){ + my $url = $_[0]; + if ($OFF_SITE_LINK_ICON && ($url =~ /^[-a-zA-Z0-9.]+:/)) { + # absolute URL; assume it points off-site + my $icon = make_icon_filename($OFF_SITE_LINK_ICON); + return (" <img src=\"$icon\"\n" + . ' border="0" class="offsitelink"' + . ($OFF_SITE_LINK_ICON_HEIGHT + ? " height=\"$OFF_SITE_LINK_ICON_HEIGHT\"" + : '') + . ($OFF_SITE_LINK_ICON_WIDTH + ? " width=\"$OFF_SITE_LINK_ICON_WIDTH\"" + : '') + . " alt=\"[off-site link]\"\n" + . " />"); + } + return ''; +} + +# This is a fairly simple hack; it supports \let when it is used to create +# (or redefine) a macro to exactly be some other macro: \let\newname=\oldname. +# Many possible uses of \let aren't supported or aren't supported correctly. +# +sub do_cmd_let{ + local($_) = @_; + my $matched = 0; + s/[\\]([a-zA-Z]+)\s*(=\s*)?[\\]([a-zA-Z]*)/$matched=1; ''/e; + if ($matched) { + my($new, $old) = ($1, $3); + eval "sub do_cmd_$new { do_cmd_$old" . '(@_); }'; + print "\ndefining handler for \\$new using \\$old\n"; + } + else { + s/[\\]([a-zA-Z]+)\s*(=\s*)?([^\\])/$matched=1; ''/es; + if ($matched) { + my($new, $char) = ($1, $3); + eval "sub do_cmd_$new { \"\\$char\" . \$_[0]; }"; + print "\ndefining handler for \\$new to insert '$char'\n"; + } + else { + write_warnings("Could not interpret \\let construct..."); + } + } + return $_; +} + + +# the older version of LaTeX2HTML we use doesn't support this, but we use it: + +sub do_cmd_textasciitilde{ '~' . $_[0]; } +sub do_cmd_textasciicircum{ '^' . $_[0]; } +sub do_cmd_textbar{ '|' . $_[0]; } +sub do_cmd_texteuro { '€' . $_[0]; } +sub do_cmd_textgreater{ '>' . $_[0]; } +sub do_cmd_textless{ '<' . $_[0]; } +sub do_cmd_textunderscore{ '_' . $_[0]; } +sub do_cmd_infinity{ '∞' . $_[0]; } +sub do_cmd_plusminus{ '±' . $_[0]; } +sub do_cmd_guilabel{ + return use_wrappers($_[0]. '<span class="guilabel">', '</span>'); } +sub do_cmd_menuselection{ + return use_wrappers($_[0], '<span class="guilabel">', '</span>'); } +sub do_cmd_sub{ + return '</span> > <span class="guilabel">' . $_[0]; } + + +# words typeset in a special way (not in HTML though) + +sub do_cmd_ABC{ 'ABC' . $_[0]; } +sub do_cmd_UNIX{ '<span class="Unix">Unix</span>' . $_[0]; } +sub do_cmd_LaTeX{ '<span class="LaTeX">LaTeX</span>' . $_[0]; } +sub do_cmd_TeX{ '<span class="TeX">TeX</span>' . $_[0]; } +sub do_cmd_ASCII{ 'ASCII' . $_[0]; } +sub do_cmd_POSIX{ 'POSIX' . $_[0]; } +sub do_cmd_C{ 'C' . $_[0]; } +sub do_cmd_Cpp{ 'C++' . $_[0]; } +sub do_cmd_EOF{ 'EOF' . $_[0]; } +sub do_cmd_NULL{ '<tt class="constant">NULL</tt>' . $_[0]; } + +sub do_cmd_e{ '\' . $_[0]; } + +$DEVELOPER_ADDRESS = ''; +$SHORT_VERSION = ''; +$RELEASE_INFO = ''; +$PACKAGE_VERSION = ''; + +sub do_cmd_version{ $PACKAGE_VERSION . $_[0]; } +sub do_cmd_shortversion{ $SHORT_VERSION . $_[0]; } +sub do_cmd_release{ + local($_) = @_; + $PACKAGE_VERSION = next_argument(); + return $_; +} + +sub do_cmd_setreleaseinfo{ + local($_) = @_; + $RELEASE_INFO = next_argument(); + return $_; +} + +sub do_cmd_setshortversion{ + local($_) = @_; + $SHORT_VERSION = next_argument(); + return $_; +} + +sub do_cmd_authoraddress{ + local($_) = @_; + $DEVELOPER_ADDRESS = next_argument(); + return $_; +} + +sub do_cmd_hackscore{ + local($_) = @_; + next_argument(); + return '_' . $_; +} + +# Helper used in many places that arbitrary code-like text appears: + +sub codetext($){ + my $text = "$_[0]"; + # Make sure that "---" is not converted to "--" later when + # LaTeX2HTML tries converting em-dashes based on the conventional + # TeX font ligatures: + $text =~ s/--/-\-/go; + return $text; +} + +sub use_wrappers($$$){ + local($_,$before,$after) = @_; + my $stuff = next_argument(); + return $before . $stuff . $after . $_; +} + +sub use_code_wrappers($$$){ + local($_,$before,$after) = @_; + my $stuff = codetext(next_argument()); + return $before . $stuff . $after . $_; +} + +$IN_DESC_HANDLER = 0; +sub do_cmd_optional{ + if ($IN_DESC_HANDLER) { + return use_wrappers($_[0], "</var><big>\[</big><var>", + "</var><big>\]</big><var>"); + } + else { + return use_wrappers($_[0], "<big>\[</big>", "<big>\]</big>"); + } +} + +# Logical formatting (some based on texinfo), needs to be converted to +# minimalist HTML. The "minimalist" is primarily to reduce the size of +# output files for users that read them over the network rather than +# from local repositories. + +sub do_cmd_pytype{ return $_[0]; } +sub do_cmd_makevar{ + return use_wrappers($_[0], '<span class="makevar">', '</span>'); } +sub do_cmd_code{ + return use_code_wrappers($_[0], '<code>', '</code>'); } +sub do_cmd_module{ + return use_wrappers($_[0], '<tt class="module">', '</tt>'); } +sub do_cmd_keyword{ + return use_wrappers($_[0], '<tt class="keyword">', '</tt>'); } +sub do_cmd_exception{ + return use_wrappers($_[0], '<tt class="exception">', '</tt>'); } +sub do_cmd_class{ + return use_wrappers($_[0], '<tt class="class">', '</tt>'); } +sub do_cmd_function{ + return use_wrappers($_[0], '<tt class="function">', '</tt>'); } +sub do_cmd_constant{ + return use_wrappers($_[0], '<tt class="constant">', '</tt>'); } +sub do_cmd_member{ + return use_wrappers($_[0], '<tt class="member">', '</tt>'); } +sub do_cmd_method{ + return use_wrappers($_[0], '<tt class="method">', '</tt>'); } +sub do_cmd_cfunction{ + return use_wrappers($_[0], '<tt class="cfunction">', '</tt>'); } +sub do_cmd_cdata{ + return use_wrappers($_[0], '<tt class="cdata">', '</tt>'); } +sub do_cmd_ctype{ + return use_wrappers($_[0], '<tt class="ctype">', '</tt>'); } +sub do_cmd_regexp{ + return use_code_wrappers($_[0], '<tt class="regexp">', '</tt>'); } +sub do_cmd_character{ + return use_code_wrappers($_[0], '"<tt class="character">', '</tt>"'); } +sub do_cmd_program{ + return use_wrappers($_[0], '<b class="program">', '</b>'); } +sub do_cmd_programopt{ + return use_wrappers($_[0], '<b class="programopt">', '</b>'); } +sub do_cmd_longprogramopt{ + # note that the --- will be later converted to -- by LaTeX2HTML + return use_wrappers($_[0], '<b class="programopt">---', '</b>'); } +sub do_cmd_email{ + return use_wrappers($_[0], '<span class="email">', '</span>'); } +sub do_cmd_mailheader{ + return use_wrappers($_[0], '<span class="mailheader">', ':</span>'); } +sub do_cmd_mimetype{ + return use_wrappers($_[0], '<span class="mimetype">', '</span>'); } +sub do_cmd_var{ + return use_wrappers($_[0], "<var>", "</var>"); } +sub do_cmd_dfn{ + return use_wrappers($_[0], '<i class="dfn">', '</i>'); } +sub do_cmd_emph{ + return use_wrappers($_[0], '<em>', '</em>'); } +sub do_cmd_file{ + return use_wrappers($_[0], '<span class="file">', '</span>'); } +sub do_cmd_filenq{ + return do_cmd_file($_[0]); } +sub do_cmd_samp{ + return use_code_wrappers($_[0], '"<tt class="samp">', '</tt>"'); } +sub do_cmd_kbd{ + return use_wrappers($_[0], '<kbd>', '</kbd>'); } +sub do_cmd_strong{ + return use_wrappers($_[0], '<strong>', '</strong>'); } +sub do_cmd_textbf{ + return use_wrappers($_[0], '<b>', '</b>'); } +sub do_cmd_textit{ + return use_wrappers($_[0], '<i>', '</i>'); } +# This can be changed/overridden for translations: +%NoticeNames = ('note' => 'Note:', + 'warning' => 'Warning:', + ); + +sub do_cmd_note{ + my $label = $NoticeNames{'note'}; + return use_wrappers( + $_[0], + "<span class=\"note\"><b class=\"label\">$label</b>\n", + '</span>'); } +sub do_cmd_warning{ + my $label = $NoticeNames{'warning'}; + return use_wrappers( + $_[0], + "<span class=\"warning\"><b class=\"label\">$label</b>\n", + '</span>'); } + +sub do_env_notice{ + local($_) = @_; + my $notice = next_optional_argument(); + if (!$notice) { + $notice = 'note'; + } + my $label = $NoticeNames{$notice}; + return ("<div class=\"$notice\"><b class=\"label\">$label</b>\n" + . $_ + . '</div>'); +} + +sub do_cmd_moreargs{ + return '...' . $_[0]; } +sub do_cmd_unspecified{ + return '...' . $_[0]; } + + +sub do_cmd_refmodule{ + # Insert the right magic to jump to the module definition. + local($_) = @_; + my $key = next_optional_argument(); + my $module = next_argument(); + $key = $module + unless $key; + return "<tt class=\"module\"><a href=\"module-$key.html\">$module</a></tt>" + . $_; +} + +sub do_cmd_newsgroup{ + local($_) = @_; + my $newsgroup = next_argument(); + my $icon = get_link_icon("news:$newsgroup"); + my $stuff = ("<a class=\"newsgroup\" href=\"news:$newsgroup\">" + . "$newsgroup$icon</a>"); + return $stuff . $_; +} + +sub do_cmd_envvar{ + local($_) = @_; + my $envvar = next_argument(); + my($name, $aname, $ahref) = new_link_info(); + # The <tt> here is really to keep buildindex.py from making + # the variable name case-insensitive. + add_index_entry("environment variables!$envvar@<tt>$envvar</tt>", + $ahref); + add_index_entry("$envvar (environment variable)", $ahref); + $aname =~ s/<a/<a class="envvar"/; + return "$aname$envvar</a>" . $_; +} + +sub do_cmd_url{ + # use the URL as both text and hyperlink + local($_) = @_; + my $url = next_argument(); + my $icon = get_link_icon($url); + $url =~ s/~/~/g; + return "<a class=\"url\" href=\"$url\">$url$icon</a>" . $_; +} + +sub do_cmd_manpage{ + # two parameters: \manpage{name}{section} + local($_) = @_; + my $page = next_argument(); + my $section = next_argument(); + return "<span class=\"manpage\"><i>$page</i>($section)</span>" . $_; +} + +$PEP_FORMAT = "http://www.python.org/peps/pep-%04d.html"; +#$RFC_FORMAT = "http://www.ietf.org/rfc/rfc%04d.txt"; +$RFC_FORMAT = "http://www.faqs.org/rfcs/rfc%d.html"; + +sub get_rfc_url($$){ + my($rfcnum, $format) = @_; + return sprintf($format, $rfcnum); +} + +sub do_cmd_pep{ + local($_) = @_; + my $rfcnumber = next_argument(); + my $id = "rfcref-" . ++$global{'max_id'}; + my $href = get_rfc_url($rfcnumber, $PEP_FORMAT); + my $icon = get_link_icon($href); + # Save the reference + my $nstr = gen_index_id("Python Enhancement Proposals!PEP $rfcnumber", ''); + $index{$nstr} .= make_half_href("$CURRENT_FILE#$id"); + return ("<a class=\"rfc\" id='$id' xml:id='$id'\n" + . "href=\"$href\">PEP $rfcnumber$icon</a>" . $_); +} + +sub do_cmd_rfc{ + local($_) = @_; + my $rfcnumber = next_argument(); + my $id = "rfcref-" . ++$global{'max_id'}; + my $href = get_rfc_url($rfcnumber, $RFC_FORMAT); + my $icon = get_link_icon($href); + # Save the reference + my $nstr = gen_index_id("RFC!RFC $rfcnumber", ''); + $index{$nstr} .= make_half_href("$CURRENT_FILE#$id"); + return ("<a class=\"rfc\" id='$id' xml:id='$id'\nhref=\"$href\">" + . "RFC $rfcnumber$icon</a>" . $_); +} + +sub do_cmd_ulink{ + local($_) = @_; + my $text = next_argument(); + my $url = next_argument(); + return "<a class=\"ulink\" href=\"$url\"\n >$text</a>" . $_; +} + +sub do_cmd_citetitle{ + local($_) = @_; + my $url = next_optional_argument(); + my $title = next_argument(); + my $icon = get_link_icon($url); + my $repl = ''; + if ($url) { + my $titletext = strip_html_markup("$title"); + $repl = ("<em class=\"citetitle\"><a\n" + . " href=\"$url\"\n" + . " title=\"$titletext\"\n" + . " >$title$icon</a></em>"); + } + else { + $repl = "<em class=\"citetitle\"\n >$title</em>"; + } + return $repl . $_; +} + +sub do_cmd_deprecated{ + # two parameters: \deprecated{version}{whattodo} + local($_) = @_; + my $release = next_argument(); + my $reason = next_argument(); + return ('<div class="versionnote">' + . "<b>Deprecated since release $release.</b>" + . "\n$reason</div><p></p>" + . $_); +} + +sub versionnote($$){ + # one or two parameters: \versionnote[explanation]{version} + my $type = $_[0]; + local $_ = $_[1]; + my $explanation = next_optional_argument(); + my $release = next_argument(); + my $text = "$type in version $release."; + if ($explanation) { + $text = "$type in version $release:\n$explanation."; + } + return "\n<span class=\"versionnote\">$text</span>\n" . $_; +} + +sub do_cmd_versionadded{ + return versionnote('New', $_[0]); +} + +sub do_cmd_versionchanged{ + return versionnote('Changed', $_[0]); +} + +# +# These function handle platform dependency tracking. +# +sub do_cmd_platform{ + local($_) = @_; + my $platform = next_argument(); + $ModulePlatforms{"<tt class=\"module\">$THIS_MODULE</tt>"} = $platform; + $platform = "Macintosh" + if $platform eq 'Mac'; + return "\n<p class=\"availability\">Availability: <span" + . "\n class=\"platform\">$platform</span>.</p>\n" . $_; +} + +$IGNORE_PLATFORM_ANNOTATION = ''; +sub do_cmd_ignorePlatformAnnotation{ + local($_) = @_; + $IGNORE_PLATFORM_ANNOTATION = next_argument(); + return $_; +} + + +# index commands + +$INDEX_SUBITEM = ""; + +sub get_indexsubitem(){ + return $INDEX_SUBITEM ? " $INDEX_SUBITEM" : ''; +} + +sub do_cmd_setindexsubitem{ + local($_) = @_; + $INDEX_SUBITEM = next_argument(); + return $_; +} + +sub do_cmd_withsubitem{ + # We can't really do the right thing, because LaTeX2HTML doesn't + # do things in the right order, but we need to at least strip this stuff + # out, and leave anything that the second argument expanded out to. + # + local($_) = @_; + my $oldsubitem = $INDEX_SUBITEM; + $INDEX_SUBITEM = next_argument(); + my $stuff = next_argument(); + my $br_id = ++$globals{'max_id'}; + my $marker = "$O$br_id$C"; + $stuff =~ s/^\s+//; + return + $stuff + . "\\setindexsubitem$marker$oldsubitem$marker" + . $_; +} + +# This is the prologue macro which is required to start writing the +# mod\jobname.idx file; we can just ignore it. (Defining this suppresses +# a warning that \makemodindex is unknown.) +# +sub do_cmd_makemodindex{ return $_[0]; } + +# We're in the document subdirectory when this happens! +# +open(IDXFILE, '>index.dat') || die "\n$!\n"; +open(INTLABELS, '>intlabels.pl') || die "\n$!\n"; +print INTLABELS "%internal_labels = ();\n"; +print INTLABELS "1; # hack in case there are no entries\n\n"; + +# Using \0 for this is bad because we can't use common tools to work with the +# resulting files. Things like grep can be useful with this stuff! +# +$IDXFILE_FIELD_SEP = "\1"; + +sub write_idxfile($$){ + my($ahref, $str) = @_; + print IDXFILE $ahref, $IDXFILE_FIELD_SEP, $str, "\n"; +} + + +sub gen_link($$){ + my($node, $target) = @_; + print INTLABELS "\$internal_labels{\"$target\"} = \"/$node\";\n"; + return "<a href=\"$node#$target\">"; +} + +sub add_index_entry($$){ + # add an entry to the index structures; ignore the return value + my($str, $ahref) = @_; + $str = gen_index_id($str, ''); + $index{$str} .= $ahref; + write_idxfile($ahref, $str); +} + +sub new_link_name_info(){ + my $name = "l2h-" . ++$globals{'max_id'}; + my $ahref = gen_link($CURRENT_FILE, $name); + return ($name, $ahref); +} + +sub new_link_info(){ + my($name, $ahref) = new_link_name_info(); + my $aname = "<a id='$name' xml:id='$name'>"; + return ($name, $aname, $ahref); +} + +$IndexMacroPattern = ''; +sub define_indexing_macro(@){ + my $count = @_; + my $i = 0; + for (; $i < $count; ++$i) { + my $name = $_[$i]; + my $cmd = "idx_cmd_$name"; + die "\nNo function $cmd() defined!\n" + if (!defined &$cmd); + eval ("sub do_cmd_$name { return process_index_macros(" + . "\$_[0], '$name'); }"); + if (length($IndexMacroPattern) == 0) { + $IndexMacroPattern = "$name"; + } + else { + $IndexMacroPattern .= "|$name"; + } + } +} + +$DEBUG_INDEXING = 0; +sub process_index_macros($$){ + local($_) = @_; + my $cmdname = $_[1]; # This is what triggered us in the first place; + # we know it's real, so just process it. + my($name, $aname, $ahref) = new_link_info(); + my $cmd = "idx_cmd_$cmdname"; + print "\nIndexing: \\$cmdname" + if $DEBUG_INDEXING; + &$cmd($ahref); # modifies $_ and adds index entries + while (/^[\s\n]*\\($IndexMacroPattern)</) { + $cmdname = "$1"; + print " \\$cmdname" + if $DEBUG_INDEXING; + $cmd = "idx_cmd_$cmdname"; + if (!defined &$cmd) { + last; + } + else { + s/^[\s\n]*\\$cmdname//; + &$cmd($ahref); + } + } +# XXX I don't remember why I added this to begin with. +# if (/^[ \t\r\n]/) { +# $_ = substr($_, 1); +# } + return "$aname$anchor_invisible_mark</a>" . $_; +} + +define_indexing_macro('index'); +sub idx_cmd_index($){ + my $str = next_argument(); + add_index_entry("$str", $_[0]); +} + +define_indexing_macro('kwindex'); +sub idx_cmd_kwindex($){ + my $str = next_argument(); + add_index_entry("<tt>$str</tt>!keyword", $_[0]); + add_index_entry("keyword!<tt>$str</tt>", $_[0]); +} + +define_indexing_macro('indexii'); +sub idx_cmd_indexii($){ + my $str1 = next_argument(); + my $str2 = next_argument(); + add_index_entry("$str1!$str2", $_[0]); + add_index_entry("$str2!$str1", $_[0]); +} + +define_indexing_macro('indexiii'); +sub idx_cmd_indexiii($){ + my $str1 = next_argument(); + my $str2 = next_argument(); + my $str3 = next_argument(); + add_index_entry("$str1!$str2 $str3", $_[0]); + add_index_entry("$str2!$str3, $str1", $_[0]); + add_index_entry("$str3!$str1 $str2", $_[0]); +} + +define_indexing_macro('indexiv'); +sub idx_cmd_indexiv($){ + my $str1 = next_argument(); + my $str2 = next_argument(); + my $str3 = next_argument(); + my $str4 = next_argument(); + add_index_entry("$str1!$str2 $str3 $str4", $_[0]); + add_index_entry("$str2!$str3 $str4, $str1", $_[0]); + add_index_entry("$str3!$str4, $str1 $str2", $_[0]); + add_index_entry("$str4!$str1 $str2 $str3", $_[0]); +} + +define_indexing_macro('ttindex'); +sub idx_cmd_ttindex($){ + my $str = codetext(next_argument()); + my $entry = $str . get_indexsubitem(); + add_index_entry($entry, $_[0]); +} + +sub my_typed_index_helper($$){ + my($word, $ahref) = @_; + my $str = next_argument(); + add_index_entry("$str $word", $ahref); + add_index_entry("$word!$str", $ahref); +} + +define_indexing_macro('stindex', 'opindex', 'exindex', 'obindex'); +sub idx_cmd_stindex($){ my_typed_index_helper('statement', $_[0]); } +sub idx_cmd_opindex($){ my_typed_index_helper('operator', $_[0]); } +sub idx_cmd_exindex($){ my_typed_index_helper('exception', $_[0]); } +sub idx_cmd_obindex($){ my_typed_index_helper('object', $_[0]); } + +define_indexing_macro('bifuncindex'); +sub idx_cmd_bifuncindex($){ + my $str = next_argument(); + add_index_entry("<tt class=\"function\">$str()</tt> (built-in function)", + $_[0]); +} + + +sub make_mod_index_entry($$){ + my($str, $define) = @_; + my($name, $aname, $ahref) = new_link_info(); + # equivalent of add_index_entry() using $define instead of '' + $ahref =~ s/\#[-_a-zA-Z0-9]*\"/\"/ + if ($define eq 'DEF'); + $str = gen_index_id($str, $define); + $index{$str} .= $ahref; + write_idxfile($ahref, $str); + + if ($define eq 'DEF') { + # add to the module index + $str =~ /(<tt.*<\/tt>)/; + my $nstr = $1; + $Modules{$nstr} .= $ahref; + } + return "$aname$anchor_invisible_mark2</a>"; +} + + +$THIS_MODULE = ''; +$THIS_CLASS = ''; + +sub define_module($$){ + my($word, $name) = @_; + my $section_tag = join('', @curr_sec_id); + if ($word ne "built-in" && $word ne "extension" + && $word ne "standard" && $word ne "") { + write_warnings("Bad module type '$word'" + . " for \\declaremodule (module $name)"); + $word = ""; + } + $word = "$word " if $word; + $THIS_MODULE = "$name"; + $INDEX_SUBITEM = "(in module $name)"; + print "[$name]"; + return make_mod_index_entry( + "<tt class=\"module\">$name</tt> (${word}module)", 'DEF'); +} + +sub my_module_index_helper($$){ + local($word, $_) = @_; + my $name = next_argument(); + return define_module($word, $name) . $_; +} + +sub do_cmd_modindex{ return my_module_index_helper('', $_[0]); } +sub do_cmd_bimodindex{ return my_module_index_helper('built-in', $_[0]); } +sub do_cmd_exmodindex{ return my_module_index_helper('extension', $_[0]); } +sub do_cmd_stmodindex{ return my_module_index_helper('standard', $_[0]); } +# local($_) = @_; +# my $name = next_argument(); +# return define_module('standard', $name) . $_; +# } + +sub ref_module_index_helper($$){ + my($word, $ahref) = @_; + my $str = next_argument(); + $word = "$word " if $word; + $str = "<tt class=\"module\">$str</tt> (${word}module)"; + # can't use add_index_entry() since the 2nd arg to gen_index_id() is used; + # just inline it all here + $str = gen_index_id($str, 'REF'); + $index{$str} .= $ahref; + write_idxfile($ahref, $str); +} + +# these should be adjusted a bit.... +define_indexing_macro('refmodindex', 'refbimodindex', + 'refexmodindex', 'refstmodindex'); +sub idx_cmd_refmodindex($){ + return ref_module_index_helper('', $_[0]); } +sub idx_cmd_refbimodindex($){ + return ref_module_index_helper('built-in', $_[0]); } +sub idx_cmd_refexmodindex($){ + return ref_module_index_helper('extension', $_[0]);} +sub idx_cmd_refstmodindex($){ + return ref_module_index_helper('standard', $_[0]); } + +sub do_cmd_nodename{ return do_cmd_label($_[0]); } + +sub init_myformat(){ + # This depends on the override of text_cleanup() in l2hinit.perl; + # if that function cleans out empty tags, the first three of these + # variables must be set to comments. + # + # Thanks to Dave Kuhlman for figuring why some named anchors were + # being lost. + $anchor_invisible_mark = ''; + $anchor_invisible_mark2 = ''; + $anchor_mark = ''; + $icons{'anchor_mark'} = ''; +} +init_myformat(); + +# Create an index entry, but include the string in the target anchor +# instead of the dummy filler. +# +sub make_str_index_entry($){ + my $str = $_[0]; + my($name, $ahref) = new_link_name_info(); + add_index_entry($str, $ahref); + if ($str =~ /^<[a-z]+\b/) { + my $s = "$str"; + $s =~ s/^<([a-z]+)\b/<$1 id='$name' xml:id='$name'/; + return $s; + } + else { + return "<a id='$name' xml:id='$name'>$str</a>"; + } +} + + +%TokenToTargetMapping = (); # language:token -> link target +%DefinedGrammars = (); # language -> full grammar text +%BackpatchGrammarFiles = (); # file -> 1 (hash of files to fixup) + +sub do_cmd_token{ + local($_) = @_; + my $token = next_argument(); + my $target = $TokenToTargetMapping{"$CURRENT_GRAMMAR:$token"}; + if ($token eq $CURRENT_TOKEN || $CURRENT_GRAMMAR eq '*') { + # recursive definition or display-only productionlist + return "$token"; + } + if ($target eq '') { + $target = "<pyGrammarToken><$CURRENT_GRAMMAR><$token>"; + if (! $BackpatchGrammarFiles{"$CURRENT_FILE"}) { + print "Adding '$CURRENT_FILE' to back-patch list.\n"; + } + $BackpatchGrammarFiles{"$CURRENT_FILE"} = 1; + } + return "<a class='grammartoken' href=\"$target\">$token</a>" . $_; +} + +sub do_cmd_grammartoken{ + return do_cmd_token(@_); +} + +sub do_env_productionlist{ + local($_) = @_; + my $lang = next_optional_argument(); + my $filename = "grammar-$lang.txt"; + if ($lang eq '') { + $filename = 'grammar.txt'; + } + local($CURRENT_GRAMMAR) = $lang; + $DefinedGrammars{$lang} .= $_; + return ("<dl><dd class=\"grammar\">\n" + . "<div class=\"productions\">\n" + . "<table>\n" + . translate_commands(translate_environments($_)) + . "</table>\n" + . "</div>\n" + . (($lang eq '*') + ? '' + : ("<a class=\"grammar-footer\"\n" + . " href=\"$filename\" type=\"text/plain\"\n" + . " >Download entire grammar as text.</a>\n")) + . "</dd></dl>"); +} + +sub do_cmd_production{ + local($_) = @_; + my $token = next_argument(); + my $defn = next_argument(); + my $lang = $CURRENT_GRAMMAR; + local($CURRENT_TOKEN) = $token; + if ($lang eq '*') { + return ("<tr>\n" + . " <td>$token</td>\n" + . " <td>::=</td>\n" + . " <td>" + . translate_commands($defn) + . "</td></tr>" + . $_); + } + my $target; + if ($lang eq '') { + $target = "$CURRENT_FILE\#tok-$token"; + } + else { + $target = "$CURRENT_FILE\#tok-$lang-$token"; + } + $TokenToTargetMapping{"$CURRENT_GRAMMAR:$token"} = $target; + return ("<tr>\n" + . " <td><a id='tok-$token' xml:id='tok-$token'>" + . "$token</a></td>\n" + . " <td>::=</td>\n" + . " <td>" + . translate_commands($defn) + . "</td></tr>" + . $_); +} + +sub do_cmd_productioncont{ + local($_) = @_; + my $defn = next_argument(); + $defn =~ s/^( +)/' ' x length $1/e; + return ("<tr>\n" + . " <td></td>\n" + . " <td></td>\n" + . " <td><code>" + . translate_commands($defn) + . "</code></td></tr>" + . $_); +} + +sub process_grammar_files(){ + my $lang; + my $filename; + local($_); + print "process_grammar_files()\n"; + foreach $lang (keys %DefinedGrammars) { + $filename = "grammar-$lang.txt"; + if ($lang eq '*') { + next; + } + if ($lang eq '') { + $filename = 'grammar.txt'; + } + open(GRAMMAR, ">$filename") || die "\n$!\n"; + print GRAMMAR strip_grammar_markup($DefinedGrammars{$lang}); + close(GRAMMAR); + print "Wrote grammar file $filename\n"; + } + my $PATTERN = '<pyGrammarToken><([^>]*)><([^>]*)>'; + foreach $filename (keys %BackpatchGrammarFiles) { + print "\nBack-patching grammar links in $filename\n"; + my $buffer; + open(GRAMMAR, "<$filename") || die "\n$!\n"; + # read all of the file into the buffer + sysread(GRAMMAR, $buffer, 1024*1024); + close(GRAMMAR); + while ($buffer =~ /$PATTERN/) { + my($lang, $token) = ($1, $2); + my $target = $TokenToTargetMapping{"$lang:$token"}; + my $source = "<pyGrammarToken><$lang><$token>"; + $buffer =~ s/$source/$target/g; + } + open(GRAMMAR, ">$filename") || die "\n$!\n"; + print GRAMMAR $buffer; + close(GRAMMAR); + } +} + +sub strip_grammar_markup($){ + local($_) = @_; + s/\\productioncont/ /g; + s/\\production(<<\d+>>)(.+)\1/\n$2 ::= /g; + s/\\token(<<\d+>>)(.+)\1/$2/g; + s/\\e([^a-zA-Z])/\\$1/g; + s/<<\d+>>//g; + s/;SPMgt;/>/g; + s/;SPMlt;/</g; + s/;SPMquot;/\"/g; + return $_; +} + + +$REFCOUNTS_LOADED = 0; + +sub load_refcounts(){ + $REFCOUNTS_LOADED = 1; + + my($myname, $mydir, $myext) = fileparse(__FILE__, '\..*'); + chop $mydir; # remove trailing '/' + ($myname, $mydir, $myext) = fileparse($mydir, '\..*'); + chop $mydir; # remove trailing '/' + $mydir = getcwd() . "$dd$mydir" + unless $mydir =~ s|^/|/|; + local $_; + my $filename = "$mydir${dd}api${dd}refcounts.dat"; + open(REFCOUNT_FILE, "<$filename") || die "\n$!\n"; + print "[loading API refcount data]"; + while (<REFCOUNT_FILE>) { + if (/([a-zA-Z0-9_]+):PyObject\*:([a-zA-Z0-9_]*):(0|[-+]1|null):(.*)$/) { + my($func, $param, $count, $comment) = ($1, $2, $3, $4); + #print "\n$func($param) --> $count"; + $REFCOUNTS{"$func:$param"} = $count; + } + } +} + +sub get_refcount($$){ + my($func, $param) = @_; + load_refcounts() + unless $REFCOUNTS_LOADED; + return $REFCOUNTS{"$func:$param"}; +} + + +$TLSTART = '<span class="typelabel">'; +$TLEND = '</span> '; + +sub cfuncline_helper($$$){ + my($type, $name, $args) = @_; + my $idx = make_str_index_entry( + "<tt class=\"cfunction\">$name()</tt>" . get_indexsubitem()); + $idx =~ s/ \(.*\)//; + $idx =~ s/\(\)//; # ???? - why both of these? + $args =~ s/(\s|\*)([a-z_][a-z_0-9]*),/$1<var>$2<\/var>,/g; + $args =~ s/(\s|\*)([a-z_][a-z_0-9]*)$/$1<var>$2<\/var>/s; + return ('<table cellpadding="0" cellspacing="0"><tr valign="baseline">' + . "<td><nobr>$type\ <b>$idx</b>(</nobr></td>" + . "<td>$args)</td>" + . '</tr></table>'); +} +sub do_cmd_cfuncline{ + local($_) = @_; + my $type = next_argument(); + my $name = next_argument(); + my $args = next_argument(); + my $siginfo = cfuncline_helper($type, $name, $args); + return "<dt>$siginfo\n<dd>" . $_; +} +sub do_env_cfuncdesc{ + local($_) = @_; + my $type = next_argument(); + my $name = next_argument(); + my $args = next_argument(); + my $siginfo = cfuncline_helper($type, $name, $args); + my $result_rc = get_refcount($name, ''); + my $rcinfo = ''; + if ($result_rc eq '+1') { + $rcinfo = 'New reference'; + } + elsif ($result_rc eq '0') { + $rcinfo = 'Borrowed reference'; + } + elsif ($result_rc eq 'null') { + $rcinfo = 'Always <tt class="constant">NULL</tt>'; + } + if ($rcinfo ne '') { + $rcinfo = ( "\n<div class=\"refcount-info\">" + . "\n <span class=\"label\">Return value:</span>" + . "\n <span class=\"value\">$rcinfo.</span>" + . "\n</div>"); + } + return "<dl><dt>$siginfo</dt>\n<dd>" + . $rcinfo + . $_ + . '</dd></dl>'; +} + +sub do_cmd_cmemberline{ + local($_) = @_; + my $container = next_argument(); + my $type = next_argument(); + my $name = next_argument(); + my $idx = make_str_index_entry("<tt class=\"cmember\">$name</tt>" + . " ($container member)"); + $idx =~ s/ \(.*\)//; + return "<dt>$type <b>$idx</b></dt>\n<dd>" + . $_; +} +sub do_env_cmemberdesc{ + local($_) = @_; + my $container = next_argument(); + my $type = next_argument(); + my $name = next_argument(); + my $idx = make_str_index_entry("<tt class=\"cmember\">$name</tt>" + . " ($container member)"); + $idx =~ s/ \(.*\)//; + return "<dl><dt>$type <b>$idx</b></dt>\n<dd>" + . $_ + . '</dl>'; +} + +sub do_env_csimplemacrodesc{ + local($_) = @_; + my $name = next_argument(); + my $idx = make_str_index_entry("<tt class=\"macro\">$name</tt>"); + return "<dl><dt><b>$idx</b></dt>\n<dd>" + . $_ + . '</dl>' +} + +sub do_env_ctypedesc{ + local($_) = @_; + my $index_name = next_optional_argument(); + my $type_name = next_argument(); + $index_name = $type_name + unless $index_name; + my($name, $aname, $ahref) = new_link_info(); + add_index_entry("<tt class=\"ctype\">$index_name</tt> (C type)", $ahref); + return "<dl><dt><b><tt class=\"ctype\">$aname$type_name</a></tt></b></dt>" + . "\n<dd>" + . $_ + . '</dl>' +} + +sub do_env_cvardesc{ + local($_) = @_; + my $var_type = next_argument(); + my $var_name = next_argument(); + my $idx = make_str_index_entry("<tt class=\"cdata\">$var_name</tt>" + . get_indexsubitem()); + $idx =~ s/ \(.*\)//; + return "<dl><dt>$var_type <b>$idx</b></dt>\n" + . '<dd>' + . $_ + . '</dd></dl>'; +} + +sub convert_args($){ + local($IN_DESC_HANDLER) = 1; + local($_) = @_; + return translate_commands($_); +} + +sub funcline_helper($$$){ + my($first, $idxitem, $arglist) = @_; + return (($first ? '<dl>' : '') + . '<dt><table cellpadding="0" cellspacing="0"><tr valign="baseline">' + . "\n <td><nobr><b>$idxitem</b>(</nobr></td>" + . "\n <td><var>$arglist</var>)</td></tr></table></dt>\n<dd>"); +} + +sub do_env_funcdesc{ + local($_) = @_; + my $function_name = next_argument(); + my $arg_list = convert_args(next_argument()); + my $idx = make_str_index_entry("<tt class=\"function\">$function_name()" + . '</tt>' + . get_indexsubitem()); + $idx =~ s/ \(.*\)//; + $idx =~ s/\(\)<\/tt>/<\/tt>/; + return funcline_helper(1, $idx, $arg_list) . $_ . '</dl>'; +} + +sub do_env_funcdescni{ + local($_) = @_; + my $function_name = next_argument(); + my $arg_list = convert_args(next_argument()); + my $prefix = "<tt class=\"function\">$function_name</tt>"; + return funcline_helper(1, $prefix, $arg_list) . $_ . '</dl>'; +} + +sub do_cmd_funcline{ + local($_) = @_; + my $function_name = next_argument(); + my $arg_list = convert_args(next_argument()); + my $prefix = "<tt class=\"function\">$function_name()</tt>"; + my $idx = make_str_index_entry($prefix . get_indexsubitem()); + $prefix =~ s/\(\)//; + + return funcline_helper(0, $prefix, $arg_list) . $_; +} + +sub do_cmd_funclineni{ + local($_) = @_; + my $function_name = next_argument(); + my $arg_list = convert_args(next_argument()); + my $prefix = "<tt class=\"function\">$function_name</tt>"; + + return funcline_helper(0, $prefix, $arg_list) . $_; +} + +# Change this flag to index the opcode entries. I don't think it's very +# useful to index them, since they're only presented to describe the dis +# module. +# +$INDEX_OPCODES = 0; + +sub do_env_opcodedesc{ + local($_) = @_; + my $opcode_name = next_argument(); + my $arg_list = next_argument(); + my $idx; + if ($INDEX_OPCODES) { + $idx = make_str_index_entry("<tt class=\"opcode\">$opcode_name</tt>" + . ' (byte code instruction)'); + $idx =~ s/ \(byte code instruction\)//; + } + else { + $idx = "<tt class=\"opcode\">$opcode_name</tt>"; + } + my $stuff = "<dl><dt><b>$idx</b>"; + if ($arg_list) { + $stuff .= " <var>$arg_list</var>"; + } + return $stuff . "</dt>\n<dd>" . $_ . '</dt></dl>'; +} + +sub do_env_datadesc{ + local($_) = @_; + my $dataname = next_argument(); + my $idx = make_str_index_entry("<tt>$dataname</tt>" . get_indexsubitem()); + $idx =~ s/ \(.*\)//; + return "<dl><dt><b>$idx</b></dt>\n<dd>" + . $_ + . '</dd></dl>'; +} + +sub do_env_datadescni{ + local($_) = @_; + my $idx = next_argument(); + if (! $STRING_INDEX_TT) { + $idx = "<tt>$idx</tt>"; + } + return "<dl><dt><b>$idx</b></dt>\n<dd>" . $_ . '</dd></dl>'; +} + +sub do_cmd_dataline{ + local($_) = @_; + my $data_name = next_argument(); + my $idx = make_str_index_entry("<tt>$data_name</tt>" . get_indexsubitem()); + $idx =~ s/ \(.*\)//; + return "<dt><b>$idx</b></dt><dd>" . $_; +} + +sub do_cmd_datalineni{ + local($_) = @_; + my $data_name = next_argument(); + return "<dt><b><tt>$data_name</tt></b></dt><dd>" . $_; +} + +sub do_env_excdesc{ + local($_) = @_; + my $excname = next_argument(); + my $idx = make_str_index_entry("<tt class=\"exception\">$excname</tt>"); + return ("<dl><dt><b>${TLSTART}exception$TLEND$idx</b></dt>" + . "\n<dd>" + . $_ + . '</dd></dl>'); +} + +sub do_env_fulllineitems{ return do_env_itemize(@_); } + + +sub handle_classlike_descriptor($$){ + local($_, $what) = @_; + $THIS_CLASS = next_argument(); + my $arg_list = convert_args(next_argument()); + $idx = make_str_index_entry( + "<tt class=\"$what\">$THIS_CLASS</tt> ($what in $THIS_MODULE)" ); + $idx =~ s/ \(.*\)//; + my $prefix = "$TLSTART$what$TLEND$idx"; + return funcline_helper(1, $prefix, $arg_list) . $_ . '</dl>'; +} + +sub do_env_classdesc{ + return handle_classlike_descriptor($_[0], "class"); +} + +sub do_env_classdescstar{ + local($_) = @_; + $THIS_CLASS = next_argument(); + $idx = make_str_index_entry( + "<tt class=\"class\">$THIS_CLASS</tt> (class in $THIS_MODULE)"); + $idx =~ s/ \(.*\)//; + my $prefix = "${TLSTART}class$TLEND$idx"; + # Can't use funcline_helper() since there is no args list. + return "<dl><dt><b>$prefix</b>\n<dd>" . $_ . '</dl>'; +} + +sub do_env_excclassdesc{ + return handle_classlike_descriptor($_[0], "exception"); +} + + +sub do_env_methoddesc{ + local($_) = @_; + my $class_name = next_optional_argument(); + $class_name = $THIS_CLASS + unless $class_name; + my $method = next_argument(); + my $arg_list = convert_args(next_argument()); + my $extra = ''; + if ($class_name) { + $extra = " ($class_name method)"; + } + my $idx = make_str_index_entry( + "<tt class=\"method\">$method()</tt>$extra"); + $idx =~ s/ \(.*\)//; + $idx =~ s/\(\)//; + return funcline_helper(1, $idx, $arg_list) . $_ . '</dl>'; +} + + +sub do_cmd_methodline{ + local($_) = @_; + my $class_name = next_optional_argument(); + $class_name = $THIS_CLASS + unless $class_name; + my $method = next_argument(); + my $arg_list = convert_args(next_argument()); + my $extra = ''; + if ($class_name) { + $extra = " ($class_name method)"; + } + my $idx = make_str_index_entry( + "<tt class=\"method\">$method()</tt>$extra"); + $idx =~ s/ \(.*\)//; + $idx =~ s/\(\)//; + return funcline_helper(0, $idx, $arg_list) . $_; +} + + +sub do_cmd_methodlineni{ + local($_) = @_; + next_optional_argument(); + my $method = next_argument(); + my $arg_list = convert_args(next_argument()); + return funcline_helper(0, $method, $arg_list) . $_; +} + +sub do_env_methoddescni{ + local($_) = @_; + next_optional_argument(); + my $method = next_argument(); + my $arg_list = convert_args(next_argument()); + return funcline_helper(1, $method, $arg_list) . $_ . '</dl>'; +} + + +sub do_env_memberdesc{ + local($_) = @_; + my $class = next_optional_argument(); + my $member = next_argument(); + $class = $THIS_CLASS + unless $class; + my $extra = ''; + $extra = " ($class attribute)" + if ($class ne ''); + my $idx = make_str_index_entry("<tt class=\"member\">$member</tt>$extra"); + $idx =~ s/ \(.*\)//; + $idx =~ s/\(\)//; + return "<dl><dt><b>$idx</b></dt>\n<dd>" . $_ . '</dl>'; +} + + +sub do_cmd_memberline{ + local($_) = @_; + my $class = next_optional_argument(); + my $member = next_argument(); + $class = $THIS_CLASS + unless $class; + my $extra = ''; + $extra = " ($class attribute)" + if ($class ne ''); + my $idx = make_str_index_entry("<tt class=\"member\">$member</tt>$extra"); + $idx =~ s/ \(.*\)//; + $idx =~ s/\(\)//; + return "<dt><b>$idx</b></dt><dd>" . $_; +} + + +sub do_env_memberdescni{ + local($_) = @_; + next_optional_argument(); + my $member = next_argument(); + return "<dl><dt><b><tt class=\"member\">$member</tt></b></dt>\n<dd>" + . $_ + . '</dd></dl>'; +} + + +sub do_cmd_memberlineni{ + local($_) = @_; + next_optional_argument(); + my $member = next_argument(); + return "<dt><b><tt class=\"member\">$member</tt></b></dt>\n<dd>" . $_; +} + + +# For tables, we include a class on every cell to allow the CSS to set +# the text-align property; this is because support for styling columns +# via the <col> element appears nearly non-existant on even the latest +# browsers (Mozilla 1.7 is stable at the time of this writing). +# Hopefully this can be improved as browsers evolve. + +@col_aligns = ('<td>', '<td>', '<td>', '<td>', '<td>'); + +%FontConversions = ('cdata' => 'tt class="cdata"', + 'character' => 'tt class="character"', + 'class' => 'tt class="class"', + 'command' => 'code', + 'constant' => 'tt class="constant"', + 'exception' => 'tt class="exception"', + 'file' => 'tt class="file"', + 'filenq' => 'tt class="file"', + 'kbd' => 'kbd', + 'member' => 'tt class="member"', + 'programopt' => 'b', + 'textrm' => '', + ); + +sub fix_font($){ + # do a little magic on a font name to get the right behavior in the first + # column of the output table + my $font = $_[0]; + if (defined $FontConversions{$font}) { + $font = $FontConversions{$font}; + } + return $font; +} + +sub figure_column_alignment($){ + my $a = $_[0]; + if (!defined $a) { + return ''; + } + my $mark = substr($a, 0, 1); + my $r = ''; + if ($mark eq 'c') + { $r = ' class="center"'; } + elsif ($mark eq 'r') + { $r = ' class="right" '; } + elsif ($mark eq 'l') + { $r = ' class="left" '; } + elsif ($mark eq 'p') + { $r = ' class="left" '; } + return $r; +} + +sub setup_column_alignments($){ + local($_) = @_; + my($s1, $s2, $s3, $s4, $s5) = split(/[|]/,$_); + my $a1 = figure_column_alignment($s1); + my $a2 = figure_column_alignment($s2); + my $a3 = figure_column_alignment($s3); + my $a4 = figure_column_alignment($s4); + my $a5 = figure_column_alignment($s5); + $col_aligns[0] = "<td$a1 valign=\"baseline\">"; + $col_aligns[1] = "<td$a2>"; + $col_aligns[2] = "<td$a3>"; + $col_aligns[3] = "<td$a4>"; + $col_aligns[4] = "<td$a5>"; + # return the aligned header start tags + return ("<th$a1>", "<th$a2>", "<th$a3>", "<th$a4>", "<th$a5>"); +} + +sub get_table_col1_fonts(){ + my $font = $globals{'lineifont'}; + my($sfont, $efont) = ('', ''); + if ($font) { + $sfont = "<$font>"; + $efont = "</$font>"; + $efont =~ s/ .*>/>/; + } + return ($sfont, $efont); +} + +sub do_env_tableii{ + local($_) = @_; + my $arg = next_argument(); + my($th1, $th2, $th3, $th4, $th5) = setup_column_alignments($arg); + my $font = fix_font(next_argument()); + my $h1 = next_argument(); + my $h2 = next_argument(); + s/[\s\n]+//; + $globals{'lineifont'} = $font; + my $a1 = $col_aligns[0]; + my $a2 = $col_aligns[1]; + s/\\lineii</\\lineii[$a1|$a2]</g; + return '<div class="center"><table class="realtable">' + . "\n <thead>" + . "\n <tr>" + . "\n $th1$h1</th>" + . "\n $th2$h2</th>" + . "\n </tr>" + . "\n </thead>" + . "\n <tbody>" + . $_ + . "\n </tbody>" + . "\n</table></div>"; +} + +sub do_env_longtableii{ + return do_env_tableii(@_); +} + +sub do_cmd_lineii{ + local($_) = @_; + my $aligns = next_optional_argument(); + my $c1 = next_argument(); + my $c2 = next_argument(); + s/[\s\n]+//; + my($sfont, $efont) = get_table_col1_fonts(); + my($c1align, $c2align) = split('\|', $aligns); + return "\n <tr>$c1align$sfont$c1$efont</td>\n" + . " $c2align$c2</td></tr>" + . $_; +} + +sub do_env_tableiii{ + local($_) = @_; + my $arg = next_argument(); + my($th1, $th2, $th3, $th4, $th5) = setup_column_alignments($arg); + my $font = fix_font(next_argument()); + my $h1 = next_argument(); + my $h2 = next_argument(); + my $h3 = next_argument(); + s/[\s\n]+//; + $globals{'lineifont'} = $font; + my $a1 = $col_aligns[0]; + my $a2 = $col_aligns[1]; + my $a3 = $col_aligns[2]; + s/\\lineiii</\\lineiii[$a1|$a2|$a3]</g; + return '<div class="center"><table class="realtable">' + . "\n <thead>" + . "\n <tr>" + . "\n $th1$h1</th>" + . "\n $th2$h2</th>" + . "\n $th3$h3</th>" + . "\n </tr>" + . "\n </thead>" + . "\n <tbody>" + . $_ + . "\n </tbody>" + . "\n</table></div>"; +} + +sub do_env_longtableiii{ + return do_env_tableiii(@_); +} + +sub do_cmd_lineiii{ + local($_) = @_; + my $aligns = next_optional_argument(); + my $c1 = next_argument(); + my $c2 = next_argument(); + my $c3 = next_argument(); + s/[\s\n]+//; + my($sfont, $efont) = get_table_col1_fonts(); + my($c1align, $c2align, $c3align) = split('\|', $aligns); + return "\n <tr>$c1align$sfont$c1$efont</td>\n" + . " $c2align$c2</td>\n" + . " $c3align$c3</td></tr>" + . $_; +} + +sub do_env_tableiv{ + local($_) = @_; + my $arg = next_argument(); + my($th1, $th2, $th3, $th4, $th5) = setup_column_alignments($arg); + my $font = fix_font(next_argument()); + my $h1 = next_argument(); + my $h2 = next_argument(); + my $h3 = next_argument(); + my $h4 = next_argument(); + s/[\s\n]+//; + $globals{'lineifont'} = $font; + my $a1 = $col_aligns[0]; + my $a2 = $col_aligns[1]; + my $a3 = $col_aligns[2]; + my $a4 = $col_aligns[3]; + s/\\lineiv</\\lineiv[$a1|$a2|$a3|$a4]</g; + return '<div class="center"><table class="realtable">' + . "\n <thead>" + . "\n <tr>" + . "\n $th1$h1</th>" + . "\n $th2$h2</th>" + . "\n $th3$h3</th>" + . "\n $th4$h4</th>" + . "\n </tr>" + . "\n </thead>" + . "\n <tbody>" + . $_ + . "\n </tbody>" + . "\n</table></div>"; +} + +sub do_env_longtableiv{ + return do_env_tableiv(@_); +} + +sub do_cmd_lineiv{ + local($_) = @_; + my $aligns = next_optional_argument(); + my $c1 = next_argument(); + my $c2 = next_argument(); + my $c3 = next_argument(); + my $c4 = next_argument(); + s/[\s\n]+//; + my($sfont, $efont) = get_table_col1_fonts(); + my($c1align, $c2align, $c3align, $c4align) = split('\|', $aligns); + return "\n <tr>$c1align$sfont$c1$efont</td>\n" + . " $c2align$c2</td>\n" + . " $c3align$c3</td>\n" + . " $c4align$c4</td></tr>" + . $_; +} + +sub do_env_tablev{ + local($_) = @_; + my $arg = next_argument(); + my($th1, $th2, $th3, $th4, $th5) = setup_column_alignments($arg); + my $font = fix_font(next_argument()); + my $h1 = next_argument(); + my $h2 = next_argument(); + my $h3 = next_argument(); + my $h4 = next_argument(); + my $h5 = next_argument(); + s/[\s\n]+//; + $globals{'lineifont'} = $font; + my $a1 = $col_aligns[0]; + my $a2 = $col_aligns[1]; + my $a3 = $col_aligns[2]; + my $a4 = $col_aligns[3]; + my $a5 = $col_aligns[4]; + s/\\linev</\\linev[$a1|$a2|$a3|$a4|$a5]</g; + return '<div class="center"><table class="realtable">' + . "\n <thead>" + . "\n <tr>" + . "\n $th1$h1</th>" + . "\n $th2$h2</th>" + . "\n $th3$h3</th>" + . "\n $th4$h4</th>" + . "\n $th5$h5</th>" + . "\n </tr>" + . "\n </thead>" + . "\n <tbody>" + . $_ + . "\n </tbody>" + . "\n</table></div>"; +} + +sub do_env_longtablev{ + return do_env_tablev(@_); +} + +sub do_cmd_linev{ + local($_) = @_; + my $aligns = next_optional_argument(); + my $c1 = next_argument(); + my $c2 = next_argument(); + my $c3 = next_argument(); + my $c4 = next_argument(); + my $c5 = next_argument(); + s/[\s\n]+//; + my($sfont, $efont) = get_table_col1_fonts(); + my($c1align, $c2align, $c3align, $c4align, $c5align) = split('\|',$aligns); + return "\n <tr>$c1align$sfont$c1$efont</td>\n" + . " $c2align$c2</td>\n" + . " $c3align$c3</td>\n" + . " $c4align$c4</td>\n" + . " $c5align$c5</td></tr>" + . $_; +} + + +# These can be used to control the title page appearance; +# they need a little bit of documentation. +# +# If $TITLE_PAGE_GRAPHIC is set, it should be the name of a file in the +# $ICONSERVER directory, or include path information (other than "./"). The +# default image type will be assumed if an extension is not provided. +# +# If specified, the "title page" will contain two colums: one containing the +# title/author/etc., and the other containing the graphic. Use the other +# four variables listed here to control specific details of the layout; all +# are optional. +# +# $TITLE_PAGE_GRAPHIC = "my-company-logo"; +# $TITLE_PAGE_GRAPHIC_COLWIDTH = "30%"; +# $TITLE_PAGE_GRAPHIC_WIDTH = 150; +# $TITLE_PAGE_GRAPHIC_HEIGHT = 150; +# $TITLE_PAGE_GRAPHIC_ON_RIGHT = 0; + +sub make_my_titlepage(){ + my $the_title = ""; + if ($t_title) { + $the_title .= "\n<h1>$t_title</h1>"; + } + else { + write_warnings("\nThis document has no title."); + } + if ($t_author) { + if ($t_authorURL) { + my $href = translate_commands($t_authorURL); + $href = make_named_href('author', $href, + "<b><font size=\"+2\">$t_author" + . '</font></b>'); + $the_title .= "\n<p>$href</p>"; + } + else { + $the_title .= ("\n<p><b><font size=\"+2\">$t_author" + . '</font></b></p>'); + } + } + else { + write_warnings("\nThere is no author for this document."); + } + if ($t_institute) { + $the_title .= "\n<p>$t_institute</p>"; + } + if ($DEVELOPER_ADDRESS) { + $the_title .= "\n<p>$DEVELOPER_ADDRESS</p>"; + } + if ($t_affil) { + $the_title .= "\n<p><i>$t_affil</i></p>"; + } + if ($t_date) { + $the_title .= "\n<p>"; + if ($PACKAGE_VERSION) { + $the_title .= ('<strong>Release ' + . "$PACKAGE_VERSION$RELEASE_INFO</strong><br />\n"); + } + $the_title .= "<strong>$t_date</strong></p>" + } + if ($t_address) { + $the_title .= "\n<p>$t_address</p>"; + } + else { + $the_title .= "\n<p></p>"; + } + if ($t_email) { + $the_title .= "\n<p>$t_email</p>"; + } + return $the_title; +} + +sub make_my_titlegraphic(){ + my $filename = make_icon_filename($TITLE_PAGE_GRAPHIC); + my $graphic = "<td class=\"titlegraphic\""; + $graphic .= " width=\"$TITLE_PAGE_GRAPHIC_COLWIDTH\"" + if ($TITLE_PAGE_GRAPHIC_COLWIDTH); + $graphic .= "><img"; + $graphic .= " width=\"$TITLE_PAGE_GRAPHIC_WIDTH\"" + if ($TITLE_PAGE_GRAPHIC_WIDTH); + $graphic .= " height=\"$TITLE_PAGE_GRAPHIC_HEIGHT\"" + if ($TITLE_PAGE_GRAPHIC_HEIGHT); + $graphic .= "\n src=\"$filename\" /></td>\n"; + return $graphic; +} + +sub do_cmd_maketitle{ + local($_) = @_; + my $the_title = "\n"; + if ($EXTERNAL_UP_LINK) { + # This generates a <link> element in the wrong place (the + # body), but I don't see any other way to get this generated + # at all. Browsers like Mozilla, that support navigation + # links, can make use of this. + $the_title .= ("<link rel='up' href='$EXTERNAL_UP_LINK'" + . ($EXTERNAL_UP_TITLE + ? " title='$EXTERNAL_UP_TITLE'" : '') + . " />\n"); + } + $the_title .= '<div class="titlepage">'; + if ($TITLE_PAGE_GRAPHIC) { + if ($TITLE_PAGE_GRAPHIC_ON_RIGHT) { + $the_title .= ("\n<table border=\"0\" width=\"100%\">" + . "<tr align=\"right\">\n<td>" + . make_my_titlepage() + . "</td>\n" + . make_my_titlegraphic() + . "</tr>\n</table>"); + } + else { + $the_title .= ("\n<table border=\"0\" width=\"100%\"><tr>\n" + . make_my_titlegraphic() + . "<td>" + . make_my_titlepage() + . "</td></tr>\n</table>"); + } + } + else { + $the_title .= ("\n<div class='center'>" + . make_my_titlepage() + . "\n</div>"); + } + $the_title .= "\n</div>"; + return $the_title . $_; +} + + +# +# Module synopsis support +# + +require SynopsisTable; + +sub get_chapter_id(){ + my $id = do_cmd_thechapter(''); + $id =~ s/<SPAN CLASS="arabic">(\d+)<\/SPAN>/$1/; + $id =~ s/\.//; + return $id; +} + +# 'chapter' => 'SynopsisTable instance' +%ModuleSynopses = (); + +sub get_synopsis_table($){ + my $chap = $_[0]; + my $key; + foreach $key (keys %ModuleSynopses) { + if ($key eq $chap) { + return $ModuleSynopses{$chap}; + } + } + my $st = SynopsisTable->new(); + $ModuleSynopses{$chap} = $st; + return $st; +} + +sub do_cmd_moduleauthor{ + local($_) = @_; + next_argument(); + next_argument(); + return $_; +} + +sub do_cmd_sectionauthor{ + local($_) = @_; + next_argument(); + next_argument(); + return $_; +} + +sub do_cmd_declaremodule{ + local($_) = @_; + my $key = next_optional_argument(); + my $type = next_argument(); + my $name = next_argument(); + my $st = get_synopsis_table(get_chapter_id()); + # + $key = $name unless $key; + $type = 'built-in' if $type eq 'builtin'; + $st->declare($name, $key, $type); + define_module($type, $name); + return anchor_label("module-$key",$CURRENT_FILE,$_) +} + +sub do_cmd_modulesynopsis{ + local($_) = @_; + my $st = get_synopsis_table(get_chapter_id()); + $st->set_synopsis($THIS_MODULE, translate_commands(next_argument())); + return $_; +} + +sub do_cmd_localmoduletable{ + local($_) = @_; + my $chap = get_chapter_id(); + my $st = get_synopsis_table($chap); + $st->set_file("$CURRENT_FILE"); + return "<tex2html-localmoduletable><$chap>\\tableofchildlinks[off]" . $_; +} + +sub process_all_localmoduletables(){ + my $key; + foreach $key (keys %ModuleSynopses) { + my $st = $ModuleSynopses{$key}; + my $file = $st->get_file(); + if ($file) { + process_localmoduletables_in_file($file); + } + else { + print "\nsynopsis table $key has no file association\n"; + } + } +} + +sub process_localmoduletables_in_file($){ + my $file = $_[0]; + open(MYFILE, "<$file"); + local($_); + sysread(MYFILE, $_, 1024*1024); + close(MYFILE); + # need to get contents of file in $_ + while (/<tex2html-localmoduletable><(\d+)>/) { + my $match = $&; + my $chap = $1; + my $st = get_synopsis_table($chap); + my $data = $st->tohtml(); + s/$match/$data/; + } + open(MYFILE,">$file"); + print MYFILE $_; + close(MYFILE); +} +sub process_python_state(){ + process_all_localmoduletables(); + process_grammar_files(); +} + + +# +# "See also:" -- references placed at the end of a \section +# + +sub do_env_seealso{ + return ("<div class=\"seealso\">\n " + . "<p class=\"heading\">See Also:</p>\n" + . $_[0] + . '</div>'); +} + +sub do_env_seealsostar{ + return ("<div class=\"seealso-simple\">\n " + . $_[0] + . '</div>'); +} + +sub do_cmd_seemodule{ + # Insert the right magic to jump to the module definition. This should + # work most of the time, at least for repeat builds.... + local($_) = @_; + my $key = next_optional_argument(); + my $module = next_argument(); + my $text = next_argument(); + my $period = '.'; + $key = $module + unless $key; + if ($text =~ /\.$/) { + $period = ''; + } + return ('<dl compact="compact" class="seemodule">' + . "\n <dt>Module <b><tt class=\"module\">" + . "<a href=\"module-$key.html\">$module</a></tt>:</b>" + . "\n <dd>$text$period\n </dl>" + . $_); +} + +sub strip_html_markup($){ + my $str = $_[0]; + my $s = "$str"; + $s =~ s/<[a-zA-Z0-9]+(\s+[a-zA-Z0-9]+(\s*=\s*(\'[^\']*\'|\"[^\"]*\"|[a-zA-Z0-9]+))?)*\s*>//g; + $s =~ s/<\/[a-zA-Z0-9]+>//g; + return $s; +} + +sub handle_rfclike_reference($$$){ + local($_, $what, $format) = @_; + my $rfcnum = next_argument(); + my $title = next_argument(); + my $text = next_argument(); + my $url = get_rfc_url($rfcnum, $format); + my $icon = get_link_icon($url); + my $attrtitle = strip_html_markup($title); + return '<dl compact="compact" class="seerfc">' + . "\n <dt><a href=\"$url\"" + . "\n title=\"$attrtitle\"" + . "\n >$what $rfcnum, <em>$title</em>$icon</a>" + . "\n <dd>$text\n </dl>" + . $_; +} + +sub do_cmd_seepep{ + return handle_rfclike_reference($_[0], "PEP", $PEP_FORMAT); +} + +sub do_cmd_seerfc{ + # XXX Would be nice to add links to the text/plain and PDF versions. + return handle_rfclike_reference($_[0], "RFC", $RFC_FORMAT); +} + +sub do_cmd_seetitle{ + local($_) = @_; + my $url = next_optional_argument(); + my $title = next_argument(); + my $text = next_argument(); + if ($url) { + my $icon = get_link_icon($url); + return '<dl compact="compact" class="seetitle">' + . "\n <dt><em class=\"citetitle\"><a href=\"$url\"" + . "\n >$title$icon</a></em></dt>" + . "\n <dd>$text</dd>\n </dl>" + . $_; + } + return '<dl compact="compact" class="seetitle">' + . "\n <dt><em class=\"citetitle\"" + . "\n >$title</em></dt>" + . "\n <dd>$text</dd>\n </dl>" + . $_; +} + +sub do_cmd_seelink{ + local($_) = @_; + my $url = next_argument(); + my $linktext = next_argument(); + my $text = next_argument(); + my $icon = get_link_icon($url); + return '<dl compact="compact" class="seeurl">' + . "\n <dt><a href='$url'" + . "\n >$linktext$icon</a></dt>" + . "\n <dd>$text</dd>\n </dl>" + . $_; +} + +sub do_cmd_seeurl{ + local($_) = @_; + my $url = next_argument(); + my $text = next_argument(); + my $icon = get_link_icon($url); + return '<dl compact="compact" class="seeurl">' + . "\n <dt><a href=\"$url\"" + . "\n class=\"url\">$url$icon</a></dt>" + . "\n <dd>$text</dd>\n </dl>" + . $_; +} + +sub do_cmd_seetext{ + local($_) = @_; + my $content = next_argument(); + return '<div class="seetext"><p>' . $content . '</p></div>' . $_; +} + + +# +# Definition list support. +# + +sub do_env_definitions{ + return '<dl class="definitions">' . $_[0] . "</dl>\n"; +} + +sub do_cmd_term{ + local($_) = @_; + my $term = next_argument(); + my($name, $aname, $ahref) = new_link_info(); + # could easily add an index entry here... + return "<dt><b>$aname" . $term . "</a></b></dt>\n<dd>" . $_; +} + + +# Commands listed here have process-order dependencies; these often +# are related to indexing operations. +# XXX Not sure why funclineni, methodlineni, and samp are here. +# +process_commands_wrap_deferred(<<_RAW_ARG_DEFERRED_CMDS_); +declaremodule # [] # {} # {} +funcline # {} # {} +funclineni # {} # {} +memberline # [] # {} +methodline # [] # {} # {} +methodlineni # [] # {} # {} +modulesynopsis # {} +bifuncindex # {} +exindex # {} +indexii # {} # {} +indexiii # {} # {} # {} +indexiv # {} # {} # {} # {} +kwindex # {} +obindex # {} +opindex # {} +stindex # {} +platform # {} +samp # {} +setindexsubitem # {} +withsubitem # {} # {} +_RAW_ARG_DEFERRED_CMDS_ + + +$alltt_start = '<div class="verbatim"><pre>'; +$alltt_end = '</pre></div>'; + +sub do_env_alltt{ + local ($_) = @_; + local($closures,$reopens,@open_block_tags); + + # get the tag-strings for all open tags + local(@keep_open_tags) = @$open_tags_R; + ($closures,$reopens) = &preserve_open_tags() if (@$open_tags_R); + + # get the tags for text-level tags only + $open_tags_R = [ @keep_open_tags ]; + local($local_closures, $local_reopens); + ($local_closures, $local_reopens,@open_block_tags) + = &preserve_open_block_tags + if (@$open_tags_R); + + $open_tags_R = [ @open_block_tags ]; + + do { + local($open_tags_R) = [ @open_block_tags ]; + local(@save_open_tags) = (); + + local($cnt) = ++$global{'max_id'}; + $_ = join('',"$O$cnt$C\\tt$O", ++$global{'max_id'}, $C + , $_ , $O, $global{'max_id'}, "$C$O$cnt$C"); + + $_ = &translate_environments($_); + $_ = &translate_commands($_) if (/\\/); + + # remove spurious <BR> someone sticks in; not sure where they + # actually come from + # XXX the replacement space is there to accomodate something + # broken that inserts a space in front of the first line of + # the environment + s/<BR>/ /gi; + + $_ = join('', $closures, $alltt_start, $local_reopens + , $_ + , &balance_tags() #, $local_closures + , $alltt_end, $reopens); + undef $open_tags_R; undef @save_open_tags; + }; + $open_tags_R = [ @keep_open_tags ]; + return codetext($_); +} + +# List of all filenames produced by do_cmd_verbatiminput() +%VerbatimFiles = (); +@VerbatimOutputs = (); + +sub get_verbatim_output_name($){ + my $file = $_[0]; + # + # Re-write the source filename to always use a .txt extension + # so that Web servers will present it as text/plain. This is + # needed since there is no other even moderately reliable way + # to get the right Content-Type header on text files for + # servers which we can't configure (like python.org mirrors). + # + if (defined $VerbatimFiles{$file}) { + # We've seen this one before; re-use the same output file. + return $VerbatimFiles{$file}; + } + my($srcname, $srcdir, $srcext) = fileparse($file, '\..*'); + $filename = "$srcname.txt"; + # + # We need to determine if our default filename is already + # being used, and find a new one it it is. If the name is in + # used, this algorithm will first attempt to include the + # source extension as part of the name, and if that is also in + # use (if the same file is included multiple times, or if + # another source file has that as the base name), a counter is + # used instead. + # + my $found = 1; + FIND: + while ($found) { + foreach $fn (@VerbatimOutputs) { + if ($fn eq $filename) { + if ($found == 1) { + $srcext =~ s/^[.]//; # Remove '.' from extension + $filename = "$srcname-$srcext.txt"; + } + else { + $filename = "$srcname-$found.txt"; + } + ++$found; + next FIND; + } + } + $found = 0; + } + push @VerbatimOutputs, $filename; + $VerbatimFiles{$file} = $filename; + return $filename; +} + +sub do_cmd_verbatiminput{ + local($_) = @_; + my $fname = next_argument(); + my $file; + my $found = 0; + my $texpath; + # Search TEXINPUTS for the input file, the way we're supposed to: + foreach $texpath (split /$envkey/, $TEXINPUTS) { + $file = "$texpath$dd$fname"; + last if ($found = (-f $file)); + } + my $filename = ''; + my $text; + if ($found) { + open(MYFILE, "<$file") || die "\n$!\n"; + read(MYFILE, $text, 1024*1024); + close(MYFILE); + $filename = get_verbatim_output_name($file); + # Now that we have a filename, write it out. + open(MYFILE, ">$filename"); + print MYFILE $text; + close(MYFILE); + # + # These rewrites convert the raw text to something that will + # be properly visible as HTML and also will pass through the + # vagaries of conversion through LaTeX2HTML. The order in + # which the specific rewrites are performed is significant. + # + $text =~ s/\&/\&/g; + # These need to happen before the normal < and > re-writes, + # since we need to avoid LaTeX2HTML's attempt to perform + # ligature processing without regard to context (since it + # doesn't have font information). + $text =~ s/--/-&\#45;/g; + $text =~ s/<</\<\&\#60;/g; + $text =~ s/>>/\>\&\#62;/g; + # Just normal re-writes... + $text =~ s/</\</g; + $text =~ s/>/\>/g; + # These last isn't needed for the HTML, but is needed to get + # past LaTeX2HTML processing TeX macros. We use \ instead + # of / since many browsers don't support that. + $text =~ s/\\/\&\#92;/g; + } + else { + return '<b>Could not locate requested file <i>$fname</i>!</b>\n'; + } + my $note = 'Download as text.'; + if ($file ne $filename) { + $note = ('Download as text (original file name: <span class="file">' + . $fname + . '</span>).'); + } + return ("<div class=\"verbatim\">\n<pre>" + . $text + . "</pre>\n<div class=\"footer\">\n" + . "<a href=\"$filename\" type=\"text/plain\"" + . ">$note</a>" + . "\n</div></div>" + . $_); +} + +1; # This must be the last line |