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