home *** CD-ROM | disk | FTP | other *** search
/ Nebula 2 / Nebula Two.iso / SourceCode / MiscKit1.7.1 / MiscKit / Examples / AutoDoc / lib / perl5 / Autodoc / DumpDocs.pm next >
Encoding:
Perl POD Document  |  1995-11-02  |  17.5 KB  |  764 lines
  1. package Autodoc::DumpDocs;
  2.  
  3. ###############################################################################
  4. ###############################################################################
  5. ##
  6. ##    Written by Adam Swift (c) 1995 by Friday Software and Consulting
  7. ##                           All rights reserved.
  8. ##
  9. ##      This notice may not be removed from this source code.
  10. ##
  11. ##    This program is included in the MiscKit by permission from the author
  12. ##    and its use is governed by the MiscKit license, found in the file
  13. ##    "LICENSE.rtf" in the MiscKit distribution.  Please refer to that file
  14. ##    for a list of all applicable permissions and restrictions.
  15. ##
  16. ##    Because AutoDoc is licensed free of charge, there is no warranty 
  17. ##    for the program.  Copyright holder, Friday Software and Consulting, 
  18. ##    is providing this program "as is" and this program is distributed in 
  19. ##    the hope that it will be useful, but WITHOUT ANY WARRANTY; without 
  20. ##    even the implied warranty of MERCHANTABILITY or FITNESS FOR A 
  21. ##    PARTICULAR PURPOSE.
  22. ##
  23. ###############################################################################
  24. ###############################################################################
  25.  
  26. require 5.000;
  27. require "flush.pl";
  28.  
  29. ##########################
  30. # load required packages #
  31. ##########################
  32. use Exporter;
  33. use Autodoc::GenerateRTF;
  34. use Autodoc::LogDebug;
  35. use Autodoc::ReadSource;
  36.  
  37. @ISA      = qw(Exporter);
  38. @EXPORT   = qw(dump_documentation
  39.                set_copyrightowner
  40.                copyrightowner
  41.                set_usetimestamp
  42.                usetimestamp
  43.                doc_bold_words
  44.                doc_italic_words
  45.               );
  46.  
  47. $module_version = '$Revision: 1.3 $';
  48. $module_version =~ s!(\$\w+: | \$)!!g;
  49. $module_id        = '$Id: DumpDocs.pm,v 1.3 1995/10/20 22:16:25 aswift Exp $';
  50. $module_id      =~ s!(\$\w+: | \$)!!g;
  51. $module_name    = $module_id;
  52. $module_name    =~ s!^([^\,]+).*$!$1!;
  53.  
  54. ############################################################################
  55. # 
  56. # Purpose: Module that encapsulates the creation of documentation from the
  57. #          source code parsed with autodoc.
  58. #
  59. # HISTORY: START
  60. # $Log: DumpDocs.pm,v $
  61. # Revision 1.3  1995/10/20  22:16:25  aswift
  62. # Added DevMan style changes Log support
  63. #
  64. #
  65. # HISTORY: END
  66. ############################################################################
  67. #
  68. # GLOBAL VARIABLES THAT AFFECT DOCUMENTATION DUMP
  69. #
  70. #  $format_italicwords  The array of words to italicize in &format_paragraph
  71. #  $dump_rtf            If the documentation should produce RTF formatted docs.
  72. #
  73. #############################################################################
  74.  
  75.  
  76. #############################################################################
  77. #
  78. # NAME:       module_version
  79. #
  80. # ACTION:     returns the version number of this module
  81. #
  82. # RETURN:     the module version
  83. #
  84. #############################################################################
  85. sub module_version
  86. {
  87.     return $module_version;
  88. }
  89.  
  90. sub module_versionstamp
  91. {
  92.     return "$module_name (rev-$module_version)";
  93. }
  94.  
  95. #############################################################################
  96. #
  97. # Module variable access 
  98. #
  99. #############################################################################
  100. sub set_copyrightowner
  101. {
  102.     $copyrightowner = $_[0];
  103. }
  104.  
  105. sub copyrightowner
  106. {
  107.     return $copyrightowner 
  108.       if (defined($copyrightowner));
  109.     return "";
  110. }
  111.  
  112. sub set_usetimestamp
  113. {
  114.     $usetimestamp = $_[0];
  115. }
  116.  
  117. sub usetimestamp
  118. {
  119.     return $usetimestamp 
  120.       if (defined($usetimestamp)); 
  121.     return 0;
  122. }
  123.  
  124. sub doc_italic_words
  125.   {
  126.     return @format_italicwords
  127.       if (defined (@format_italicwords));
  128.     return ();
  129.   }
  130.  
  131. sub doc_bold_words
  132.   {
  133.     return ("self", "nil", "super", "id", "NULL");
  134.   }
  135.  
  136.  
  137. ###############################################################################
  138. #
  139. # DOCUMENTATION DUMPING TO OBJECT RTF FILE
  140. #
  141. #    Use the information scanned into the global object variables to create
  142. #  a Rich Text Formatted documentation file, in the directory specified by
  143. #  $dest_dir.
  144. #
  145.  
  146. #
  147. # Locate and write the documentation file for the object passed as the one
  148. # argument to this subroutine. 
  149. #
  150. sub dump_documentation
  151.   {
  152.     local ($obj_root, $obj_r, $opt_silent) = @_;
  153.     
  154.     $dump_rtf = 1;
  155.     
  156.     dblog (0, "Writing documentation for:\t$obj_root");
  157.     dblog (1, "Writing documentation to file: $obj_r");
  158.     
  159.     # open the documentation file
  160.     if (!open(DUMPFILE, ">$obj_r")) {
  161.       warn ("Can't open $obj_r: $!\n");
  162.       return 0;
  163.     } else {
  164.       if (!$opt_silent) {
  165.         print ("autodoc producing $obj_r ... ");
  166.         flush (STDOUT);
  167.       }
  168.     }
  169.     
  170.     # Header    
  171.     dump_header();
  172.     
  173.     # Body
  174.     dump_copyrightinfo();
  175.     dump_objectname();
  176.     dump_inheritsfrom_declaredin();
  177.     dump_classdescription()
  178.       if (!object_noobjectdefined());
  179.     dump_typedefs();
  180.     dump_defines();
  181.     dump_macros();
  182.     dump_functions();
  183.     dump_globals();
  184.     dump_instancevariables();
  185.     dump_methodtypes();
  186.     
  187.     dump_methods(1, object_classmethods())
  188.       if (object_classmethods());
  189.     dump_methods(0, object_instmethods())
  190.       if (object_instmethods());
  191.     
  192.     # Footer
  193.     dump_footer();    
  194.     
  195.     # close the docuentation file and message the user
  196.     close (DUMPFILE);
  197.     if (!$opt_silent) {
  198.       print ("done\n");
  199.     }
  200.     return 1;
  201. }                
  202.  
  203.  
  204. #
  205. # Dump the instance (or class) methods with full formatting, setup the 
  206. # format_italicwords so that the method documentaiton italicizes the 
  207. # arguments to the method.
  208. #
  209. sub dump_methods
  210.   {
  211.     local ($class_meth) = shift (@_);
  212.     local (@o_methods) = @_;
  213.     local ($index, $meth, $methname);
  214.     
  215.     if ($class_meth) {
  216.       dump_majorheading ("Class Methods");
  217.     } else {
  218.       dump_majorheading ("Instance Methods");
  219.     }
  220.  
  221.     @o_methods = sort bymethodname @o_methods;
  222.     
  223.     for ($index = 0; $index < @o_methods; $index ++) {
  224.       if ($dump_rtf) {
  225.         dump_line (rtf_newline_small(3))
  226.           if ($index);
  227.       }
  228.       $meth = $o_methods[$index];
  229.       if ($class_meth) {
  230.         $methname = "+";
  231.       } else {
  232.         $methname = "-";
  233.       }
  234.       $methname .= extract_methodname ($meth);
  235.       dump_method ($meth, $methname);
  236.     }
  237.   }
  238.  
  239.  
  240. #
  241. # dump a formatted method with documentation
  242. #
  243. sub dump_method
  244.   {
  245.     local ($meth, $methname, $methname_raw, $methtype, $f_method, $i_words);
  246.     local (%o_methoddocs);
  247.     
  248.     $meth          = $_[0];        # the full method declaration 
  249.     $methname      = $_[1];        # the abbrv. unique name
  250.     $methname      =~ m/^([\+\-])/;
  251.     $methname_raw = $';            # methname_raw is methname w/o + or -
  252.     $meth          = $1 . $meth;    # prepend the + or - onto the method name
  253.     
  254.     if ($dump_rtf) {
  255.       # write the raw methodname (no args or type info)
  256.       dump_paragraph(rtf_setfont_helvetica() . rtf_boldify($methname_raw));
  257.  
  258.       ($f_method, $i_words) = rtf_format_method ($meth);
  259.  
  260.       # write the formatted method with args and type info
  261.       dump_line (rtf_setfont_times() . rtf_newline_micro());
  262.       dump_methodline ($f_method);
  263.     }
  264.  
  265.     # set up the italic words for dumping the description documentation 
  266.     if ($i_words) {
  267.       @format_italicwords = split (" ", $i_words);
  268.     } else {
  269.       @format_italicwords = ();
  270.     }
  271.  
  272.     # dump the method documentation
  273.     %o_methoddocs = object_methoddocs();
  274.     if (defined($o_methoddocs{$methname}) && 
  275.         $o_methoddocs{$methname} ne "") {
  276.       
  277.       dump_paragraph ($o_methoddocs{$methname});
  278.     } else {
  279.       dump_paragraph ("No method description.");
  280.     }
  281.     @format_italicwords = ();
  282.   }
  283.  
  284.  
  285. #
  286. # Dump the formatted method names with block names before the methods they
  287. # were assigned to.
  288. #
  289. sub dump_methodtypes
  290.   {
  291.     local ($index);
  292.     local ($methname, $methname_raw, $methtype, $block);
  293.     local (@o_methodnames, %o_methodblocks);
  294.     
  295.     @o_methodnames = object_methodnames();
  296.     return 
  297.       if (scalar(@o_methodnames) == 0);
  298.     %o_methodblocks = object_methodblocks();
  299.     
  300.     dump_majorheading ("Method Types");
  301.     dump_keyvalue();
  302.  
  303.     for ($index=0; $index < @o_methodnames; $index++) {
  304.       $methname = $o_methodnames[$index];
  305.       
  306.       # If there is a method block assigned to this method
  307.       if (($block = $o_methodblocks{$methname})) {
  308.         dump_line (rtf_newline_small())
  309.           if ($dump_rtf && $index > 0);
  310.         dump_string ("$block");
  311.         
  312.         # long block names push methods to the next line
  313.         if (length($block) > 30) {
  314.           dump_string (rtf_newline());
  315.         } 
  316.       } 
  317.       $methname_raw = $methname;
  318.       $methname_raw =~ s/^([\+\-])//;
  319.       $methtype = $1;
  320.  
  321.       if ($dump_rtf) {
  322.         if ($methtype eq "-") {
  323.           dump_line ("\t" . rtf_emdash . " $methname_raw" . rtf_newline());
  324.         } else {
  325.           dump_line ("\t+ $methname_raw" . rtf_newline());
  326.         }
  327.       }
  328.     }
  329.   }
  330.  
  331.  
  332. sub dump_defines
  333.   {
  334.     local ($title, @names, %docs, %values, $fmt_expr);
  335.     
  336.     $title      = "Symbolic Constants";
  337.     @names      = object_defines();
  338.     %docs      = object_definedocs();
  339.     %values      = object_definevals();
  340.     $fmt_expr = 's!(.*)!\\\b $1\\\b0!'
  341.       if ($dump_rtf);
  342.     dump_synopsis_description (*title, *names, *docs, *values, $fmt_expr);
  343.   }
  344.  
  345.  
  346. sub dump_macros
  347.   {
  348.     local ($title, @names, %docs, %values, $fmt_expr);
  349.     
  350.     $title       = "Macro Definitions";
  351.     @names       = object_macros();
  352.     %docs       = object_macrodocs();
  353.     %values       = {};
  354.     $fmt_expr = 's!(\\S+\\s*\\()([^\\(]*)\\)$!\\\b $1\\\b0$2\\\b \)\\\b0!'
  355.       if ($dump_rtf);
  356.     dump_synopsis_description (*title, *names, *docs, *values, $fmt_expr);
  357.   }
  358.  
  359.  
  360. sub dump_functions
  361.   {
  362.     local ($title, @names, %docs, %values, $fmt_expr);
  363.     
  364.     $title       = "Functions";
  365.     @names       = object_functions();
  366.     %docs       = object_functiondocs();
  367.     %values       = {};
  368.     $fmt_expr = 's!(\\S+\\s*\\()([^\\(]*)\\)$!\\\b $1\\\b0$2\\\b \)\\\b0!'
  369.       if ($dump_rtf);
  370.     dump_synopsis_description (*title, *names, *docs, *values, $fmt_expr);
  371.   }
  372.  
  373.  
  374. sub dump_globals
  375.   {
  376.     local ($title, @names, %docs, %values, $fmt_expr);
  377.     
  378.     $title      = "Global Variables";
  379.     @names      = object_globals();
  380.     %docs      = object_globaldocs();
  381.     %values      = {};
  382.     $fmt_expr = 's!(\\S+)\\;$!\\\b $1\\\b0\\;!'
  383.       if ($dump_rtf);
  384.     dump_synopsis_description (*title, *names, *docs, *values, $fmt_expr);
  385.   }
  386.  
  387.  
  388. sub dump_typedefs
  389.   {
  390.     local ($title, @names, %docs, %values, $fmt_expr);
  391.     
  392.     $title      = "Defined Types";
  393.     @names      = object_typedefs();
  394.     %docs      = object_typedefdocs();
  395.     %values      = object_typedefvals();
  396.     $fmt_expr = 's!(.*)!\\\b $1\\\b0!'
  397.       if ($dump_rtf);
  398.     dump_synopsis_description (*title, *names, *docs, *values, $fmt_expr);
  399.   }
  400.  
  401.  
  402. sub dump_synopsis_description
  403.   {
  404.     local (*title, *names, *docs, *values) = @_;
  405.     local ($docs, $value, $show_synopsis, $name_expr);
  406.     local ($i, $max, $name);
  407.  
  408.     return 
  409.       if (!scalar(@names));
  410.  
  411.     # check for the special 4th argument - the executable formatting string
  412.     $name_expr = ""
  413.       if ((scalar(@_) < 5) || (($name_expr = $_[4]) eq ""));
  414.     
  415.     dump_majorheading($title);
  416.     
  417.     $show_synopsis = 1;
  418.     $show_docs       = 0;
  419.     $docs           = "";
  420.     $max           = scalar (@names);
  421.     
  422.     for ($i = 0; $i < $max; $i++) {
  423.       $name = $names[$i];
  424.       
  425.       if (defined($values{$name})) {
  426.         local ($valline, @valarray, $indent);
  427.  
  428.         $value = "$values{$name}";
  429.  
  430.         # reformat special characters to preserve them in the output
  431.         if ($dump_rtf) {
  432.           $value =~ s!([\{\}])!\\$1!g;
  433.           $value =~ s!\n!\\\n\t!g;
  434.  
  435.           $value = " $value "; # add extra spaces to help matching
  436.           $value =~ s!(\W)$name(\W)!$1\\b $name\\b0$2!;
  437.           $value =~ s!^ | $!!g; # remove the extra spaces
  438.  
  439.           # do some fancy indentation on the value (if curlies are there)
  440.           if ($value =~ m!\{!) {
  441.             $indent = "";
  442.             @valarray = split(m!\n!, $value);
  443.  
  444.             # for each line in the value, add indents to the approriate level
  445.             foreach $valline (@valarray) {
  446.               $indent =~ s!\t!!
  447.                 if ($valline =~ m!\}!);
  448.               $valline = "$indent$valline"
  449.                 if ($indent =~ m!\t!);
  450.               
  451.               if ($valline =~ m!\{!) {
  452.                 $indent = "\t$indent";
  453.                 $valline =~ s!\{\s*(\S+)!\{$indent$1!;
  454.               }
  455.             }
  456.             $value = join("\n", @valarray);
  457.           }
  458.         }          
  459.       } else {
  460.         $value = "";
  461.       }
  462.       
  463.       if ($show_synopsis) {
  464.         dump_minorheading("SYNOPSIS");
  465.         dump_synopsis();
  466.         $show_synopsis = 0;
  467.       }
  468.       if ($name_expr ne "") {
  469.         local ($fname) = $name;
  470.         # dblog(-5, "expr = $name_expr");
  471.         eval ("\$fname =~ $name_expr");
  472.         warn ("Error formatting names: $@")
  473.           if ($@ ne "");
  474.         dump_line ("$fname\t$value" . rtf_newline())
  475.           if ($dump_rtf);
  476.       } else {
  477.         dump_line ("$name\t$value" . rtf_newline())
  478.           if ($dump_rtf);
  479.       }
  480.       
  481.       $show_docs = 1
  482.         if (($i == ($max - 1)) || defined($docs{$names[$i+1]}));
  483.       $docs = "$docs{$name}"
  484.         if (defined($docs{$name}));
  485.       
  486.       if (($docs ne "") && ($show_docs == 1)) {
  487.         dump_line (rtf_newline_small())
  488.           if ($dump_rtf);
  489.         dump_minorheading("DESCRIPTION");
  490.         dump_paragraph ($docs);
  491.         dump_line (rtf_newline_small(2))
  492.           if ($dump_rtf && ($i != ($max - 1)));
  493.         $show_docs = 0;
  494.         $show_synopsis = 1;
  495.       }
  496.     }
  497.   }
  498.  
  499.  
  500. #
  501. # Dump the instance variables and their descriptions to the documentation file
  502. # descriptions are formatted by format_words
  503. #
  504. sub dump_instancevariables
  505.   {
  506.     my ($ivar, $lastivar, $docs);
  507.     my (@o_ivars, %o_ivartypes, %o_ivardocs);
  508.     my ($ivar_out) = "";
  509.     
  510.     @o_ivars = object_ivars();
  511.     return 
  512.       if (scalar(@o_ivars) == 0);
  513.     
  514.     %o_ivartypes = object_ivartypes();
  515.     %o_ivardocs  = object_ivardocs();
  516.     
  517.     dump_majorheading ("Instance Variables");
  518.  
  519.     # output ivar type list
  520.     if ($dump_rtf) {
  521.       foreach $ivar (@o_ivars) {
  522.         $ivar_out .= $o_ivartypes{$ivar} . rtf_boldify($ivar) . ";";
  523.         $ivar_out .= rtf_newline();
  524.       }
  525.       dump_paragraph ($ivar_out);
  526.  
  527.       # output ivar description list
  528.       dump_line (rtf_newline_small(2));
  529.       $lastivar = $o_ivars[$#o_ivars];
  530.       foreach $ivar (@o_ivars) {
  531.         $docs = rtf_format_words ($o_ivardocs{$ivar});
  532.         dump_keyvalue ("$ivar\t$docs");
  533.         dump_line (rtf_newline_small())
  534.           if ($ivar ne $lastivar);
  535.       }
  536.     }
  537.   }
  538.  
  539.  
  540. #
  541. # Dump the formatted class description to the docs.  Boldify any instance
  542. # variables or methods that appear in the description
  543. #
  544. sub dump_classdescription
  545.   {
  546.     # Problem here may be that both an obj and category are defined
  547.     # in the same .m file.  Maybe figuring out how to dump two
  548.     # seperate .rtf files would be optimal, but until then we should
  549.     # allow for both to be included in the same .m and thus .rtf.
  550.     dump_majorheading ("Class Description") 
  551.       if (object_inherits());
  552.     dump_majorheading ("Protocol Description")
  553.       if (object_protocol());
  554.     dump_majorheading ("Category Description") 
  555.       if (object_category());
  556.  
  557.     dump_paragraph (object_classdocs());
  558.   }
  559.  
  560. #
  561. # dump the formatting and text necessary to put the inheritance and
  562. # declaration location in the docs
  563. # This has been expanded to allow categories...
  564. #
  565. sub dump_inheritsfrom_declaredin
  566.   {
  567.     my ($o_name) = object_name();
  568.     my ($o_inh)     = object_inherits();
  569.     my ($o_cat)     = object_category();
  570.     my ($o_decl) = object_declaredin();
  571.     my (@o_conf) = object_conformsto();
  572.     
  573.     if (object_noobjectdefined()) {
  574.       dump_subtitle ("Resource Collection");
  575.     } else {
  576.       if ($o_inh) {
  577.         if ($o_inh =~ m!^none$!) {
  578.           $o_inh .= rtf_italicize(" ($o_name is a root class)")
  579.             if ($dump_rtf);
  580.         }
  581.         dump_subtitle ("Inherits From:", $o_inh);
  582.       } else {
  583.         dump_subtitle ("Category Name:", $o_cat)
  584.           if ($o_cat);
  585.       }
  586.       
  587.       dump_subtitle ("Conforms To:", @o_conf)
  588.         if (scalar (@o_conf) > 0);
  589.     }
  590.     dump_subtitle ("Declared In:", $o_decl);
  591.   }
  592.  
  593.  
  594. #
  595. # dump the formatting and text necessary to put the copyright info in the docs
  596. #
  597. sub dump_copyrightinfo
  598.   {
  599.     my ($head)          = "";
  600.     my ($timestamp)      = "";
  601.     my ($copyright)      = "";
  602.     my ($bycopyowner) = "";
  603.     my ($o_version)      = "";
  604.  
  605.     $timestamp = scalar (localtime (time ()))
  606.       if (usetimestamp());
  607.     $bycopyowner .= " by " . copyrightowner()
  608.       if (copyrightowner());
  609.     $o_version = object_version() . " "
  610.       if (object_version());
  611.  
  612.     if ($dump_rtf) {
  613.       $copyright = rtf_copyright() . " ";
  614.       $timestamp = rtf_italicize($timestamp);
  615.     }
  616.     
  617.     $head = $o_version . "Copyright " . $copyright . object_year();
  618.     $head .= $bycopyowner . " All Rights Reserved.  " . $timestamp;
  619.  
  620.     if ($dump_rtf) {
  621.       dump_line (rtf_head($head));
  622.     }
  623.   }
  624.  
  625.  
  626. #
  627. # Compares the methods passed in $a and $b for alphabetical sorting, ignoring
  628. # the typecasting
  629. #
  630. sub bymethodname
  631.   {
  632.     local ($one, $two);
  633.     if ($a =~/^\([^\)]+\)\s*/) {
  634.       $one = $';
  635.     } else {
  636.       $one = $a;
  637.     }
  638.     if ($b =~/^\([^\)]+\)\s*/) {
  639.       $two = $';
  640.     } else {
  641.       $two = $b;
  642.     }
  643.     return $one cmp $two;
  644.   }
  645.  
  646.  
  647. #
  648. # Write out all the arguments to the DUMPFILE and finish it off with a newline
  649. #
  650. sub dump_line
  651.   {
  652.     local ($buffer);
  653.     foreach $buffer (@_) {
  654.       print DUMPFILE ("$buffer");
  655.     }
  656.     print DUMPFILE ("\n");
  657.   }
  658.  
  659.  
  660. #
  661. # Write out all the arguments to the DUMPFILE 
  662. #
  663. sub dump_string
  664.   {
  665.     local ($buffer);
  666.     foreach $buffer (@_) {
  667.       print DUMPFILE ("$buffer");
  668.     }
  669.   }
  670.  
  671.  
  672. #
  673. # Dump the standard spacer to the docs
  674. #
  675. sub dump_spacer
  676.   {
  677.     if ($dump_rtf) {
  678.       dump_line (rtf_spacer());
  679.     }
  680.   }
  681.  
  682.  
  683. #
  684. # Write the file header, to start the documentation file.
  685. #
  686. sub dump_header
  687.   {
  688.     if ($dump_rtf) {
  689.       dump_line (rtf_fileheader());
  690.       dump_line (rtf_fonttable());
  691.       dump_line (rtf_stylesheet());
  692.     }
  693.   }
  694.  
  695. #
  696. # Write the file footer, to terminate the documentation file
  697. #
  698. sub dump_footer
  699.   {
  700.     if ($dump_rtf) {
  701.       dump_line (rtf_filefooter());
  702.     }
  703.   }
  704.  
  705.  
  706. #
  707. # dump the formatting and text necessary to put the object name in the docs
  708. #
  709. sub dump_objectname
  710.   {
  711.     dump_line (rtf_title (object_name()))
  712.       if ($dump_rtf);
  713.   }
  714.  
  715.  
  716. sub dump_majorheading
  717.   {
  718.     dump_line (rtf_majorheading (@_))
  719.       if ($dump_rtf);
  720.   }
  721.  
  722.  
  723. sub dump_minorheading
  724.   {
  725.     dump_line (rtf_minorheading (@_))
  726.       if ($dump_rtf);
  727.   }
  728.  
  729.  
  730. sub dump_subtitle
  731.   {
  732.     dump_line (rtf_subtitle (@_))
  733.       if ($dump_rtf);
  734.   }
  735.  
  736.  
  737. sub dump_paragraph
  738.   {
  739.     dump_line (rtf_paragraph (@_))
  740.       if ($dump_rtf);
  741.   }
  742.  
  743.  
  744. sub dump_synopsis
  745.   {
  746.     dump_line (rtf_synopsis (@_))
  747.       if ($dump_rtf);
  748.   }
  749.  
  750. sub dump_keyvalue
  751.   {
  752.     dump_line (rtf_keyvalue (@_))
  753.       if ($dump_rtf);
  754.   }
  755.  
  756. sub dump_methodline
  757.   {
  758.     dump_line (rtf_methodline (@_))
  759.       if ($dump_rtf);
  760.   }
  761.  
  762.  
  763. 1;
  764.