git.oblomov.eu Git - wine/blob - tools/winapi_check/winapi.pm

   1 package winapi;
   2
   3 use strict;
   4
   5 sub new {
   6     my $proto = shift;
   7     my $class = ref($proto) || $proto;
   8     my $self  = {};
   9     bless ($self, $class);
  10
  11     my $options = \${$self->{OPTIONS}};
  12     my $output = \${$self->{OUTPUT}};
  13     my $name = \${$self->{NAME}};
  14
  15     $$options = shift;
  16     $$output = shift;
  17     $$name = shift;
  18     my $path = shift;
  19
  20     my @files = map {
  21         s%^\./%%;
  22         $_;
  23     } split(/\n/, `find $path -name \\*.api`);
  24
  25     foreach my $file (@files) {
  26         my $module = $file;
  27         $module =~ s/.*?\/([^\/]*?)\.api$/$1/;
  28         $self->parse_api_file($file,$module);
  29     }
  30
  31     return $self;
  32 }
  33
  34 sub parse_api_file {
  35     my $self = shift;
  36
  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}};
  45
  46     my $file = shift;
  47     my $module = shift;
  48
  49     my $kind;
  50     my $format;
  51     my $extension = 0;
  52     my $forbidden = 0;
  53
  54     if($$options->progress) {
  55         $$output->progress("$file");
  56     }
  57
  58     open(IN, "< $file") || die "$file: $!\n";
  59     $/ = "\n";
  60     while(<IN>) {
  61         s/^\s*?(.*?)\s*$/$1/; # remove whitespace at begin and end of line
  62         s/^(.*?)\s*#.*$/$1/;  # remove comments
  63         /^$/ && next;         # skip empty lines
  64
  65         if(s/^%(\S+)\s*//) {
  66             $kind = $1;
  67             $format = undef;
  68             $forbidden = 0;
  69             $extension = 0;
  70
  71             $$allowed_kind{$kind} = 1;
  72             if(/^--forbidden/) {
  73                 $forbidden = 1;
  74             } elsif(/^--extension/) {
  75                 $extension = 1;
  76             } elsif(/^--format=(\".*?\"|\S*)/) {
  77                 $format = $1;
  78                 $format =~ s/^\"(.*?)\"$/$1/;
  79             }
  80
  81             if(!defined($format)) {
  82                 if($kind eq "long") {
  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") {
  90                     $format = "%lld";
  91                 } elsif($kind eq "ptr") {
  92                     $format = "%p";
  93                 } elsif($kind eq "segptr") {
  94                     $format = "%p";
  95                 } elsif($kind eq "str") {
  96                     $format = "%p|%s";
  97                 } elsif($kind eq "wstr") {
  98                     $format = "%p|%s";
  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";
 103                 } else {
 104                     $format = "<unknown>";
 105                 }
 106             }
 107         } elsif(defined($kind)) {
 108             my $type = $_;
 109             if(!$forbidden) {
 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;
 116                     } else {
 117                         $$output->write("$file: type ($type) already specificed\n");
 118                     }
 119                 } else {
 120                     $$allowed_modules_unlimited{$type} = 1;
 121                 }
 122             } else {
 123                 $$allowed_modules_limited{$type} = 1;
 124             }
 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");
 127             } else {
 128                 $$translate_argument{$type} = $kind;
 129             }
 130
 131             $$type_format{$module}{$type} = $format;
 132         } else {
 133             $$output->write("$file: file must begin with %<type> statement\n");
 134             exit 1;
 135         }
 136     }
 137     close(IN);
 138 }
 139
 140 sub get_spec_file_type {
 141     my $proto = shift;
 142     my $class = ref($proto) || $proto;
 143
 144     my $file = shift;
 145
 146     my $module;
 147     my $type;
 148
 149     open(IN, "< $file") || die "$file: $!\n";
 150     local $/ = "\n";
 151     while(<IN>) {
 152         s/^\s*(.*?)\s*$/$1/;
 153         s/^(.*?)\s*#.*$/$1/;
 154         /^$/ && next;
 155
 156         if(/^name\s*(\S*)/) { $module = $1; }
 157         if(/^type\s*(\w+)/) { $type = $1; }
 158
 159         if(defined($module) && defined($type)) { last; }
 160     }
 161     close(IN);
 162
 163     return ($type, $module);
 164 }
 165
 166 sub read_spec_files {
 167     my $proto = shift;
 168     my $class = ref($proto) || $proto;
 169
 170     my $modules = shift;
 171     my $wine_dir = shift;
 172     my $current_dir = shift;
 173     my $files = shift;
 174     my $win16api = shift;
 175     my $win32api = shift;
 176
 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");
 184         }
 185     }
 186
 187     foreach my $self ($win16api, $win32api) {
 188         my $function_forward = \%{$self->{FUNCTION_FORWARD}};
 189         my $function_internal_name = \%{$self->{FUNCTION_INTERNAL_NAME}};
 190         my $function_module = \%{$self->{FUNCTION_MODULE}};
 191
 192         foreach my $forward_name (sort(keys(%$function_forward))) {
 193             $$function_forward{$forward_name} =~ /^(\S*):(\S*)\.(\S*)$/;
 194             (my $from_module, my $to_module, my $external_name) = ($1, $2, $3);
 195             my $internal_name = $$function_internal_name{$external_name};
 196             if(defined($internal_name)) {
 197                 $$function_module{$internal_name} .= " & $from_module";
 198             }
 199         }
 200     }
 201 }
 202
 203 sub read_all_spec_files {
 204     my $proto = shift;
 205     my $class = ref($proto) || $proto;
 206
 207     my $modules = shift;
 208     my $wine_dir = shift;
 209     my $current_dir = shift;
 210     my $file_type = shift;
 211     my $win16api = shift;
 212     my $win32api = shift;
 213
 214     my @files = map {
 215         s%^\./%%;
 216         if(&$file_type($_) eq "winelib") {
 217             $_;
 218         } else {
 219             ();
 220         }
 221     } split(/\n/, `find $wine_dir -name \\*.spec`);
 222
 223     'winapi'->read_spec_files($modules, $wine_dir, $current_dir, \@files, $win16api, $win32api);
 224 }
 225
 226 sub parse_spec_file {
 227     my $self = shift;
 228
 229     my $options = \${$self->{OPTIONS}};
 230     my $output = \${$self->{OUTPUT}};
 231     my $function_internal_arguments = \%{$self->{FUNCTION_INTERNAL_ARGUMENTS}};
 232     my $function_external_arguments = \%{$self->{FUNCTION_EXTERNAL_ARGUMENTS}};
 233     my $function_internal_ordinal = \%{$self->{FUNCTION_INTERNAL_ORDINAL}};
 234     my $function_external_ordinal = \%{$self->{FUNCTION_EXTERNAL_ORDINAL}};
 235     my $function_internal_calling_convention = \%{$self->{FUNCTION_INTERNAL_CALLING_CONVENTION}};
 236     my $function_external_calling_convention = \%{$self->{FUNCTION_EXTERNAL_CALLING_CONVENTION}};
 237     my $function_internal_name = \%{$self->{FUNCTION_INTERNAL_NAME}};
 238     my $function_external_name = \%{$self->{FUNCTION_EXTERNAL_NAME}};
 239     my $function_stub = \%{$self->{FUNCTION_STUB}};
 240     my $function_forward = \%{$self->{FUNCTION_FORWARD}};
 241     my $function_internal_module = \%{$self->{FUNCTION_INTERNAL_MODULE}};
 242     my $function_external_module = \%{$self->{FUNCTION_EXTERNAL_MODULE}};
 243     my $modules = \%{$self->{MODULES}};
 244     my $module_files = \%{$self->{MODULE_FILES}};
 245
 246     my $file = shift;
 247     $file =~ s%^\./%%;
 248
 249     my %ordinals;
 250     my $type;
 251     my $module;
 252     my $module_file;
 253
 254     if($$options->progress) {
 255         $$output->progress("$file");
 256     }
 257
 258     open(IN, "< $file") || die "$file: $!\n";
 259     $/ = "\n";
 260     my $header = 1;
 261     my $lookahead = 0;
 262     while($lookahead || defined($_ = <IN>)) {
 263         $lookahead = 0;
 264         s/^\s*(.*?)\s*$/$1/;
 265         s/^(.*?)\s*#.*$/$1/;
 266         /^$/ && next;
 267
 268         if($header)  {
 269             if(/^name\s*(\S*)/) { $module = $1; }
 270             if(/^file\s*(\S*)/) { $module_file = $1; }
 271             if(/^type\s*(\w+)/) { $type = $1; }
 272             if(/^\d+|@/) { $header = 0; $lookahead = 1; }
 273             next;
 274         }
 275
 276         my $ordinal;
 277         if(/^(\d+|@)\s+
 278            (pascal|pascal16|stdcall|cdecl|register|interrupt|varargs)
 279            (?:\s+(?:-noimport|-norelay|-i386|-ret64))*\s+(\S+)\s*\(\s*(.*?)\s*\)\s*(\S+)$/x)
 280         {
 281             my $calling_convention = $2;
 282             my $external_name = $3;
 283             my $arguments = $4;
 284             my $internal_name = $5;
 285
 286             $ordinal = $1;
 287
 288             # FIXME: Internal name existing more than once not handled properly
 289             if(!$$function_internal_name{$external_name}) {
 290                 $$function_internal_name{$external_name} = $internal_name;
 291             } else {
 292                 $$function_internal_name{$external_name} .= " & $internal_name";
 293             }
 294             if(!$$function_external_name{$internal_name}) {
 295                 $$function_external_name{$internal_name} = $external_name;
 296             } else {
 297                 $$function_external_name{$internal_name} .= " & $external_name";
 298             }
 299             $$function_internal_arguments{$internal_name} = $arguments;
 300             $$function_external_arguments{$external_name} = $arguments;
 301             if(!$$function_internal_ordinal{$internal_name}) {
 302                 $$function_internal_ordinal{$internal_name} = $ordinal;
 303             } else {
 304                 $$function_internal_ordinal{$internal_name} .= " & $ordinal";
 305             }
 306             if(!$$function_external_ordinal{$external_name}) {
 307                 $$function_external_ordinal{$external_name} = $ordinal;
 308             } else {
 309                 $$function_external_ordinal{$external_name} .= " & $ordinal";
 310             }
 311             $$function_internal_calling_convention{$internal_name} = $calling_convention;
 312             $$function_external_calling_convention{$external_name} = $calling_convention;
 313             if(!$$function_internal_module{$internal_name}) {
 314                 $$function_internal_module{$internal_name} = "$module";
 315             } else {
 316                 $$function_internal_module{$internal_name} .= " & $module";
 317             }
 318             if(!$$function_external_module{$external_name}) {
 319                 $$function_external_module{$external_name} = "$module";
 320             } else {
 321                 $$function_external_module{$external_name} .= " & $module";
 322             }
 323
 324             if(0 && $$options->spec_mismatch) {
 325                 if($external_name eq "@") {
 326                     if($internal_name !~ /^\U$module\E_$ordinal$/) {
 327                         $$output->write("$file: $external_name: the internal name ($internal_name) mismatch\n");
 328                     }
 329                 } else {
 330                     my $name = $external_name;
 331
 332                     my $name1 = $name;
 333                     $name1 =~ s/^Zw/Nt/;
 334
 335                     my $name2 = $name;
 336                     $name2 =~ s/^(?:_|Rtl|k32|K32)//;
 337
 338                     my $name3 = $name;
 339                     $name3 =~ s/^INT_Int[0-9a-f]{2}Handler$/BUILTIN_DefaultIntHandler/;
 340
 341                     my $name4 = $name;
 342                     $name4 =~ s/^(VxDCall)\d$/$1/;
 343
 344                     # FIXME: This special case is becuase of a very ugly kludge that should be fixed IMHO
 345                     my $name5 = $name;
 346                     $name5 =~ s/^(.*?16)_(.*?)$/$1_fn$2/;
 347
 348                     if(uc($internal_name) ne uc($external_name) &&
 349                        $internal_name !~ /(\Q$name\E|\Q$name1\E|\Q$name2\E|\Q$name3\E|\Q$name4\E|\Q$name5\E)/)
 350                     {
 351                         $$output->write("$file: $external_name: internal name ($internal_name) mismatch\n");
 352                     }
 353                 }
 354             }
 355         } elsif(/^(\d+|@)\s+stub(?:\s+(?:-noimport|-norelay|-i386|-ret64))?\s+(\S+)$/) {
 356             my $external_name = $2;
 357
 358             $ordinal = $1;
 359
 360             my $internal_name;
 361             if($type eq "win16") {
 362                 if($external_name =~ /\d$/) {
 363                     $internal_name = $external_name . "_16";
 364                 } else {
 365                     $internal_name = $external_name . "16";
 366                 }
 367             } else {
 368                 $internal_name = $external_name;
 369             }
 370
 371             # FIXME: Internal name existing more than once not handled properly
 372             $$function_stub{$internal_name} = 1;
 373             if(!$$function_internal_ordinal{$internal_name}) {
 374                 $$function_internal_ordinal{$internal_name} = $ordinal;
 375             } else {
 376                 $$function_internal_ordinal{$internal_name} .= " & $ordinal";
 377             }
 378             if(!$$function_external_ordinal{$external_name}) {
 379                 $$function_external_ordinal{$external_name} = $ordinal;
 380             } else {
 381                 $$function_external_ordinal{$external_name} .= " & $ordinal";
 382             }
 383             if(!$$function_internal_module{$internal_name}) {
 384                 $$function_internal_module{$internal_name} = "$module";
 385             } else { # if($$function_internal_module{$internal_name} !~ /$module/) {
 386                 $$function_internal_module{$internal_name} .= " & $module";
 387             }
 388             if(!$$function_external_module{$external_name}) {
 389                 $$function_external_module{$external_name} = "$module";
 390             } else { # if($$function_external_module{$external_name} !~ /$module/) {
 391                 $$function_external_module{$external_name} .= " & $module";
 392             }
 393         } elsif(/^(\d+|@)\s+forward(?:\s+(?:-noimport|-norelay|-i386|-ret64))?\s+(\S+)\s+(\S+)\.(\S+)$/) {
 394             $ordinal = $1;
 395
 396             my $external_name = $2;
 397             my $forward_module = lc($3);
 398             my $forward_name = $4;
 399
 400             $$function_forward{$external_name} = "$module:$forward_module.$forward_name";
 401         } elsif(/^(\d+|@)\s+(equate|extern|variable)/) {
 402             # ignore
 403         } else {
 404             my $next_line = <IN>;
 405             if(!defined($next_line) || $next_line =~ /^\s*\d|@/) {
 406                 die "$file: $.: syntax error: '$_'\n";
 407             } else {
 408                 $_ .= $next_line;
 409                 $lookahead = 1;
 410             }
 411         }
 412
 413         if(defined($ordinal)) {
 414             if($ordinal ne "@" && $ordinals{$ordinal}) {
 415                 $$output->write("$file: ordinal redefined: $_\n");
 416             }
 417             $ordinals{$ordinal}++;
 418         }
 419     }
 420     close(IN);
 421
 422     $$modules{$module}++;
 423
 424     $$module_files{$module} = $file;
 425 }
 426
 427 sub name {
 428     my $self = shift;
 429     my $name = \${$self->{NAME}};
 430
 431     return $$name;
 432 }
 433
 434 sub is_allowed_kind {
 435     my $self = shift;
 436     my $allowed_kind = \%{$self->{ALLOWED_KIND}};
 437
 438     my $kind = shift;
 439     if(defined($kind)) {
 440         return $$allowed_kind{$kind};
 441     } else {
 442         return 0;
 443     }
 444 }
 445
 446 sub is_limited_type {
 447     my $self = shift;
 448     my $allowed_modules_limited = \%{$self->{ALLOWED_MODULES_LIMITED}};
 449
 450     my $type = shift;
 451
 452     return $$allowed_modules_limited{$type};
 453 }
 454
 455 sub allowed_type_in_module {
 456     my $self = shift;
 457     my $allowed_modules = \%{$self->{ALLOWED_MODULES}};
 458     my $allowed_modules_limited = \%{$self->{ALLOWED_MODULES_LIMITED}};
 459
 460     my $type = shift;
 461     my @modules = split(/ \& /, shift);
 462
 463     if(!$$allowed_modules_limited{$type}) { return 1; }
 464
 465     foreach my $module (@modules) {
 466         if($$allowed_modules{$type}{$module}) { return 1; }
 467     }
 468
 469     return 0;
 470 }
 471
 472 sub type_used_in_module {
 473     my $self = shift;
 474     my $used_modules = \%{$self->{USED_MODULES}};
 475
 476     my $type = shift;
 477     my @modules = split(/ \& /, shift);
 478
 479     foreach my $module (@modules) {
 480         $$used_modules{$type}{$module} = 1;
 481     }
 482
 483     return ();
 484 }
 485
 486 sub types_not_used {
 487     my $self = shift;
 488     my $used_modules = \%{$self->{USED_MODULES}};
 489     my $allowed_modules = \%{$self->{ALLOWED_MODULES}};
 490
 491     my $not_used;
 492     foreach my $type (sort(keys(%$allowed_modules))) {
 493         foreach my $module (sort(keys(%{$$allowed_modules{$type}}))) {
 494             if(!$$used_modules{$type}{$module}) {
 495                 $$not_used{$module}{$type} = 1;
 496             }
 497         }
 498     }
 499     return $not_used;
 500 }
 501
 502 sub types_unlimited_used_in_modules {
 503     my $self = shift;
 504
 505     my $output = \${$self->{OUTPUT}};
 506     my $used_modules = \%{$self->{USED_MODULES}};
 507     my $allowed_modules = \%{$self->{ALLOWED_MODULES}};
 508     my $allowed_modules_unlimited = \%{$self->{ALLOWED_MODULES_UNLIMITED}};
 509
 510     my $used_types;
 511     foreach my $type (sort(keys(%$allowed_modules_unlimited))) {
 512         my $count = 0;
 513         my @modules = ();
 514         foreach my $module (sort(keys(%{$$used_modules{$type}}))) {
 515             $count++;
 516             push @modules, $module;
 517         }
 518         if($count) {
 519             foreach my $module (@modules) {
 520               $$used_types{$type}{$module} = 1;
 521             }
 522         }
 523     }
 524     return $used_types;
 525 }
 526
 527 sub translate_argument {
 528     my $self = shift;
 529     my $translate_argument = \%{$self->{TRANSLATE_ARGUMENT}};
 530
 531     my $argument = shift;
 532
 533     return $$translate_argument{$argument};
 534 }
 535
 536 sub all_declared_types {
 537     my $self = shift;
 538     my $translate_argument = \%{$self->{TRANSLATE_ARGUMENT}};
 539
 540     return sort(keys(%$translate_argument));
 541 }
 542
 543 sub found_type {
 544     my $self = shift;
 545     my $type_found = \%{$self->{TYPE_FOUND}};
 546
 547     my $name = shift;
 548
 549     $$type_found{$name}++;
 550 }
 551
 552 sub type_found {
 553     my $self = shift;
 554     my $type_found= \%{$self->{TYPE_FOUND}};
 555
 556     my $name = shift;
 557
 558     return $$type_found{$name};
 559 }
 560
 561 sub is_allowed_type_format {
 562     my $self = shift;
 563     my $type_format = \%{$self->{TYPE_FORMAT}};
 564
 565     my $module = shift;
 566     my $type = shift;
 567     my $format = shift;
 568
 569     my $formats;
 570
 571     if(defined($module) && defined($type)) {
 572         local $_;
 573         foreach (split(/ & /, $module)) {
 574             if(defined($formats)) {
 575                 $formats .= "|";
 576             } else {
 577                 $formats = "";
 578             }
 579             if(defined($$type_format{$_}{$type})) {
 580                 $formats .= $$type_format{$_}{$type};
 581             }
 582         }
 583     }
 584
 585     if(defined($formats)) {
 586         local $_;
 587         foreach (split(/\|/, $formats)) {
 588             if($_ eq $format) {
 589                 return 1;
 590             }
 591         }
 592     }
 593
 594     return 0;
 595 }
 596
 597 sub all_modules {
 598     my $self = shift;
 599     my $modules = \%{$self->{MODULES}};
 600
 601     return sort(keys(%$modules));
 602 }
 603
 604 sub is_module {
 605     my $self = shift;
 606     my $modules = \%{$self->{MODULES}};
 607
 608     my $name = shift;
 609
 610     return $$modules{$name};
 611 }
 612
 613 sub module_file {
 614     my $self = shift;
 615
 616     my $module = shift;
 617
 618     my $module_files = \%{$self->{MODULE_FILES}};
 619
 620     return $$module_files{$module};
 621 }
 622
 623 sub all_internal_functions {
 624     my $self = shift;
 625     my $function_internal_calling_convention = \%{$self->{FUNCTION_INTERNAL_CALLING_CONVENTION}};
 626
 627     return sort(keys(%$function_internal_calling_convention));
 628 }
 629
 630 sub all_internal_functions_in_module {
 631     my $self = shift;
 632     my $function_internal_calling_convention = \%{$self->{FUNCTION_INTERNAL_CALLING_CONVENTION}};
 633     my $function_internal_module = \%{$self->{FUNCTION_INTERNAL_MODULE}};
 634
 635     my $module = shift;
 636
 637     my @names;
 638     foreach my $name (keys(%$function_internal_calling_convention)) {
 639         if($$function_internal_module{$name} eq $module) {
 640             push @names, $name;
 641         }
 642     }
 643
 644     return sort(@names);
 645 }
 646
 647 sub all_functions_stub {
 648     my $self = shift;
 649     my $function_stub = \%{$self->{FUNCTION_STUB}};
 650
 651     return sort(keys(%$function_stub));
 652 }
 653
 654 sub all_internal_functions_found {
 655     my $self = shift;
 656     my $function_found = \%{$self->{FUNCTION_FOUND}};
 657
 658     return sort(keys(%$function_found));
 659 }
 660
 661 sub function_internal_ordinal {
 662     my $self = shift;
 663     my $function_internal_ordinal = \%{$self->{FUNCTION_INTERNAL_ORDINAL}};
 664
 665     my $name = shift;
 666
 667     return $$function_internal_ordinal{$name};
 668 }
 669
 670 sub function_external_ordinal {
 671     my $self = shift;
 672     my $function_external_ordinal = \%{$self->{FUNCTION_EXTERNAL_ORDINAL}};
 673
 674     my $name = shift;
 675
 676     return $$function_external_ordinal{$name};
 677 }
 678
 679 sub function_internal_calling_convention {
 680     my $self = shift;
 681     my $function_internal_calling_convention = \%{$self->{FUNCTION_INTERNAL_CALLING_CONVENTION}};
 682
 683     my $name = shift;
 684
 685     return $$function_internal_calling_convention{$name};
 686 }
 687
 688 sub function_external_calling_convention {
 689     my $self = shift;
 690     my $function_external_calling_convention = \%{$self->{FUNCTION_EXTERNAL_CALLING_CONVENTION}};
 691
 692     my $name = shift;
 693
 694     return $$function_external_calling_convention{$name};
 695 }
 696
 697 sub function_external_name {
 698     my $self = shift;
 699     my $function_external_name = \%{$self->{FUNCTION_EXTERNAL_NAME}};
 700
 701     my $name = shift;
 702
 703     return $$function_external_name{$name};
 704 }
 705
 706 sub is_function {
 707     my $self = shift;
 708     my $function_internal_calling_convention = \%{$self->{FUNCTION_INTERNAL_CALLING_CONVENTION}};
 709
 710     my $name = shift;
 711
 712     return $$function_internal_calling_convention{$name};
 713 }
 714
 715 sub is_shared_function {
 716     my $self = shift;
 717     my $function_shared = \%{$self->{FUNCTION_SHARED}};
 718
 719     my $name = shift;
 720
 721     return $$function_shared{$name};
 722 }
 723
 724 sub found_shared_function {
 725     my $self = shift;
 726     my $function_shared = \%{$self->{FUNCTION_SHARED}};
 727
 728     my $name = shift;
 729
 730     $$function_shared{$name} = 1;
 731 }
 732
 733 sub function_internal_arguments {
 734     my $self = shift;
 735     my $function_internal_arguments = \%{$self->{FUNCTION_INTERNAL_ARGUMENTS}};
 736
 737     my $name = shift;
 738
 739     return $$function_internal_arguments{$name};
 740 }
 741
 742 sub function_external_arguments {
 743     my $self = shift;
 744     my $function_external_arguments = \%{$self->{FUNCTION_EXTERNAL_ARGUMENTS}};
 745
 746     my $name = shift;
 747
 748     return $$function_external_arguments{$name};
 749 }
 750
 751 sub function_internal_module {
 752     my $self = shift;
 753     my $function_internal_module = \%{$self->{FUNCTION_INTERNAL_MODULE}};
 754
 755     my $name = shift;
 756
 757     return $$function_internal_module{$name};
 758 }
 759
 760 sub function_external_module {
 761     my $self = shift;
 762     my $function_external_module = \%{$self->{FUNCTION_EXTERNAL_MODULE}};
 763
 764     my $name = shift;
 765
 766     return $$function_external_module{$name};
 767 }
 768
 769 sub function_stub {
 770     my $self = shift;
 771     my $function_stub = \%{$self->{FUNCTION_STUB}};
 772
 773     my $name = shift;
 774
 775     return $$function_stub{$name};
 776 }
 777
 778 sub found_internal_function {
 779     my $self = shift;
 780     my $function_found = \%{$self->{FUNCTION_FOUND}};
 781
 782     my $name = shift;
 783
 784     $$function_found{$name}++;
 785 }
 786
 787 sub internal_function_found {
 788     my $self = shift;
 789     my $function_found = \%{$self->{FUNCTION_FOUND}};
 790
 791     my $name = shift;
 792
 793     return $$function_found{$name};
 794 }
 795
 796 1;