release/src-rt-6.x/linux/linux-2.6/scripts/kernel-doc

   1 #!/usr/bin/perl -w
   2
   3 use strict;
   4
   5 ## Copyright (c) 1998 Michael Zucchi, All Rights Reserved        ##
   6 ## Copyright (C) 2000, 1  Tim Waugh <twaugh@redhat.com>          ##
   7 ## Copyright (C) 2001  Simon Huggins                             ##
   8 ##                                                               ##
   9 ## #define enhancements by Armin Kuster <akuster@mvista.com>     ##
  10 ## Copyright (c) 2000 MontaVista Software, Inc.                  ##
  11 ##                                                               ##
  12 ## This software falls under the GNU General Public License.     ##
  13 ## Please read the COPYING file for more information             ##
  14
  15 # w.o. 03-11-2000: added the '-filelist' option.
  16
  17 # 18/01/2001 -  Cleanups
  18 #               Functions prototyped as foo(void) same as foo()
  19 #               Stop eval'ing where we don't need to.
  20 # -- huggie@earth.li
  21
  22 # 27/06/2001 -  Allowed whitespace after initial "/**" and
  23 #               allowed comments before function declarations.
  24 # -- Christian Kreibich <ck@whoop.org>
  25
  26 # Still to do:
  27 #       - add perldoc documentation
  28 #       - Look more closely at some of the scarier bits :)
  29
  30 # 26/05/2001 -  Support for separate source and object trees.
  31 #               Return error code.
  32 #               Keith Owens <kaos@ocs.com.au>
  33
  34 # 23/09/2001 - Added support for typedefs, structs, enums and unions
  35 #              Support for Context section; can be terminated using empty line
  36 #              Small fixes (like spaces vs. \s in regex)
  37 # -- Tim Jansen <tim@tjansen.de>
  38
  39
  40 #
  41 # This will read a 'c' file and scan for embedded comments in the
  42 # style of gnome comments (+minor extensions - see below).
  43 #
  44
  45 # Note: This only supports 'c'.
  46
  47 # usage:
  48 # kernel-doc [ -docbook | -html | -text | -man ]
  49 #           [ -function funcname [ -function funcname ...] ] c file(s)s > outputfile
  50 # or
  51 #           [ -nofunction funcname [ -function funcname ...] ] c file(s)s > outputfile
  52 #
  53 #  Set output format using one of -docbook -html -text or -man.  Default is man.
  54 #
  55 #  -function funcname
  56 #       If set, then only generate documentation for the given function(s).  All
  57 #       other functions are ignored.
  58 #
  59 #  -nofunction funcname
  60 #       If set, then only generate documentation for the other function(s).
  61 #       Cannot be used together with -function
  62 #       (yes, that's a bug -- perl hackers can fix it 8))
  63 #
  64 #  c files - list of 'c' files to process
  65 #
  66 #  All output goes to stdout, with errors to stderr.
  67
  68 #
  69 # format of comments.
  70 # In the following table, (...)? signifies optional structure.
  71 #                         (...)* signifies 0 or more structure elements
  72 # /**
  73 #  * function_name(:)? (- short description)?
  74 # (* @parameterx: (description of parameter x)?)*
  75 # (* a blank line)?
  76 #  * (Description:)? (Description of function)?
  77 #  * (section header: (section description)? )*
  78 #  (*)?*/
  79 #
  80 # So .. the trivial example would be:
  81 #
  82 # /**
  83 #  * my_function
  84 #  **/
  85 #
  86 # If the Description: header tag is omitted, then there must be a blank line
  87 # after the last parameter specification.
  88 # e.g.
  89 # /**
  90 #  * my_function - does my stuff
  91 #  * @my_arg: its mine damnit
  92 #  *
  93 #  * Does my stuff explained.
  94 #  */
  95 #
  96 #  or, could also use:
  97 # /**
  98 #  * my_function - does my stuff
  99 #  * @my_arg: its mine damnit
 100 #  * Description: Does my stuff explained.
 101 #  */
 102 # etc.
 103 #
 104 # Beside functions you can also write documentation for structs, unions,
 105 # enums and typedefs. Instead of the function name you must write the name
 106 # of the declaration;  the struct/union/enum/typedef must always precede
 107 # the name. Nesting of declarations is not supported.
 108 # Use the argument mechanism to document members or constants.
 109 # e.g.
 110 # /**
 111 #  * struct my_struct - short description
 112 #  * @a: first member
 113 #  * @b: second member
 114 #  *
 115 #  * Longer description
 116 #  */
 117 # struct my_struct {
 118 #     int a;
 119 #     int b;
 120 # /* private: */
 121 #     int c;
 122 # };
 123 #
 124 # All descriptions can be multiline, except the short function description.
 125 #
 126 # You can also add additional sections. When documenting kernel functions you
 127 # should document the "Context:" of the function, e.g. whether the functions
 128 # can be called form interrupts. Unlike other sections you can end it with an
 129 # empty line.
 130 # Example-sections should contain the string EXAMPLE so that they are marked
 131 # appropriately in DocBook.
 132 #
 133 # Example:
 134 # /**
 135 #  * user_function - function that can only be called in user context
 136 #  * @a: some argument
 137 #  * Context: !in_interrupt()
 138 #  *
 139 #  * Some description
 140 #  * Example:
 141 #  *    user_function(22);
 142 #  */
 143 # ...
 144 #
 145 #
 146 # All descriptive text is further processed, scanning for the following special
 147 # patterns, which are highlighted appropriately.
 148 #
 149 # 'funcname()' - function
 150 # '$ENVVAR' - environmental variable
 151 # '&struct_name' - name of a structure (up to two words including 'struct')
 152 # '@parameter' - name of a parameter
 153 # '%CONST' - name of a constant.
 154
 155 my $errors = 0;
 156 my $warnings = 0;
 157
 158 # match expressions used to find embedded type information
 159 my $type_constant = '\%([-_\w]+)';
 160 my $type_func = '(\w+)\(\)';
 161 my $type_param = '\@(\w+)';
 162 my $type_struct = '\&((struct\s*)*[_\w]+)';
 163 my $type_struct_xml = '\\\amp;((struct\s*)*[_\w]+)';
 164 my $type_env = '(\$\w+)';
 165
 166 # Output conversion substitutions.
 167 #  One for each output format
 168
 169 # these work fairly well
 170 my %highlights_html = ( $type_constant, "<i>\$1</i>",
 171                         $type_func, "<b>\$1</b>",
 172                         $type_struct_xml, "<i>\$1</i>",
 173                         $type_env, "<b><i>\$1</i></b>",
 174                         $type_param, "<tt><b>\$1</b></tt>" );
 175 my $blankline_html = "<p>";
 176
 177 # XML, docbook format
 178 my %highlights_xml = ( "([^=])\\\"([^\\\"<]+)\\\"", "\$1<quote>\$2</quote>",
 179                         $type_constant, "<constant>\$1</constant>",
 180                         $type_func, "<function>\$1</function>",
 181                         $type_struct, "<structname>\$1</structname>",
 182                         $type_env, "<envar>\$1</envar>",
 183                         $type_param, "<parameter>\$1</parameter>" );
 184 my $blankline_xml = "</para><para>\n";
 185
 186 # gnome, docbook format
 187 my %highlights_gnome = ( $type_constant, "<replaceable class=\"option\">\$1</replaceable>",
 188                          $type_func, "<function>\$1</function>",
 189                          $type_struct, "<structname>\$1</structname>",
 190                          $type_env, "<envar>\$1</envar>",
 191                          $type_param, "<parameter>\$1</parameter>" );
 192 my $blankline_gnome = "</para><para>\n";
 193
 194 # these are pretty rough
 195 my %highlights_man = ( $type_constant, "\$1",
 196                        $type_func, "\\\\fB\$1\\\\fP",
 197                        $type_struct, "\\\\fI\$1\\\\fP",
 198                        $type_param, "\\\\fI\$1\\\\fP" );
 199 my $blankline_man = "";
 200
 201 # text-mode
 202 my %highlights_text = ( $type_constant, "\$1",
 203                         $type_func, "\$1",
 204                         $type_struct, "\$1",
 205                         $type_param, "\$1" );
 206 my $blankline_text = "";
 207
 208
 209 sub usage {
 210     print "Usage: $0 [ -v ] [ -docbook | -html | -text | -man ]\n";
 211     print "         [ -function funcname [ -function funcname ...] ]\n";
 212     print "         [ -nofunction funcname [ -nofunction funcname ...] ]\n";
 213     print "         c source file(s) > outputfile\n";
 214     exit 1;
 215 }
 216
 217 # read arguments
 218 if ($#ARGV==-1) {
 219     usage();
 220 }
 221
 222 my $verbose = 0;
 223 my $output_mode = "man";
 224 my %highlights = %highlights_man;
 225 my $blankline = $blankline_man;
 226 my $modulename = "Kernel API";
 227 my $function_only = 0;
 228 my $man_date = ('January', 'February', 'March', 'April', 'May', 'June',
 229                 'July', 'August', 'September', 'October',
 230                 'November', 'December')[(localtime)[4]] .
 231   " " . ((localtime)[5]+1900);
 232
 233 # Essentially these are globals
 234 # They probably want to be tidied up made more localised or summat.
 235 # CAVEAT EMPTOR!  Some of the others I localised may not want to be which
 236 # could cause "use of undefined value" or other bugs.
 237 my ($function, %function_table,%parametertypes,$declaration_purpose);
 238 my ($type,$declaration_name,$return_type);
 239 my ($newsection,$newcontents,$prototype,$filelist, $brcount, %source_map);
 240
 241 # Generated docbook code is inserted in a template at a point where
 242 # docbook v3.1 requires a non-zero sequence of RefEntry's; see:
 243 # http://www.oasis-open.org/docbook/documentation/reference/html/refentry.html
 244 # We keep track of number of generated entries and generate a dummy
 245 # if needs be to ensure the expanded template can be postprocessed
 246 # into html.
 247 my $section_counter = 0;
 248
 249 my $lineprefix="";
 250
 251 # states
 252 # 0 - normal code
 253 # 1 - looking for function name
 254 # 2 - scanning field start.
 255 # 3 - scanning prototype.
 256 # 4 - documentation block
 257 my $state;
 258 my $in_doc_sect;
 259
 260 #declaration types: can be
 261 # 'function', 'struct', 'union', 'enum', 'typedef'
 262 my $decl_type;
 263
 264 my $doc_special = "\@\%\$\&";
 265
 266 my $doc_start = '^/\*\*\s*$'; # Allow whitespace at end of comment start.
 267 my $doc_end = '\*/';
 268 my $doc_com = '\s*\*\s*';
 269 my $doc_decl = $doc_com.'(\w+)';
 270 my $doc_sect = $doc_com.'(['.$doc_special.']?[\w\s]+):(.*)';
 271 my $doc_content = $doc_com.'(.*)';
 272 my $doc_block = $doc_com.'DOC:\s*(.*)?';
 273
 274 my %constants;
 275 my %parameterdescs;
 276 my @parameterlist;
 277 my %sections;
 278 my @sectionlist;
 279
 280 my $contents = "";
 281 my $section_default = "Description";    # default section
 282 my $section_intro = "Introduction";
 283 my $section = $section_default;
 284 my $section_context = "Context";
 285
 286 my $undescribed = "-- undescribed --";
 287
 288 reset_state();
 289
 290 while ($ARGV[0] =~ m/^-(.*)/) {
 291     my $cmd = shift @ARGV;
 292     if ($cmd eq "-html") {
 293         $output_mode = "html";
 294         %highlights = %highlights_html;
 295         $blankline = $blankline_html;
 296     } elsif ($cmd eq "-man") {
 297         $output_mode = "man";
 298         %highlights = %highlights_man;
 299         $blankline = $blankline_man;
 300     } elsif ($cmd eq "-text") {
 301         $output_mode = "text";
 302         %highlights = %highlights_text;
 303         $blankline = $blankline_text;
 304     } elsif ($cmd eq "-docbook") {
 305         $output_mode = "xml";
 306         %highlights = %highlights_xml;
 307         $blankline = $blankline_xml;
 308     } elsif ($cmd eq "-gnome") {
 309         $output_mode = "gnome";
 310         %highlights = %highlights_gnome;
 311         $blankline = $blankline_gnome;
 312     } elsif ($cmd eq "-module") { # not needed for XML, inherits from calling document
 313         $modulename = shift @ARGV;
 314     } elsif ($cmd eq "-function") { # to only output specific functions
 315         $function_only = 1;
 316         $function = shift @ARGV;
 317         $function_table{$function} = 1;
 318     } elsif ($cmd eq "-nofunction") { # to only output specific functions
 319         $function_only = 2;
 320         $function = shift @ARGV;
 321         $function_table{$function} = 1;
 322     } elsif ($cmd eq "-v") {
 323         $verbose = 1;
 324     } elsif (($cmd eq "-h") || ($cmd eq "--help")) {
 325         usage();
 326     } elsif ($cmd eq '-filelist') {
 327             $filelist = shift @ARGV;
 328     }
 329 }
 330
 331 # get kernel version from env
 332 sub get_kernel_version() {
 333     my $version;
 334
 335     if (defined($ENV{'KERNELVERSION'})) {
 336         $version = $ENV{'KERNELVERSION'};
 337     }
 338     return $version;
 339 }
 340 my $kernelversion = get_kernel_version();
 341
 342 # generate a sequence of code that will splice in highlighting information
 343 # using the s// operator.
 344 my $dohighlight = "";
 345 foreach my $pattern (keys %highlights) {
 346 #   print STDERR "scanning pattern:$pattern, highlight:($highlights{$pattern})\n";
 347     $dohighlight .=  "\$contents =~ s:$pattern:$highlights{$pattern}:gs;\n";
 348 }
 349
 350 ##
 351 # dumps section contents to arrays/hashes intended for that purpose.
 352 #
 353 sub dump_section {
 354     my $name = shift;
 355     my $contents = join "\n", @_;
 356
 357     if ($name =~ m/$type_constant/) {
 358         $name = $1;
 359 #       print STDERR "constant section '$1' = '$contents'\n";
 360         $constants{$name} = $contents;
 361     } elsif ($name =~ m/$type_param/) {
 362 #       print STDERR "parameter def '$1' = '$contents'\n";
 363         $name = $1;
 364         $parameterdescs{$name} = $contents;
 365     } else {
 366 #       print STDERR "other section '$name' = '$contents'\n";
 367         $sections{$name} = $contents;
 368         push @sectionlist, $name;
 369     }
 370 }
 371
 372 ##
 373 # output function
 374 #
 375 # parameterdescs, a hash.
 376 #  function => "function name"
 377 #  parameterlist => @list of parameters
 378 #  parameterdescs => %parameter descriptions
 379 #  sectionlist => @list of sections
 380 #  sections => %section descriptions
 381 #
 382
 383 sub output_highlight {
 384     my $contents = join "\n",@_;
 385     my $line;
 386
 387 #   DEBUG
 388 #   if (!defined $contents) {
 389 #       use Carp;
 390 #       confess "output_highlight got called with no args?\n";
 391 #   }
 392
 393 #   print STDERR "contents b4:$contents\n";
 394     eval $dohighlight;
 395     die $@ if $@;
 396     if ($output_mode eq "html") {
 397         $contents =~ s/\\\\//;
 398     }
 399 #   print STDERR "contents af:$contents\n";
 400
 401     foreach $line (split "\n", $contents) {
 402         if ($line eq ""){
 403             print $lineprefix, $blankline;
 404         } else {
 405             $line =~ s/\\\\\\/\&/g;
 406             print $lineprefix, $line;
 407         }
 408         print "\n";
 409     }
 410 }
 411
 412 #output sections in html
 413 sub output_section_html(%) {
 414     my %args = %{$_[0]};
 415     my $section;
 416
 417     foreach $section (@{$args{'sectionlist'}}) {
 418         print "<h3>$section</h3>\n";
 419         print "<blockquote>\n";
 420         output_highlight($args{'sections'}{$section});
 421         print "</blockquote>\n";
 422     }
 423 }
 424
 425 # output enum in html
 426 sub output_enum_html(%) {
 427     my %args = %{$_[0]};
 428     my ($parameter);
 429     my $count;
 430     print "<h2>enum ".$args{'enum'}."</h2>\n";
 431
 432     print "<b>enum ".$args{'enum'}."</b> {<br>\n";
 433     $count = 0;
 434     foreach $parameter (@{$args{'parameterlist'}}) {
 435         print " <b>".$parameter."</b>";
 436         if ($count != $#{$args{'parameterlist'}}) {
 437             $count++;
 438             print ",\n";
 439         }
 440         print "<br>";
 441     }
 442     print "};<br>\n";
 443
 444     print "<h3>Constants</h3>\n";
 445     print "<dl>\n";
 446     foreach $parameter (@{$args{'parameterlist'}}) {
 447         print "<dt><b>".$parameter."</b>\n";
 448         print "<dd>";
 449         output_highlight($args{'parameterdescs'}{$parameter});
 450     }
 451     print "</dl>\n";
 452     output_section_html(@_);
 453     print "<hr>\n";
 454 }
 455
 456 # output typedef in html
 457 sub output_typedef_html(%) {
 458     my %args = %{$_[0]};
 459     my ($parameter);
 460     my $count;
 461     print "<h2>typedef ".$args{'typedef'}."</h2>\n";
 462
 463     print "<b>typedef ".$args{'typedef'}."</b>\n";
 464     output_section_html(@_);
 465     print "<hr>\n";
 466 }
 467
 468 # output struct in html
 469 sub output_struct_html(%) {
 470     my %args = %{$_[0]};
 471     my ($parameter);
 472
 473     print "<h2>".$args{'type'}." ".$args{'struct'}. " - " .$args{'purpose'}."</h2>\n";
 474     print "<b>".$args{'type'}." ".$args{'struct'}."</b> {<br>\n";
 475     foreach $parameter (@{$args{'parameterlist'}}) {
 476         if ($parameter =~ /^#/) {
 477                 print "$parameter<br>\n";
 478                 next;
 479         }
 480         my $parameter_name = $parameter;
 481         $parameter_name =~ s/\[.*//;
 482
 483         ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
 484         $type = $args{'parametertypes'}{$parameter};
 485         if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
 486             # pointer-to-function
 487             print "&nbsp; &nbsp; <i>$1</i><b>$parameter</b>) <i>($2)</i>;<br>\n";
 488         } elsif ($type =~ m/^(.*?)\s*(:.*)/) {
 489             # bitfield
 490             print "&nbsp; &nbsp; <i>$1</i> <b>$parameter</b>$2;<br>\n";
 491         } else {
 492             print "&nbsp; &nbsp; <i>$type</i> <b>$parameter</b>;<br>\n";
 493         }
 494     }
 495     print "};<br>\n";
 496
 497     print "<h3>Members</h3>\n";
 498     print "<dl>\n";
 499     foreach $parameter (@{$args{'parameterlist'}}) {
 500         ($parameter =~ /^#/) && next;
 501
 502         my $parameter_name = $parameter;
 503         $parameter_name =~ s/\[.*//;
 504
 505         ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
 506         print "<dt><b>".$parameter."</b>\n";
 507         print "<dd>";
 508         output_highlight($args{'parameterdescs'}{$parameter_name});
 509     }
 510     print "</dl>\n";
 511     output_section_html(@_);
 512     print "<hr>\n";
 513 }
 514
 515 # output function in html
 516 sub output_function_html(%) {
 517     my %args = %{$_[0]};
 518     my ($parameter, $section);
 519     my $count;
 520
 521     print "<h2>" .$args{'function'}." - ".$args{'purpose'}."</h2>\n";
 522     print "<i>".$args{'functiontype'}."</i>\n";
 523     print "<b>".$args{'function'}."</b>\n";
 524     print "(";
 525     $count = 0;
 526     foreach $parameter (@{$args{'parameterlist'}}) {
 527         $type = $args{'parametertypes'}{$parameter};
 528         if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
 529             # pointer-to-function
 530             print "<i>$1</i><b>$parameter</b>) <i>($2)</i>";
 531         } else {
 532             print "<i>".$type."</i> <b>".$parameter."</b>";
 533         }
 534         if ($count != $#{$args{'parameterlist'}}) {
 535             $count++;
 536             print ",\n";
 537         }
 538     }
 539     print ")\n";
 540
 541     print "<h3>Arguments</h3>\n";
 542     print "<dl>\n";
 543     foreach $parameter (@{$args{'parameterlist'}}) {
 544         my $parameter_name = $parameter;
 545         $parameter_name =~ s/\[.*//;
 546
 547         ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
 548         print "<dt><b>".$parameter."</b>\n";
 549         print "<dd>";
 550         output_highlight($args{'parameterdescs'}{$parameter_name});
 551     }
 552     print "</dl>\n";
 553     output_section_html(@_);
 554     print "<hr>\n";
 555 }
 556
 557 # output intro in html
 558 sub output_intro_html(%) {
 559     my %args = %{$_[0]};
 560     my ($parameter, $section);
 561     my $count;
 562
 563     foreach $section (@{$args{'sectionlist'}}) {
 564         print "<h3>$section</h3>\n";
 565         print "<ul>\n";
 566         output_highlight($args{'sections'}{$section});
 567         print "</ul>\n";
 568     }
 569     print "<hr>\n";
 570 }
 571
 572 sub output_section_xml(%) {
 573     my %args = %{$_[0]};
 574     my $section;
 575     # print out each section
 576     $lineprefix="   ";
 577     foreach $section (@{$args{'sectionlist'}}) {
 578         print "<refsect1>\n";
 579         print "<title>$section</title>\n";
 580         if ($section =~ m/EXAMPLE/i) {
 581             print "<informalexample><programlisting>\n";
 582         } else {
 583             print "<para>\n";
 584         }
 585         output_highlight($args{'sections'}{$section});
 586         if ($section =~ m/EXAMPLE/i) {
 587             print "</programlisting></informalexample>\n";
 588         } else {
 589             print "</para>\n";
 590         }
 591         print "</refsect1>\n";
 592     }
 593 }
 594
 595 # output function in XML DocBook
 596 sub output_function_xml(%) {
 597     my %args = %{$_[0]};
 598     my ($parameter, $section);
 599     my $count;
 600     my $id;
 601
 602     $id = "API-".$args{'function'};
 603     $id =~ s/[^A-Za-z0-9]/-/g;
 604
 605     print "<refentry id=\"$id\">\n";
 606     print "<refentryinfo>\n";
 607     print " <title>LINUX</title>\n";
 608     print " <productname>Kernel Hackers Manual</productname>\n";
 609     print " <date>$man_date</date>\n";
 610     print "</refentryinfo>\n";
 611     print "<refmeta>\n";
 612     print " <refentrytitle><phrase>".$args{'function'}."</phrase></refentrytitle>\n";
 613     print " <manvolnum>9</manvolnum>\n";
 614     print " <refmiscinfo class=\"version\">" . $kernelversion . "</refmiscinfo>\n";
 615     print "</refmeta>\n";
 616     print "<refnamediv>\n";
 617     print " <refname>".$args{'function'}."</refname>\n";
 618     print " <refpurpose>\n";
 619     print "  ";
 620     output_highlight ($args{'purpose'});
 621     print " </refpurpose>\n";
 622     print "</refnamediv>\n";
 623
 624     print "<refsynopsisdiv>\n";
 625     print " <title>Synopsis</title>\n";
 626     print "  <funcsynopsis><funcprototype>\n";
 627     print "   <funcdef>".$args{'functiontype'}." ";
 628     print "<function>".$args{'function'}." </function></funcdef>\n";
 629
 630     $count = 0;
 631     if ($#{$args{'parameterlist'}} >= 0) {
 632         foreach $parameter (@{$args{'parameterlist'}}) {
 633             $type = $args{'parametertypes'}{$parameter};
 634             if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
 635                 # pointer-to-function
 636                 print "   <paramdef>$1<parameter>$parameter</parameter>)\n";
 637                 print "     <funcparams>$2</funcparams></paramdef>\n";
 638             } else {
 639                 print "   <paramdef>".$type;
 640                 print " <parameter>$parameter</parameter></paramdef>\n";
 641             }
 642         }
 643     } else {
 644         print "  <void/>\n";
 645     }
 646     print "  </funcprototype></funcsynopsis>\n";
 647     print "</refsynopsisdiv>\n";
 648
 649     # print parameters
 650     print "<refsect1>\n <title>Arguments</title>\n";
 651     if ($#{$args{'parameterlist'}} >= 0) {
 652         print " <variablelist>\n";
 653         foreach $parameter (@{$args{'parameterlist'}}) {
 654             my $parameter_name = $parameter;
 655             $parameter_name =~ s/\[.*//;
 656
 657             print "  <varlistentry>\n   <term><parameter>$parameter</parameter></term>\n";
 658             print "   <listitem>\n    <para>\n";
 659             $lineprefix="     ";
 660             output_highlight($args{'parameterdescs'}{$parameter_name});
 661             print "    </para>\n   </listitem>\n  </varlistentry>\n";
 662         }
 663         print " </variablelist>\n";
 664     } else {
 665         print " <para>\n  None\n </para>\n";
 666     }
 667     print "</refsect1>\n";
 668
 669     output_section_xml(@_);
 670     print "</refentry>\n\n";
 671 }
 672
 673 # output struct in XML DocBook
 674 sub output_struct_xml(%) {
 675     my %args = %{$_[0]};
 676     my ($parameter, $section);
 677     my $id;
 678
 679     $id = "API-struct-".$args{'struct'};
 680     $id =~ s/[^A-Za-z0-9]/-/g;
 681
 682     print "<refentry id=\"$id\">\n";
 683     print "<refentryinfo>\n";
 684     print " <title>LINUX</title>\n";
 685     print " <productname>Kernel Hackers Manual</productname>\n";
 686     print " <date>$man_date</date>\n";
 687     print "</refentryinfo>\n";
 688     print "<refmeta>\n";
 689     print " <refentrytitle><phrase>".$args{'type'}." ".$args{'struct'}."</phrase></refentrytitle>\n";
 690     print " <manvolnum>9</manvolnum>\n";
 691     print " <refmiscinfo class=\"version\">" . $kernelversion . "</refmiscinfo>\n";
 692     print "</refmeta>\n";
 693     print "<refnamediv>\n";
 694     print " <refname>".$args{'type'}." ".$args{'struct'}."</refname>\n";
 695     print " <refpurpose>\n";
 696     print "  ";
 697     output_highlight ($args{'purpose'});
 698     print " </refpurpose>\n";
 699     print "</refnamediv>\n";
 700
 701     print "<refsynopsisdiv>\n";
 702     print " <title>Synopsis</title>\n";
 703     print "  <programlisting>\n";
 704     print $args{'type'}." ".$args{'struct'}." {\n";
 705     foreach $parameter (@{$args{'parameterlist'}}) {
 706         if ($parameter =~ /^#/) {
 707             print "$parameter\n";
 708             next;
 709         }
 710
 711         my $parameter_name = $parameter;
 712         $parameter_name =~ s/\[.*//;
 713
 714         defined($args{'parameterdescs'}{$parameter_name}) || next;
 715         ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
 716         $type = $args{'parametertypes'}{$parameter};
 717         if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
 718             # pointer-to-function
 719             print "  $1 $parameter) ($2);\n";
 720         } elsif ($type =~ m/^(.*?)\s*(:.*)/) {
 721             print "  $1 $parameter$2;\n";
 722         } else {
 723             print "  ".$type." ".$parameter.";\n";
 724         }
 725     }
 726     print "};";
 727     print "  </programlisting>\n";
 728     print "</refsynopsisdiv>\n";
 729
 730     print " <refsect1>\n";
 731     print "  <title>Members</title>\n";
 732
 733     print "  <variablelist>\n";
 734     foreach $parameter (@{$args{'parameterlist'}}) {
 735       ($parameter =~ /^#/) && next;
 736
 737       my $parameter_name = $parameter;
 738       $parameter_name =~ s/\[.*//;
 739
 740       defined($args{'parameterdescs'}{$parameter_name}) || next;
 741       ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
 742       print "    <varlistentry>";
 743       print "      <term>$parameter</term>\n";
 744       print "      <listitem><para>\n";
 745       output_highlight($args{'parameterdescs'}{$parameter_name});
 746       print "      </para></listitem>\n";
 747       print "    </varlistentry>\n";
 748     }
 749     print "  </variablelist>\n";
 750     print " </refsect1>\n";
 751
 752     output_section_xml(@_);
 753
 754     print "</refentry>\n\n";
 755 }
 756
 757 # output enum in XML DocBook
 758 sub output_enum_xml(%) {
 759     my %args = %{$_[0]};
 760     my ($parameter, $section);
 761     my $count;
 762     my $id;
 763
 764     $id = "API-enum-".$args{'enum'};
 765     $id =~ s/[^A-Za-z0-9]/-/g;
 766
 767     print "<refentry id=\"$id\">\n";
 768     print "<refentryinfo>\n";
 769     print " <title>LINUX</title>\n";
 770     print " <productname>Kernel Hackers Manual</productname>\n";
 771     print " <date>$man_date</date>\n";
 772     print "</refentryinfo>\n";
 773     print "<refmeta>\n";
 774     print " <refentrytitle><phrase>enum ".$args{'enum'}."</phrase></refentrytitle>\n";
 775     print " <manvolnum>9</manvolnum>\n";
 776     print " <refmiscinfo class=\"version\">" . $kernelversion . "</refmiscinfo>\n";
 777     print "</refmeta>\n";
 778     print "<refnamediv>\n";
 779     print " <refname>enum ".$args{'enum'}."</refname>\n";
 780     print " <refpurpose>\n";
 781     print "  ";
 782     output_highlight ($args{'purpose'});
 783     print " </refpurpose>\n";
 784     print "</refnamediv>\n";
 785
 786     print "<refsynopsisdiv>\n";
 787     print " <title>Synopsis</title>\n";
 788     print "  <programlisting>\n";
 789     print "enum ".$args{'enum'}." {\n";
 790     $count = 0;
 791     foreach $parameter (@{$args{'parameterlist'}}) {
 792         print "  $parameter";
 793         if ($count != $#{$args{'parameterlist'}}) {
 794             $count++;
 795             print ",";
 796         }
 797         print "\n";
 798     }
 799     print "};";
 800     print "  </programlisting>\n";
 801     print "</refsynopsisdiv>\n";
 802
 803     print "<refsect1>\n";
 804     print " <title>Constants</title>\n";
 805     print "  <variablelist>\n";
 806     foreach $parameter (@{$args{'parameterlist'}}) {
 807       my $parameter_name = $parameter;
 808       $parameter_name =~ s/\[.*//;
 809
 810       print "    <varlistentry>";
 811       print "      <term>$parameter</term>\n";
 812       print "      <listitem><para>\n";
 813       output_highlight($args{'parameterdescs'}{$parameter_name});
 814       print "      </para></listitem>\n";
 815       print "    </varlistentry>\n";
 816     }
 817     print "  </variablelist>\n";
 818     print "</refsect1>\n";
 819
 820     output_section_xml(@_);
 821
 822     print "</refentry>\n\n";
 823 }
 824
 825 # output typedef in XML DocBook
 826 sub output_typedef_xml(%) {
 827     my %args = %{$_[0]};
 828     my ($parameter, $section);
 829     my $id;
 830
 831     $id = "API-typedef-".$args{'typedef'};
 832     $id =~ s/[^A-Za-z0-9]/-/g;
 833
 834     print "<refentry id=\"$id\">\n";
 835     print "<refentryinfo>\n";
 836     print " <title>LINUX</title>\n";
 837     print " <productname>Kernel Hackers Manual</productname>\n";
 838     print " <date>$man_date</date>\n";
 839     print "</refentryinfo>\n";
 840     print "<refmeta>\n";
 841     print " <refentrytitle><phrase>typedef ".$args{'typedef'}."</phrase></refentrytitle>\n";
 842     print " <manvolnum>9</manvolnum>\n";
 843     print "</refmeta>\n";
 844     print "<refnamediv>\n";
 845     print " <refname>typedef ".$args{'typedef'}."</refname>\n";
 846     print " <refpurpose>\n";
 847     print "  ";
 848     output_highlight ($args{'purpose'});
 849     print " </refpurpose>\n";
 850     print "</refnamediv>\n";
 851
 852     print "<refsynopsisdiv>\n";
 853     print " <title>Synopsis</title>\n";
 854     print "  <synopsis>typedef ".$args{'typedef'}.";</synopsis>\n";
 855     print "</refsynopsisdiv>\n";
 856
 857     output_section_xml(@_);
 858
 859     print "</refentry>\n\n";
 860 }
 861
 862 # output in XML DocBook
 863 sub output_intro_xml(%) {
 864     my %args = %{$_[0]};
 865     my ($parameter, $section);
 866     my $count;
 867
 868     my $id = $args{'module'};
 869     $id =~ s/[^A-Za-z0-9]/-/g;
 870
 871     # print out each section
 872     $lineprefix="   ";
 873     foreach $section (@{$args{'sectionlist'}}) {
 874         print "<refsect1>\n <title>$section</title>\n <para>\n";
 875         if ($section =~ m/EXAMPLE/i) {
 876             print "<example><para>\n";
 877         }
 878         output_highlight($args{'sections'}{$section});
 879         if ($section =~ m/EXAMPLE/i) {
 880             print "</para></example>\n";
 881         }
 882         print " </para>\n</refsect1>\n";
 883     }
 884
 885     print "\n\n";
 886 }
 887
 888 # output in XML DocBook
 889 sub output_function_gnome {
 890     my %args = %{$_[0]};
 891     my ($parameter, $section);
 892     my $count;
 893     my $id;
 894
 895     $id = $args{'module'}."-".$args{'function'};
 896     $id =~ s/[^A-Za-z0-9]/-/g;
 897
 898     print "<sect2>\n";
 899     print " <title id=\"$id\">".$args{'function'}."</title>\n";
 900
 901     print "  <funcsynopsis>\n";
 902     print "   <funcdef>".$args{'functiontype'}." ";
 903     print "<function>".$args{'function'}." ";
 904     print "</function></funcdef>\n";
 905
 906     $count = 0;
 907     if ($#{$args{'parameterlist'}} >= 0) {
 908         foreach $parameter (@{$args{'parameterlist'}}) {
 909             $type = $args{'parametertypes'}{$parameter};
 910             if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
 911                 # pointer-to-function
 912                 print "   <paramdef>$1 <parameter>$parameter</parameter>)\n";
 913                 print "     <funcparams>$2</funcparams></paramdef>\n";
 914             } else {
 915                 print "   <paramdef>".$type;
 916                 print " <parameter>$parameter</parameter></paramdef>\n";
 917             }
 918         }
 919     } else {
 920         print "  <void>\n";
 921     }
 922     print "  </funcsynopsis>\n";
 923     if ($#{$args{'parameterlist'}} >= 0) {
 924         print " <informaltable pgwide=\"1\" frame=\"none\" role=\"params\">\n";
 925         print "<tgroup cols=\"2\">\n";
 926         print "<colspec colwidth=\"2*\">\n";
 927         print "<colspec colwidth=\"8*\">\n";
 928         print "<tbody>\n";
 929         foreach $parameter (@{$args{'parameterlist'}}) {
 930             my $parameter_name = $parameter;
 931             $parameter_name =~ s/\[.*//;
 932
 933             print "  <row><entry align=\"right\"><parameter>$parameter</parameter></entry>\n";
 934             print "   <entry>\n";
 935             $lineprefix="     ";
 936             output_highlight($args{'parameterdescs'}{$parameter_name});
 937             print "    </entry></row>\n";
 938         }
 939         print " </tbody></tgroup></informaltable>\n";
 940     } else {
 941         print " <para>\n  None\n </para>\n";
 942     }
 943
 944     # print out each section
 945     $lineprefix="   ";
 946     foreach $section (@{$args{'sectionlist'}}) {
 947         print "<simplesect>\n <title>$section</title>\n";
 948         if ($section =~ m/EXAMPLE/i) {
 949             print "<example><programlisting>\n";
 950         } else {
 951         }
 952         print "<para>\n";
 953         output_highlight($args{'sections'}{$section});
 954         print "</para>\n";
 955         if ($section =~ m/EXAMPLE/i) {
 956             print "</programlisting></example>\n";
 957         } else {
 958         }
 959         print " </simplesect>\n";
 960     }
 961
 962     print "</sect2>\n\n";
 963 }
 964
 965 ##
 966 # output function in man
 967 sub output_function_man(%) {
 968     my %args = %{$_[0]};
 969     my ($parameter, $section);
 970     my $count;
 971
 972     print ".TH \"$args{'function'}\" 9 \"$args{'function'}\" \"$man_date\" \"Kernel Hacker's Manual\" LINUX\n";
 973
 974     print ".SH NAME\n";
 975     print $args{'function'}." \\- ".$args{'purpose'}."\n";
 976
 977     print ".SH SYNOPSIS\n";
 978     if ($args{'functiontype'} ne "") {
 979         print ".B \"".$args{'functiontype'}."\" ".$args{'function'}."\n";
 980     } else {
 981         print ".B \"".$args{'function'}."\n";
 982     }
 983     $count = 0;
 984     my $parenth = "(";
 985     my $post = ",";
 986     foreach my $parameter (@{$args{'parameterlist'}}) {
 987         if ($count == $#{$args{'parameterlist'}}) {
 988             $post = ");";
 989         }
 990         $type = $args{'parametertypes'}{$parameter};
 991         if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
 992             # pointer-to-function
 993             print ".BI \"".$parenth.$1."\" ".$parameter." \") (".$2.")".$post."\"\n";
 994         } else {
 995             $type =~ s/([^\*])$/$1 /;
 996             print ".BI \"".$parenth.$type."\" ".$parameter." \"".$post."\"\n";
 997         }
 998         $count++;
 999         $parenth = "";
1000     }
1001
1002     print ".SH ARGUMENTS\n";
1003     foreach $parameter (@{$args{'parameterlist'}}) {
1004         my $parameter_name = $parameter;
1005         $parameter_name =~ s/\[.*//;
1006
1007         print ".IP \"".$parameter."\" 12\n";
1008         output_highlight($args{'parameterdescs'}{$parameter_name});
1009     }
1010     foreach $section (@{$args{'sectionlist'}}) {
1011         print ".SH \"", uc $section, "\"\n";
1012         output_highlight($args{'sections'}{$section});
1013     }
1014 }
1015
1016 ##
1017 # output enum in man
1018 sub output_enum_man(%) {
1019     my %args = %{$_[0]};
1020     my ($parameter, $section);
1021     my $count;
1022
1023     print ".TH \"$args{'module'}\" 9 \"enum $args{'enum'}\" \"$man_date\" \"API Manual\" LINUX\n";
1024
1025     print ".SH NAME\n";
1026     print "enum ".$args{'enum'}." \\- ".$args{'purpose'}."\n";
1027
1028     print ".SH SYNOPSIS\n";
1029     print "enum ".$args{'enum'}." {\n";
1030     $count = 0;
1031     foreach my $parameter (@{$args{'parameterlist'}}) {
1032         print ".br\n.BI \"    $parameter\"\n";
1033         if ($count == $#{$args{'parameterlist'}}) {
1034             print "\n};\n";
1035             last;
1036         }
1037         else {
1038             print ", \n.br\n";
1039         }
1040         $count++;
1041     }
1042
1043     print ".SH Constants\n";
1044     foreach $parameter (@{$args{'parameterlist'}}) {
1045         my $parameter_name = $parameter;
1046         $parameter_name =~ s/\[.*//;
1047
1048         print ".IP \"".$parameter."\" 12\n";
1049         output_highlight($args{'parameterdescs'}{$parameter_name});
1050     }
1051     foreach $section (@{$args{'sectionlist'}}) {
1052         print ".SH \"$section\"\n";
1053         output_highlight($args{'sections'}{$section});
1054     }
1055 }
1056
1057 ##
1058 # output struct in man
1059 sub output_struct_man(%) {
1060     my %args = %{$_[0]};
1061     my ($parameter, $section);
1062
1063     print ".TH \"$args{'module'}\" 9 \"".$args{'type'}." ".$args{'struct'}."\" \"$man_date\" \"API Manual\" LINUX\n";
1064
1065     print ".SH NAME\n";
1066     print $args{'type'}." ".$args{'struct'}." \\- ".$args{'purpose'}."\n";
1067
1068     print ".SH SYNOPSIS\n";
1069     print $args{'type'}." ".$args{'struct'}." {\n.br\n";
1070
1071     foreach my $parameter (@{$args{'parameterlist'}}) {
1072         if ($parameter =~ /^#/) {
1073             print ".BI \"$parameter\"\n.br\n";
1074             next;
1075         }
1076         my $parameter_name = $parameter;
1077         $parameter_name =~ s/\[.*//;
1078
1079         ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
1080         $type = $args{'parametertypes'}{$parameter};
1081         if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
1082             # pointer-to-function
1083             print ".BI \"    ".$1."\" ".$parameter." \") (".$2.")"."\"\n;\n";
1084         } elsif ($type =~ m/^(.*?)\s*(:.*)/) {
1085             # bitfield
1086             print ".BI \"    ".$1."\ \" ".$parameter.$2." \""."\"\n;\n";
1087         } else {
1088             $type =~ s/([^\*])$/$1 /;
1089             print ".BI \"    ".$type."\" ".$parameter." \""."\"\n;\n";
1090         }
1091         print "\n.br\n";
1092     }
1093     print "};\n.br\n";
1094
1095     print ".SH Members\n";
1096     foreach $parameter (@{$args{'parameterlist'}}) {
1097         ($parameter =~ /^#/) && next;
1098
1099         my $parameter_name = $parameter;
1100         $parameter_name =~ s/\[.*//;
1101
1102         ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
1103         print ".IP \"".$parameter."\" 12\n";
1104         output_highlight($args{'parameterdescs'}{$parameter_name});
1105     }
1106     foreach $section (@{$args{'sectionlist'}}) {
1107         print ".SH \"$section\"\n";
1108         output_highlight($args{'sections'}{$section});
1109     }
1110 }
1111
1112 ##
1113 # output typedef in man
1114 sub output_typedef_man(%) {
1115     my %args = %{$_[0]};
1116     my ($parameter, $section);
1117
1118     print ".TH \"$args{'module'}\" 9 \"$args{'typedef'}\" \"$man_date\" \"API Manual\" LINUX\n";
1119
1120     print ".SH NAME\n";
1121     print "typedef ".$args{'typedef'}." \\- ".$args{'purpose'}."\n";
1122
1123     foreach $section (@{$args{'sectionlist'}}) {
1124         print ".SH \"$section\"\n";
1125         output_highlight($args{'sections'}{$section});
1126     }
1127 }
1128
1129 sub output_intro_man(%) {
1130     my %args = %{$_[0]};
1131     my ($parameter, $section);
1132     my $count;
1133
1134     print ".TH \"$args{'module'}\" 9 \"$args{'module'}\" \"$man_date\" \"API Manual\" LINUX\n";
1135
1136     foreach $section (@{$args{'sectionlist'}}) {
1137         print ".SH \"$section\"\n";
1138         output_highlight($args{'sections'}{$section});
1139     }
1140 }
1141
1142 ##
1143 # output in text
1144 sub output_function_text(%) {
1145     my %args = %{$_[0]};
1146     my ($parameter, $section);
1147     my $start;
1148
1149     print "Name:\n\n";
1150     print $args{'function'}." - ".$args{'purpose'}."\n";
1151
1152     print "\nSynopsis:\n\n";
1153     if ($args{'functiontype'} ne "") {
1154         $start = $args{'functiontype'}." ".$args{'function'}." (";
1155     } else {
1156         $start = $args{'function'}." (";
1157     }
1158     print $start;
1159
1160     my $count = 0;
1161     foreach my $parameter (@{$args{'parameterlist'}}) {
1162         $type = $args{'parametertypes'}{$parameter};
1163         if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
1164             # pointer-to-function
1165             print $1.$parameter.") (".$2;
1166         } else {
1167             print $type." ".$parameter;
1168         }
1169         if ($count != $#{$args{'parameterlist'}}) {
1170             $count++;
1171             print ",\n";
1172             print " " x length($start);
1173         } else {
1174             print ");\n\n";
1175         }
1176     }
1177
1178     print "Arguments:\n\n";
1179     foreach $parameter (@{$args{'parameterlist'}}) {
1180         my $parameter_name = $parameter;
1181         $parameter_name =~ s/\[.*//;
1182
1183         print $parameter."\n\t".$args{'parameterdescs'}{$parameter_name}."\n";
1184     }
1185     output_section_text(@_);
1186 }
1187
1188 #output sections in text
1189 sub output_section_text(%) {
1190     my %args = %{$_[0]};
1191     my $section;
1192
1193     print "\n";
1194     foreach $section (@{$args{'sectionlist'}}) {
1195         print "$section:\n\n";
1196         output_highlight($args{'sections'}{$section});
1197     }
1198     print "\n\n";
1199 }
1200
1201 # output enum in text
1202 sub output_enum_text(%) {
1203     my %args = %{$_[0]};
1204     my ($parameter);
1205     my $count;
1206     print "Enum:\n\n";
1207
1208     print "enum ".$args{'enum'}." - ".$args{'purpose'}."\n\n";
1209     print "enum ".$args{'enum'}." {\n";
1210     $count = 0;
1211     foreach $parameter (@{$args{'parameterlist'}}) {
1212         print "\t$parameter";
1213         if ($count != $#{$args{'parameterlist'}}) {
1214             $count++;
1215             print ",";
1216         }
1217         print "\n";
1218     }
1219     print "};\n\n";
1220
1221     print "Constants:\n\n";
1222     foreach $parameter (@{$args{'parameterlist'}}) {
1223         print "$parameter\n\t";
1224         print $args{'parameterdescs'}{$parameter}."\n";
1225     }
1226
1227     output_section_text(@_);
1228 }
1229
1230 # output typedef in text
1231 sub output_typedef_text(%) {
1232     my %args = %{$_[0]};
1233     my ($parameter);
1234     my $count;
1235     print "Typedef:\n\n";
1236
1237     print "typedef ".$args{'typedef'}." - ".$args{'purpose'}."\n";
1238     output_section_text(@_);
1239 }
1240
1241 # output struct as text
1242 sub output_struct_text(%) {
1243     my %args = %{$_[0]};
1244     my ($parameter);
1245
1246     print $args{'type'}." ".$args{'struct'}." - ".$args{'purpose'}."\n\n";
1247     print $args{'type'}." ".$args{'struct'}." {\n";
1248     foreach $parameter (@{$args{'parameterlist'}}) {
1249         if ($parameter =~ /^#/) {
1250             print "$parameter\n";
1251             next;
1252         }
1253
1254         my $parameter_name = $parameter;
1255         $parameter_name =~ s/\[.*//;
1256
1257         ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
1258         $type = $args{'parametertypes'}{$parameter};
1259         if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
1260             # pointer-to-function
1261             print "\t$1 $parameter) ($2);\n";
1262         } elsif ($type =~ m/^(.*?)\s*(:.*)/) {
1263             print "\t$1 $parameter$2;\n";
1264         } else {
1265             print "\t".$type." ".$parameter.";\n";
1266         }
1267     }
1268     print "};\n\n";
1269
1270     print "Members:\n\n";
1271     foreach $parameter (@{$args{'parameterlist'}}) {
1272         ($parameter =~ /^#/) && next;
1273
1274         my $parameter_name = $parameter;
1275         $parameter_name =~ s/\[.*//;
1276
1277         ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
1278         print "$parameter\n\t";
1279         print $args{'parameterdescs'}{$parameter_name}."\n";
1280     }
1281     print "\n";
1282     output_section_text(@_);
1283 }
1284
1285 sub output_intro_text(%) {
1286     my %args = %{$_[0]};
1287     my ($parameter, $section);
1288
1289     foreach $section (@{$args{'sectionlist'}}) {
1290         print " $section:\n";
1291         print "    -> ";
1292         output_highlight($args{'sections'}{$section});
1293     }
1294 }
1295
1296 ##
1297 # generic output function for all types (function, struct/union, typedef, enum);
1298 # calls the generated, variable output_ function name based on
1299 # functype and output_mode
1300 sub output_declaration {
1301     no strict 'refs';
1302     my $name = shift;
1303     my $functype = shift;
1304     my $func = "output_${functype}_$output_mode";
1305     if (($function_only==0) ||
1306         ( $function_only == 1 && defined($function_table{$name})) ||
1307         ( $function_only == 2 && !defined($function_table{$name})))
1308     {
1309         &$func(@_);
1310         $section_counter++;
1311     }
1312 }
1313
1314 ##
1315 # generic output function - calls the right one based on current output mode.
1316 sub output_intro {
1317     no strict 'refs';
1318     my $func = "output_intro_".$output_mode;
1319     &$func(@_);
1320     $section_counter++;
1321 }
1322
1323 ##
1324 # takes a declaration (struct, union, enum, typedef) and
1325 # invokes the right handler. NOT called for functions.
1326 sub dump_declaration($$) {
1327     no strict 'refs';
1328     my ($prototype, $file) = @_;
1329     my $func = "dump_".$decl_type;
1330     &$func(@_);
1331 }
1332
1333 sub dump_union($$) {
1334     dump_struct(@_);
1335 }
1336
1337 sub dump_struct($$) {
1338     my $x = shift;
1339     my $file = shift;
1340
1341     if ($x =~/(struct|union)\s+(\w+)\s*{(.*)}/) {
1342         $declaration_name = $2;
1343         my $members = $3;
1344
1345         # ignore embedded structs or unions
1346         $members =~ s/{.*?}//g;
1347
1348         # ignore members marked private:
1349         $members =~ s/\/\*.*?private:.*?public:.*?\*\///gos;
1350         $members =~ s/\/\*.*?private:.*//gos;
1351         # strip comments:
1352         $members =~ s/\/\*.*?\*\///gos;
1353
1354         create_parameterlist($members, ';', $file);
1355
1356         output_declaration($declaration_name,
1357                            'struct',
1358                            {'struct' => $declaration_name,
1359                             'module' => $modulename,
1360                             'parameterlist' => \@parameterlist,
1361                             'parameterdescs' => \%parameterdescs,
1362                             'parametertypes' => \%parametertypes,
1363                             'sectionlist' => \@sectionlist,
1364                             'sections' => \%sections,
1365                             'purpose' => $declaration_purpose,
1366                             'type' => $decl_type
1367                            });
1368     }
1369     else {
1370         print STDERR "Error(${file}:$.): Cannot parse struct or union!\n";
1371         ++$errors;
1372     }
1373 }
1374
1375 sub dump_enum($$) {
1376     my $x = shift;
1377     my $file = shift;
1378
1379     $x =~ s@/\*.*?\*/@@gos;     # strip comments.
1380     if ($x =~ /enum\s+(\w+)\s*{(.*)}/) {
1381         $declaration_name = $1;
1382         my $members = $2;
1383
1384         foreach my $arg (split ',', $members) {
1385             $arg =~ s/^\s*(\w+).*/$1/;
1386             push @parameterlist, $arg;
1387             if (!$parameterdescs{$arg}) {
1388                 $parameterdescs{$arg} = $undescribed;
1389                 print STDERR "Warning(${file}:$.): Enum value '$arg' ".
1390                     "not described in enum '$declaration_name'\n";
1391             }
1392
1393         }
1394
1395         output_declaration($declaration_name,
1396                            'enum',
1397                            {'enum' => $declaration_name,
1398                             'module' => $modulename,
1399                             'parameterlist' => \@parameterlist,
1400                             'parameterdescs' => \%parameterdescs,
1401                             'sectionlist' => \@sectionlist,
1402                             'sections' => \%sections,
1403                             'purpose' => $declaration_purpose
1404                            });
1405     }
1406     else {
1407         print STDERR "Error(${file}:$.): Cannot parse enum!\n";
1408         ++$errors;
1409     }
1410 }
1411
1412 sub dump_typedef($$) {
1413     my $x = shift;
1414     my $file = shift;
1415
1416     $x =~ s@/\*.*?\*/@@gos;     # strip comments.
1417     while (($x =~ /\(*.\)\s*;$/) || ($x =~ /\[*.\]\s*;$/)) {
1418         $x =~ s/\(*.\)\s*;$/;/;
1419         $x =~ s/\[*.\]\s*;$/;/;
1420     }
1421
1422     if ($x =~ /typedef.*\s+(\w+)\s*;/) {
1423         $declaration_name = $1;
1424
1425         output_declaration($declaration_name,
1426                            'typedef',
1427                            {'typedef' => $declaration_name,
1428                             'module' => $modulename,
1429                             'sectionlist' => \@sectionlist,
1430                             'sections' => \%sections,
1431                             'purpose' => $declaration_purpose
1432                            });
1433     }
1434     else {
1435         print STDERR "Error(${file}:$.): Cannot parse typedef!\n";
1436         ++$errors;
1437     }
1438 }
1439
1440 sub create_parameterlist($$$) {
1441     my $args = shift;
1442     my $splitter = shift;
1443     my $file = shift;
1444     my $type;
1445     my $param;
1446
1447     # temporarily replace commas inside function pointer definition
1448     while ($args =~ /(\([^\),]+),/) {
1449         $args =~ s/(\([^\),]+),/$1#/g;
1450     }
1451
1452     foreach my $arg (split($splitter, $args)) {
1453         # strip comments
1454         $arg =~ s/\/\*.*\*\///;
1455         # strip leading/trailing spaces
1456         $arg =~ s/^\s*//;
1457         $arg =~ s/\s*$//;
1458         $arg =~ s/\s+/ /;
1459
1460         if ($arg =~ /^#/) {
1461             # Treat preprocessor directive as a typeless variable just to fill
1462             # corresponding data structures "correctly". Catch it later in
1463             # output_* subs.
1464             push_parameter($arg, "", $file);
1465         } elsif ($arg =~ m/\(.*\*/) {
1466             # pointer-to-function
1467             $arg =~ tr/#/,/;
1468             $arg =~ m/[^\(]+\(\*\s*([^\)]+)\)/;
1469             $param = $1;
1470             $type = $arg;
1471             $type =~ s/([^\(]+\(\*)$param/$1/;
1472             push_parameter($param, $type, $file);
1473         } elsif ($arg) {
1474             $arg =~ s/\s*:\s*/:/g;
1475             $arg =~ s/\s*\[/\[/g;
1476
1477             my @args = split('\s*,\s*', $arg);
1478             if ($args[0] =~ m/\*/) {
1479                 $args[0] =~ s/(\*+)\s*/ $1/;
1480             }
1481
1482             my @first_arg;
1483             if ($args[0] =~ /^(.*\s+)(.*?\[.*\].*)$/) {
1484                     shift @args;
1485                     push(@first_arg, split('\s+', $1));
1486                     push(@first_arg, $2);
1487             } else {
1488                     @first_arg = split('\s+', shift @args);
1489             }
1490
1491             unshift(@args, pop @first_arg);
1492             $type = join " ", @first_arg;
1493
1494             foreach $param (@args) {
1495                 if ($param =~ m/^(\*+)\s*(.*)/) {
1496                     push_parameter($2, "$type $1", $file);
1497                 }
1498                 elsif ($param =~ m/(.*?):(\d+)/) {
1499                     push_parameter($1, "$type:$2", $file)
1500                 }
1501                 else {
1502                     push_parameter($param, $type, $file);
1503                 }
1504             }
1505         }
1506     }
1507 }
1508
1509 sub push_parameter($$$) {
1510         my $param = shift;
1511         my $type = shift;
1512         my $file = shift;
1513         my $anon = 0;
1514
1515         my $param_name = $param;
1516         $param_name =~ s/\[.*//;
1517
1518         if ($type eq "" && $param =~ /\.\.\.$/)
1519         {
1520             $type="";
1521             $parameterdescs{$param} = "variable arguments";
1522         }
1523         elsif ($type eq "" && ($param eq "" or $param eq "void"))
1524         {
1525             $type="";
1526             $param="void";
1527             $parameterdescs{void} = "no arguments";
1528         }
1529         elsif ($type eq "" && ($param eq "struct" or $param eq "union"))
1530         # handle unnamed (anonymous) union or struct:
1531         {
1532                 $type = $param;
1533                 $param = "{unnamed_" . $param. "}";
1534                 $parameterdescs{$param} = "anonymous\n";
1535                 $anon = 1;
1536         }
1537
1538         # warn if parameter has no description
1539         # (but ignore ones starting with # as these are not parameters
1540         # but inline preprocessor statements);
1541         # also ignore unnamed structs/unions;
1542         if (!$anon) {
1543         if (!defined $parameterdescs{$param_name} && $param_name !~ /^#/) {
1544
1545             $parameterdescs{$param_name} = $undescribed;
1546
1547             if (($type eq 'function') || ($type eq 'enum')) {
1548                 print STDERR "Warning(${file}:$.): Function parameter ".
1549                     "or member '$param' not " .
1550                     "described in '$declaration_name'\n";
1551             }
1552             print STDERR "Warning(${file}:$.):".
1553                          " No description found for parameter '$param'\n";
1554             ++$warnings;
1555         }
1556         }
1557
1558         push @parameterlist, $param;
1559         $parametertypes{$param} = $type;
1560 }
1561
1562 ##
1563 # takes a function prototype and the name of the current file being
1564 # processed and spits out all the details stored in the global
1565 # arrays/hashes.
1566 sub dump_function($$) {
1567     my $prototype = shift;
1568     my $file = shift;
1569
1570     $prototype =~ s/^static +//;
1571     $prototype =~ s/^extern +//;
1572     $prototype =~ s/^fastcall +//;
1573     $prototype =~ s/^asmlinkage +//;
1574     $prototype =~ s/^inline +//;
1575     $prototype =~ s/^__inline__ +//;
1576     $prototype =~ s/^__inline +//;
1577     $prototype =~ s/^__always_inline +//;
1578     $prototype =~ s/^noinline +//;
1579     $prototype =~ s/__devinit +//;
1580     $prototype =~ s/^#define\s+//; #ak added
1581     $prototype =~ s/__attribute__\s*\(\([a-z,]*\)\)//;
1582
1583     # Yes, this truly is vile.  We are looking for:
1584     # 1. Return type (may be nothing if we're looking at a macro)
1585     # 2. Function name
1586     # 3. Function parameters.
1587     #
1588     # All the while we have to watch out for function pointer parameters
1589     # (which IIRC is what the two sections are for), C types (these
1590     # regexps don't even start to express all the possibilities), and
1591     # so on.
1592     #
1593     # If you mess with these regexps, it's a good idea to check that
1594     # the following functions' documentation still comes out right:
1595     # - parport_register_device (function pointer parameters)
1596     # - atomic_set (macro)
1597     # - pci_match_device, __copy_to_user (long return type)
1598
1599     if ($prototype =~ m/^()([a-zA-Z0-9_~:]+)\s*\(([^\(]*)\)/ ||
1600         $prototype =~ m/^(\w+)\s+([a-zA-Z0-9_~:]+)\s*\(([^\(]*)\)/ ||
1601         $prototype =~ m/^(\w+\s*\*)\s*([a-zA-Z0-9_~:]+)\s*\(([^\(]*)\)/ ||
1602         $prototype =~ m/^(\w+\s+\w+)\s+([a-zA-Z0-9_~:]+)\s*\(([^\(]*)\)/ ||
1603         $prototype =~ m/^(\w+\s+\w+\s*\*)\s*([a-zA-Z0-9_~:]+)\s*\(([^\(]*)\)/ ||
1604         $prototype =~ m/^(\w+\s+\w+\s+\w+)\s+([a-zA-Z0-9_~:]+)\s*\(([^\(]*)\)/ ||
1605         $prototype =~ m/^(\w+\s+\w+\s+\w+\s*\*)\s*([a-zA-Z0-9_~:]+)\s*\(([^\(]*)\)/ ||
1606         $prototype =~ m/^()([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/ ||
1607         $prototype =~ m/^(\w+)\s+([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/ ||
1608         $prototype =~ m/^(\w+\s*\*)\s*([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/ ||
1609         $prototype =~ m/^(\w+\s+\w+)\s+([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/ ||
1610         $prototype =~ m/^(\w+\s+\w+\s*\*)\s*([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/ ||
1611         $prototype =~ m/^(\w+\s+\w+\s+\w+)\s+([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/ ||
1612         $prototype =~ m/^(\w+\s+\w+\s+\w+\s*\*)\s*([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/ ||
1613         $prototype =~ m/^(\w+\s+\w+\s+\w+\s+\w+)\s+([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/ ||
1614         $prototype =~ m/^(\w+\s+\w+\s+\w+\s+\w+\s*\*)\s*([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/ ||
1615         $prototype =~ m/^(\w+\s+\w+\s*\*\s*\w+\s*\*\s*)\s*([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/)  {
1616         $return_type = $1;
1617         $declaration_name = $2;
1618         my $args = $3;
1619
1620         create_parameterlist($args, ',', $file);
1621     } else {
1622         print STDERR "Error(${file}:$.): cannot understand prototype: '$prototype'\n";
1623         ++$errors;
1624         return;
1625     }
1626
1627     output_declaration($declaration_name,
1628                        'function',
1629                        {'function' => $declaration_name,
1630                         'module' => $modulename,
1631                         'functiontype' => $return_type,
1632                         'parameterlist' => \@parameterlist,
1633                         'parameterdescs' => \%parameterdescs,
1634                         'parametertypes' => \%parametertypes,
1635                         'sectionlist' => \@sectionlist,
1636                         'sections' => \%sections,
1637                         'purpose' => $declaration_purpose
1638                        });
1639 }
1640
1641 sub process_file($);
1642
1643 # Read the file that maps relative names to absolute names for
1644 # separate source and object directories and for shadow trees.
1645 if (open(SOURCE_MAP, "<.tmp_filelist.txt")) {
1646         my ($relname, $absname);
1647         while(<SOURCE_MAP>) {
1648                 chop();
1649                 ($relname, $absname) = (split())[0..1];
1650                 $relname =~ s:^/+::;
1651                 $source_map{$relname} = $absname;
1652         }
1653         close(SOURCE_MAP);
1654 }
1655
1656 if ($filelist) {
1657         open(FLIST,"<$filelist") or die "Can't open file list $filelist";
1658         while(<FLIST>) {
1659                 chop;
1660                 process_file($_);
1661         }
1662 }
1663
1664 foreach (@ARGV) {
1665     chomp;
1666     process_file($_);
1667 }
1668 if ($verbose && $errors) {
1669   print STDERR "$errors errors\n";
1670 }
1671 if ($verbose && $warnings) {
1672   print STDERR "$warnings warnings\n";
1673 }
1674
1675 exit($errors);
1676
1677 sub reset_state {
1678     $function = "";
1679     %constants = ();
1680     %parameterdescs = ();
1681     %parametertypes = ();
1682     @parameterlist = ();
1683     %sections = ();
1684     @sectionlist = ();
1685     $prototype = "";
1686
1687     $state = 0;
1688 }
1689
1690 sub process_state3_function($$) {
1691     my $x = shift;
1692     my $file = shift;
1693
1694     if ($x =~ m#\s*/\*\s+MACDOC\s*#io || ($x =~ /^#/ && $x !~ /^#define/)) {
1695         # do nothing
1696     }
1697     elsif ($x =~ /([^\{]*)/) {
1698         $prototype .= $1;
1699     }
1700     if (($x =~ /\{/) || ($x =~ /\#define/) || ($x =~ /;/)) {
1701         $prototype =~ s@/\*.*?\*/@@gos; # strip comments.
1702         $prototype =~ s@[\r\n]+@ @gos; # strip newlines/cr's.
1703         $prototype =~ s@^\s+@@gos; # strip leading spaces
1704         dump_function($prototype,$file);
1705         reset_state();
1706     }
1707 }
1708
1709 sub process_state3_type($$) {
1710     my $x = shift;
1711     my $file = shift;
1712
1713     $x =~ s@[\r\n]+@ @gos; # strip newlines/cr's.
1714     $x =~ s@^\s+@@gos; # strip leading spaces
1715     $x =~ s@\s+$@@gos; # strip trailing spaces
1716     if ($x =~ /^#/) {
1717         # To distinguish preprocessor directive from regular declaration later.
1718         $x .= ";";
1719     }
1720
1721     while (1) {
1722         if ( $x =~ /([^{};]*)([{};])(.*)/ ) {
1723             $prototype .= $1 . $2;
1724             ($2 eq '{') && $brcount++;
1725             ($2 eq '}') && $brcount--;
1726             if (($2 eq ';') && ($brcount == 0)) {
1727                 dump_declaration($prototype,$file);
1728                 reset_state();
1729                 last;
1730             }
1731             $x = $3;
1732         } else {
1733             $prototype .= $x;
1734             last;
1735         }
1736     }
1737 }
1738
1739 # replace <, >, and &
1740 sub xml_escape($) {
1741         my $text = shift;
1742         if (($output_mode eq "text") || ($output_mode eq "man")) {
1743                 return $text;
1744         }
1745         $text =~ s/\&/\\\\\\amp;/g;
1746         $text =~ s/\</\\\\\\lt;/g;
1747         $text =~ s/\>/\\\\\\gt;/g;
1748         return $text;
1749 }
1750
1751 sub process_file($) {
1752     my $file;
1753     my $identifier;
1754     my $func;
1755     my $descr;
1756     my $initial_section_counter = $section_counter;
1757
1758     if (defined($ENV{'SRCTREE'})) {
1759         $file = "$ENV{'SRCTREE'}" . "/" . "@_";
1760     }
1761     else {
1762         $file = "@_";
1763     }
1764     if (defined($source_map{$file})) {
1765         $file = $source_map{$file};
1766     }
1767
1768     if (!open(IN,"<$file")) {
1769         print STDERR "Error: Cannot open file $file\n";
1770         ++$errors;
1771         return;
1772     }
1773
1774     $section_counter = 0;
1775     while (<IN>) {
1776         if ($state == 0) {
1777             if (/$doc_start/o) {
1778                 $state = 1;             # next line is always the function name
1779                 $in_doc_sect = 0;
1780             }
1781         } elsif ($state == 1) { # this line is the function name (always)
1782             if (/$doc_block/o) {
1783                 $state = 4;
1784                 $contents = "";
1785                 if ( $1 eq "" ) {
1786                         $section = $section_intro;
1787                 } else {
1788                         $section = $1;
1789                 }
1790             }
1791             elsif (/$doc_decl/o) {
1792                 $identifier = $1;
1793                 if (/\s*([\w\s]+?)\s*-/) {
1794                     $identifier = $1;
1795                 }
1796
1797                 $state = 2;
1798                 if (/-(.*)/) {
1799                     # strip leading/trailing/multiple spaces #RDD:T:
1800                     $descr= $1;
1801                     $descr =~ s/^\s*//;
1802                     $descr =~ s/\s*$//;
1803                     $descr =~ s/\s+/ /;
1804                     $declaration_purpose = xml_escape($descr);
1805                 } else {
1806                     $declaration_purpose = "";
1807                 }
1808                 if ($identifier =~ m/^struct/) {
1809                     $decl_type = 'struct';
1810                 } elsif ($identifier =~ m/^union/) {
1811                     $decl_type = 'union';
1812                 } elsif ($identifier =~ m/^enum/) {
1813                     $decl_type = 'enum';
1814                 } elsif ($identifier =~ m/^typedef/) {
1815                     $decl_type = 'typedef';
1816                 } else {
1817                     $decl_type = 'function';
1818                 }
1819
1820                 if ($verbose) {
1821                     print STDERR "Info(${file}:$.): Scanning doc for $identifier\n";
1822                 }
1823             } else {
1824                 print STDERR "Warning(${file}:$.): Cannot understand $_ on line $.",
1825                 " - I thought it was a doc line\n";
1826                 ++$warnings;
1827                 $state = 0;
1828             }
1829         } elsif ($state == 2) { # look for head: lines, and include content
1830             if (/$doc_sect/o) {
1831                 $newsection = $1;
1832                 $newcontents = $2;
1833
1834                 if ($contents ne "") {
1835                     if (!$in_doc_sect && $verbose) {
1836                         print STDERR "Warning(${file}:$.): contents before sections\n";
1837                         ++$warnings;
1838                     }
1839                     dump_section($section, xml_escape($contents));
1840                     $section = $section_default;
1841                 }
1842
1843                 $in_doc_sect = 1;
1844                 $contents = $newcontents;
1845                 if ($contents ne "") {
1846                     while ((substr($contents, 0, 1) eq " ") ||
1847                         substr($contents, 0, 1) eq "\t") {
1848                             $contents = substr($contents, 1);
1849                     }
1850                     $contents .= "\n";
1851                 }
1852                 $section = $newsection;
1853             } elsif (/$doc_end/) {
1854
1855                 if ($contents ne "") {
1856                     dump_section($section, xml_escape($contents));
1857                     $section = $section_default;
1858                     $contents = "";
1859                 }
1860
1861                 $prototype = "";
1862                 $state = 3;
1863                 $brcount = 0;
1864 #               print STDERR "end of doc comment, looking for prototype\n";
1865             } elsif (/$doc_content/) {
1866                 # miguel-style comment kludge, look for blank lines after
1867                 # @parameter line to signify start of description
1868                 if ($1 eq "" &&
1869                         ($section =~ m/^@/ || $section eq $section_context)) {
1870                     dump_section($section, xml_escape($contents));
1871                     $section = $section_default;
1872                     $contents = "";
1873                 } else {
1874                     $contents .= $1."\n";
1875                 }
1876             } else {
1877                 # i dont know - bad line?  ignore.
1878                 print STDERR "Warning(${file}:$.): bad line: $_";
1879                 ++$warnings;
1880             }
1881         } elsif ($state == 3) { # scanning for function '{' (end of prototype)
1882             if ($decl_type eq 'function') {
1883                 process_state3_function($_, $file);
1884             } else {
1885                 process_state3_type($_, $file);
1886             }
1887         } elsif ($state == 4) {
1888                 # Documentation block
1889                 if (/$doc_block/) {
1890                         dump_section($section, $contents);
1891                         output_intro({'sectionlist' => \@sectionlist,
1892                                       'sections' => \%sections });
1893                         $contents = "";
1894                         $function = "";
1895                         %constants = ();
1896                         %parameterdescs = ();
1897                         %parametertypes = ();
1898                         @parameterlist = ();
1899                         %sections = ();
1900                         @sectionlist = ();
1901                         $prototype = "";
1902                         if ( $1 eq "" ) {
1903                                 $section = $section_intro;
1904                         } else {
1905                                 $section = $1;
1906                         }
1907                 }
1908                 elsif (/$doc_end/)
1909                 {
1910                         dump_section($section, $contents);
1911                         output_intro({'sectionlist' => \@sectionlist,
1912                                       'sections' => \%sections });
1913                         $contents = "";
1914                         $function = "";
1915                         %constants = ();
1916                         %parameterdescs = ();
1917                         %parametertypes = ();
1918                         @parameterlist = ();
1919                         %sections = ();
1920                         @sectionlist = ();
1921                         $prototype = "";
1922                         $state = 0;
1923                 }
1924                 elsif (/$doc_content/)
1925                 {
1926                         if ( $1 eq "" )
1927                         {
1928                                 $contents .= $blankline;
1929                         }
1930                         else
1931                         {
1932                                 $contents .= $1 . "\n";
1933                         }
1934                 }
1935         }
1936     }
1937     if ($initial_section_counter == $section_counter) {
1938         print STDERR "Warning(${file}): no structured comments found\n";
1939         if ($output_mode eq "xml") {
1940             # The template wants at least one RefEntry here; make one.
1941             print "<refentry>\n";
1942             print " <refnamediv>\n";
1943             print "  <refname>\n";
1944             print "   ${file}\n";
1945             print "  </refname>\n";
1946             print "  <refpurpose>\n";
1947             print "   Document generation inconsistency\n";
1948             print "  </refpurpose>\n";
1949             print " </refnamediv>\n";
1950             print " <refsect1>\n";
1951             print "  <title>\n";
1952             print "   Oops\n";
1953             print "  </title>\n";
1954             print "  <warning>\n";
1955             print "   <para>\n";
1956             print "    The template for this document tried to insert\n";
1957             print "    the structured comment from the file\n";
1958             print "    <filename>${file}</filename> at this point,\n";
1959             print "    but none was found.\n";
1960             print "    This dummy section is inserted to allow\n";
1961             print "    generation to continue.\n";
1962             print "   </para>\n";
1963             print "  </warning>\n";
1964             print " </refsect1>\n";
1965             print "</refentry>\n";
1966         }
1967     }
1968 }