2 # Copyright 1999, 2000, 2001 Patrik Stridvall
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License, or (at your option) any later version.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 use vars
qw($VERSION @ISA @EXPORT @EXPORT_OK);
30 use options
qw($options);
31 use output qw($output);
36 # Defined a couple common regexp tidbits
37 my $CALL_CONVENTION="__cdecl|__stdcall|" .
38 "__RPC_API|__RPC_STUB|__RPC_USER|" .
39 "CALLBACK|CDECL|NTAPI|PASCAL|RPC_ENTRY|RPC_VAR_ENTRY|" .
40 "SEC_ENTRY|VFWAPI|VFWAPIV|WINGDIPAPI|WMIAPI|WINAPI|WINAPIV|APIENTRY|";
43 sub parse_c_function($$$$$);
44 sub parse_c_function_call($$$$$$$$);
45 sub parse_c_preprocessor($$$$);
46 sub parse_c_statements($$$$);
47 sub parse_c_tuple($$$$$$$);
48 sub parse_c_type($$$$$);
49 sub parse_c_typedef($$$$);
50 sub parse_c_variable($$$$$$$);
55 my ($proto, $filename) = @_;
56 my $class = ref($proto) || $proto;
57 my $self = {FILE => $filename,
58 CREATE_FUNCTION => sub { return new c_function; },
59 CREATE_TYPE => sub { return new c_type; },
60 FOUND_COMMENT => sub { return 1; },
61 FOUND_DECLARATION => sub { return 1; },
62 FOUND_FUNCTION => sub { return 1; },
63 FOUND_FUNCTION_CALL => sub { return 1; },
64 FOUND_LINE => sub { return 1; },
65 FOUND_PREPROCESSOR => sub { return 1; },
66 FOUND_STATEMENT => sub { return 1; },
67 FOUND_TYPE => sub { return 1; },
68 FOUND_VARIABLE => sub { return 1; }
70 bless ($self, $class);
79 sub set_found_comment_callback($$)
81 my ($self, $found_comment) = @_;
82 $self->{FOUND_COMMENT} = $found_comment;
85 sub set_found_declaration_callback($$)
87 my ($self, $found_declaration) = @_;
88 $self->{FOUND_DEClARATION} = $found_declaration;
91 sub set_found_function_callback($$)
93 my ($self, $found_function) = @_;
94 $self->{FOUND_FUNCTION} = $found_function;
97 sub set_found_function_call_callback($$)
99 my ($self, $found_function_call) = @_;
100 $self->{FOUND_FUNCTION_CALL} = $found_function_call;
103 sub set_found_line_callback($$)
105 my ($self, $found_line) = @_;
106 $self->{FOUND_LINE} = $found_line;
109 sub set_found_preprocessor_callback($$)
111 my ($self, $found_preprocessor) = @_;
112 $self->{FOUND_PREPROCESSOR} = $found_preprocessor;
115 sub set_found_statement_callback($$)
117 my ($self, $found_statement) = @_;
118 $self->{FOUND_STATEMENT} = $found_statement;
121 sub set_found_type_callback($$)
123 my ($self, $found_type) = @_;
124 $self->{FOUND_TYPE} = $found_type;
127 sub set_found_variable_callback($$)
129 my ($self, $found_variable) = @_;
130 $self->{FOUND_VARIABLE} = $found_variable;
134 ########################################################################
136 sub _format_c_type($$)
138 my ($self, $type) = @_;
140 $type =~ s/^\s*(.*?)\s*$/$1/;
142 if ($type =~ /^(\w+(?:\s*\*)*)\s*\(\s*\*\s*\)\s*\(\s*(.*?)\s*\)$/s) {
143 my $return_type = $1;
144 my @arguments = split(/\s*,\s*/, $2);
145 foreach my $argument (@arguments) {
146 if ($argument =~ s/^(\w+(?:\s*\*)*)\s*\w+$/$1/) {
147 $argument =~ s/\s+/ /g;
148 $argument =~ s/\s*\*\s*/*/g;
149 $argument =~ s/(\*+)$/ $1/;
153 $type = "$return_type (*)(" . join(", ", @arguments) . ")";
160 ########################################################################
163 # FIXME: Use caller (See man perlfunc)
164 sub _parse_c_warning($$$$$$)
166 my ($self, $curlines, $line, $column, $context, $message) = @_;
168 $message = "warning" if !$message;
172 my @lines = split(/\n/, $curlines);
174 $current .= $lines[0] . "\n" if $lines[0];
175 $current .= $lines[1] . "\n" if $lines[1];
179 $output->write("$self->{FILE}:$line." . ($column + 1) . ": $context: $message: \\\n$current");
181 $output->write("$self->{FILE}:$line." . ($column + 1) . ": $context: $message\n");
185 ########################################################################
188 sub _parse_c_error($$$$$$)
190 my ($self, $curlines, $line, $column, $context, $message) = @_;
192 $message = "parse error" if !$message;
195 if($output->prefix) {
196 # $output->write("\n");
200 $self->_parse_c_warning($curlines, $line, $column, $context, $message);
205 ########################################################################
208 sub _update_c_position($$$$)
210 my ($self, $source, $refline, $refcolumn) = @_;
211 my $line = $$refline;
212 my $column = $$refcolumn;
216 if ($source =~ s/^[^\n\t\'\"]*//s)
218 $column += length($&);
221 if ($source =~ s/^\'//)
224 while ($source =~ /^./ && $source !~ s/^\'//)
226 $source =~ s/^([^\'\\]*)//s;
227 $column += length($1);
228 if ($source =~ s/^\\//)
231 if ($source =~ s/^(.)//s)
233 $column += length($1);
236 $source =~ s/^(\d{0,3})//s;
237 $column += length($1);
244 elsif ($source =~ s/^\"//)
247 while ($source =~ /^./ && $source !~ s/^\"//)
249 $source =~ s/^([^\"\\]*)//s;
250 $column += length($1);
251 if ($source =~ s/^\\//)
254 if ($source =~ s/^(.)//s)
256 $column += length($1);
259 $source =~ s/^(\d{0,3})//s;
260 $column += length($1);
267 elsif ($source =~ s/^\n//)
272 elsif ($source =~ s/^\t//)
274 $column = $column + 8 - $column % 8;
279 $$refcolumn = $column;
282 ########################################################################
283 # __parse_c_until_one_of
285 sub __parse_c_until_one_of($$$$$$$) {
288 my $characters = shift;
289 my $on_same_level = shift;
290 my $refcurrent = shift;
292 my $refcolumn = shift;
295 local $_ = $$refcurrent;
296 my $line = $$refline;
297 my $column = $$refcolumn;
300 if(!defined($match)) {
302 $match = \$blackhole;
307 while(/^[^$characters]/s || $level > 0) {
311 if(s/^[^\(\)\[\]\{\}\n\t\'\"]*//s) {
314 } elsif ($on_same_level) {
315 if(s/^[^$characters\(\)\[\]\{\}\n\t\'\"]*//s) {
319 if(s/^[^$characters\n\t\'\"]*//s) {
326 while(/^./ && !s/^\'//) {
342 $$match .= $submatch;
343 $column += length($submatch);
346 while(/^./ && !s/^\"//) {
362 $$match .= $submatch;
363 $column += length($submatch);
364 } elsif($on_same_level && s/^[\(\[\{]//) {
368 $$match .= $submatch;
370 } elsif($on_same_level && s/^[\)\]\}]//) {
375 $$match .= $submatch;
379 $$match .= $submatch;
385 $$match .= $submatch;
391 $$match .= $submatch;
392 $column = $column + 8 - $column % 8;
394 $$match .= $submatch;
395 $column += length($submatch);
401 $$refcolumn = $column;
405 sub _parse_c_until_one_of($$$$$$)
407 my ($self, $characters, $refcurrent, $refline, $refcolumn, $match) = @_;
408 return $self->__parse_c_until_one_of($characters, 0, $refcurrent, $refline, $refcolumn, $match);
411 sub _parse_c_on_same_level_until_one_of($$$$$$)
413 my ($self, $characters, $refcurrent, $refline, $refcolumn, $match) = @_;
414 return $self->__parse_c_until_one_of($characters, 1, $refcurrent, $refline, $refcolumn, $match);
417 ########################################################################
420 sub parse_c_block($$$$$$$) {
423 my $refcurrent = shift;
425 my $refcolumn = shift;
427 my $refstatements = shift;
428 my $refstatements_line = shift;
429 my $refstatements_column = shift;
431 local $_ = $$refcurrent;
432 my $line = $$refline;
433 my $column = $$refcolumn;
435 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
445 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
447 my $statements_line = $line;
448 my $statements_column = $column;
453 $self->_parse_c_until_one_of("\\{\\}", \$_, \$line, \$column, \$match);
457 $statements .= $match;
473 $$refcolumn = $column;
474 $$refstatements = $statements;
475 $$refstatements_line = $statements_line;
476 $$refstatements_column = $statements_column;
481 sub parse_c_declaration($$$$)
483 my ($self, $refcurrent, $refline, $refcolumn) = @_;
485 local $_ = $$refcurrent;
486 my $line = $$refline;
487 my $column = $$refcolumn;
489 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
491 my $begin_line = $line;
492 my $begin_column = $column + 1;
494 my $end_line = $begin_line;
495 my $end_column = $begin_column;
496 $self->_update_c_position($_, \$end_line, \$end_column);
498 if(!$self->{FOUND_DECLARATION}($begin_line, $begin_column, $end_line, $end_column, $_)) {
506 my ($linkage, $type, $name);
508 if(s/^WINE_(?:DEFAULT|DECLARE)_DEBUG_CHANNEL\s*\(\s*(\w+)\s*\)\s*//s) { # FIXME: Wine specific kludge
509 $self->_update_c_position($&, \$line, \$column);
510 } elsif(s/^__ASM_GLOBAL_FUNC\(\s*(\w+)\s*,\s*//s) { # FIXME: Wine specific kludge
511 $self->_update_c_position($&, \$line, \$column);
512 $self->_parse_c_until_one_of("\)", \$_, \$line, \$column);
516 } elsif(s/^__ASM_STDCALL_FUNC\(\s*(\w+)\s*,\s*\d+\s*,\s*//s) { # FIXME: Wine specific kludge
517 $self->_update_c_position($&, \$line, \$column);
518 $self->_parse_c_until_one_of("\)", \$_, \$line, \$column);
522 } elsif(s/^(?:DEFINE_AVIGUID|DEFINE_OLEGUID)\s*(?=\()//s) { # FIXME: Wine specific kludge
523 $self->_update_c_position($&, \$line, \$column);
527 my @argument_columns;
529 if(!$self->parse_c_tuple(\$_, \$line, \$column, \@arguments, \@argument_lines, \@argument_columns)) {
532 } elsif(s/^DEFINE_COMMON_NOTIFICATIONS\(\s*(\w+)\s*,\s*(\w+)\s*\)//s) { # FIXME: Wine specific kludge
533 $self->_update_c_position($&, \$line, \$column);
534 } elsif(s/^MAKE_FUNCPTR\(\s*(\w+)\s*\)//s) { # FIXME: Wine specific kludge
535 $self->_update_c_position($&, \$line, \$column);
536 } elsif(s/^START_TEST\(\s*(\w+)\s*\)\s*{//s) { # FIXME: Wine specific kludge
537 $self->_update_c_position($&, \$line, \$column);
538 } elsif(s/^int\s*_FUNCTION_\s*{//s) { # FIXME: Wine specific kludge
539 $self->_update_c_position($&, \$line, \$column);
540 } elsif(s/^(?:jump|strong)_alias//s) { # FIXME: GNU C library specific kludge
541 $self->_update_c_position($&, \$line, \$column);
542 } elsif(s/^(?:__asm__|asm)\s*\(//) {
543 $self->_update_c_position($&, \$line, \$column);
544 } elsif($self->parse_c_typedef(\$_, \$line, \$column)) {
546 } elsif($self->parse_c_variable(\$_, \$line, \$column, \$linkage, \$type, \$name)) {
548 } elsif($self->parse_c_function(\$_, \$line, \$column, \$function)) {
549 if($self->{FOUND_FUNCTION}($function))
551 my $statements = $function->statements;
552 my $statements_line = $function->statements_line;
553 my $statements_column = $function->statements_column;
555 if(defined($statements)) {
556 if(!$self->parse_c_statements(\$statements, \$statements_line, \$statements_column)) {
562 $self->_parse_c_error($_, $line, $column, "declaration");
567 $$refcolumn = $column;
574 my ($self, $pattern, $refcurrent, $refline, $refcolumn, $refmatch) = @_;
576 local $_ = $$refcurrent;
577 my $line = $$refline;
578 my $column = $$refcolumn;
581 if(s/^(?:$pattern)//s) {
582 $self->_update_c_position($&, \$line, \$column);
588 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
592 $$refcolumn = $column;
599 sub parse_c_enum($$$$)
601 my ($self, $refcurrent, $refline, $refcolumn) = @_;
603 local $_ = $$refcurrent;
604 my $line = $$refline;
605 my $column = $$refcolumn;
607 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
609 if (!s/^enum\s+((?:MSVCRT|WS)\(\s*\w+\s*\)|\w+)?\s*\{\s*//s) {
612 my $_name = $1 || "";
614 $self->_update_c_position($&, \$line, \$column);
619 while ($self->_parse_c_on_same_level_until_one_of(',', \$_, \$line, \$column, \$match)) {
621 if ($match !~ /^(\w+)\s*(?:=\s*(.*?)\s*)?$/) {
622 $self->_parse_c_error($_, $line, $column, "enum");
625 my $enum_value = $2 || "";
627 # $output->write("enum:$_name:$enum_name:$enum_value\n");
630 if ($self->_parse_c(',', \$_, \$line, \$column)) {
632 } elsif ($self->_parse_c('}', \$_, \$line, \$column)) {
635 my $tuple_line = $line;
636 my $tuple_column = $column - 1;
640 my @argument_columns;
642 if(!$self->parse_c_tuple(\$tuple, \$tuple_line, \$tuple_column,
643 \@arguments, \@argument_lines, \@argument_columns))
645 $self->_parse_c_error($_, $line, $column, "enum");
649 if ($#arguments >= 0) {
650 $name = $arguments[0];
655 $self->_parse_c_error($_, $line, $column, "enum");
659 $self->_update_c_position($_, \$line, \$column);
663 $$refcolumn = $column;
666 sub parse_c_expression($$$$)
668 my ($self, $refcurrent, $refline, $refcolumn) = @_;
670 local $_ = $$refcurrent;
671 my $line = $$refline;
672 my $column = $$refcolumn;
674 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
677 if(s/^(.*?)(\w+\s*\()/$2/s) {
678 $self->_update_c_position($1, \$line, \$column);
680 my $begin_line = $line;
681 my $begin_column = $column + 1;
686 my @argument_columns;
687 if(!$self->parse_c_function_call(\$_, \$line, \$column, \$name, \@arguments, \@argument_lines, \@argument_columns)) {
691 if($self->{FOUND_FUNCTION_CALL}($begin_line, $begin_column, $line, $column, $name, \@arguments))
693 while(defined(my $argument = shift @arguments) &&
694 defined(my $argument_line = shift @argument_lines) &&
695 defined(my $argument_column = shift @argument_columns))
697 $self->parse_c_expression(\$argument, \$argument_line, \$argument_column);
705 $self->_update_c_position($_, \$line, \$column);
709 $$refcolumn = $column;
714 sub parse_c_file($$$$)
716 my ($self, $refcurrent, $refline, $refcolumn) = @_;
718 local $_ = $$refcurrent;
719 my $line = $$refline;
720 my $column = $$refcolumn;
722 my $declaration = "";
723 my $declaration_line = $line;
724 my $declaration_column = $column;
726 my $previous_line = 0;
727 my $previous_column = -1;
729 my $preprocessor_condition = "";
736 while($plevel > 0 || $blevel > 0) {
738 $self->_parse_c_until_one_of("#/\\(\\)\\[\\]\\{\\};", \$_, \$line, \$column, \$match);
740 if($line != $previous_line) {
741 $self->{FOUND_LINE}($line);
743 # $self->{FOUND_LINE}("$line.$column");
745 $previous_line = $line;
746 $previous_column = $column;
748 if($match !~ /^\s+$/s && $options->debug) {
749 $self->_parse_c_warning($_, $line, $column, "file", "$plevel $blevel: '$declaration' '$match'");
752 if(!$declaration && $match =~ s/^\s+//s) {
753 $self->_update_c_position($&, \$declaration_line, \$declaration_column);
757 $declaration .= $match;
760 if ($declaration =~ s/^extern\s*\"C\"//s) {
762 $self->_update_c_position($&, \$line, \$column);
764 $declaration_line = $line;
765 $declaration_column = $column;
770 } elsif ($extern_c && $blevel == 1 && $plevel == 1 && !$declaration) {
772 $self->_update_c_position($&, \$line, \$column);
774 $declaration_line = $line;
775 $declaration_column = $column;
780 } elsif($declaration =~ s/^(?:__DEFINE_(?:GET|SET)_SEG|OUR_GUID_ENTRY)\s*(?=\()//sx) { # FIXME: Wine specific kludge
782 if ($plevel > 2 || !s/^\)//) {
783 $declaration = "$prefix$declaration";
786 $self->_update_c_position($&, \$line, \$column);
791 my @argument_columns;
793 if(!$self->parse_c_tuple(\$declaration, \$declaration_line, \$declaration_column,
794 \@arguments, \@argument_lines, \@argument_columns))
796 $self->_parse_c_error($declaration, $declaration_line, $declaration_column, "file", "tuple expected");
800 $declaration_line = $line;
801 $declaration_column = $column;
805 } elsif ($declaration =~ s/^(?:DECL_WINELIB_TYPE_AW|DECLARE_HANDLE(?:16)?|TYPE_MARSHAL)\(\s*(\w+)\s*\)\s*//s) {
806 $self->_update_c_position($&, \$declaration_line, \$declaration_column);
812 while(s/^.*?\n//) { $blank_lines++; }
815 $declaration_line = $line;
816 $declaration_column = $column;
818 $declaration .= "\n" x $blank_lines;
826 my $preprocessor_line = $line;
827 my $preprocessor_column = $column;
829 my $preprocessor = $&;
830 while(s/^(.*?)\\\s*\n//) {
832 $preprocessor .= "$1\n";
834 if(s/^(.*?)(\/\*.*?\*\/)(.*?)\n//) {
837 $preprocessor .= "$1$3";
841 } elsif(s/^(.*?)(\/[\*\/].*?)?\n//) {
851 if($preprocessor =~ /^\#\s*if/) {
852 if($preprocessor =~ /^\#\s*if\s*0/) {
857 if($preprocessor =~ /^\#\s*ifdef\s+WORDS_BIGENDIAN$/) {
858 $preprocessor_condition = "defined(WORD_BIGENDIAN)";
859 # $output->write("'$preprocessor_condition':'$declaration'\n")
861 $preprocessor_condition = "";
864 } elsif($preprocessor =~ /^\#\s*else/) {
865 if ($preprocessor_condition ne "") {
866 $preprocessor_condition =~ "!$preprocessor_condition";
867 $preprocessor_condition =~ s/^!!/!/;
868 # $output->write("'$preprocessor_condition':'$declaration'\n")
870 } elsif($preprocessor =~ /^\#\s*endif/) {
878 if ($preprocessor_condition ne "") {
879 # $output->write("'$preprocessor_condition':'$declaration'\n");
880 $preprocessor_condition = "";
885 if(!$self->parse_c_preprocessor(\$preprocessor, \$preprocessor_line, \$preprocessor_column)) {
890 if(s/^\/\*.*?\*\///s) {
891 $self->{FOUND_COMMENT}($line, $column + 1, $&);
897 $column += length($_);
899 } elsif(s/^\/\/(.*?)\n//) {
900 $self->{FOUND_COMMENT}($line, $column + 1, $&);
909 $line += $blank_lines;
910 if($blank_lines > 0) {
915 $declaration_line = $line;
916 $declaration_column = $column;
917 } elsif($blank_lines > 0) {
918 $declaration .= "\n" x $blank_lines;
940 $self->_parse_c_error($_, $line, $column, "file", ") without (");
943 if($plevel == 1 && $declaration =~ /^(__ASM_GLOBAL_FUNC|__ASM_STDCALL_FUNC)/) {
944 if(!$self->parse_c_declaration(\$declaration, \$declaration_line, \$declaration_column)) {
947 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
949 $declaration_line = $line;
950 $declaration_column = $column;
958 $self->_parse_c_error($_, $line, $column, "file", "} without {");
963 if($declaration =~ /^typedef/s ||
964 $declaration =~ /^(?:const\s+|extern\s+|static\s+|volatile\s+)*(?:interface|struct|union)(?:\s+\w+)?\s*\{/s)
967 } elsif($plevel == 1 && $blevel == 1) {
968 if(!$self->parse_c_declaration(\$declaration, \$declaration_line, \$declaration_column)) {
971 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
973 $declaration_line = $line;
974 $declaration_column = $column;
975 } elsif($column == 1 && !$extern_c) {
976 $self->_parse_c_warning("", $line, $column, "file", "inner } ends on column 1");
980 if($plevel == 1 && $blevel == 1) {
981 $declaration =~ s/\s*;$//;
982 if($declaration && !$self->parse_c_declaration(\$declaration, \$declaration_line, \$declaration_column)) {
985 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
987 $declaration_line = $line;
988 $declaration_column = $column;
990 } elsif(/^\s*$/ && $declaration =~ /^\s*$/ && $match =~ /^\s*$/) {
994 $self->_parse_c_error($_, $line, $column, "file", "parse error: '$declaration' '$match'");
1000 $$refcolumn = $column;
1005 sub parse_c_function($$$$$)
1007 my ($self, $refcurrent, $refline, $refcolumn, $reffunction) = @_;
1009 local $_ = $$refcurrent;
1010 my $line = $$refline;
1011 my $column = $$refcolumn;
1014 my $calling_convention = "";
1019 my @argument_columns;
1021 my $statements_line;
1022 my $statements_column;
1024 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
1026 my $begin_line = $line;
1027 my $begin_column = $column + 1;
1029 if($self->_parse_c('__declspec\((?:dllexport|dllimport|naked)\)|INTERNETAPI|RPCRTAPI', \$_, \$line, \$column)) {
1033 # $self->_parse_c_warning($_, $line, $column, "function", "");
1036 while($self->_parse_c('(?:const|inline|extern(?:\s+\"C\")?|EXTERN_C|static|volatile|' .
1037 'signed(?=\s+__int(?:8|16|32|64)\b|\s+char\b|\s+int\b|\s+long(?:\s+long)?\b|\s+short\b)|' .
1038 'unsigned(?=\s+__int(?:8|16|32|64)\b|\s+char\b|\s+int\b|\s+long(?:\s+long)?\b|\s+short\b)|' .
1039 'long(?=\s+double\b|\s+int\b|\s+long\b))(?=\b)',
1040 \$_, \$line, \$column, \$match))
1042 if($match =~ /^(?:extern|static)$/) {
1049 if($self->_parse_c('DECL_GLOBAL_CONSTRUCTOR', \$_, \$line, \$column, \$name)) { # FIXME: Wine specific kludge
1051 } elsif($self->_parse_c('WINE_EXCEPTION_FILTER\(\w+\)', \$_, \$line, \$column, \$name)) { # FIXME: Wine specific kludge
1054 if(!$self->parse_c_type(\$_, \$line, \$column, \$return_type)) {
1058 $self->_parse_c('inline|FAR', \$_, \$line, \$column);
1060 $self->_parse_c($CALL_CONVENTION,
1061 \$_, \$line, \$column, \$calling_convention);
1064 # FIXME: ???: Old variant of __attribute((const))
1065 $self->_parse_c('(?:const|volatile)', \$_, \$line, \$column);
1067 if(!$self->_parse_c('(?:operator\s*!=|(?:MSVCRT|WS)\(\s*\w+\s*\)|\w+)', \$_, \$line, \$column, \$name)) {
1073 $self->_update_c_position($&, \$line, \$column);
1077 if(!$self->parse_c_tuple(\$_, \$line, \$column, \@arguments, \@argument_lines, \@argument_columns)) {
1083 $self->_update_c_position($&, \$line, \$column);
1085 $self->_parse_c_error($_, $line, $column, "function");
1091 if($self->_parse_c('__attribute__\s*\(\s*\(\s*(?:constructor|destructor)\s*\)\s*\)', \$_, \$line, \$column)) {
1096 # FIXME: Implement proper handling of K&R C functions
1097 $self->_parse_c_until_one_of("{", \$_, \$line, \$column, $kar);
1100 $output->write("K&R: $kar\n");
1103 if($_ && !$self->parse_c_block(\$_, \$line, \$column, \$statements, \$statements_line, \$statements_column)) {
1107 my $end_line = $line;
1108 my $end_column = $column;
1112 $$refcolumn = $column;
1114 my $function = $self->{CREATE_FUNCTION}();
1116 $function->file($self->{FILE});
1117 $function->begin_line($begin_line);
1118 $function->begin_column($begin_column);
1119 $function->end_line($end_line);
1120 $function->end_column($end_column);
1121 $function->linkage($linkage);
1122 $function->return_type($return_type);
1123 $function->calling_convention($calling_convention);
1124 $function->name($name);
1125 # if(defined($argument_types)) {
1126 # $function->argument_types([@$argument_types]);
1128 # if(defined($argument_names)) {
1129 # $function->argument_names([@$argument_names]);
1131 $function->statements_line($statements_line);
1132 $function->statements_column($statements_column);
1133 $function->statements($statements);
1135 $$reffunction = $function;
1140 sub parse_c_function_call($$$$$$$$)
1142 my ($self, $refcurrent, $refline, $refcolumn, $refname, $refarguments, $refargument_lines, $refargument_columns) = @_;
1144 local $_ = $$refcurrent;
1145 my $line = $$refline;
1146 my $column = $$refcolumn;
1151 my @argument_columns;
1153 if(s/^(\w+)(\s*)(?=\()//s) {
1154 $self->_update_c_position($&, \$line, \$column);
1158 if(!$self->parse_c_tuple(\$_, \$line, \$column, \@arguments, \@argument_lines, \@argument_columns)) {
1167 $$refcolumn = $column;
1170 @$refarguments = @arguments;
1171 @$refargument_lines = @argument_lines;
1172 @$refargument_columns = @argument_columns;
1178 sub parse_c_preprocessor($$$$)
1180 my ($self, $refcurrent, $refline, $refcolumn) = @_;
1182 local $_ = $$refcurrent;
1183 my $line = $$refline;
1184 my $column = $$refcolumn;
1186 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
1188 my $begin_line = $line;
1189 my $begin_column = $column + 1;
1191 if(!$self->{FOUND_PREPROCESSOR}($begin_line, $begin_column, "$_")) {
1195 if(/^\#\s*define\s*(.*?)$/s) {
1196 $self->_update_c_position($_, \$line, \$column);
1197 } elsif(/^\#\s*else/s) {
1198 $self->_update_c_position($_, \$line, \$column);
1199 } elsif(/^\#\s*endif/s) {
1200 $self->_update_c_position($_, \$line, \$column);
1201 } elsif(/^\#\s*(?:if|ifdef|ifndef)?\s*(.*?)$/s) {
1202 $self->_update_c_position($_, \$line, \$column);
1203 } elsif(/^\#\s*include\s+(.*?)$/s) {
1204 $self->_update_c_position($_, \$line, \$column);
1205 } elsif(/^\#\s*undef\s+(.*?)$/s) {
1206 $self->_update_c_position($_, \$line, \$column);
1208 $self->_parse_c_error($_, $line, $column, "preprocessor");
1213 $$refcolumn = $column;
1218 sub parse_c_statement($$$$)
1220 my ($self, $refcurrent, $refline, $refcolumn) = @_;
1222 local $_ = $$refcurrent;
1223 my $line = $$refline;
1224 my $column = $$refcolumn;
1226 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
1228 $self->_parse_c('(?:case\s+)?(\w+)\s*:\s*', \$_, \$line, \$column);
1230 # $output->write("$line.$column: statement: '$_'\n");
1236 my $statements_line;
1237 my $statements_column;
1238 if(!$self->parse_c_block(\$_, \$line, \$column, \$statements, \$statements_line, \$statements_column)) {
1241 if(!$self->parse_c_statements(\$statements, \$statements_line, \$statements_column)) {
1244 } elsif(s/^(for|if|switch|while)\s*(?=\()//) {
1245 $self->_update_c_position($&, \$line, \$column);
1251 my @argument_columns;
1252 if(!$self->parse_c_tuple(\$_, \$line, \$column, \@arguments, \@argument_lines, \@argument_columns)) {
1256 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
1257 if(!$self->parse_c_statement(\$_, \$line, \$column)) {
1260 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
1262 while(defined(my $argument = shift @arguments) &&
1263 defined(my $argument_line = shift @argument_lines) &&
1264 defined(my $argument_column = shift @argument_columns))
1266 $self->parse_c_expression(\$argument, \$argument_line, \$argument_column);
1268 } elsif(s/^else//) {
1269 $self->_update_c_position($&, \$line, \$column);
1270 if(!$self->parse_c_statement(\$_, \$line, \$column)) {
1273 } elsif(s/^return//) {
1274 $self->_update_c_position($&, \$line, \$column);
1275 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
1276 if(!$self->parse_c_expression(\$_, \$line, \$column)) {
1279 } elsif($self->parse_c_expression(\$_, \$line, \$column)) {
1282 # $self->_parse_c_error($_, $line, $column, "statement");
1285 $self->_update_c_position($_, \$line, \$column);
1289 $$refcolumn = $column;
1294 sub parse_c_statements($$$$)
1296 my ($self, $refcurrent, $refline, $refcolumn) = @_;
1298 local $_ = $$refcurrent;
1299 my $line = $$refline;
1300 my $column = $$refcolumn;
1302 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
1304 # $output->write("$line.$column: statements: '$_'\n");
1307 my $statement_line = $line;
1308 my $statement_column = $column;
1310 my $previous_line = -1;
1311 my $previous_column = -1;
1315 while($plevel > 0 || $blevel > 0) {
1317 $self->_parse_c_until_one_of("\\(\\)\\[\\]\\{\\};", \$_, \$line, \$column, \$match);
1319 if($previous_line == $line && $previous_column == $column) {
1320 $self->_parse_c_error($_, $line, $column, "statements", "no progress");
1322 $previous_line = $line;
1323 $previous_column = $column;
1325 # $output->write("'$match' '$_'\n");
1327 $statement .= $match;
1332 } elsif(s/^[\)\]]//) {
1335 $self->_parse_c_error($_, $line, $column, "statements");
1345 if(!$self->parse_c_statement(\$statement, \$statement_line, \$statement_column)) {
1348 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
1350 $statement_line = $line;
1351 $statement_column = $column;
1354 if($plevel == 1 && $blevel == 1) {
1355 if(!$self->parse_c_statement(\$statement, \$statement_line, \$statement_column)) {
1359 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
1361 $statement_line = $line;
1362 $statement_column = $column;
1366 } elsif(/^\s*$/ && $statement =~ /^\s*$/ && $match =~ /^\s*$/) {
1370 $self->_parse_c_error($_, $line, $column, "statements");
1374 $self->_update_c_position($_, \$line, \$column);
1378 $$refcolumn = $column;
1383 sub parse_c_struct_union($$$$$$$$$)
1385 my ($self, $refcurrent, $refline, $refcolumn, $refkind, $ref_name, $reffield_type_names, $reffield_names, $refnames) = @_;
1387 local $_ = $$refcurrent;
1388 my $line = $$refline;
1389 my $column = $$refcolumn;
1393 my @field_type_names = ();
1394 my @field_names = ();
1397 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
1399 if (!s/^(interface|struct|union)(\s+((?:MSVCRT|WS)\(\s*\w+\s*\)|\w+))?\s*\{\s*//s) {
1405 $self->_update_c_position($&, \$line, \$column);
1408 while ($_ && $self->_parse_c_on_same_level_until_one_of(';', \$_, \$line, \$column, \$match))
1411 my $field_type_name;
1414 if ($self->parse_c_variable(\$match, \$line, \$column, \$field_linkage, \$field_type_name, \$field_name)) {
1415 $field_type_name =~ s/\s+/ /g;
1417 push @field_type_names, $field_type_name;
1418 push @field_names, $field_name;
1419 # $output->write("$kind:$_name:$field_type_name:$field_name\n");
1421 $self->_parse_c_error($_, $line, $column, "typedef $kind: '$match'");
1424 if ($self->_parse_c(';', \$_, \$line, \$column)) {
1426 } elsif ($self->_parse_c('}', \$_, \$line, \$column)) {
1429 my $tuple_line = $line;
1430 my $tuple_column = $column - 1;
1434 my @argument_columns;
1436 if(!$self->parse_c_tuple(\$tuple, \$tuple_line, \$tuple_column,
1437 \@arguments, \@argument_lines, \@argument_columns))
1439 $self->_parse_c_error($_, $line, $column, "$kind");
1442 foreach my $argument (@arguments) {
1443 my $name = $argument;
1450 $self->_parse_c_error($_, $line, $column, "$kind");
1456 $$refcolumn = $column;
1459 $$ref_name = $_name;
1460 @$reffield_type_names = @field_type_names;
1461 @$reffield_names = @field_names;
1462 @$refnames = @names;
1467 sub parse_c_tuple($$$$$$$)
1469 my ($self, $refcurrent, $refline, $refcolumn,
1470 # FIXME: Should not write directly
1471 $items, $item_lines, $item_columns) = @_;
1473 local $_ = $$refcurrent;
1475 my $line = $$refline;
1476 my $column = $$refcolumn;
1486 my $item_line = $line;
1487 my $item_column = $column + 1;
1490 while($plevel > 0) {
1492 $self->_parse_c_until_one_of("\\(,\\)", \$_, \$line, \$column, \$match);
1500 push @$item_lines, $item_line;
1501 push @$item_columns, $item_column;
1502 push @$items, $item;
1512 push @$item_lines, $item_line;
1513 push @$item_columns, $item_column;
1514 push @$items, $item;
1515 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
1517 $item_column = $column + 1;
1529 $$refcolumn = $column;
1534 sub parse_c_type($$$$$)
1536 my ($self, $refcurrent, $refline, $refcolumn, $reftype) = @_;
1538 local $_ = $$refcurrent;
1539 my $line = $$refline;
1540 my $column = $$refcolumn;
1544 $self->_parse_c("(?:const|volatile)", \$_, \$line, \$column);
1546 if($self->_parse_c('ICOM_VTABLE\(.*?\)', \$_, \$line, \$column, \$type)) {
1548 } elsif($self->_parse_c('(?:enum\s+|interface\s+|struct\s+|union\s+)?(?:(?:MSVCRT|WS)\(\s*\w+\s*\)|\w+)\s*(\*\s*)*',
1549 \$_, \$line, \$column, \$type))
1559 $$refcolumn = $column;
1566 sub parse_c_typedef($$$$)
1568 my ($self, $refcurrent, $refline, $refcolumn) = @_;
1570 local $_ = $$refcurrent;
1571 my $line = $$refline;
1572 my $column = $$refcolumn;
1574 if (!$self->_parse_c("typedef", \$_, \$line, \$column)) {
1578 my ($kind, $name, @field_type_names, @field_names, @names);
1579 my ($linkage, $type_name);
1580 if ($self->parse_c_enum(\$_, \$line, \$column))
1584 elsif ($self->parse_c_struct_union(\$_, \$line, \$column,
1585 \$kind, \$name, \@field_type_names, \@field_names, \@names))
1588 foreach my $_name (@names)
1590 if ($_name =~ /^\w+$/)
1592 $base_name = $_name;
1596 $base_name="$kind $name" if (!defined $base_name and defined $name);
1597 $base_name=$kind if (!defined $base_name);
1598 foreach my $_name (@names) {
1599 if ($_name =~ /^\w+$/) {
1600 my $type = $self->{CREATE_TYPE}();
1603 $type->_name($name);
1604 $type->name($_name);
1605 $type->field_type_names([@field_type_names]);
1606 $type->field_names([@field_names]);
1608 $self->{FOUND_TYPE}($type);
1609 } elsif ($_name =~ /^(\*+)\s*(?:RESTRICTED_POINTER\s+)?(\w+)$/) {
1610 my $type_name = "$base_name $1";
1613 my $type = $self->{CREATE_TYPE}();
1616 $type->name($_name);
1617 $type->field_type_names([$type_name]);
1618 $type->field_names([""]);
1620 $self->{FOUND_TYPE}($type);
1622 $self->_parse_c_error($_, $line, $column, "typedef 2");
1626 elsif ($self->parse_c_variable(\$_, \$line, \$column, \$linkage, \$type_name, \$name))
1628 $type_name =~ s/\s+/ /g;
1630 if(defined($type_name) && defined($name)) {
1631 my $type = $self->{CREATE_TYPE}();
1633 if (length($name) == 0) {
1634 $self->_parse_c_error($_, $line, $column, "typedef");
1639 $type->field_type_names([$type_name]);
1640 $type->field_names([""]);
1642 $self->{FOUND_TYPE}($type);
1645 $self->_parse_c_error($_, $line, $column, "typedef");
1650 $$refcolumn = $column;
1655 sub parse_c_variable($$$$$$$)
1657 my ($self, $refcurrent, $refline, $refcolumn, $reflinkage, $reftype, $refname) = @_;
1659 local $_ = $$refcurrent;
1660 my $line = $$refline;
1661 my $column = $$refcolumn;
1663 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
1665 my $begin_line = $line;
1666 my $begin_column = $column + 1;
1673 # $self->_parse_c_warning($_, $line, $column, "variable");
1676 while($self->_parse_c('(?:const|inline|extern(?:\s+\"C\")?|EXTERN_C|static|volatile|' .
1677 'signed(?=\s+__int(?:8|16|32|64)\b|\s+char\b|\s+int\b|\s+long(?:\s+long)?\b|\s+short\b)|' .
1678 'unsigned(?=\s+__int(?:8|16|32|64)\b|\s+char\b|\s+int\b|\s+long(?:\s+long)?\b|\s+short\b)|' .
1679 'long(?=\s+double\b|\s+int\b|\s+long\b))(?=\b)',
1680 \$_, \$line, \$column, \$match))
1682 if ($match =~ /^(?:extern|static)$/) {
1686 $self->_parse_c_warning($_, $line, $column, "repeated linkage (ignored): $match");
1688 } elsif ($match =~ /^(?:signed|unsigned)$/) {
1692 $self->_parse_c_warning($_, $line, $column, "repeated sign (ignored): $match");
1701 if (s/^(enum\s+|interface\s+|struct\s+|union\s+)((?:MSVCRT|WS)\(\s*\w+\s*\)|\w+)?\s*\{\s*//s) {
1704 $self->_update_c_position($&, \$line, \$column);
1706 if(defined($_name)) {
1707 $type = "$kind $_name { }";
1709 $type = "$kind { }";
1713 } elsif(s/^((?:enum\s+|interface\s+|struct\s+|union\s+)?\w+\b(?:\s+DECLSPEC_ALIGN\(.*?\)|\s*(?:const\s*|volatile\s*)?\*)*)\s*(\w+)\s*(\[.*?\]$|:\s*(\d+)$|\{)?//s) {
1729 $type = $self->_format_c_type($type);
1732 } elsif(s/^((?:enum\s+|interface\s+|struct\s+|union\s+)?\w+\b(?:\s*\*)*)\s*:\s*(\d+)$//s) {
1733 $type = "$sign$1:$2";
1735 $type = $self->_format_c_type($type);
1738 } elsif(s/^((?:enum\s+|interface\s+|struct\s+|union\s+)?\w+\b(?:\s*\*)*\s*\(\s*(?:$CALL_CONVENTION)?(?:\s+DECLSPEC_[A-Z]+)?(?:\s*\*)*)\s*(\w+)\s*(\)\s*\(.*?\))$//s) {
1739 $type = $self->_format_c_type("$sign$1$3");
1743 } elsif($self->_parse_c('DEFINE_GUID', \$_, \$line, \$column, \$match)) { # Windows specific
1747 $self->_parse_c_warning($_, $line, $column, "variable", "'$_'");
1751 if($self->_parse_c('SEQ_DEFINEBUF', \$_, \$line, \$column, \$match)) { # Linux specific
1754 } elsif($self->_parse_c('DEFINE_REGS_ENTRYPOINT_\w+|DPQ_DECL_\w+|HANDLER_DEF|IX86_ONLY', # Wine specific
1755 \$_, \$line, \$column, \$match))
1759 } elsif($self->_parse_c('(?:struct\s+)?ICOM_VTABLE\s*\(\w+\)', \$_, \$line, \$column, \$match)) {
1762 } elsif(s/^(enum|interface|struct|union)(?:\s+(\w+))?\s*\{.*?\}\s*//s) {
1765 $self->_update_c_position($&, \$line, \$column);
1767 if(defined($_name)) {
1768 $type = "struct $_name { }";
1770 $type = "struct { }";
1772 } elsif(s/^((?:enum\s+|interface\s+|struct\s+|union\s+)?\w+)\s*(?:\*\s*)*//s) {
1779 # $output->write("*** $type: '$_'\n");
1781 # $self->_parse_c_warning($_, $line, $column, "variable2", "");
1783 if(s/^WINAPI\s*//) {
1784 $self->_update_c_position($&, \$line, \$column);
1787 if(s/^(\((?:$CALL_CONVENTION)?\s*\*?\s*(?:$CALL_CONVENTION)?\w+\s*(?:\[[^\]]*\]\s*)*\))\s*\(//) {
1788 $self->_update_c_position($&, \$line, \$column);
1793 $self->_parse_c_until_one_of("\\)", \$_, \$line, \$column);
1794 if(s/^\)//) { $column++; }
1795 $self->_parse_c_until_one_of("\\S", \$_, \$line, \$column);
1797 if(!s/^(?:=\s*|,\s*|$)//) {
1800 } elsif(s/^(?:\*\s*)*(?:const\s+|volatile\s+)?(\w+)\s*(?:\[[^\]]*\]\s*)*\s*(?:=\s*|,\s*|$)//) {
1801 $self->_update_c_position($&, \$line, \$column);
1813 # $output->write("$type: $name: '$_'\n");
1817 $$refcolumn = $column;
1819 $$reflinkage = $linkage;
1823 $self->{FOUND_VARIABLE}($begin_line, $begin_column, $linkage, $type, $name);