mirror of
git://source.winehq.org/git/wine.git
synced 2024-10-31 11:26:10 +00:00
609 lines
17 KiB
Perl
Executable file
609 lines
17 KiB
Perl
Executable file
#!/usr/bin/perl -w
|
|
|
|
# Copyright 2002 Patrik Stridvall
|
|
#
|
|
# This library is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU Lesser General Public
|
|
# License as published by the Free Software Foundation; either
|
|
# version 2.1 of the License, or (at your option) any later version.
|
|
#
|
|
# This library is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# Lesser General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Lesser General Public
|
|
# License along with this library; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
#
|
|
|
|
use strict;
|
|
|
|
BEGIN {
|
|
$0 =~ m%^(.*?/?tools)/winapi/winapi_extract$%;
|
|
require "$1/winapi/setup.pm";
|
|
}
|
|
|
|
use config qw(
|
|
files_skip files_filter get_spec_files
|
|
$current_dir $wine_dir $winapi_dir
|
|
);
|
|
use output qw($output);
|
|
use winapi_extract_options qw($options);
|
|
|
|
if($options->progress) {
|
|
$output->enable_progress;
|
|
} else {
|
|
$output->disable_progress;
|
|
}
|
|
|
|
use c_parser;
|
|
use function;
|
|
use type;
|
|
|
|
use winapi_function;
|
|
|
|
use vars qw($win16api $win32api @winapis);
|
|
if ($options->implemented || $options->stub_statistics || $options->winetest) {
|
|
require winapi;
|
|
import winapi qw($win16api $win32api @winapis);
|
|
}
|
|
|
|
my %module2entries;
|
|
my %module2spec_file;
|
|
if($options->winetest) {
|
|
local $_;
|
|
|
|
foreach my $spec_file (get_spec_files("winelib")) {
|
|
my $entries = [];
|
|
|
|
my $module = $spec_file;
|
|
$module =~ s/^.*?([^\/]*)\.spec$/$1/;
|
|
|
|
my $type = "win32";
|
|
|
|
open(IN, "< $wine_dir/$spec_file") || die "Error: Can't open $wine_dir/$spec_file: $!\n";
|
|
|
|
my $header = 1;
|
|
my $lookahead = 0;
|
|
while($lookahead || defined($_ = <IN>)) {
|
|
$lookahead = 0;
|
|
|
|
s/^\s*?(.*?)\s*$/$1/; # remove whitespace at beginning and end of line
|
|
s/^(.*?)\s*#.*$/$1/; # remove comments
|
|
/^$/ && next; # skip empty lines
|
|
|
|
if($header) {
|
|
if(/^(?:\d+|@)/) {
|
|
$header = 0;
|
|
$lookahead = 1;
|
|
}
|
|
next;
|
|
}
|
|
|
|
if(/^(\d+|@)\s+stdcall\s+(\w+)\s*\(\s*([^\)]*)\s*\)/) {
|
|
my $ordinal = $1;
|
|
my $name = $2;
|
|
my @args = split(/\s+/, $3);
|
|
|
|
push @$entries, [$name, "undef", \@args];
|
|
}
|
|
}
|
|
close(IN);
|
|
|
|
$module2spec_file{$module} = $spec_file;
|
|
$module2entries{$module} = $entries;
|
|
}
|
|
}
|
|
|
|
my %specifications;
|
|
|
|
sub documentation_specifications($) {
|
|
my $function = shift;
|
|
|
|
my @debug_channels = @{$function->debug_channels};
|
|
my $documentation = $function->documentation;
|
|
my $documentation_line = $function->documentation_line;
|
|
my $return_type = $function->return_type;
|
|
my $linkage = $function->linkage;
|
|
my $internal_name = $function->internal_name;
|
|
|
|
if($linkage eq "static") {
|
|
return;
|
|
}
|
|
|
|
local $_;
|
|
foreach (split(/\n/, $documentation)) {
|
|
if(/^\s*\*\s*(\S+)\s*[\(\[]\s*(\w+)\s*\.\s*(\S+)\s*[\)\]]/) {
|
|
my $external_name = $1;
|
|
my $module = lc($2);
|
|
my $ordinal = $3;
|
|
|
|
if($ordinal eq "@") {
|
|
if(1 || !exists($specifications{$module}{unfixed}{$external_name})) {
|
|
$specifications{$module}{unfixed}{$external_name}{ordinal} = $ordinal;
|
|
$specifications{$module}{unfixed}{$external_name}{external_name} = $external_name;
|
|
$specifications{$module}{unfixed}{$external_name}{function} = $function;
|
|
} else {
|
|
$output->write("$external_name ($module.$ordinal) already exists\n");
|
|
}
|
|
} elsif($ordinal =~ /^\d+$/) {
|
|
if(1 || !exists($specifications{$module}{fixed}{$ordinal})) {
|
|
$specifications{$module}{fixed}{$ordinal}{ordinal} = $ordinal;
|
|
$specifications{$module}{fixed}{$ordinal}{external_name} = $external_name;
|
|
$specifications{$module}{fixed}{$ordinal}{function} = $function;
|
|
} else {
|
|
$output->write("$external_name ($module.$ordinal) already exists\n");
|
|
}
|
|
} elsif($ordinal eq "init") {
|
|
if(!exists($specifications{$module}{init})) {
|
|
$specifications{$module}{init}{function} = $function;
|
|
} else {
|
|
$output->write("$external_name ($module.$ordinal) already exists\n");
|
|
}
|
|
} else {
|
|
if(!exists($specifications{$module}{unknown}{$external_name})) {
|
|
$specifications{$module}{unknown}{$external_name}{ordinal} = $ordinal;
|
|
$specifications{$module}{unknown}{$external_name}{external_name} = $external_name;
|
|
$specifications{$module}{unknown}{$external_name}{function} = $function;
|
|
} else {
|
|
$output->write("$external_name ($module.$ordinal) already exists\n");
|
|
}
|
|
}
|
|
|
|
if($options->debug) {
|
|
$output->write("$external_name ($module.$ordinal)\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
my %module_pseudo_stub;
|
|
|
|
sub statements_pseudo_stub($) {
|
|
my $function = shift;
|
|
|
|
my $pseudo_stub = 0;
|
|
my $statements = $function->statements;
|
|
if(defined($statements) && $statements =~ /FIXME[^;]*stub/s) {
|
|
if($options->win16) {
|
|
my $external_name16 = $function->external_name16;
|
|
foreach my $module16 ($function->modules16) {
|
|
$module_pseudo_stub{$module16}{$external_name16}++;
|
|
$pseudo_stub = 1;
|
|
}
|
|
}
|
|
if($options->win32) {
|
|
my $external_name32 = $function->external_name32;
|
|
foreach my $module32 ($function->modules32) {
|
|
$module_pseudo_stub{$module32}{$external_name32}++;
|
|
$pseudo_stub = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $pseudo_stub;
|
|
}
|
|
|
|
my @h_files = ();
|
|
if($options->headers) {
|
|
@h_files = $options->h_files;
|
|
@h_files = files_skip(@h_files);
|
|
@h_files = files_filter("winelib", @h_files);
|
|
}
|
|
|
|
my @c_files = ();
|
|
if($options->pseudo_implemented || $options->pseudo_stub_statistics) {
|
|
@c_files = $options->c_files;
|
|
@c_files = files_skip(@c_files);
|
|
@c_files = files_filter("winelib", @c_files);
|
|
}
|
|
|
|
my $progress_output;
|
|
my $progress_current = 0;
|
|
my $progress_max = scalar(@h_files) + scalar(@c_files);
|
|
|
|
foreach my $file (@h_files, @c_files) {
|
|
my %functions;
|
|
|
|
$progress_current++;
|
|
|
|
{
|
|
open(IN, "< $file") || die "Error: Can't open $file: $!\n";
|
|
local $/ = undef;
|
|
$_ = <IN>;
|
|
close(IN);
|
|
}
|
|
|
|
my $max_line = 0;
|
|
{
|
|
local $_ = $_;
|
|
while(s/^.*?\n//) { $max_line++; }
|
|
if($_) { $max_line++; }
|
|
}
|
|
|
|
my $parser = new c_parser($file);
|
|
|
|
my $function;
|
|
my $line;
|
|
|
|
my $update_output = sub {
|
|
my $progress = "";
|
|
my $prefix = "";
|
|
|
|
$progress .= "$file (file $progress_current of $progress_max)";
|
|
$prefix .= "$file:";
|
|
|
|
if(defined($function)) {
|
|
my $name = $function->name;
|
|
my $begin_line = $function->begin_line;
|
|
my $begin_column = $function->begin_column;
|
|
|
|
$progress .= ": function $name";
|
|
$prefix .= "$begin_line.$begin_column: function $name: ";
|
|
} else {
|
|
$prefix .= " ";
|
|
}
|
|
|
|
if(defined($line)) {
|
|
$progress .= ": line $line of $max_line";
|
|
}
|
|
|
|
$output->progress($progress);
|
|
$output->prefix($prefix);
|
|
};
|
|
|
|
&$update_output();
|
|
|
|
my $found_function = sub {
|
|
$function = shift;
|
|
|
|
my $name = $function->name;
|
|
$functions{$name} = $function;
|
|
|
|
if ($function->statements) {
|
|
&$update_output();
|
|
}
|
|
|
|
my $old_function;
|
|
if($options->implemented || $options->stub_statistics) {
|
|
$old_function = 'winapi_function'->new;
|
|
} else {
|
|
$old_function = 'function'->new;
|
|
}
|
|
|
|
$old_function->file($function->file);
|
|
$old_function->debug_channels([]); # FIXME: Not complete
|
|
|
|
$old_function->documentation_line(0); # FIXME: Not complete
|
|
$old_function->documentation(""); # FIXME: Not complete
|
|
|
|
$old_function->function_line($function->begin_line());
|
|
$old_function->linkage($function->linkage);
|
|
$old_function->return_type($function->return_type);
|
|
$old_function->calling_convention($function->calling_convention);
|
|
$old_function->internal_name($function->name);
|
|
if (defined($function->argument_types)) {
|
|
$old_function->argument_types([@{$function->argument_types}]);
|
|
}
|
|
if (defined($function->argument_names)) {
|
|
$old_function->argument_names([@{$function->argument_names}]);
|
|
}
|
|
$old_function->argument_documentations([]); # FIXME: Not complete
|
|
$old_function->statements_line($function->statements_line);
|
|
$old_function->statements($function->statements);
|
|
|
|
if($options->winetest) {
|
|
documentation_specifications($old_function);
|
|
}
|
|
|
|
if ($function->statements) {
|
|
$function = undef;
|
|
&$update_output();
|
|
} else {
|
|
$function = undef;
|
|
}
|
|
|
|
my $pseudo_stub = 0;
|
|
if ($options->pseudo_implemented || $options->pseudo_stub_statistics) {
|
|
$pseudo_stub = statements_pseudo_stub($old_function);
|
|
}
|
|
|
|
my $module = $old_function->module;
|
|
my $external_name = $old_function->external_name;
|
|
my $statements = $old_function->statements;
|
|
if ($options->pseudo_implemented && $module && $external_name && $statements) {
|
|
my @external_names = split(/\s*&\s*/, $external_name);
|
|
my @modules = split(/\s*&\s*/, $module);
|
|
|
|
my @external_names2;
|
|
while(defined(my $external_name = shift @external_names) &&
|
|
defined(my $module = shift @modules))
|
|
{
|
|
if ($pseudo_stub) {
|
|
$output->write("$module.$external_name: pseudo implemented\n");
|
|
} else {
|
|
$output->write("$module.$external_name: implemented\n");
|
|
}
|
|
}
|
|
}
|
|
};
|
|
$parser->set_found_function_callback($found_function);
|
|
|
|
my $found_line = sub {
|
|
$line = shift;
|
|
|
|
&$update_output;
|
|
};
|
|
$parser->set_found_line_callback($found_line);
|
|
|
|
my $found_type = sub {
|
|
my $type = shift;
|
|
|
|
&$update_output();
|
|
|
|
my $kind = $type->kind;
|
|
my $_name = $type->_name;
|
|
my $name = $type->name;
|
|
|
|
foreach my $field ($type->fields) {
|
|
my $field_type_name = $field->type_name;
|
|
my $field_name = $field->name;
|
|
|
|
if ($options->struct && $kind =~ /^(?:struct|union)$/) {
|
|
if ($name) {
|
|
$output->write("$name:$field_type_name:$field_name\n");
|
|
} else {
|
|
$output->write("$kind $_name:$field_type_name:$field_name\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
};
|
|
$parser->set_found_type_callback($found_type);
|
|
|
|
{
|
|
my $line = 1;
|
|
my $column = 0;
|
|
if(!$parser->parse_c_file(\$_, \$line, \$column)) {
|
|
$output->write("can't parse file\n");
|
|
}
|
|
}
|
|
|
|
$output->prefix("");
|
|
}
|
|
|
|
|
|
if($options->implemented && !$options->pseudo_implemented) {
|
|
foreach my $winapi (@winapis) {
|
|
my $type = $winapi->name;
|
|
|
|
if($type eq "win16" && !$options->win16) { next; }
|
|
if($type eq "win32" && !$options->win32) { next; }
|
|
|
|
foreach my $module ($winapi->all_modules) {
|
|
foreach my $external_name ($winapi->all_functions_in_module($module)) {
|
|
my $external_calling_convention =
|
|
$winapi->function_external_calling_convention_in_module($module, $external_name);
|
|
|
|
if($external_calling_convention eq "forward") {
|
|
(my $forward_module, my $forward_external_name) =
|
|
$winapi->function_forward_final_destination($module, $external_name);
|
|
|
|
my $forward_external_calling_convention =
|
|
$winapi->function_external_calling_convention_in_module($forward_module, $forward_external_name);
|
|
|
|
if(!defined($forward_external_calling_convention)) {
|
|
next;
|
|
}
|
|
|
|
$external_calling_convention = $forward_external_calling_convention;
|
|
}
|
|
|
|
if ($external_calling_convention ne "stub") {
|
|
$output->write("*.spec: $module.$external_name: implemented\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
sub output_function($$$$$) {
|
|
local *OUT = shift;
|
|
my $type = shift;
|
|
my $ordinal = shift;
|
|
my $external_name = shift;
|
|
my $function = shift;
|
|
|
|
my $internal_name = $function->internal_name;
|
|
|
|
my $return_kind;
|
|
my $calling_convention;
|
|
my $refargument_kinds;
|
|
if($type eq "win16") {
|
|
$return_kind = $function->return_kind16 || "undef";
|
|
$calling_convention = $function->calling_convention16 || "undef";
|
|
$refargument_kinds = $function->argument_kinds16;
|
|
} elsif($type eq "win32") {
|
|
$return_kind = $function->return_kind32 || "undef";
|
|
$calling_convention = $function->calling_convention32 || "undef";
|
|
$refargument_kinds = $function->argument_kinds32;
|
|
}
|
|
|
|
if(defined($refargument_kinds)) {
|
|
my @argument_kinds = map { $_ || "undef"; } @$refargument_kinds;
|
|
print OUT "$ordinal $calling_convention $external_name(@argument_kinds) $internal_name\n";
|
|
} else {
|
|
print OUT "$ordinal $calling_convention $external_name() $internal_name # FIXME: arguments undefined\n";
|
|
}
|
|
}
|
|
|
|
if($options->stub_statistics) {
|
|
foreach my $winapi (@winapis) {
|
|
my $type = $winapi->name;
|
|
|
|
if($type eq "win16" && !$options->win16) { next; }
|
|
if($type eq "win32" && !$options->win32) { next; }
|
|
|
|
my %module_counts;
|
|
foreach my $module ($winapi->all_modules) {
|
|
foreach my $external_name ($winapi->all_functions_in_module($module)) {
|
|
my $external_calling_convention =
|
|
$winapi->function_external_calling_convention_in_module($module, $external_name);
|
|
if($external_calling_convention !~ /^(?:forward|stub)$/) {
|
|
if($module_pseudo_stub{$module}{$external_name}) {
|
|
$external_calling_convention = "pseudo_stub";
|
|
}
|
|
} elsif($external_calling_convention eq "forward") {
|
|
(my $forward_module, my $forward_external_name) =
|
|
$winapi->function_forward_final_destination($module, $external_name);
|
|
|
|
my $forward_external_calling_convention =
|
|
$winapi->function_external_calling_convention_in_module($forward_module, $forward_external_name);
|
|
|
|
if(!defined($forward_external_calling_convention)) {
|
|
next;
|
|
}
|
|
|
|
if($forward_external_calling_convention ne "stub" &&
|
|
$module_pseudo_stub{$forward_module}{$forward_external_name})
|
|
{
|
|
$forward_external_calling_convention = "pseudo_stub";
|
|
}
|
|
|
|
$external_calling_convention = "forward_$forward_external_calling_convention";
|
|
}
|
|
|
|
$module_counts{$module}{$external_calling_convention}++;
|
|
}
|
|
}
|
|
|
|
foreach my $module ($winapi->all_modules) {
|
|
my $pseudo_stubs = $module_counts{$module}{pseudo_stub} || 0;
|
|
my $real_stubs = $module_counts{$module}{stub} || 0;
|
|
my $forward_pseudo_stubs = $module_counts{$module}{forward_pseudo_stub} || 0;
|
|
my $forward_real_stubs = $module_counts{$module}{forward_stub} || 0;
|
|
|
|
my $forwards = 0;
|
|
my $total = 0;
|
|
foreach my $calling_convention (keys(%{$module_counts{$module}})) {
|
|
my $count = $module_counts{$module}{$calling_convention};
|
|
if($calling_convention =~ /^forward/) {
|
|
$forwards += $count;
|
|
}
|
|
$total += $count;
|
|
}
|
|
|
|
if($total > 0) {
|
|
my $stubs = $real_stubs + $pseudo_stubs;
|
|
|
|
$output->write("*.c: $module: ");
|
|
$output->write("$stubs of $total functions are stubs ($real_stubs real, $pseudo_stubs pseudo) " .
|
|
"and $forwards are forwards\n");
|
|
}
|
|
|
|
if($forwards > 0) {
|
|
my $forward_stubs = $forward_real_stubs + $forward_pseudo_stubs;
|
|
|
|
$output->write("*.c: $module: ");
|
|
$output->write("$forward_stubs of $forwards forwarded functions are stubs " .
|
|
"($forward_real_stubs real, $forward_pseudo_stubs pseudo)\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if($options->winetest) {
|
|
foreach my $module ($win32api->all_modules) {
|
|
my $type = "win32";
|
|
|
|
my $package = $module;
|
|
$package =~ s/\.dll$//;
|
|
$package =~ s/\./_/g;
|
|
|
|
my @entries;
|
|
|
|
foreach my $external_name (sort(keys(%{$specifications{$module}{unknown}}))) {
|
|
my $entry = $specifications{$module}{unknown}{$external_name};
|
|
push @entries, $entry;
|
|
}
|
|
|
|
foreach my $ordinal (sort {$a <=> $b} keys(%{$specifications{$module}{fixed}})) {
|
|
my $entry = $specifications{$module}{fixed}{$ordinal};
|
|
push @entries, $entry;
|
|
}
|
|
|
|
foreach my $external_name (sort(keys(%{$specifications{$module}{unfixed}}))) {
|
|
my $entry = $specifications{$module}{unfixed}{$external_name};
|
|
push @entries, $entry;
|
|
}
|
|
|
|
my $n = 0;
|
|
foreach my $entry (@entries) {
|
|
my $external_name = $entry->{external_name};
|
|
my $ordinal = $entry->{ordinal};
|
|
my $function = $entry->{function};
|
|
|
|
my $return_kind = $function->return_kind32 || "undef";
|
|
my $calling_convention = $function->calling_convention32 || "undef";
|
|
my $refargument_kinds = $function->argument_kinds32;
|
|
|
|
my @argument_kinds;
|
|
if(defined($refargument_kinds)) {
|
|
@argument_kinds = map { $_ || "undef"; } @$refargument_kinds;
|
|
}
|
|
|
|
next if $calling_convention ne "stdcall";
|
|
next if $external_name eq "\@";
|
|
|
|
if($n == 0) {
|
|
open(OUT, "> $wine_dir/programs/winetest/include/${package}.pm") || die "Error: Can't open $wine_dir/programs/winetest/include/${package}.pm: $!\n";
|
|
|
|
print OUT "package ${package};\n";
|
|
print OUT "\n";
|
|
|
|
print OUT "use strict;\n";
|
|
print OUT "\n";
|
|
|
|
print OUT "require Exporter;\n";
|
|
print OUT "\n";
|
|
|
|
print OUT "use wine;\n";
|
|
print OUT "use vars qw(\@ISA \@EXPORT \@EXPORT_OK);\n";
|
|
print OUT "\n";
|
|
|
|
print OUT "\@ISA = qw(Exporter);\n";
|
|
print OUT "\@EXPORT = qw();\n";
|
|
print OUT "\@EXPORT_OK = qw();\n";
|
|
print OUT "\n";
|
|
|
|
print OUT "my \$module_declarations = {\n";
|
|
} elsif($n > 0) {
|
|
print OUT ",\n";
|
|
}
|
|
|
|
print OUT " \"\Q$external_name\E\" => [\"$return_kind\", [";
|
|
my $m = 0;
|
|
foreach my $argument_kind (@argument_kinds) {
|
|
if($m > 0) {
|
|
print OUT ", ";
|
|
}
|
|
print OUT "\"$argument_kind\"";
|
|
$m++;
|
|
}
|
|
print OUT "]]";
|
|
$n++;
|
|
}
|
|
|
|
if($n > 0) {
|
|
print OUT "\n";
|
|
print OUT "};\n";
|
|
print OUT "\n";
|
|
print OUT "&wine::declare(\"$module\",\%\$module_declarations);\n";
|
|
print OUT "push \@EXPORT, map { \"&\" . \$_; } sort(keys(\%\$module_declarations));\n";
|
|
print OUT "1;\n";
|
|
close(OUT);
|
|
}
|
|
}
|
|
}
|