Embedded Freedom
• source navigation • diff markup • identifier search • freetext search •
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-2008 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 = '\\&((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 print " -v : verbose output, more warnings & other info listed\n"; 222 exit 1; 223 } 224 225 # read arguments 226 if ($#ARGV==-1) { 227 usage(); 228 } 229 230 my $verbose = 0; 231 my $output_mode = "man"; 232 my $no_doc_sections = 0; 233 my %highlights = %highlights_man; 234 my $blankline = $blankline_man; 235 my $modulename = "Kernel API"; 236 my $function_only = 0; 237 my $man_date = ('January', 'February', 'March', 'April', 'May', 'June', 238 'July', 'August', 'September', 'October', 239 'November', 'December')[(localtime)[4]] . 240 " " . ((localtime)[5]+1900); 241 242 # Essentially these are globals 243 # They probably want to be tidied up made more localised or summat. 244 # CAVEAT EMPTOR! Some of the others I localised may not want to be which 245 # could cause "use of undefined value" or other bugs. 246 my ($function, %function_table,%parametertypes,$declaration_purpose); 247 my ($type,$declaration_name,$return_type); 248 my ($newsection,$newcontents,$prototype,$filelist, $brcount, %source_map); 249 250 if (defined($ENV{'KBUILD_VERBOSE'})) { 251 $verbose = "$ENV{'KBUILD_VERBOSE'}"; 252 } 253 254 # Generated docbook code is inserted in a template at a point where 255 # docbook v3.1 requires a non-zero sequence of RefEntry's; see: 256 # http://www.oasis-open.org/docbook/documentation/reference/html/refentry.html 257 # We keep track of number of generated entries and generate a dummy 258 # if needs be to ensure the expanded template can be postprocessed 259 # into html. 260 my $section_counter = 0; 261 262 my $lineprefix=""; 263 264 # states 265 # 0 - normal code 266 # 1 - looking for function name 267 # 2 - scanning field start. 268 # 3 - scanning prototype. 269 # 4 - documentation block 270 my $state; 271 my $in_doc_sect; 272 273 #declaration types: can be 274 # 'function', 'struct', 'union', 'enum', 'typedef' 275 my $decl_type; 276 277 my $doc_special = "\@\%\$\&"; 278 279 my $doc_start = '^/\*\*\s*$'; # Allow whitespace at end of comment start. 280 my $doc_end = '\*/'; 281 my $doc_com = '\s*\*\s*'; 282 my $doc_decl = $doc_com.'(\w+)'; 283 my $doc_sect = $doc_com.'(['.$doc_special.']?[\w\s]+):(.*)'; 284 my $doc_content = $doc_com.'(.*)'; 285 my $doc_block = $doc_com.'DOC:\s*(.*)?'; 286 287 my %constants; 288 my %parameterdescs; 289 my @parameterlist; 290 my %sections; 291 my @sectionlist; 292 293 my $contents = ""; 294 my $section_default = "Description"; # default section 295 my $section_intro = "Introduction"; 296 my $section = $section_default; 297 my $section_context = "Context"; 298 299 my $undescribed = "-- undescribed --"; 300 301 reset_state(); 302 303 while ($ARGV[0] =~ m/^-(.*)/) { 304 my $cmd = shift @ARGV; 305 if ($cmd eq "-html") { 306 $output_mode = "html"; 307 %highlights = %highlights_html; 308 $blankline = $blankline_html; 309 } elsif ($cmd eq "-man") { 310 $output_mode = "man"; 311 %highlights = %highlights_man; 312 $blankline = $blankline_man; 313 } elsif ($cmd eq "-text") { 314 $output_mode = "text"; 315 %highlights = %highlights_text; 316 $blankline = $blankline_text; 317 } elsif ($cmd eq "-docbook") { 318 $output_mode = "xml"; 319 %highlights = %highlights_xml; 320 $blankline = $blankline_xml; 321 } elsif ($cmd eq "-gnome") { 322 $output_mode = "gnome"; 323 %highlights = %highlights_gnome; 324 $blankline = $blankline_gnome; 325 } elsif ($cmd eq "-module") { # not needed for XML, inherits from calling document 326 $modulename = shift @ARGV; 327 } elsif ($cmd eq "-function") { # to only output specific functions 328 $function_only = 1; 329 $function = shift @ARGV; 330 $function_table{$function} = 1; 331 } elsif ($cmd eq "-nofunction") { # to only output specific functions 332 $function_only = 2; 333 $function = shift @ARGV; 334 $function_table{$function} = 1; 335 } elsif ($cmd eq "-v") { 336 $verbose = 1; 337 } elsif (($cmd eq "-h") || ($cmd eq "--help")) { 338 usage(); 339 } elsif ($cmd eq '-filelist') { 340 $filelist = shift @ARGV; 341 } elsif ($cmd eq '-no-doc-sections') { 342 $no_doc_sections = 1; 343 } 344 } 345 346 # get kernel version from env 347 sub get_kernel_version() { 348 my $version = 'unknown kernel version'; 349 350 if (defined($ENV{'KERNELVERSION'})) { 351 $version = $ENV{'KERNELVERSION'}; 352 } 353 return $version; 354 } 355 my $kernelversion = get_kernel_version(); 356 357 # generate a sequence of code that will splice in highlighting information 358 # using the s// operator. 359 my $dohighlight = ""; 360 foreach my $pattern (keys %highlights) { 361 # print STDERR "scanning pattern:$pattern, highlight:($highlights{$pattern})\n"; 362 $dohighlight .= "\$contents =~ s:$pattern:$highlights{$pattern}:gs;\n"; 363 } 364 365 ## 366 # dumps section contents to arrays/hashes intended for that purpose. 367 # 368 sub dump_section { 369 my $file = shift; 370 my $name = shift; 371 my $contents = join "\n", @_; 372 373 if ($name =~ m/$type_constant/) { 374 $name = $1; 375 # print STDERR "constant section '$1' = '$contents'\n"; 376 $constants{$name} = $contents; 377 } elsif ($name =~ m/$type_param/) { 378 # print STDERR "parameter def '$1' = '$contents'\n"; 379 $name = $1; 380 $parameterdescs{$name} = $contents; 381 } elsif ($name eq "@\.\.\.") { 382 # print STDERR "parameter def '...' = '$contents'\n"; 383 $name = "..."; 384 $parameterdescs{$name} = $contents; 385 } else { 386 # print STDERR "other section '$name' = '$contents'\n"; 387 if (defined($sections{$name}) && ($sections{$name} ne "")) { 388 print STDERR "Error(${file}:$.): duplicate section name '$name'\n"; 389 ++$errors; 390 } 391 $sections{$name} = $contents; 392 push @sectionlist, $name; 393 } 394 } 395 396 ## 397 # dump DOC: section after checking that it should go out 398 # 399 sub dump_doc_section { 400 my $file = shift; 401 my $name = shift; 402 my $contents = join "\n", @_; 403 404 if ($no_doc_sections) { 405 return; 406 } 407 408 if (($function_only == 0) || 409 ( $function_only == 1 && defined($function_table{$name})) || 410 ( $function_only == 2 && !defined($function_table{$name}))) 411 { 412 dump_section($file, $name, $contents); 413 output_blockhead({'sectionlist' => \@sectionlist, 414 'sections' => \%sections, 415 'module' => $modulename, 416 'content-only' => ($function_only != 0), }); 417 } 418 } 419 420 ## 421 # output function 422 # 423 # parameterdescs, a hash. 424 # function => "function name" 425 # parameterlist => @list of parameters 426 # parameterdescs => %parameter descriptions 427 # sectionlist => @list of sections 428 # sections => %section descriptions 429 # 430 431 sub output_highlight { 432 my $contents = join "\n",@_; 433 my $line; 434 435 # DEBUG 436 # if (!defined $contents) { 437 # use Carp; 438 # confess "output_highlight got called with no args?\n"; 439 # } 440 441 if ($output_mode eq "html" || $output_mode eq "xml") { 442 $contents = local_unescape($contents); 443 # convert data read & converted thru xml_escape() into &xyz; format: 444 $contents =~ s/\\\\\\/&/g; 445 } 446 # print STDERR "contents b4:$contents\n"; 447 eval $dohighlight; 448 die $@ if $@; 449 # print STDERR "contents af:$contents\n"; 450 451 foreach $line (split "\n", $contents) { 452 if ($line eq ""){ 453 print $lineprefix, local_unescape($blankline); 454 } else { 455 $line =~ s/\\\\\\/\&/g; 456 if ($output_mode eq "man" && substr($line, 0, 1) eq ".") { 457 print "\\&$line"; 458 } else { 459 print $lineprefix, $line; 460 } 461 } 462 print "\n"; 463 } 464 } 465 466 #output sections in html 467 sub output_section_html(%) { 468 my %args = %{$_[0]}; 469 my $section; 470 471 foreach $section (@{$args{'sectionlist'}}) { 472 print "<h3>$section</h3>\n"; 473 print "<blockquote>\n"; 474 output_highlight($args{'sections'}{$section}); 475 print "</blockquote>\n"; 476 } 477 } 478 479 # output enum in html 480 sub output_enum_html(%) { 481 my %args = %{$_[0]}; 482 my ($parameter); 483 my $count; 484 print "<h2>enum ".$args{'enum'}."</h2>\n"; 485 486 print "<b>enum ".$args{'enum'}."</b> {<br>\n"; 487 $count = 0; 488 foreach $parameter (@{$args{'parameterlist'}}) { 489 print " <b>".$parameter."</b>"; 490 if ($count != $#{$args{'parameterlist'}}) { 491 $count++; 492 print ",\n"; 493 } 494 print "<br>"; 495 } 496 print "};<br>\n"; 497 498 print "<h3>Constants</h3>\n"; 499 print "<dl>\n"; 500 foreach $parameter (@{$args{'parameterlist'}}) { 501 print "<dt><b>".$parameter."</b>\n"; 502 print "<dd>"; 503 output_highlight($args{'parameterdescs'}{$parameter}); 504 } 505 print "</dl>\n"; 506 output_section_html(@_); 507 print "<hr>\n"; 508 } 509 510 # output typedef in html 511 sub output_typedef_html(%) { 512 my %args = %{$_[0]}; 513 my ($parameter); 514 my $count; 515 print "<h2>typedef ".$args{'typedef'}."</h2>\n"; 516 517 print "<b>typedef ".$args{'typedef'}."</b>\n"; 518 output_section_html(@_); 519 print "<hr>\n"; 520 } 521 522 # output struct in html 523 sub output_struct_html(%) { 524 my %args = %{$_[0]}; 525 my ($parameter); 526 527 print "<h2>".$args{'type'}." ".$args{'struct'}. " - " .$args{'purpose'}."</h2>\n"; 528 print "<b>".$args{'type'}." ".$args{'struct'}."</b> {<br>\n"; 529 foreach $parameter (@{$args{'parameterlist'}}) { 530 if ($parameter =~ /^#/) { 531 print "$parameter<br>\n"; 532 next; 533 } 534 my $parameter_name = $parameter; 535 $parameter_name =~ s/\[.*//; 536 537 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next; 538 $type = $args{'parametertypes'}{$parameter}; 539 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) { 540 # pointer-to-function 541 print " <i>$1</i><b>$parameter</b>) <i>($2)</i>;<br>\n"; 542 } elsif ($type =~ m/^(.*?)\s*(:.*)/) { 543 # bitfield 544 print " <i>$1</i> <b>$parameter</b>$2;<br>\n"; 545 } else { 546 print " <i>$type</i> <b>$parameter</b>;<br>\n"; 547 } 548 } 549 print "};<br>\n"; 550 551 print "<h3>Members</h3>\n"; 552 print "<dl>\n"; 553 foreach $parameter (@{$args{'parameterlist'}}) { 554 ($parameter =~ /^#/) && next; 555 556 my $parameter_name = $parameter; 557 $parameter_name =~ s/\[.*//; 558 559 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next; 560 print "<dt><b>".$parameter."</b>\n"; 561 print "<dd>"; 562 output_highlight($args{'parameterdescs'}{$parameter_name}); 563 } 564 print "</dl>\n"; 565 output_section_html(@_); 566 print "<hr>\n"; 567 } 568 569 # output function in html 570 sub output_function_html(%) { 571 my %args = %{$_[0]}; 572 my ($parameter, $section); 573 my $count; 574 575 print "<h2>" .$args{'function'}." - ".$args{'purpose'}."</h2>\n"; 576 print "<i>".$args{'functiontype'}."</i>\n"; 577 print "<b>".$args{'function'}."</b>\n"; 578 print "("; 579 $count = 0; 580 foreach $parameter (@{$args{'parameterlist'}}) { 581 $type = $args{'parametertypes'}{$parameter}; 582 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) { 583 # pointer-to-function 584 print "<i>$1</i><b>$parameter</b>) <i>($2)</i>"; 585 } else { 586 print "<i>".$type."</i> <b>".$parameter."</b>"; 587 } 588 if ($count != $#{$args{'parameterlist'}}) { 589 $count++; 590 print ",\n"; 591 } 592 } 593 print ")\n"; 594 595 print "<h3>Arguments</h3>\n"; 596 print "<dl>\n"; 597 foreach $parameter (@{$args{'parameterlist'}}) { 598 my $parameter_name = $parameter; 599 $parameter_name =~ s/\[.*//; 600 601 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next; 602 print "<dt><b>".$parameter."</b>\n"; 603 print "<dd>"; 604 output_highlight($args{'parameterdescs'}{$parameter_name}); 605 } 606 print "</dl>\n"; 607 output_section_html(@_); 608 print "<hr>\n"; 609 } 610 611 # output DOC: block header in html 612 sub output_blockhead_html(%) { 613 my %args = %{$_[0]}; 614 my ($parameter, $section); 615 my $count; 616 617 foreach $section (@{$args{'sectionlist'}}) { 618 print "<h3>$section</h3>\n"; 619 print "<ul>\n"; 620 output_highlight($args{'sections'}{$section}); 621 print "</ul>\n"; 622 } 623 print "<hr>\n"; 624 } 625 626 sub output_section_xml(%) { 627 my %args = %{$_[0]}; 628 my $section; 629 # print out each section 630 $lineprefix=" "; 631 foreach $section (@{$args{'sectionlist'}}) { 632 print "<refsect1>\n"; 633 print "<title>$section</title>\n"; 634 if ($section =~ m/EXAMPLE/i) { 635 print "<informalexample><programlisting>\n"; 636 } else { 637 print "<para>\n"; 638 } 639 output_highlight($args{'sections'}{$section}); 640 if ($section =~ m/EXAMPLE/i) { 641 print "</programlisting></informalexample>\n"; 642 } else { 643 print "</para>\n"; 644 } 645 print "</refsect1>\n"; 646 } 647 } 648 649 # output function in XML DocBook 650 sub output_function_xml(%) { 651 my %args = %{$_[0]}; 652 my ($parameter, $section); 653 my $count; 654 my $id; 655 656 $id = "API-".$args{'function'}; 657 $id =~ s/[^A-Za-z0-9]/-/g; 658 659 print "<refentry id=\"$id\">\n"; 660 print "<refentryinfo>\n"; 661 print " <title>LINUX</title>\n"; 662 print " <productname>Kernel Hackers Manual</productname>\n"; 663 print " <date>$man_date</date>\n"; 664 print "</refentryinfo>\n"; 665 print "<refmeta>\n"; 666 print " <refentrytitle><phrase>".$args{'function'}."</phrase></refentrytitle>\n"; 667 print " <manvolnum>9</manvolnum>\n"; 668 print " <refmiscinfo class=\"version\">" . $kernelversion . "</refmiscinfo>\n"; 669 print "</refmeta>\n"; 670 print "<refnamediv>\n"; 671 print " <refname>".$args{'function'}."</refname>\n"; 672 print " <refpurpose>\n"; 673 print " "; 674 output_highlight ($args{'purpose'}); 675 print " </refpurpose>\n"; 676 print "</refnamediv>\n"; 677 678 print "<refsynopsisdiv>\n"; 679 print " <title>Synopsis</title>\n"; 680 print " <funcsynopsis><funcprototype>\n"; 681 print " <funcdef>".$args{'functiontype'}." "; 682 print "<function>".$args{'function'}." </function></funcdef>\n"; 683 684 $count = 0; 685 if ($#{$args{'parameterlist'}} >= 0) { 686 foreach $parameter (@{$args{'parameterlist'}}) { 687 $type = $args{'parametertypes'}{$parameter}; 688 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) { 689 # pointer-to-function 690 print " <paramdef>$1<parameter>$parameter</parameter>)\n"; 691 print " <funcparams>$2</funcparams></paramdef>\n"; 692 } else { 693 print " <paramdef>".$type; 694 print " <parameter>$parameter</parameter></paramdef>\n"; 695 } 696 } 697 } else { 698 print " <void/>\n"; 699 } 700 print " </funcprototype></funcsynopsis>\n"; 701 print "</refsynopsisdiv>\n"; 702 703 # print parameters 704 print "<refsect1>\n <title>Arguments</title>\n"; 705 if ($#{$args{'parameterlist'}} >= 0) { 706 print " <variablelist>\n"; 707 foreach $parameter (@{$args{'parameterlist'}}) { 708 my $parameter_name = $parameter; 709 $parameter_name =~ s/\[.*//; 710 711 print " <varlistentry>\n <term><parameter>$parameter</parameter></term>\n"; 712 print " <listitem>\n <para>\n"; 713 $lineprefix=" "; 714 output_highlight($args{'parameterdescs'}{$parameter_name}); 715 print " </para>\n </listitem>\n </varlistentry>\n"; 716 } 717 print " </variablelist>\n"; 718 } else { 719 print " <para>\n None\n </para>\n"; 720 } 721 print "</refsect1>\n"; 722 723 output_section_xml(@_); 724 print "</refentry>\n\n"; 725 } 726 727 # output struct in XML DocBook 728 sub output_struct_xml(%) { 729 my %args = %{$_[0]}; 730 my ($parameter, $section); 731 my $id; 732 733 $id = "API-struct-".$args{'struct'}; 734 $id =~ s/[^A-Za-z0-9]/-/g; 735 736 print "<refentry id=\"$id\">\n"; 737 print "<refentryinfo>\n"; 738 print " <title>LINUX</title>\n"; 739 print " <productname>Kernel Hackers Manual</productname>\n"; 740 print " <date>$man_date</date>\n"; 741 print "</refentryinfo>\n"; 742 print "<refmeta>\n"; 743 print " <refentrytitle><phrase>".$args{'type'}." ".$args{'struct'}."</phrase></refentrytitle>\n"; 744 print " <manvolnum>9</manvolnum>\n"; 745 print " <refmiscinfo class=\"version\">" . $kernelversion . "</refmiscinfo>\n"; 746 print "</refmeta>\n"; 747 print "<refnamediv>\n"; 748 print " <refname>".$args{'type'}." ".$args{'struct'}."</refname>\n"; 749 print " <refpurpose>\n"; 750 print " "; 751 output_highlight ($args{'purpose'}); 752 print " </refpurpose>\n"; 753 print "</refnamediv>\n"; 754 755 print "<refsynopsisdiv>\n"; 756 print " <title>Synopsis</title>\n"; 757 print " <programlisting>\n"; 758 print $args{'type'}." ".$args{'struct'}." {\n"; 759 foreach $parameter (@{$args{'parameterlist'}}) { 760 if ($parameter =~ /^#/) { 761 print "$parameter\n"; 762 next; 763 } 764 765 my $parameter_name = $parameter; 766 $parameter_name =~ s/\[.*//; 767 768 defined($args{'parameterdescs'}{$parameter_name}) || next; 769 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next; 770 $type = $args{'parametertypes'}{$parameter}; 771 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) { 772 # pointer-to-function 773 print " $1 $parameter) ($2);\n"; 774 } elsif ($type =~ m/^(.*?)\s*(:.*)/) { 775 # bitfield 776 print " $1 $parameter$2;\n"; 777 } else { 778 print " ".$type." ".$parameter.";\n"; 779 } 780 } 781 print "};"; 782 print " </programlisting>\n"; 783 print "</refsynopsisdiv>\n"; 784 785 print " <refsect1>\n"; 786 print " <title>Members</title>\n"; 787 788 if ($#{$args{'parameterlist'}} >= 0) { 789 print " <variablelist>\n"; 790 foreach $parameter (@{$args{'parameterlist'}}) { 791 ($parameter =~ /^#/) && next; 792 793 my $parameter_name = $parameter; 794 $parameter_name =~ s/\[.*//; 795 796 defined($args{'parameterdescs'}{$parameter_name}) || next; 797 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next; 798 print " <varlistentry>"; 799 print " <term>$parameter</term>\n"; 800 print " <listitem><para>\n"; 801 output_highlight($args{'parameterdescs'}{$parameter_name}); 802 print " </para></listitem>\n"; 803 print " </varlistentry>\n"; 804 } 805 print " </variablelist>\n"; 806 } else { 807 print " <para>\n None\n </para>\n"; 808 } 809 print " </refsect1>\n"; 810 811 output_section_xml(@_); 812 813 print "</refentry>\n\n"; 814 } 815 816 # output enum in XML DocBook 817 sub output_enum_xml(%) { 818 my %args = %{$_[0]}; 819 my ($parameter, $section); 820 my $count; 821 my $id; 822 823 $id = "API-enum-".$args{'enum'}; 824 $id =~ s/[^A-Za-z0-9]/-/g; 825 826 print "<refentry id=\"$id\">\n"; 827 print "<refentryinfo>\n"; 828 print " <title>LINUX</title>\n"; 829 print " <productname>Kernel Hackers Manual</productname>\n"; 830 print " <date>$man_date</date>\n"; 831 print "</refentryinfo>\n"; 832 print "<refmeta>\n"; 833 print " <refentrytitle><phrase>enum ".$args{'enum'}."</phrase></refentrytitle>\n"; 834 print " <manvolnum>9</manvolnum>\n"; 835 print " <refmiscinfo class=\"version\">" . $kernelversion . "</refmiscinfo>\n"; 836 print "</refmeta>\n"; 837 print "<refnamediv>\n"; 838 print " <refname>enum ".$args{'enum'}."</refname>\n"; 839 print " <refpurpose>\n"; 840 print " "; 841 output_highlight ($args{'purpose'}); 842 print " </refpurpose>\n"; 843 print "</refnamediv>\n"; 844 845 print "<refsynopsisdiv>\n"; 846 print " <title>Synopsis</title>\n"; 847 print " <programlisting>\n"; 848 print "enum ".$args{'enum'}." {\n"; 849 $count = 0; 850 foreach $parameter (@{$args{'parameterlist'}}) { 851 print " $parameter"; 852 if ($count != $#{$args{'parameterlist'}}) { 853 $count++; 854 print ","; 855 } 856 print "\n"; 857 } 858 print "};"; 859 print " </programlisting>\n"; 860 print "</refsynopsisdiv>\n"; 861 862 print "<refsect1>\n"; 863 print " <title>Constants</title>\n"; 864 print " <variablelist>\n"; 865 foreach $parameter (@{$args{'parameterlist'}}) { 866 my $parameter_name = $parameter; 867 $parameter_name =~ s/\[.*//; 868 869 print " <varlistentry>"; 870 print " <term>$parameter</term>\n"; 871 print " <listitem><para>\n"; 872 output_highlight($args{'parameterdescs'}{$parameter_name}); 873 print " </para></listitem>\n"; 874 print " </varlistentry>\n"; 875 } 876 print " </variablelist>\n"; 877 print "</refsect1>\n"; 878 879 output_section_xml(@_); 880 881 print "</refentry>\n\n"; 882 } 883 884 # output typedef in XML DocBook 885 sub output_typedef_xml(%) { 886 my %args = %{$_[0]}; 887 my ($parameter, $section); 888 my $id; 889 890 $id = "API-typedef-".$args{'typedef'}; 891 $id =~ s/[^A-Za-z0-9]/-/g; 892 893 print "<refentry id=\"$id\">\n"; 894 print "<refentryinfo>\n"; 895 print " <title>LINUX</title>\n"; 896 print " <productname>Kernel Hackers Manual</productname>\n"; 897 print " <date>$man_date</date>\n"; 898 print "</refentryinfo>\n"; 899 print "<refmeta>\n"; 900 print " <refentrytitle><phrase>typedef ".$args{'typedef'}."</phrase></refentrytitle>\n"; 901 print " <manvolnum>9</manvolnum>\n"; 902 print "</refmeta>\n"; 903 print "<refnamediv>\n"; 904 print " <refname>typedef ".$args{'typedef'}."</refname>\n"; 905 print " <refpurpose>\n"; 906 print " "; 907 output_highlight ($args{'purpose'}); 908 print " </refpurpose>\n"; 909 print "</refnamediv>\n"; 910 911 print "<refsynopsisdiv>\n"; 912 print " <title>Synopsis</title>\n"; 913 print " <synopsis>typedef ".$args{'typedef'}.";</synopsis>\n"; 914 print "</refsynopsisdiv>\n"; 915 916 output_section_xml(@_); 917 918 print "</refentry>\n\n"; 919 } 920 921 # output in XML DocBook 922 sub output_blockhead_xml(%) { 923 my %args = %{$_[0]}; 924 my ($parameter, $section); 925 my $count; 926 927 my $id = $args{'module'}; 928 $id =~ s/[^A-Za-z0-9]/-/g; 929 930 # print out each section 931 $lineprefix=" "; 932 foreach $section (@{$args{'sectionlist'}}) { 933 if (!$args{'content-only'}) { 934 print "<refsect1>\n <title>$section</title>\n"; 935 } 936 if ($section =~ m/EXAMPLE/i) { 937 print "<example><para>\n"; 938 } else { 939 print "<para>\n"; 940 } 941 output_highlight($args{'sections'}{$section}); 942 if ($section =~ m/EXAMPLE/i) { 943 print "</para></example>\n"; 944 } else { 945 print "</para>"; 946 } 947 if (!$args{'content-only'}) { 948 print "\n</refsect1>\n"; 949 } 950 } 951 952 print "\n\n"; 953 } 954 955 # output in XML DocBook 956 sub output_function_gnome { 957 my %args = %{$_[0]}; 958 my ($parameter, $section); 959 my $count; 960 my $id; 961 962 $id = $args{'module'}."-".$args{'function'}; 963 $id =~ s/[^A-Za-z0-9]/-/g; 964 965 print "<sect2>\n"; 966 print " <title id=\"$id\">".$args{'function'}."</title>\n"; 967 968 print " <funcsynopsis>\n"; 969 print " <funcdef>".$args{'functiontype'}." "; 970 print "<function>".$args{'function'}." "; 971 print "</function></funcdef>\n"; 972 973 $count = 0; 974 if ($#{$args{'parameterlist'}} >= 0) { 975 foreach $parameter (@{$args{'parameterlist'}}) { 976 $type = $args{'parametertypes'}{$parameter}; 977 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) { 978 # pointer-to-function 979 print " <paramdef>$1 <parameter>$parameter</parameter>)\n"; 980 print " <funcparams>$2</funcparams></paramdef>\n"; 981 } else { 982 print " <paramdef>".$type; 983 print " <parameter>$parameter</parameter></paramdef>\n"; 984 } 985 } 986 } else { 987 print " <void>\n"; 988 } 989 print " </funcsynopsis>\n"; 990 if ($#{$args{'parameterlist'}} >= 0) { 991 print " <informaltable pgwide=\"1\" frame=\"none\" role=\"params\">\n"; 992 print "<tgroup cols=\"2\">\n"; 993 print "<colspec colwidth=\"2*\">\n"; 994 print "<colspec colwidth=\"8*\">\n"; 995 print "<tbody>\n"; 996 foreach $parameter (@{$args{'parameterlist'}}) { 997 my $parameter_name = $parameter; 998 $parameter_name =~ s/\[.*//; 999 1000 print " <row><entry align=\"right\"><parameter>$parameter</parameter></entry>\n"; 1001 print " <entry>\n"; 1002 $lineprefix=" "; 1003 output_highlight($args{'parameterdescs'}{$parameter_name}); 1004 print " </entry></row>\n"; 1005 } 1006 print " </tbody></tgroup></informaltable>\n"; 1007 } else { 1008 print " <para>\n None\n </para>\n"; 1009 } 1010 1011 # print out each section 1012 $lineprefix=" "; 1013 foreach $section (@{$args{'sectionlist'}}) { 1014 print "<simplesect>\n <title>$section</title>\n"; 1015 if ($section =~ m/EXAMPLE/i) { 1016 print "<example><programlisting>\n"; 1017 } else { 1018 } 1019 print "<para>\n"; 1020 output_highlight($args{'sections'}{$section}); 1021 print "</para>\n"; 1022 if ($section =~ m/EXAMPLE/i) { 1023 print "</programlisting></example>\n"; 1024 } else { 1025 } 1026 print " </simplesect>\n"; 1027 } 1028 1029 print "</sect2>\n\n"; 1030 } 1031 1032 ## 1033 # output function in man 1034 sub output_function_man(%) { 1035 my %args = %{$_[0]}; 1036 my ($parameter, $section); 1037 my $count; 1038 1039 print ".TH \"$args{'function'}\" 9 \"$args{'function'}\" \"$man_date\" \"Kernel Hacker's Manual\" LINUX\n"; 1040 1041 print ".SH NAME\n"; 1042 print $args{'function'}." \\- ".$args{'purpose'}."\n"; 1043 1044 print ".SH SYNOPSIS\n"; 1045 if ($args{'functiontype'} ne "") { 1046 print ".B \"".$args{'functiontype'}."\" ".$args{'function'}."\n"; 1047 } else { 1048 print ".B \"".$args{'function'}."\n"; 1049 } 1050 $count = 0; 1051 my $parenth = "("; 1052 my $post = ","; 1053 foreach my $parameter (@{$args{'parameterlist'}}) { 1054 if ($count == $#{$args{'parameterlist'}}) { 1055 $post = ");"; 1056 } 1057 $type = $args{'parametertypes'}{$parameter}; 1058 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) { 1059 # pointer-to-function 1060 print ".BI \"".$parenth.$1."\" ".$parameter." \") (".$2.")".$post."\"\n"; 1061 } else { 1062 $type =~ s/([^\*])$/$1 /; 1063 print ".BI \"".$parenth.$type."\" ".$parameter." \"".$post."\"\n"; 1064 } 1065 $count++; 1066 $parenth = ""; 1067 } 1068 1069 print ".SH ARGUMENTS\n"; 1070 foreach $parameter (@{$args{'parameterlist'}}) { 1071 my $parameter_name = $parameter; 1072 $parameter_name =~ s/\[.*//; 1073 1074 print ".IP \"".$parameter."\" 12\n"; 1075 output_highlight($args{'parameterdescs'}{$parameter_name}); 1076 } 1077 foreach $section (@{$args{'sectionlist'}}) { 1078 print ".SH \"", uc $section, "\"\n"; 1079 output_highlight($args{'sections'}{$section}); 1080 } 1081 } 1082 1083 ## 1084 # output enum in man 1085 sub output_enum_man(%) { 1086 my %args = %{$_[0]}; 1087 my ($parameter, $section); 1088 my $count; 1089 1090 print ".TH \"$args{'module'}\" 9 \"enum $args{'enum'}\" \"$man_date\" \"API Manual\" LINUX\n"; 1091 1092 print ".SH NAME\n"; 1093 print "enum ".$args{'enum'}." \\- ".$args{'purpose'}."\n"; 1094 1095 print ".SH SYNOPSIS\n"; 1096 print "enum ".$args{'enum'}." {\n"; 1097 $count = 0; 1098 foreach my $parameter (@{$args{'parameterlist'}}) { 1099 print ".br\n.BI \" $parameter\"\n"; 1100 if ($count == $#{$args{'parameterlist'}}) { 1101 print "\n};\n"; 1102 last; 1103 } 1104 else { 1105 print ", \n.br\n"; 1106 } 1107 $count++; 1108 } 1109 1110 print ".SH Constants\n"; 1111 foreach $parameter (@{$args{'parameterlist'}}) { 1112 my $parameter_name = $parameter; 1113 $parameter_name =~ s/\[.*//; 1114 1115 print ".IP \"".$parameter."\" 12\n"; 1116 output_highlight($args{'parameterdescs'}{$parameter_name}); 1117 } 1118 foreach $section (@{$args{'sectionlist'}}) { 1119 print ".SH \"$section\"\n"; 1120 output_highlight($args{'sections'}{$section}); 1121 } 1122 } 1123 1124 ## 1125 # output struct in man 1126 sub output_struct_man(%) { 1127 my %args = %{$_[0]}; 1128 my ($parameter, $section); 1129 1130 print ".TH \"$args{'module'}\" 9 \"".$args{'type'}." ".$args{'struct'}."\" \"$man_date\" \"API Manual\" LINUX\n"; 1131 1132 print ".SH NAME\n"; 1133 print $args{'type'}." ".$args{'struct'}." \\- ".$args{'purpose'}."\n"; 1134 1135 print ".SH SYNOPSIS\n"; 1136 print $args{'type'}." ".$args{'struct'}." {\n.br\n"; 1137 1138 foreach my $parameter (@{$args{'parameterlist'}}) { 1139 if ($parameter =~ /^#/) { 1140 print ".BI \"$parameter\"\n.br\n"; 1141 next; 1142 } 1143 my $parameter_name = $parameter; 1144 $parameter_name =~ s/\[.*//; 1145 1146 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next; 1147 $type = $args{'parametertypes'}{$parameter}; 1148 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) { 1149 # pointer-to-function 1150 print ".BI \" ".$1."\" ".$parameter." \") (".$2.")"."\"\n;\n"; 1151 } elsif ($type =~ m/^(.*?)\s*(:.*)/) { 1152 # bitfield 1153 print ".BI \" ".$1."\ \" ".$parameter.$2." \""."\"\n;\n"; 1154 } else { 1155 $type =~ s/([^\*])$/$1 /; 1156 print ".BI \" ".$type."\" ".$parameter." \""."\"\n;\n"; 1157 } 1158 print "\n.br\n"; 1159 } 1160 print "};\n.br\n"; 1161 1162 print ".SH Members\n"; 1163 foreach $parameter (@{$args{'parameterlist'}}) { 1164 ($parameter =~ /^#/) && next; 1165 1166 my $parameter_name = $parameter; 1167 $parameter_name =~ s/\[.*//; 1168 1169 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next; 1170 print ".IP \"".$parameter."\" 12\n"; 1171 output_highlight($args{'parameterdescs'}{$parameter_name}); 1172 } 1173 foreach $section (@{$args{'sectionlist'}}) { 1174 print ".SH \"$section\"\n"; 1175 output_highlight($args{'sections'}{$section}); 1176 } 1177 } 1178 1179 ## 1180 # output typedef in man 1181 sub output_typedef_man(%) { 1182 my %args = %{$_[0]}; 1183 my ($parameter, $section); 1184 1185 print ".TH \"$args{'module'}\" 9 \"$args{'typedef'}\" \"$man_date\" \"API Manual\" LINUX\n"; 1186 1187 print ".SH NAME\n"; 1188 print "typedef ".$args{'typedef'}." \\- ".$args{'purpose'}."\n"; 1189 1190 foreach $section (@{$args{'sectionlist'}}) { 1191 print ".SH \"$section\"\n"; 1192 output_highlight($args{'sections'}{$section}); 1193 } 1194 } 1195 1196 sub output_blockhead_man(%) { 1197 my %args = %{$_[0]}; 1198 my ($parameter, $section); 1199 my $count; 1200 1201 print ".TH \"$args{'module'}\" 9 \"$args{'module'}\" \"$man_date\" \"API Manual\" LINUX\n"; 1202 1203 foreach $section (@{$args{'sectionlist'}}) { 1204 print ".SH \"$section\"\n"; 1205 output_highlight($args{'sections'}{$section}); 1206 } 1207 } 1208 1209 ## 1210 # output in text 1211 sub output_function_text(%) { 1212 my %args = %{$_[0]}; 1213 my ($parameter, $section); 1214 my $start; 1215 1216 print "Name:\n\n"; 1217 print $args{'function'}." - ".$args{'purpose'}."\n"; 1218 1219 print "\nSynopsis:\n\n"; 1220 if ($args{'functiontype'} ne "") { 1221 $start = $args{'functiontype'}." ".$args{'function'}." ("; 1222 } else { 1223 $start = $args{'function'}." ("; 1224 } 1225 print $start; 1226 1227 my $count = 0; 1228 foreach my $parameter (@{$args{'parameterlist'}}) { 1229 $type = $args{'parametertypes'}{$parameter}; 1230 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) { 1231 # pointer-to-function 1232 print $1.$parameter.") (".$2; 1233 } else { 1234 print $type." ".$parameter; 1235 } 1236 if ($count != $#{$args{'parameterlist'}}) { 1237 $count++; 1238 print ",\n"; 1239 print " " x length($start); 1240 } else { 1241 print ");\n\n"; 1242 } 1243 } 1244 1245 print "Arguments:\n\n"; 1246 foreach $parameter (@{$args{'parameterlist'}}) { 1247 my $parameter_name = $parameter; 1248 $parameter_name =~ s/\[.*//; 1249 1250 print $parameter."\n\t".$args{'parameterdescs'}{$parameter_name}."\n"; 1251 } 1252 output_section_text(@_); 1253 } 1254 1255 #output sections in text 1256 sub output_section_text(%) { 1257 my %args = %{$_[0]}; 1258 my $section; 1259 1260 print "\n"; 1261 foreach $section (@{$args{'sectionlist'}}) { 1262 print "$section:\n\n"; 1263 output_highlight($args{'sections'}{$section}); 1264 } 1265 print "\n\n"; 1266 } 1267 1268 # output enum in text 1269 sub output_enum_text(%) { 1270 my %args = %{$_[0]}; 1271 my ($parameter); 1272 my $count; 1273 print "Enum:\n\n"; 1274 1275 print "enum ".$args{'enum'}." - ".$args{'purpose'}."\n\n"; 1276 print "enum ".$args{'enum'}." {\n"; 1277 $count = 0; 1278 foreach $parameter (@{$args{'parameterlist'}}) { 1279 print "\t$parameter"; 1280 if ($count != $#{$args{'parameterlist'}}) { 1281 $count++; 1282 print ","; 1283 } 1284 print "\n"; 1285 } 1286 print "};\n\n"; 1287 1288 print "Constants:\n\n"; 1289 foreach $parameter (@{$args{'parameterlist'}}) { 1290 print "$parameter\n\t"; 1291 print $args{'parameterdescs'}{$parameter}."\n"; 1292 } 1293 1294 output_section_text(@_); 1295 } 1296 1297 # output typedef in text 1298 sub output_typedef_text(%) { 1299 my %args = %{$_[0]}; 1300 my ($parameter); 1301 my $count; 1302 print "Typedef:\n\n"; 1303 1304 print "typedef ".$args{'typedef'}." - ".$args{'purpose'}."\n"; 1305 output_section_text(@_); 1306 } 1307 1308 # output struct as text 1309 sub output_struct_text(%) { 1310 my %args = %{$_[0]}; 1311 my ($parameter); 1312 1313 print $args{'type'}." ".$args{'struct'}." - ".$args{'purpose'}."\n\n"; 1314 print $args{'type'}." ".$args{'struct'}." {\n"; 1315 foreach $parameter (@{$args{'parameterlist'}}) { 1316 if ($parameter =~ /^#/) { 1317 print "$parameter\n"; 1318 next; 1319 } 1320 1321 my $parameter_name = $parameter; 1322 $parameter_name =~ s/\[.*//; 1323 1324 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next; 1325 $type = $args{'parametertypes'}{$parameter}; 1326 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) { 1327 # pointer-to-function 1328 print "\t$1 $parameter) ($2);\n"; 1329 } elsif ($type =~ m/^(.*?)\s*(:.*)/) { 1330 # bitfield 1331 print "\t$1 $parameter$2;\n"; 1332 } else { 1333 print "\t".$type." ".$parameter.";\n"; 1334 } 1335 } 1336 print "};\n\n"; 1337 1338 print "Members:\n\n"; 1339 foreach $parameter (@{$args{'parameterlist'}}) { 1340 ($parameter =~ /^#/) && next; 1341 1342 my $parameter_name = $parameter; 1343 $parameter_name =~ s/\[.*//; 1344 1345 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next; 1346 print "$parameter\n\t"; 1347 print $args{'parameterdescs'}{$parameter_name}."\n"; 1348 } 1349 print "\n"; 1350 output_section_text(@_); 1351 } 1352 1353 sub output_blockhead_text(%) { 1354 my %args = %{$_[0]}; 1355 my ($parameter, $section); 1356 1357 foreach $section (@{$args{'sectionlist'}}) { 1358 print " $section:\n"; 1359 print " -> "; 1360 output_highlight($args{'sections'}{$section}); 1361 } 1362 } 1363 1364 ## 1365 # generic output function for all types (function, struct/union, typedef, enum); 1366 # calls the