tools/winapi_check/winapi_check - wine - Git at Google

 #!/usr/bin/perl -w

 # Copyright 1999-2000 Patrik Stridvall

 # Note that winapi_check are using heuristics quite heavily.
 # So always remember that:
 #
 # "Heuristics are bug ridden by definition.
 #  If they didn't have bugs, then they'd be algorithms."
 #
 # In other words, reported bugs are only potential bugs not
 # real bugs, so they are called issues rather than bugs.
 #

 use strict;

 my $wine_dir;
 my $winapi_check_dir;

 BEGIN {

     if($0 =~ /^((.*?)\/?tools\/winapi_check)\/winapi_check$/)
     {
 	$winapi_check_dir = $1;
 	if($2 ne "")
 	{
 	    $wine_dir = $2;
 	} else {
 	    $wine_dir = ".";
 	}
     }
     @INC = ($winapi_check_dir);

     require "modules.pm";
     require "nativeapi.pm";
     require "output.pm";
     require "preprocessor.pm";
     require "winapi.pm";
     require "winapi_documentation.pm";
     require "winapi_function.pm";
     require "winapi_local.pm";
     require "winapi_global.pm";
     require "winapi_options.pm";
     require "winapi_parser.pm";

     import modules;
     import nativeapi;
     import output;
     import preprocessor;
     import winapi;
     import winapi_documentation;
     import winapi_function;
     import winapi_local;
     import winapi_global;
     import winapi_options;
     import winapi_parser;
 }

 my $current_dir = ".";
 if(length($wine_dir) != 1) {
     my $pwd; chomp($pwd = `pwd`);
     foreach my $n (1..((length($wine_dir) + 1) / 3)) {
 	$pwd =~ s/\/([^\/]*)$//;
 	$current_dir = "$1/$current_dir";
     }
     $current_dir =~ s/\/.$//;
 }

 my $output = 'output'->new;

 my $options = winapi_options->new($output, \@ARGV, $wine_dir);
 if(!defined($options)) {
     $output->write("usage: winapi_check [--help] [<files>]\n");

     exit 1;
 } elsif($options->help) {
     $options->show_help;
     exit;
 }

 sub file_type {
     my $file = shift;

     my $file_dir = $file;
     if(!($file_dir =~ s/^(.*?)\/[^\/]*$/$1/)) {
 	$file_dir = ".";
     }

     $file_dir =~ s/^$wine_dir\///;

     if($file_dir =~ /^(libtest|program|rc|tests|tools)/ ||
        $file =~ /dbgmain\.c$/ ||
        $file =~ /wineclipsrv\.c$/) # FIXME: Kludge
     {
 	return "application";
     } elsif($file_dir =~ /^(debug|miscemu)/) {
 	return "emulator";
     } else {
 	return "library";
     }
 }

 my $modules = 'modules'->new($options, $output, $wine_dir, $current_dir, \&file_type, "$winapi_check_dir/modules.dat");

 my $win16api = 'winapi'->new($options, $output, "win16", "$winapi_check_dir/win16");
 my $win32api = 'winapi'->new($options, $output, "win32", "$winapi_check_dir/win32");
 my @winapis = ($win16api, $win32api);

 if($options->global) {
     'winapi'->read_all_spec_files($modules, $wine_dir, $current_dir, \&file_type, $win16api, $win32api);
 } else {
     my @spec_files = $modules->allowed_spec_files($wine_dir, $current_dir);
     'winapi'->read_spec_files($modules, $wine_dir, $current_dir, \@spec_files, $win16api, $win32api);
 }

 my $nativeapi = 'nativeapi'->new($options, $output, "$winapi_check_dir/nativeapi.dat", "$wine_dir/configure.in", "$wine_dir/include/config.h.in");

 for my $name ($win32api->all_functions) {
     my $module16 = $win16api->function_module($name);
     my $module32 = $win32api->function_module($name);

     if(defined($module16)) {
 	$win16api->found_shared_function($name);
 	$win32api->found_shared_function($name);

 	if($options->shared) {
 	    $output->write("*.spec: $name: is shared between $module16 (Win16) and $module32 (Win32)\n");
 	}
     }
 }

 my %includes;
 {
     my @files = map {
 	s/^.\/(.*)$/$1/;
 	$_;
     } split(/\n/, `find . -name \\*.h`);

     foreach my $file (@files) {
 	my $file_dir = $file;
 	if(!($file_dir =~ s/(.*?)\/[^\/]*$/$1/)) {
 	    $file_dir = ".";
 	}

 	$includes{$file} = { name => $file };

 	open(IN, "< $file");
 	while(<IN>) {
 	    if(/^\s*\#\s*include\s*\"(.*?)\"/) {
 		my $header = $1;
 		if(-e "$file_dir/$header") {
 		    $includes{$file}{includes}{"$file_dir/$header"}++;
 		} elsif(-e "$file_dir/../$header") { # FIXME: This is not correct
 		    $includes{$file}{includes}{"$file_dir/../$header"}++; # FIXME: This is not correct
 		} elsif(-e "$wine_dir/include/$header") {
 		    $includes{$file}{includes}{"include/$header"}++;
 		} else {
 		    $output->write("$file: #include \"$header\" is not a local include\n");
 		}
 	    }
 	}
 	close(IN);
     }

     my @files2 = ("acconfig.h", "poppack.h", "pshpack1.h", "pshpack2.h", "pshpack4.h", "pshpack8.h",
                   "storage.h", "ver.h");
     foreach my $file2 (@files2) {
 	$includes{"include/$file2"}{used}++;
     }
 }

 my %declared_functions;

 my $progress_output;
 my $progress_current=0;
 my $progress_max=scalar($options->c_files);

 if($options->headers) {
     $progress_max += scalar($options->h_files);

     foreach my $file ($options->h_files) {
 	my %functions;

 	$progress_current++;
 	if($options->progress) {
 	    $output->progress("$file: file $progress_current of $progress_max");
 	}

 	my $found_function = sub {
 	    my $documentation = shift;
 	    my $linkage = shift;
 	    my $return_type = shift;
 	    my $calling_convention = shift;
 	    my $internal_name = shift;
 	    my $refargument_types = shift;
 	    my @argument_types = @$refargument_types;
 	    my $refargument_names = shift;
 	    my @argument_names = @$refargument_names;
 	    my $refargument_documentations = shift;
 	    my @argument_documentations = @$refargument_documentations;
 	    my $statements = shift;

 	    foreach my $winapi (@winapis) {
 		my $module = $winapi->function_module($internal_name);
 		if(!defined($module)) { next }

 		my $external_name = $winapi->function_external_name($internal_name);
 		# FIXME: Kludge because of the THUNK variants
 		if(!defined($external_name)) {
 		    next;
 		}

 		my $output_function = sub {
 		    my $message = shift;

 		    $output->write("$file: $module: $return_type ");
 		    $output->write("$calling_convention ") if $calling_convention;
 		    $output->write("$internal_name(" . join(",", @argument_types) . "): $message\n");
 		};

 		if(!defined($declared_functions{$winapi->name}{$external_name})) {
 		    $declared_functions{$winapi->name}{$external_name} = "$file";
 		} elsif($options->headers_duplicated) {
 		    my $message = "declared more than once";
 		    if($file ne $declared_functions{$winapi->name}{$external_name}) {
 			$message .= ", first declaration in '" . $declared_functions{$winapi->name}{$external_name} . "'";
 		    }
 	            &$output_function("$message");
 		}

 		if($options->headers_misplaced) {
 		    if($file =~ /^include\/[^\/]*$/ && $winapi->name eq "win16") {
 			&$output_function("declaration misplaced");
 		    } elsif($file =~ /^include\/wine\/[^\/]*$/ && $winapi->name eq "win32") {
 			&$output_function("declaration misplaced");
 		    }
 		}
 	    }
 	};

 	my $found_preprocessor = sub {
 	    my $directive = shift;
 	    my $argument = shift;
 	};

         winapi_parser::parse_c_file $options, $output, $file, $found_function, $found_preprocessor;
     }
 }

 my %module_pseudo_stub_count16;
 my %module_pseudo_stub_count32;

 foreach my $file ($options->c_files) {
     my %functions = ();

     my $file_module16 = $modules->allowed_modules_in_file("$current_dir/$file");
     my $file_module32 = $modules->allowed_modules_in_file("$current_dir/$file");

     $progress_current++;
     if($options->progress) {
 	$output->progress("$file: file $progress_current of $progress_max");
     }

     my $file_dir = $file;
     if(!($file_dir =~ s/(.*?)\/[^\/]*$/$1/)) {
 	$file_dir = ".";
     }

     my $file_type = file_type($file);

     my $found_function = sub {
 	my $documentation = shift;
 	my $linkage = shift;
 	my $return_type = shift;
 	my $calling_convention = shift;
 	my $internal_name = shift;
 	my $refargument_types = shift;
 	my @argument_types = @$refargument_types;
 	my $refargument_names = shift;
 	my @argument_names = @$refargument_names;
 	my $refargument_documentations = shift;
 	my @argument_documentations = @$refargument_documentations;
 	my $statements = shift;

 	my $external_name16 = $win16api->function_external_name($internal_name);
 	my $external_name32 = $win32api->function_external_name($internal_name);

 	if($options->global) {
 	    $win16api->found_type($return_type) if $options->win16;
 	    $win32api->found_type($return_type) if $options->win32;
 	    for my $argument (@argument_types) {
 		$win16api->found_type($argument) if $options->win16;
 		$win32api->found_type($argument) if $options->win32;
 	    }

 	    $win16api->found_function($internal_name) if $options->win16;
 	    $win32api->found_function($internal_name) if $options->win32;
 	}

 	if($file_type ne "application") {
 	    my $module16 = $win16api->function_module($internal_name);
 	    my $module32 = $win32api->function_module($internal_name);

 	    if(defined($module16)) {
 		$modules->found_module_in_dir($module16, $file_dir);
 	    }
 	    if(defined($module32)) {
 		$modules->found_module_in_dir($module32, $file_dir);
 	    }

 	    my $function = 'winapi_function'->new;
 	    $functions{$internal_name} = $function;

  	    $function->documentation($documentation);
 	    $function->linkage($linkage);
 	    $function->file($file);
 	    $function->return_type($return_type);
 	    $function->calling_convention($calling_convention);
 	    $function->external_name16($external_name16);
 	    $function->external_name32($external_name32);
 	    $function->internal_name($internal_name);
 	    $function->argument_types([@argument_types]);
 	    $function->argument_names([@argument_names]);
  	    $function->argument_documentations([@argument_documentations]);
 	    $function->statements($statements);
 	    $function->module16($module16);
 	    $function->module32($module32);

 	    my $prefix = "";
 	    $prefix .= "$file: ";
 	    if(defined($module16) && !defined($module32)) {
 		$prefix .= "$module16: ";
 	    } elsif(!defined($module16) && defined($module32)) {
 		$prefix .= "$module32: ";
 	    } elsif(defined($module16) && defined($module32)) {
 		$prefix .= "$module16 & $module32: ";
 	    } else {
 		$prefix .= "<>: ";
 	    }
             $prefix .= "$return_type ";
 	    $prefix .= "$calling_convention " if $calling_convention;
 	    $prefix .= "$internal_name(" . join(",", @argument_types) . "): ";
 	    $output->prefix($prefix);

 	    if($options->local && $options->misplaced &&
 	       $linkage ne "extern" && $statements)
 	    {
 		if($options->win16 && $options->report_module($module16)) {
 		    my $match = 0;
 		    foreach my $module (split(/ & /, $module16)) {
 			foreach my $file_module (split(/ & /, $file_module16)) {
 			    if($module eq $file_module) {
 				$match++;
 			    }
 			}
 		    }
 		    if(!$match && $file ne "library/port.c" && !$nativeapi->is_function($internal_name)) {
 			$output->write("is misplaced\n");
 		    }
 		}

 		if($options->win32 && $options->report_module($module32)) {
 		    my $match = 0;
 		    foreach my $module (split(/ & /, $module32)) {
 			foreach my $file_module (split(/ & /, $file_module32)) {
 			    if($module eq $file_module) {
 				$match++;
 			    }
 			}
 		    }
 		    if(!$match && $file ne "library/port.c" && !$nativeapi->is_function($internal_name)) {
 			$output->write("is misplaced\n");
 		    }
 		}
 	    }

 	    if($options->local && $options->headers && $options->prototype) {
 		if($options->win16 && $options->report_module($module16)) {
 		    if(!defined($external_name16) || (!$nativeapi->is_function($external_name16) &&
 		       !defined($declared_functions{$win16api->name}{$external_name16})))
 		    {
 			if(!defined($external_name16) || ($external_name16 !~ /^DllEntryPoint$/ &&
 			    $internal_name !~ /^I(?:Malloc|Storage)16_fn/ &&
 			    $internal_name !~ /^(?:\Q$module16\E|THUNK|WIN16)_\Q$external_name16\E(?:16)?$/))
 			{
 			    $output->write("no prototype\n");
 			}
 		    }
 		}

 		if($options->win32 && $options->report_module($module32)) {
 		    if(!defined($external_name32) || (!$nativeapi->is_function($external_name32) && 						          !defined($declared_functions{$win32api->name}{$external_name32})))
 		    {
 			if(!defined($external_name32) || ($external_name32 !~ /^Dll(?:
 			   Install|CanUnloadNow|GetClassObject|GetVersion|
 			   RegisterServer|RegisterServerEx|UnregisterServer)|DriverProc$/x &&
 			   $internal_name !~ /^COMCTL32_Str/ &&
 			   $internal_name !~ /^(?:\Q$module32\E|wine)_(?:\Q$external_name32\E|\d+)$/))
 			{
 			    $output->write("no prototype\n");
 			}
 		    }
 		}
 	    }

 	    if($options->local && $options->argument) {
 		if($options->win16 && $options->report_module($module16)) {
 		  winapi_local::check_function $options, $output,
 		    $return_type, $calling_convention, $external_name16, $internal_name, [@argument_types], $nativeapi, $win16api;
 		}
 		if($options->win32 && $options->report_module($module32)) {
 		  winapi_local::check_function $options, $output,
 		    $return_type, $calling_convention, $external_name32, $internal_name, [@argument_types], $nativeapi, $win32api;
 		}
 	    }

 	    if($options->local && $options->statements) {
 		if($options->win16 && $options->report_module($module16)) {
 		  winapi_local::check_statements $options, $output, $win16api, \%functions, $function;
 		}

 		if($options->win32 && $options->report_module($module32)) {
 		  winapi_local::check_statements $options, $output, $win32api, \%functions, $function;
 		}
 	    }

 	    if($options->stubs) {
 		if(defined($statements) && $statements =~ /FIXME[^;]*stub/) {
 		    if($options->win16 && $options->report_module($module16)) {
 			foreach my $module (split(/ \& /, $module16)) {
 			    $module_pseudo_stub_count16{$module}++;
 			}
 		    }
 		    if($options->win32 && $options->report_module($module32)) {
 			foreach my $module (split(/ \& /, $module32)) {
 			    $module_pseudo_stub_count32{$module}++;
 			}
 		    }
 		}
 	    }

 	    if($options->local && $options->documentation &&
 	       (defined($module16) || defined($module32)) &&
 	       $linkage ne "extern" && $statements)
 	    {
 	        winapi_documentation::check_documentation $options, $output, $win16api, $win32api, $function;
 	    }
 	    $output->prefix("");
 	}
     };

     my $config = 0;
     my $conditional = 0;
     my $found_include = sub {
 	local $_ = shift;
 	if(/^\"config\.h\"/) {
 	    $config++;
 	}
     };
     my $found_conditional = sub {
 	local $_ = shift;

 	$nativeapi->found_conditional($_);

 	if($options->config) {
 	    if($file_type ne "application") {
 		if(!$nativeapi->is_conditional($_)) {
 		    if(/^HAVE_/ && !/^HAVE_(IPX|MESAGL|BUGGY_MESAGL|WINE_CONSTRUCTOR)$/)
 		    {
 			$output->write("$file: $_ is not declared as a conditional\n");
 		    }
 		} else {
 		    $conditional++;
 		    if(!$config) {
 			$output->write("$file: conditional $_ used but config.h is not included\n");
 		    }
 		}
 	    }
 	}
     };
     my $preprocessor = 'preprocessor'->new($found_include, $found_conditional);
     my $found_preprocessor = sub {
 	my $directive = shift;
 	my $argument = shift;

 	$preprocessor->directive($directive, $argument);

 	if($options->config) {
 	    if($directive eq "include") {
 		my $header;
 		my $check_protection;
 		my $check_local;
 		if($argument =~ /^<(.*?)>$/) {
 		   $header = $1;
 		   if($file_type ne "application") {
 		       $check_protection = 1;
 		   } else {
 		       $check_protection = 0;
 		   }
 		   $check_local = 0;
 		} elsif($argument =~ /^"(.*?)"$/) {
 		   $header = $1;
 		   $check_protection = 0;
 		   $check_local = 1;
 		}

 		if($check_protection) {
 		    if((-e "$wine_dir/include/$header" || -e "$file_dir/$header")) {
 			if($header !~ /^ctype.h$/) {
 			    $output->write("$file: #include \<$header\> is a local include\n");
 			}
 		    }

 		    my $macro = uc($header);
 		    $macro =~ y/\.\//__/;
 		    $macro = "HAVE_" . $macro;

 		    if($nativeapi->is_conditional_header($header)) {
 			if(!$preprocessor->is_def($macro)) {
 			    if($macro =~ /^HAVE_X11/) {
 				# Do nothing X Windows is handled differently
 			    } elsif($macro =~ /^HAVE_(.*?)_H$/) {
 				if($header ne "alloca.h" && !$preprocessor->is_def("STATFS_DEFINED_BY_$1")) {
 				    $output->write("$file: #$directive $argument: is a conditional include, " .
 						   "but is not protected\n");
 				}
 			    }
 			}
 		    } elsif($preprocessor->is_def($macro)) {
 			$output->write("$file: #$directive $argument: is protected, " .
 				       "but is not a conditional include\n");
 		    }
 		}

 		if($check_local) {
 		    if(-e "$file_dir/$header") {
 			$includes{"$file_dir/$header"}{used}++;
 			foreach my $name (keys(%{$includes{"$file_dir/$header"}{includes}})) {
 			    $includes{$name}{used}++;
 			}
 		    } elsif(-e "$file_dir/../$header") { # FIXME: Kludge
 			$includes{"$file_dir/../$header"}{used}++; # FIXME: This is not correct
 			foreach my $name (keys(%{$includes{"$file_dir/../$header"}{includes}})) { # FIXME: This is not correct
 			    $includes{$name}{used}++;
 			}
 		    } elsif($header eq "controls.h") { # FIXME: Kludge
 			$includes{"dlls/user/$header"}{used}++;
 			foreach my $name (keys(%{$includes{"dlls/user/$header"}{includes}})) {
 			    $includes{$name}{used}++;
 			}
 		    } elsif(-e "$wine_dir/include/$header") {
 			$includes{"include/$header"}{used}++;
 			foreach my $name (keys(%{$includes{"include/$header"}{includes}})) {
 			    $includes{$name}{used}++;
 			}
 		    } else {
 			$output->write("$file: #include \"$header\" is not a local include\n");
 		    }
 		}
 	    }
 	}
     };

     winapi_parser::parse_c_file $options, $output, $file, $found_function, $found_preprocessor;

     if($options->config_unnessary) {
 	if($config && $conditional == 0) {
 	    $output->write("$file: includes config.h but do not use any conditionals\n");
 	}
     }

     winapi_local::check_file $options, $output, $file, \%functions;
 }

 $output->hide_progress;

 if($options->global) {
     winapi_documentation::report_documentation $options, $output;

     if($options->stubs) {
 	if($options->win16) {
 	    my %module_stub_count16;
 	    my %module_total_count16;

 	    foreach my $name ($win16api->all_functions,$win16api->all_functions_stub) {
 		foreach my $module (split(/ \& /, $win16api->function_module($name))) {
 		    if($win16api->function_stub($name)) {
 			$module_stub_count16{$module}++;
 		    }
 		    $module_total_count16{$module}++;
 		}
 	    }

 	    foreach my $module ($win16api->all_modules) {
 		if($options->report_module($module)) {
 		    my $real_stubs = $module_stub_count16{$module};
 		    my $pseudo_stubs = $module_pseudo_stub_count16{$module};

 		    if(!defined($real_stubs)) { $real_stubs = 0; }
 		    if(!defined($pseudo_stubs)) { $pseudo_stubs = 0; }

 		    my $stubs = $real_stubs + $pseudo_stubs;
 		    my $total = $module_total_count16{$module};

 		    if(!defined($total)) { $total = 0;}

 		    $output->write("*.c: $module: ");
 		    $output->write("$stubs of $total functions are stubs ($real_stubs real, $pseudo_stubs pseudo)\n");
 		}
 	    }
 	}

 	if($options->win32) {
 	    my %module_stub_count32;
 	    my %module_total_count32;

 	    foreach my $name ($win32api->all_functions,$win32api->all_functions_stub) {
 		foreach my $module (split(/ \& /, $win32api->function_module($name))) {
 		    if($win32api->function_stub($name)) {
 			$module_stub_count32{$module}++;
 		    }
 		    $module_total_count32{$module}++;
 		}
 	    }

 	    foreach my $module ($win32api->all_modules) {
 		if($options->report_module($module)) {
 		    my $real_stubs = $module_stub_count32{$module};
 		    my $pseudo_stubs = $module_pseudo_stub_count32{$module};

 		    if(!defined($real_stubs)) { $real_stubs = 0; }
 		    if(!defined($pseudo_stubs)) { $pseudo_stubs = 0; }

 		    my $stubs = $real_stubs + $pseudo_stubs;
 		    my $total = $module_total_count32{$module};

 		    if(!defined($total)) { $total = 0;}

 		    $output->write("*.c: $module: ");
 		    $output->write("$stubs of $total functions are stubs ($real_stubs real, $pseudo_stubs pseudo)\n");
 		}
 	    }
 	}
     }

     if($options->headers) {
 	foreach my $name (sort(keys(%includes))) {
 	    if(!$includes{$name}{used}) {
 		if($options->include) {
 		    $output->write("*.c: $name: include file is never used\n");
 		}
 	    }
 	}
     }

     winapi_global::check $options, $output, $win16api, $nativeapi if $options->win16;
     winapi_global::check $options, $output, $win32api, $nativeapi if $options->win32;

     $modules->global_report;
     $nativeapi->global_report;
 }
	#!/usr/bin/perl -w

	# Copyright 1999-2000 Patrik Stridvall

	# Note that winapi_check are using heuristics quite heavily.
	# So always remember that:
	#
	# "Heuristics are bug ridden by definition.
	# If they didn't have bugs, then they'd be algorithms."
	#
	# In other words, reported bugs are only potential bugs not
	# real bugs, so they are called issues rather than bugs.
	#

	use strict;

	my $wine_dir;
	my $winapi_check_dir;

	BEGIN {

	if($0 =~ /^((.*?)\/?tools\/winapi_check)\/winapi_check$/)
	{
	$winapi_check_dir = $1;
	if($2 ne "")
	{
	$wine_dir = $2;
	} else {
	$wine_dir = ".";
	}
	}
	@INC = ($winapi_check_dir);

	require "modules.pm";
	require "nativeapi.pm";
	require "output.pm";
	require "preprocessor.pm";
	require "winapi.pm";
	require "winapi_documentation.pm";
	require "winapi_function.pm";
	require "winapi_local.pm";
	require "winapi_global.pm";
	require "winapi_options.pm";
	require "winapi_parser.pm";

	import modules;
	import nativeapi;
	import output;
	import preprocessor;
	import winapi;
	import winapi_documentation;
	import winapi_function;
	import winapi_local;
	import winapi_global;
	import winapi_options;
	import winapi_parser;
	}

	my $current_dir = ".";
	if(length($wine_dir) != 1) {
	my $pwd; chomp($pwd = `pwd`);
	foreach my $n (1..((length($wine_dir) + 1) / 3)) {
	$pwd =~ s/\/([^\/]*)$//;
	$current_dir = "$1/$current_dir";
	}
	$current_dir =~ s/\/.$//;
	}

	my $output = 'output'->new;

	my $options = winapi_options->new($output, \@ARGV, $wine_dir);
	if(!defined($options)) {
	$output->write("usage: winapi_check [--help] [<files>]\n");

	exit 1;
	} elsif($options->help) {
	$options->show_help;
	exit;
	}

	sub file_type {
	my $file = shift;

	my $file_dir = $file;
	if(!($file_dir =~ s/^(.?)\/[^\/]$/$1/)) {
	$file_dir = ".";
	}

	$file_dir =~ s/^$wine_dir\///;

	if($file_dir =~ /^(libtest\|program\|rc\|tests\|tools)/ \|\|
	$file =~ /dbgmain\.c$/ \|\|
	$file =~ /wineclipsrv\.c$/) # FIXME: Kludge
	{
	return "application";
	} elsif($file_dir =~ /^(debug\|miscemu)/) {
	return "emulator";
	} else {
	return "library";
	}
	}

	my $modules = 'modules'->new($options, $output, $wine_dir, $current_dir, \&file_type, "$winapi_check_dir/modules.dat");

	my $win16api = 'winapi'->new($options, $output, "win16", "$winapi_check_dir/win16");
	my $win32api = 'winapi'->new($options, $output, "win32", "$winapi_check_dir/win32");
	my @winapis = ($win16api, $win32api);

	if($options->global) {
	'winapi'->read_all_spec_files($modules, $wine_dir, $current_dir, \&file_type, $win16api, $win32api);
	} else {
	my @spec_files = $modules->allowed_spec_files($wine_dir, $current_dir);
	'winapi'->read_spec_files($modules, $wine_dir, $current_dir, \@spec_files, $win16api, $win32api);
	}

	my $nativeapi = 'nativeapi'->new($options, $output, "$winapi_check_dir/nativeapi.dat", "$wine_dir/configure.in", "$wine_dir/include/config.h.in");

	for my $name ($win32api->all_functions) {
	my $module16 = $win16api->function_module($name);
	my $module32 = $win32api->function_module($name);

	if(defined($module16)) {
	$win16api->found_shared_function($name);
	$win32api->found_shared_function($name);

	if($options->shared) {
	$output->write("*.spec: $name: is shared between $module16 (Win16) and $module32 (Win32)\n");
	}
	}
	}

	my %includes;
	{
	my @files = map {
	s/^.\/(.*)$/$1/;
	$_;
	} split(/\n/, `find . -name \\*.h`);

	foreach my $file (@files) {
	my $file_dir = $file;
	if(!($file_dir =~ s/(.?)\/[^\/]$/$1/)) {
	$file_dir = ".";
	}

	$includes{$file} = { name => $file };

	open(IN, "< $file");
	while(<IN>) {
	if(/^\s\#\sinclude\s\"(.?)\"/) {
	my $header = $1;
	if(-e "$file_dir/$header") {
	$includes{$file}{includes}{"$file_dir/$header"}++;
	} elsif(-e "$file_dir/../$header") { # FIXME: This is not correct
	$includes{$file}{includes}{"$file_dir/../$header"}++; # FIXME: This is not correct
	} elsif(-e "$wine_dir/include/$header") {
	$includes{$file}{includes}{"include/$header"}++;
	} else {
	$output->write("$file: #include \"$header\" is not a local include\n");
	}
	}
	}
	close(IN);
	}

	my @files2 = ("acconfig.h", "poppack.h", "pshpack1.h", "pshpack2.h", "pshpack4.h", "pshpack8.h",
	"storage.h", "ver.h");
	foreach my $file2 (@files2) {
	$includes{"include/$file2"}{used}++;
	}
	}

	my %declared_functions;

	my $progress_output;
	my $progress_current=0;
	my $progress_max=scalar($options->c_files);

	if($options->headers) {
	$progress_max += scalar($options->h_files);

	foreach my $file ($options->h_files) {
	my %functions;

	$progress_current++;
	if($options->progress) {
	$output->progress("$file: file $progress_current of $progress_max");
	}

	my $found_function = sub {
	my $documentation = shift;
	my $linkage = shift;
	my $return_type = shift;
	my $calling_convention = shift;
	my $internal_name = shift;
	my $refargument_types = shift;
	my @argument_types = @$refargument_types;
	my $refargument_names = shift;
	my @argument_names = @$refargument_names;
	my $refargument_documentations = shift;
	my @argument_documentations = @$refargument_documentations;
	my $statements = shift;

	foreach my $winapi (@winapis) {
	my $module = $winapi->function_module($internal_name);
	if(!defined($module)) { next }

	my $external_name = $winapi->function_external_name($internal_name);
	# FIXME: Kludge because of the THUNK variants
	if(!defined($external_name)) {
	next;
	}

	my $output_function = sub {
	my $message = shift;

	$output->write("$file: $module: $return_type ");
	$output->write("$calling_convention ") if $calling_convention;
	$output->write("$internal_name(" . join(",", @argument_types) . "): $message\n");
	};

	if(!defined($declared_functions{$winapi->name}{$external_name})) {
	$declared_functions{$winapi->name}{$external_name} = "$file";
	} elsif($options->headers_duplicated) {
	my $message = "declared more than once";
	if($file ne $declared_functions{$winapi->name}{$external_name}) {
	$message .= ", first declaration in '" . $declared_functions{$winapi->name}{$external_name} . "'";
	}
	&$output_function("$message");
	}

	if($options->headers_misplaced) {
	if($file =~ /^include\/[^\/]*$/ && $winapi->name eq "win16") {
	&$output_function("declaration misplaced");
	} elsif($file =~ /^include\/wine\/[^\/]*$/ && $winapi->name eq "win32") {
	&$output_function("declaration misplaced");
	}
	}
	}
	};

	my $found_preprocessor = sub {
	my $directive = shift;
	my $argument = shift;
	};

	winapi_parser::parse_c_file $options, $output, $file, $found_function, $found_preprocessor;
	}
	}

	my %module_pseudo_stub_count16;
	my %module_pseudo_stub_count32;

	foreach my $file ($options->c_files) {
	my %functions = ();

	my $file_module16 = $modules->allowed_modules_in_file("$current_dir/$file");
	my $file_module32 = $modules->allowed_modules_in_file("$current_dir/$file");

	$progress_current++;
	if($options->progress) {
	$output->progress("$file: file $progress_current of $progress_max");
	}

	my $file_dir = $file;
	if(!($file_dir =~ s/(.?)\/[^\/]$/$1/)) {
	$file_dir = ".";
	}

	my $file_type = file_type($file);

	my $found_function = sub {
	my $documentation = shift;
	my $linkage = shift;
	my $return_type = shift;
	my $calling_convention = shift;
	my $internal_name = shift;
	my $refargument_types = shift;
	my @argument_types = @$refargument_types;
	my $refargument_names = shift;
	my @argument_names = @$refargument_names;
	my $refargument_documentations = shift;
	my @argument_documentations = @$refargument_documentations;
	my $statements = shift;

	my $external_name16 = $win16api->function_external_name($internal_name);
	my $external_name32 = $win32api->function_external_name($internal_name);

	if($options->global) {
	$win16api->found_type($return_type) if $options->win16;
	$win32api->found_type($return_type) if $options->win32;
	for my $argument (@argument_types) {
	$win16api->found_type($argument) if $options->win16;
	$win32api->found_type($argument) if $options->win32;
	}

	$win16api->found_function($internal_name) if $options->win16;
	$win32api->found_function($internal_name) if $options->win32;
	}

	if($file_type ne "application") {
	my $module16 = $win16api->function_module($internal_name);
	my $module32 = $win32api->function_module($internal_name);

	if(defined($module16)) {
	$modules->found_module_in_dir($module16, $file_dir);
	}
	if(defined($module32)) {
	$modules->found_module_in_dir($module32, $file_dir);
	}

	my $function = 'winapi_function'->new;
	$functions{$internal_name} = $function;

	$function->documentation($documentation);
	$function->linkage($linkage);
	$function->file($file);
	$function->return_type($return_type);
	$function->calling_convention($calling_convention);
	$function->external_name16($external_name16);
	$function->external_name32($external_name32);
	$function->internal_name($internal_name);
	$function->argument_types([@argument_types]);
	$function->argument_names([@argument_names]);
	$function->argument_documentations([@argument_documentations]);
	$function->statements($statements);
	$function->module16($module16);
	$function->module32($module32);

	my $prefix = "";
	$prefix .= "$file: ";
	if(defined($module16) && !defined($module32)) {
	$prefix .= "$module16: ";
	} elsif(!defined($module16) && defined($module32)) {
	$prefix .= "$module32: ";
	} elsif(defined($module16) && defined($module32)) {
	$prefix .= "$module16 & $module32: ";
	} else {
	$prefix .= "<>: ";
	}
	$prefix .= "$return_type ";
	$prefix .= "$calling_convention " if $calling_convention;
	$prefix .= "$internal_name(" . join(",", @argument_types) . "): ";
	$output->prefix($prefix);

	if($options->local && $options->misplaced &&
	$linkage ne "extern" && $statements)
	{
	if($options->win16 && $options->report_module($module16)) {
	my $match = 0;
	foreach my $module (split(/ & /, $module16)) {
	foreach my $file_module (split(/ & /, $file_module16)) {
	if($module eq $file_module) {
	$match++;
	}
	}
	}
	if(!$match && $file ne "library/port.c" && !$nativeapi->is_function($internal_name)) {
	$output->write("is misplaced\n");
	}
	}

	if($options->win32 && $options->report_module($module32)) {
	my $match = 0;
	foreach my $module (split(/ & /, $module32)) {
	foreach my $file_module (split(/ & /, $file_module32)) {
	if($module eq $file_module) {
	$match++;
	}
	}
	}
	if(!$match && $file ne "library/port.c" && !$nativeapi->is_function($internal_name)) {
	$output->write("is misplaced\n");
	}
	}
	}

	if($options->local && $options->headers && $options->prototype) {
	if($options->win16 && $options->report_module($module16)) {
	if(!defined($external_name16) \|\| (!$nativeapi->is_function($external_name16) &&
	!defined($declared_functions{$win16api->name}{$external_name16})))
	{
	if(!defined($external_name16) \|\| ($external_name16 !~ /^DllEntryPoint$/ &&
	$internal_name !~ /^I(?:Malloc\|Storage)16_fn/ &&
	$internal_name !~ /^(?:\Q$module16\E\|THUNK\|WIN16)_\Q$external_name16\E(?:16)?$/))
	{
	$output->write("no prototype\n");
	}
	}
	}

	if($options->win32 && $options->report_module($module32)) {
	if(!defined($external_name32) \|\| (!$nativeapi->is_function($external_name32) && !defined($declared_functions{$win32api->name}{$external_name32})))
	{
	if(!defined($external_name32) \|\| ($external_name32 !~ /^Dll(?:
	Install\|CanUnloadNow\|GetClassObject\|GetVersion\|
	RegisterServer\|RegisterServerEx\|UnregisterServer)\|DriverProc$/x &&
	$internal_name !~ /^COMCTL32_Str/ &&
	$internal_name !~ /^(?:\Q$module32\E\|wine)_(?:\Q$external_name32\E\|\d+)$/))
	{
	$output->write("no prototype\n");
	}
	}
	}
	}

	if($options->local && $options->argument) {
	if($options->win16 && $options->report_module($module16)) {
	winapi_local::check_function $options, $output,
	$return_type, $calling_convention, $external_name16, $internal_name, [@argument_types], $nativeapi, $win16api;
	}
	if($options->win32 && $options->report_module($module32)) {
	winapi_local::check_function $options, $output,
	$return_type, $calling_convention, $external_name32, $internal_name, [@argument_types], $nativeapi, $win32api;
	}
	}

	if($options->local && $options->statements) {
	if($options->win16 && $options->report_module($module16)) {
	winapi_local::check_statements $options, $output, $win16api, \%functions, $function;
	}

	if($options->win32 && $options->report_module($module32)) {
	winapi_local::check_statements $options, $output, $win32api, \%functions, $function;
	}
	}

	if($options->stubs) {
	if(defined($statements) && $statements =~ /FIXME[^;]*stub/) {
	if($options->win16 && $options->report_module($module16)) {
	foreach my $module (split(/ \& /, $module16)) {
	$module_pseudo_stub_count16{$module}++;
	}
	}
	if($options->win32 && $options->report_module($module32)) {
	foreach my $module (split(/ \& /, $module32)) {
	$module_pseudo_stub_count32{$module}++;
	}
	}
	}
	}

	if($options->local && $options->documentation &&
	(defined($module16) \|\| defined($module32)) &&
	$linkage ne "extern" && $statements)
	{
	winapi_documentation::check_documentation $options, $output, $win16api, $win32api, $function;
	}
	$output->prefix("");
	}
	};

	my $config = 0;
	my $conditional = 0;
	my $found_include = sub {
	local $_ = shift;
	if(/^\"config\.h\"/) {
	$config++;
	}
	};
	my $found_conditional = sub {
	local $_ = shift;

	$nativeapi->found_conditional($_);

	if($options->config) {
	if($file_type ne "application") {
	if(!$nativeapi->is_conditional($_)) {
	if(/^HAVE_/ && !/^HAVE_(IPX\|MESAGL\|BUGGY_MESAGL\|WINE_CONSTRUCTOR)$/)
	{
	$output->write("$file: $_ is not declared as a conditional\n");
	}
	} else {
	$conditional++;
	if(!$config) {
	$output->write("$file: conditional $_ used but config.h is not included\n");
	}
	}
	}
	}
	};
	my $preprocessor = 'preprocessor'->new($found_include, $found_conditional);
	my $found_preprocessor = sub {
	my $directive = shift;
	my $argument = shift;

	$preprocessor->directive($directive, $argument);

	if($options->config) {
	if($directive eq "include") {
	my $header;
	my $check_protection;
	my $check_local;
	if($argument =~ /^<(.*?)>$/) {
	$header = $1;
	if($file_type ne "application") {
	$check_protection = 1;
	} else {
	$check_protection = 0;
	}
	$check_local = 0;
	} elsif($argument =~ /^"(.*?)"$/) {
	$header = $1;
	$check_protection = 0;
	$check_local = 1;
	}

	if($check_protection) {
	if((-e "$wine_dir/include/$header" \|\| -e "$file_dir/$header")) {
	if($header !~ /^ctype.h$/) {
	$output->write("$file: #include \<$header\> is a local include\n");
	}
	}

	my $macro = uc($header);
	$macro =~ y/\.\//__/;
	$macro = "HAVE_" . $macro;

	if($nativeapi->is_conditional_header($header)) {
	if(!$preprocessor->is_def($macro)) {
	if($macro =~ /^HAVE_X11/) {
	# Do nothing X Windows is handled differently
	} elsif($macro =~ /^HAVE_(.*?)_H$/) {
	if($header ne "alloca.h" && !$preprocessor->is_def("STATFS_DEFINED_BY_$1")) {
	$output->write("$file: #$directive $argument: is a conditional include, " .
	"but is not protected\n");
	}
	}
	}
	} elsif($preprocessor->is_def($macro)) {
	$output->write("$file: #$directive $argument: is protected, " .
	"but is not a conditional include\n");
	}
	}

	if($check_local) {
	if(-e "$file_dir/$header") {
	$includes{"$file_dir/$header"}{used}++;
	foreach my $name (keys(%{$includes{"$file_dir/$header"}{includes}})) {
	$includes{$name}{used}++;
	}
	} elsif(-e "$file_dir/../$header") { # FIXME: Kludge
	$includes{"$file_dir/../$header"}{used}++; # FIXME: This is not correct
	foreach my $name (keys(%{$includes{"$file_dir/../$header"}{includes}})) { # FIXME: This is not correct
	$includes{$name}{used}++;
	}
	} elsif($header eq "controls.h") { # FIXME: Kludge
	$includes{"dlls/user/$header"}{used}++;
	foreach my $name (keys(%{$includes{"dlls/user/$header"}{includes}})) {
	$includes{$name}{used}++;
	}
	} elsif(-e "$wine_dir/include/$header") {
	$includes{"include/$header"}{used}++;
	foreach my $name (keys(%{$includes{"include/$header"}{includes}})) {
	$includes{$name}{used}++;
	}
	} else {
	$output->write("$file: #include \"$header\" is not a local include\n");
	}
	}
	}
	}
	};

	winapi_parser::parse_c_file $options, $output, $file, $found_function, $found_preprocessor;

	if($options->config_unnessary) {
	if($config && $conditional == 0) {
	$output->write("$file: includes config.h but do not use any conditionals\n");
	}
	}

	winapi_local::check_file $options, $output, $file, \%functions;
	}

	$output->hide_progress;

	if($options->global) {
	winapi_documentation::report_documentation $options, $output;

	if($options->stubs) {
	if($options->win16) {
	my %module_stub_count16;
	my %module_total_count16;

	foreach my $name ($win16api->all_functions,$win16api->all_functions_stub) {
	foreach my $module (split(/ \& /, $win16api->function_module($name))) {
	if($win16api->function_stub($name)) {
	$module_stub_count16{$module}++;
	}
	$module_total_count16{$module}++;
	}
	}

	foreach my $module ($win16api->all_modules) {
	if($options->report_module($module)) {
	my $real_stubs = $module_stub_count16{$module};
	my $pseudo_stubs = $module_pseudo_stub_count16{$module};

	if(!defined($real_stubs)) { $real_stubs = 0; }
	if(!defined($pseudo_stubs)) { $pseudo_stubs = 0; }

	my $stubs = $real_stubs + $pseudo_stubs;
	my $total = $module_total_count16{$module};

	if(!defined($total)) { $total = 0;}

	$output->write("*.c: $module: ");
	$output->write("$stubs of $total functions are stubs ($real_stubs real, $pseudo_stubs pseudo)\n");
	}
	}
	}

	if($options->win32) {
	my %module_stub_count32;
	my %module_total_count32;

	foreach my $name ($win32api->all_functions,$win32api->all_functions_stub) {
	foreach my $module (split(/ \& /, $win32api->function_module($name))) {
	if($win32api->function_stub($name)) {
	$module_stub_count32{$module}++;
	}
	$module_total_count32{$module}++;
	}
	}

	foreach my $module ($win32api->all_modules) {
	if($options->report_module($module)) {
	my $real_stubs = $module_stub_count32{$module};
	my $pseudo_stubs = $module_pseudo_stub_count32{$module};

	if(!defined($real_stubs)) { $real_stubs = 0; }
	if(!defined($pseudo_stubs)) { $pseudo_stubs = 0; }

	my $stubs = $real_stubs + $pseudo_stubs;
	my $total = $module_total_count32{$module};

	if(!defined($total)) { $total = 0;}

	$output->write("*.c: $module: ");
	$output->write("$stubs of $total functions are stubs ($real_stubs real, $pseudo_stubs pseudo)\n");
	}
	}
	}
	}

	if($options->headers) {
	foreach my $name (sort(keys(%includes))) {
	if(!$includes{$name}{used}) {
	if($options->include) {
	$output->write("*.c: $name: include file is never used\n");
	}
	}
	}
	}

	winapi_global::check $options, $output, $win16api, $nativeapi if $options->win16;
	winapi_global::check $options, $output, $win32api, $nativeapi if $options->win32;

	$modules->global_report;
	$nativeapi->global_report;
	}