7 my $class = ref($proto) || $proto;
11 my $options = \
${$self->{OPTIONS
}};
12 my $output = \
${$self->{OUTPUT
}};
13 my $name = \
${$self->{NAME
}};
23 } split(/\n/, `find $path -name \\*.api`);
25 foreach my $file (@files) {
27 $module =~ s/.*?\/([^\/]*?
)\
.api
$/$1/;
28 $self->parse_api_file($file,$module);
37 my $options = \
${$self->{OPTIONS
}};
38 my $output = \
${$self->{OUTPUT
}};
39 my $allowed_kind = \
%{$self->{ALLOWED_KIND
}};
40 my $allowed_modules = \
%{$self->{ALLOWED_MODULES
}};
41 my $allowed_modules_limited = \
%{$self->{ALLOWED_MODULES_LIMITED
}};
42 my $allowed_modules_unlimited = \
%{$self->{ALLOWED_MODULES_UNLIMITED
}};
43 my $translate_argument = \
%{$self->{TRANSLATE_ARGUMENT
}};
44 my $type_format = \
%{$self->{TYPE_FORMAT
}};
54 if($$options->progress) {
55 $$output->progress("$file");
58 open(IN
, "< $file") || die "$file: $!\n";
61 s/^\s*?(.*?)\s*$/$1/; # remove whitespace at begin and end of line
62 s/^(.*?)\s*#.*$/$1/; # remove comments
63 /^$/ && next; # skip empty lines
71 $$allowed_kind{$kind} = 1;
74 } elsif(/^--extension/) {
76 } elsif(/^--format=(\".*?\"|\S*)/) {
78 $format =~ s/^\"(.*?)\"$/$1/;
81 if(!defined($format)) {
83 $format = "%d|%u|%x|%X|";
84 $format .= "%hd|%hu|%hx|%hX|";
85 $format .= "%ld|%lu|%lx|%lX|";
86 $format .= "%04x|%04X|0x%04x|0x%04X|";
87 $format .= "%08x|%08X|0x%08x|0x%08X|";
88 $format .= "%08lx|%08lX|0x%08lx|0x%08lX";
89 } elsif($kind eq "longlong") {
91 } elsif($kind eq "ptr") {
93 } elsif($kind eq "segptr") {
95 } elsif($kind eq "str") {
97 } elsif($kind eq "wstr") {
99 } elsif($kind eq "word") {
100 $format = "%d|%u|%x|%X|";
101 $format .= "%hd|%hu|%hx|%hX|";
102 $format .= "%04x|%04X|0x%04x|0x%04X";
104 $format = "<unknown>";
107 } elsif(defined($kind)) {
110 if(defined($module)) {
111 if($$allowed_modules_unlimited{$type}) {
112 $$output->write("$file: type ($type) already specificed as an unlimited type\n");
113 } elsif(!$$allowed_modules{$type}{$module}) {
114 $$allowed_modules{$type}{$module} = 1;
115 $$allowed_modules_limited{$type} = 1;
117 $$output->write("$file: type ($type) already specificed\n");
120 $$allowed_modules_unlimited{$type} = 1;
123 $$allowed_modules_limited{$type} = 1;
125 if(defined($$translate_argument{$type}) && $$translate_argument{$type} ne $kind) {
126 $$output->write("$file: type ($type) respecified as different kind ($kind != $$translate_argument{$type})\n");
128 $$translate_argument{$type} = $kind;
131 $$type_format{$module}{$type} = $format;
133 $$output->write("$file: file must begin with %<type> statement\n");
140 sub get_spec_file_type
{
142 my $class = ref($proto) || $proto;
149 open(IN
, "< $file") || die "$file: $!\n";
156 if(/^name\s*(\S*)/) { $module = $1; }
157 if(/^type\s*(\w+)/) { $type = $1; }
159 if(defined($module) && defined($type)) { last; }
163 return ($type, $module);
166 sub read_spec_files
{
168 my $class = ref($proto) || $proto;
171 my $wine_dir = shift;
172 my $current_dir = shift;
174 my $win16api = shift;
175 my $win32api = shift;
177 foreach my $file (@
$files) {
178 (my $type, my $module) = 'winapi'->get_spec_file_type("$wine_dir/$file");
179 $modules->spec_file_module($file, $module);
180 if($type eq "win16") {
181 $win16api->parse_spec_file("$wine_dir/$file");
182 } elsif($type eq "win32") {
183 $win32api->parse_spec_file("$wine_dir/$file");
188 sub read_all_spec_files
{
190 my $class = ref($proto) || $proto;
193 my $wine_dir = shift;
194 my $current_dir = shift;
195 my $file_type = shift;
196 my $win16api = shift;
197 my $win32api = shift;
200 s/^$wine_dir\/(.*)$/$1/;
201 if(&$file_type($_) eq "library") {
206 } split(/\n/, `find $wine_dir -name \\*.spec`);
208 'winapi'->read_spec_files($modules, $wine_dir, $current_dir, \
@files, $win16api, $win32api);
211 sub parse_spec_file
{
214 my $options = \
${$self->{OPTIONS
}};
215 my $output = \
${$self->{OUTPUT
}};
216 my $function_arguments = \
%{$self->{FUNCTION_ARGUMENTS
}};
217 my $function_calling_convention = \
%{$self->{FUNCTION_CALLING_CONVENTION
}};
218 my $function_external_name = \
%{$self->{FUNCTION_EXTERNAL_NAME
}};
219 my $function_stub = \
%{$self->{FUNCTION_STUB
}};
220 my $function_module = \
%{$self->{FUNCTION_MODULE
}};
221 my $modules = \
%{$self->{MODULES
}};
229 if($$options->progress) {
230 $$output->progress("$file");
233 open(IN
, "< $file") || die "$file: $!\n";
237 while($lookahead || defined($_ = <IN
>)) {
244 if(/^name\s*(\S*)/) { $module = $1; }
245 if(/^type\s*(\w+)/) { $type = $1; }
246 if(/^\d+|@/) { $header = 0; $lookahead = 1; }
251 if(/^(\d+|@)\s+(pascal|pascal16|stdcall|cdecl|register|interrupt|varargs)\s+(\S+)\s*\(\s*(.*?)\s*\)\s*(\S+)$/) {
252 my $calling_convention = $2;
253 my $external_name = $3;
255 my $internal_name = $5;
259 # FIXME: Internal name existing more than once not handled properly
260 $$function_external_name{$internal_name} = $external_name;
261 $$function_arguments{$internal_name} = $arguments;
262 $$function_calling_convention{$internal_name} = $calling_convention;
263 if(!$$function_module{$internal_name}) {
264 $$function_module{$internal_name} = "$module";
265 } elsif($$function_module{$internal_name} !~ /$module/) {
266 $$function_module{$internal_name} .= " & $module";
269 if(0 && $$options->spec_mismatch) {
270 if($external_name eq "@") {
271 if($internal_name !~ /^\U$module\E_$ordinal$/) {
272 $$output->write("$file: $external_name: the internal name ($internal_name) mismatch\n");
275 my $name = $external_name;
281 $name2 =~ s/^(?:_|Rtl|k32|K32)//;
284 $name3 =~ s/^INT_Int[0-9a-f]{2}Handler$/BUILTIN_DefaultIntHandler/;
287 $name4 =~ s/^(VxDCall)\d$/$1/;
289 # FIXME: This special case is becuase of a very ugly kludge that should be fixed IMHO
291 $name5 =~ s/^(.*?16)_(.*?)$/$1_fn$2/;
293 if(uc($internal_name) ne uc($external_name) &&
294 $internal_name !~ /(\Q$name\E|\Q$name1\E|\Q$name2\E|\Q$name3\E|\Q$name4\E|\Q$name5\E)/)
296 $$output->write("$file: $external_name: internal name ($internal_name) mismatch\n");
300 } elsif(/^(\d+|@)\s+stub\s+(\S+)$/) {
301 my $external_name = $2;
306 if($type eq "win16") {
307 $internal_name = $external_name . "16";
309 $internal_name = $external_name;
312 # FIXME: Internal name existing more than once not handled properly
313 $$function_stub{$internal_name} = 1;
314 if(!$$function_module{$internal_name}) {
315 $$function_module{$internal_name} = "$module";
316 } elsif($$function_module{$internal_name} !~ /$module/) {
317 $$function_module{$internal_name} .= " & $module";
319 } elsif(/^(\d+|@)\s+(equate|long|word|extern|forward)/) {
322 my $next_line = <IN
>;
323 if(!defined($next_line) || $next_line =~ /^\s*\d|@/) {
324 die "$file: $.: syntax error: '$_'\n";
331 if(defined($ordinal)) {
332 if($ordinal ne "@" && $ordinals{$ordinal}) {
333 $$output->write("$file: ordinal redefined: $_\n");
335 $ordinals{$ordinal}++;
340 $$modules{$module}++;
345 my $name = \
${$self->{NAME
}};
350 sub is_allowed_kind
{
352 my $allowed_kind = \
%{$self->{ALLOWED_KIND
}};
356 return $$allowed_kind{$kind};
362 sub is_limited_type
{
364 my $allowed_modules_limited = \
%{$self->{ALLOWED_MODULES_LIMITED
}};
368 return $$allowed_modules_limited{$type};
371 sub allowed_type_in_module
{
373 my $allowed_modules = \
%{$self->{ALLOWED_MODULES
}};
374 my $allowed_modules_limited = \
%{$self->{ALLOWED_MODULES_LIMITED
}};
377 my @modules = split(/ \& /, shift);
379 if(!$$allowed_modules_limited{$type}) { return 1; }
381 foreach my $module (@modules) {
382 if($$allowed_modules{$type}{$module}) { return 1; }
388 sub type_used_in_module
{
390 my $used_modules = \
%{$self->{USED_MODULES
}};
393 my @modules = split(/ \& /, shift);
395 foreach my $module (@modules) {
396 $$used_modules{$type}{$module} = 1;
404 my $used_modules = \
%{$self->{USED_MODULES
}};
405 my $allowed_modules = \
%{$self->{ALLOWED_MODULES
}};
408 foreach my $type (sort(keys(%$allowed_modules))) {
409 foreach my $module (sort(keys(%{$$allowed_modules{$type}}))) {
410 if(!$$used_modules{$type}{$module}) {
411 $$not_used{$module}{$type} = 1;
418 sub types_unlimited_used_in_modules
{
421 my $output = \
${$self->{OUTPUT
}};
422 my $used_modules = \
%{$self->{USED_MODULES
}};
423 my $allowed_modules = \
%{$self->{ALLOWED_MODULES
}};
424 my $allowed_modules_unlimited = \
%{$self->{ALLOWED_MODULES_UNLIMITED
}};
427 foreach my $type (sort(keys(%$allowed_modules_unlimited))) {
430 foreach my $module (sort(keys(%{$$used_modules{$type}}))) {
432 push @modules, $module;
435 foreach my $module (@modules) {
436 $$used_types{$type}{$module} = 1;
443 sub translate_argument
{
445 my $translate_argument = \
%{$self->{TRANSLATE_ARGUMENT
}};
447 my $argument = shift;
449 return $$translate_argument{$argument};
452 sub all_declared_types
{
454 my $translate_argument = \
%{$self->{TRANSLATE_ARGUMENT
}};
456 return sort(keys(%$translate_argument));
461 my $type_found = \
%{$self->{TYPE_FOUND
}};
465 $$type_found{$name}++;
470 my $type_found= \
%{$self->{TYPE_FOUND
}};
474 return $$type_found{$name};
477 sub is_allowed_type_format
{
479 my $type_format = \
%{$self->{TYPE_FORMAT
}};
487 if(defined($module) && defined($type)) {
489 foreach (split(/ & /, $module)) {
490 if(defined($formats)) {
495 if(defined($$type_format{$_}{$type})) {
496 $formats .= $$type_format{$_}{$type};
501 if(defined($formats)) {
503 foreach (split(/\|/, $formats)) {
515 my $modules = \
%{$self->{MODULES
}};
517 return sort(keys(%$modules));
522 my $modules = \
%{$self->{MODULES
}};
526 return $$modules{$name};
531 my $function_calling_convention = \
%{$self->{FUNCTION_CALLING_CONVENTION
}};
533 return sort(keys(%$function_calling_convention));
536 sub all_functions_in_module
{
538 my $function_calling_convention = \
%{$self->{FUNCTION_CALLING_CONVENTION
}};
539 my $function_module = \
%{$self->{FUNCTION_MODULE
}};
544 foreach my $name (keys(%$function_calling_convention)) {
545 if($$function_module{$name} eq $module) {
553 sub all_functions_stub
{
555 my $function_stub = \
%{$self->{FUNCTION_STUB
}};
557 return sort(keys(%$function_stub));
560 sub all_functions_found
{
562 my $function_found = \
%{$self->{FUNCTION_FOUND
}};
564 return sort(keys(%$function_found));
567 sub function_calling_convention
{
569 my $function_calling_convention = \
%{$self->{FUNCTION_CALLING_CONVENTION
}};
573 return $$function_calling_convention{$name};
576 sub function_external_name
{
578 my $function_external_name = \
%{$self->{FUNCTION_EXTERNAL_NAME
}};
582 return $$function_external_name{$name};
587 my $function_calling_convention = \
%{$self->{FUNCTION_CALLING_CONVENTION
}};
591 return $$function_calling_convention{$name};
594 sub is_shared_function
{
596 my $function_shared = \
%{$self->{FUNCTION_SHARED
}};
600 return $$function_shared{$name};
603 sub found_shared_function
{
605 my $function_shared = \
%{$self->{FUNCTION_SHARED
}};
609 $$function_shared{$name} = 1;
612 sub function_arguments
{
614 my $function_arguments = \
%{$self->{FUNCTION_ARGUMENTS
}};
618 return $$function_arguments{$name};
621 sub function_module
{
623 my $function_module = \
%{$self->{FUNCTION_MODULE
}};
627 return $$function_module{$name};
632 my $function_stub = \
%{$self->{FUNCTION_STUB
}};
636 return $$function_stub{$name};
641 my $function_found = \
%{$self->{FUNCTION_FOUND
}};
645 $$function_found{$name}++;
650 my $function_found = \
%{$self->{FUNCTION_FOUND
}};
654 return $$function_found{$name};