kernel-doc (70a02f840c5113cd9255ce4c1b1848bb48b0bd21) kernel-doc (85afe608f5f3c10134e94c8aa87d9f9eecd81622)
1#!/usr/bin/env perl
2
3use warnings;
4use strict;
5
6## Copyright (c) 1998 Michael Zucchi, All Rights Reserved ##
7## Copyright (C) 2000, 1 Tim Waugh <twaugh@redhat.com> ##
8## Copyright (C) 2001 Simon Huggins ##

--- 34 unchanged lines hidden (view full) ---

43sub usage {
44 my $message = <<"EOF";
45Usage: $0 [OPTION ...] FILE ...
46
47Read C language source or header FILEs, extract embedded documentation comments,
48and print formatted documentation to standard output.
49
50The documentation comments are identified by "/**" opening comment mark. See
1#!/usr/bin/env perl
2
3use warnings;
4use strict;
5
6## Copyright (c) 1998 Michael Zucchi, All Rights Reserved ##
7## Copyright (C) 2000, 1 Tim Waugh <twaugh@redhat.com> ##
8## Copyright (C) 2001 Simon Huggins ##

--- 34 unchanged lines hidden (view full) ---

43sub usage {
44 my $message = <<"EOF";
45Usage: $0 [OPTION ...] FILE ...
46
47Read C language source or header FILEs, extract embedded documentation comments,
48and print formatted documentation to standard output.
49
50The documentation comments are identified by "/**" opening comment mark. See
51Documentation/kernel-doc-nano-HOWTO.txt for the documentation comment syntax.
51Documentation/doc-guide/kernel-doc.rst for the documentation comment syntax.
52
53Output format selection (mutually exclusive):
52
53Output format selection (mutually exclusive):
54 -docbook Output DocBook format.
55 -html Output HTML format.
56 -html5 Output HTML5 format.
57 -list Output symbol list format. This is for use by docproc.
58 -man Output troff manual page format. This is the default.
59 -rst Output reStructuredText format.
54 -man Output troff manual page format. This is the default.
55 -rst Output reStructuredText format.
60 -text Output plain text format.
61 -none Do not output documentation, only warnings.
62
63Output selection (mutually exclusive):
64 -export Only output documentation for symbols that have been
65 exported using EXPORT_SYMBOL() or EXPORT_SYMBOL_GPL()
66 in any input FILE or -export-file FILE.
67 -internal Only output documentation for symbols that have NOT been
68 exported using EXPORT_SYMBOL() or EXPORT_SYMBOL_GPL()

--- 142 unchanged lines hidden (view full) ---

211my $errors = 0;
212my $warnings = 0;
213my $anon_struct_union = 0;
214
215# match expressions used to find embedded type information
216my $type_constant = '\b``([^\`]+)``\b';
217my $type_constant2 = '\%([-_\w]+)';
218my $type_func = '(\w+)\(\)';
56 -none Do not output documentation, only warnings.
57
58Output selection (mutually exclusive):
59 -export Only output documentation for symbols that have been
60 exported using EXPORT_SYMBOL() or EXPORT_SYMBOL_GPL()
61 in any input FILE or -export-file FILE.
62 -internal Only output documentation for symbols that have NOT been
63 exported using EXPORT_SYMBOL() or EXPORT_SYMBOL_GPL()

--- 142 unchanged lines hidden (view full) ---

206my $errors = 0;
207my $warnings = 0;
208my $anon_struct_union = 0;
209
210# match expressions used to find embedded type information
211my $type_constant = '\b``([^\`]+)``\b';
212my $type_constant2 = '\%([-_\w]+)';
213my $type_func = '(\w+)\(\)';
219my $type_param = '\@(\w+(\.\.\.)?)';
214my $type_param = '\@(\w*(\.\w+)*(\.\.\.)?)';
220my $type_fp_param = '\@(\w+)\(\)'; # Special RST handling for func ptr params
221my $type_env = '(\$\w+)';
222my $type_enum = '\&(enum\s*([_\w]+))';
223my $type_struct = '\&(struct\s*([_\w]+))';
224my $type_typedef = '\&(typedef\s*([_\w]+))';
225my $type_union = '\&(union\s*([_\w]+))';
226my $type_member = '\&([_\w]+)(\.|->)([_\w]+)';
227my $type_fallback = '\&([_\w]+)';
215my $type_fp_param = '\@(\w+)\(\)'; # Special RST handling for func ptr params
216my $type_env = '(\$\w+)';
217my $type_enum = '\&(enum\s*([_\w]+))';
218my $type_struct = '\&(struct\s*([_\w]+))';
219my $type_typedef = '\&(typedef\s*([_\w]+))';
220my $type_union = '\&(union\s*([_\w]+))';
221my $type_member = '\&([_\w]+)(\.|->)([_\w]+)';
222my $type_fallback = '\&([_\w]+)';
228my $type_enum_xml = '\&amp;(enum\s*([_\w]+))';
229my $type_struct_xml = '\&amp;(struct\s*([_\w]+))';
230my $type_typedef_xml = '\&amp;(typedef\s*([_\w]+))';
231my $type_union_xml = '\&amp;(union\s*([_\w]+))';
232my $type_member_xml = '\&amp;([_\w]+)(\.|-\&gt;)([_\w]+)';
233my $type_fallback_xml = '\&amp([_\w]+)';
234my $type_member_func = $type_member . '\(\)';
235
236# Output conversion substitutions.
237# One for each output format
238
223my $type_member_func = $type_member . '\(\)';
224
225# Output conversion substitutions.
226# One for each output format
227
239# these work fairly well
240my @highlights_html = (
241 [$type_constant, "<i>\$1</i>"],
242 [$type_constant2, "<i>\$1</i>"],
243 [$type_func, "<b>\$1</b>"],
244 [$type_enum_xml, "<i>\$1</i>"],
245 [$type_struct_xml, "<i>\$1</i>"],
246 [$type_typedef_xml, "<i>\$1</i>"],
247 [$type_union_xml, "<i>\$1</i>"],
248 [$type_env, "<b><i>\$1</i></b>"],
249 [$type_param, "<tt><b>\$1</b></tt>"],
250 [$type_member_xml, "<tt><i>\$1</i>\$2\$3</tt>"],
251 [$type_fallback_xml, "<i>\$1</i>"]
252 );
253my $local_lt = "\\\\\\\\lt:";
254my $local_gt = "\\\\\\\\gt:";
255my $blankline_html = $local_lt . "p" . $local_gt; # was "<p>"
256
257# html version 5
258my @highlights_html5 = (
259 [$type_constant, "<span class=\"const\">\$1</span>"],
260 [$type_constant2, "<span class=\"const\">\$1</span>"],
261 [$type_func, "<span class=\"func\">\$1</span>"],
262 [$type_enum_xml, "<span class=\"enum\">\$1</span>"],
263 [$type_struct_xml, "<span class=\"struct\">\$1</span>"],
264 [$type_typedef_xml, "<span class=\"typedef\">\$1</span>"],
265 [$type_union_xml, "<span class=\"union\">\$1</span>"],
266 [$type_env, "<span class=\"env\">\$1</span>"],
267 [$type_param, "<span class=\"param\">\$1</span>]"],
268 [$type_member_xml, "<span class=\"literal\"><span class=\"struct\">\$1</span>\$2<span class=\"member\">\$3</span></span>"],
269 [$type_fallback_xml, "<span class=\"struct\">\$1</span>"]
270 );
271my $blankline_html5 = $local_lt . "br /" . $local_gt;
272
273# XML, docbook format
274my @highlights_xml = (
275 ["([^=])\\\"([^\\\"<]+)\\\"", "\$1<quote>\$2</quote>"],
276 [$type_constant, "<constant>\$1</constant>"],
277 [$type_constant2, "<constant>\$1</constant>"],
278 [$type_enum_xml, "<type>\$1</type>"],
279 [$type_struct_xml, "<structname>\$1</structname>"],
280 [$type_typedef_xml, "<type>\$1</type>"],
281 [$type_union_xml, "<structname>\$1</structname>"],
282 [$type_param, "<parameter>\$1</parameter>"],
283 [$type_func, "<function>\$1</function>"],
284 [$type_env, "<envar>\$1</envar>"],
285 [$type_member_xml, "<literal><structname>\$1</structname>\$2<structfield>\$3</structfield></literal>"],
286 [$type_fallback_xml, "<structname>\$1</structname>"]
287 );
288my $blankline_xml = $local_lt . "/para" . $local_gt . $local_lt . "para" . $local_gt . "\n";
289
290# gnome, docbook format
291my @highlights_gnome = (
292 [$type_constant, "<replaceable class=\"option\">\$1</replaceable>"],
293 [$type_constant2, "<replaceable class=\"option\">\$1</replaceable>"],
294 [$type_func, "<function>\$1</function>"],
295 [$type_enum, "<type>\$1</type>"],
296 [$type_struct, "<structname>\$1</structname>"],
297 [$type_typedef, "<type>\$1</type>"],
298 [$type_union, "<structname>\$1</structname>"],
299 [$type_env, "<envar>\$1</envar>"],
300 [$type_param, "<parameter>\$1</parameter>" ],
301 [$type_member, "<literal><structname>\$1</structname>\$2<structfield>\$3</structfield></literal>"],
302 [$type_fallback, "<structname>\$1</structname>"]
303 );
304my $blankline_gnome = "</para><para>\n";
305
306# these are pretty rough
307my @highlights_man = (
308 [$type_constant, "\$1"],
309 [$type_constant2, "\$1"],
310 [$type_func, "\\\\fB\$1\\\\fP"],
311 [$type_enum, "\\\\fI\$1\\\\fP"],
312 [$type_struct, "\\\\fI\$1\\\\fP"],
313 [$type_typedef, "\\\\fI\$1\\\\fP"],
314 [$type_union, "\\\\fI\$1\\\\fP"],
315 [$type_param, "\\\\fI\$1\\\\fP"],
316 [$type_member, "\\\\fI\$1\$2\$3\\\\fP"],
317 [$type_fallback, "\\\\fI\$1\\\\fP"]
318 );
319my $blankline_man = "";
320
228# these are pretty rough
229my @highlights_man = (
230 [$type_constant, "\$1"],
231 [$type_constant2, "\$1"],
232 [$type_func, "\\\\fB\$1\\\\fP"],
233 [$type_enum, "\\\\fI\$1\\\\fP"],
234 [$type_struct, "\\\\fI\$1\\\\fP"],
235 [$type_typedef, "\\\\fI\$1\\\\fP"],
236 [$type_union, "\\\\fI\$1\\\\fP"],
237 [$type_param, "\\\\fI\$1\\\\fP"],
238 [$type_member, "\\\\fI\$1\$2\$3\\\\fP"],
239 [$type_fallback, "\\\\fI\$1\\\\fP"]
240 );
241my $blankline_man = "";
242
321# text-mode
322my @highlights_text = (
323 [$type_constant, "\$1"],
324 [$type_constant2, "\$1"],
325 [$type_func, "\$1"],
326 [$type_enum, "\$1"],
327 [$type_struct, "\$1"],
328 [$type_typedef, "\$1"],
329 [$type_union, "\$1"],
330 [$type_param, "\$1"],
331 [$type_member, "\$1\$2\$3"],
332 [$type_fallback, "\$1"]
333 );
334my $blankline_text = "";
335
336# rst-mode
337my @highlights_rst = (
338 [$type_constant, "``\$1``"],
339 [$type_constant2, "``\$1``"],
340 # Note: need to escape () to avoid func matching later
341 [$type_member_func, "\\:c\\:type\\:`\$1\$2\$3\\\\(\\\\) <\$1>`"],
342 [$type_member, "\\:c\\:type\\:`\$1\$2\$3 <\$1>`"],
343 [$type_fp_param, "**\$1\\\\(\\\\)**"],
344 [$type_func, "\\:c\\:func\\:`\$1()`"],
345 [$type_enum, "\\:c\\:type\\:`\$1 <\$2>`"],
346 [$type_struct, "\\:c\\:type\\:`\$1 <\$2>`"],
347 [$type_typedef, "\\:c\\:type\\:`\$1 <\$2>`"],
348 [$type_union, "\\:c\\:type\\:`\$1 <\$2>`"],
349 # in rst this can refer to any type
350 [$type_fallback, "\\:c\\:type\\:`\$1`"],
351 [$type_param, "**\$1**"]
352 );
353my $blankline_rst = "\n";
354
243# rst-mode
244my @highlights_rst = (
245 [$type_constant, "``\$1``"],
246 [$type_constant2, "``\$1``"],
247 # Note: need to escape () to avoid func matching later
248 [$type_member_func, "\\:c\\:type\\:`\$1\$2\$3\\\\(\\\\) <\$1>`"],
249 [$type_member, "\\:c\\:type\\:`\$1\$2\$3 <\$1>`"],
250 [$type_fp_param, "**\$1\\\\(\\\\)**"],
251 [$type_func, "\\:c\\:func\\:`\$1()`"],
252 [$type_enum, "\\:c\\:type\\:`\$1 <\$2>`"],
253 [$type_struct, "\\:c\\:type\\:`\$1 <\$2>`"],
254 [$type_typedef, "\\:c\\:type\\:`\$1 <\$2>`"],
255 [$type_union, "\\:c\\:type\\:`\$1 <\$2>`"],
256 # in rst this can refer to any type
257 [$type_fallback, "\\:c\\:type\\:`\$1`"],
258 [$type_param, "**\$1**"]
259 );
260my $blankline_rst = "\n";
261
355# list mode
356my @highlights_list = (
357 [$type_constant, "\$1"],
358 [$type_constant2, "\$1"],
359 [$type_func, "\$1"],
360 [$type_enum, "\$1"],
361 [$type_struct, "\$1"],
362 [$type_typedef, "\$1"],
363 [$type_union, "\$1"],
364 [$type_param, "\$1"],
365 [$type_member, "\$1"],
366 [$type_fallback, "\$1"]
367 );
368my $blankline_list = "";
369
370# read arguments
371if ($#ARGV == -1) {
372 usage();
373}
374
375my $kernelversion;
376my $dohighlight = "";
377
378my $verbose = 0;
262# read arguments
263if ($#ARGV == -1) {
264 usage();
265}
266
267my $kernelversion;
268my $dohighlight = "";
269
270my $verbose = 0;
379my $output_mode = "man";
271my $output_mode = "rst";
380my $output_preformatted = 0;
381my $no_doc_sections = 0;
382my $enable_lineno = 0;
272my $output_preformatted = 0;
273my $no_doc_sections = 0;
274my $enable_lineno = 0;
383my @highlights = @highlights_man;
384my $blankline = $blankline_man;
275my @highlights = @highlights_rst;
276my $blankline = $blankline_rst;
385my $modulename = "Kernel API";
386
387use constant {
388 OUTPUT_ALL => 0, # output all symbols and doc sections
389 OUTPUT_INCLUDE => 1, # output only specified symbols
390 OUTPUT_EXCLUDE => 2, # output everything except specified symbols
391 OUTPUT_EXPORTED => 3, # output exported symbols
392 OUTPUT_INTERNAL => 4, # output non-exported symbols

--- 101 unchanged lines hidden (view full) ---

494my $section = $section_default;
495my $section_context = "Context";
496my $section_return = "Return";
497
498my $undescribed = "-- undescribed --";
499
500reset_state();
501
277my $modulename = "Kernel API";
278
279use constant {
280 OUTPUT_ALL => 0, # output all symbols and doc sections
281 OUTPUT_INCLUDE => 1, # output only specified symbols
282 OUTPUT_EXCLUDE => 2, # output everything except specified symbols
283 OUTPUT_EXPORTED => 3, # output exported symbols
284 OUTPUT_INTERNAL => 4, # output non-exported symbols

--- 101 unchanged lines hidden (view full) ---

386my $section = $section_default;
387my $section_context = "Context";
388my $section_return = "Return";
389
390my $undescribed = "-- undescribed --";
391
392reset_state();
393
502while ($ARGV[0] =~ m/^-(.*)/) {
503 my $cmd = shift @ARGV;
504 if ($cmd eq "-html") {
505 $output_mode = "html";
506 @highlights = @highlights_html;
507 $blankline = $blankline_html;
508 } elsif ($cmd eq "-html5") {
509 $output_mode = "html5";
510 @highlights = @highlights_html5;
511 $blankline = $blankline_html5;
512 } elsif ($cmd eq "-man") {
394while ($ARGV[0] =~ m/^--?(.*)/) {
395 my $cmd = $1;
396 shift @ARGV;
397 if ($cmd eq "man") {
513 $output_mode = "man";
514 @highlights = @highlights_man;
515 $blankline = $blankline_man;
398 $output_mode = "man";
399 @highlights = @highlights_man;
400 $blankline = $blankline_man;
516 } elsif ($cmd eq "-text") {
517 $output_mode = "text";
518 @highlights = @highlights_text;
519 $blankline = $blankline_text;
520 } elsif ($cmd eq "-rst") {
401 } elsif ($cmd eq "rst") {
521 $output_mode = "rst";
522 @highlights = @highlights_rst;
523 $blankline = $blankline_rst;
402 $output_mode = "rst";
403 @highlights = @highlights_rst;
404 $blankline = $blankline_rst;
524 } elsif ($cmd eq "-docbook") {
525 $output_mode = "xml";
526 @highlights = @highlights_xml;
527 $blankline = $blankline_xml;
528 } elsif ($cmd eq "-list") {
529 $output_mode = "list";
530 @highlights = @highlights_list;
531 $blankline = $blankline_list;
532 } elsif ($cmd eq "-gnome") {
533 $output_mode = "gnome";
534 @highlights = @highlights_gnome;
535 $blankline = $blankline_gnome;
536 } elsif ($cmd eq "-none") {
405 } elsif ($cmd eq "none") {
537 $output_mode = "none";
406 $output_mode = "none";
538 } elsif ($cmd eq "-module") { # not needed for XML, inherits from calling document
407 } elsif ($cmd eq "module") { # not needed for XML, inherits from calling document
539 $modulename = shift @ARGV;
408 $modulename = shift @ARGV;
540 } elsif ($cmd eq "-function") { # to only output specific functions
409 } elsif ($cmd eq "function") { # to only output specific functions
541 $output_selection = OUTPUT_INCLUDE;
542 $function = shift @ARGV;
543 $function_table{$function} = 1;
410 $output_selection = OUTPUT_INCLUDE;
411 $function = shift @ARGV;
412 $function_table{$function} = 1;
544 } elsif ($cmd eq "-nofunction") { # output all except specific functions
413 } elsif ($cmd eq "nofunction") { # output all except specific functions
545 $output_selection = OUTPUT_EXCLUDE;
546 $function = shift @ARGV;
547 $function_table{$function} = 1;
414 $output_selection = OUTPUT_EXCLUDE;
415 $function = shift @ARGV;
416 $function_table{$function} = 1;
548 } elsif ($cmd eq "-export") { # only exported symbols
417 } elsif ($cmd eq "export") { # only exported symbols
549 $output_selection = OUTPUT_EXPORTED;
550 %function_table = ();
418 $output_selection = OUTPUT_EXPORTED;
419 %function_table = ();
551 } elsif ($cmd eq "-internal") { # only non-exported symbols
420 } elsif ($cmd eq "internal") { # only non-exported symbols
552 $output_selection = OUTPUT_INTERNAL;
553 %function_table = ();
421 $output_selection = OUTPUT_INTERNAL;
422 %function_table = ();
554 } elsif ($cmd eq "-export-file") {
423 } elsif ($cmd eq "export-file") {
555 my $file = shift @ARGV;
556 push(@export_file_list, $file);
424 my $file = shift @ARGV;
425 push(@export_file_list, $file);
557 } elsif ($cmd eq "-v") {
426 } elsif ($cmd eq "v") {
558 $verbose = 1;
427 $verbose = 1;
559 } elsif (($cmd eq "-h") || ($cmd eq "--help")) {
428 } elsif (($cmd eq "h") || ($cmd eq "help")) {
560 usage();
429 usage();
561 } elsif ($cmd eq '-no-doc-sections') {
430 } elsif ($cmd eq 'no-doc-sections') {
562 $no_doc_sections = 1;
431 $no_doc_sections = 1;
563 } elsif ($cmd eq '-enable-lineno') {
432 } elsif ($cmd eq 'enable-lineno') {
564 $enable_lineno = 1;
433 $enable_lineno = 1;
565 } elsif ($cmd eq '-show-not-found') {
434 } elsif ($cmd eq 'show-not-found') {
566 $show_not_found = 1;
435 $show_not_found = 1;
436 } else {
437 # Unknown argument
438 usage();
567 }
568}
569
570# continue execution near EOF;
571
572# get kernel version from env
573sub get_kernel_version() {
574 my $version = 'unknown kernel version';

--- 90 unchanged lines hidden (view full) ---

665 my $line;
666
667# DEBUG
668# if (!defined $contents) {
669# use Carp;
670# confess "output_highlight got called with no args?\n";
671# }
672
439 }
440}
441
442# continue execution near EOF;
443
444# get kernel version from env
445sub get_kernel_version() {
446 my $version = 'unknown kernel version';

--- 90 unchanged lines hidden (view full) ---

537 my $line;
538
539# DEBUG
540# if (!defined $contents) {
541# use Carp;
542# confess "output_highlight got called with no args?\n";
543# }
544
673 if ($output_mode eq "html" || $output_mode eq "html5" ||
674 $output_mode eq "xml") {
675 $contents = local_unescape($contents);
676 # convert data read & converted thru xml_escape() into &xyz; format:
677 $contents =~ s/\\\\\\/\&/g;
678 }
679# print STDERR "contents b4:$contents\n";
680 eval $dohighlight;
681 die $@ if $@;
682# print STDERR "contents af:$contents\n";
683
545# print STDERR "contents b4:$contents\n";
546 eval $dohighlight;
547 die $@ if $@;
548# print STDERR "contents af:$contents\n";
549
684# strip whitespaces when generating html5
685 if ($output_mode eq "html5") {
686 $contents =~ s/^\s+//;
687 $contents =~ s/\s+$//;
688 }
689 foreach $line (split "\n", $contents) {
690 if (! $output_preformatted) {
691 $line =~ s/^\s*//;
692 }
693 if ($line eq ""){
694 if (! $output_preformatted) {
695 print $lineprefix, local_unescape($blankline);
696 }

--- 4 unchanged lines hidden (view full) ---

701 } else {
702 print $lineprefix, $line;
703 }
704 }
705 print "\n";
706 }
707}
708
550 foreach $line (split "\n", $contents) {
551 if (! $output_preformatted) {
552 $line =~ s/^\s*//;
553 }
554 if ($line eq ""){
555 if (! $output_preformatted) {
556 print $lineprefix, local_unescape($blankline);
557 }

--- 4 unchanged lines hidden (view full) ---

562 } else {
563 print $lineprefix, $line;
564 }
565 }
566 print "\n";
567 }
568}
569
709# output sections in html
710sub output_section_html(%) {
711 my %args = %{$_[0]};
712 my $section;
713
714 foreach $section (@{$args{'sectionlist'}}) {
715 print "<h3>$section</h3>\n";
716 print "<blockquote>\n";
717 output_highlight($args{'sections'}{$section});
718 print "</blockquote>\n";
719 }
720}
721
722# output enum in html
723sub output_enum_html(%) {
724 my %args = %{$_[0]};
725 my ($parameter);
726 my $count;
727 print "<h2>enum " . $args{'enum'} . "</h2>\n";
728
729 print "<b>enum " . $args{'enum'} . "</b> {<br>\n";
730 $count = 0;
731 foreach $parameter (@{$args{'parameterlist'}}) {
732 print " <b>" . $parameter . "</b>";
733 if ($count != $#{$args{'parameterlist'}}) {
734 $count++;
735 print ",\n";
736 }
737 print "<br>";
738 }
739 print "};<br>\n";
740
741 print "<h3>Constants</h3>\n";
742 print "<dl>\n";
743 foreach $parameter (@{$args{'parameterlist'}}) {
744 print "<dt><b>" . $parameter . "</b>\n";
745 print "<dd>";
746 output_highlight($args{'parameterdescs'}{$parameter});
747 }
748 print "</dl>\n";
749 output_section_html(@_);
750 print "<hr>\n";
751}
752
753# output typedef in html
754sub output_typedef_html(%) {
755 my %args = %{$_[0]};
756 my ($parameter);
757 my $count;
758 print "<h2>typedef " . $args{'typedef'} . "</h2>\n";
759
760 print "<b>typedef " . $args{'typedef'} . "</b>\n";
761 output_section_html(@_);
762 print "<hr>\n";
763}
764
765# output struct in html
766sub output_struct_html(%) {
767 my %args = %{$_[0]};
768 my ($parameter);
769
770 print "<h2>" . $args{'type'} . " " . $args{'struct'} . " - " . $args{'purpose'} . "</h2>\n";
771 print "<b>" . $args{'type'} . " " . $args{'struct'} . "</b> {<br>\n";
772 foreach $parameter (@{$args{'parameterlist'}}) {
773 if ($parameter =~ /^#/) {
774 print "$parameter<br>\n";
775 next;
776 }
777 my $parameter_name = $parameter;
778 $parameter_name =~ s/\[.*//;
779
780 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
781 $type = $args{'parametertypes'}{$parameter};
782 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
783 # pointer-to-function
784 print "&nbsp; &nbsp; <i>$1</i><b>$parameter</b>) <i>($2)</i>;<br>\n";
785 } elsif ($type =~ m/^(.*?)\s*(:.*)/) {
786 # bitfield
787 print "&nbsp; &nbsp; <i>$1</i> <b>$parameter</b>$2;<br>\n";
788 } else {
789 print "&nbsp; &nbsp; <i>$type</i> <b>$parameter</b>;<br>\n";
790 }
791 }
792 print "};<br>\n";
793
794 print "<h3>Members</h3>\n";
795 print "<dl>\n";
796 foreach $parameter (@{$args{'parameterlist'}}) {
797 ($parameter =~ /^#/) && next;
798
799 my $parameter_name = $parameter;
800 $parameter_name =~ s/\[.*//;
801
802 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
803 print "<dt><b>" . $parameter . "</b>\n";
804 print "<dd>";
805 output_highlight($args{'parameterdescs'}{$parameter_name});
806 }
807 print "</dl>\n";
808 output_section_html(@_);
809 print "<hr>\n";
810}
811
812# output function in html
813sub output_function_html(%) {
814 my %args = %{$_[0]};
815 my ($parameter, $section);
816 my $count;
817
818 print "<h2>" . $args{'function'} . " - " . $args{'purpose'} . "</h2>\n";
819 print "<i>" . $args{'functiontype'} . "</i>\n";
820 print "<b>" . $args{'function'} . "</b>\n";
821 print "(";
822 $count = 0;
823 foreach $parameter (@{$args{'parameterlist'}}) {
824 $type = $args{'parametertypes'}{$parameter};
825 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
826 # pointer-to-function
827 print "<i>$1</i><b>$parameter</b>) <i>($2)</i>";
828 } else {
829 print "<i>" . $type . "</i> <b>" . $parameter . "</b>";
830 }
831 if ($count != $#{$args{'parameterlist'}}) {
832 $count++;
833 print ",\n";
834 }
835 }
836 print ")\n";
837
838 print "<h3>Arguments</h3>\n";
839 print "<dl>\n";
840 foreach $parameter (@{$args{'parameterlist'}}) {
841 my $parameter_name = $parameter;
842 $parameter_name =~ s/\[.*//;
843
844 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
845 print "<dt><b>" . $parameter . "</b>\n";
846 print "<dd>";
847 output_highlight($args{'parameterdescs'}{$parameter_name});
848 }
849 print "</dl>\n";
850 output_section_html(@_);
851 print "<hr>\n";
852}
853
854# output DOC: block header in html
855sub output_blockhead_html(%) {
856 my %args = %{$_[0]};
857 my ($parameter, $section);
858 my $count;
859
860 foreach $section (@{$args{'sectionlist'}}) {
861 print "<h3>$section</h3>\n";
862 print "<ul>\n";
863 output_highlight($args{'sections'}{$section});
864 print "</ul>\n";
865 }
866 print "<hr>\n";
867}
868
869# output sections in html5
870sub output_section_html5(%) {
871 my %args = %{$_[0]};
872 my $section;
873
874 foreach $section (@{$args{'sectionlist'}}) {
875 print "<section>\n";
876 print "<h1>$section</h1>\n";
877 print "<p>\n";
878 output_highlight($args{'sections'}{$section});
879 print "</p>\n";
880 print "</section>\n";
881 }
882}
883
884# output enum in html5
885sub output_enum_html5(%) {
886 my %args = %{$_[0]};
887 my ($parameter);
888 my $count;
889 my $html5id;
890
891 $html5id = $args{'enum'};
892 $html5id =~ s/[^a-zA-Z0-9\-]+/_/g;
893 print "<article class=\"enum\" id=\"enum:". $html5id . "\">";
894 print "<h1>enum " . $args{'enum'} . "</h1>\n";
895 print "<ol class=\"code\">\n";
896 print "<li>";
897 print "<span class=\"keyword\">enum</span> ";
898 print "<span class=\"identifier\">" . $args{'enum'} . "</span> {";
899 print "</li>\n";
900 $count = 0;
901 foreach $parameter (@{$args{'parameterlist'}}) {
902 print "<li class=\"indent\">";
903 print "<span class=\"param\">" . $parameter . "</span>";
904 if ($count != $#{$args{'parameterlist'}}) {
905 $count++;
906 print ",";
907 }
908 print "</li>\n";
909 }
910 print "<li>};</li>\n";
911 print "</ol>\n";
912
913 print "<section>\n";
914 print "<h1>Constants</h1>\n";
915 print "<dl>\n";
916 foreach $parameter (@{$args{'parameterlist'}}) {
917 print "<dt>" . $parameter . "</dt>\n";
918 print "<dd>";
919 output_highlight($args{'parameterdescs'}{$parameter});
920 print "</dd>\n";
921 }
922 print "</dl>\n";
923 print "</section>\n";
924 output_section_html5(@_);
925 print "</article>\n";
926}
927
928# output typedef in html5
929sub output_typedef_html5(%) {
930 my %args = %{$_[0]};
931 my ($parameter);
932 my $count;
933 my $html5id;
934
935 $html5id = $args{'typedef'};
936 $html5id =~ s/[^a-zA-Z0-9\-]+/_/g;
937 print "<article class=\"typedef\" id=\"typedef:" . $html5id . "\">\n";
938 print "<h1>typedef " . $args{'typedef'} . "</h1>\n";
939
940 print "<ol class=\"code\">\n";
941 print "<li>";
942 print "<span class=\"keyword\">typedef</span> ";
943 print "<span class=\"identifier\">" . $args{'typedef'} . "</span>";
944 print "</li>\n";
945 print "</ol>\n";
946 output_section_html5(@_);
947 print "</article>\n";
948}
949
950# output struct in html5
951sub output_struct_html5(%) {
952 my %args = %{$_[0]};
953 my ($parameter);
954 my $html5id;
955
956 $html5id = $args{'struct'};
957 $html5id =~ s/[^a-zA-Z0-9\-]+/_/g;
958 print "<article class=\"struct\" id=\"struct:" . $html5id . "\">\n";
959 print "<hgroup>\n";
960 print "<h1>" . $args{'type'} . " " . $args{'struct'} . "</h1>";
961 print "<h2>". $args{'purpose'} . "</h2>\n";
962 print "</hgroup>\n";
963 print "<ol class=\"code\">\n";
964 print "<li>";
965 print "<span class=\"type\">" . $args{'type'} . "</span> ";
966 print "<span class=\"identifier\">" . $args{'struct'} . "</span> {";
967 print "</li>\n";
968 foreach $parameter (@{$args{'parameterlist'}}) {
969 print "<li class=\"indent\">";
970 if ($parameter =~ /^#/) {
971 print "<span class=\"param\">" . $parameter ."</span>\n";
972 print "</li>\n";
973 next;
974 }
975 my $parameter_name = $parameter;
976 $parameter_name =~ s/\[.*//;
977
978 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
979 $type = $args{'parametertypes'}{$parameter};
980 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
981 # pointer-to-function
982 print "<span class=\"type\">$1</span> ";
983 print "<span class=\"param\">$parameter</span>";
984 print "<span class=\"type\">)</span> ";
985 print "(<span class=\"args\">$2</span>);";
986 } elsif ($type =~ m/^(.*?)\s*(:.*)/) {
987 # bitfield
988 print "<span class=\"type\">$1</span> ";
989 print "<span class=\"param\">$parameter</span>";
990 print "<span class=\"bits\">$2</span>;";
991 } else {
992 print "<span class=\"type\">$type</span> ";
993 print "<span class=\"param\">$parameter</span>;";
994 }
995 print "</li>\n";
996 }
997 print "<li>};</li>\n";
998 print "</ol>\n";
999
1000 print "<section>\n";
1001 print "<h1>Members</h1>\n";
1002 print "<dl>\n";
1003 foreach $parameter (@{$args{'parameterlist'}}) {
1004 ($parameter =~ /^#/) && next;
1005
1006 my $parameter_name = $parameter;
1007 $parameter_name =~ s/\[.*//;
1008
1009 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
1010 print "<dt>" . $parameter . "</dt>\n";
1011 print "<dd>";
1012 output_highlight($args{'parameterdescs'}{$parameter_name});
1013 print "</dd>\n";
1014 }
1015 print "</dl>\n";
1016 print "</section>\n";
1017 output_section_html5(@_);
1018 print "</article>\n";
1019}
1020
1021# output function in html5
1022sub output_function_html5(%) {
1023 my %args = %{$_[0]};
1024 my ($parameter, $section);
1025 my $count;
1026 my $html5id;
1027
1028 $html5id = $args{'function'};
1029 $html5id =~ s/[^a-zA-Z0-9\-]+/_/g;
1030 print "<article class=\"function\" id=\"func:". $html5id . "\">\n";
1031 print "<hgroup>\n";
1032 print "<h1>" . $args{'function'} . "</h1>";
1033 print "<h2>" . $args{'purpose'} . "</h2>\n";
1034 print "</hgroup>\n";
1035 print "<ol class=\"code\">\n";
1036 print "<li>";
1037 print "<span class=\"type\">" . $args{'functiontype'} . "</span> ";
1038 print "<span class=\"identifier\">" . $args{'function'} . "</span> (";
1039 print "</li>";
1040 $count = 0;
1041 foreach $parameter (@{$args{'parameterlist'}}) {
1042 print "<li class=\"indent\">";
1043 $type = $args{'parametertypes'}{$parameter};
1044 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
1045 # pointer-to-function
1046 print "<span class=\"type\">$1</span> ";
1047 print "<span class=\"param\">$parameter</span>";
1048 print "<span class=\"type\">)</span> ";
1049 print "(<span class=\"args\">$2</span>)";
1050 } else {
1051 print "<span class=\"type\">$type</span> ";
1052 print "<span class=\"param\">$parameter</span>";
1053 }
1054 if ($count != $#{$args{'parameterlist'}}) {
1055 $count++;
1056 print ",";
1057 }
1058 print "</li>\n";
1059 }
1060 print "<li>)</li>\n";
1061 print "</ol>\n";
1062
1063 print "<section>\n";
1064 print "<h1>Arguments</h1>\n";
1065 print "<p>\n";
1066 print "<dl>\n";
1067 foreach $parameter (@{$args{'parameterlist'}}) {
1068 my $parameter_name = $parameter;
1069 $parameter_name =~ s/\[.*//;
1070
1071 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
1072 print "<dt>" . $parameter . "</dt>\n";
1073 print "<dd>";
1074 output_highlight($args{'parameterdescs'}{$parameter_name});
1075 print "</dd>\n";
1076 }
1077 print "</dl>\n";
1078 print "</section>\n";
1079 output_section_html5(@_);
1080 print "</article>\n";
1081}
1082
1083# output DOC: block header in html5
1084sub output_blockhead_html5(%) {
1085 my %args = %{$_[0]};
1086 my ($parameter, $section);
1087 my $count;
1088 my $html5id;
1089
1090 foreach $section (@{$args{'sectionlist'}}) {
1091 $html5id = $section;
1092 $html5id =~ s/[^a-zA-Z0-9\-]+/_/g;
1093 print "<article class=\"doc\" id=\"doc:". $html5id . "\">\n";
1094 print "<h1>$section</h1>\n";
1095 print "<p>\n";
1096 output_highlight($args{'sections'}{$section});
1097 print "</p>\n";
1098 }
1099 print "</article>\n";
1100}
1101
1102sub output_section_xml(%) {
1103 my %args = %{$_[0]};
1104 my $section;
1105 # print out each section
1106 $lineprefix=" ";
1107 foreach $section (@{$args{'sectionlist'}}) {
1108 print "<refsect1>\n";
1109 print "<title>$section</title>\n";
1110 if ($section =~ m/EXAMPLE/i) {
1111 print "<informalexample><programlisting>\n";
1112 $output_preformatted = 1;
1113 } else {
1114 print "<para>\n";
1115 }
1116 output_highlight($args{'sections'}{$section});
1117 $output_preformatted = 0;
1118 if ($section =~ m/EXAMPLE/i) {
1119 print "</programlisting></informalexample>\n";
1120 } else {
1121 print "</para>\n";
1122 }
1123 print "</refsect1>\n";
1124 }
1125}
1126
1127# output function in XML DocBook
1128sub output_function_xml(%) {
1129 my %args = %{$_[0]};
1130 my ($parameter, $section);
1131 my $count;
1132 my $id;
1133
1134 $id = "API-" . $args{'function'};
1135 $id =~ s/[^A-Za-z0-9]/-/g;
1136
1137 print "<refentry id=\"$id\">\n";
1138 print "<refentryinfo>\n";
1139 print " <title>LINUX</title>\n";
1140 print " <productname>Kernel Hackers Manual</productname>\n";
1141 print " <date>$man_date</date>\n";
1142 print "</refentryinfo>\n";
1143 print "<refmeta>\n";
1144 print " <refentrytitle><phrase>" . $args{'function'} . "</phrase></refentrytitle>\n";
1145 print " <manvolnum>9</manvolnum>\n";
1146 print " <refmiscinfo class=\"version\">" . $kernelversion . "</refmiscinfo>\n";
1147 print "</refmeta>\n";
1148 print "<refnamediv>\n";
1149 print " <refname>" . $args{'function'} . "</refname>\n";
1150 print " <refpurpose>\n";
1151 print " ";
1152 output_highlight ($args{'purpose'});
1153 print " </refpurpose>\n";
1154 print "</refnamediv>\n";
1155
1156 print "<refsynopsisdiv>\n";
1157 print " <title>Synopsis</title>\n";
1158 print " <funcsynopsis><funcprototype>\n";
1159 print " <funcdef>" . $args{'functiontype'} . " ";
1160 print "<function>" . $args{'function'} . " </function></funcdef>\n";
1161
1162 $count = 0;
1163 if ($#{$args{'parameterlist'}} >= 0) {
1164 foreach $parameter (@{$args{'parameterlist'}}) {
1165 $type = $args{'parametertypes'}{$parameter};
1166 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
1167 # pointer-to-function
1168 print " <paramdef>$1<parameter>$parameter</parameter>)\n";
1169 print " <funcparams>$2</funcparams></paramdef>\n";
1170 } else {
1171 print " <paramdef>" . $type;
1172 print " <parameter>$parameter</parameter></paramdef>\n";
1173 }
1174 }
1175 } else {
1176 print " <void/>\n";
1177 }
1178 print " </funcprototype></funcsynopsis>\n";
1179 print "</refsynopsisdiv>\n";
1180
1181 # print parameters
1182 print "<refsect1>\n <title>Arguments</title>\n";
1183 if ($#{$args{'parameterlist'}} >= 0) {
1184 print " <variablelist>\n";
1185 foreach $parameter (@{$args{'parameterlist'}}) {
1186 my $parameter_name = $parameter;
1187 $parameter_name =~ s/\[.*//;
1188 $type = $args{'parametertypes'}{$parameter};
1189
1190 print " <varlistentry>\n <term><parameter>$type $parameter</parameter></term>\n";
1191 print " <listitem>\n <para>\n";
1192 $lineprefix=" ";
1193 output_highlight($args{'parameterdescs'}{$parameter_name});
1194 print " </para>\n </listitem>\n </varlistentry>\n";
1195 }
1196 print " </variablelist>\n";
1197 } else {
1198 print " <para>\n None\n </para>\n";
1199 }
1200 print "</refsect1>\n";
1201
1202 output_section_xml(@_);
1203 print "</refentry>\n\n";
1204}
1205
1206# output struct in XML DocBook
1207sub output_struct_xml(%) {
1208 my %args = %{$_[0]};
1209 my ($parameter, $section);
1210 my $id;
1211
1212 $id = "API-struct-" . $args{'struct'};
1213 $id =~ s/[^A-Za-z0-9]/-/g;
1214
1215 print "<refentry id=\"$id\">\n";
1216 print "<refentryinfo>\n";
1217 print " <title>LINUX</title>\n";
1218 print " <productname>Kernel Hackers Manual</productname>\n";
1219 print " <date>$man_date</date>\n";
1220 print "</refentryinfo>\n";
1221 print "<refmeta>\n";
1222 print " <refentrytitle><phrase>" . $args{'type'} . " " . $args{'struct'} . "</phrase></refentrytitle>\n";
1223 print " <manvolnum>9</manvolnum>\n";
1224 print " <refmiscinfo class=\"version\">" . $kernelversion . "</refmiscinfo>\n";
1225 print "</refmeta>\n";
1226 print "<refnamediv>\n";
1227 print " <refname>" . $args{'type'} . " " . $args{'struct'} . "</refname>\n";
1228 print " <refpurpose>\n";
1229 print " ";
1230 output_highlight ($args{'purpose'});
1231 print " </refpurpose>\n";
1232 print "</refnamediv>\n";
1233
1234 print "<refsynopsisdiv>\n";
1235 print " <title>Synopsis</title>\n";
1236 print " <programlisting>\n";
1237 print $args{'type'} . " " . $args{'struct'} . " {\n";
1238 foreach $parameter (@{$args{'parameterlist'}}) {
1239 if ($parameter =~ /^#/) {
1240 my $prm = $parameter;
1241 # convert data read & converted thru xml_escape() into &xyz; format:
1242 # This allows us to have #define macros interspersed in a struct.
1243 $prm =~ s/\\\\\\/\&/g;
1244 print "$prm\n";
1245 next;
1246 }
1247
1248 my $parameter_name = $parameter;
1249 $parameter_name =~ s/\[.*//;
1250
1251 defined($args{'parameterdescs'}{$parameter_name}) || next;
1252 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
1253 $type = $args{'parametertypes'}{$parameter};
1254 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
1255 # pointer-to-function
1256 print " $1 $parameter) ($2);\n";
1257 } elsif ($type =~ m/^(.*?)\s*(:.*)/) {
1258 # bitfield
1259 print " $1 $parameter$2;\n";
1260 } else {
1261 print " " . $type . " " . $parameter . ";\n";
1262 }
1263 }
1264 print "};";
1265 print " </programlisting>\n";
1266 print "</refsynopsisdiv>\n";
1267
1268 print " <refsect1>\n";
1269 print " <title>Members</title>\n";
1270
1271 if ($#{$args{'parameterlist'}} >= 0) {
1272 print " <variablelist>\n";
1273 foreach $parameter (@{$args{'parameterlist'}}) {
1274 ($parameter =~ /^#/) && next;
1275
1276 my $parameter_name = $parameter;
1277 $parameter_name =~ s/\[.*//;
1278
1279 defined($args{'parameterdescs'}{$parameter_name}) || next;
1280 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
1281 $type = $args{'parametertypes'}{$parameter};
1282 print " <varlistentry>";
1283 print " <term><literal>$type $parameter</literal></term>\n";
1284 print " <listitem><para>\n";
1285 output_highlight($args{'parameterdescs'}{$parameter_name});
1286 print " </para></listitem>\n";
1287 print " </varlistentry>\n";
1288 }
1289 print " </variablelist>\n";
1290 } else {
1291 print " <para>\n None\n </para>\n";
1292 }
1293 print " </refsect1>\n";
1294
1295 output_section_xml(@_);
1296
1297 print "</refentry>\n\n";
1298}
1299
1300# output enum in XML DocBook
1301sub output_enum_xml(%) {
1302 my %args = %{$_[0]};
1303 my ($parameter, $section);
1304 my $count;
1305 my $id;
1306
1307 $id = "API-enum-" . $args{'enum'};
1308 $id =~ s/[^A-Za-z0-9]/-/g;
1309
1310 print "<refentry id=\"$id\">\n";
1311 print "<refentryinfo>\n";
1312 print " <title>LINUX</title>\n";
1313 print " <productname>Kernel Hackers Manual</productname>\n";
1314 print " <date>$man_date</date>\n";
1315 print "</refentryinfo>\n";
1316 print "<refmeta>\n";
1317 print " <refentrytitle><phrase>enum " . $args{'enum'} . "</phrase></refentrytitle>\n";
1318 print " <manvolnum>9</manvolnum>\n";
1319 print " <refmiscinfo class=\"version\">" . $kernelversion . "</refmiscinfo>\n";
1320 print "</refmeta>\n";
1321 print "<refnamediv>\n";
1322 print " <refname>enum " . $args{'enum'} . "</refname>\n";
1323 print " <refpurpose>\n";
1324 print " ";
1325 output_highlight ($args{'purpose'});
1326 print " </refpurpose>\n";
1327 print "</refnamediv>\n";
1328
1329 print "<refsynopsisdiv>\n";
1330 print " <title>Synopsis</title>\n";
1331 print " <programlisting>\n";
1332 print "enum " . $args{'enum'} . " {\n";
1333 $count = 0;
1334 foreach $parameter (@{$args{'parameterlist'}}) {
1335 print " $parameter";
1336 if ($count != $#{$args{'parameterlist'}}) {
1337 $count++;
1338 print ",";
1339 }
1340 print "\n";
1341 }
1342 print "};";
1343 print " </programlisting>\n";
1344 print "</refsynopsisdiv>\n";
1345
1346 print "<refsect1>\n";
1347 print " <title>Constants</title>\n";
1348 print " <variablelist>\n";
1349 foreach $parameter (@{$args{'parameterlist'}}) {
1350 my $parameter_name = $parameter;
1351 $parameter_name =~ s/\[.*//;
1352
1353 print " <varlistentry>";
1354 print " <term>$parameter</term>\n";
1355 print " <listitem><para>\n";
1356 output_highlight($args{'parameterdescs'}{$parameter_name});
1357 print " </para></listitem>\n";
1358 print " </varlistentry>\n";
1359 }
1360 print " </variablelist>\n";
1361 print "</refsect1>\n";
1362
1363 output_section_xml(@_);
1364
1365 print "</refentry>\n\n";
1366}
1367
1368# output typedef in XML DocBook
1369sub output_typedef_xml(%) {
1370 my %args = %{$_[0]};
1371 my ($parameter, $section);
1372 my $id;
1373
1374 $id = "API-typedef-" . $args{'typedef'};
1375 $id =~ s/[^A-Za-z0-9]/-/g;
1376
1377 print "<refentry id=\"$id\">\n";
1378 print "<refentryinfo>\n";
1379 print " <title>LINUX</title>\n";
1380 print " <productname>Kernel Hackers Manual</productname>\n";
1381 print " <date>$man_date</date>\n";
1382 print "</refentryinfo>\n";
1383 print "<refmeta>\n";
1384 print " <refentrytitle><phrase>typedef " . $args{'typedef'} . "</phrase></refentrytitle>\n";
1385 print " <manvolnum>9</manvolnum>\n";
1386 print "</refmeta>\n";
1387 print "<refnamediv>\n";
1388 print " <refname>typedef " . $args{'typedef'} . "</refname>\n";
1389 print " <refpurpose>\n";
1390 print " ";
1391 output_highlight ($args{'purpose'});
1392 print " </refpurpose>\n";
1393 print "</refnamediv>\n";
1394
1395 print "<refsynopsisdiv>\n";
1396 print " <title>Synopsis</title>\n";
1397 print " <synopsis>typedef " . $args{'typedef'} . ";</synopsis>\n";
1398 print "</refsynopsisdiv>\n";
1399
1400 output_section_xml(@_);
1401
1402 print "</refentry>\n\n";
1403}
1404
1405# output in XML DocBook
1406sub output_blockhead_xml(%) {
1407 my %args = %{$_[0]};
1408 my ($parameter, $section);
1409 my $count;
1410
1411 my $id = $args{'module'};
1412 $id =~ s/[^A-Za-z0-9]/-/g;
1413
1414 # print out each section
1415 $lineprefix=" ";
1416 foreach $section (@{$args{'sectionlist'}}) {
1417 if (!$args{'content-only'}) {
1418 print "<refsect1>\n <title>$section</title>\n";
1419 }
1420 if ($section =~ m/EXAMPLE/i) {
1421 print "<example><para>\n";
1422 $output_preformatted = 1;
1423 } else {
1424 print "<para>\n";
1425 }
1426 output_highlight($args{'sections'}{$section});
1427 $output_preformatted = 0;
1428 if ($section =~ m/EXAMPLE/i) {
1429 print "</para></example>\n";
1430 } else {
1431 print "</para>";
1432 }
1433 if (!$args{'content-only'}) {
1434 print "\n</refsect1>\n";
1435 }
1436 }
1437
1438 print "\n\n";
1439}
1440
1441# output in XML DocBook
1442sub output_function_gnome {
1443 my %args = %{$_[0]};
1444 my ($parameter, $section);
1445 my $count;
1446 my $id;
1447
1448 $id = $args{'module'} . "-" . $args{'function'};
1449 $id =~ s/[^A-Za-z0-9]/-/g;
1450
1451 print "<sect2>\n";
1452 print " <title id=\"$id\">" . $args{'function'} . "</title>\n";
1453
1454 print " <funcsynopsis>\n";
1455 print " <funcdef>" . $args{'functiontype'} . " ";
1456 print "<function>" . $args{'function'} . " ";
1457 print "</function></funcdef>\n";
1458
1459 $count = 0;
1460 if ($#{$args{'parameterlist'}} >= 0) {
1461 foreach $parameter (@{$args{'parameterlist'}}) {
1462 $type = $args{'parametertypes'}{$parameter};
1463 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
1464 # pointer-to-function
1465 print " <paramdef>$1 <parameter>$parameter</parameter>)\n";
1466 print " <funcparams>$2</funcparams></paramdef>\n";
1467 } else {
1468 print " <paramdef>" . $type;
1469 print " <parameter>$parameter</parameter></paramdef>\n";
1470 }
1471 }
1472 } else {
1473 print " <void>\n";
1474 }
1475 print " </funcsynopsis>\n";
1476 if ($#{$args{'parameterlist'}} >= 0) {
1477 print " <informaltable pgwide=\"1\" frame=\"none\" role=\"params\">\n";
1478 print "<tgroup cols=\"2\">\n";
1479 print "<colspec colwidth=\"2*\">\n";
1480 print "<colspec colwidth=\"8*\">\n";
1481 print "<tbody>\n";
1482 foreach $parameter (@{$args{'parameterlist'}}) {
1483 my $parameter_name = $parameter;
1484 $parameter_name =~ s/\[.*//;
1485
1486 print " <row><entry align=\"right\"><parameter>$parameter</parameter></entry>\n";
1487 print " <entry>\n";
1488 $lineprefix=" ";
1489 output_highlight($args{'parameterdescs'}{$parameter_name});
1490 print " </entry></row>\n";
1491 }
1492 print " </tbody></tgroup></informaltable>\n";
1493 } else {
1494 print " <para>\n None\n </para>\n";
1495 }
1496
1497 # print out each section
1498 $lineprefix=" ";
1499 foreach $section (@{$args{'sectionlist'}}) {
1500 print "<simplesect>\n <title>$section</title>\n";
1501 if ($section =~ m/EXAMPLE/i) {
1502 print "<example><programlisting>\n";
1503 $output_preformatted = 1;
1504 } else {
1505 }
1506 print "<para>\n";
1507 output_highlight($args{'sections'}{$section});
1508 $output_preformatted = 0;
1509 print "</para>\n";
1510 if ($section =~ m/EXAMPLE/i) {
1511 print "</programlisting></example>\n";
1512 } else {
1513 }
1514 print " </simplesect>\n";
1515 }
1516
1517 print "</sect2>\n\n";
1518}
1519
1520##
1521# output function in man
1522sub output_function_man(%) {
1523 my %args = %{$_[0]};
1524 my ($parameter, $section);
1525 my $count;
1526
1527 print ".TH \"$args{'function'}\" 9 \"$args{'function'}\" \"$man_date\" \"Kernel Hacker's Manual\" LINUX\n";

--- 87 unchanged lines hidden (view full) ---

1615 my %args = %{$_[0]};
1616 my ($parameter, $section);
1617
1618 print ".TH \"$args{'module'}\" 9 \"" . $args{'type'} . " " . $args{'struct'} . "\" \"$man_date\" \"API Manual\" LINUX\n";
1619
1620 print ".SH NAME\n";
1621 print $args{'type'} . " " . $args{'struct'} . " \\- " . $args{'purpose'} . "\n";
1622
570##
571# output function in man
572sub output_function_man(%) {
573 my %args = %{$_[0]};
574 my ($parameter, $section);
575 my $count;
576
577 print ".TH \"$args{'function'}\" 9 \"$args{'function'}\" \"$man_date\" \"Kernel Hacker's Manual\" LINUX\n";

--- 87 unchanged lines hidden (view full) ---

665 my %args = %{$_[0]};
666 my ($parameter, $section);
667
668 print ".TH \"$args{'module'}\" 9 \"" . $args{'type'} . " " . $args{'struct'} . "\" \"$man_date\" \"API Manual\" LINUX\n";
669
670 print ".SH NAME\n";
671 print $args{'type'} . " " . $args{'struct'} . " \\- " . $args{'purpose'} . "\n";
672
673 my $declaration = $args{'definition'};
674 $declaration =~ s/\t/ /g;
675 $declaration =~ s/\n/"\n.br\n.BI \"/g;
1623 print ".SH SYNOPSIS\n";
1624 print $args{'type'} . " " . $args{'struct'} . " {\n.br\n";
676 print ".SH SYNOPSIS\n";
677 print $args{'type'} . " " . $args{'struct'} . " {\n.br\n";
678 print ".BI \"$declaration\n};\n.br\n\n";
1625
679
1626 foreach my $parameter (@{$args{'parameterlist'}}) {
1627 if ($parameter =~ /^#/) {
1628 print ".BI \"$parameter\"\n.br\n";
1629 next;
1630 }
1631 my $parameter_name = $parameter;
1632 $parameter_name =~ s/\[.*//;
1633
1634 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
1635 $type = $args{'parametertypes'}{$parameter};
1636 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
1637 # pointer-to-function
1638 print ".BI \" " . $1 . "\" " . $parameter . " \") (" . $2 . ")" . "\"\n;\n";
1639 } elsif ($type =~ m/^(.*?)\s*(:.*)/) {
1640 # bitfield
1641 print ".BI \" " . $1 . "\ \" " . $parameter . $2 . " \"" . "\"\n;\n";
1642 } else {
1643 $type =~ s/([^\*])$/$1 /;
1644 print ".BI \" " . $type . "\" " . $parameter . " \"" . "\"\n;\n";
1645 }
1646 print "\n.br\n";
1647 }
1648 print "};\n.br\n";
1649
1650 print ".SH Members\n";
1651 foreach $parameter (@{$args{'parameterlist'}}) {
1652 ($parameter =~ /^#/) && next;
1653
1654 my $parameter_name = $parameter;
1655 $parameter_name =~ s/\[.*//;
1656
1657 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;

--- 32 unchanged lines hidden (view full) ---

1690
1691 foreach $section (@{$args{'sectionlist'}}) {
1692 print ".SH \"$section\"\n";
1693 output_highlight($args{'sections'}{$section});
1694 }
1695}
1696
1697##
680 print ".SH Members\n";
681 foreach $parameter (@{$args{'parameterlist'}}) {
682 ($parameter =~ /^#/) && next;
683
684 my $parameter_name = $parameter;
685 $parameter_name =~ s/\[.*//;
686
687 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;

--- 32 unchanged lines hidden (view full) ---

720
721 foreach $section (@{$args{'sectionlist'}}) {
722 print ".SH \"$section\"\n";
723 output_highlight($args{'sections'}{$section});
724 }
725}
726
727##
1698# output in text
1699sub output_function_text(%) {
1700 my %args = %{$_[0]};
1701 my ($parameter, $section);
1702 my $start;
1703
1704 print "Name:\n\n";
1705 print $args{'function'} . " - " . $args{'purpose'} . "\n";
1706
1707 print "\nSynopsis:\n\n";
1708 if ($args{'functiontype'} ne "") {
1709 $start = $args{'functiontype'} . " " . $args{'function'} . " (";
1710 } else {
1711 $start = $args{'function'} . " (";
1712 }
1713 print $start;
1714
1715 my $count = 0;
1716 foreach my $parameter (@{$args{'parameterlist'}}) {
1717 $type = $args{'parametertypes'}{$parameter};
1718 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
1719 # pointer-to-function
1720 print $1 . $parameter . ") (" . $2;
1721 } else {
1722 print $type . " " . $parameter;
1723 }
1724 if ($count != $#{$args{'parameterlist'}}) {
1725 $count++;
1726 print ",\n";
1727 print " " x length($start);
1728 } else {
1729 print ");\n\n";
1730 }
1731 }
1732
1733 print "Arguments:\n\n";
1734 foreach $parameter (@{$args{'parameterlist'}}) {
1735 my $parameter_name = $parameter;
1736 $parameter_name =~ s/\[.*//;
1737
1738 print $parameter . "\n\t" . $args{'parameterdescs'}{$parameter_name} . "\n";
1739 }
1740 output_section_text(@_);
1741}
1742
1743#output sections in text
1744sub output_section_text(%) {
1745 my %args = %{$_[0]};
1746 my $section;
1747
1748 print "\n";
1749 foreach $section (@{$args{'sectionlist'}}) {
1750 print "$section:\n\n";
1751 output_highlight($args{'sections'}{$section});
1752 }
1753 print "\n\n";
1754}
1755
1756# output enum in text
1757sub output_enum_text(%) {
1758 my %args = %{$_[0]};
1759 my ($parameter);
1760 my $count;
1761 print "Enum:\n\n";
1762
1763 print "enum " . $args{'enum'} . " - " . $args{'purpose'} . "\n\n";
1764 print "enum " . $args{'enum'} . " {\n";
1765 $count = 0;
1766 foreach $parameter (@{$args{'parameterlist'}}) {
1767 print "\t$parameter";
1768 if ($count != $#{$args{'parameterlist'}}) {
1769 $count++;
1770 print ",";
1771 }
1772 print "\n";
1773 }
1774 print "};\n\n";
1775
1776 print "Constants:\n\n";
1777 foreach $parameter (@{$args{'parameterlist'}}) {
1778 print "$parameter\n\t";
1779 print $args{'parameterdescs'}{$parameter} . "\n";
1780 }
1781
1782 output_section_text(@_);
1783}
1784
1785# output typedef in text
1786sub output_typedef_text(%) {
1787 my %args = %{$_[0]};
1788 my ($parameter);
1789 my $count;
1790 print "Typedef:\n\n";
1791
1792 print "typedef " . $args{'typedef'} . " - " . $args{'purpose'} . "\n";
1793 output_section_text(@_);
1794}
1795
1796# output struct as text
1797sub output_struct_text(%) {
1798 my %args = %{$_[0]};
1799 my ($parameter);
1800
1801 print $args{'type'} . " " . $args{'struct'} . " - " . $args{'purpose'} . "\n\n";
1802 print $args{'type'} . " " . $args{'struct'} . " {\n";
1803 foreach $parameter (@{$args{'parameterlist'}}) {
1804 if ($parameter =~ /^#/) {
1805 print "$parameter\n";
1806 next;
1807 }
1808
1809 my $parameter_name = $parameter;
1810 $parameter_name =~ s/\[.*//;
1811
1812 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
1813 $type = $args{'parametertypes'}{$parameter};
1814 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
1815 # pointer-to-function
1816 print "\t$1 $parameter) ($2);\n";
1817 } elsif ($type =~ m/^(.*?)\s*(:.*)/) {
1818 # bitfield
1819 print "\t$1 $parameter$2;\n";
1820 } else {
1821 print "\t" . $type . " " . $parameter . ";\n";
1822 }
1823 }
1824 print "};\n\n";
1825
1826 print "Members:\n\n";
1827 foreach $parameter (@{$args{'parameterlist'}}) {
1828 ($parameter =~ /^#/) && next;
1829
1830 my $parameter_name = $parameter;
1831 $parameter_name =~ s/\[.*//;
1832
1833 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
1834 print "$parameter\n\t";
1835 print $args{'parameterdescs'}{$parameter_name} . "\n";
1836 }
1837 print "\n";
1838 output_section_text(@_);
1839}
1840
1841sub output_blockhead_text(%) {
1842 my %args = %{$_[0]};
1843 my ($parameter, $section);
1844
1845 foreach $section (@{$args{'sectionlist'}}) {
1846 print " $section:\n";
1847 print " -> ";
1848 output_highlight($args{'sections'}{$section});
1849 }
1850}
1851
1852##
1853# output in restructured text
1854#
1855
1856#
1857# This could use some work; it's used to output the DOC: sections, and
1858# starts by putting out the name of the doc section itself, but that tends
1859# to duplicate a header already in the template file.
1860#

--- 172 unchanged lines hidden (view full) ---

2033 print "\n\n.. c:type:: " . $name . "\n\n";
2034 print_lineno($declaration_start_line);
2035 $lineprefix = " ";
2036 output_highlight_rst($args{'purpose'});
2037 print "\n";
2038
2039 print "**Definition**\n\n";
2040 print "::\n\n";
728# output in restructured text
729#
730
731#
732# This could use some work; it's used to output the DOC: sections, and
733# starts by putting out the name of the doc section itself, but that tends
734# to duplicate a header already in the template file.
735#

--- 172 unchanged lines hidden (view full) ---

908 print "\n\n.. c:type:: " . $name . "\n\n";
909 print_lineno($declaration_start_line);
910 $lineprefix = " ";
911 output_highlight_rst($args{'purpose'});
912 print "\n";
913
914 print "**Definition**\n\n";
915 print "::\n\n";
2041 print " " . $args{'type'} . " " . $args{'struct'} . " {\n";
2042 foreach $parameter (@{$args{'parameterlist'}}) {
2043 if ($parameter =~ /^#/) {
2044 print " " . "$parameter\n";
2045 next;
2046 }
916 my $declaration = $args{'definition'};
917 $declaration =~ s/\t/ /g;
918 print " " . $args{'type'} . " " . $args{'struct'} . " {\n$declaration };\n\n";
2047
919
2048 my $parameter_name = $parameter;
2049 $parameter_name =~ s/\[.*//;
2050
2051 ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next;
2052 $type = $args{'parametertypes'}{$parameter};
2053 if ($type =~ m/([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)/) {
2054 # pointer-to-function
2055 print " $1 $parameter) ($2);\n";
2056 } elsif ($type =~ m/^(.*?)\s*(:.*)/) {
2057 # bitfield
2058 print " $1 $parameter$2;\n";
2059 } else {
2060 print " " . $type . " " . $parameter . ";\n";
2061 }
2062 }
2063 print " };\n\n";
2064
2065 print "**Members**\n\n";
2066 $lineprefix = " ";
2067 foreach $parameter (@{$args{'parameterlist'}}) {
2068 ($parameter =~ /^#/) && next;
2069
2070 my $parameter_name = $parameter;
2071 $parameter_name =~ s/\[.*//;
2072

--- 5 unchanged lines hidden (view full) ---

2078 print "\n";
2079 }
2080 print "\n";
2081
2082 $lineprefix = $oldprefix;
2083 output_section_rst(@_);
2084}
2085
920 print "**Members**\n\n";
921 $lineprefix = " ";
922 foreach $parameter (@{$args{'parameterlist'}}) {
923 ($parameter =~ /^#/) && next;
924
925 my $parameter_name = $parameter;
926 $parameter_name =~ s/\[.*//;
927

--- 5 unchanged lines hidden (view full) ---

933 print "\n";
934 }
935 print "\n";
936
937 $lineprefix = $oldprefix;
938 output_section_rst(@_);
939}
940
2086
2087## list mode output functions
2088
2089sub output_function_list(%) {
2090 my %args = %{$_[0]};
2091
2092 print $args{'function'} . "\n";
2093}
2094
2095# output enum in list
2096sub output_enum_list(%) {
2097 my %args = %{$_[0]};
2098 print $args{'enum'} . "\n";
2099}
2100
2101# output typedef in list
2102sub output_typedef_list(%) {
2103 my %args = %{$_[0]};
2104 print $args{'typedef'} . "\n";
2105}
2106
2107# output struct as list
2108sub output_struct_list(%) {
2109 my %args = %{$_[0]};
2110
2111 print $args{'struct'} . "\n";
2112}
2113
2114sub output_blockhead_list(%) {
2115 my %args = %{$_[0]};
2116 my ($parameter, $section);
2117
2118 foreach $section (@{$args{'sectionlist'}}) {
2119 print "DOC: $section\n";
2120 }
2121}
2122
2123
2124## none mode output functions
2125
2126sub output_function_none(%) {
2127}
2128
2129sub output_enum_none(%) {
2130}
2131

--- 49 unchanged lines hidden (view full) ---

2181
2182sub dump_union($$) {
2183 dump_struct(@_);
2184}
2185
2186sub dump_struct($$) {
2187 my $x = shift;
2188 my $file = shift;
941## none mode output functions
942
943sub output_function_none(%) {
944}
945
946sub output_enum_none(%) {
947}
948

--- 49 unchanged lines hidden (view full) ---

998
999sub dump_union($$) {
1000 dump_struct(@_);
1001}
1002
1003sub dump_struct($$) {
1004 my $x = shift;
1005 my $file = shift;
2189 my $nested;
2190
2191 if ($x =~ /(struct|union)\s+(\w+)\s*{(.*)}/) {
2192 my $decl_type = $1;
2193 $declaration_name = $2;
2194 my $members = $3;
2195
1006
1007 if ($x =~ /(struct|union)\s+(\w+)\s*{(.*)}/) {
1008 my $decl_type = $1;
1009 $declaration_name = $2;
1010 my $members = $3;
1011
2196 # ignore embedded structs or unions
2197 $members =~ s/({.*})//g;
2198 $nested = $1;
2199
2200 # ignore members marked private:
2201 $members =~ s/\/\*\s*private:.*?\/\*\s*public:.*?\*\///gosi;
2202 $members =~ s/\/\*\s*private:.*//gosi;
2203 # strip comments:
2204 $members =~ s/\/\*.*?\*\///gos;
1012 # ignore members marked private:
1013 $members =~ s/\/\*\s*private:.*?\/\*\s*public:.*?\*\///gosi;
1014 $members =~ s/\/\*\s*private:.*//gosi;
1015 # strip comments:
1016 $members =~ s/\/\*.*?\*\///gos;
2205 $nested =~ s/\/\*.*?\*\///gos;
2206 # strip attributes
2207 $members =~ s/__attribute__\s*\(\([a-z,_\*\s\(\)]*\)\)//i;
2208 $members =~ s/__aligned\s*\([^;]*\)//gos;
2209 $members =~ s/\s*CRYPTO_MINALIGN_ATTR//gos;
2210 # replace DECLARE_BITMAP
1017 # strip attributes
1018 $members =~ s/__attribute__\s*\(\([a-z,_\*\s\(\)]*\)\)//i;
1019 $members =~ s/__aligned\s*\([^;]*\)//gos;
1020 $members =~ s/\s*CRYPTO_MINALIGN_ATTR//gos;
1021 # replace DECLARE_BITMAP
2211 $members =~ s/DECLARE_BITMAP\s*\(([^,)]+), ([^,)]+)\)/unsigned long $1\[BITS_TO_LONGS($2)\]/gos;
1022 $members =~ s/DECLARE_BITMAP\s*\(([^,)]+),\s*([^,)]+)\)/unsigned long $1\[BITS_TO_LONGS($2)\]/gos;
2212 # replace DECLARE_HASHTABLE
1023 # replace DECLARE_HASHTABLE
2213 $members =~ s/DECLARE_HASHTABLE\s*\(([^,)]+), ([^,)]+)\)/unsigned long $1\[1 << (($2) - 1)\]/gos;
1024 $members =~ s/DECLARE_HASHTABLE\s*\(([^,)]+),\s*([^,)]+)\)/unsigned long $1\[1 << (($2) - 1)\]/gos;
1025 # replace DECLARE_KFIFO
1026 $members =~ s/DECLARE_KFIFO\s*\(([^,)]+),\s*([^,)]+),\s*([^,)]+)\)/$2 \*$1/gos;
1027 # replace DECLARE_KFIFO_PTR
1028 $members =~ s/DECLARE_KFIFO_PTR\s*\(([^,)]+),\s*([^,)]+)\)/$2 \*$1/gos;
2214
1029
2215 create_parameterlist($members, ';', $file);
2216 check_sections($file, $declaration_name, $decl_type, $sectcheck, $struct_actual, $nested);
1030 my $declaration = $members;
2217
1031
1032 # Split nested struct/union elements as newer ones
1033 while ($members =~ m/(struct|union)([^\{\};]+)\{([^\{\}]*)\}([^\{\}\;]*)\;/) {
1034 my $newmember;
1035 my $maintype = $1;
1036 my $ids = $4;
1037 my $content = $3;
1038 foreach my $id(split /,/, $ids) {
1039 $newmember .= "$maintype $id; ";
1040
1041 $id =~ s/[:\[].*//;
1042 $id =~ s/^\s*\**(\S+)\s*/$1/;
1043 foreach my $arg (split /;/, $content) {
1044 next if ($arg =~ m/^\s*$/);
1045 if ($arg =~ m/^([^\(]+\(\*?\s*)([\w\.]*)(\s*\).*)/) {
1046 # pointer-to-function
1047 my $type = $1;
1048 my $name = $2;
1049 my $extra = $3;
1050 next if (!$name);
1051 if ($id =~ m/^\s*$/) {
1052 # anonymous struct/union
1053 $newmember .= "$type$name$extra; ";
1054 } else {
1055 $newmember .= "$type$id.$name$extra; ";
1056 }
1057 } else {
1058 my $type;
1059 my $names;
1060 $arg =~ s/^\s+//;
1061 $arg =~ s/\s+$//;
1062 # Handle bitmaps
1063 $arg =~ s/:\s*\d+\s*//g;
1064 # Handle arrays
1065 $arg =~ s/\[\S+\]//g;
1066 # The type may have multiple words,
1067 # and multiple IDs can be defined, like:
1068 # const struct foo, *bar, foobar
1069 # So, we remove spaces when parsing the
1070 # names, in order to match just names
1071 # and commas for the names
1072 $arg =~ s/\s*,\s*/,/g;
1073 if ($arg =~ m/(.*)\s+([\S+,]+)/) {
1074 $type = $1;
1075 $names = $2;
1076 } else {
1077 $newmember .= "$arg; ";
1078 next;
1079 }
1080 foreach my $name (split /,/, $names) {
1081 $name =~ s/^\s*\**(\S+)\s*/$1/;
1082 next if (($name =~ m/^\s*$/));
1083 if ($id =~ m/^\s*$/) {
1084 # anonymous struct/union
1085 $newmember .= "$type $name; ";
1086 } else {
1087 $newmember .= "$type $id.$name; ";
1088 }
1089 }
1090 }
1091 }
1092 }
1093 $members =~ s/(struct|union)([^\{\};]+)\{([^\{\}]*)}([^\{\}\;]*)\;/$newmember/;
1094 }
1095
1096 # Ignore other nested elements, like enums
1097 $members =~ s/({[^\{\}]*})//g;
1098
1099 create_parameterlist($members, ';', $file, $declaration_name);
1100 check_sections($file, $declaration_name, $decl_type, $sectcheck, $struct_actual);
1101
1102 # Adjust declaration for better display
1103 $declaration =~ s/([{;])/$1\n/g;
1104 $declaration =~ s/}\s+;/};/g;
1105 # Better handle inlined enums
1106 do {} while ($declaration =~ s/(enum\s+{[^}]+),([^\n])/$1,\n$2/);
1107
1108 my @def_args = split /\n/, $declaration;
1109 my $level = 1;
1110 $declaration = "";
1111 foreach my $clause (@def_args) {
1112 $clause =~ s/^\s+//;
1113 $clause =~ s/\s+$//;
1114 $clause =~ s/\s+/ /;
1115 next if (!$clause);
1116 $level-- if ($clause =~ m/(})/ && $level > 1);
1117 if (!($clause =~ m/^\s*#/)) {
1118 $declaration .= "\t" x $level;
1119 }
1120 $declaration .= "\t" . $clause . "\n";
1121 $level++ if ($clause =~ m/({)/ && !($clause =~m/}/));
1122 }
2218 output_declaration($declaration_name,
2219 'struct',
2220 {'struct' => $declaration_name,
2221 'module' => $modulename,
1123 output_declaration($declaration_name,
1124 'struct',
1125 {'struct' => $declaration_name,
1126 'module' => $modulename,
1127 'definition' => $declaration,
2222 'parameterlist' => \@parameterlist,
2223 'parameterdescs' => \%parameterdescs,
2224 'parametertypes' => \%parametertypes,
2225 'sectionlist' => \@sectionlist,
2226 'sections' => \%sections,
2227 'purpose' => $declaration_purpose,
2228 'type' => $decl_type
2229 });
2230 }
2231 else {
2232 print STDERR "${file}:$.: error: Cannot parse struct or union!\n";
2233 ++$errors;
2234 }
2235}
2236
1128 'parameterlist' => \@parameterlist,
1129 'parameterdescs' => \%parameterdescs,
1130 'parametertypes' => \%parametertypes,
1131 'sectionlist' => \@sectionlist,
1132 'sections' => \%sections,
1133 'purpose' => $declaration_purpose,
1134 'type' => $decl_type
1135 });
1136 }
1137 else {
1138 print STDERR "${file}:$.: error: Cannot parse struct or union!\n";
1139 ++$errors;
1140 }
1141}
1142
1143
1144sub show_warnings($$) {
1145 my $functype = shift;
1146 my $name = shift;
1147
1148 return 1 if ($output_selection == OUTPUT_ALL);
1149
1150 if ($output_selection == OUTPUT_EXPORTED) {
1151 if (defined($function_table{$name})) {
1152 return 1;
1153 } else {
1154 return 0;
1155 }
1156 }
1157 if ($output_selection == OUTPUT_INTERNAL) {
1158 if (!($functype eq "function" && defined($function_table{$name}))) {
1159 return 1;
1160 } else {
1161 return 0;
1162 }
1163 }
1164 if ($output_selection == OUTPUT_INCLUDE) {
1165 if (defined($function_table{$name})) {
1166 return 1;
1167 } else {
1168 return 0;
1169 }
1170 }
1171 if ($output_selection == OUTPUT_EXCLUDE) {
1172 if (!defined($function_table{$name})) {
1173 return 1;
1174 } else {
1175 return 0;
1176 }
1177 }
1178 die("Please add the new output type at show_warnings()");
1179}
1180
2237sub dump_enum($$) {
2238 my $x = shift;
2239 my $file = shift;
2240
2241 $x =~ s@/\*.*?\*/@@gos; # strip comments.
2242 # strip #define macros inside enums
2243 $x =~ s@#\s*((define|ifdef)\s+|endif)[^;]*;@@gos;
2244

--- 4 unchanged lines hidden (view full) ---

2249
2250 $members =~ s/\s+$//;
2251
2252 foreach my $arg (split ',', $members) {
2253 $arg =~ s/^\s*(\w+).*/$1/;
2254 push @parameterlist, $arg;
2255 if (!$parameterdescs{$arg}) {
2256 $parameterdescs{$arg} = $undescribed;
1181sub dump_enum($$) {
1182 my $x = shift;
1183 my $file = shift;
1184
1185 $x =~ s@/\*.*?\*/@@gos; # strip comments.
1186 # strip #define macros inside enums
1187 $x =~ s@#\s*((define|ifdef)\s+|endif)[^;]*;@@gos;
1188

--- 4 unchanged lines hidden (view full) ---

1193
1194 $members =~ s/\s+$//;
1195
1196 foreach my $arg (split ',', $members) {
1197 $arg =~ s/^\s*(\w+).*/$1/;
1198 push @parameterlist, $arg;
1199 if (!$parameterdescs{$arg}) {
1200 $parameterdescs{$arg} = $undescribed;
2257 print STDERR "${file}:$.: warning: Enum value '$arg' ".
2258 "not described in enum '$declaration_name'\n";
1201 if (show_warnings("enum", $declaration_name)) {
1202 print STDERR "${file}:$.: warning: Enum value '$arg' not described in enum '$declaration_name'\n";
1203 }
2259 }
2260 $_members{$arg} = 1;
2261 }
2262
2263 while (my ($k, $v) = each %parameterdescs) {
2264 if (!exists($_members{$k})) {
1204 }
1205 $_members{$arg} = 1;
1206 }
1207
1208 while (my ($k, $v) = each %parameterdescs) {
1209 if (!exists($_members{$k})) {
2265 print STDERR "${file}:$.: warning: Excess enum value " .
2266 "'$k' description in '$declaration_name'\n";
1210 if (show_warnings("enum", $declaration_name)) {
1211 print STDERR "${file}:$.: warning: Excess enum value '$k' description in '$declaration_name'\n";
1212 }
2267 }
2268 }
2269
2270 output_declaration($declaration_name,
2271 'enum',
2272 {'enum' => $declaration_name,
2273 'module' => $modulename,
2274 'parameterlist' => \@parameterlist,

--- 19 unchanged lines hidden (view full) ---

2294 if ($x =~ /typedef\s+(\w+)\s*\(\*\s*(\w\S+)\s*\)\s*\((.*)\);/ ||
2295 $x =~ /typedef\s+(\w+)\s*(\w\S+)\s*\s*\((.*)\);/) {
2296
2297 # Function typedefs
2298 $return_type = $1;
2299 $declaration_name = $2;
2300 my $args = $3;
2301
1213 }
1214 }
1215
1216 output_declaration($declaration_name,
1217 'enum',
1218 {'enum' => $declaration_name,
1219 'module' => $modulename,
1220 'parameterlist' => \@parameterlist,

--- 19 unchanged lines hidden (view full) ---

1240 if ($x =~ /typedef\s+(\w+)\s*\(\*\s*(\w\S+)\s*\)\s*\((.*)\);/ ||
1241 $x =~ /typedef\s+(\w+)\s*(\w\S+)\s*\s*\((.*)\);/) {
1242
1243 # Function typedefs
1244 $return_type = $1;
1245 $declaration_name = $2;
1246 my $args = $3;
1247
2302 create_parameterlist($args, ',', $file);
1248 create_parameterlist($args, ',', $file, $declaration_name);
2303
2304 output_declaration($declaration_name,
2305 'function',
2306 {'function' => $declaration_name,
2307 'typedef' => 1,
2308 'module' => $modulename,
2309 'functiontype' => $return_type,
2310 'parameterlist' => \@parameterlist,

--- 32 unchanged lines hidden (view full) ---

2343sub save_struct_actual($) {
2344 my $actual = shift;
2345
2346 # strip all spaces from the actual param so that it looks like one string item
2347 $actual =~ s/\s*//g;
2348 $struct_actual = $struct_actual . $actual . " ";
2349}
2350
1249
1250 output_declaration($declaration_name,
1251 'function',
1252 {'function' => $declaration_name,
1253 'typedef' => 1,
1254 'module' => $modulename,
1255 'functiontype' => $return_type,
1256 'parameterlist' => \@parameterlist,

--- 32 unchanged lines hidden (view full) ---

1289sub save_struct_actual($) {
1290 my $actual = shift;
1291
1292 # strip all spaces from the actual param so that it looks like one string item
1293 $actual =~ s/\s*//g;
1294 $struct_actual = $struct_actual . $actual . " ";
1295}
1296
2351sub create_parameterlist($$$) {
1297sub create_parameterlist($$$$) {
2352 my $args = shift;
2353 my $splitter = shift;
2354 my $file = shift;
1298 my $args = shift;
1299 my $splitter = shift;
1300 my $file = shift;
1301 my $declaration_name = shift;
2355 my $type;
2356 my $param;
2357
2358 # temporarily replace commas inside function pointer definition
2359 while ($args =~ /(\([^\),]+),/) {
2360 $args =~ s/(\([^\),]+),/$1#/g;
2361 }
2362

--- 8 unchanged lines hidden (view full) ---

2371 if ($arg =~ /^#/) {
2372 # Treat preprocessor directive as a typeless variable just to fill
2373 # corresponding data structures "correctly". Catch it later in
2374 # output_* subs.
2375 push_parameter($arg, "", $file);
2376 } elsif ($arg =~ m/\(.+\)\s*\(/) {
2377 # pointer-to-function
2378 $arg =~ tr/#/,/;
1302 my $type;
1303 my $param;
1304
1305 # temporarily replace commas inside function pointer definition
1306 while ($args =~ /(\([^\),]+),/) {
1307 $args =~ s/(\([^\),]+),/$1#/g;
1308 }
1309

--- 8 unchanged lines hidden (view full) ---

1318 if ($arg =~ /^#/) {
1319 # Treat preprocessor directive as a typeless variable just to fill
1320 # corresponding data structures "correctly". Catch it later in
1321 # output_* subs.
1322 push_parameter($arg, "", $file);
1323 } elsif ($arg =~ m/\(.+\)\s*\(/) {
1324 # pointer-to-function
1325 $arg =~ tr/#/,/;
2379 $arg =~ m/[^\(]+\(\*?\s*(\w*)\s*\)/;
1326 $arg =~ m/[^\(]+\(\*?\s*([\w\.]*)\s*\)/;
2380 $param = $1;
2381 $type = $arg;
2382 $type =~ s/([^\(]+\(\*?)\s*$param/$1/;
2383 save_struct_actual($param);
1327 $param = $1;
1328 $type = $arg;
1329 $type =~ s/([^\(]+\(\*?)\s*$param/$1/;
1330 save_struct_actual($param);
2384 push_parameter($param, $type, $file);
1331 push_parameter($param, $type, $file, $declaration_name);
2385 } elsif ($arg) {
2386 $arg =~ s/\s*:\s*/:/g;
2387 $arg =~ s/\s*\[/\[/g;
2388
2389 my @args = split('\s*,\s*', $arg);
2390 if ($args[0] =~ m/\*/) {
2391 $args[0] =~ s/(\*+)\s*/ $1/;
2392 }

--- 8 unchanged lines hidden (view full) ---

2401 }
2402
2403 unshift(@args, pop @first_arg);
2404 $type = join " ", @first_arg;
2405
2406 foreach $param (@args) {
2407 if ($param =~ m/^(\*+)\s*(.*)/) {
2408 save_struct_actual($2);
1332 } elsif ($arg) {
1333 $arg =~ s/\s*:\s*/:/g;
1334 $arg =~ s/\s*\[/\[/g;
1335
1336 my @args = split('\s*,\s*', $arg);
1337 if ($args[0] =~ m/\*/) {
1338 $args[0] =~ s/(\*+)\s*/ $1/;
1339 }

--- 8 unchanged lines hidden (view full) ---

1348 }
1349
1350 unshift(@args, pop @first_arg);
1351 $type = join " ", @first_arg;
1352
1353 foreach $param (@args) {
1354 if ($param =~ m/^(\*+)\s*(.*)/) {
1355 save_struct_actual($2);
2409 push_parameter($2, "$type $1", $file);
1356 push_parameter($2, "$type $1", $file, $declaration_name);
2410 }
2411 elsif ($param =~ m/(.*?):(\d+)/) {
2412 if ($type ne "") { # skip unnamed bit-fields
2413 save_struct_actual($1);
1357 }
1358 elsif ($param =~ m/(.*?):(\d+)/) {
1359 if ($type ne "") { # skip unnamed bit-fields
1360 save_struct_actual($1);
2414 push_parameter($1, "$type:$2", $file)
1361 push_parameter($1, "$type:$2", $file, $declaration_name)
2415 }
2416 }
2417 else {
2418 save_struct_actual($param);
1362 }
1363 }
1364 else {
1365 save_struct_actual($param);
2419 push_parameter($param, $type, $file);
1366 push_parameter($param, $type, $file, $declaration_name);
2420 }
2421 }
2422 }
2423 }
2424}
2425
1367 }
1368 }
1369 }
1370 }
1371}
1372
2426sub push_parameter($$$) {
1373sub push_parameter($$$$) {
2427 my $param = shift;
2428 my $type = shift;
2429 my $file = shift;
1374 my $param = shift;
1375 my $type = shift;
1376 my $file = shift;
1377 my $declaration_name = shift;
2430
2431 if (($anon_struct_union == 1) && ($type eq "") &&
2432 ($param eq "}")) {
2433 return; # ignore the ending }; from anon. struct/union
2434 }
2435
2436 $anon_struct_union = 0;
2437 $param =~ s/[\[\)].*//;

--- 20 unchanged lines hidden (view full) ---

2458 $param = "{unnamed_" . $param . "}";
2459 $parameterdescs{$param} = "anonymous\n";
2460 $anon_struct_union = 1;
2461 }
2462
2463 # warn if parameter has no description
2464 # (but ignore ones starting with # as these are not parameters
2465 # but inline preprocessor statements);
1378
1379 if (($anon_struct_union == 1) && ($type eq "") &&
1380 ($param eq "}")) {
1381 return; # ignore the ending }; from anon. struct/union
1382 }
1383
1384 $anon_struct_union = 0;
1385 $param =~ s/[\[\)].*//;

--- 20 unchanged lines hidden (view full) ---

1406 $param = "{unnamed_" . $param . "}";
1407 $parameterdescs{$param} = "anonymous\n";
1408 $anon_struct_union = 1;
1409 }
1410
1411 # warn if parameter has no description
1412 # (but ignore ones starting with # as these are not parameters
1413 # but inline preprocessor statements);
2466 # also ignore unnamed structs/unions;
2467 if (!$anon_struct_union) {
1414 # Note: It will also ignore void params and unnamed structs/unions
2468 if (!defined $parameterdescs{$param} && $param !~ /^#/) {
1415 if (!defined $parameterdescs{$param} && $param !~ /^#/) {
1416 $parameterdescs{$param} = $undescribed;
2469
1417
2470 $parameterdescs{$param} = $undescribed;
2471
2472 if (($type eq 'function') || ($type eq 'enum')) {
2473 print STDERR "${file}:$.: warning: Function parameter ".
2474 "or member '$param' not " .
2475 "described in '$declaration_name'\n";
2476 }
2477 print STDERR "${file}:$.: warning:" .
2478 " No description found for parameter '$param'\n";
2479 ++$warnings;
1418 if (show_warnings($type, $declaration_name)) {
1419 print STDERR
1420 "${file}:$.: warning: Function parameter or member '$param' not described in '$declaration_name'\n";
1421 ++$warnings;
1422 }
2480 }
1423 }
2481 }
2482
2483 $param = xml_escape($param);
2484
2485 # strip spaces from $param so that it is one continuous string
2486 # on @parameterlist;
2487 # this fixes a problem where check_sections() cannot find
2488 # a parameter like "addr[6 + 2]" because it actually appears
2489 # as "addr[6", "+", "2]" on the parameter list;
2490 # but it's better to maintain the param string unchanged for output,
2491 # so just weaken the string compare in check_sections() to ignore
2492 # "[blah" in a parameter string;
2493 ###$param =~ s/\s*//g;
2494 push @parameterlist, $param;
2495 $type =~ s/\s\s+/ /g;
2496 $parametertypes{$param} = $type;
2497}
2498
1424
1425 $param = xml_escape($param);
1426
1427 # strip spaces from $param so that it is one continuous string
1428 # on @parameterlist;
1429 # this fixes a problem where check_sections() cannot find
1430 # a parameter like "addr[6 + 2]" because it actually appears
1431 # as "addr[6", "+", "2]" on the parameter list;
1432 # but it's better to maintain the param string unchanged for output,
1433 # so just weaken the string compare in check_sections() to ignore
1434 # "[blah" in a parameter string;
1435 ###$param =~ s/\s*//g;
1436 push @parameterlist, $param;
1437 $type =~ s/\s\s+/ /g;
1438 $parametertypes{$param} = $type;
1439}
1440
2499sub check_sections($$$$$$) {
2500 my ($file, $decl_name, $decl_type, $sectcheck, $prmscheck, $nested) = @_;
1441sub check_sections($$$$$) {
1442 my ($file, $decl_name, $decl_type, $sectcheck, $prmscheck) = @_;
2501 my @sects = split ' ', $sectcheck;
2502 my @prms = split ' ', $prmscheck;
2503 my $err;
2504 my ($px, $sx);
2505 my $prm_clean; # strip trailing "[array size]" and/or beginning "*"
2506
2507 foreach $sx (0 .. $#sects) {
2508 $err = 1;

--- 17 unchanged lines hidden (view full) ---

2526 }
2527 if ($err) {
2528 if ($decl_type eq "function") {
2529 print STDERR "${file}:$.: warning: " .
2530 "Excess function parameter " .
2531 "'$sects[$sx]' " .
2532 "description in '$decl_name'\n";
2533 ++$warnings;
1443 my @sects = split ' ', $sectcheck;
1444 my @prms = split ' ', $prmscheck;
1445 my $err;
1446 my ($px, $sx);
1447 my $prm_clean; # strip trailing "[array size]" and/or beginning "*"
1448
1449 foreach $sx (0 .. $#sects) {
1450 $err = 1;

--- 17 unchanged lines hidden (view full) ---

1468 }
1469 if ($err) {
1470 if ($decl_type eq "function") {
1471 print STDERR "${file}:$.: warning: " .
1472 "Excess function parameter " .
1473 "'$sects[$sx]' " .
1474 "description in '$decl_name'\n";
1475 ++$warnings;
2534 } else {
2535 if ($nested !~ m/\Q$sects[$sx]\E/) {
2536 print STDERR "${file}:$.: warning: " .
2537 "Excess $decl_type member " .
2538 "'$sects[$sx]' " .
2539 "description in '$decl_name'\n";
2540 ++$warnings;
2541 }
2542 }
2543 }
2544 }
2545}
2546
2547##
2548# Checks the section describing the return value of a function.
2549sub check_return_section {

--- 87 unchanged lines hidden (view full) ---

2637 $prototype =~ m/^(\w+\s+\w+\s+\w+\s*\*+)\s*([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/ ||
2638 $prototype =~ m/^(\w+\s+\w+\s+\w+\s+\w+)\s+([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/ ||
2639 $prototype =~ m/^(\w+\s+\w+\s+\w+\s+\w+\s*\*+)\s*([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/ ||
2640 $prototype =~ m/^(\w+\s+\w+\s*\*+\s*\w+\s*\*+\s*)\s*([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/) {
2641 $return_type = $1;
2642 $declaration_name = $2;
2643 my $args = $3;
2644
1476 }
1477 }
1478 }
1479}
1480
1481##
1482# Checks the section describing the return value of a function.
1483sub check_return_section {

--- 87 unchanged lines hidden (view full) ---

1571 $prototype =~ m/^(\w+\s+\w+\s+\w+\s*\*+)\s*([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/ ||
1572 $prototype =~ m/^(\w+\s+\w+\s+\w+\s+\w+)\s+([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/ ||
1573 $prototype =~ m/^(\w+\s+\w+\s+\w+\s+\w+\s*\*+)\s*([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/ ||
1574 $prototype =~ m/^(\w+\s+\w+\s*\*+\s*\w+\s*\*+\s*)\s*([a-zA-Z0-9_~:]+)\s*\(([^\{]*)\)/) {
1575 $return_type = $1;
1576 $declaration_name = $2;
1577 my $args = $3;
1578
2645 create_parameterlist($args, ',', $file);
1579 create_parameterlist($args, ',', $file, $declaration_name);
2646 } else {
2647 print STDERR "${file}:$.: warning: cannot understand function prototype: '$prototype'\n";
2648 return;
2649 }
2650
2651 my $prms = join " ", @parameterlist;
1580 } else {
1581 print STDERR "${file}:$.: warning: cannot understand function prototype: '$prototype'\n";
1582 return;
1583 }
1584
1585 my $prms = join " ", @parameterlist;
2652 check_sections($file, $declaration_name, "function", $sectcheck, $prms, "");
1586 check_sections($file, $declaration_name, "function", $sectcheck, $prms);
2653
2654 # This check emits a lot of warnings at the moment, because many
2655 # functions don't have a 'Return' doc section. So until the number
2656 # of warnings goes sufficiently down, the check is only performed in
2657 # verbose mode.
2658 # TODO: always perform the check.
2659 if ($verbose && !$noret) {
2660 check_return_section($file, $declaration_name, $return_type);

--- 52 unchanged lines hidden (view full) ---

2713 } else {
2714 $prototype = "static inline void trace_$tracepointname($tracepointargs)";
2715 }
2716}
2717
2718sub syscall_munge() {
2719 my $void = 0;
2720
1587
1588 # This check emits a lot of warnings at the moment, because many
1589 # functions don't have a 'Return' doc section. So until the number
1590 # of warnings goes sufficiently down, the check is only performed in
1591 # verbose mode.
1592 # TODO: always perform the check.
1593 if ($verbose && !$noret) {
1594 check_return_section($file, $declaration_name, $return_type);

--- 52 unchanged lines hidden (view full) ---

1647 } else {
1648 $prototype = "static inline void trace_$tracepointname($tracepointargs)";
1649 }
1650}
1651
1652sub syscall_munge() {
1653 my $void = 0;
1654
2721 $prototype =~ s@[\r\n\t]+@ @gos; # strip newlines/CR's/tabs
1655 $prototype =~ s@[\r\n]+@ @gos; # strip newlines/CR's
2722## if ($prototype =~ m/SYSCALL_DEFINE0\s*\(\s*(a-zA-Z0-9_)*\s*\)/) {
2723 if ($prototype =~ m/SYSCALL_DEFINE0/) {
2724 $void = 1;
2725## $prototype = "long sys_$1(void)";
2726 }
2727
2728 $prototype =~ s/SYSCALL_DEFINE.*\(/long sys_/; # fix return type & func name
2729 if ($prototype =~ m/long (sys_.*?),/) {

--- 88 unchanged lines hidden (view full) ---

2818#
2819# however, formatting controls that are generated internally/locally in the
2820# kernel-doc script are not escaped here; instead, they begin life like
2821# $blankline_html (4 of '\' followed by a mnemonic + ':'), then these strings
2822# are converted to their mnemonic-expected output, without the 4 * '\' & ':',
2823# just before actual output; (this is done by local_unescape())
2824sub xml_escape($) {
2825 my $text = shift;
1656## if ($prototype =~ m/SYSCALL_DEFINE0\s*\(\s*(a-zA-Z0-9_)*\s*\)/) {
1657 if ($prototype =~ m/SYSCALL_DEFINE0/) {
1658 $void = 1;
1659## $prototype = "long sys_$1(void)";
1660 }
1661
1662 $prototype =~ s/SYSCALL_DEFINE.*\(/long sys_/; # fix return type & func name
1663 if ($prototype =~ m/long (sys_.*?),/) {

--- 88 unchanged lines hidden (view full) ---

1752#
1753# however, formatting controls that are generated internally/locally in the
1754# kernel-doc script are not escaped here; instead, they begin life like
1755# $blankline_html (4 of '\' followed by a mnemonic + ':'), then these strings
1756# are converted to their mnemonic-expected output, without the 4 * '\' & ':',
1757# just before actual output; (this is done by local_unescape())
1758sub xml_escape($) {
1759 my $text = shift;
2826 if (($output_mode eq "text") || ($output_mode eq "man")) {
1760 if ($output_mode eq "man") {
2827 return $text;
2828 }
2829 $text =~ s/\&/\\\\\\amp;/g;
2830 $text =~ s/\</\\\\\\lt;/g;
2831 $text =~ s/\>/\\\\\\gt;/g;
2832 return $text;
2833}
2834
2835# xml_unescape: reverse the effects of xml_escape
2836sub xml_unescape($) {
2837 my $text = shift;
1761 return $text;
1762 }
1763 $text =~ s/\&/\\\\\\amp;/g;
1764 $text =~ s/\</\\\\\\lt;/g;
1765 $text =~ s/\>/\\\\\\gt;/g;
1766 return $text;
1767}
1768
1769# xml_unescape: reverse the effects of xml_escape
1770sub xml_unescape($) {
1771 my $text = shift;
2838 if (($output_mode eq "text") || ($output_mode eq "man")) {
1772 if ($output_mode eq "man") {
2839 return $text;
2840 }
2841 $text =~ s/\\\\\\amp;/\&/g;
2842 $text =~ s/\\\\\\lt;/</g;
2843 $text =~ s/\\\\\\gt;/>/g;
2844 return $text;
2845}
2846
2847# convert local escape strings to html
2848# local escape strings look like: '\\\\menmonic:' (that's 4 backslashes)
2849sub local_unescape($) {
2850 my $text = shift;
1773 return $text;
1774 }
1775 $text =~ s/\\\\\\amp;/\&/g;
1776 $text =~ s/\\\\\\lt;/</g;
1777 $text =~ s/\\\\\\gt;/>/g;
1778 return $text;
1779}
1780
1781# convert local escape strings to html
1782# local escape strings look like: '\\\\menmonic:' (that's 4 backslashes)
1783sub local_unescape($) {
1784 my $text = shift;
2851 if (($output_mode eq "text") || ($output_mode eq "man")) {
1785 if ($output_mode eq "man") {
2852 return $text;
2853 }
2854 $text =~ s/\\\\\\\\lt:/</g;
2855 $text =~ s/\\\\\\\\gt:/>/g;
2856 return $text;
2857}
2858
2859sub map_filename($) {

--- 52 unchanged lines hidden (view full) ---

2912
2913 $. = 1;
2914
2915 $section_counter = 0;
2916 while (<IN>) {
2917 while (s/\\\s*$//) {
2918 $_ .= <IN>;
2919 }
1786 return $text;
1787 }
1788 $text =~ s/\\\\\\\\lt:/</g;
1789 $text =~ s/\\\\\\\\gt:/>/g;
1790 return $text;
1791}
1792
1793sub map_filename($) {

--- 52 unchanged lines hidden (view full) ---

1846
1847 $. = 1;
1848
1849 $section_counter = 0;
1850 while (<IN>) {
1851 while (s/\\\s*$//) {
1852 $_ .= <IN>;
1853 }
1854 # Replace tabs by spaces
1855 while ($_ =~ s/\t+/' ' x (length($&) * 8 - length($`) % 8)/e) {};
2920 if ($state == STATE_NORMAL) {
2921 if (/$doc_start/o) {
2922 $state = STATE_NAME; # next line is always the function name
2923 $in_doc_sect = 0;
2924 $declaration_start_line = $. + 1;
2925 }
2926 } elsif ($state == STATE_NAME) {# this line is the function name (always)
2927 if (/$doc_block/o) {

--- 83 unchanged lines hidden (view full) ---

3011 dump_section($file, $section, xml_escape($contents));
3012 $section = $section_default;
3013 }
3014
3015 $in_doc_sect = 1;
3016 $in_purpose = 0;
3017 $contents = $newcontents;
3018 $new_start_line = $.;
1856 if ($state == STATE_NORMAL) {
1857 if (/$doc_start/o) {
1858 $state = STATE_NAME; # next line is always the function name
1859 $in_doc_sect = 0;
1860 $declaration_start_line = $. + 1;
1861 }
1862 } elsif ($state == STATE_NAME) {# this line is the function name (always)
1863 if (/$doc_block/o) {

--- 83 unchanged lines hidden (view full) ---

1947 dump_section($file, $section, xml_escape($contents));
1948 $section = $section_default;
1949 }
1950
1951 $in_doc_sect = 1;
1952 $in_purpose = 0;
1953 $contents = $newcontents;
1954 $new_start_line = $.;
3019 while ((substr($contents, 0, 1) eq " ") ||
3020 substr($contents, 0, 1) eq "\t") {
1955 while (substr($contents, 0, 1) eq " ") {
3021 $contents = substr($contents, 1);
3022 }
3023 if ($contents ne "") {
3024 $contents .= "\n";
3025 }
3026 $section = $newsection;
3027 $leading_space = undef;
3028 } elsif (/$doc_end/) {

--- 52 unchanged lines hidden (view full) ---

3081 }
3082 } elsif ($state == STATE_INLINE) { # scanning for inline parameters
3083 # First line (state 1) needs to be a @parameter
3084 if ($inline_doc_state == STATE_INLINE_NAME && /$doc_inline_sect/o) {
3085 $section = $1;
3086 $contents = $2;
3087 $new_start_line = $.;
3088 if ($contents ne "") {
1956 $contents = substr($contents, 1);
1957 }
1958 if ($contents ne "") {
1959 $contents .= "\n";
1960 }
1961 $section = $newsection;
1962 $leading_space = undef;
1963 } elsif (/$doc_end/) {

--- 52 unchanged lines hidden (view full) ---

2016 }
2017 } elsif ($state == STATE_INLINE) { # scanning for inline parameters
2018 # First line (state 1) needs to be a @parameter
2019 if ($inline_doc_state == STATE_INLINE_NAME && /$doc_inline_sect/o) {
2020 $section = $1;
2021 $contents = $2;
2022 $new_start_line = $.;
2023 if ($contents ne "") {
3089 while ((substr($contents, 0, 1) eq " ") ||
3090 substr($contents, 0, 1) eq "\t") {
2024 while (substr($contents, 0, 1) eq " ") {
3091 $contents = substr($contents, 1);
3092 }
3093 $contents .= "\n";
3094 }
3095 $inline_doc_state = STATE_INLINE_TEXT;
3096 # Documentation block end */
3097 } elsif (/$doc_inline_end/) {
3098 if (($contents ne "") && ($contents ne "\n")) {

--- 66 unchanged lines hidden (view full) ---

3165 }
3166 if ($initial_section_counter == $section_counter) {
3167 if ($output_mode ne "none") {
3168 print STDERR "${file}:1: warning: no structured comments found\n";
3169 }
3170 if (($output_selection == OUTPUT_INCLUDE) && ($show_not_found == 1)) {
3171 print STDERR " Was looking for '$_'.\n" for keys %function_table;
3172 }
2025 $contents = substr($contents, 1);
2026 }
2027 $contents .= "\n";
2028 }
2029 $inline_doc_state = STATE_INLINE_TEXT;
2030 # Documentation block end */
2031 } elsif (/$doc_inline_end/) {
2032 if (($contents ne "") && ($contents ne "\n")) {

--- 66 unchanged lines hidden (view full) ---

2099 }
2100 if ($initial_section_counter == $section_counter) {
2101 if ($output_mode ne "none") {
2102 print STDERR "${file}:1: warning: no structured comments found\n";
2103 }
2104 if (($output_selection == OUTPUT_INCLUDE) && ($show_not_found == 1)) {
2105 print STDERR " Was looking for '$_'.\n" for keys %function_table;
2106 }
3173 if ($output_mode eq "xml") {
3174 # The template wants at least one RefEntry here; make one.
3175 print "<refentry>\n";
3176 print " <refnamediv>\n";
3177 print " <refname>\n";
3178 print " ${orig_file}\n";
3179 print " </refname>\n";
3180 print " <refpurpose>\n";
3181 print " Document generation inconsistency\n";
3182 print " </refpurpose>\n";
3183 print " </refnamediv>\n";
3184 print " <refsect1>\n";
3185 print " <title>\n";
3186 print " Oops\n";
3187 print " </title>\n";
3188 print " <warning>\n";
3189 print " <para>\n";
3190 print " The template for this document tried to insert\n";
3191 print " the structured comment from the file\n";
3192 print " <filename>${orig_file}</filename> at this point,\n";
3193 print " but none was found.\n";
3194 print " This dummy section is inserted to allow\n";
3195 print " generation to continue.\n";
3196 print " </para>\n";
3197 print " </warning>\n";
3198 print " </refsect1>\n";
3199 print "</refentry>\n";
3200 }
3201 }
3202}
3203
3204
3205$kernelversion = get_kernel_version();
3206
3207# generate a sequence of code that will splice in highlighting information
3208# using the s// operator.

--- 43 unchanged lines hidden --- 		2107 }
2108}
2109
2110
2111$kernelversion = get_kernel_version();
2112
2113# generate a sequence of code that will splice in highlighting information
2114# using the s// operator.

--- 43 unchanged lines hidden ---