]> git.saurik.com Git - apt.git/blame - abicheck/abi-compliance-checker.pl
projects / apt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Allow the FileFd to use an external Compressor to uncompress a given file
[apt.git] / abicheck / abi-compliance-checker.pl
CommitLineData
d8cd04f8
MV		 1#!/usr/bin/perl
2###########################################################################
3# ABI-compliance-checker v1.13, lightweight tool for statically checking
4# backward binary compatibility of shared C/C++ libraries in Linux.
5# Copyright (C) The Linux Foundation
6# Copyright (C) Institute for System Programming, RAS
7# Author: Andrey Ponomarenko
8#
9# This program is free software: you can redistribute it and/or modify
10# it under the terms of the GNU General Public License as published by
11# the Free Software Foundation, either version 2 of the License, or
12# (at your option) any later version.
13#
14# This program is distributed in the hope that it will be useful,
15# but WITHOUT ANY WARRANTY; without even the implied warranty of
16# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17# GNU General Public License for more details.
18#
19# You should have received a copy of the GNU General Public License
20# along with this program. If not, see <http://www.gnu.org/licenses/>.
21###########################################################################
22use Getopt::Long;
23Getopt::Long::Configure ("posix_default", "no_ignore_case");
24use Data::Dumper;
25
26my $ABI_COMPLIANCE_CHECKER_VERSION = "1.13";
27my ($Help, $ShowVersion, %Descriptor, $TargetLibraryName, $HeaderCheckingMode_Separately, $GenerateDescriptor, $TestSystem, $DumpInfo_DescriptorPath, $CheckHeadersOnly, $InterfacesListPath, $AppPath, $ShowExpendTime);
28
29my $CmdName = get_FileName($0);
30GetOptions("h|help!" => \$Help,
31 "v|version!" => \$ShowVersion,
32#general options
33 "l|library=s" => \$TargetLibraryName,
34 "d1|descriptor1=s" => \$Descriptor{1}{"Path"},
35 "d2|descriptor2=s" => \$Descriptor{2}{"Path"},
36#extra options
37 "app|application=s" => \$AppPath,
38 "symbols_list|int_list=s" => \$InterfacesListPath,
39 "dump_abi|dump_info=s" => \$DumpInfo_DescriptorPath,
40 "headers_only!" => \$CheckHeadersOnly,
41#other options
42 "d|descriptor_template!" => \$GenerateDescriptor,
43 "separately!" => \$HeaderCheckingMode_Separately,
44 "test!" => \$TestSystem,
45 "time!" => \$ShowExpendTime
46) or exit(1);
47
48sub HELP_MESSAGE()
49{
50 print STDERR <<"EOM"
51
52NAME:
53 $CmdName - check ABI compatibility of shared C/C++ library versions
54
55DESCRIPTION:
56 Lightweight tool for statically checking backward binary compatibility of shared C/C++ libraries
57 in Linux. It checks header files along with shared objects in two library versions and searches
58 for ABI changes that may lead to incompatibility. Breakage of the binary compatibility may result
59 in crashing or incorrect behavior of applications built with an old version of a library when
60 it is running with a new one.
61
62 ABI Compliance Checker was intended for library developers that are interested in ensuring
63 backward binary compatibility. Also it can be used for checking forward binary compatibility
64 and checking applications portability to the new library version.
65
66 This tool is free software: you can redistribute it and/or modify it under the terms of the GNU GPL.
67
68USAGE:
69 $CmdName [options]
70
71EXAMPLE OF USE:
72 $CmdName -l <library_name> -d1 <1st_version_descriptor> -d2 <2nd_version_descriptor>
73
74GENERAL OPTIONS:
75 -h|-help
76 Print this help.
77
78 -v|-version
79 Print version.
80
81 -l|-library <name>
82 Library name (without version).
83 It affects only on the path and the title of the report.
84
85 -d1|-descriptor1 <path>
86 Path to descriptor of 1st library version.
87
88 -d2|-descriptor2 <path>
89 Path to descriptor of 2nd library version.
90
91EXTRA OPTIONS:
92 -app|-application <path>
93 This option allow to specify the application that should be tested for portability
94 to the new library version.
95
96 -dump_abi|-dump_info <descriptor_path>
97 Dump library ABI information using specified descriptor.
98 This command will create '<library>_<ver1>.abi.tar.gz' file in the directory 'abi_dumps/<library>/'.
99 You can transfer it anywhere and pass instead of library descriptor.
100
101 -headers_only
102 Check header files without shared objects. It is easy to run, but may provide
103 a low quality ABI compliance report with false positives and without
104 detecting of added/withdrawn interfaces.
105
106 -symbols_list|-int_list <path>
107 This option allow to specify a file with a list of interfaces (mangled names in C++)
108 that should be checked, other library interfaces will not be checked.
109
110OTHER OPTIONS:
111 -d|-descriptor_template
112 Create library descriptor template 'library-descriptor.xml' in the current directory.
113
114 -separately
115 Check headers individually. This mode requires more time for checking ABI compliance,
116 but possible compiler errors in one header can't affect others.
117
118 -test
119 Run internal tests (create two binary-incompatible versions of an artificial library
120 and run ABI-Compliance-Checker on it).
121
122DESCRIPTOR EXAMPLE:
123 <version>
124 1.28.0
125 </version>
126
127 <headers>
128 /usr/local/atk/atk-1.28.0/include/
129 </headers>
130
131 <libs>
132 /usr/local/atk/atk-1.28.0/lib/libatk-1.0.so
133 </libs>
134
135 <include_paths>
136 /usr/include/glib-2.0/
137 /usr/lib/glib-2.0/include/
138 </include_paths>
139
140
141Report bugs to <abi-compliance-checker\@linuxtesting.org>
142For more information, please see: http://ispras.linux-foundation.org/index.php/ABI_compliance_checker
143EOM
144 ;
145}
146
147my $Descriptor_Template = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>
148<descriptor>
149
150<!-- Template for the library version descriptor -->
151
152<!--
153 Necessary sections
154 -->
155
156<version>
157 <!-- Version of the library -->
158</version>
159
160<headers>
161 <!-- The list of paths to header files and/or
162 directories with header files, one per line -->
163</headers>
164
165<libs>
166 <!-- The list of paths to shared objects and/or
167 directories with shared objects, one per line -->
168</libs>
169
170<!--
171 Additional sections
172 -->
173
174<include_paths>
175 <!-- The list of paths to be searched for header files
176 needed for compiling of library headers, one per line -->
177</include_paths>
178
179<gcc_options>
180 <!-- Additional gcc options, one per line -->
181</gcc_options>
182
183<opaque_types>
184 <!-- The list of opaque types, one per line -->
185</opaque_types>
186
187<skip_interfaces>
188 <!-- The list of functions (mangled/symbol names in C++)
189 that should be skipped while testing, one per line -->
190</skip_interfaces>
191
192<include_preamble>
193 <!-- The list of header files that should be included before other headers, one per line.
194 For example, it is a tree.h for libxml2 and ft2build.h for freetype2 -->
195</include_preamble>
196
197</descriptor>";
198
199my %Operator_Indication = (
200"not" => "~",
201"assign" => "=",
202"andassign" => "&=",
203"orassign" => "|=",
204"xorassign" => "^=",
205"or" => "|",
206"xor" => "^",
207"addr" => "&",
208"and" => "&",
209"lnot" => "!",
210"eq" => "==",
211"ne" => "!=",
212"lt" => "<",
213"lshift" => "<<",
214"lshiftassign" => "<<=",
215"rshiftassign" => ">>=",
216"call" => "()",
217"mod" => "%",
218"modassign" => "%=",
219"subs" => "[]",
220"land" => "&&",
221"lor" => "||",
222"rshift" => ">>",
223"ref" => "->",
224"le" => "<=",
225"deref" => "*",
226"mult" => "*",
227"preinc" => "++",
228"delete" => " delete",
229"vecnew" => " new[]",
230"vecdelete" => " delete[]",
231"predec" => "--",
232"postinc" => "++",
233"postdec" => "--",
234"plusassign" => "+=",
235"plus" => "+",
236"minus" => "-",
237"minusassign" => "-=",
238"gt" => ">",
239"ge" => ">=",
240"new" => " new",
241"multassign" => "*=",
242"divassign" => "/=",
243"div" => "/",
244"neg" => "-",
245"pos" => "+",
246"memref" => "->*",
247"compound" => ","
248);
249
250sub num_to_str($)
251{
252 my $Number = $_[0];
253 if(int($Number)>3)
254 {
255 return $Number."th";
256 }
257 elsif(int($Number)==1)
258 {
259 return "1st";
260 }
261 elsif(int($Number)==2)
262 {
263 return "2nd";
264 }
265 elsif(int($Number)==3)
266 {
267 return "3rd";
268 }
269 else
270 {
271 return "";
272 }
273}
274
275#Global variables
276my $REPORT_PATH;
277my %ERR_PATH;
278my $POINTER_SIZE;
279my $MAX_COMMAND_LINE_ARGUMENTS = 4096;
280my %Cache;
281my %FuncAttr;
282my %LibInfo;
283my %HeaderCompileError;
284my $StartTime;
285my %CompilerOptions;
286my %AddedInt;
287my %WithdrawnInt;
288my @RecurLib;
289my %CheckedSoLib;
290
291#Constants checking
292my %ConstantsSrc;
293my %Constants;
294
295#Types
296my %TypeDescr;
297my %TemplateInstance_Func;
298my %TemplateInstance;
299my %OpaqueTypes;
300my %Tid_TDid;
301my %CheckedTypes;
302my %Typedef_BaseName;
303my %StdCxxTypedef;
304my %TName_Tid;
305my %EnumMembName_Id;
306
307#Interfaces
308my %FuncDescr;
309my %ClassFunc;
310my %ClassVirtFunc;
311my %ClassIdVirtFunc;
312my %ClassId;
313my %tr_name;
314my %mangled_name;
315my %InternalInterfaces;
316my %InterfacesList;
317my %InterfacesList_App;
318my %CheckedInterfaces;
319my %DepInterfaces;
320
321#Headers
322my %Include_Preamble;
323my %Headers;
324my %HeaderName_Destinations;
325my %Header_Dependency;
326
327#Shared objects
328my %SoLib_DefaultPath;
329
330#Merging
331my %CompleteSignature;
332my @RecurTypes;
333my %Interface_Library;
334my %Library_Interface;
335my %Language;
336my %SoNames_All;
337my $Version;
338
339#Symbols versioning
340my %SymVer;
341
342#Problem descriptions
343my %CompatProblems;
344my %ConstantProblems;
345
346#Rerorts
347my $ContentID = 1;
348my $ContentSpanStart = "<span class=\"section\" onclick=\"javascript:showContent(this, 'CONTENT_ID')\">\n";
349my $ContentSpanEnd = "</span>\n";
350my $ContentDivStart = "<div id=\"CONTENT_ID\" style=\"display:none;\">\n";
351my $ContentDivEnd = "</div>\n";
352my $Content_Counter = 0;
353
354sub readDescriptor($)
355{
356 my $LibVersion = $_[0];
357 if(not -e $Descriptor{$LibVersion}{"Path"})
358 {
359 return;
360 }
361 my $Descriptor_File = readFile($Descriptor{$LibVersion}{"Path"});
362 $Descriptor_File =~ s/\/\*(.|\n)+?\*\///g;
363 $Descriptor_File =~ s/<\!--(.|\n)+?-->//g;
364 if(not $Descriptor_File)
365 {
366 print "ERROR: descriptor d$LibVersion is empty\n";
367 exit(1);
368 }
369 $Descriptor{$LibVersion}{"Version"} = parseTag(\$Descriptor_File, "version");
370 if(not $Descriptor{$LibVersion}{"Version"})
371 {
372 print "ERROR: version in the descriptor d$LibVersion was not specified (section <version>)\n\n";
373 exit(1);
374 }
375 $Descriptor{$LibVersion}{"Headers"} = parseTag(\$Descriptor_File, "headers");
376 if(not $Descriptor{$LibVersion}{"Headers"})
377 {
378 print "ERROR: header files in the descriptor d$LibVersion were not specified (section <headers>)\n";
379 exit(1);
380 }
381 if(not $CheckHeadersOnly)
382 {
383 $Descriptor{$LibVersion}{"Libs"} = parseTag(\$Descriptor_File, "libs");
384 if(not $Descriptor{$LibVersion}{"Libs"})
385 {
386 print "ERROR: shared objects in the descriptor d$LibVersion were not specified (section <libs>)\n";
387 exit(1);
388 }
389 }
390 $Descriptor{$LibVersion}{"Include_Paths"} = parseTag(\$Descriptor_File, "include_paths");
391 $Descriptor{$LibVersion}{"Gcc_Options"} = parseTag(\$Descriptor_File, "gcc_options");
392 foreach my $Option (split("\n", $Descriptor{$LibVersion}{"Gcc_Options"}))
393 {
394 $Option =~ s/\A\s+|\s+\Z//g;
395 next if(not $Option);
396 $CompilerOptions{$LibVersion} .= " ".$Option;
397 }
398 $Descriptor{$LibVersion}{"Opaque_Types"} = parseTag(\$Descriptor_File, "opaque_types");
399 foreach my $Type_Name (split("\n", $Descriptor{$LibVersion}{"Opaque_Types"}))
400 {
401 $Type_Name =~ s/\A\s+|\s+\Z//g;
402 next if(not $Type_Name);
403 $OpaqueTypes{$LibVersion}{$Type_Name} = 1;
404 }
405 $Descriptor{$LibVersion}{"Skip_interfaces"} = parseTag(\$Descriptor_File, "skip_interfaces");
406 foreach my $Interface_Name (split("\n", $Descriptor{$LibVersion}{"Skip_interfaces"}))
407 {
408 $Interface_Name =~ s/\A\s+|\s+\Z//g;
409 next if(not $Interface_Name);
410 $InternalInterfaces{$LibVersion}{$Interface_Name} = 1;
411 }
412 $Descriptor{$LibVersion}{"Include_Preamble"} = parseTag(\$Descriptor_File, "include_preamble");
413 my $Position = 0;
414 foreach my $Header_Name (split("\n", $Descriptor{$LibVersion}{"Include_Preamble"}))
415 {
416 $Header_Name =~ s/\A\s+|\s+\Z//g;
417 next if(not $Header_Name);
418 $Include_Preamble{$LibVersion}{$Header_Name}{"Position"} = $Position;
419 $Position+=1;
420 }
421 my $Descriptors_Dir = "descriptors_storage/$TargetLibraryName";
422 system("mkdir", "-p", $Descriptors_Dir);
423 my $Descriptor_Name = $TargetLibraryName."_".$Descriptor{$LibVersion}{"Version"}.".desc";
424 if($Descriptor{$LibVersion}{"Path"} ne $Descriptors_Dir."/".$Descriptor_Name)
425 {
426 system("cp", "-f", $Descriptor{$LibVersion}{"Path"}, $Descriptors_Dir."/".$Descriptor_Name);
427 }
428 $ERR_PATH{$LibVersion} = "header_compile_errors/$TargetLibraryName/".$Descriptor{$LibVersion}{"Version"};
429}
430
431sub parseTag($$)
432{
433 my ($CodeRef, $Tag) = @_;
434 return "" if(not $CodeRef or not ${$CodeRef} or not $Tag);
435 if(${$CodeRef} =~ s/\<$Tag\>((.|\n)+?)\<\/$Tag\>//)
436 {
437 my $Content = $1;
438 $Content=~s/(\A\s+|\s+\Z)//g;
439 return $Content;
440 }
441 else
442 {
443 return "";
444 }
445}
446
447my %check_node=(
448"array_type"=>1,
449"binfo"=>1,
450"boolean_type"=>1,
451"complex_type"=>1,
452"const_decl"=>1,
453"enumeral_type"=>1,
454"field_decl"=>1,
455"function_decl"=>1,
456"function_type"=>1,
457"identifier_node"=>1,
458"integer_cst"=>1,
459"integer_type"=>1,
460"method_type"=>1,
461"namespace_decl"=>1,
462"parm_decl"=>1,
463"pointer_type"=>1,
464"real_cst"=>1,
465"real_type"=>1,
466"record_type"=>1,
467"reference_type"=>1,
468"string_cst"=>1,
469"template_decl"=>1,
470"template_type_parm"=>1,
471"tree_list"=>1,
472"tree_vec"=>1,
473"type_decl"=>1,
474"union_type"=>1,
475"var_decl"=>1,
476"void_type"=>1);
477
478sub getInfo($)
479{
480 my $InfoPath = $_[0];
481 return if(not $InfoPath or not -f $InfoPath);
482 my $InfoPath_New = $InfoPath.".1";
483 #my $Keywords = join("\\|", keys(%check_node));#|grep "$Keywords"
484 system("sed ':a;N;\$!ba;s/\\n[^\@]//g' ".esc($InfoPath)."|sed 's/ [ ]\\+/ /g' > ".esc($InfoPath_New));
485 system("rm", "-fr", $InfoPath);
486 #getting info
487 open(INFO, $InfoPath_New) || die ("can't open file '\$InfoPath_New\': $!\n");
488 while(<INFO>)
489 {
490 chomp;
491 if(/\A@([0-9]+)[ ]+([a-zA-Z_]+)[ ]+(.*)\Z/)
492 {
493 next if(not $check_node{$2});
494 $LibInfo{$Version}{$1}{"info_type"}=$2;
495 $LibInfo{$Version}{$1}{"info"}=$3;
496 }
497 }
498 close(INFO);
499 system("rm", "-fr", $InfoPath_New);
500 #processing info
501 setTemplateParams_All();
502 getTypeDescr_All();
503 getFuncDescr_All();
504 getVarDescr_All();
505 %LibInfo = ();
506 %TemplateInstance = ();
507}
508
509sub setTemplateParams_All()
510{
511 foreach (keys(%{$LibInfo{$Version}}))
512 {
513 if($LibInfo{$Version}{$_}{"info_type"} eq "template_decl")
514 {
515 setTemplateParams($_);
516 }
517 }
518}
519
520sub setTemplateParams($)
521{
522 my $TypeInfoId = $_[0];
523 my $Info = $LibInfo{$Version}{$TypeInfoId}{"info"};
524 if($Info =~ /(inst|spcs)[ ]*:[ ]*@([0-9]+) /)
525 {
526 my $TmplInst_InfoId = $2;
527 setTemplateInstParams($TmplInst_InfoId);
528 my $TmplInst_Info = $LibInfo{$Version}{$TmplInst_InfoId}{"info"};
529 while($TmplInst_Info =~ /chan[ ]*:[ ]*@([0-9]+) /)
530 {
531 $TmplInst_InfoId = $1;
532 $TmplInst_Info = $LibInfo{$Version}{$TmplInst_InfoId}{"info"};
533 setTemplateInstParams($TmplInst_InfoId);
534 }
535 }
536}
537
538sub setTemplateInstParams($)
539{
540 my $TmplInst_Id = $_[0];
541 my $Info = $LibInfo{$Version}{$TmplInst_Id}{"info"};
542 my ($Params_InfoId, $ElemId) = ();
543 if($Info =~ /purp[ ]*:[ ]*@([0-9]+) /)
544 {
545 $Params_InfoId = $1;
546 }
547 if($Info =~ /valu[ ]*:[ ]*@([0-9]+) /)
548 {
549 $ElemId = $1;
550 }
551 if($Params_InfoId and $ElemId)
552 {
553 my $Params_Info = $LibInfo{$Version}{$Params_InfoId}{"info"};
554 while($Params_Info =~ s/ ([0-9]+)[ ]*:[ ]*@([0-9]+) //)
555 {
556 my ($Param_Pos, $Param_TypeId) = ($1, $2);
557 return if($LibInfo{$Version}{$Param_TypeId}{"info_type"} eq "template_type_parm");
558 if($LibInfo{$ElemId}{"info_type"} eq "function_decl")
559 {
560 $TemplateInstance_Func{$Version}{$ElemId}{$Param_Pos} = $Param_TypeId;
561 }
562 else
563 {
564 $TemplateInstance{$Version}{getTypeDeclId($ElemId)}{$ElemId}{$Param_Pos} = $Param_TypeId;
565 }
566 }
567 }
568}
569
570sub getTypeDeclId($)
571{
572 my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
573 if($TypeInfo =~ /name[ ]*:[ ]*@([0-9]+)/)
574 {
575 return $1;
576 }
577 else
578 {
579 return "";
580 }
581}
582
583sub isFuncPtr($)
584{
585 my $Ptd = pointTo($_[0]);
586 if($Ptd)
587 {
588 if(($LibInfo{$Version}{$_[0]}{"info"} =~ m/unql[ ]*:/) and not ($LibInfo{$Version}{$_[0]}{"info"} =~ m/qual[ ]*:/))
589 {
590 return 0;
591 }
592 elsif(($LibInfo{$Version}{$_[0]}{"info_type"} eq "pointer_type") and ($LibInfo{$Version}{$Ptd}{"info_type"} eq "function_type" or $LibInfo{$Version}{$Ptd}{"info_type"} eq "method_type"))
593 {
594 return 1;
595 }
596 else
597 {
598 return 0;
599 }
600 }
601 else
602 {
603 return 0;
604 }
605}
606
607sub pointTo($)
608{
609 my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
610 if($TypeInfo =~ /ptd[ ]*:[ ]*@([0-9]+)/)
611 {
612 return $1;
613 }
614 else
615 {
616 return "";
617 }
618}
619
620sub getTypeDescr_All()
621{
622 foreach (sort {int($a)<=>int($b)} keys(%{$LibInfo{$Version}}))
623 {
624 if($LibInfo{$Version}{$_}{"info_type"}=~/_type\Z/ and $LibInfo{$Version}{$_}{"info_type"}!~/function_type|method_type/)
625 {
626 getTypeDescr(getTypeDeclId($_), $_);
627 }
628 }
629 $TypeDescr{$Version}{""}{-1}{"Name"} = "...";
630 $TypeDescr{$Version}{""}{-1}{"Type"} = "Intrinsic";
631 $TypeDescr{$Version}{""}{-1}{"Tid"} = -1;
632}
633
634sub getTypeDescr($$)
635{
636 my ($TypeDeclId, $TypeId) = @_;
637 $Tid_TDid{$Version}{$TypeId} = $TypeDeclId;
638 %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}} = getTypeAttr($TypeDeclId, $TypeId);
639 if(not $TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"})
640 {
641 delete($TypeDescr{$Version}{$TypeDeclId}{$TypeId});
642 return;
643 }
644 if(not $TName_Tid{$Version}{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"}})
645 {
646 $TName_Tid{$Version}{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"}} = $TypeId;
647 }
648}
649
650sub getTypeAttr($$)
651{
652 my ($TypeDeclId, $TypeId) = @_;
653 my ($BaseTypeSpec, %TypeAttr) = ();
654 if($TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"})
655 {
656 return %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}};
657 }
658 $TypeAttr{"Tid"} = $TypeId;
659 $TypeAttr{"TDid"} = $TypeDeclId;
660 $TypeAttr{"Type"} = getTypeType($TypeDeclId, $TypeId);
661 if($TypeAttr{"Type"} eq "Unknown")
662 {
663 return ();
664 }
665 elsif($TypeAttr{"Type"} eq "FuncPtr")
666 {
667 %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}} = getFuncPtrAttr(pointTo($TypeId), $TypeDeclId, $TypeId);
668 $TName_Tid{$Version}{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"}} = $TypeId;
669 return %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}};
670 }
671 elsif($TypeAttr{"Type"} eq "Array")
672 {
673 ($TypeAttr{"BaseType"}{"Tid"}, $TypeAttr{"BaseType"}{"TDid"}, $BaseTypeSpec) = selectBaseType($TypeDeclId, $TypeId);
674 my %BaseTypeAttr = getTypeAttr($TypeAttr{"BaseType"}{"TDid"}, $TypeAttr{"BaseType"}{"Tid"});
675 my $ArrayElemNum = getSize($TypeId)/8;
676 $ArrayElemNum = $ArrayElemNum/$BaseTypeAttr{"Size"} if($BaseTypeAttr{"Size"});
677 $TypeAttr{"Size"} = $ArrayElemNum;
678 if($ArrayElemNum)
679 {
680 $TypeAttr{"Name"} = $BaseTypeAttr{"Name"}."[".$ArrayElemNum."]";
681 }
682 else
683 {
684 $TypeAttr{"Name"} = $BaseTypeAttr{"Name"}."[]";
685 }
686 $TypeAttr{"Name"} = correctName($TypeAttr{"Name"});
687 $TypeAttr{"Library"} = $BaseTypeAttr{"Library"};
688 $TypeAttr{"Header"} = $BaseTypeAttr{"Header"};
689 %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}} = %TypeAttr;
690 $TName_Tid{$Version}{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"}} = $TypeId;
691 return %TypeAttr;
692 }
693 elsif($TypeAttr{"Type"} =~ /Intrinsic|Union|Struct|Enum|Class/)
694 {
695 if($TemplateInstance{$Version}{$TypeDeclId}{$TypeId})
696 {
697 my @Template_Params = ();
698 foreach my $Param_Pos (sort {int($a)<=>int($b)} keys(%{$TemplateInstance{$Version}{$TypeDeclId}{$TypeId}}))
699 {
700 my $Type_Id = $TemplateInstance{$Version}{$TypeDeclId}{$TypeId}{$Param_Pos};
701 my $Param = get_TemplateParam($Type_Id);
702 if($Param eq "")
703 {
704 return ();
705 }
706 @Template_Params = (@Template_Params, $Param);
707 }
708 %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}} = getTrivialTypeAttr($TypeDeclId, $TypeId);
709 $TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"} = $TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"}."< ".join(", ", @Template_Params)." >";
710 $TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"} = correctName($TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"});
711 $TName_Tid{$Version}{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"}} = $TypeId;
712 return %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}};
713 }
714 else
715 {
716 %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}} = getTrivialTypeAttr($TypeDeclId, $TypeId);
717 return %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}};
718 }
719 }
720 else
721 {
722 ($TypeAttr{"BaseType"}{"Tid"}, $TypeAttr{"BaseType"}{"TDid"}, $BaseTypeSpec) = selectBaseType($TypeDeclId, $TypeId);
723 my %BaseTypeAttr = getTypeAttr($TypeAttr{"BaseType"}{"TDid"}, $TypeAttr{"BaseType"}{"Tid"});
724 if($BaseTypeSpec and $BaseTypeAttr{"Name"})
725 {
726 if(($TypeAttr{"Type"} eq "Pointer") and $BaseTypeAttr{"Name"}=~/\([\*]+\)/)
727 {
728 $TypeAttr{"Name"} = $BaseTypeAttr{"Name"};
729 $TypeAttr{"Name"} =~ s/\(([*]+)\)/($1*)/g;
730 }
731 else
732 {
733 $TypeAttr{"Name"} = $BaseTypeAttr{"Name"}." ".$BaseTypeSpec;
734 }
735 }
736 elsif($BaseTypeAttr{"Name"})
737 {
738 $TypeAttr{"Name"} = $BaseTypeAttr{"Name"};
739 }
740 if($TypeAttr{"Type"} eq "Typedef")
741 {
742 $TypeAttr{"Name"} = getNameByInfo($TypeDeclId);
743 $TypeAttr{"NameSpace"} = getNameSpace($TypeDeclId);
744 if($TypeAttr{"NameSpace"})
745 {
746 $TypeAttr{"Name"} = $TypeAttr{"NameSpace"}."::".$TypeAttr{"Name"};
747 }
748 ($TypeAttr{"Header"}, $TypeAttr{"Line"}) = getLocation($TypeDeclId);
749 if($TypeAttr{"NameSpace"}=~/\Astd(::|\Z)/ and $BaseTypeAttr{"NameSpace"}=~/\Astd(::|\Z)/)
750 {
751 $StdCxxTypedef{$Version}{$BaseTypeAttr{"Name"}} = $TypeAttr{"Name"};
752 }
753 $Typedef_BaseName{$Version}{$TypeAttr{"Name"}} = $BaseTypeAttr{"Name"};
754 }
755 if(not $TypeAttr{"Size"})
756 {
757 if($TypeAttr{"Type"} eq "Pointer")
758 {
759 $TypeAttr{"Size"} = $POINTER_SIZE;
760 }
761 else
762 {
763 $TypeAttr{"Size"} = $BaseTypeAttr{"Size"};
764 }
765 }
766 $TypeAttr{"Name"} = correctName($TypeAttr{"Name"});
767 $TypeAttr{"Library"} = $BaseTypeAttr{"Library"};
768 $TypeAttr{"Header"} = $BaseTypeAttr{"Header"} if(not $TypeAttr{"Header"});
769 %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}} = %TypeAttr;
770 $TName_Tid{$Version}{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"}} = $TypeId;
771 return %TypeAttr;
772 }
773}
774
775sub get_TemplateParam($)
776{
777 my $Type_Id = $_[0];
778 if(getNodeType($Type_Id) eq "integer_cst")
779 {
780 return getNodeIntCst($Type_Id);
781 }
782 elsif(getNodeType($Type_Id) eq "string_cst")
783 {
784 return getNodeStrCst($Type_Id);
785 }
786 else
787 {
788 my $Type_DId = getTypeDeclId($Type_Id);
789 my %ParamAttr = getTypeAttr($Type_DId, $Type_Id);
790 if(not $ParamAttr{"Name"})
791 {
792 return "";
793 }
794 if($ParamAttr{"Name"}=~/\>/)
795 {
796 if($StdCxxTypedef{$Version}{$ParamAttr{"Name"}})
797 {
798 return $StdCxxTypedef{$Version}{$ParamAttr{"Name"}};
799 }
800 elsif(my $Covered = cover_stdcxx_typedef($ParamAttr{"Name"}))
801 {
802 return $Covered;
803 }
804 else
805 {
806 return $ParamAttr{"Name"};
807 }
808 }
809 else
810 {
811 return $ParamAttr{"Name"};
812 }
813 }
814}
815
816sub cover_stdcxx_typedef($)
817{
818 my $TypeName = $_[0];
819 my $TypeName_Covered = $TypeName;
820 while($TypeName=~s/>[ ]*(const|volatile|restrict| |\*|\&)\Z/>/g){};
821 if(my $Cover = $StdCxxTypedef{$Version}{$TypeName})
822 {
823 $TypeName = esc_l($TypeName);
824 $TypeName_Covered=~s/$TypeName/$Cover /g;
825 }
826 return correctName($TypeName_Covered);
827}
828
829sub getNodeType($)
830{
831 return $LibInfo{$Version}{$_[0]}{"info_type"};
832}
833
834sub getNodeIntCst($)
835{
836 my $CstId = $_[0];
837 my $CstTypeId = getTreeAttr($CstId, "type");
838 if($EnumMembName_Id{$Version}{$CstId})
839 {
840 return $EnumMembName_Id{$Version}{$CstId};
841 }
842 elsif($LibInfo{$Version}{$_[0]}{"info"} =~ /low[ ]*:[ ]*([^ ]+) /)
843 {
844 if($1 eq "0")
845 {
846 if(getNodeType($CstTypeId) eq "boolean_type")
847 {
848 return "false";
849 }
850 else
851 {
852 return "0";
853 }
854 }
855 elsif($1 eq "1")
856 {
857 if(getNodeType($CstTypeId) eq "boolean_type")
858 {
859 return "true";
860 }
861 else
862 {
863 return "1";
864 }
865 }
866 else
867 {
868 return $1;
869 }
870 }
871 else
872 {
873 return "";
874 }
875}
876
877sub getNodeStrCst($)
878{
879 if($LibInfo{$Version}{$_[0]}{"info"} =~ /low[ ]*:[ ]*(.+)[ ]+lngt/)
880 {
881 return $1;
882 }
883 else
884 {
885 return "";
886 }
887}
888
889sub esc_l($)
890{
891 my $String = $_[0];
892 $String=~s/([()*])/\\$1/g;
893 return $String;
894}
895
896sub getFuncPtrAttr($$$)
897{
898 my ($FuncTypeId, $TypeDeclId, $TypeId) = @_;
899 my $FuncInfo = $LibInfo{$Version}{$FuncTypeId}{"info"};
900 my $FuncInfo_Type = $LibInfo{$Version}{$FuncTypeId}{"info_type"};
901 my $FuncPtrCorrectName = "";
902 my %TypeAttr = ("Size"=>$POINTER_SIZE, "Type"=>"FuncPtr", "TDid"=>$TypeDeclId, "Tid"=>$TypeId);
903 my @ParamTypeName;
904 if($FuncInfo =~ /retn[ ]*:[ ]*\@([0-9]+) /)
905 {
906 my $ReturnTypeId = $1;
907 my %ReturnAttr = getTypeAttr(getTypeDeclId($ReturnTypeId), $ReturnTypeId);
908 $FuncPtrCorrectName .= $ReturnAttr{"Name"};
909 $TypeAttr{"Return"} = $ReturnTypeId;
910 }
911 if($FuncInfo =~ /prms[ ]*:[ ]*@([0-9]+) /)
912 {
913 my $ParamTypeInfoId = $1;
914 my $Position = 0;
915 while($ParamTypeInfoId)
916 {
917 my $ParamTypeInfo = $LibInfo{$Version}{$ParamTypeInfoId}{"info"};
918 last if($ParamTypeInfo !~ /valu[ ]*:[ ]*@([0-9]+) /);
919 my $ParamTypeId = $1;
920 my %ParamAttr = getTypeAttr(getTypeDeclId($ParamTypeId), $ParamTypeId);
921 last if($ParamAttr{"Name"} eq "void");
922 $TypeAttr{"Memb"}{$Position}{"type"} = $ParamTypeId;
923 push(@ParamTypeName, $ParamAttr{"Name"});
924 last if($ParamTypeInfo !~ /chan[ ]*:[ ]*@([0-9]+) /);
925 $ParamTypeInfoId = $1;
926 $Position+=1;
927 }
928 }
929 if($FuncInfo_Type eq "function_type")
930 {
931 $FuncPtrCorrectName .= " (*) (".join(", ", @ParamTypeName).")";
932 }
933 elsif($FuncInfo_Type eq "method_type")
934 {
935 if($FuncInfo =~ /clas[ ]*:[ ]*@([0-9]+) /)
936 {
937 my $ClassId = $1;
938 my $ClassName = $TypeDescr{$Version}{getTypeDeclId($ClassId)}{$ClassId}{"Name"};
939 if($ClassName)
940 {
941 $FuncPtrCorrectName .= " ($ClassName\:\:*) (".join(", ", @ParamTypeName).")";
942 }
943 else
944 {
945 $FuncPtrCorrectName .= " (*) (".join(", ", @ParamTypeName).")";
946 }
947 }
948 else
949 {
950 $FuncPtrCorrectName .= " (*) (".join(", ", @ParamTypeName).")";
951 }
952 }
953 $TypeAttr{"Name"} = correctName($FuncPtrCorrectName);
954 return %TypeAttr;
955}
956
957sub getTypeName($)
958{
959 my $Info = $LibInfo{$Version}{$_[0]}{"info"};
960 if($Info =~ /name[ ]*:[ ]*@([0-9]+) /)
961 {
962 return getNameByInfo($1);
963 }
964 else
965 {
966 if($LibInfo{$Version}{$_[0]}{"info_type"} eq "integer_type")
967 {
968 if($LibInfo{$Version}{$_[0]}{"info"} =~ /unsigned/)
969 {
970 return "unsigned int";
971 }
972 else
973 {
974 return "int";
975 }
976 }
977 else
978 {
979 return "";
980 }
981 }
982}
983
984sub selectBaseType($$)
985{
986 my ($TypeDeclId, $TypeId) = @_;
987 my $TypeInfo = $LibInfo{$Version}{$TypeId}{"info"};
988 my $BaseTypeDeclId;
989 my $Type_Type = getTypeType($TypeDeclId, $TypeId);
990 #qualifications
991 if(($LibInfo{$Version}{$TypeId}{"info"} =~ /qual[ ]*:[ ]*c /) and ($LibInfo{$Version}{$TypeId}{"info"} =~ /unql[ ]*:[ ]*\@([0-9]+) /))
992 {
993 return ($1, getTypeDeclId($1), "const");
994 }
995 elsif(($LibInfo{$Version}{$TypeId}{"info"} =~ /qual[ ]*:[ ]*r /) and ($LibInfo{$Version}{$TypeId}{"info"} =~ /unql[ ]*:[ ]*\@([0-9]+) /))
996 {
997 return ($1, getTypeDeclId($1), "restrict");
998 }
999 elsif(($LibInfo{$Version}{$TypeId}{"info"} =~ /qual[ ]*:[ ]*v /) and ($LibInfo{$Version}{$TypeId}{"info"} =~ /unql[ ]*:[ ]*\@([0-9]+) /))
1000 {
1001 return ($1, getTypeDeclId($1), "volatile");
1002 }
1003 elsif((not ($LibInfo{$Version}{$TypeId}{"info"} =~ /qual[ ]*:/)) and ($LibInfo{$Version}{$TypeId}{"info"} =~ /unql[ ]*:[ ]*\@([0-9]+) /))
1004 {#typedefs
1005 return ($1, getTypeDeclId($1), "");
1006 }
1007 elsif($LibInfo{$Version}{$TypeId}{"info_type"} eq "reference_type")
1008 {
1009 if($TypeInfo =~ /refd[ ]*:[ ]*@([0-9]+) /)
1010 {
1011 return ($1, getTypeDeclId($1), "&");
1012 }
1013 else
1014 {
1015 return (0, 0, "");
1016 }
1017 }
1018 elsif($LibInfo{$Version}{$TypeId}{"info_type"} eq "array_type")
1019 {
1020 if($TypeInfo =~ /elts[ ]*:[ ]*@([0-9]+) /)
1021 {
1022 return ($1, getTypeDeclId($1), "");
1023 }
1024 else
1025 {
1026 return (0, 0, "");
1027 }
1028 }
1029 elsif($LibInfo{$Version}{$TypeId}{"info_type"} eq "pointer_type")
1030 {
1031 if($TypeInfo =~ /ptd[ ]*:[ ]*@([0-9]+) /)
1032 {
1033 return ($1, getTypeDeclId($1), "*");
1034 }
1035 else
1036 {
1037 return (0, 0, "");
1038 }
1039 }
1040 else
1041 {
1042 return (0, 0, "");
1043 }
1044}
1045
1046sub getFuncDescr_All()
1047{
1048 foreach (sort {int($b)<=>int($a)} keys(%{$LibInfo{$Version}}))
1049 {
1050 if($LibInfo{$Version}{$_}{"info_type"} eq "function_decl")
1051 {
1052 getFuncDescr($_);
1053 }
1054 }
1055}
1056
1057sub getVarDescr_All()
1058{
1059 foreach (sort {int($b)<=>int($a)} keys(%{$LibInfo{$Version}}))
1060 {
1061 if($LibInfo{$Version}{$_}{"info_type"} eq "var_decl")
1062 {
1063 getVarDescr($_);
1064 }
1065 }
1066}
1067
1068sub getVarDescr($)
1069{
1070 my $FuncInfoId = $_[0];
1071 if($LibInfo{$Version}{getNameSpaceId($FuncInfoId)}{"info_type"} eq "function_decl")
1072 {
1073 return;
1074 }
1075 ($FuncDescr{$Version}{$FuncInfoId}{"Header"}, $FuncDescr{$Version}{$FuncInfoId}{"Line"}) = getLocation($FuncInfoId);
1076 if((not $FuncDescr{$Version}{$FuncInfoId}{"Header"}) or ($FuncDescr{$Version}{$FuncInfoId}{"Header"}=~/\<built\-in\>|\<internal\>/))
1077 {
1078 delete($FuncDescr{$Version}{$FuncInfoId});
1079 return;
1080 }
1081 $FuncDescr{$Version}{$FuncInfoId}{"ShortName"} = getNameByInfo($FuncInfoId);
1082 $FuncDescr{$Version}{$FuncInfoId}{"MnglName"} = getFuncMnglName($FuncInfoId);
1083 if($FuncDescr{$Version}{$FuncInfoId}{"MnglName"} and $FuncDescr{$Version}{$FuncInfoId}{"MnglName"}!~/\A_Z/)
1084 {
1085 delete($FuncDescr{$Version}{$FuncInfoId});
1086 return;
1087 }
1088 if(not $FuncDescr{$Version}{$FuncInfoId}{"MnglName"})
1089 {
1090 $FuncDescr{$Version}{$FuncInfoId}{"Name"} = $FuncDescr{$Version}{$FuncInfoId}{"ShortName"};
1091 $FuncDescr{$Version}{$FuncInfoId}{"MnglName"} = $FuncDescr{$Version}{$FuncInfoId}{"ShortName"};
1092 }
1093 if(not is_in_library($FuncDescr{$Version}{$FuncInfoId}{"MnglName"}, $Version) and not $CheckHeadersOnly)
1094 {
1095 delete $FuncDescr{$Version}{$FuncInfoId};
1096 return;
1097 }
1098 $FuncDescr{$Version}{$FuncInfoId}{"Return"} = getTypeId($FuncInfoId);
1099 delete($FuncDescr{$Version}{$FuncInfoId}{"Return"}) if(not $FuncDescr{$Version}{$FuncInfoId}{"Return"});
1100 $FuncDescr{$Version}{$FuncInfoId}{"Data"} = 1;
1101 set_Class_And_Namespace($FuncInfoId);
1102 setFuncAccess($FuncInfoId);
1103 if($FuncDescr{$Version}{$FuncInfoId}{"MnglName"} =~ /\A_ZTV/)
1104 {
1105 delete($FuncDescr{$Version}{$FuncInfoId}{"Return"});
1106 }
1107 if($FuncDescr{$Version}{$FuncInfoId}{"ShortName"} =~ /\A_Z/)
1108 {
1109 delete($FuncDescr{$Version}{$FuncInfoId}{"ShortName"});
1110 }
1111}
1112
1113sub getTrivialTypeAttr($$)
1114{
1115 my ($TypeInfoId, $TypeId) = @_;
1116 my %TypeAttr = ();
1117 return if(getTypeTypeByTypeId($TypeId)!~/Intrinsic|Union|Struct|Enum/);
1118 setTypeAccess($TypeId, \%TypeAttr);
1119 ($TypeAttr{"Header"}, $TypeAttr{"Line"}) = getLocation($TypeInfoId);
1120 if(($TypeAttr{"Header"} eq "<built-in>") or ($TypeAttr{"Header"} eq "<internal>"))
1121 {
1122 delete($TypeAttr{"Header"});
1123 }
1124 $TypeAttr{"Name"} = getNameByInfo($TypeInfoId);
1125 $TypeAttr{"Name"} = getTypeName($TypeId) if(not $TypeAttr{"Name"});
1126 my $NameSpaceId = getNameSpaceId($TypeInfoId);
1127 if($NameSpaceId ne $TypeId)
1128 {
1129 $TypeAttr{"NameSpace"} = getNameSpace($TypeInfoId);
1130 }
1131 if($TypeAttr{"NameSpace"} and isNotAnon($TypeAttr{"Name"}))
1132 {
1133 $TypeAttr{"Name"} = $TypeAttr{"NameSpace"}."::".$TypeAttr{"Name"};
1134 }
1135 $TypeAttr{"Name"} = correctName($TypeAttr{"Name"});
1136 if(isAnon($TypeAttr{"Name"}))
1137 {
1138 $TypeAttr{"Name"} = "anon-";
1139 $TypeAttr{"Name"} .= $TypeAttr{"Header"}."-".$TypeAttr{"Line"};
1140 }
1141 $TypeAttr{"Size"} = getSize($TypeId)/8;
1142 $TypeAttr{"Type"} = getTypeType($TypeInfoId, $TypeId);
1143 if($TypeAttr{"Type"} eq "Struct" and has_methods($TypeId))
1144 {
1145 $TypeAttr{"Type"} = "Class";
1146 }
1147 if(($TypeAttr{"Type"} eq "Struct") or ($TypeAttr{"Type"} eq "Class"))
1148 {
1149 setBaseClasses($TypeInfoId, $TypeId, \%TypeAttr);
1150 }
1151 setTypeMemb($TypeInfoId, $TypeId, \%TypeAttr);
1152 $TypeAttr{"Tid"} = $TypeId;
1153 $TypeAttr{"TDid"} = $TypeInfoId;
1154 $Tid_TDid{$Version}{$TypeId} = $TypeInfoId;
1155 if(not $TName_Tid{$Version}{$TypeAttr{"Name"}})
1156 {
1157 $TName_Tid{$Version}{$TypeAttr{"Name"}} = $TypeId;
1158 }
1159 return %TypeAttr;
1160}
1161
1162sub has_methods($)
1163{
1164 my $TypeId = $_[0];
1165 my $Info = $LibInfo{$Version}{$TypeId}{"info"};
1166 return ($Info=~/(fncs)[ ]*:[ ]*@([0-9]+) /);
1167}
1168
1169sub setBaseClasses($$$)
1170{
1171 my ($TypeInfoId, $TypeId, $TypeAttr) = @_;
1172 my $Info = $LibInfo{$Version}{$TypeId}{"info"};
1173 if($Info =~ /binf[ ]*:[ ]*@([0-9]+) /)
1174 {
1175 $Info = $LibInfo{$Version}{$1}{"info"};
1176 while($Info =~ /accs[ ]*:[ ]*([a-z]+) /)
1177 {
1178 last if($Info !~ s/accs[ ]*:[ ]*([a-z]+) //);
1179 my $Access = $1;
1180 last if($Info !~ s/binf[ ]*:[ ]*@([0-9]+) //);
1181 my $BInfoId = $1;
1182 my $ClassId = getBinfClassId($BInfoId);
1183 if($Access eq "pub")
1184 {
1185 $TypeAttr->{"BaseClass"}{$ClassId} = "public";
1186 }
1187 elsif($Access eq "prot")
1188 {
1189 $TypeAttr->{"BaseClass"}{$ClassId} = "protected";
1190 }
1191 elsif($Access eq "priv")
1192 {
1193 $TypeAttr->{"BaseClass"}{$ClassId} = "private";
1194 }
1195 else
1196 {
1197 $TypeAttr->{"BaseClass"}{$ClassId} = "private";
1198 }
1199 }
1200 }
1201}
1202
1203sub getBinfClassId($)
1204{
1205 my $Info = $LibInfo{$Version}{$_[0]}{"info"};
1206 $Info =~ /type[ ]*:[ ]*@([0-9]+) /;
1207 return $1;
1208}
1209
1210sub get_func_signature($)
1211{
1212 my $FuncInfoId = $_[0];
1213 my $PureSignature = $FuncDescr{$Version}{$FuncInfoId}{"ShortName"};
1214 my @ParamTypes = ();
1215 foreach my $ParamPos (sort {int($a) <=> int($b)} keys(%{$FuncDescr{$Version}{$FuncInfoId}{"Param"}}))
1216 {#checking parameters
1217 my $ParamType_Id = $FuncDescr{$Version}{$FuncInfoId}{"Param"}{$ParamPos}{"type"};
1218 my $ParamType_Name = uncover_typedefs($TypeDescr{$Version}{getTypeDeclId($ParamType_Id)}{$ParamType_Id}{"Name"});
1219 @ParamTypes = (@ParamTypes, $ParamType_Name);
1220 }
1221 $PureSignature = $PureSignature."(".join(", ", @ParamTypes).")";
1222 $PureSignature = delete_keywords($PureSignature);
1223 return correctName($PureSignature);
1224}
1225
1226sub delete_keywords($)
1227{
1228 my $TypeName = $_[0];
1229 $TypeName =~ s/(\W|\A)(enum |struct |union |class )/$1/g;
1230 return $TypeName;
1231}
1232
1233sub uncover_typedefs($)
1234{
1235 my $TypeName = $_[0];
1236 return "" if(not $TypeName);
1237 return $Cache{"uncover_typedefs"}{$Version}{$TypeName} if(defined $Cache{"uncover_typedefs"}{$Version}{$TypeName});
1238 my ($TypeName_New, $TypeName_Pre) = (correctName($TypeName), "");
1239 while($TypeName_New ne $TypeName_Pre)
1240 {
1241 $TypeName_Pre = $TypeName_New;
1242 my $TypeName_Copy = $TypeName_New;
1243 my %Words = ();
1244 while($TypeName_Copy=~s/(\W|\A)([a-z_][\w:]*)(\W|\Z)//io)
1245 {
1246 my $Word = $2;
1247 next if(not $Word or $Word=~/\A(true|false|const|int|long|void|short|float|unsigned|char|double|class|struct|union|enum)\Z/);
1248 $Words{$Word} = 1;
1249 }
1250 foreach my $Word (keys(%Words))
1251 {
1252 my $BaseType_Name = $Typedef_BaseName{$Version}{$Word};
1253 next if($TypeName_New=~/(\W|\A)(struct $Word|union $Word|enum $Word)(\W|\Z)/);
1254 next if(not $BaseType_Name);
1255 if($BaseType_Name=~/\([*]+\)/)
1256 {
1257 $TypeName_New =~ /$Word(.*)\Z/;
1258 my $Type_Suffix = $1;
1259 $TypeName_New = $BaseType_Name;
1260 if($TypeName_New =~ s/\(([*]+)\)/($1 $Type_Suffix)/)
1261 {
1262 $TypeName_New = correctName($TypeName_New);
1263 }
1264 }
1265 else
1266 {
1267 if($TypeName_New =~ s/(\W|\A)$Word(\W|\Z)/$1$BaseType_Name$2/g)
1268 {
1269 $TypeName_New = correctName($TypeName_New);
1270 }
1271 }
1272 }
1273 }
1274 $Cache{"uncover_typedefs"}{$Version}{$TypeName} = $TypeName_New;
1275 return $TypeName_New;
1276}
1277
1278sub isInternal($)
1279{
1280 my $FuncInfoId = $_[0];
1281 my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
1282 return 0 if($FuncInfo !~ /mngl[ ]*:[ ]*@([0-9]+) /);
1283 my $FuncMnglNameInfoId = $1;
1284 return ($LibInfo{$Version}{$FuncMnglNameInfoId}{"info"} =~ /\*[ ]*INTERNAL[ ]*\*/);
1285}
1286
1287sub set_Class_And_Namespace($)
1288{
1289 my $FuncInfoId = $_[0];
1290 my $FuncInfo = $LibInfo{$Version}{$FuncInfoId}{"info"};
1291 if($FuncInfo =~ /scpe[ ]*:[ ]*@([0-9]+) /)
1292 {
1293 my $NameSpaceInfoId = $1;
1294 if($LibInfo{$Version}{$NameSpaceInfoId}{"info_type"} eq "namespace_decl")
1295 {
1296 my $NameSpaceInfo = $LibInfo{$Version}{$NameSpaceInfoId}{"info"};
1297 if($NameSpaceInfo =~ /name[ ]*:[ ]*@([0-9]+) /)
1298 {
1299 my $NameSpaceId = $1;
1300 my $NameSpaceIdentifier = $LibInfo{$Version}{$NameSpaceId}{"info"};
1301 if($NameSpaceIdentifier =~ /strg[ ]*:[ ]*(.*)[ ]+lngt/)
1302 {
1303 my $NameSpace = $1;
1304 $NameSpace =~ s/[ ]+\Z//g;
1305 $FuncDescr{$Version}{$FuncInfoId}{"NameSpace"} = $NameSpace;
1306 }
1307 }
1308 }
1309 elsif($LibInfo{$Version}{$NameSpaceInfoId}{"info_type"} eq "record_type")
1310 {
1311 $FuncDescr{$Version}{$FuncInfoId}{"Class"} = $NameSpaceInfoId;
1312 }
1313 }
1314}
1315
1316sub getFuncDescr($)
1317{
1318 my $FuncInfoId = $_[0];
1319 return if(isInternal($FuncInfoId));
1320 ($FuncDescr{$Version}{$FuncInfoId}{"Header"}, $FuncDescr{$Version}{$FuncInfoId}{"Line"}) = getLocation($FuncInfoId);
1321 if(not $FuncDescr{$Version}{$FuncInfoId}{"Header"} or $FuncDescr{$Version}{$FuncInfoId}{"Header"}=~/\<built\-in\>|\<internal\>/)
1322 {
1323 delete($FuncDescr{$Version}{$FuncInfoId});
1324 return;
1325 }
1326 setFuncAccess($FuncInfoId);
1327 setFuncKind($FuncInfoId);
1328 if($FuncDescr{$Version}{$FuncInfoId}{"PseudoTemplate"})
1329 {
1330 delete($FuncDescr{$Version}{$FuncInfoId});
1331 return;
1332 }
1333 $FuncDescr{$Version}{$FuncInfoId}{"Type"} = getFuncType($FuncInfoId);
1334 $FuncDescr{$Version}{$FuncInfoId}{"Return"} = getFuncReturn($FuncInfoId);
1335 delete($FuncDescr{$Version}{$FuncInfoId}{"Return"}) if(not $FuncDescr{$Version}{$FuncInfoId}{"Return"});
1336 $FuncDescr{$Version}{$FuncInfoId}{"ShortName"} = getFuncShortName(getFuncOrig($FuncInfoId));
1337 if($FuncDescr{$Version}{$FuncInfoId}{"ShortName"} =~ /\._/)
1338 {
1339 delete($FuncDescr{$Version}{$FuncInfoId});
1340 return;
1341 }
1342 if(defined $TemplateInstance_Func{$Version}{$FuncInfoId})
1343 {
1344 my @TmplParams = ();
1345 foreach my $ParamPos (sort {int($a) <=> int($b)} keys(%{$TemplateInstance_Func{$Version}{$FuncInfoId}}))
1346 {
1347 my $Param = get_TemplateParam($TemplateInstance_Func{$Version}{$FuncInfoId}{$ParamPos});
1348 if($Param eq "")
1349 {
1350 delete($FuncDescr{$Version}{$FuncInfoId});
1351 return;
1352 }
1353 push(@TmplParams, $Param);
1354 }
1355 $FuncDescr{$Version}{$FuncInfoId}{"ShortName"} .= "<".join(", ", @TmplParams).">";
1356 }
1357 setFuncParams($FuncInfoId);
1358 $FuncDescr{$Version}{$FuncInfoId}{"MnglName"} = getFuncMnglName($FuncInfoId);
1359 if($FuncDescr{$Version}{$FuncInfoId}{"MnglName"} and $FuncDescr{$Version}{$FuncInfoId}{"MnglName"}!~/\A_Z/)
1360 {
1361 delete($FuncDescr{$Version}{$FuncInfoId});
1362 return;
1363 }
1364
1365 if((is_in_library($FuncDescr{$Version}{$FuncInfoId}{"ShortName"}, $Version) or $CheckHeadersOnly) and not $FuncDescr{$Version}{$FuncInfoId}{"MnglName"} and ($FuncDescr{$Version}{$FuncInfoId}{"Type"} eq "Function"))
1366 {
1367 $FuncDescr{$Version}{$FuncInfoId}{"MnglName"} = $FuncDescr{$Version}{$FuncInfoId}{"ShortName"};
1368 }
1369 set_Class_And_Namespace($FuncInfoId);
1370 if(not $FuncDescr{$Version}{$FuncInfoId}{"MnglName"} and not $FuncDescr{$Version}{$FuncInfoId}{"Class"})
1371 {#this section only for c++ functions without class that have not been mangled in the tree
1372 $FuncDescr{$Version}{$FuncInfoId}{"MnglName"} = $mangled_name{get_func_signature($FuncInfoId)};
1373 }
1374 if(not is_in_library($FuncDescr{$Version}{$FuncInfoId}{"MnglName"}, $Version) and not $CheckHeadersOnly)
1375 {#src only
1376 delete($FuncDescr{$Version}{$FuncInfoId});
1377 return;
1378 }
1379 if($FuncDescr{$Version}{$FuncInfoId}{"Constructor"} or $FuncDescr{$Version}{$FuncInfoId}{"Destructor"})
1380 {
1381 delete($FuncDescr{$Version}{$FuncInfoId}{"Return"});
1382 }
1383 my $FuncBody = getFuncBody($FuncInfoId);
1384 if($FuncBody eq "defined")
1385 {
1386 $FuncDescr{$Version}{$FuncInfoId}{"InLine"} = 1;
1387 }
1388 if($CheckHeadersOnly and $FuncDescr{$Version}{$FuncInfoId}{"InLine"})
1389 {
1390 delete($FuncDescr{$Version}{$FuncInfoId});
1391 return;
1392 }
1393 if(($FuncDescr{$Version}{$FuncInfoId}{"Type"} eq "Method") or $FuncDescr{$Version}{$FuncInfoId}{"Constructor"} or $FuncDescr{$Version}{$FuncInfoId}{"Destructor"})
1394 {
1395 if($FuncDescr{$Version}{$FuncInfoId}{"MnglName"}!~/\A_Z/)
1396 {
1397 delete($FuncDescr{$Version}{$FuncInfoId});
1398 return;
1399 }
1400 }
1401 if(getFuncSpec($FuncInfoId) eq "Virt")
1402 {#virtual methods
1403 $FuncDescr{$Version}{$FuncInfoId}{"Virt"} = 1;
1404 }
1405 if(getFuncSpec($FuncInfoId) eq "PureVirt")
1406 {#pure virtual methods
1407 $FuncDescr{$Version}{$FuncInfoId}{"PureVirt"} = 1;
1408 }
1409 if($FuncDescr{$Version}{$FuncInfoId}{"MnglName"} =~ /\A_Z/ and $FuncDescr{$Version}{$FuncInfoId}{"Class"})
1410 {
1411 if($FuncDescr{$Version}{$FuncInfoId}{"Type"} eq "Function")
1412 {#static methods
1413 $FuncDescr{$Version}{$FuncInfoId}{"Static"} = 1;
1414 }
1415 }
1416 if(getFuncLink($FuncInfoId) eq "Static")
1417 {
1418 $FuncDescr{$Version}{$FuncInfoId}{"Static"} = 1;
1419 }
1420 delete($FuncDescr{$Version}{$FuncInfoId}{"Type"});
1421}
1422
1423sub getFuncBody($)
1424{
1425 my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
1426 if($FuncInfo =~ /body[ ]*:[ ]*undefined(\ |\Z)/i)
1427 {
1428 return "undefined";
1429 }
1430 elsif($FuncInfo =~ /body[ ]*:[ ]*@([0-9]+)(\ |\Z)/i)
1431 {
1432 return "defined";
1433 }
1434 else
1435 {
1436 return "";
1437 }
1438}
1439
1440sub getTypeShortName($)
1441{
1442 my $TypeName = $_[0];
1443 $TypeName =~ s/\<.*\>//g;
1444 $TypeName =~ s/.*\:\://g;
1445 return $TypeName;
1446}
1447
1448sub getBackRef($)
1449{
1450 my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
1451 if($TypeInfo =~ /name[ ]*:[ ]*@([0-9]+) /)
1452 {
1453 return $1;
1454 }
1455 else
1456 {
1457 return "";
1458 }
1459}
1460
1461sub getTypeId($)
1462{
1463 my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
1464 if($TypeInfo =~ /type[ ]*:[ ]*@([0-9]+) /)
1465 {
1466 return $1;
1467 }
1468 else
1469 {
1470 return "";
1471 }
1472}
1473
1474sub getFuncId($)
1475{
1476 my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
1477 if($FuncInfo =~ /type[ ]*:[ ]*@([0-9]+) /)
1478 {
1479 return $1;
1480 }
1481 else
1482 {
1483 return "";
1484 }
1485}
1486
1487sub setTypeMemb($$)
1488{
1489 my ($TypeDeclId, $TypeId, $TypeAttr) = @_;
1490 my $TypeInfo = $LibInfo{$Version}{$TypeId}{"info"};
1491 my $TypeMembInfoId;
1492 my $TypeType = $TypeAttr->{"Type"};
1493 my $Position = 0;
1494 my $BasePosition = 0;
1495 my $TypeTypeInfoId;
1496 my $StructMembName;
1497 if($TypeType eq "Enum")
1498 {
1499 $TypeMembInfoId = getEnumMembInfoId($TypeId);
1500 while($TypeMembInfoId)
1501 {
1502 $TypeAttr->{"Memb"}{$Position}{"value"} = getEnumMembVal($TypeMembInfoId);
1503 my $MembName = getEnumMembName($TypeMembInfoId);
1504 $TypeAttr->{"Memb"}{$Position}{"name"} = getEnumMembName($TypeMembInfoId);
1505 $EnumMembName_Id{$Version}{getTreeAttr($TypeMembInfoId, "valu")} = ($TypeAttr->{"NameSpace"})?$TypeAttr->{"NameSpace"}."::".$MembName:$MembName;
1506 $TypeMembInfoId = getNextMembInfoId($TypeMembInfoId);
1507 $Position += 1;
1508 }
1509 }
1510 elsif(($TypeType eq "Struct") or ($TypeType eq "Class") or ($TypeType eq "Union"))
1511 {
1512 $TypeMembInfoId = getStructMembInfoId($TypeId);
1513 while($TypeMembInfoId)
1514 {
1515 if($LibInfo{$Version}{$TypeMembInfoId}{"info_type"} ne "field_decl")
1516 {
1517 $TypeMembInfoId = getNextStructMembInfoId($TypeMembInfoId);
1518 next;
1519 }
1520 $StructMembName = getStructMembName($TypeMembInfoId);
1521 if($StructMembName =~ /_vptr\./)
1522 {#virtual tables
1523 $TypeMembInfoId = getNextStructMembInfoId($TypeMembInfoId);
1524 next;
1525 }
1526 if(not $StructMembName)
1527 {#base classes
1528 #$TypeAttr->{"Base"}{$BasePosition}{"type"} = getStructMembType($TypeMembInfoId);
1529 #$TypeAttr->{"Base"}{$BasePosition}{"access"} = getStructMembAccess($TypeMembInfoId);
1530 $BasePosition += 1;
1531 $TypeMembInfoId = getNextStructMembInfoId($TypeMembInfoId);
1532 next;
1533 }
1534 $TypeAttr->{"Memb"}{$Position}{"type"} = getStructMembType($TypeMembInfoId);
1535 $TypeAttr->{"Memb"}{$Position}{"name"} = $StructMembName;
1536 $TypeAttr->{"Memb"}{$Position}{"access"} = getStructMembAccess($TypeMembInfoId);
1537 $TypeAttr->{"Memb"}{$Position}{"bitfield"} = getStructMembBitFieldSize($TypeMembInfoId);
1538
1539 $TypeMembInfoId = getNextStructMembInfoId($TypeMembInfoId);
1540 $Position += 1;
1541 }
1542 }
1543}
1544
1545sub setFuncParams($)
1546{
1547 my $FuncInfoId = $_[0];
1548 my $ParamInfoId = getFuncParamInfoId($FuncInfoId);
1549 my $FunctionType = getFuncType($FuncInfoId);
1550 if($FunctionType eq "Method")
1551 {
1552 $ParamInfoId = getNextElem($ParamInfoId);
1553 }
1554 my $Position = 0;
1555 while($ParamInfoId)
1556 {
1557 my $ParamTypeId = getFuncParamType($ParamInfoId);
1558 last if($TypeDescr{$Version}{getTypeDeclId($ParamTypeId)}{$ParamTypeId}{"Name"} eq "void");
1559 if($TypeDescr{$Version}{getTypeDeclId($ParamTypeId)}{$ParamTypeId}{"Type"} eq "Restrict")
1560 {#delete restrict spec
1561 $ParamTypeId = getRestrictBase($ParamTypeId);
1562 }
1563 $FuncDescr{$Version}{$FuncInfoId}{"Param"}{$Position}{"type"} = $ParamTypeId;
1564 $FuncDescr{$Version}{$FuncInfoId}{"Param"}{$Position}{"name"} = getFuncParamName($ParamInfoId);
1565 if(not $FuncDescr{$Version}{$FuncInfoId}{"Param"}{$Position}{"name"})
1566 {
1567 $FuncDescr{$Version}{$FuncInfoId}{"Param"}{$Position}{"name"} = "p".($Position+1);
1568 }
1569 $ParamInfoId = getNextElem($ParamInfoId);
1570 $Position += 1;
1571 }
1572 if(detect_nolimit_args($FuncInfoId))
1573 {
1574 $FuncDescr{$Version}{$FuncInfoId}{"Param"}{$Position}{"type"} = -1;
1575 }
1576}
1577
1578sub detect_nolimit_args($)
1579{
1580 my $FuncInfoId = $_[0];
1581 my $FuncTypeId = getFuncTypeId($FuncInfoId);
1582 my $ParamListElemId = getFuncParamTreeListId($FuncTypeId);
1583 my $HaveVoid = 0;
1584 my $Position = 0;
1585 while($ParamListElemId)
1586 {
1587 my $ParamTypeId = getTreeAttr($ParamListElemId, "valu");
1588 if($TypeDescr{$Version}{getTypeDeclId($ParamTypeId)}{$ParamTypeId}{"Name"} eq "void")
1589 {
1590 $HaveVoid = 1;
1591 last;
1592 }
1593 $ParamListElemId = getNextElem($ParamListElemId);
1594 $Position += 1;
1595 }
1596 return ($Position>=1 and not $HaveVoid);
1597}
1598
1599sub getFuncParamTreeListId($)
1600{
1601 my $FuncTypeId = $_[0];
1602 if($LibInfo{$Version}{$FuncTypeId}{"info"} =~ /prms[ ]*:[ ]*@([0-9]+) /)
1603 {
1604 return $1;
1605 }
1606 else
1607 {
1608 return "";
1609 }
1610}
1611
1612sub getTreeAttr($$)
1613{
1614 my ($Id, $Attr) = @_;
1615 if($LibInfo{$Version}{$Id}{"info"} =~ /$Attr[ ]*:[ ]*@([0-9]+) /)
1616 {
1617 return $1;
1618 }
1619 else
1620 {
1621 return "";
1622 }
1623}
1624
1625sub getRestrictBase($)
1626{
1627 my $TypeId = $_[0];
1628 my $TypeDeclId = getTypeDeclId($TypeId);
1629 my $BaseTypeId = $TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"BaseType"}{"Tid"};
1630 my $BaseTypeDeclId = $TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"BaseType"}{"TDid"};
1631 return $BaseTypeId;
1632}
1633
1634sub setFuncAccess($)
1635{
1636 my $FuncInfoId = $_[0];
1637 if($LibInfo{$Version}{$FuncInfoId}{"info"} =~ /accs[ ]*:[ ]*([a-zA-Z]+) /)
1638 {
1639 my $Access = $1;
1640 if($Access eq "prot")
1641 {
1642 $FuncDescr{$Version}{$FuncInfoId}{"Protected"} = 1;
1643 }
1644 elsif($Access eq "priv")
1645 {
1646 $FuncDescr{$Version}{$FuncInfoId}{"Private"} = 1;
1647 }
1648 }
1649}
1650
1651sub setTypeAccess($$)
1652{
1653 my ($TypeId, $TypeAttr) = @_;
1654 my $TypeInfo = $LibInfo{$Version}{$TypeId}{"info"};
1655 if($TypeInfo =~ /accs[ ]*:[ ]*([a-zA-Z]+) /)
1656 {
1657 my $Access = $1;
1658 if($Access eq "prot")
1659 {
1660 $TypeAttr->{"Protected"} = 1;
1661 }
1662 elsif($Access eq "priv")
1663 {
1664 $TypeAttr->{"Private"} = 1;
1665 }
1666 }
1667}
1668
1669sub setFuncKind($)
1670{
1671 my $FuncInfoId = $_[0];
1672 if($LibInfo{$Version}{$FuncInfoId}{"info"} =~ /pseudo tmpl/)
1673 {
1674 $FuncDescr{$Version}{$FuncInfoId}{"PseudoTemplate"} = 1;
1675 }
1676 elsif($LibInfo{$Version}{$FuncInfoId}{"info"} =~ /note[ ]*:[ ]*constructor /)
1677 {
1678 $FuncDescr{$Version}{$FuncInfoId}{"Constructor"} = 1;
1679 }
1680 elsif($LibInfo{$Version}{$FuncInfoId}{"info"} =~ /note[ ]*:[ ]*destructor /)
1681 {
1682 $FuncDescr{$Version}{$FuncInfoId}{"Destructor"} = 1;
1683 }
1684}
1685
1686sub getFuncSpec($)
1687{
1688 my $FuncInfoId = $_[0];
1689 my $FuncInfo = $LibInfo{$Version}{$FuncInfoId}{"info"};
1690 if($FuncInfo =~ m/spec[ ]*:[ ]*pure /)
1691 {
1692 return "PureVirt";
1693 }
1694 elsif($FuncInfo =~ m/spec[ ]*:[ ]*virt /)
1695 {
1696 return "Virt";
1697 }
1698 else
1699 {
1700 if($FuncInfo =~ /spec[ ]*:[ ]*([a-zA-Z]+) /)
1701 {
1702 return $1;
1703 }
1704 else
1705 {
1706 return "";
1707 }
1708 }
1709}
1710
1711sub getFuncClass($)
1712{
1713 my $FuncInfoId = $_[0];
1714 my $FuncInfo = $LibInfo{$Version}{$FuncInfoId}{"info"};
1715 if($FuncInfo =~ /scpe[ ]*:[ ]*@([0-9]+) /)
1716 {
1717 return $1;
1718 }
1719 else
1720 {
1721 return "";
1722 }
1723}
1724
1725sub getFuncLink($)
1726{
1727 my $FuncInfoId = $_[0];
1728 my $FuncInfo = $LibInfo{$Version}{$FuncInfoId}{"info"};
1729 if($FuncInfo =~ /link[ ]*:[ ]*static /)
1730 {
1731 return "Static";
1732 }
1733 else
1734 {
1735 if($FuncInfo =~ /link[ ]*:[ ]*([a-zA-Z]+) /)
1736 {
1737 return $1;
1738 }
1739 else
1740 {
1741 return "";
1742 }
1743 }
1744}
1745
1746sub getNextElem($)
1747{
1748 my $FuncInfoId = $_[0];
1749 my $FuncInfo = $LibInfo{$Version}{$FuncInfoId}{"info"};
1750 if($FuncInfo =~ /chan[ ]*:[ ]*@([0-9]+) /)
1751 {
1752 return $1;
1753 }
1754 else
1755 {
1756 return "";
1757 }
1758}
1759
1760sub getFuncParamInfoId($)
1761{
1762 my $FuncInfoId = $_[0];
1763 my $FuncInfo = $LibInfo{$Version}{$FuncInfoId}{"info"};
1764 if($FuncInfo =~ /args[ ]*:[ ]*@([0-9]+) /)
1765 {
1766 return $1;
1767 }
1768 else
1769 {
1770 return "";
1771 }
1772}
1773
1774sub getFuncParamType($)
1775{
1776 my $ParamInfoId = $_[0];
1777 my $ParamInfo = $LibInfo{$Version}{$ParamInfoId}{"info"};
1778 if($ParamInfo =~ /type[ ]*:[ ]*@([0-9]+) /)
1779 {
1780 return $1;
1781 }
1782 else
1783 {
1784 return "";
1785 }
1786}
1787
1788sub getFuncParamName($)
1789{
1790 my $ParamInfoId = $_[0];
1791 my $ParamInfo = $LibInfo{$Version}{$ParamInfoId}{"info"};
1792 return "" if($ParamInfo !~ /name[ ]*:[ ]*@([0-9]+) /);
1793 my $NameInfoId = $1;
1794 return "" if($LibInfo{$Version}{$NameInfoId}{"info"} !~ /strg[ ]*:[ ]*(.*)[ ]+lngt/);
1795 my $FuncParamName = $1;
1796 $FuncParamName =~ s/[ ]+\Z//g;
1797 return $FuncParamName;
1798}
1799
1800sub getEnumMembInfoId($)
1801{
1802 my $TypeInfoId = $_[0];
1803 my $TypeInfo = $LibInfo{$Version}{$TypeInfoId}{"info"};
1804 if($TypeInfo =~ /csts[ ]*:[ ]*@([0-9]+) /)
1805 {
1806 return $1;
1807 }
1808 else
1809 {
1810 return "";
1811 }
1812}
1813
1814sub getStructMembInfoId($)
1815{
1816 my $TypeInfoId = $_[0];
1817 my $TypeInfo = $LibInfo{$Version}{$TypeInfoId}{"info"};
1818 if($TypeInfo =~ /flds[ ]*:[ ]*@([0-9]+) /)
1819 {
1820 return $1;
1821 }
1822 else
1823 {
1824 return "";
1825 }
1826}
1827
1828sub getNameSpace($)
1829{
1830 my $TypeInfoId = $_[0];
1831 my $TypeInfo = $LibInfo{$Version}{$TypeInfoId}{"info"};
1832 return "" if($TypeInfo !~ /scpe[ ]*:[ ]*@([0-9]+) /);
1833 my $NameSpaceInfoId = $1;
1834 if($LibInfo{$Version}{$NameSpaceInfoId}{"info_type"} eq "namespace_decl")
1835 {
1836 my $NameSpaceInfo = $LibInfo{$Version}{$NameSpaceInfoId}{"info"};
1837 if($NameSpaceInfo =~ /name[ ]*:[ ]*@([0-9]+) /)
1838 {
1839 my $NameSpaceId = $1;
1840 my $NameSpaceIdentifier = $LibInfo{$Version}{$NameSpaceId}{"info"};
1841 return "" if($NameSpaceIdentifier !~ /strg[ ]*:[ ]*(.*)[ ]+lngt/);
1842 my $NameSpace = $1;
1843 $NameSpace =~ s/[ ]+\Z//g;
1844 my $BaseNameSpace = getNameSpace($NameSpaceInfoId);
1845 $NameSpace = $BaseNameSpace."::".$NameSpace if($BaseNameSpace);
1846 return $NameSpace;
1847 }
1848 else
1849 {
1850 return "";
1851 }
1852 }
1853 elsif($LibInfo{$Version}{$NameSpaceInfoId}{"info_type"} eq "record_type")
1854 {
1855 my %NameSpaceAttr = getTypeAttr(getTypeDeclId($NameSpaceInfoId), $NameSpaceInfoId);
1856 return $NameSpaceAttr{"Name"};
1857 }
1858 else
1859 {
1860 return "";
1861 }
1862}
1863
1864sub getNameSpaceId($)
1865{
1866 my $TypeInfoId = $_[0];
1867 my $TypeInfo = $LibInfo{$Version}{$TypeInfoId}{"info"};
1868 if($TypeInfo =~ /scpe[ ]*:[ ]*@([0-9]+) /)
1869 {
1870 return $1;
1871 }
1872 else
1873 {
1874 return "";
1875 }
1876}
1877
1878sub getEnumMembName($)
1879{
1880 my $TypeMembInfoId = $_[0];
1881 return "" if($LibInfo{$Version}{$TypeMembInfoId}{"info"} !~ /purp[ ]*:[ ]*@([0-9]+)/);
1882 my $Purp = $1;
1883 return "" if($LibInfo{$Version}{$Purp}{"info"} !~ /strg[ ]*:[ ]*(.*)[ ]+lngt/);
1884 my $EnumMembName = $1;
1885 $EnumMembName =~ s/[ ]+\Z//g;
1886 return $EnumMembName;
1887}
1888
1889sub getStructMembName($)
1890{
1891 my $TypeMembInfoId = $_[0];
1892 return "" if($LibInfo{$Version}{$TypeMembInfoId}{"info"} !~ /name[ ]*:[ ]*@([0-9]+) /);
1893 my $NameInfoId = $1;
1894 return "" if($LibInfo{$Version}{$NameInfoId}{"info"} !~ /strg[ ]*:[ ]*(.*)[ ]+lngt/);
1895 my $StructMembName = $1;
1896 $StructMembName =~ s/[ ]+\Z//g;
1897 return $StructMembName;
1898}
1899
1900sub getEnumMembVal($)
1901{
1902 my $TypeMembInfoId = $_[0];
1903 return "" if($LibInfo{$Version}{$TypeMembInfoId}{"info"} !~ /valu[ ]*:[ ]*@([0-9]+) /);
1904 my $Valu = $1;
1905 if($LibInfo{$Version}{$Valu}{"info"} =~ /low[ ]*:[ ]*(-?[0-9]+) /)
1906 {
1907 return $1;
1908 }
1909 else
1910 {
1911 return "";
1912 }
1913}
1914
1915sub getSize($)
1916{
1917 my $Info = $LibInfo{$Version}{$_[0]}{"info"};
1918 if($Info =~ /size[ ]*:[ ]*@([0-9]+) /)
1919 {
1920 my $SizeInfoId = $1;
1921 if($LibInfo{$Version}{$SizeInfoId}{"info"} =~ /low[ ]*:[ ]*(-?[0-9]+) /)
1922 {
1923 return $1;
1924 }
1925 else
1926 {
1927 return "";
1928 }
1929 }
1930 else
1931 {
1932 return 0;
1933 }
1934}
1935
1936sub getStructMembType($)
1937{
1938 my $TypeMembInfoId = $_[0];
1939 if($LibInfo{$Version}{$TypeMembInfoId}{"info"} =~ /type[ ]*:[ ]*@([0-9]+) /)
1940 {
1941 return $1;
1942 }
1943 else
1944 {
1945 return "";
1946 }
1947}
1948
1949sub getStructMembBitFieldSize($)
1950{
1951 my $TypeMembInfoId = $_[0];
1952 if($LibInfo{$Version}{$TypeMembInfoId}{"info"} =~ / bitfield /)
1953 {
1954 return getSize($TypeMembInfoId);
1955 }
1956 else
1957 {
1958 return 0;
1959 }
1960}
1961
1962sub getStructMembAccess($)
1963{
1964 my $MembInfo = $LibInfo{$Version}{$_[0]}{"info"};
1965 if($MembInfo =~ /accs[ ]*:[ ]*([a-zA-Z]+) /)
1966 {
1967 my $Access = $1;
1968 if($Access eq "prot")
1969 {
1970 return "protected";
1971 }
1972 elsif($Access eq "priv")
1973 {
1974 return "private";
1975 }
1976 else
1977 {
1978 return "public";
1979 }
1980 }
1981 else
1982 {
1983 return "public";
1984 }
1985}
1986
1987sub getNextMembInfoId($)
1988{
1989 my $TypeMembInfoId = $_[0];
1990 if($LibInfo{$Version}{$TypeMembInfoId}{"info"} =~ /chan[ ]*:[ ]*@([0-9]+) /)
1991 {
1992 return $1;
1993 }
1994 else
1995 {
1996 return "";
1997 }
1998}
1999
2000sub getNextStructMembInfoId($)
2001{
2002 my $TypeMembInfoId = $_[0];
2003 if($LibInfo{$Version}{$TypeMembInfoId}{"info"} =~ /chan[ ]*:[ ]*@([0-9]+) /)
2004 {
2005 return $1;
2006 }
2007 else
2008 {
2009 return "";
2010 }
2011}
2012
2013sub fieldHasName($)
2014{
2015 my $TypeMembInfoId = $_[0];
2016 if($LibInfo{$Version}{$TypeMembInfoId}{"info_type"} eq "field_decl")
2017 {
2018 if($LibInfo{$Version}{$TypeMembInfoId}{"info"} =~ /name[ ]*:[ ]*@([0-9]+) /)
2019 {
2020 return $1;
2021 }
2022 else
2023 {
2024 return "";
2025 }
2026 }
2027 else
2028 {
2029 return 0;
2030 }
2031}
2032
2033sub getTypeHeader($)
2034{
2035 my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
2036 if($TypeInfo =~ /srcp[ ]*:[ ]*([0-9a-zA-Z\_\-\<\>\.\+]+):([0-9]+) /)
2037 {
2038 return ($1, $2);
2039 }
2040 else
2041 {
2042 return ();
2043 }
2044}
2045
2046sub register_header($$$)
2047{
2048 my ($Destination, $Position, $LibVersion) = @_;
2049 return if(not $Destination);
2050 if($Destination=~/\A\// and not -f $Destination)
2051 {
2052 print "\nERROR: specified header \'$Destination\' does not exist\n";
2053 return;
2054 }
2055 my $Header_Name = get_FileName($Destination);
2056 $Headers{$LibVersion}{$Destination}{"Name"} = $Header_Name;
2057 $Headers{$LibVersion}{$Destination}{"Position"} = $Position;
2058 $Headers{$LibVersion}{$Destination}{"Identity"} = $Destination;
2059 $HeaderName_Destinations{$LibVersion}{$Header_Name}{$Destination} = 1;
2060}
2061
2062sub headerSearch($)
2063{
2064 my $LibVersion = $_[0];
2065 foreach my $Dest (split("\n", $Descriptor{$LibVersion}{"Include_Paths"}))
2066 {
2067 $Dest =~ s/\A\s+|\s+\Z//g;
2068 next if(not $Dest);
2069 if(not -e $Dest)
2070 {
2071 print "ERROR: can't access \'$Dest\'\n";
2072 }
2073 $Header_Dependency{$LibVersion}{$Dest} = 1;
2074 }
2075 foreach my $Dest (split("\n", $Descriptor{$LibVersion}{"Headers"}))
2076 {#fill %Header_Dependency
2077 if(-d $Dest)
2078 {
2079 foreach my $Dir (cmd_find($Dest,"d",""))
2080 {
2081 chomp($Dir);
2082 $Header_Dependency{$LibVersion}{$Dir} = 1;
2083 }
2084 }
2085 elsif(-f $Dest)
2086 {
2087 $Header_Dependency{$LibVersion}{get_Dir($Dest)} = 1;
2088 }
2089 }
2090 my $Position = 0;
2091 foreach my $Dest (split("\n", $Descriptor{$LibVersion}{"Headers"}))
2092 {
2093 $Dest =~ s/\A\s+|\s+\Z//g;
2094 next if(not $Dest);
2095 if(is_header($Dest, $LibVersion))
2096 {
2097 register_header($Dest, $Position, $LibVersion);
2098 $Position += 1;
2099 }
2100 elsif(-d $Dest)
2101 {
2102 foreach my $Destination (sort {lc($a) cmp lc($b)} (cmd_find($Dest,"f","")))
2103 {
2104 chomp($Destination);
2105 next if(not is_header($Destination, $LibVersion));
2106 register_header($Destination, $Position, $LibVersion);
2107 $Position += 1;
2108 }
2109 }
2110 else
2111 {
2112 print "WARNING: \'$Dest\' was not found in the specified include paths\n";
2113 register_header($Dest, $Position, $LibVersion);
2114 $Position += 1;
2115 }
2116 }
2117 if(keys(%{$Headers{$LibVersion}})==1)
2118 {
2119 my $Destination = (keys(%{$Headers{$LibVersion}}))[0];
2120 $Headers{$LibVersion}{$Destination}{"Identity"} = $Headers{$LibVersion}{$Destination}{"Name"};
2121 }
2122 foreach my $Header_Name (keys(%{$HeaderName_Destinations{$LibVersion}}))
2123 {#set relative paths (for dublicates)
2124 if(keys(%{$HeaderName_Destinations{$LibVersion}{$Header_Name}})>1)
2125 {
2126 my $FirstDest = (keys(%{$HeaderName_Destinations{$LibVersion}{$Header_Name}}))[0];
2127 my $Prefix = get_Dir($FirstDest);
2128 while($Prefix =~ /\A(.+)\/[^\/]+\Z/)
2129 {
2130 my $NewPrefix = $1;
2131 my $Changes_Number = 0;
2132 my %Identity = ();
2133 foreach my $Dest (keys(%{$HeaderName_Destinations{$LibVersion}{$Header_Name}}))
2134 {
2135 if($Dest =~ /\A$Prefix\/(.*)\Z/)
2136 {
2137 $Identity{$Dest} = $1;
2138 $Changes_Number+=1;
2139 }
2140 }
2141 if($Changes_Number eq keys(%{$HeaderName_Destinations{$LibVersion}{$Header_Name}}))
2142 {
2143 foreach my $Dest (keys(%{$HeaderName_Destinations{$LibVersion}{$Header_Name}}))
2144 {
2145 $Headers{$LibVersion}{$Dest}{"Identity"} = $Identity{$Dest};
2146 }
2147 last;
2148 }
2149 $Prefix = $NewPrefix;
2150 }
2151 }
2152 }
2153 if(not keys(%{$Headers{$LibVersion}}))
2154 {
2155 print "ERROR: header files were not found\n";
2156 exit(1);
2157 }
2158}
2159
2160sub get_FileName($)
2161{
2162 my $Path = $_[0];
2163 if($Path =~ /\A(.*\/)([^\/]*)\Z/)
2164 {
2165 return $2;
2166 }
2167 else
2168 {
2169 return $Path;
2170 }
2171}
2172
2173sub get_Dir($)
2174{
2175 my $Path = $_[0];
2176 return "" if($Path =~ m*\A\./*);
2177 if($Path =~ /\A(.*)\/([^\/]*)\Z/)
2178 {
2179 return $1;
2180 }
2181 else
2182 {
2183 return "";
2184 }
2185}
2186
2187sub esc($)
2188{
2189 my $Str = $_[0];
2190 $Str =~ s/([()\[\]{}$ &'"`;,<>])/\\$1/g;
2191 return $Str;
2192}
2193
2194sub getLocation($)
2195{
2196 my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
2197 if($TypeInfo =~ /srcp[ ]*:[ ]*([0-9a-zA-Z\_\-\<\>\.\+]+):([0-9]+) /)
2198 {
2199 return ($1, $2);
2200 }
2201 else
2202 {
2203 return ();
2204 }
2205}
2206
2207sub getHeader($)
2208{
2209 my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
2210 if($TypeInfo =~ /srcp[ ]*:[ ]*([0-9a-zA-Z\_\-\<\>\.\+]+):([0-9]+) /)
2211 {
2212 return $1;
2213 }
2214 else
2215 {
2216 return "";
2217 }
2218}
2219
2220sub getLine($)
2221{
2222 my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
2223 if($TypeInfo =~ /srcp[ ]*:[ ]*([0-9a-zA-Z\_\-\<\>\.\+]+):([0-9]+) /)
2224 {
2225 return $2;
2226 }
2227 else
2228 {
2229 return "";
2230 }
2231}
2232
2233sub getTypeType($$)
2234{
2235 my ($TypeDeclId, $TypeId) = @_;
2236 return "Const" if($LibInfo{$Version}{$TypeId}{"info"} =~ /qual[ ]*:[ ]*c / and $LibInfo{$Version}{$TypeId}{"info"} =~ /unql[ ]*:[ ]*\@/);
2237 return "Typedef" if($LibInfo{$Version}{$TypeId}{"info"} =~ /unql[ ]*:/ and $LibInfo{$Version}{$TypeId}{"info"} !~ /qual[ ]*:/);
2238 return "Volatile" if($LibInfo{$Version}{$TypeId}{"info"} =~ /qual[ ]*:[ ]*v / and $LibInfo{$Version}{$TypeId}{"info"} =~ /unql[ ]*:[ ]*\@/);
2239 return "Restrict" if($LibInfo{$Version}{$TypeId}{"info"} =~ /qual[ ]*:[ ]*r / and $LibInfo{$Version}{$TypeId}{"info"} =~ /unql[ ]*:[ ]*\@/);
2240 my $TypeType = getTypeTypeByTypeId($TypeId);
2241 if($TypeType eq "Struct")
2242 {
2243 if($TypeDeclId and $LibInfo{$Version}{$TypeDeclId}{"info_type"} eq "template_decl")
2244 {
2245 return "Template";
2246 }
2247 else
2248 {
2249 return "Struct";
2250 }
2251 }
2252 else
2253 {
2254 return $TypeType;
2255 }
2256
2257}
2258
2259sub getTypeTypeByTypeId($)
2260{
2261 my $TypeId = $_[0];
2262 my $TypeType = $LibInfo{$Version}{$TypeId}{"info_type"};
2263 if($TypeType =~ /integer_type|real_type|boolean_type|void_type|complex_type/)
2264 {
2265 return "Intrinsic";
2266 }
2267 elsif(isFuncPtr($TypeId))
2268 {
2269 return "FuncPtr";
2270 }
2271 elsif($TypeType eq "pointer_type")
2272 {
2273 return "Pointer";
2274 }
2275 elsif($TypeType eq "reference_type")
2276 {
2277 return "Ref";
2278 }
2279 elsif($TypeType eq "union_type")
2280 {
2281 return "Union";
2282 }
2283 elsif($TypeType eq "enumeral_type")
2284 {
2285 return "Enum";
2286 }
2287 elsif($TypeType eq "record_type")
2288 {
2289 return "Struct";
2290 }
2291 elsif($TypeType eq "array_type")
2292 {
2293 return "Array";
2294 }
2295 elsif($TypeType eq "complex_type")
2296 {
2297 return "Intrinsic";
2298 }
2299 elsif($TypeType eq "function_type")
2300 {
2301 return "FunctionType";
2302 }
2303 elsif($TypeType eq "method_type")
2304 {
2305 return "MethodType";
2306 }
2307 else
2308 {
2309 return "Unknown";
2310 }
2311}
2312
2313sub getNameByInfo($)
2314{
2315 my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
2316 return "" if($TypeInfo !~ /name[ ]*:[ ]*@([0-9]+) /);
2317 my $TypeNameInfoId = $1;
2318 return "" if($LibInfo{$Version}{$TypeNameInfoId}{"info"} !~ /strg[ ]*:[ ]*(.*)[ ]+lngt/);
2319 my $TypeName = $1;
2320 $TypeName =~ s/[ ]+\Z//g;
2321 return $TypeName;
2322}
2323
2324sub getFuncShortName($)
2325{
2326 my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
2327 if($FuncInfo =~ / operator /)
2328 {
2329 if($FuncInfo =~ /note[ ]*:[ ]*conversion /)
2330 {
2331 return "operator ".get_TypeName($FuncDescr{$Version}{$_[0]}{"Return"});
2332 }
2333 else
2334 {
2335 return "" if($FuncInfo !~ / operator[ ]+([a-zA-Z]+) /);
2336 return "operator".$Operator_Indication{$1};
2337 }
2338 }
2339 else
2340 {
2341 return "" if($FuncInfo !~ /name[ ]*:[ ]*@([0-9]+) /);
2342 my $FuncNameInfoId = $1;
2343 return "" if($LibInfo{$Version}{$FuncNameInfoId}{"info"} !~ /strg[ ]*:[ ]*([^ ]*)[ ]+lngt/);
2344 return $1;
2345 }
2346}
2347
2348sub getFuncMnglName($)
2349{
2350 my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
2351 return "" if($FuncInfo !~ /mngl[ ]*:[ ]*@([0-9]+) /);
2352 my $FuncMnglNameInfoId = $1;
2353 return "" if($LibInfo{$Version}{$FuncMnglNameInfoId}{"info"} !~ /strg[ ]*:[ ]*([^ ]*)[ ]+/);
2354 my $FuncMnglName = $1;
2355 $FuncMnglName =~ s/[ ]+\Z//g;
2356 return $FuncMnglName;
2357}
2358
2359sub getFuncReturn($)
2360{
2361 my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
2362 return "" if($FuncInfo !~ /type[ ]*:[ ]*@([0-9]+) /);
2363 my $FuncTypeInfoId = $1;
2364 return "" if($LibInfo{$Version}{$FuncTypeInfoId}{"info"} !~ /retn[ ]*:[ ]*@([0-9]+) /);
2365 my $FuncReturnTypeId = $1;
2366 if($TypeDescr{$Version}{getTypeDeclId($FuncReturnTypeId)}{$FuncReturnTypeId}{"Type"} eq "Restrict")
2367 {#delete restrict spec
2368 $FuncReturnTypeId = getRestrictBase($FuncReturnTypeId);
2369 }
2370 return $FuncReturnTypeId;
2371}
2372
2373sub getFuncOrig($)
2374{
2375 my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
2376 if($FuncInfo =~ /orig[ ]*:[ ]*@([0-9]+) /)
2377 {
2378 return $1;
2379 }
2380 else
2381 {
2382 return $_[0];
2383 }
2384}
2385
2386sub unmangleArray(@)
2387{
2388 if($#_>$MAX_COMMAND_LINE_ARGUMENTS)
2389 {
2390 my @Half = splice(@_, 0, ($#_+1)/2);
2391 return (unmangleArray(@Half), unmangleArray(@_))
2392 }
2393 else
2394 {
2395 my $UnmangleCommand = "c++filt ".join(" ", @_);
2396 return split("\n", `$UnmangleCommand`);
2397 }
2398}
2399
2400sub get_Signature($$)
2401{
2402 my ($Interface, $LibVersion) = @_;
2403 return $Cache{"get_Signature"}{$Interface}{$LibVersion} if($Cache{"get_Signature"}{$Interface}{$LibVersion});
2404 my ($MnglName, $SymbolVersion) = ($Interface, "");
2405 if($Interface =~ /\A([^@]+)[\@]+([^@]+)\Z/)
2406 {
2407 ($MnglName, $SymbolVersion) = ($1, $2);
2408 }
2409 if($MnglName =~ /\A(_ZGV|_ZTI|_ZTS|_ZTT|_ZTV|_ZThn|_ZTv0_n)/)
2410 {
2411 $Cache{"get_Signature"}{$Interface}{$LibVersion} = $tr_name{$MnglName}.(($SymbolVersion)?"\@".$SymbolVersion:"");
2412 return $Cache{"get_Signature"}{$Interface}{$LibVersion};
2413 }
2414 if(not $CompleteSignature{$LibVersion}{$Interface})
2415 {
2416 if($Interface =~ /\A_Z/)
2417 {
2418 $Cache{"get_Signature"}{$Interface}{$LibVersion} = $tr_name{$MnglName}.(($SymbolVersion)?"\@".$SymbolVersion:"");
2419 return $Cache{"get_Signature"}{$Interface}{$LibVersion};
2420 }
2421 else
2422 {
2423 $Cache{"get_Signature"}{$Interface}{$LibVersion} = $Interface;
2424 return $Interface;
2425 }
2426 }
2427 my ($Func_Signature, @Param_Types_FromUnmangledName) = ();
2428 my $ShortName = $CompleteSignature{$LibVersion}{$Interface}{"ShortName"};
2429 if($Interface =~ /\A_Z/)
2430 {
2431 if($CompleteSignature{$LibVersion}{$Interface}{"Class"})
2432 {
2433 $Func_Signature = get_TypeName($CompleteSignature{$LibVersion}{$Interface}{"Class"}, $LibVersion)."::".(($CompleteSignature{$LibVersion}{$Interface}{"Destructor"})?"~":"").$ShortName;
2434 }
2435 else
2436 {
2437 $Func_Signature = $ShortName;
2438 }
2439 @Param_Types_FromUnmangledName = get_Signature_Parts($tr_name{$MnglName}, 0);
2440 }
2441 else
2442 {
2443 $Func_Signature = $MnglName;
2444 }
2445 my @ParamArray = ();
2446 foreach my $Pos (sort {int($a) <=> int($b)} keys(%{$CompleteSignature{$LibVersion}{$Interface}{"Param"}}))
2447 {
2448 next if($Pos eq "");
2449 my $ParamTypeId = $CompleteSignature{$LibVersion}{$Interface}{"Param"}{$Pos}{"type"};
2450 my $ParamTypeName = $TypeDescr{$LibVersion}{$Tid_TDid{$LibVersion}{$ParamTypeId}}{$ParamTypeId}{"Name"};
2451 $ParamTypeName = $Param_Types_FromUnmangledName[$Pos] if(not $ParamTypeName);
2452 if(my $ParamName = $CompleteSignature{$LibVersion}{$Interface}{"Param"}{$Pos}{"name"})
2453 {
2454 if($ParamTypeName=~/\([*]+\)/)
2455 {
2456 $ParamTypeName=~s/\(([*]+)\)/\($1$ParamName\)/;
2457 push(@ParamArray, $ParamTypeName);
2458 }
2459 else
2460 {
2461 push(@ParamArray, $ParamTypeName." ".$ParamName);
2462 }
2463 }
2464 else
2465 {
2466 push(@ParamArray, $ParamTypeName);
2467 }
2468 }
2469 if(not $CompleteSignature{$LibVersion}{$Interface}{"Data"})
2470 {
2471 if($Interface=~/\A_Z/)
2472 {
2473 if($CompleteSignature{$LibVersion}{$Interface}{"Constructor"})
2474 {
2475 if($Interface=~/C1/)
2476 {
2477 $Func_Signature .= " [in-charge]";
2478 }
2479 elsif($Interface=~/C2/)
2480 {
2481 $Func_Signature .= " [not-in-charge]";
2482 }
2483 }
2484 elsif($CompleteSignature{$LibVersion}{$Interface}{"Destructor"})
2485 {
2486 if($Interface=~/D1/)
2487 {
2488 $Func_Signature .= " [in-charge]";
2489 }
2490 elsif($Interface=~/D2/)
2491 {
2492 $Func_Signature .= " [not-in-charge]";
2493 }
2494 elsif($Interface=~/D0/)
2495 {
2496 $Func_Signature .= " [in-charge-deleting]";
2497 }
2498 }
2499 }
2500 $Func_Signature .= " (".join(", ", @ParamArray).")";
2501 }
2502 if($Interface=~/\A_ZNK/)
2503 {
2504 $Func_Signature .= " const";
2505 }
2506 $Func_Signature .= "\@".$SymbolVersion if($SymbolVersion);
2507 $Cache{"get_Signature"}{$Interface}{$LibVersion} = $Func_Signature;
2508 return $Func_Signature;
2509}
2510
2511sub getVarNameByAttr($)
2512{
2513 my $FuncInfoId = $_[0];
2514 my $VarName;
2515 return "" if(not $FuncDescr{$Version}{$FuncInfoId}{"ShortName"});
2516 if($FuncDescr{$Version}{$FuncInfoId}{"Class"})
2517 {
2518 $VarName .= $TypeDescr{$Version}{getTypeDeclId($FuncDescr{$Version}{$FuncInfoId}{"Class"})}{$FuncDescr{$Version}{$FuncInfoId}{"Class"}}{"Name"};
2519 $VarName .= "::";
2520 }
2521 $VarName .= $FuncDescr{$Version}{$FuncInfoId}{"ShortName"};
2522 return $VarName;
2523}
2524
2525sub mangleFuncName($)
2526{
2527 my $FuncId = $_[0];
2528}
2529
2530sub getFuncType($)
2531{
2532 my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
2533 return "" if($FuncInfo !~ /type[ ]*:[ ]*@([0-9]+) /);
2534 my $FuncTypeInfoId = $1;
2535 my $FunctionType = $LibInfo{$Version}{$FuncTypeInfoId}{"info_type"};
2536 if($FunctionType eq "method_type")
2537 {
2538 return "Method";
2539 }
2540 elsif($FunctionType eq "function_type")
2541 {
2542 return "Function";
2543 }
2544 else
2545 {
2546 return $FunctionType;
2547 }
2548}
2549
2550sub getFuncTypeId($)
2551{
2552 my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
2553 if($FuncInfo =~ /type[ ]*:[ ]*@([0-9]+)( |\Z)/)
2554 {
2555 return $1;
2556 }
2557 else
2558 {
2559 return 0;
2560 }
2561}
2562
2563sub isNotAnon($)
2564{
2565 return (not isAnon($_[0]));
2566}
2567
2568sub isAnon($)
2569{
2570 return (($_[0] =~ m/\.\_[0-9]+/) or ($_[0] =~ m/anon-/));
2571}
2572
2573sub unmangled_Compact($$)
2574#Removes all non-essential (for C++ language) whitespace from a string. If
2575#the whitespace is essential it will be replaced with exactly one ' '
2576#character. Works correctly only for unmangled names.
2577#If level > 1 is supplied, can relax its intent to compact the string.
2578{
2579 my $result=$_[0];
2580 my $level = $_[1] || 1;
2581 my $o1 = ($level>1)?' ':'';
2582 #First, we reduce all spaces that we can
2583 my $coms='[-()<>:*&~!|+=%@~"?.,/[^'."']";
2584 my $coms_nobr='[-()<:*&~!|+=%@~"?.,'."']";
2585 my $clos='[),;:\]]';
2586 $result=~s/^\s+//gm;
2587 $result=~s/\s+$//gm;
2588 $result=~s/((?!\n)\s)+/ /g;
2589 $result=~s/(\w+)\s+($coms+)/$1$o1$2/gm;
2590 #$result=~s/(\w)(\()/$1$o1$2/gm if $o1;
2591 $result=~s/($coms+)\s+(\w+)/$1$o1$2/gm;
2592 $result=~s/(\()\s+(\w)/$1$2/gm if $o1;
2593 $result=~s/(\w)\s+($clos)/$1$2/gm;
2594 $result=~s/($coms+)\s+($coms+)/$1 $2/gm;
2595 $result=~s/($coms_nobr+)\s+($coms+)/$1$o1$2/gm;
2596 $result=~s/($coms+)\s+($coms_nobr+)/$1$o1$2/gm;
2597 #don't forget about >> and <:. In unmangled names global-scope modifier
2598 #is not used, so <: will always be a digraph and requires no special treatment.
2599 #We also try to remove other parts that are better to be removed here than in other places
2600 #double-cv
2601 $result=~s/\bconst\s+const\b/const/gm;
2602 $result=~s/\bvolatile\s+volatile\b/volatile/gm;
2603 $result=~s/\bconst\s+volatile\b\s+const\b/const volatile/gm;
2604 $result=~s/\bvolatile\s+const\b\s+volatile\b/const volatile/gm;
2605 #Place cv in proper order
2606 $result=~s/\bvolatile\s+const\b/const volatile/gm;
2607 return $result;
2608}
2609
2610sub unmangled_PostProcess($)
2611{
2612 my $result = $_[0];
2613 #s/\bunsigned int\b/unsigned/g;
2614 $result =~ s/\bshort unsigned int\b/unsigned short/g;
2615 $result =~ s/\bshort int\b/short/g;
2616 $result =~ s/\blong long unsigned int\b/unsigned long long/g;
2617 $result =~ s/\blong unsigned int\b/unsigned long/g;
2618 $result =~ s/\blong long int\b/long long/g;
2619 $result =~ s/\blong int\b/long/g;
2620 $result =~ s/\)const\b/\) const/g;
2621 $result =~ s/\blong long unsigned\b/unsigned long long/g;
2622 $result =~ s/\blong unsigned\b/unsigned long/g;
2623 return $result;
2624}
2625
2626# From libtodb2/libtodb.pm
2627# Trim string spaces.
2628sub trim($)
2629{
2630 my $string = shift;
2631 $string =~ s/^\s+//;
2632 $string =~ s/\s+$//;
2633 return $string;
2634}
2635
2636sub correctName($)
2637{#type name correction
2638 my $CorrectName = $_[0];
2639 $CorrectName = unmangled_Compact($CorrectName, 1);
2640 $CorrectName = unmangled_PostProcess($CorrectName);
2641 return $CorrectName;
2642}
2643
2644sub getDump_AllInOne()
2645{
2646 return if(not keys(%Headers));
2647 `mkdir -p temp && rm -f temp/*`;
2648 my $Header_Depend = "";
2649 foreach my $Dep (sort {length($a) <=> length($b)} keys(%{$Header_Dependency{$Version}}))
2650 {
2651 $Header_Depend .= " -I".esc($Dep);
2652 }
2653 my $Lib_VersionName = esc($TargetLibraryName)."_v".$Version;
2654 open(LIB_HEADER, ">temp/$TargetLibraryName"."_v$Version.h");
2655 foreach my $Preamble_Header (sort {int($Include_Preamble{$Version}{$a}{"Position"})<=>int($Include_Preamble{$Version}{$b}{"Position"})} keys(%{$Include_Preamble{$Version}}))
2656 {
2657 print LIB_HEADER "#include <$Preamble_Header>\n";
2658 }
2659 foreach my $Destination (sort {int($Headers{$Version}{$a}{"Position"})<=>int($Headers{$Version}{$b}{"Position"})} keys(%{$Headers{$Version}}))
2660 {
2661 my $HName = get_FileName($Destination);
2662 next if($Include_Preamble{$Version}{$Destination} or ($Include_Preamble{$Version}{$HName} and $HeaderName_Destinations{$Version}{$HName} and keys(%{$HeaderName_Destinations{$Version}{$HName}})==1));
2663 print LIB_HEADER "#include <$Destination>\n";
2664 }
2665 close(LIB_HEADER);
2666 system("g++ >".esc($ERR_PATH{$Version})." 2>&1 -fdump-translation-unit temp/$Lib_VersionName.h $CompilerOptions{$Version} $Header_Depend");
2667 if($?)
2668 {
2669 print "WARNING: some errors have occured while compiling header(s), fix it first!\nyou can see compilation errors in the file \'$ERR_PATH{$Version}\'\n";
2670 }
2671 $ConstantsSrc{$Version} = cmd_preprocessor("temp/$Lib_VersionName.h", $CompilerOptions{$Version}." ".$Header_Depend, "define\\ \\|undef\\ \\|#[ ]\\+[0-9]\\+ \".*\"");
2672 system("mkdir", "-p", "header_compile_errors/$TargetLibraryName/temp/");
2673 system("cp", "-f", "temp/$TargetLibraryName"."_v$Version.h", "header_compile_errors/$TargetLibraryName/temp/");
2674 return (split("\n", `find . -maxdepth 1 -name "$Lib_VersionName\.h*\.tu"`))[0];
2675}
2676
2677sub getDump_Separately($)
2678{
2679 `mkdir -p temp`;
2680 `rm -f temp/*`;
2681 my $Destination = $_[0];
2682 my $Header_Depend = "";
2683 foreach my $Dep (sort {length($a) <=> length($b)} keys(%{$Header_Dependency{$Version}}))
2684 {
2685 $Header_Depend .= " -I".esc($Dep);
2686 }
2687 my $Lib_VersionName = esc($TargetLibraryName)."_v".$Version;
2688 open(LIB_HEADER, ">temp/$TargetLibraryName"."_v$Version.h");
2689 foreach my $Preamble_Header (sort {int($Include_Preamble{$Version}{$a}{"Position"})<=>int($Include_Preamble{$Version}{$b}{"Position"})} keys(%{$Include_Preamble{$Version}}))
2690 {
2691 print LIB_HEADER "#include <$Preamble_Header>\n";
2692 }
2693 my $Destination_HName = get_FileName($Destination);
2694 if(not ( $Include_Preamble{$Version}{$Destination} or ($Include_Preamble{$Version}{$Destination_HName} and $HeaderName_Destinations{$Version}{$Destination_HName} and keys(%{$HeaderName_Destinations{$Version}{$Destination_HName}})==1) ))
2695 {
2696 print LIB_HEADER "#include <$Destination>\n";
2697 }
2698 close(LIB_HEADER);
2699 system("g++ >>".esc($ERR_PATH{$Version})." 2>&1 -fdump-translation-unit temp/$Lib_VersionName.h $CompilerOptions{$Version} $Header_Depend");
2700 if($?)
2701 {
2702 $HeaderCompileError{get_FileName($Destination)} = 1;
2703 }
2704 $ConstantsSrc{$Version} .= cmd_preprocessor("temp/$Lib_VersionName.h", $CompilerOptions{$Version}." ".$Header_Depend, "define\\ \\|undef\\ \\|#[ ]\\+[0-9]\\+ \".*\"");
2705 return (split("\n", `find . -maxdepth 1 -name "$Lib_VersionName\.h*\.tu"`))[0];
2706}
2707
2708sub cmd_file($)
2709{
2710 my $Path = $_[0];
2711 return "" if(not $Path or not -e $Path);
2712 my $Cmd = "file ".esc($Path);
2713 my $Cmd_Out = `$Cmd`;
2714 return $Cmd_Out;
2715}
2716
2717sub cmd_preprocessor($$$)
2718{
2719 my ($Path, $AddOpt, $Grep) = @_;
2720 return "" if(not $Path or not -f $Path);
2721 my $Cmd = "g++ -dD -E -x c++-header ".esc($Path)." 2>/dev/null $AddOpt";
2722 if($Grep)
2723 {
2724 $Cmd .= " | grep \"$Grep\"";
2725 }
2726 my $Cmd_Out = `$Cmd`;
2727 return $Cmd_Out;
2728}
2729
2730sub cmd_cat($$)
2731{
2732 my ($Path, $Grep) = @_;
2733 return "" if(not $Path or not -e $Path);
2734 my $Cmd = "cat ".esc($Path);
2735 if($Grep)
2736 {
2737 $Cmd .= " | grep \"$Grep\"";
2738 }
2739 my $Cmd_Out = `$Cmd`;
2740 return $Cmd_Out;
2741}
2742
2743sub cmd_find($$$)
2744{
2745 my ($Path, $Type, $Name) = @_;
2746 return () if(not $Path or not -e $Path);
2747 my $Cmd = "find ".esc($Path);
2748 if($Type)
2749 {
2750 $Cmd .= " -type $Type";
2751 }
2752 if($Name)
2753 {
2754 $Cmd .= " -name \"$Name\"";
2755 }
2756 return split("\n", `$Cmd`);
2757}
2758
2759sub cmd_tar($)
2760{
2761 my $Path = $_[0];
2762 return "" if(not $Path or not -e $Path);
2763 my $Cmd = "tar -xvzf ".esc($Path);
2764 my $Cmd_Out = `$Cmd`;
2765 return $Cmd_Out;
2766}
2767
2768sub is_header($$)
2769{
2770 my ($Destination, $LibVersion) = @_;
2771 return 0 if(-d $Destination);
2772 return 1 if($Destination =~ /\.(h|hh|hhh|hpp|tcc)\Z/i);
2773 return 0 if($Destination =~ /\.\w+\Z/i);#cpp|c|gch|tu|fs|pas
2774 if($Destination =~ /\A\//)
2775 {
2776 return (cmd_file($Destination) =~ /:[ ]*ASCII C[\+]* program text/);
2777 }
2778 else
2779 {
2780 foreach my $Prefix (keys(%{$Header_Dependency{$LibVersion}}))
2781 {
2782 my $Path = $Prefix."/".$Destination;
2783 if(-f $Path)
2784 {
2785 if(cmd_file($Path) =~ /:[ ]*ASCII C[\+]* program text/)
2786 {
2787 return 1;
2788 }
2789 }
2790 }
2791 return 0;
2792 }
2793}
2794
2795sub parseHeaders_AllInOne($)
2796{
2797 $Version = $_[0];
2798 print "checking header(s) ".$Descriptor{$Version}{"Version"}." ...\n";
2799 system("mkdir", "-p", "header_compile_errors/".$TargetLibraryName);
2800 system("rm", "-fr", $ERR_PATH{$Version});
2801 my $DumpPath = getDump_AllInOne();
2802 if(not $DumpPath)
2803 {
2804 print "\nERROR: can't create gcc syntax tree for header(s)\nyou can see compilation errors in the file '$ERR_PATH{$Version}'\n";
2805 exit(1);
2806 }
2807 getInfo($DumpPath);
2808 parse_constants();
2809 system("rm", "-fr", "temp");
2810}
2811
2812sub parseHeader($)
2813{
2814 my $Destination = $_[0];
2815 my $DumpPath = getDump_Separately($Destination);
2816 if(not $DumpPath)
2817 {
2818 print "ERROR: can't create gcc syntax tree for header\nyou can see compilation errors in the file '$ERR_PATH{$Version}'\n";
2819 exit(1);
2820 }
2821 getInfo($DumpPath);
2822 parse_constants();
2823 system("rm", "-fr", "temp");
2824}
2825
2826sub is_in_library($$)
2827{
2828 my ($MnglName, $LibVersion) = @_;
2829 return ($Interface_Library{$LibVersion}{$MnglName} or ($SymVer{$LibVersion}{$MnglName} and $Interface_Library{$LibVersion}{$SymVer{$LibVersion}{$MnglName}}));
2830}
2831
2832sub prepareInterfaces($)
2833{
2834 my $LibVersion = $_[0];
2835 my (@MnglNames, @UnMnglNames) = ();
2836 if($CheckHeadersOnly)
2837 {
2838 foreach my $FuncInfoId (sort keys(%{$FuncDescr{$LibVersion}}))
2839 {
2840 if($FuncDescr{$LibVersion}{$FuncInfoId}{"MnglName"} =~ /\A_Z/)
2841 {
2842 push(@MnglNames, $FuncDescr{$LibVersion}{$FuncInfoId}{"MnglName"});
2843 }
2844 }
2845 if($#MnglNames > -1)
2846 {
2847 @UnMnglNames = reverse(unmangleArray(@MnglNames));
2848 foreach my $FuncInfoId (sort keys(%{$FuncDescr{$LibVersion}}))
2849 {
2850 if($FuncDescr{$LibVersion}{$FuncInfoId}{"MnglName"} =~ /\A_Z/)
2851 {
2852 my $UnmangledName = pop(@UnMnglNames);
2853 $tr_name{$FuncDescr{$LibVersion}{$FuncInfoId}{"MnglName"}} = $UnmangledName;
2854 }
2855 }
2856 }
2857 }
2858 my (%NotMangled_Int, %Mangled_Int) = ();
2859 foreach my $FuncInfoId (keys(%{$FuncDescr{$LibVersion}}))
2860 {
2861 my $MnglName = $FuncDescr{$LibVersion}{$FuncInfoId}{"MnglName"};
2862 if($MnglName=~/\A_Z/)
2863 {
2864 $Mangled_Int{$FuncInfoId} = $MnglName;
2865 }
2866 else
2867 {
2868 $NotMangled_Int{$FuncInfoId} = $MnglName;
2869 }
2870 next if(not $MnglName or not is_in_library($MnglName, $LibVersion) and not $CheckHeadersOnly);
2871 next if($MnglName =~ /\A_Z/ and $tr_name{$MnglName} =~ /\.\_[0-9]/);
2872 next if(not $FuncDescr{$LibVersion}{$FuncInfoId}{"Header"});
2873 %{$CompleteSignature{$LibVersion}{$MnglName}} = %{$FuncDescr{$LibVersion}{$FuncInfoId}};
2874 #interface and its symlink have same signatures
2875 if($SymVer{$LibVersion}{$MnglName})
2876 {
2877 %{$CompleteSignature{$LibVersion}{$SymVer{$LibVersion}{$MnglName}}} = %{$FuncDescr{$LibVersion}{$FuncInfoId}};
2878 }
2879 delete($FuncDescr{$LibVersion}{$FuncInfoId});
2880 }
2881 if(keys(%Mangled_Int))
2882 {
2883 foreach my $Interface_Id (keys(%NotMangled_Int))
2884 {
2885 delete($CompleteSignature{$LibVersion}{$NotMangled_Int{$Interface_Id}});
2886 }
2887 }
2888}
2889
2890my %UsedType;
2891sub cleanData($)
2892{
2893 my $LibVersion = $_[0];
2894 foreach my $FuncInfoId (keys(%{$FuncDescr{$LibVersion}}))
2895 {
2896 my $MnglName = $FuncDescr{$LibVersion}{$FuncInfoId}{"MnglName"};
2897 if(not $MnglName or not is_in_library($MnglName, $LibVersion) and not $CheckHeadersOnly)
2898 {
2899 delete($FuncDescr{$LibVersion}{$FuncInfoId});
2900 next;
2901 }
2902 if(defined $InterfacesListPath and not $InterfacesList{$MnglName})
2903 {
2904 delete($FuncDescr{$LibVersion}{$FuncInfoId});
2905 next;
2906 }
2907 if(defined $AppPath and not $InterfacesList_App{$MnglName})
2908 {
2909 delete($FuncDescr{$LibVersion}{$FuncInfoId});
2910 next;
2911 }
2912 my %FuncInfo = %{$FuncDescr{$LibVersion}{$FuncInfoId}};
2913 detect_TypeUsing($Tid_TDid{$LibVersion}{$FuncInfo{"Return"}}, $FuncInfo{"Return"}, $LibVersion);
2914 detect_TypeUsing($Tid_TDid{$LibVersion}{$FuncInfo{"Class"}}, $FuncInfo{"Class"}, $LibVersion);
2915 foreach my $Param_Pos (keys(%{$FuncInfo{"Param"}}))
2916 {
2917 my $Param_TypeId = $FuncInfo{"Param"}{$Param_Pos}{"type"};
2918 detect_TypeUsing($Tid_TDid{$LibVersion}{$Param_TypeId}, $Param_TypeId, $LibVersion);
2919 }
2920 }
2921 foreach my $TDid (keys(%{$TypeDescr{$LibVersion}}))
2922 {
2923 foreach my $Tid (keys(%{$TypeDescr{$LibVersion}{$TDid}}))
2924 {
2925 if(not $UsedType{$LibVersion}{$TDid}{$Tid})
2926 {
2927 delete($TypeDescr{$LibVersion}{$TDid}{$Tid});
2928 if(not keys(%{$TypeDescr{$LibVersion}{$TDid}}))
2929 {
2930 delete($TypeDescr{$LibVersion}{$TDid});
2931 }
2932 delete($Tid_TDid{$LibVersion}{$Tid}) if($Tid_TDid{$LibVersion}{$Tid} eq $TDid);
2933 }
2934 }
2935 }
2936}
2937
2938sub detect_TypeUsing($$$)
2939{
2940 my ($TypeDeclId, $TypeId, $LibVersion) = @_;
2941 return if($UsedType{$LibVersion}{$TypeDeclId}{$TypeId});
2942 my %Type = get_Type($TypeDeclId, $TypeId, $LibVersion);
2943 if($Type{"Type"} =~ /Struct|Union|Class|FuncPtr|Enum/)
2944 {
2945 $UsedType{$LibVersion}{$TypeDeclId}{$TypeId} = 1;
2946 foreach my $Memb_Pos (keys(%{$Type{"Memb"}}))
2947 {
2948 my $Member_TypeId = $Type{"Memb"}{$Memb_Pos}{"type"};
2949 detect_TypeUsing($Tid_TDid{$LibVersion}{$Member_TypeId}, $Member_TypeId, $LibVersion);
2950 }
2951 if($Type{"Type"} eq "FuncPtr")
2952 {
2953 my $ReturnType = $Type{"Return"};
2954 detect_TypeUsing($Tid_TDid{$LibVersion}{$ReturnType}, $ReturnType, $LibVersion);
2955 }
2956 }
2957 elsif($Type{"Type"} =~ /Const|Pointer|Ref|Volatile|Restrict|Array|/)
2958 {
2959 $UsedType{$LibVersion}{$TypeDeclId}{$TypeId} = 1;
2960 detect_TypeUsing($Type{"BaseType"}{"TDid"}, $Type{"BaseType"}{"Tid"}, $LibVersion);
2961 }
2962 elsif($Type{"Type"} eq "Intrinsic")
2963 {
2964 $UsedType{$LibVersion}{$TypeDeclId}{$TypeId} = 1;
2965 }
2966 else
2967 {
2968 delete($TypeDescr{$LibVersion}{$TypeDeclId}{$TypeId});
2969 if(not keys(%{$TypeDescr{$LibVersion}{$TypeDeclId}}))
2970 {
2971 delete($TypeDescr{$LibVersion}{$TypeDeclId});
2972 }
2973 delete($Tid_TDid{$LibVersion}{$TypeId}) if($Tid_TDid{$LibVersion}{$TypeId} eq $TypeDeclId);
2974 }
2975}
2976
2977sub initializeClassVirtFunc($)
2978{
2979 my $LibVersion = $_[0];
2980 foreach my $Interface (keys(%{$CompleteSignature{$LibVersion}}))
2981 {
2982 if($CompleteSignature{$LibVersion}{$Interface}{"Virt"})
2983 {
2984 my $ClassName = $TypeDescr{$LibVersion}{$Tid_TDid{$LibVersion}{$CompleteSignature{$LibVersion}{$Interface}{"Class"}}}{$CompleteSignature{$LibVersion}{$Interface}{"Class"}}{"Name"};
2985 $ClassVirtFunc{$LibVersion}{$ClassName}{$Interface} = 1;
2986 $ClassIdVirtFunc{$LibVersion}{$CompleteSignature{$LibVersion}{$Interface}{"Class"}}{$Interface} = 1;
2987 $ClassId{$LibVersion}{$ClassName} = $CompleteSignature{$LibVersion}{$Interface}{"Class"};
2988 }
2989 }
2990}
2991
2992sub checkVirtFuncRedefinitions($)
2993{
2994 my $LibVersion = $_[0];
2995 foreach my $Class_Name (keys(%{$ClassVirtFunc{$LibVersion}}))
2996 {
2997 $CheckedTypes{$Class_Name} = 1;
2998 foreach my $VirtFuncName (keys(%{$ClassVirtFunc{$LibVersion}{$Class_Name}}))
2999 {
3000 $CompleteSignature{$LibVersion}{$VirtFuncName}{"VirtualRedefine"} = find_virtual_method_in_base_classes($VirtFuncName, $ClassId{$LibVersion}{$Class_Name}, $LibVersion);
3001 }
3002 }
3003}
3004
3005sub setVirtFuncPositions($)
3006{
3007 my $LibVersion = $_[0];
3008 foreach my $Class_Name (keys(%{$ClassVirtFunc{$LibVersion}}))
3009 {
3010 $CheckedTypes{$Class_Name} = 1;
3011 my $Position = 0;
3012 foreach my $VirtFuncName (sort {int($CompleteSignature{$LibVersion}{$a}{"Line"}) <=> int($CompleteSignature{$LibVersion}{$b}{"Line"})} keys(%{$ClassVirtFunc{$LibVersion}{$Class_Name}}))
3013 {
3014 if($ClassVirtFunc{1}{$Class_Name}{$VirtFuncName} and $ClassVirtFunc{2}{$Class_Name}{$VirtFuncName} and not $CompleteSignature{1}{$VirtFuncName}{"VirtualRedefine"} and not $CompleteSignature{2}{$VirtFuncName}{"VirtualRedefine"})
3015 {
3016 $CompleteSignature{$LibVersion}{$VirtFuncName}{"Position"} = $Position;
3017 $Position += 1;
3018 }
3019 }
3020 }
3021}
3022
3023sub check_VirtualTable($$)
3024{
3025 my ($TargetFunction, $LibVersion) = @_;
3026 my $Class_Id = $CompleteSignature{$LibVersion}{$TargetFunction}{"Class"};
3027 my $Class_DId = $Tid_TDid{$LibVersion}{$Class_Id};
3028 my %Class_Type = get_Type($Class_DId, $Class_Id, $LibVersion);
3029 $CheckedTypes{$Class_Type{"Name"}} = 1;
3030 foreach my $VirtFuncName (keys(%{$ClassVirtFunc{2}{$Class_Type{"Name"}}}))
3031 {#Added
3032 if($ClassId{1}{$Class_Type{"Name"}} and not $ClassVirtFunc{1}{$Class_Type{"Name"}}{$VirtFuncName} and $AddedInt{$VirtFuncName})
3033 {
3034 if($CompleteSignature{2}{$VirtFuncName}{"VirtualRedefine"})
3035 {
3036 if($TargetFunction eq $VirtFuncName)
3037 {
3038 my $BaseClass_Id = $CompleteSignature{2}{$CompleteSignature{2}{$VirtFuncName}{"VirtualRedefine"}}{"Class"};
3039 my %BaseClass_Type = get_Type($Tid_TDid{2}{$BaseClass_Id}, $BaseClass_Id, 2);
3040 my $BaseClass_Name = $BaseClass_Type{"Name"};
3041 %{$CompatProblems{$TargetFunction}{"Virtual_Function_Redefinition"}{$tr_name{$CompleteSignature{2}{$VirtFuncName}{"VirtualRedefine"}}}}=(
3042 "Type_Name"=>$Class_Type{"Name"},
3043 "Type_Type"=>$Class_Type{"Type"},
3044 "Header"=>$CompleteSignature{2}{$TargetFunction}{"Header"},
3045 "Line"=>$CompleteSignature{2}{$TargetFunction}{"Line"},
3046 "Target"=>$tr_name{$CompleteSignature{2}{$VirtFuncName}{"VirtualRedefine"}},
3047 "Signature"=>$tr_name{$TargetFunction},
3048 "Old_Value"=>$tr_name{$CompleteSignature{2}{$VirtFuncName}{"VirtualRedefine"}},
3049 "New_Value"=>$tr_name{$TargetFunction},
3050 "Old_SoName"=>$Interface_Library{1}{$TargetFunction},
3051 "New_SoName"=>$Interface_Library{2}{$TargetFunction} );
3052 }
3053 }
3054 elsif($TargetFunction ne $VirtFuncName)
3055 {
3056 %{$CompatProblems{$TargetFunction}{"Added_Virtual_Function"}{$tr_name{$VirtFuncName}}}=(
3057 "Type_Name"=>$Class_Type{"Name"},
3058 "Type_Type"=>$Class_Type{"Type"},
3059 "Header"=>$Class_Type{"Header"},
3060 "Line"=>$Class_Type{"Line"},
3061 "Target"=>$tr_name{$VirtFuncName},
3062 "Signature"=>$tr_name{$TargetFunction},
3063 "Old_SoName"=>$Interface_Library{1}{$TargetFunction},
3064 "New_SoName"=>$Interface_Library{2}{$TargetFunction} );
3065 }
3066 }
3067 }
3068 foreach my $VirtFuncName (keys(%{$ClassVirtFunc{1}{$Class_Type{"Name"}}}))
3069 {#Withdrawn
3070 if($ClassId{2}{$Class_Type{"Name"}} and not $ClassVirtFunc{2}{$Class_Type{"Name"}}{$VirtFuncName} and $WithdrawnInt{$VirtFuncName})
3071 {
3072 if($CompleteSignature{1}{$VirtFuncName}{"VirtualRedefine"})
3073 {
3074 if($TargetFunction eq $VirtFuncName)
3075 {
3076 my $BaseClass_Id = $CompleteSignature{1}{$CompleteSignature{1}{$VirtFuncName}{"VirtualRedefine"}}{"Class"};
3077 my $BaseClass_Name = $TypeDescr{1}{$Tid_TDid{1}{$BaseClass_Id}}{$BaseClass_Id}{"Name"};
3078 %{$CompatProblems{$TargetFunction}{"Virtual_Function_Redefinition_B"}{$tr_name{$CompleteSignature{1}{$VirtFuncName}{"VirtualRedefine"}}}}=(
3079 "Type_Name"=>$Class_Type{"Name"},
3080 "Type_Type"=>$Class_Type{"Type"},
3081 "Header"=>$CompleteSignature{2}{$TargetFunction}{"Header"},
3082 "Line"=>$CompleteSignature{2}{$TargetFunction}{"Line"},
3083 "Target"=>$tr_name{$CompleteSignature{1}{$VirtFuncName}{"VirtualRedefine"}},
3084 "Signature"=>$tr_name{$TargetFunction},
3085 "Old_Value"=>$tr_name{$TargetFunction},
3086 "New_Value"=>$tr_name{$CompleteSignature{1}{$VirtFuncName}{"VirtualRedefine"}},
3087 "Old_SoName"=>$Interface_Library{1}{$TargetFunction},
3088 "New_SoName"=>$Interface_Library{2}{$TargetFunction} );
3089 }
3090 }
3091 else
3092 {
3093 %{$CompatProblems{$TargetFunction}{"Withdrawn_Virtual_Function"}{$tr_name{$VirtFuncName}}}=(
3094 "Type_Name"=>$Class_Type{"Name"},
3095 "Type_Type"=>$Class_Type{"Type"},
3096 "Header"=>$Class_Type{"Header"},
3097 "Line"=>$Class_Type{"Line"},
3098 "Target"=>$tr_name{$VirtFuncName},
3099 "Signature"=>$tr_name{$TargetFunction},
3100 "Old_SoName"=>$Interface_Library{1}{$TargetFunction},
3101 "New_SoName"=>$Interface_Library{2}{$TargetFunction} );
3102 }
3103 }
3104 }
3105}
3106
3107sub find_virtual_method_in_base_classes($$$)
3108{
3109 my ($VirtFuncName, $Checked_ClassId, $LibVersion) = @_;
3110 foreach my $BaseClass_Id (keys(%{$TypeDescr{$LibVersion}{$Tid_TDid{$LibVersion}{$Checked_ClassId}}{$Checked_ClassId}{"BaseClass"}}))
3111 {
3112 my $VirtMethodInClass = find_virtual_method_in_class($VirtFuncName, $BaseClass_Id, $LibVersion);
3113 if($VirtMethodInClass)
3114 {
3115 return $VirtMethodInClass;
3116 }
3117 my $VirtMethodInBaseClasses = find_virtual_method_in_base_classes($VirtFuncName, $BaseClass_Id, $LibVersion);
3118 if($VirtMethodInBaseClasses)
3119 {
3120 return $VirtMethodInBaseClasses;
3121 }
3122 }
3123 return "";
3124}
3125
3126sub find_virtual_method_in_class($$$)
3127{
3128 my ($VirtFuncName, $Checked_ClassId, $LibVersion) = @_;
3129 my $Suffix = getFuncSuffix($VirtFuncName, $LibVersion);
3130 foreach my $Checked_VirtFuncName (keys(%{$ClassIdVirtFunc{$LibVersion}{$Checked_ClassId}}))
3131 {
3132 if($Suffix eq getFuncSuffix($Checked_VirtFuncName, $LibVersion)
3133 and ((not $CompleteSignature{$LibVersion}{$VirtFuncName}{"Constructor"} and not $CompleteSignature{$LibVersion}{$VirtFuncName}{"Destructor"} and $CompleteSignature{$LibVersion}{$VirtFuncName}{"ShortName"} eq $CompleteSignature{$LibVersion}{$Checked_VirtFuncName}{"ShortName"}) or ($CompleteSignature{$LibVersion}{$VirtFuncName}{"Constructor"} or $CompleteSignature{$LibVersion}{$VirtFuncName}{"Destructor"})))
3134 {
3135 return $Checked_VirtFuncName;
3136 }
3137 }
3138 return "";
3139}
3140
3141sub getFuncSuffix($$)
3142{
3143 my ($FuncName, $LibVersion) = @_;
3144 my $ClassId = $CompleteSignature{$LibVersion}{$FuncName}{"Class"};
3145 my $ClassName = $TypeDescr{$LibVersion}{$Tid_TDid{$LibVersion}{$ClassId}}{$ClassId}{"Name"};
3146 my $ShortName = $CompleteSignature{$LibVersion}{$FuncName}{"ShortName"};
3147 my $Suffix = $tr_name{$FuncName};
3148 $Suffix =~ s/\A$ClassName\:\:[~]*$ShortName[ ]*//g;
3149 return $Suffix;
3150}
3151
3152sub isRecurType($$$$)
3153{
3154 foreach (@RecurTypes)
3155 {
3156 if($_->{"Tid1"} eq $_[0]
3157 and $_->{"TDid1"} eq $_[1]
3158 and $_->{"Tid2"} eq $_[2]
3159 and $_->{"TDid2"} eq $_[3])
3160 {
3161 return 1;
3162 }
3163 }
3164 return 0;
3165}
3166
3167sub find_MemberPair_Pos_byName($$)
3168{
3169 my ($Member_Name, $Pair_Type) = @_;
3170 foreach my $MemberPair_Pos (sort keys(%{$Pair_Type->{"Memb"}}))
3171 {
3172 if($Pair_Type->{"Memb"}{$MemberPair_Pos}{"name"} eq $Member_Name)
3173 {
3174 return $MemberPair_Pos;
3175 }
3176 }
3177 return "lost";
3178}
3179
3180sub getBitfieldSum($$)
3181{
3182 my ($Member_Pos, $Pair_Type) = @_;
3183 my $BitfieldSum = 0;
3184 while($Member_Pos>-1)
3185 {
3186 return $BitfieldSum if(not $Pair_Type->{"Memb"}{$Member_Pos}{"bitfield"});
3187 $BitfieldSum += $Pair_Type->{"Memb"}{$Member_Pos}{"bitfield"};
3188 $Member_Pos -= 1;
3189 }
3190 return $BitfieldSum;
3191}
3192
3193sub find_MemberPair_Pos_byVal($$)
3194{
3195 my ($Member_Value, $Pair_Type) = @_;
3196 foreach my $MemberPair_Pos (sort keys(%{$Pair_Type->{"Memb"}}))
3197 {
3198 if($Pair_Type->{"Memb"}{$MemberPair_Pos}{"value"} eq $Member_Value)
3199 {
3200 return $MemberPair_Pos;
3201 }
3202 }
3203 return "lost";
3204}
3205
3206my %Priority_Value=(
3207"High"=>3,
3208"Medium"=>2,
3209"Low"=>1
3210);
3211
3212sub max_priority($$)
3213{
3214 my ($Priority1, $Priority2) = @_;
3215 if(cmp_priority($Priority1, $Priority2))
3216 {
3217 return $Priority1;
3218 }
3219 else
3220 {
3221 return $Priority2;
3222 }
3223}
3224
3225sub cmp_priority($$)
3226{
3227 my ($Priority1, $Priority2) = @_;
3228 return ($Priority_Value{$Priority1}>$Priority_Value{$Priority2});
3229}
3230
3231sub set_Problems_Priority()
3232{
3233 foreach my $InterfaceName (sort keys(%CompatProblems))
3234 {
3235 foreach my $Kind (sort keys(%{$CompatProblems{$InterfaceName}}))
3236 {
3237 foreach my $Location (sort keys(%{$CompatProblems{$InterfaceName}{$Kind}}))
3238 {
3239 my $IsInTypeInternals = $CompatProblems{$InterfaceName}{$Kind}{$Location}{"IsInTypeInternals"};
3240 my $InitialType_Type = $CompatProblems{$InterfaceName}{$Kind}{$Location}{"InitialType_Type"};
3241 if($Kind eq "Function_Become_Static")
3242 {
3243 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
3244 }
3245 elsif($Kind eq "Function_Become_NonStatic")
3246 {
3247 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
3248 }
3249 elsif($Kind eq "Parameter_Type_And_Size")
3250 {
3251 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
3252 }
3253 elsif($Kind eq "Parameter_Type")
3254 {
3255 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3256 }
3257 elsif($Kind eq "Withdrawn_Parameter")
3258 {
3259 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
3260 }
3261 elsif($Kind eq "Added_Parameter")
3262 {
3263 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
3264 }
3265 elsif($Kind eq "Parameter_BaseType_And_Size")
3266 {
3267 if($InitialType_Type eq "Pointer")
3268 {
3269 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3270 }
3271 else
3272 {
3273 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
3274 }
3275 }
3276 elsif($Kind eq "Parameter_BaseType")
3277 {
3278 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3279 }
3280 elsif($Kind eq "Parameter_PointerLevel")
3281 {
3282 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
3283 }
3284 elsif($Kind eq "Return_Type_And_Size")
3285 {
3286 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
3287 }
3288 elsif($Kind eq "Return_Type")
3289 {
3290 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3291 }
3292 elsif($Kind eq "Return_BaseType_And_Size")
3293 {
3294 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
3295 }
3296 elsif($Kind eq "Return_BaseType")
3297 {
3298 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3299 }
3300 elsif($Kind eq "Return_PointerLevel")
3301 {
3302 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3303 }
3304 if($Kind eq "Added_Virtual_Function")
3305 {
3306 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
3307 }
3308 elsif($Kind eq "Withdrawn_Virtual_Function")
3309 {
3310 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
3311 }
3312 elsif($Kind eq "Virtual_Function_Position")
3313 {
3314 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
3315 }
3316 elsif($Kind eq "Virtual_Function_Redefinition")
3317 {
3318 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3319 }
3320 elsif($Kind eq "Virtual_Function_Redefinition_B")
3321 {
3322 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3323 }
3324 elsif($Kind eq "Size")
3325 {
3326 if(($InitialType_Type eq "Pointer") or ($InitialType_Type eq "Array"))
3327 {
3328 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3329 }
3330 else
3331 {
3332 if($IsInTypeInternals)
3333 {
3334 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
3335 }
3336 else
3337 {
3338 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
3339 }
3340 }
3341 }
3342 elsif($Kind eq "BaseType")
3343 {
3344 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3345 }
3346 elsif($Kind eq "Added_Member_And_Size")
3347 {
3348 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3349 }
3350 elsif($Kind eq "Added_Middle_Member_And_Size")
3351 {
3352 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
3353 }
3354 elsif($Kind eq "Withdrawn_Member_And_Size")
3355 {
3356 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
3357 }
3358 elsif($Kind eq "Withdrawn_Member")
3359 {
3360 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3361 }
3362 elsif($Kind eq "Withdrawn_Middle_Member_And_Size")
3363 {
3364 if($IsInTypeInternals)
3365 {
3366 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
3367 }
3368 else
3369 {
3370 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
3371 }
3372 }
3373 elsif($Kind eq "Withdrawn_Middle_Member")
3374 {
3375 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
3376 }
3377 elsif($Kind eq "Member_Rename")
3378 {
3379 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3380 }
3381 elsif($Kind eq "Enum_Member_Value")
3382 {
3383 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
3384 }
3385 elsif($Kind eq "Enum_Member_Name")
3386 {
3387 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3388 }
3389 elsif($Kind eq "Member_Type_And_Size")
3390 {
3391 if(($InitialType_Type eq "Pointer") or ($InitialType_Type eq "Array"))
3392 {
3393 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3394 }
3395 else
3396 {
3397 if($IsInTypeInternals)
3398 {
3399 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3400 }
3401 else
3402 {
3403 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
3404 }
3405 }
3406 }
3407 elsif($Kind eq "Member_Type")
3408 {
3409 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3410 }
3411 elsif($Kind eq "Member_BaseType_And_Size")
3412 {
3413 if(($InitialType_Type eq "Pointer") or ($InitialType_Type eq "Array"))
3414 {
3415 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3416 }
3417 else
3418 {
3419 if($IsInTypeInternals)
3420 {
3421 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3422 }
3423 else
3424 {
3425 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
3426 }
3427 }
3428 }
3429 elsif($Kind eq "Member_BaseType")
3430 {
3431 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3432 }
3433 elsif($Kind eq "Member_PointerLevel")
3434 {
3435 if(($InitialType_Type eq "Pointer") or ($InitialType_Type eq "Array"))
3436 {
3437 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3438 }
3439 else
3440 {
3441 if($IsInTypeInternals)
3442 {
3443 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
3444 }
3445 else
3446 {
3447 $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
3448 }
3449 }
3450 }
3451 }
3452 }
3453 }
3454}
3455
3456sub pushType($$$$)
3457{
3458 my %TypeDescriptor=(
3459 "Tid1" => $_[0],
3460 "TDid1" => $_[1],
3461 "Tid2" => $_[2],
3462 "TDid2" => $_[3] );
3463 push(@RecurTypes, \%TypeDescriptor);
3464}
3465
3466sub mergeTypes($$$$)
3467{
3468 my ($Type1_Id, $Type1_DId, $Type2_Id, $Type2_DId) = @_;
3469 my (%Sub_SubProblems, %SubProblems) = ();
3470 if((not $Type1_Id and not $Type1_DId) or (not $Type2_Id and not $Type2_DId))
3471 {#Not Empty Inputs Only
3472 return ();
3473 }
3474 if($Cache{"mergeTypes"}{$Type1_Id}{$Type1_DId}{$Type2_Id}{$Type2_DId})
3475 {#Already Merged
3476 return %{$Cache{"mergeTypes"}{$Type1_Id}{$Type1_DId}{$Type2_Id}{$Type2_DId}};
3477 }
3478 my %Type1 = get_Type($Type1_DId, $Type1_Id, 1);
3479 my %Type2 = get_Type($Type2_DId, $Type2_Id, 2);
3480 my %Type1_Pure = get_PureType($Type1_DId, $Type1_Id, 1);
3481 my %Type2_Pure = get_PureType($Type2_DId, $Type2_Id, 2);
3482 return () if(not $Type1_Pure{"Size"} or not $Type2_Pure{"Size"});
3483 if(isRecurType($Type1_Pure{"Tid"}, $Type1_Pure{"TDid"}, $Type2_Pure{"Tid"}, $Type2_Pure{"TDid"}))
3484 {#Recursive Declarations
3485 return ();
3486 }
3487 return if(not $Type1_Pure{"Name"} or not $Type2_Pure{"Name"});
3488 return if($OpaqueTypes{1}{$Type1_Pure{"Name"}} or $OpaqueTypes{2}{$Type1_Pure{"Name"}} or $OpaqueTypes{1}{$Type1{"Name"}} or $OpaqueTypes{2}{$Type1{"Name"}});
3489
3490 my %Typedef_1 = goToFirst($Type1{"TDid"}, $Type1{"Tid"}, 1, "Typedef");
3491 my %Typedef_2 = goToFirst($Type2{"TDid"}, $Type2{"Tid"}, 2, "Typedef");
3492 if($Typedef_1{"Type"} eq "Typedef" and $Typedef_2{"Type"} eq "Typedef" and $Typedef_1{"Name"} eq $Typedef_2{"Name"})
3493 {
3494 my %Base_1 = get_OneStep_BaseType($Typedef_1{"TDid"}, $Typedef_1{"Tid"}, 1);
3495 my %Base_2 = get_OneStep_BaseType($Typedef_2{"TDid"}, $Typedef_2{"Tid"}, 2);
3496 if($Base_1{"Name"}!~/anon\-/ and $Base_2{"Name"}!~/anon\-/
3497 and ($Base_1{"Name"} ne $Base_2{"Name"}))
3498 {
3499 %{$SubProblems{"BaseType"}{$Typedef_1{"Name"}}}=(
3500 "Type_Name"=>$Typedef_1{"Name"},
3501 "Type_Type"=>"Typedef",
3502 "Header"=>$Typedef_2{"Header"},
3503 "Line"=>$Typedef_2{"Line"},
3504 "Old_Value"=>$Base_1{"Name"},
3505 "New_Value"=>$Base_2{"Name"} );
3506 }
3507 }
3508
3509 if(($Type1_Pure{"Name"} ne $Type2_Pure{"Name"}) and ($Type1_Pure{"Type"} ne "Pointer") and $Type1_Pure{"Name"}!~/anon\-/)
3510 {#Different types
3511 return ();
3512 }
3513
3514 pushType($Type1_Pure{"Tid"}, $Type1_Pure{"TDid"}, $Type2_Pure{"Tid"}, $Type2_Pure{"TDid"});
3515 if(($Type1_Pure{"Name"} eq $Type2_Pure{"Name"}) and ($Type1_Pure{"Type"} =~ /Struct|Class|Union/))
3516 {#Check Size
3517 if($Type1_Pure{"Size"} ne $Type2_Pure{"Size"})
3518 {
3519 %{$SubProblems{"Size"}{$Type1_Pure{"Name"}}}=(
3520 "Type_Name"=>$Type1_Pure{"Name"},
3521 "Type_Type"=>$Type1_Pure{"Type"},
3522 "Header"=>$Type2_Pure{"Header"},
3523 "Line"=>$Type2_Pure{"Line"},
3524 "Old_Value"=>$Type1_Pure{"Size"},
3525 "New_Value"=>$Type2_Pure{"Size"} );
3526 }
3527 }
3528 if($Type1_Pure{"Name"} and $Type2_Pure{"Name"} and ($Type1_Pure{"Name"} ne $Type2_Pure{"Name"}) and ($Type1_Pure{"Name"} !~ /\Avoid[ ]*\*/) and ($Type2_Pure{"Name"} =~ /\Avoid[ ]*\*/))
3529 {#Check "void *"
3530 pop(@RecurTypes);
3531 return ();
3532 }
3533 if($Type1_Pure{"BaseType"}{"Tid"} and $Type2_Pure{"BaseType"}{"Tid"})
3534 {#Check Base Types
3535 %Sub_SubProblems = &mergeTypes($Type1_Pure{"BaseType"}{"Tid"}, $Type1_Pure{"BaseType"}{"TDid"}, $Type2_Pure{"BaseType"}{"Tid"}, $Type2_Pure{"BaseType"}{"TDid"});
3536 foreach my $Sub_SubProblemType (keys(%Sub_SubProblems))
3537 {
3538 foreach my $Sub_SubLocation (keys(%{$Sub_SubProblems{$Sub_SubProblemType}}))
3539 {
3540 %{$SubProblems{$Sub_SubProblemType}{$Sub_SubLocation}} = %{$Sub_SubProblems{$Sub_SubProblemType}{$Sub_SubLocation}};
3541 $SubProblems{$Sub_SubProblemType}{$Sub_SubLocation}{"InitialType_Type"} = $Type1_Pure{"Type"};
3542 }
3543 }
3544 }
3545 foreach my $Member_Pos (sort keys(%{$Type1_Pure{"Memb"}}))
3546 {#Check Members
3547 next if($Type1_Pure{"Memb"}{$Member_Pos}{"access"} eq "private");
3548 my $Member_Name = $Type1_Pure{"Memb"}{$Member_Pos}{"name"};
3549 next if(not $Member_Name);
3550 my $Member_Location = $Member_Name;
3551 my $MemberPair_Pos = find_MemberPair_Pos_byName($Member_Name, \%Type2_Pure);
3552 if(($MemberPair_Pos eq "lost") and (($Type2_Pure{"Type"} eq "Struct") or ($Type2_Pure{"Type"} eq "Class")))
3553 {#Withdrawn_Member
3554 if($Member_Pos > keys(%{$Type2_Pure{"Memb"}}) - 1)
3555 {
3556 if($Type1_Pure{"Size"} ne $Type2_Pure{"Size"})
3557 {
3558 %{$SubProblems{"Withdrawn_Member_And_Size"}{$Member_Name}}=(
3559 "Target"=>$Member_Name,
3560 "Type_Name"=>$Type1_Pure{"Name"},
3561 "Type_Type"=>$Type1_Pure{"Type"},
3562 "Header"=>$Type2_Pure{"Header"},
3563 "Line"=>$Type2_Pure{"Line"},
3564 "Old_Size"=>$Type1_Pure{"Size"},
3565 "New_Size"=>$Type2_Pure{"Size"} );
3566 }
3567 else
3568 {
3569 %{$SubProblems{"Withdrawn_Member"}{$Member_Name}}=(
3570 "Target"=>$Member_Name,
3571 "Type_Name"=>$Type1_Pure{"Name"},
3572 "Type_Type"=>$Type1_Pure{"Type"},
3573 "Header"=>$Type2_Pure{"Header"},
3574 "Line"=>$Type2_Pure{"Line"} );
3575 }
3576 next;
3577 }
3578 elsif($Member_Pos < keys(%{$Type1_Pure{"Memb"}}) - 1)
3579 {
3580 my $MemberType_Id = $Type1_Pure{"Memb"}{$Member_Pos}{"type"};
3581 my %MemberType_Pure = get_PureType($Tid_TDid{1}{$MemberType_Id}, $MemberType_Id, 1);
3582 my $MemberStraightPairType_Id = $Type2_Pure{"Memb"}{$Member_Pos}{"type"};
3583 my %MemberStraightPairType_Pure = get_PureType($Tid_TDid{2}{$MemberStraightPairType_Id}, $MemberStraightPairType_Id, 2);
3584
3585 if(($MemberType_Pure{"Size"} eq $MemberStraightPairType_Pure{"Size"}) and find_MemberPair_Pos_byName($Type2_Pure{"Memb"}{$Member_Pos}{"name"}, \%Type1_Pure) eq "lost")
3586 {
3587 %{$SubProblems{"Member_Rename"}{$Member_Name}}=(
3588 "Target"=>$Member_Name,
3589 "Type_Name"=>$Type1_Pure{"Name"},
3590 "Type_Type"=>$Type1_Pure{"Type"},
3591 "Header"=>$Type2_Pure{"Header"},
3592 "Line"=>$Type2_Pure{"Line"},
3593 "Old_Value"=>$Type1_Pure{"Memb"}{$Member_Pos}{"name"},
3594 "New_Value"=>$Type2_Pure{"Memb"}{$Member_Pos}{"name"} );
3595 $MemberPair_Pos = $Member_Pos;
3596 }
3597 else
3598 {
3599 if($Type1_Pure{"Memb"}{$Member_Pos}{"bitfield"})
3600 {
3601 my $BitfieldSum = getBitfieldSum($Member_Pos-1, \%Type1_Pure)%($POINTER_SIZE*8);
3602 if($BitfieldSum and $BitfieldSum-$Type2_Pure{"Memb"}{$Member_Pos}{"bitfield"}>=0)
3603 {
3604 %{$SubProblems{"Withdrawn_Middle_Member"}{$Member_Name}}=(
3605 "Target"=>$Member_Name,
3606 "Type_Name"=>$Type1_Pure{"Name"},
3607 "Type_Type"=>$Type1_Pure{"Type"},
3608 "Header"=>$Type2_Pure{"Header"},
3609 "Line"=>$Type2_Pure{"Line"} );
3610 next;
3611 }
3612 }
3613 %{$SubProblems{"Withdrawn_Middle_Member_And_Size"}{$Member_Name}}=(
3614 "Target"=>$Member_Name,
3615 "Type_Name"=>$Type1_Pure{"Name"},
3616 "Type_Type"=>$Type1_Pure{"Type"},
3617 "Header"=>$Type2_Pure{"Header"},
3618 "Line"=>$Type2_Pure{"Line"} );
3619 next;
3620 }
3621 }
3622 }
3623 if($Type1_Pure{"Type"} eq "Enum")
3624 {
3625 my $Member_Value1 = $Type1_Pure{"Memb"}{$Member_Pos}{"value"};
3626 next if(not $Member_Value1);
3627 my $Member_Value2 = $Type2_Pure{"Memb"}{$MemberPair_Pos}{"value"};
3628 if($MemberPair_Pos eq "lost")
3629 {
3630 $MemberPair_Pos = find_MemberPair_Pos_byVal($Member_Value1, \%Type2_Pure);
3631 if($MemberPair_Pos ne "lost")
3632 {
3633 %{$SubProblems{"Enum_Member_Name"}{$Type1_Pure{"Memb"}{$Member_Pos}{"value"}}}=(
3634 "Target"=>$Type1_Pure{"Memb"}{$Member_Pos}{"value"},
3635 "Type_Name"=>$Type1_Pure{"Name"},
3636 "Type_Type"=>"Enum",
3637 "Header"=>$Type2_Pure{"Header"},
3638 "Line"=>$Type2_Pure{"Line"},
3639 "Old_Value"=>$Type1_Pure{"Memb"}{$Member_Pos}{"name"},
3640 "New_Value"=>$Type2_Pure{"Memb"}{$MemberPair_Pos}{"name"} );
3641 }
3642 }
3643 else
3644 {
3645 if($Member_Value1 ne "" and $Member_Value2 ne "")
3646 {
3647 if($Member_Value1 ne $Member_Value2)
3648 {
3649 %{$SubProblems{"Enum_Member_Value"}{$Member_Name}}=(
3650 "Target"=>$Member_Name,
3651 "Type_Name"=>$Type1_Pure{"Name"},
3652 "Type_Type"=>"Enum",
3653 "Header"=>$Type2_Pure{"Header"},
3654 "Line"=>$Type2_Pure{"Line"},
3655 "Old_Value"=>$Type1_Pure{"Memb"}{$Member_Pos}{"value"},
3656 "New_Value"=>$Type2_Pure{"Memb"}{$MemberPair_Pos}{"value"} );
3657 }
3658 }
3659 }
3660 next;
3661 }
3662 my $MemberType1_Id = $Type1_Pure{"Memb"}{$Member_Pos}{"type"};
3663 my $MemberType2_Id = $Type2_Pure{"Memb"}{$MemberPair_Pos}{"type"};
3664 %Sub_SubProblems = detectTypeChange($MemberType1_Id, $MemberType2_Id, "Member");
3665 foreach my $Sub_SubProblemType (keys(%Sub_SubProblems))
3666 {
3667 %{$SubProblems{$Sub_SubProblemType}{$Member_Name}}=(
3668 "Target"=>$Member_Name,
3669 "Member_Position"=>$Member_Pos,
3670 "Type_Name"=>$Type1_Pure{"Name"},
3671 "Type_Type"=>$Type1_Pure{"Type"},
3672 "Header"=>$Type2_Pure{"Header"},
3673 "Line"=>$Type2_Pure{"Line"});
3674 @{$SubProblems{$Sub_SubProblemType}{$Member_Name}}{keys(%{$Sub_SubProblems{$Sub_SubProblemType}})} = values %{$Sub_SubProblems{$Sub_SubProblemType}};
3675 }
3676 if($MemberType1_Id and $MemberType2_Id)
3677 {#checking member type change (replace)
3678 %Sub_SubProblems = &mergeTypes($MemberType1_Id, $Tid_TDid{1}{$MemberType1_Id}, $MemberType2_Id, $Tid_TDid{2}{$MemberType2_Id});
3679 foreach my $Sub_SubProblemType (keys(%Sub_SubProblems))
3680 {
3681 foreach my $Sub_SubLocation (keys(%{$Sub_SubProblems{$Sub_SubProblemType}}))
3682 {
3683 my $NewLocation = ($Sub_SubLocation)?$Member_Location."->".$Sub_SubLocation:$Member_Location;
3684 %{$SubProblems{$Sub_SubProblemType}{$NewLocation}}=(
3685 "IsInTypeInternals"=>"Yes");
3686 @{$SubProblems{$Sub_SubProblemType}{$NewLocation}}{keys(%{$Sub_SubProblems{$Sub_SubProblemType}{$Sub_SubLocation}})} = values %{$Sub_SubProblems{$Sub_SubProblemType}{$Sub_SubLocation}};
3687 if($Sub_SubLocation !~ /\-\>/)
3688 {
3689 $SubProblems{$Sub_SubProblemType}{$NewLocation}{"Member_Type_Name"} = get_TypeName($MemberType1_Id, 1);
3690 $SubProblems{$Sub_SubProblemType}{$NewLocation}{"Start_Type_Name"} = get_TypeName($MemberType1_Id, 1);
3691 }
3692 }
3693 }
3694 }
3695 }
3696 if(($Type2_Pure{"Type"} eq "Struct") or ($Type2_Pure{"Type"} eq "Class"))
3697 {
3698 foreach my $Member_Pos (sort keys(%{$Type2_Pure{"Memb"}}))
3699 {#checking added members
3700 next if(not $Type2_Pure{"Memb"}{$Member_Pos}{"name"});
3701 my $MemberPair_Pos = find_MemberPair_Pos_byName($Type2_Pure{"Memb"}{$Member_Pos}{"name"}, \%Type1_Pure);
3702 if($MemberPair_Pos eq "lost")
3703 {#Added_Member
3704 if($Member_Pos > keys(%{$Type1_Pure{"Memb"}}) - 1)
3705 {
3706 if($Type1_Pure{"Size"} ne $Type2_Pure{"Size"})
3707 {
3708 if($Type2_Pure{"Memb"}{$Member_Pos}{"bitfield"})
3709 {
3710 my $BitfieldSum = getBitfieldSum($Member_Pos-1, \%Type2_Pure)%($POINTER_SIZE*8);
3711 next if($BitfieldSum and $BitfieldSum<=$POINTER_SIZE*8-$Type2_Pure{"Memb"}{$Member_Pos}{"bitfield"});
3712 }
3713 %{$SubProblems{"Added_Member_And_Size"}{$Type2_Pure{"Memb"}{$Member_Pos}{"name"}}}=(
3714 "Target"=>$Type2_Pure{"Memb"}{$Member_Pos}{"name"},
3715 "Type_Name"=>$Type1_Pure{"Name"},
3716 "Type_Type"=>$Type1_Pure{"Type"},
3717 "Header"=>$Type2_Pure{"Header"},
3718 "Line"=>$Type2_Pure{"Line"} );
3719 }
3720 }
3721 else
3722 {
3723 my $MemberType_Id = $Type2_Pure{"Memb"}{$Member_Pos}{"type"};
3724 my $MemberType_DId = $Tid_TDid{2}{$MemberType_Id};
3725 my %MemberType_Pure = get_PureType($MemberType_DId, $MemberType_Id, 2);
3726
3727 my $MemberStraightPairType_Id = $Type1_Pure{"Memb"}{$Member_Pos}{"type"};
3728 my %MemberStraightPairType_Pure = get_PureType($Tid_TDid{1}{$MemberStraightPairType_Id}, $MemberStraightPairType_Id, 1);
3729
3730 if(($MemberType_Pure{"Size"} eq $MemberStraightPairType_Pure{"Size"}) and find_MemberPair_Pos_byName($Type1_Pure{"Memb"}{$Member_Pos}{"name"}, \%Type2_Pure) eq "lost")
3731 {
3732 next if($Type1_Pure{"Memb"}{$Member_Pos}{"access"} eq "private");
3733 %{$SubProblems{"Member_Rename"}{$Type2_Pure{"Memb"}{$Member_Pos}{"name"}}}=(
3734 "Target"=>$Type1_Pure{"Memb"}{$Member_Pos}{"name"},
3735 "Type_Name"=>$Type1_Pure{"Name"},
3736 "Type_Type"=>$Type1_Pure{"Type"},
3737 "Header"=>$Type2_Pure{"Header"},
3738 "Line"=>$Type2_Pure{"Line"},
3739 "Old_Value"=>$Type1_Pure{"Memb"}{$Member_Pos}{"name"},
3740 "New_Value"=>$Type2_Pure{"Memb"}{$Member_Pos}{"name"} );
3741 }
3742 else
3743 {
3744 if($Type1_Pure{"Size"} ne $Type2_Pure{"Size"})
3745 {
3746 if($Type2_Pure{"Memb"}{$Member_Pos}{"bitfield"})
3747 {
3748 my $BitfieldSum = getBitfieldSum($Member_Pos-1, \%Type2_Pure)%($POINTER_SIZE*8);
3749 next if($BitfieldSum and $BitfieldSum<=$POINTER_SIZE*8-$Type2_Pure{"Memb"}{$Member_Pos}{"bitfield"});
3750 }
3751 %{$SubProblems{"Added_Middle_Member_And_Size"}{$Type2_Pure{"Memb"}{$Member_Pos}{"name"}}}=(
3752 "Target"=>$Type2_Pure{"Memb"}{$Member_Pos}{"name"},
3753 "Type_Name"=>$Type1_Pure{"Name"},
3754 "Type_Type"=>$Type1_Pure{"Type"},
3755 "Header"=>$Type2_Pure{"Header"},
3756 "Line"=>$Type2_Pure{"Line"} );
3757 }
3758 }
3759 }
3760 }
3761 }
3762 }
3763 %{$Cache{"mergeTypes"}{$Type1_Id}{$Type1_DId}{$Type2_Id}{$Type2_DId}} = %SubProblems;
3764 pop(@RecurTypes);
3765 return %SubProblems;
3766}
3767
3768sub get_TypeName($$)
3769{
3770 my ($TypeId, $LibVersion) = @_;
3771 return $TypeDescr{$LibVersion}{$Tid_TDid{$LibVersion}{$TypeId}}{$TypeId}{"Name"};
3772}
3773
3774sub goToFirst($$$$)
3775{
3776 my ($TypeDId, $TypeId, $LibVersion, $Type_Type) = @_;
3777 if(defined $Cache{"goToFirst"}{$TypeDId}{$TypeId}{$LibVersion}{$Type_Type})
3778 {
3779 return %{$Cache{"goToFirst"}{$TypeDId}{$TypeId}{$LibVersion}{$Type_Type}};
3780 }
3781 return () if(not $TypeDescr{$LibVersion}{$TypeDId}{$TypeId});
3782 my %Type = %{$TypeDescr{$LibVersion}{$TypeDId}{$TypeId}};
3783 return () if(not $Type{"Type"});
3784 if($Type{"Type"} ne $Type_Type)
3785 {
3786 return () if(not $Type{"BaseType"}{"TDid"} and not $Type{"BaseType"}{"Tid"});
3787 %Type = goToFirst($Type{"BaseType"}{"TDid"}, $Type{"BaseType"}{"Tid"}, $LibVersion, $Type_Type);
3788 }
3789 $Cache{"goToFirst"}{$TypeDId}{$TypeId}{$LibVersion}{$Type_Type} = \%Type;
3790 return %Type;
3791}
3792
3793my %TypeSpecAttributes = (
3794 "Ref" => 1,
3795 "Const" => 1,
3796 "Volatile" => 1,
3797 "Restrict" => 1,
3798 "Typedef" => 1
3799);
3800
3801sub get_PureType($$$)
3802{
3803 my ($TypeDId, $TypeId, $LibVersion) = @_;
3804 return "" if(not $TypeId);
3805 if(defined $Cache{"get_PureType"}{$TypeDId}{$TypeId}{$LibVersion})
3806 {
3807 return %{$Cache{"get_PureType"}{$TypeDId}{$TypeId}{$LibVersion}};
3808 }
3809 return "" if(not $TypeDescr{$LibVersion}{$TypeDId}{$TypeId});
3810 my %Type = %{$TypeDescr{$LibVersion}{$TypeDId}{$TypeId}};
3811 if($Type{"Type"} =~ /Struct|Union|Typedef|Class|Enum/)
3812 {
3813 $CheckedTypes{$Type{"Name"}} = 1;
3814 }
3815 return %Type if(not $Type{"BaseType"}{"TDid"} and not $Type{"BaseType"}{"Tid"});
3816 if($TypeSpecAttributes{$Type{"Type"}})
3817 {
3818 %Type = get_PureType($Type{"BaseType"}{"TDid"}, $Type{"BaseType"}{"Tid"}, $LibVersion);
3819 }
3820 $Cache{"get_PureType"}{$TypeDId}{$TypeId}{$LibVersion} = \%Type;
3821 return %Type;
3822}
3823
3824sub get_PointerLevel($$$)
3825{
3826 my ($TypeDId, $TypeId, $LibVersion) = @_;
3827 return "" if(not $TypeId);
3828 if(defined $Cache{"get_PointerLevel"}{$TypeDId}{$TypeId}{$LibVersion})
3829 {
3830 return $Cache{"get_PointerLevel"}{$TypeDId}{$TypeId}{$LibVersion};
3831 }
3832 return "" if(not $TypeDescr{$LibVersion}{$TypeDId}{$TypeId});
3833 my %Type = %{$TypeDescr{$LibVersion}{$TypeDId}{$TypeId}};
3834 return 0 if(not $Type{"BaseType"}{"TDid"} and not $Type{"BaseType"}{"Tid"});
3835 my $PointerLevel = 0;
3836 if($Type{"Type"} eq "Pointer")
3837 {
3838 $PointerLevel += 1;
3839 }
3840 $PointerLevel += get_PointerLevel($Type{"BaseType"}{"TDid"}, $Type{"BaseType"}{"Tid"}, $LibVersion);
3841 $Cache{"get_PointerLevel"}{$TypeDId}{$TypeId}{$LibVersion} = $PointerLevel;
3842 return $PointerLevel;
3843}
3844
3845sub get_BaseType($$$)
3846{
3847 my ($TypeDId, $TypeId, $LibVersion) = @_;
3848 return "" if(not $TypeId);
3849 if(defined $Cache{"get_BaseType"}{$TypeDId}{$TypeId}{$LibVersion})
3850 {
3851 return %{$Cache{"get_BaseType"}{$TypeDId}{$TypeId}{$LibVersion}};
3852 }
3853 return "" if(not $TypeDescr{$LibVersion}{$TypeDId}{$TypeId});
3854 my %Type = %{$TypeDescr{$LibVersion}{$TypeDId}{$TypeId}};
3855 if($Type{"Type"} =~ /Struct|Union|Typedef|Class|Enum/)
3856 {
3857 $CheckedTypes{$Type{"Name"}} = 1;
3858 }
3859 return %Type if(not $Type{"BaseType"}{"TDid"} and not $Type{"BaseType"}{"Tid"});
3860 %Type = get_BaseType($Type{"BaseType"}{"TDid"}, $Type{"BaseType"}{"Tid"}, $LibVersion);
3861 $Cache{"get_BaseType"}{$TypeDId}{$TypeId}{$LibVersion} = \%Type;
3862 return %Type;
3863}
3864
3865sub get_OneStep_BaseType($$$)
3866{
3867 my ($TypeDId, $TypeId, $LibVersion) = @_;
3868 return "" if(not $TypeId);
3869 return "" if(not $TypeDescr{$LibVersion}{$TypeDId}{$TypeId});
3870 my %Type = %{$TypeDescr{$LibVersion}{$TypeDId}{$TypeId}};
3871 return %Type if(not $Type{"BaseType"}{"TDid"} and not $Type{"BaseType"}{"Tid"});
3872 return get_Type($Type{"BaseType"}{"TDid"}, $Type{"BaseType"}{"Tid"}, $LibVersion);
3873}
3874
3875sub get_Type($$$)
3876{
3877 my ($TypeDId, $TypeId, $LibVersion) = @_;
3878 return "" if(not $TypeId);
3879 return "" if(not $TypeDescr{$LibVersion}{$TypeDId}{$TypeId});
3880 return %{$TypeDescr{$LibVersion}{$TypeDId}{$TypeId}};
3881}
3882
3883sub mergeLibs()
3884{
3885 foreach my $Interface (sort keys(%AddedInt))
3886 {#checking added interfaces
3887 next if($InternalInterfaces{1}{$Interface} or $InternalInterfaces{2}{$Interface});
3888 next if(defined $InterfacesListPath and not $InterfacesList{$Interface});
3889 next if(defined $AppPath and not $InterfacesList_App{$Interface});
3890 next if($FuncAttr{2}{$Interface}{"Private"});
3891 next if(not $FuncAttr{2}{$Interface}{"Header"});
3892 %{$CompatProblems{$Interface}{"Added_Interface"}{"SharedLibrary"}}=(
3893 "Header"=>$FuncAttr{2}{$Interface}{"Header"},
3894 "Line"=>$FuncAttr{2}{$Interface}{"Line"},
3895 "Signature"=>$FuncAttr{2}{$Interface}{"Signature"},
3896 "New_SoName"=>$Interface_Library{2}{$Interface} );
3897 }
3898 foreach my $Interface (sort keys(%WithdrawnInt))
3899 {#checking withdrawn interfaces
3900 next if($InternalInterfaces{1}{$Interface} or $InternalInterfaces{2}{$Interface});
3901 next if(defined $InterfacesListPath and not $InterfacesList{$Interface});
3902 next if(defined $AppPath and not $InterfacesList_App{$Interface});
3903 next if($FuncAttr{1}{$Interface}{"Private"});
3904 next if(not $FuncAttr{1}{$Interface}{"Header"});
3905 %{$CompatProblems{$Interface}{"Withdrawn_Interface"}{"SharedLibrary"}}=(
3906 "Header"=>$FuncAttr{1}{$Interface}{"Header"},
3907 "Line"=>$FuncAttr{1}{$Interface}{"Line"},
3908 "Signature"=>$FuncAttr{1}{$Interface}{"Signature"},
3909 "Old_SoName"=>$Interface_Library{1}{$Interface} );
3910 }
3911}
3912
3913sub mergeSignatures()
3914{
3915 my %SubProblems = ();
3916
3917 prepareInterfaces(1);
3918 prepareInterfaces(2);
3919 %FuncDescr=();
3920
3921 initializeClassVirtFunc(1);
3922 initializeClassVirtFunc(2);
3923
3924 checkVirtFuncRedefinitions(1);
3925 checkVirtFuncRedefinitions(2);
3926
3927 setVirtFuncPositions(1);
3928 setVirtFuncPositions(2);
3929
3930 foreach my $Interface (sort keys(%AddedInt))
3931 {#collecting the attributes of added interfaces
3932 next if($CheckedInterfaces{$Interface});
3933 if($CompleteSignature{2}{$Interface})
3934 {
3935 if($CompleteSignature{2}{$Interface}{"Private"})
3936 {
3937 $FuncAttr{2}{$Interface}{"Private"} = 1;
3938 }
3939 if($CompleteSignature{2}{$Interface}{"Protected"})
3940 {
3941 $FuncAttr{2}{$Interface}{"Protected"} = 1;
3942 }
3943 if($CompleteSignature{2}{$Interface}{"Header"})
3944 {
3945 $FuncAttr{2}{$Interface}{"Header"} = $CompleteSignature{2}{$Interface}{"Header"};
3946 }
3947 if($CompleteSignature{2}{$Interface}{"Line"})
3948 {
3949 $FuncAttr{2}{$Interface}{"Line"} = $CompleteSignature{2}{$Interface}{"Line"};
3950 }
3951 $FuncAttr{2}{$Interface}{"Signature"} = get_Signature($Interface, 2);
3952 foreach my $ParamPos (keys(%{$CompleteSignature{2}{$Interface}{"Param"}}))
3953 {
3954 my $ParamType_Id = $CompleteSignature{2}{$Interface}{"Param"}{$ParamPos}{"type"};
3955 my $ParamType_DId = $Tid_TDid{2}{$ParamType_Id};
3956 my %ParamType = get_Type($ParamType_DId, $ParamType_Id, 2);
3957 }
3958 #checking virtual table
3959 check_VirtualTable($Interface, 2);
3960 $CheckedInterfaces{$Interface} = 1;
3961 }
3962 }
3963 foreach my $Interface (sort keys(%WithdrawnInt))
3964 {#collecting the attributes of withdrawn interfaces
3965 next if($CheckedInterfaces{$Interface});
3966 if($CompleteSignature{1}{$Interface})
3967 {
3968 if($CompleteSignature{1}{$Interface}{"Private"})
3969 {
3970 $FuncAttr{1}{$Interface}{"Private"} = 1;
3971 }
3972 if($CompleteSignature{1}{$Interface}{"Protected"})
3973 {
3974 $FuncAttr{1}{$Interface}{"Protected"} = 1;
3975 }
3976 if($CompleteSignature{1}{$Interface}{"Header"})
3977 {
3978 $FuncAttr{1}{$Interface}{"Header"} = $CompleteSignature{1}{$Interface}{"Header"};
3979 }
3980 if($CompleteSignature{1}{$Interface}{"Line"})
3981 {
3982 $FuncAttr{1}{$Interface}{"Line"} = $CompleteSignature{1}{$Interface}{"Line"};
3983 }
3984 $FuncAttr{1}{$Interface}{"Signature"} = get_Signature($Interface, 1);
3985 foreach my $ParamPos (keys(%{$CompleteSignature{1}{$Interface}{"Param"}}))
3986 {
3987 my $ParamType_Id = $CompleteSignature{1}{$Interface}{"Param"}{$ParamPos}{"type"};
3988 my $ParamType_DId = $Tid_TDid{1}{$ParamType_Id};
3989 my %ParamType = get_Type($ParamType_DId, $ParamType_Id, 1);
3990 }
3991 #checking virtual table
3992 check_VirtualTable($Interface, 1);
3993 $CheckedInterfaces{$Interface} = 1;
3994 }
3995 }
3996
3997 foreach my $Interface (sort keys(%{$CompleteSignature{1}}))
3998 {#checking interfaces
3999 if(($Interface !~ /\@/) and ($SymVer{1}{$Interface} =~ /\A(.*)[\@]+/))
4000 {
4001 next if($1 eq $Interface);
4002 }
4003 my ($MnglName, $SymbolVersion) = ($Interface, "");
4004 if($Interface =~ /\A([^@]+)[\@]+([^@]+)\Z/)
4005 {
4006 ($MnglName, $SymbolVersion) = ($1, $2);
4007 }
4008 next if($InternalInterfaces{1}{$Interface} or $InternalInterfaces{2}{$Interface});
4009 next if(defined $InterfacesListPath and not $InterfacesList{$Interface});
4010 next if(defined $AppPath and not $InterfacesList_App{$Interface});
4011 next if($CheckedInterfaces{$Interface});
4012 next if($CompleteSignature{1}{$Interface}{"Private"});
4013 next if(not $CompleteSignature{1}{$Interface}{"Header"} or not $CompleteSignature{2}{$Interface}{"Header"});
4014 next if(not $CompleteSignature{1}{$Interface}{"MnglName"} or not $CompleteSignature{2}{$Interface}{"MnglName"});
4015 next if((not $CompleteSignature{1}{$Interface}{"PureVirt"} and $CompleteSignature{2}{$Interface}{"PureVirt"}) or ($CompleteSignature{1}{$Interface}{"PureVirt"} and not $CompleteSignature{2}{$Interface}{"PureVirt"}));
4016 $CheckedInterfaces{$Interface} = 1;
4017 #checking virtual table
4018 check_VirtualTable($Interface, 1);
4019 #checking attributes
4020 if($CompleteSignature{2}{$Interface}{"Static"} and not $CompleteSignature{1}{$Interface}{"Static"})
4021 {
4022 %{$CompatProblems{$Interface}{"Function_Become_Static"}{"Attributes"}}=(
4023 "Header"=>$CompleteSignature{1}{$Interface}{"Header"},
4024 "Line"=>$CompleteSignature{1}{$Interface}{"Line"},
4025 "Signature"=>get_Signature($Interface, 1),
4026 "Old_SoName"=>$Interface_Library{1}{$Interface},
4027 "New_SoName"=>$Interface_Library{2}{$Interface} );
4028 }
4029 elsif(not $CompleteSignature{2}{$Interface}{"Static"} and $CompleteSignature{1}{$Interface}{"Static"})
4030 {
4031 %{$CompatProblems{$Interface}{"Function_Become_NonStatic"}{"Attributes"}}=(
4032 "Header"=>$CompleteSignature{1}{$Interface}{"Header"},
4033 "Line"=>$CompleteSignature{1}{$Interface}{"Line"},
4034 "Signature"=>get_Signature($Interface, 1),
4035 "Old_SoName"=>$Interface_Library{1}{$Interface},
4036 "New_SoName"=>$Interface_Library{2}{$Interface} );
4037 }
4038 if($CompleteSignature{1}{$Interface}{"Virt"} and $CompleteSignature{2}{$Interface}{"Virt"})
4039 {
4040 if($CompleteSignature{1}{$Interface}{"Position"}!=$CompleteSignature{2}{$Interface}{"Position"})
4041 {
4042 my $Class_Id = $CompleteSignature{1}{$Interface}{"Class"};
4043 my $Class_DId = $Tid_TDid{1}{$Class_Id};
4044 my %Class_Type = get_Type($Class_DId, $Class_Id, 1);
4045 %{$CompatProblems{$Interface}{"Virtual_Function_Position"}{$tr_name{$MnglName}}}=(
4046 "Type_Name"=>$Class_Type{"Name"},
4047 "Type_Type"=>$Class_Type{"Type"},
4048 "Header"=>$Class_Type{"Header"},
4049 "Line"=>$Class_Type{"Line"},
4050 "Old_Value"=>$CompleteSignature{1}{$Interface}{"Position"},
4051 "New_Value"=>$CompleteSignature{2}{$Interface}{"Position"},
4052 "Signature"=>get_Signature($Interface, 1),
4053 "Target"=>$tr_name{$MnglName},
4054 "Old_SoName"=>$Interface_Library{1}{$Interface},
4055 "New_SoName"=>$Interface_Library{2}{$Interface} );
4056 }
4057 }
4058 foreach my $ParamPos (sort {int($a) <=> int($b)} keys(%{$CompleteSignature{2}{$Interface}{"Param"}}))
4059 {#checking added parameters
4060 last if($Interface=~/\A_Z/);
4061 if(not defined $CompleteSignature{1}{$Interface}{"Param"}{$ParamPos})
4062 {#checking withdrawn parameters
4063 my $ParamType2_Id = $CompleteSignature{2}{$Interface}{"Param"}{$ParamPos}{"type"};
4064 my $Parameter_Name = $CompleteSignature{2}{$Interface}{"Param"}{$ParamPos}{"name"};
4065 last if(get_TypeName($ParamType2_Id, 2) eq "...");
4066 %{$CompatProblems{$Interface}{"Added_Parameter"}{num_to_str($ParamPos+1)." Parameter"}}=(
4067 "Target"=>$Parameter_Name,
4068 "Parameter_Position"=>$ParamPos,
4069 "Signature"=>get_Signature($Interface, 1),
4070 "Header"=>$CompleteSignature{1}{$Interface}{"Header"},
4071 "Line"=>$CompleteSignature{1}{$Interface}{"Line"},
4072 "Old_SoName"=>$Interface_Library{1}{$Interface},
4073 "New_SoName"=>$Interface_Library{2}{$Interface});
4074 }
4075 }
4076 foreach my $ParamPos (sort {int($a) <=> int($b)} keys(%{$CompleteSignature{1}{$Interface}{"Param"}}))
4077 {#checking parameters
4078 my $ParamType1_Id = $CompleteSignature{1}{$Interface}{"Param"}{$ParamPos}{"type"};
4079 my $Parameter_Name = $CompleteSignature{1}{$Interface}{"Param"}{$ParamPos}{"name"};
4080 if(not defined $CompleteSignature{2}{$Interface}{"Param"}{$ParamPos} and get_TypeName($ParamType1_Id, 1) ne "..." and $Interface!~/\A_Z/)
4081 {#checking withdrawn parameters
4082 %{$CompatProblems{$Interface}{"Withdrawn_Parameter"}{num_to_str($ParamPos+1)." Parameter"}}=(
4083 "Target"=>$Parameter_Name,
4084 "Parameter_Position"=>$ParamPos,
4085 "Signature"=>get_Signature($Interface, 1),
4086 "Header"=>$CompleteSignature{1}{$Interface}{"Header"},
4087 "Line"=>$CompleteSignature{1}{$Interface}{"Line"},
4088 "Old_SoName"=>$Interface_Library{1}{$Interface},
4089 "New_SoName"=>$Interface_Library{2}{$Interface});
4090 next;
4091 }
4092 my $ParamType2_Id = $CompleteSignature{2}{$Interface}{"Param"}{$ParamPos}{"type"};
4093 next if(not $ParamType1_Id or not $ParamType2_Id);
4094 my $Parameter_Location = ($Parameter_Name)?$Parameter_Name:num_to_str($ParamPos+1)." Parameter";
4095
4096 #checking type change(replace)
4097 %SubProblems = detectTypeChange($ParamType1_Id, $ParamType2_Id, "Parameter");
4098 foreach my $SubProblemType (keys(%SubProblems))
4099 {
4100 %{$CompatProblems{$Interface}{$SubProblemType}{$Parameter_Location}}=(
4101 "Target"=>$Parameter_Name,
4102 "Parameter_Position"=>$ParamPos,
4103 "Signature"=>get_Signature($Interface, 1),
4104 "Header"=>$CompleteSignature{1}{$Interface}{"Header"},
4105 "Line"=>$CompleteSignature{1}{$Interface}{"Line"},
4106 "Old_SoName"=>$Interface_Library{1}{$Interface},
4107 "New_SoName"=>$Interface_Library{2}{$Interface});
4108 @{$CompatProblems{$Interface}{$SubProblemType}{$Parameter_Location}}{keys(%{$SubProblems{$SubProblemType}})} = values %{$SubProblems{$SubProblemType}};
4109 }
4110 @RecurTypes = ();
4111 #checking type definition changes
4112 %SubProblems = mergeTypes($ParamType1_Id, $Tid_TDid{1}{$ParamType1_Id}, $ParamType2_Id, $Tid_TDid{2}{$ParamType2_Id});
4113 foreach my $SubProblemType (keys(%SubProblems))
4114 {
4115 foreach my $SubLocation (keys(%{$SubProblems{$SubProblemType}}))
4116 {
4117 my $NewLocation = ($SubLocation)?$Parameter_Location."->".$SubLocation:$Parameter_Location;
4118 %{$CompatProblems{$Interface}{$SubProblemType}{$NewLocation}}=(
4119 "Signature"=>get_Signature($Interface, 1),
4120 "Header"=>$CompleteSignature{1}{$Interface}{"Header"},
4121 "Line"=>$CompleteSignature{1}{$Interface}{"Line"},
4122 "Old_SoName"=>$Interface_Library{1}{$Interface},
4123 "New_SoName"=>$Interface_Library{2}{$Interface},
4124 "Parameter_Type_Name"=>get_TypeName($ParamType1_Id, 1),
4125 "Parameter_Position"=>$ParamPos,
4126 "Parameter_Name"=>$Parameter_Name);
4127 @{$CompatProblems{$Interface}{$SubProblemType}{$NewLocation}}{keys(%{$SubProblems{$SubProblemType}{$SubLocation}})} = values %{$SubProblems{$SubProblemType}{$SubLocation}};
4128 if($SubLocation !~ /\-\>/)
4129 {
4130 $CompatProblems{$Interface}{$SubProblemType}{$NewLocation}{"Start_Type_Name"} = get_TypeName($ParamType1_Id, 1);
4131 }
4132 }
4133 }
4134 }
4135 #checking return type
4136 my $ReturnType1_Id = $CompleteSignature{1}{$Interface}{"Return"};
4137 my $ReturnType2_Id = $CompleteSignature{2}{$Interface}{"Return"};
4138 %SubProblems = detectTypeChange($ReturnType1_Id, $ReturnType2_Id, "Return");
4139 foreach my $SubProblemType (keys(%SubProblems))
4140 {
4141 %{$CompatProblems{$Interface}{$SubProblemType}{"RetVal"}}=(
4142 "Signature"=>get_Signature($Interface, 1),
4143 "Header"=>$CompleteSignature{1}{$Interface}{"Header"},
4144 "Line"=>$CompleteSignature{1}{$Interface}{"Line"},
4145 "Old_SoName"=>$Interface_Library{1}{$Interface},
4146 "New_SoName"=>$Interface_Library{2}{$Interface});
4147 @{$CompatProblems{$Interface}{$SubProblemType}{"RetVal"}}{keys(%{$SubProblems{$SubProblemType}})} = values %{$SubProblems{$SubProblemType}};
4148 }
4149 if($ReturnType1_Id and $ReturnType2_Id)
4150 {
4151 @RecurTypes = ();
4152 %SubProblems = mergeTypes($ReturnType1_Id, $Tid_TDid{1}{$ReturnType1_Id}, $ReturnType2_Id, $Tid_TDid{2}{$ReturnType2_Id});
4153 foreach my $SubProblemType (keys(%SubProblems))
4154 {
4155 foreach my $SubLocation (keys(%{$SubProblems{$SubProblemType}}))
4156 {
4157 my $NewLocation = ($SubLocation)?"RetVal->".$SubLocation:"RetVal";
4158 %{$CompatProblems{$Interface}{$SubProblemType}{$NewLocation}}=(
4159 "Signature"=>get_Signature($Interface, 1),
4160 "Header"=>$CompleteSignature{1}{$Interface}{"Header"},
4161 "Line"=>$CompleteSignature{1}{$Interface}{"Line"},
4162 "Old_SoName"=>$Interface_Library{1}{$Interface},
4163 "New_SoName"=>$Interface_Library{2}{$Interface},
4164 "Return_Type_Name"=>get_TypeName($ReturnType1_Id, 1) );
4165 @{$CompatProblems{$Interface}{$SubProblemType}{$NewLocation}}{keys(%{$SubProblems{$SubProblemType}{$SubLocation}})} = values %{$SubProblems{$SubProblemType}{$SubLocation}};
4166 if($SubLocation !~ /\-\>/)
4167 {
4168 $CompatProblems{$Interface}{$SubProblemType}{$NewLocation}{"Start_Type_Name"} = get_TypeName($ReturnType1_Id, 1);
4169 }
4170 }
4171 }
4172 }
4173
4174 #checking object type
4175 my $ObjectType1_Id = $CompleteSignature{1}{$Interface}{"Class"};
4176 my $ObjectType2_Id = $CompleteSignature{2}{$Interface}{"Class"};
4177 if($ObjectType1_Id and $ObjectType2_Id)
4178 {
4179 my $ThisType1_Id = getTypeIdByName(get_TypeName($ObjectType1_Id, 1)."*const", 1);
4180 my $ThisType2_Id = getTypeIdByName(get_TypeName($ObjectType2_Id, 2)."*const", 2);
4181 if($ThisType1_Id and $ThisType2_Id)
4182 {
4183 @RecurTypes = ();
4184 %SubProblems = mergeTypes($ThisType1_Id, $Tid_TDid{1}{$ThisType1_Id}, $ThisType2_Id, $Tid_TDid{2}{$ThisType2_Id});
4185 foreach my $SubProblemType (keys(%SubProblems))
4186 {
4187 foreach my $SubLocation (keys(%{$SubProblems{$SubProblemType}}))
4188 {
4189 my $NewLocation = ($SubLocation)?"Obj->".$SubLocation:"Obj";
4190 %{$CompatProblems{$Interface}{$SubProblemType}{$NewLocation}}=(
4191 "Signature"=>get_Signature($Interface, 1),
4192 "Header"=>$CompleteSignature{1}{$Interface}{"Header"},
4193 "Line"=>$CompleteSignature{1}{$Interface}{"Line"},
4194 "Old_SoName"=>$Interface_Library{1}{$Interface},
4195 "New_SoName"=>$Interface_Library{2}{$Interface},
4196 "Object_Type_Name"=>get_TypeName($ObjectType1_Id, 1) );
4197 @{$CompatProblems{$Interface}{$SubProblemType}{$NewLocation}}{keys(%{$SubProblems{$SubProblemType}{$SubLocation}})} = values %{$SubProblems{$SubProblemType}{$SubLocation}};
4198 if($SubLocation !~ /\-\>/)
4199 {
4200 $CompatProblems{$Interface}{$SubProblemType}{$NewLocation}{"Start_Type_Name"} = get_TypeName($ObjectType1_Id, 1);
4201 }
4202 }
4203 }
4204 }
4205 }
4206 }
4207 set_Problems_Priority();
4208}
4209
4210sub getTypeIdByName($$)
4211{
4212 my ($TypeName, $Version) = @_;
4213 return $TName_Tid{$Version}{correctName($TypeName)};
4214}
4215
4216sub detectTypeChange($$$)
4217{
4218 my ($Type1_Id, $Type2_Id, $Prefix) = @_;
4219 my %LocalProblems = ();
4220 my $Type1_DId = $Tid_TDid{1}{$Type1_Id};
4221 my $Type2_DId = $Tid_TDid{2}{$Type2_Id};
4222 my %Type1 = get_Type($Type1_DId, $Type1_Id, 1);
4223 my %Type2 = get_Type($Type2_DId, $Type2_Id, 2);
4224 my %Type1_Base = get_BaseType($Type1_DId, $Type1_Id, 1);
4225 my %Type2_Base = get_BaseType($Type2_DId, $Type2_Id, 2);
4226 my %Type1_Pure = get_PureType($Type1_DId, $Type1_Id, 1);
4227 my %Type2_Pure = get_PureType($Type2_DId, $Type2_Id, 2);
4228 my $Type1_PointerLevel = get_PointerLevel($Type1_DId, $Type1_Id, 1);
4229 my $Type2_PointerLevel = get_PointerLevel($Type2_DId, $Type2_Id, 2);
4230 return () if(not $Type1{"Name"} or not $Type2{"Name"} or not $Type1{"Size"} or not $Type2{"Size"} or not $Type1_Pure{"Size"} or not $Type2_Pure{"Size"} or not $Type1_Base{"Name"} or not $Type2_Base{"Name"} or not $Type1_Base{"Size"} or not $Type2_Base{"Size"} or $Type1_PointerLevel eq "" or $Type2_PointerLevel eq "");
4231 if($Type1_Base{"Name"} ne $Type2_Base{"Name"})
4232 {#base type change
4233 if($Type1_Base{"Name"}!~/anon\-/ and $Type2_Base{"Name"}!~/anon\-/)
4234 {
4235 if($Type1_Base{"Size"}!=$Type2_Base{"Size"})
4236 {
4237 %{$LocalProblems{$Prefix."_BaseType_And_Size"}}=(
4238 "Old_Value"=>$Type1_Base{"Name"},
4239 "New_Value"=>$Type2_Base{"Name"},
4240 "Old_Size"=>$Type1_Base{"Size"},
4241 "New_Size"=>$Type2_Base{"Size"},
4242 "InitialType_Type"=>$Type1_Pure{"Type"});
4243 }
4244 else
4245 {
4246 %{$LocalProblems{$Prefix."_BaseType"}}=(
4247 "Old_Value"=>$Type1_Base{"Name"},
4248 "New_Value"=>$Type2_Base{"Name"},
4249 "InitialType_Type"=>$Type1_Pure{"Type"});
4250 }
4251 }
4252 }
4253 elsif($Type1{"Name"} ne $Type2{"Name"})
4254 {#type change
4255 if($Type1{"Name"}!~/anon\-/ and $Type2{"Name"}!~/anon\-/)
4256 {
4257 if($Type1{"Size"}!=$Type2{"Size"})
4258 {
4259 %{$LocalProblems{$Prefix."_Type_And_Size"}}=(
4260 "Old_Value"=>$Type1{"Name"},
4261 "New_Value"=>$Type2{"Name"},
4262 "Old_Size"=>($Type1{"Type"} eq "Array")?$Type1{"Size"}*$Type1_Base{"Size"}:$Type1{"Size"},
4263 "New_Size"=>($Type2{"Type"} eq "Array")?$Type2{"Size"}*$Type2_Base{"Size"}:$Type2{"Size"},
4264 "InitialType_Type"=>$Type1_Pure{"Type"});
4265 }
4266 else
4267 {
4268 %{$LocalProblems{$Prefix."_Type"}}=(
4269 "Old_Value"=>$Type1{"Name"},
4270 "New_Value"=>$Type2{"Name"},
4271 "InitialType_Type"=>$Type1_Pure{"Type"});
4272 }
4273 }
4274 }
4275
4276 if($Type1_PointerLevel!=$Type2_PointerLevel)
4277 {
4278 %{$LocalProblems{$Prefix."_PointerLevel"}}=(
4279 "Old_Value"=>$Type1_PointerLevel,
4280 "New_Value"=>$Type2_PointerLevel);
4281 }
4282 return %LocalProblems;
4283}
4284
4285sub htmlSpecChars($)
4286{
4287 my $Str = $_[0];
4288 $Str =~ s/\&([^#])/&amp;$1/g;
4289 $Str =~ s/</&lt;/g;
4290 $Str =~ s/>/&gt;/g;
4291 $Str =~ s/([^ ])( )([^ ])/$1\@ALONE_SP\@$3/g;
4292 $Str =~ s/ /&nbsp;/g;
4293 $Str =~ s/\@ALONE_SP\@/ /g;
4294 $Str =~ s/\n/<br\/>/g;
4295 return $Str;
4296}
4297
4298sub highLight_Signature($)
4299{
4300 my $Signature = $_[0];
4301 return highLight_Signature_PPos_Italic($Signature, "", 0, 0);
4302}
4303
4304sub highLight_Signature_Italic($)
4305{
4306 my $Signature = $_[0];
4307 return highLight_Signature_PPos_Italic($Signature, "", 1, 0);
4308}
4309
4310sub highLight_Signature_Italic_Color($)
4311{
4312 my $Signature = $_[0];
4313 return highLight_Signature_PPos_Italic($Signature, "", 1, 1);
4314}
4315
4316sub highLight_Signature_PPos_Italic($$$$)
4317{
4318 my ($FullSignature, $Parameter_Position, $ItalicParams, $ColorParams) = @_;
4319 my ($Signature, $SymbolVersion) = ($FullSignature, "");
4320 if($FullSignature =~ /\A(.+)[\@]+(.+)\Z/)
4321 {
4322 ($Signature, $SymbolVersion) = ($1, $2);
4323 }
4324 if($Signature=~/\Atypeinfo\W/)
4325 {
4326 return $Signature.(($SymbolVersion)?"<span class='symver'> \@ $SymbolVersion</span>":"");
4327 }
4328 if($Signature!~/\)(| const)\Z/)
4329 {
4330 return $Signature.(($SymbolVersion)?"<span class='symver'> \@ $SymbolVersion</span>":"");
4331 }
4332 $Signature =~ /(.+?)\(.*\)(| const)\Z/;
4333 my ($Begin, $End) = ($1, $2);
4334 my @Parts = ();
4335 my $Part_Num = 0;
4336 foreach my $Part (get_Signature_Parts($Signature, 1))
4337 {
4338 $Part =~ s/\A\s+|\s+\Z//g;
4339 my ($Part_Styled, $ParamName) = ($Part, "");
4340 if($Part=~/\([\*]+(\w+)\)/i)
4341 {#func-ptr
4342 $ParamName = $1;
4343 }
4344 elsif($Part=~/(\w+)[\,\)]*\Z/i)
4345 {
4346 $ParamName = $1;
4347 }
4348 if(not $ParamName)
4349 {
4350 push(@Parts, $Part);
4351 next;
4352 }
4353 if($ItalicParams and not $TName_Tid{1}{$Part} and not $TName_Tid{2}{$Part})
4354 {
4355 if(($Parameter_Position ne "") and ($Part_Num == $Parameter_Position))
4356 {
4357 $Part_Styled =~ s!(\W)$ParamName([\,\)]|\Z)!$1<span class='focus_param'>$ParamName</span>$2!ig;
4358 }
4359 elsif($ColorParams)
4360 {
4361 $Part_Styled =~ s!(\W)$ParamName([\,\)]|\Z)!$1<span class='color_param'>$ParamName</span>$2!ig;
4362 }
4363 else
4364 {
4365 $Part_Styled =~ s!(\W)$ParamName([\,\)]|\Z)!$1<span style='font-style:italic;'>$ParamName</span>$2!ig;
4366 }
4367 }
4368 $Part_Styled = "<span style='white-space:nowrap;'>".$Part_Styled."</span>";
4369 push(@Parts, $Part_Styled);
4370 $Part_Num += 1;
4371 }
4372 $Signature = $Begin."<span class='int_p'>"."(".join(" ", @Parts).")"."</span>".$End;
4373 $Signature =~ s!\[\]![<span style='padding-left:2px;'>]</span>!g;
4374 $Signature =~ s!operator=!operator<span style='padding-left:2px'>=</span>!g;
4375 $Signature =~ s!(\[in-charge\]|\[not-in-charge\]|\[in-charge-deleting\])!<span style='color:Black;font-weight:normal;'>$1</span>!g;
4376 return $Signature.(($SymbolVersion)?"<span class='symver'> \@ $SymbolVersion</span>":"");
4377}
4378
4379sub get_Signature_Parts($$)
4380{
4381 my ($Signature, $Comma) = @_;
4382 my @Parts = ();
4383 my $Bracket_Num = 0;
4384 my $Bracket2_Num = 0;
4385 my $Parameters = $Signature;
4386 if($Signature=~/&gt;|&lt;/)
4387 {
4388 $Parameters=~s/&gt;/>/g;
4389 $Parameters=~s/&lt;/</g;
4390 }
4391 my $Part_Num = 0;
4392 if($Parameters =~ s/.+?\((.*)\)(| const)\Z/$1/)
4393 {
4394 foreach my $Pos (0 .. length($Parameters) - 1)
4395 {
4396 my $Symbol = substr($Parameters, $Pos, 1);
4397 $Bracket_Num += 1 if($Symbol eq "(");
4398 $Bracket_Num -= 1 if($Symbol eq ")");
4399 $Bracket2_Num += 1 if($Symbol eq "<");
4400 $Bracket2_Num -= 1 if($Symbol eq ">");
4401 if($Symbol eq "," and $Bracket_Num==0 and $Bracket2_Num==0)
4402 {
4403 $Parts[$Part_Num] .= $Symbol if($Comma);
4404 $Part_Num += 1;
4405 }
4406 else
4407 {
4408 $Parts[$Part_Num] .= $Symbol;
4409 }
4410 }
4411 if($Signature=~/&gt;|&lt;/)
4412 {
4413 foreach my $Part (@Parts)
4414 {
4415 $Part=~s/\>/&gt;/g;
4416 $Part=~s/\</&lt;/g;
4417 }
4418 }
4419 return @Parts;
4420 }
4421 else
4422 {
4423 return ();
4424 }
4425}
4426
4427my %TypeProblems_Kind=(
4428 "Added_Virtual_Function"=>1,
4429 "Withdrawn_Virtual_Function"=>1,
4430 "Virtual_Function_Position"=>1,
4431 "Virtual_Function_Redefinition"=>1,
4432 "Virtual_Function_Redefinition_B"=>1,
4433 "Size"=>1,
4434 "Added_Member_And_Size"=>1,
4435 "Added_Middle_Member_And_Size"=>1,
4436 "Withdrawn_Member_And_Size"=>1,
4437 "Withdrawn_Member"=>1,
4438 "Withdrawn_Middle_Member_And_Size"=>1,
4439 "Member_Rename"=>1,
4440 "Enum_Member_Value"=>1,
4441 "Enum_Member_Name"=>1,
4442 "Member_Type_And_Size"=>1,
4443 "Member_Type"=>1,
4444 "Member_BaseType_And_Size"=>1,
4445 "Member_BaseType"=>1,
4446 "Member_PointerLevel"=>1,
4447 "BaseType"=>1
4448);
4449
4450my %InterfaceProblems_Kind=(
4451 "Added_Interface"=>1,
4452 "Withdrawn_Interface"=>1,
4453 "Function_Become_Static"=>1,
4454 "Function_Become_NonStatic"=>1,
4455 "Parameter_Type_And_Size"=>1,
4456 "Parameter_Type"=>1,
4457 "Parameter_BaseType_And_Size"=>1,
4458 "Parameter_BaseType"=>1,
4459 "Parameter_PointerLevel"=>1,
4460 "Return_Type_And_Size"=>1,
4461 "Return_Type"=>1,
4462 "Return_BaseType_And_Size"=>1,
4463 "Return_BaseType"=>1,
4464 "Return_PointerLevel"=>1,
4465 "Withdrawn_Parameter"=>1,
4466 "Added_Parameter"=>1
4467);
4468
4469sub testSystem_cpp()
4470{
4471 print "testing for C++ library changes\n";
4472 my (@DataDefs_v1, @Sources_v1, @DataDefs_v2, @Sources_v2) = ();
4473
4474 #Withdrawn_Parameter
4475 @DataDefs_v1 = (@DataDefs_v1, "int func_withdrawn_parameter(int param, int withdrawn_param);");
4476 @Sources_v1 = (@Sources_v1, "int func_withdrawn_parameter(int param, int withdrawn_param)\n{\n return 0;\n}");
4477
4478 @DataDefs_v2 = (@DataDefs_v2, "int func_withdrawn_parameter(int param);");
4479 @Sources_v2 = (@Sources_v2, "int func_withdrawn_parameter(int param)\n{\n return 0;\n}");
4480
4481 #Added_Parameter
4482 @DataDefs_v1 = (@DataDefs_v1, "int func_added_parameter(int param);");
4483 @Sources_v1 = (@Sources_v1, "int func_added_parameter(int param)\n{\n return 0;\n}");
4484
4485 @DataDefs_v2 = (@DataDefs_v2, "int func_added_parameter(int param, int added_param);");
4486 @Sources_v2 = (@Sources_v2, "int func_added_parameter(int param, int added_param)\n{\n return 0;\n}");
4487
4488 #Added_Virtual_Function
4489 @DataDefs_v1 = (@DataDefs_v1, "class type_test_added_virtual_function\n{\npublic:\n int func1(int param);\n virtual int func2(int param);\n};");
4490 @Sources_v1 = (@Sources_v1, "int type_test_added_virtual_function::func1(int param)\n{\n return param;\n}");
4491 @Sources_v1 = (@Sources_v1, "int type_test_added_virtual_function::func2(int param)\n{\n return param;\n}");
4492
4493 @DataDefs_v2 = (@DataDefs_v2, "class type_test_added_virtual_function\n{\npublic:\n virtual int func1(int param);\n virtual int func2(int param);\n};");
4494 @Sources_v2 = (@Sources_v2, "int type_test_added_virtual_function::func1(int param)\n{\n return param;\n}");
4495 @Sources_v2 = (@Sources_v2, "int type_test_added_virtual_function::func2(int param)\n{\n return param;\n}");
4496
4497 #added simple function
4498 @DataDefs_v2 = (@DataDefs_v2, "typedef int (*FUNCPTR_TYPE)(int a, int b);\nint added_function_param_funcptr(FUNCPTR_TYPE*const** f);");
4499 @Sources_v2 = (@Sources_v2, "int added_function_param_funcptr(FUNCPTR_TYPE*const** f)\n{\n return 0;\n}");
4500
4501 #Withdrawn_Virtual_Function
4502 @DataDefs_v1 = (@DataDefs_v1, "class type_test_withdrawn_virtual_function\n{\npublic:\n virtual int func1(int param);\n virtual int func2(int param);\n};");
4503 @Sources_v1 = (@Sources_v1, "int type_test_withdrawn_virtual_function::func1(int param)\n{\n return param;\n}");
4504 @Sources_v1 = (@Sources_v1, "int type_test_withdrawn_virtual_function::func2(int param)\n{\n return param;\n}");
4505
4506 @DataDefs_v2 = (@DataDefs_v2, "class type_test_withdrawn_virtual_function\n{\npublic:\n int func1(int param);\n virtual int func2(int param);\n};");
4507 @Sources_v2 = (@Sources_v2, "int type_test_withdrawn_virtual_function::func1(int param)\n{\n return param;\n}");
4508 @Sources_v2 = (@Sources_v2, "int type_test_withdrawn_virtual_function::func2(int param)\n{\n return param;\n}");
4509
4510 #Virtual_Function_Position
4511 @DataDefs_v1 = (@DataDefs_v1, "class type_test_virtual_function_position\n{\npublic:\n virtual int func1(int param);\n virtual int func2(int param);\n};");
4512 @Sources_v1 = (@Sources_v1, "int type_test_virtual_function_position::func1(int param)\n{\n return param;\n}");
4513 @Sources_v1 = (@Sources_v1, "int type_test_virtual_function_position::func2(int param)\n{\n return param;\n}");
4514
4515 @DataDefs_v2 = (@DataDefs_v2, "class type_test_virtual_function_position\n{\npublic:\n virtual int func2(int param);\n virtual int func1(int param);\n};");
4516 @Sources_v2 = (@Sources_v2, "int type_test_virtual_function_position::func1(int param)\n{\n return param;\n}");
4517 @Sources_v2 = (@Sources_v2, "int type_test_virtual_function_position::func2(int param)\n{\n return param;\n}");
4518
4519 #virtual functions safe replace
4520 @DataDefs_v1 = (@DataDefs_v1, "class type_test_virtual_function_position_safe_replace_base\n{\npublic:\n virtual int func1(int param);\n virtual int func2(int param);\n};");
4521 @Sources_v1 = (@Sources_v1, "int type_test_virtual_function_position_safe_replace_base::func1(int param)\n{\n return param;\n}");
4522 @Sources_v1 = (@Sources_v1, "int type_test_virtual_function_position_safe_replace_base::func2(int param)\n{\n return param;\n}");
4523
4524 @DataDefs_v2 = (@DataDefs_v2, "class type_test_virtual_function_position_safe_replace_base\n{\npublic:\n virtual int func1(int param);\n virtual int func2(int param);\n};");
4525 @Sources_v2 = (@Sources_v2, "int type_test_virtual_function_position_safe_replace_base::func1(int param)\n{\n return param;\n}");
4526 @Sources_v2 = (@Sources_v2, "int type_test_virtual_function_position_safe_replace_base::func2(int param)\n{\n return param;\n}");
4527
4528 @DataDefs_v1 = (@DataDefs_v1, "class type_test_virtual_function_position_safe_replace:public type_test_virtual_function_position_safe_replace_base\n{\npublic:\n virtual int func1(int param);\n virtual int func2(int param);\n};");
4529 @Sources_v1 = (@Sources_v1, "int type_test_virtual_function_position_safe_replace::func1(int param)\n{\n return param;\n}");
4530 @Sources_v1 = (@Sources_v1, "int type_test_virtual_function_position_safe_replace::func2(int param)\n{\n return param;\n}");
4531
4532 @DataDefs_v2 = (@DataDefs_v2, "class type_test_virtual_function_position_safe_replace:public type_test_virtual_function_position_safe_replace_base\n{\npublic:\n virtual int func2(int param);\n virtual int func1(int param);\n};");
4533 @Sources_v2 = (@Sources_v2, "int type_test_virtual_function_position_safe_replace::func1(int param)\n{\n return param;\n}");
4534 @Sources_v2 = (@Sources_v2, "int type_test_virtual_function_position_safe_replace::func2(int param)\n{\n return param;\n}");
4535
4536 #virtual table changes
4537 @DataDefs_v1 = (@DataDefs_v1, "class type_test_virtual_table_base\n{\npublic:\n virtual int func1(int param);\n virtual int func2(int param);\n};");
4538 @DataDefs_v1 = (@DataDefs_v1, "class type_test_virtual_table:public type_test_virtual_table_base\n{\npublic:\n virtual int func1(int param);\n virtual int func2(int param);\n};");
4539 @Sources_v1 = (@Sources_v1, "int type_test_virtual_table_base::func1(int param)\n{\n return param;\n}");
4540 @Sources_v1 = (@Sources_v1, "int type_test_virtual_table_base::func2(int param)\n{\n return param;\n}");
4541 @Sources_v1 = (@Sources_v1, "int type_test_virtual_table::func1(int param)\n{\n return param;\n}");
4542 @Sources_v1 = (@Sources_v1, "int type_test_virtual_table::func2(int param)\n{\n return param;\n}");
4543
4544 @DataDefs_v2 = (@DataDefs_v2, "class type_test_virtual_table_base\n{\npublic:\n virtual int func1(int param);\n virtual int func2(int param);\n};");
4545 @DataDefs_v2 = (@DataDefs_v2, "class type_test_virtual_table:public type_test_virtual_table_base\n{\npublic:\n virtual int func2(int param);\n virtual int func1(int param);\n};");
4546 @Sources_v2 = (@Sources_v2, "int type_test_virtual_table_base::func1(int param)\n{\n return param;\n}");
4547 @Sources_v2 = (@Sources_v2, "int type_test_virtual_table_base::func2(int param)\n{\n return param;\n}");
4548 @Sources_v2 = (@Sources_v2, "int type_test_virtual_table::func1(int param)\n{\n return param;\n}");
4549 @Sources_v2 = (@Sources_v2, "int type_test_virtual_table::func2(int param)\n{\n return param;\n}");
4550
4551 #Virtual_Function_Redefinition
4552 @DataDefs_v1 = (@DataDefs_v1, "class type_test_virtual_function_redefinition_base\n{\npublic:\n virtual int func1(int param);\n virtual int func2(int param);\n};");
4553 @DataDefs_v1 = (@DataDefs_v1, "class type_test_virtual_function_redefinition:public type_test_virtual_function_redefinition_base\n{\npublic:\n virtual int func3(int param);\n};");
4554 @Sources_v1 = (@Sources_v1, "int type_test_virtual_function_redefinition_base::func1(int param)\n{\n return param;\n}");
4555 @Sources_v1 = (@Sources_v1, "int type_test_virtual_function_redefinition_base::func2(int param)\n{\n return param;\n}");
4556 @Sources_v1 = (@Sources_v1, "int type_test_virtual_function_redefinition::func3(int param)\n{\n return param;\n}");
4557
4558 @DataDefs_v2 = (@DataDefs_v2, "class type_test_virtual_function_redefinition_base\n{\npublic:\n virtual int func1(int param);\n virtual int func2(int param);\n};");
4559 @DataDefs_v2 = (@DataDefs_v2, "class type_test_virtual_function_redefinition:public type_test_virtual_function_redefinition_base\n{\npublic:\n virtual int func2(int param);\n virtual int func3(int param);\n};");
4560 @Sources_v2 = (@Sources_v2, "int type_test_virtual_function_redefinition_base::func1(int param){\n return param;\n}");
4561 @Sources_v2 = (@Sources_v2, "int type_test_virtual_function_redefinition_base::func2(int param){\n return param;\n}");
4562 @Sources_v2 = (@Sources_v2, "int type_test_virtual_function_redefinition::func2(int param)\n{\n return param;\n}");
4563 @Sources_v2 = (@Sources_v2, "int type_test_virtual_function_redefinition::func3(int param)\n{\n return param;\n}");
4564
4565 #size change
4566 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_size\n{\npublic:\n virtual type_test_size func1(type_test_size param);\n int i;\n long j;\n double k;\n type_test_size* p;\n};");
4567 @Sources_v1 = (@Sources_v1, "type_test_size type_test_size::func1(type_test_size param)\n{\n return param;\n}");
4568
4569 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_size\n{\npublic:\n virtual type_test_size func1(type_test_size param);\n int i;\n long j;\n double k;\n type_test_size* p;\n int added_member;\n};");
4570 @Sources_v2 = (@Sources_v2, "type_test_size type_test_size::func1(type_test_size param)\n{\n return param;\n}");
4571
4572 #Added_Member_And_Size
4573 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_added_member\n{\npublic:\n virtual type_test_added_member func1(type_test_added_member param);\n int i;\n long j;\n double k;\n type_test_added_member* p;\n};");
4574 @Sources_v1 = (@Sources_v1, "type_test_added_member type_test_added_member::func1(type_test_added_member param)\n{\n return param;\n}");
4575
4576 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_added_member\n{\npublic:\n virtual type_test_added_member func1(type_test_added_member param);\n int i;\n long j;\n double k;\n type_test_added_member* p;\n int added_member;\n};");
4577 @Sources_v2 = (@Sources_v2, "type_test_added_member type_test_added_member::func1(type_test_added_member param)\n{\n return param;\n}");
4578
4579 #Method object changes
4580 @DataDefs_v1 = (@DataDefs_v1, "class type_test_object_added_member\n{\npublic:\n virtual int func1(int param);\n int i;\n long j;\n double k;\n type_test_added_member* p;\n};");
4581 @Sources_v1 = (@Sources_v1, "int type_test_object_added_member::func1(int param)\n{\n return param;\n}");
4582
4583 @DataDefs_v2 = (@DataDefs_v2, "class type_test_object_added_member\n{\npublic:\n virtual int func1(int param);\n int i;\n long j;\n double k;\n type_test_added_member* p;\n int added_member;\n};");
4584 @Sources_v2 = (@Sources_v2, "int type_test_object_added_member::func1(int param)\n{\n return param;\n}");
4585
4586 #added bitfield
4587 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_added_bitfield\n{\npublic:\n virtual type_test_added_bitfield func1(type_test_added_bitfield param);\n int i;\n long j;\n double k;\n int b1 : 32;\n int b2 : 31;\n type_test_added_bitfield* p;\n};");
4588 @Sources_v1 = (@Sources_v1, "type_test_added_bitfield type_test_added_bitfield::func1(type_test_added_bitfield param)\n{\n return param;\n}");
4589
4590 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_added_bitfield\n{\npublic:\n virtual type_test_added_bitfield func1(type_test_added_bitfield param);\n int i;\n long j;\n double k;\n int b1 : 32;\n int b2 : 31;\n int added_bitfield : 1;\n type_test_added_bitfield* p;\n};");
4591 @Sources_v2 = (@Sources_v2, "type_test_added_bitfield type_test_added_bitfield::func1(type_test_added_bitfield param)\n{\n return param;\n}");
4592
4593 #withdrawn bitfield
4594 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_withdrawn_bitfield\n{\npublic:\n virtual type_test_withdrawn_bitfield func1(type_test_withdrawn_bitfield param);\n int i;\n long j;\n double k;\n int b1 : 32;\n int b2 : 31;\n int withdrawn_bitfield : 1;\n type_test_withdrawn_bitfield* p;\n};");
4595 @Sources_v1 = (@Sources_v1, "type_test_withdrawn_bitfield type_test_withdrawn_bitfield::func1(type_test_withdrawn_bitfield param)\n{\n return param;\n}");
4596
4597 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_withdrawn_bitfield\n{\npublic:\n virtual type_test_withdrawn_bitfield func1(type_test_withdrawn_bitfield param);\n int i;\n long j;\n double k;\n int b1 : 32;\n int b2 : 31;\n type_test_withdrawn_bitfield* p;\n};");
4598 @Sources_v2 = (@Sources_v2, "type_test_withdrawn_bitfield type_test_withdrawn_bitfield::func1(type_test_withdrawn_bitfield param)\n{\n return param;\n}");
4599
4600 #Added_Middle_Member_And_Size
4601 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_added_middle_member\n{\npublic:\n virtual type_test_added_middle_member func1(type_test_added_middle_member param);\n int i;\n long j;\n double k;\n type_test_added_middle_member* p;\n};");
4602 @Sources_v1 = (@Sources_v1, "type_test_added_middle_member type_test_added_middle_member::func1(type_test_added_middle_member param)\n{\n return param;\n}");
4603
4604 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_added_middle_member\n{\npublic:\n virtual type_test_added_middle_member func1(type_test_added_middle_member param);\n int i;\n int added_middle_member;\n long j;\n double k;\n type_test_added_middle_member* p;\n};");
4605 @Sources_v2 = (@Sources_v2, "type_test_added_middle_member type_test_added_middle_member::func1(type_test_added_middle_member param)\n{\n return param;\n}");
4606
4607 #Member_Rename
4608 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_member_rename\n{\npublic:\n virtual type_test_member_rename func1(type_test_member_rename param);\n long i;\n long j;\n double k;\n type_test_member_rename* p;\n};");
4609 @Sources_v1 = (@Sources_v1, "type_test_member_rename type_test_member_rename::func1(type_test_member_rename param)\n{\n return param;\n}");
4610
4611 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_member_rename\n{\npublic:\n virtual type_test_member_rename func1(type_test_member_rename param);\n long renamed_member;\n long j;\n double k;\n type_test_member_rename* p;\n};");
4612 @Sources_v2 = (@Sources_v2, "type_test_member_rename type_test_member_rename::func1(type_test_member_rename param)\n{\n return param;\n}");
4613
4614 #Withdrawn_Member_And_Size
4615 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_withdrawn_member\n{\npublic:\n virtual type_test_withdrawn_member func1(type_test_withdrawn_member param);\n int i;\n long j;\n double k;\n type_test_withdrawn_member* p;\n int withdrawn_member;\n};");
4616 @Sources_v1 = (@Sources_v1, "type_test_withdrawn_member type_test_withdrawn_member::func1(type_test_withdrawn_member param)\n{\n return param;\n}");
4617
4618 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_withdrawn_member\n{\npublic:\n virtual type_test_withdrawn_member func1(type_test_withdrawn_member param);\n int i;\n long j;\n double k;\n type_test_withdrawn_member* p;\n};");
4619 @Sources_v2 = (@Sources_v2, "type_test_withdrawn_member type_test_withdrawn_member::func1(type_test_withdrawn_member param)\n{\n return param;\n}");
4620
4621 #Withdrawn_Middle_Member_And_Size
4622 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_withdrawn_middle_member\n{\npublic:\n virtual type_test_withdrawn_middle_member func1(type_test_withdrawn_middle_member param);\n int i;\n int withdrawn_middle_member;\n long j;\n double k;\n type_test_withdrawn_middle_member* p;\n};");
4623 @Sources_v1 = (@Sources_v1, "type_test_withdrawn_middle_member type_test_withdrawn_middle_member::func1(type_test_withdrawn_middle_member param)\n{\n return param;\n}");
4624
4625 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_withdrawn_middle_member\n{\npublic:\n virtual type_test_withdrawn_middle_member func1(type_test_withdrawn_middle_member param);\n int i;\n long j;\n double k;\n type_test_withdrawn_middle_member* p;\n};");
4626 @Sources_v2 = (@Sources_v2, "type_test_withdrawn_middle_member type_test_withdrawn_middle_member::func1(type_test_withdrawn_middle_member param)\n{\n return param;\n}");
4627
4628 #Enum_Member_Value
4629 @DataDefs_v1 = (@DataDefs_v1, "enum type_test_enum_member_value_change\n{\n MEMBER_1=1,\n MEMBER_2=2\n};");
4630 @DataDefs_v1 = (@DataDefs_v1, "int func_test_enum_member_value_change(enum type_test_enum_member_value_change param);");
4631 @Sources_v1 = (@Sources_v1,
4632"int func_test_enum_member_value_change(enum type_test_enum_member_value_change param)
4633{
4634 switch(param)
4635 {
4636 case 1:
4637 return 1;
4638 case 2:
4639 return 2;
4640 }
4641 return 0;
4642}");
4643
4644 @DataDefs_v2 = (@DataDefs_v2, "enum type_test_enum_member_value_change\n{\n MEMBER_1=2,\n MEMBER_2=1\n};");
4645 @DataDefs_v2 = (@DataDefs_v2, "int func_test_enum_member_value_change(enum type_test_enum_member_value_change param);");
4646 @Sources_v2 = (@Sources_v2,
4647"int func_test_enum_member_value_change(enum type_test_enum_member_value_change param)
4648{
4649 switch(param)
4650 {
4651 case 1:
4652 return 1;
4653 case 2:
4654 return 2;
4655 }
4656 return 0;
4657}");
4658
4659 #Enum_Member_Name
4660 @DataDefs_v1 = (@DataDefs_v1, "enum type_test_enum_member_rename\n{\n BRANCH_1=1,\n BRANCH_2=2\n};");
4661 @DataDefs_v1 = (@DataDefs_v1, "int func_test_enum_member_rename(enum type_test_enum_member_rename param);");
4662 @Sources_v1 = (@Sources_v1,
4663"int func_test_enum_member_rename(enum type_test_enum_member_rename param)
4664{
4665 switch(param)
4666 {
4667 case 1:
4668 return 1;
4669 case 2:
4670 return 2;
4671 }
4672 return 0;
4673}");
4674
4675 @DataDefs_v2 = (@DataDefs_v2, "enum type_test_enum_member_rename\n{\n BRANCH_FIRST=1,\n BRANCH_SECOND=1\n};");
4676 @DataDefs_v2 = (@DataDefs_v2, "int func_test_enum_member_rename(enum type_test_enum_member_rename param);");
4677 @Sources_v2 = (@Sources_v2,
4678"int func_test_enum_member_rename(enum type_test_enum_member_rename param)
4679{
4680 switch(param)
4681 {
4682 case 1:
4683 return 1;
4684 case 2:
4685 return 2;
4686 }
4687 return 0;
4688}");
4689
4690 #Member_Type_And_Size
4691 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_member_type_and_size\n{\npublic:\n type_test_member_type_and_size func1(type_test_member_type_and_size param);\n int i;\n long j;\n double k;\n type_test_member_type_and_size* p;\n};");
4692 @Sources_v1 = (@Sources_v1, "type_test_member_type_and_size type_test_member_type_and_size::func1(type_test_member_type_and_size param)\n{\n return param;\n}");
4693
4694 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_member_type_and_size\n{\npublic:\n type_test_member_type_and_size func1(type_test_member_type_and_size param);\n long long i;\n long j;\n double k;\n type_test_member_type_and_size* p;\n};");
4695 @Sources_v2 = (@Sources_v2, "type_test_member_type_and_size type_test_member_type_and_size::func1(type_test_member_type_and_size param)\n{\n return param;\n}");
4696
4697 #Member_Type
4698 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_member_type\n{\npublic:\n type_test_member_type func1(type_test_member_type param);\n int i;\n long j;\n double k;\n type_test_member_type* p;\n};");
4699 @Sources_v1 = (@Sources_v1, "type_test_member_type type_test_member_type::func1(type_test_member_type param)\n{\n return param;\n}");
4700
4701 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_member_type\n{\npublic:\n type_test_member_type func1(type_test_member_type param);\n float i;\n long j;\n double k;\n type_test_member_type* p;\n};");
4702 @Sources_v2 = (@Sources_v2, "type_test_member_type type_test_member_type::func1(type_test_member_type param)\n{\n return param;\n}");
4703
4704 #Member_BaseType
4705 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_member_basetype\n{\npublic:\n type_test_member_basetype func1(type_test_member_basetype param);\n int *i;\n long j;\n double k;\n type_test_member_basetype* p;\n};");
4706 @Sources_v1 = (@Sources_v1, "type_test_member_basetype type_test_member_basetype::func1(type_test_member_basetype param)\n{\n return param;\n}");
4707
4708 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_member_basetype\n{\npublic:\n type_test_member_basetype func1(type_test_member_basetype param);\n long long *i;\n long j;\n double k;\n type_test_member_basetype* p;\n};");
4709 @Sources_v2 = (@Sources_v2, "type_test_member_basetype type_test_member_basetype::func1(type_test_member_basetype param)\n{\n return param;\n}");
4710
4711 #Member_PointerLevel_And_Size
4712 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_member_pointerlevel_and_size\n{\npublic:\n type_test_member_pointerlevel_and_size func1(type_test_member_pointerlevel_and_size param);\n long long i;\n long j;\n double k;\n type_test_member_pointerlevel_and_size* p;\n};");
4713 @Sources_v1 = (@Sources_v1, "type_test_member_pointerlevel_and_size type_test_member_pointerlevel_and_size::func1(type_test_member_pointerlevel_and_size param)\n{\n return param;\n}");
4714
4715 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_member_pointerlevel_and_size\n{\npublic:\n type_test_member_pointerlevel_and_size func1(type_test_member_pointerlevel_and_size param);\n long long *i;\n long j;\n double k;\n type_test_member_pointerlevel_and_size* p;\n};");
4716 @Sources_v2 = (@Sources_v2, "type_test_member_pointerlevel_and_size type_test_member_pointerlevel_and_size::func1(type_test_member_pointerlevel_and_size param)\n{\n return param;\n}");
4717
4718 #Member_PointerLevel
4719 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_member_pointerlevel\n{\npublic:\n type_test_member_pointerlevel func1(type_test_member_pointerlevel param);\n int **i;\n long j;\n double k;\n type_test_member_pointerlevel* p;\n};");
4720 @Sources_v1 = (@Sources_v1, "type_test_member_pointerlevel type_test_member_pointerlevel::func1(type_test_member_pointerlevel param)\n{\n return param;\n}");
4721
4722 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_member_pointerlevel\n{\npublic:\n type_test_member_pointerlevel func1(type_test_member_pointerlevel param);\n int *i;\n long j;\n double k;\n type_test_member_pointerlevel* p;\n};");
4723 @Sources_v2 = (@Sources_v2, "type_test_member_pointerlevel type_test_member_pointerlevel::func1(type_test_member_pointerlevel param)\n{\n return param;\n}");
4724
4725 #Added_Interface (function)
4726 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_added_interface\n{\npublic:\n type_test_added_interface func1(type_test_added_interface param);\n int i;\n long j;\n double k;\n type_test_added_interface* p;\n};");
4727 @Sources_v1 = (@Sources_v1, "type_test_added_interface type_test_added_interface::func1(type_test_added_interface param)\n{\n return param;\n}");
4728
4729 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_added_interface\n{\npublic:\n type_test_added_interface func1(type_test_added_interface param);\n type_test_added_interface added_func(type_test_added_interface param);\n int i;\n long j;\n double k;\n type_test_added_interface* p;\n};");
4730 @DataDefs_v2 = (@DataDefs_v2, "int added_func_2(void *** param);");
4731 @Sources_v2 = (@Sources_v2, "type_test_added_interface type_test_added_interface::func1(type_test_added_interface param)\n{\n return param;\n}");
4732 @Sources_v2 = (@Sources_v2, "type_test_added_interface type_test_added_interface::added_func(type_test_added_interface param)\n{\n return param;\n}");
4733 @Sources_v2 = (@Sources_v2, "int added_func_2(void *** param)\n{\n return 0;\n}");
4734
4735 #Added_Interface (global variable)
4736 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_added_variable\n{\npublic:\n int func1(type_test_added_variable param);\n int i;\n long j;\n double k;\n type_test_added_variable* p;\n};");
4737 @Sources_v1 = (@Sources_v1, "int type_test_added_variable::func1(type_test_added_variable param)\n{\n return i;\n}");
4738
4739 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_added_variable\n{\npublic:\n int func1(type_test_added_variable param);\n static int i;\n long j;\n double k;\n type_test_added_variable* p;\n};");
4740 @Sources_v2 = (@Sources_v2, "int type_test_added_variable::func1(type_test_added_variable param)\n{\n return type_test_added_variable::i;\n}");
4741 @Sources_v2 = (@Sources_v2, "int type_test_added_variable::i=0;");
4742
4743 #Withdrawn_Interface
4744 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_withdrawn_interface\n{\npublic:\n type_test_withdrawn_interface func1(type_test_withdrawn_interface param);\n type_test_withdrawn_interface withdrawn_func(type_test_withdrawn_interface param);\n int i;\n long j;\n double k;\n type_test_withdrawn_interface* p;\n};");
4745 @DataDefs_v1 = (@DataDefs_v1, "int withdrawn_func_2(void *** param);");
4746 @Sources_v1 = (@Sources_v1, "type_test_withdrawn_interface type_test_withdrawn_interface::func1(type_test_withdrawn_interface param)\n{\n return param;\n}");
4747 @Sources_v1 = (@Sources_v1, "type_test_withdrawn_interface type_test_withdrawn_interface::withdrawn_func(type_test_withdrawn_interface param)\n{\n return param;\n}");
4748 @Sources_v1 = (@Sources_v1, "int withdrawn_func_2(void *** param)\n{\n return 0;\n}");
4749
4750 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_withdrawn_interface\n{\npublic:\n type_test_withdrawn_interface func1(type_test_withdrawn_interface param);\n int i;\n long j;\n double k;\n type_test_withdrawn_interface* p;\n};");
4751 @Sources_v2 = (@Sources_v2, "type_test_withdrawn_interface type_test_withdrawn_interface::func1(type_test_withdrawn_interface param)\n{\n return param;\n}");
4752
4753 #Function_Become_Static
4754 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_become_static\n{\npublic:\n type_test_become_static func_become_static(type_test_become_static param);\n int **i;\n long j;\n double k;\n type_test_become_static* p;\n};");
4755 @Sources_v1 = (@Sources_v1, "type_test_become_static type_test_become_static::func_become_static(type_test_become_static param)\n{\n return param;\n}");
4756
4757 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_become_static\n{\npublic:\n static type_test_become_static func_become_static(type_test_become_static param);\n int **i;\n long j;\n double k;\n type_test_become_static* p;\n};");
4758 @Sources_v2 = (@Sources_v2, "type_test_become_static type_test_become_static::func_become_static(type_test_become_static param)\n{\n return param;\n}");
4759
4760 #Function_Become_NonStatic
4761 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_become_nonstatic\n{\npublic:\n static type_test_become_nonstatic func_become_nonstatic(type_test_become_nonstatic param);\n int **i;\n long j;\n double k;\n type_test_become_nonstatic* p;\n};");
4762 @Sources_v1 = (@Sources_v1, "type_test_become_nonstatic type_test_become_nonstatic::func_become_nonstatic(type_test_become_nonstatic param)\n{\n return param;\n}");
4763
4764 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_become_nonstatic\n{\npublic:\n type_test_become_nonstatic func_become_nonstatic(type_test_become_nonstatic param);\n int **i;\n long j;\n double k;\n type_test_become_nonstatic* p;\n};");
4765 @Sources_v2 = (@Sources_v2, "type_test_become_nonstatic type_test_become_nonstatic::func_become_nonstatic(type_test_become_nonstatic param)\n{\n return param;\n}");
4766
4767 #Parameter_Type_And_Size
4768 @DataDefs_v1 = (@DataDefs_v1, "int func_parameter_type_and_size(int param, int other_param);");
4769 @Sources_v1 = (@Sources_v1, "int func_parameter_type_and_size(int param, int other_param)\n{\n return other_param;\n}");
4770
4771 @DataDefs_v2 = (@DataDefs_v2, "int func_parameter_type_and_size(long long param, int other_param);");
4772 @Sources_v2 = (@Sources_v2, "int func_parameter_type_and_size(long long param, int other_param)\n{\n return other_param;\n}");
4773
4774 #Parameter_Type
4775 @DataDefs_v1 = (@DataDefs_v1, "int func_parameter_type(int param, int other_param);");
4776 @Sources_v1 = (@Sources_v1, "int func_parameter_type(int param, int other_param)\n{\n return other_param;\n}");
4777
4778 @DataDefs_v2 = (@DataDefs_v2, "int func_parameter_type(float param, int other_param);");
4779 @Sources_v2 = (@Sources_v2, "int func_parameter_type(float param, int other_param)\n{\n return other_param;\n}");
4780
4781 #Parameter_BaseType
4782 @DataDefs_v1 = (@DataDefs_v1, "int func_parameter_basetypechange(int *param);");
4783 @Sources_v1 = (@Sources_v1, "int func_parameter_basetypechange(int *param)\n{\n return sizeof(*param);\n}");
4784
4785 @DataDefs_v2 = (@DataDefs_v2, "int func_parameter_basetypechange(long long *param);");
4786 @Sources_v2 = (@Sources_v2, "int func_parameter_basetypechange(long long *param)\n{\n return sizeof(*param);\n}");
4787
4788 #Parameter_PointerLevel_And_Size
4789 @DataDefs_v1 = (@DataDefs_v1, "long long func_parameter_pointerlevel_and_size(long long param);");
4790 @Sources_v1 = (@Sources_v1, "long long func_parameter_pointerlevel_and_size(long long param)\n{\n return param;\n}");
4791
4792 @DataDefs_v2 = (@DataDefs_v2, "long long func_parameter_pointerlevel_and_size(long long *param);");
4793 @Sources_v2 = (@Sources_v2, "long long func_parameter_pointerlevel_and_size(long long *param)\n{\n return param[5];\n}");
4794
4795 #Parameter_PointerLevel
4796 @DataDefs_v1 = (@DataDefs_v1, "int func_parameter_pointerlevel(int *param);");
4797 @Sources_v1 = (@Sources_v1, "int func_parameter_pointerlevel(int *param)\n{\n return param[5];\n}");
4798
4799 @DataDefs_v2 = (@DataDefs_v2, "int func_parameter_pointerlevel(int **param);");
4800 @Sources_v2 = (@Sources_v2, "int func_parameter_pointerlevel(int **param)\n{\n return param[5][5];\n}");
4801
4802 #Return_Type_And_Size
4803 @DataDefs_v1 = (@DataDefs_v1, "int func_return_type_and_size(int param);");
4804 @Sources_v1 = (@Sources_v1, "int func_return_type_and_size(int param)\n{\n return 2^(sizeof(int)*8-1)-1;\n}");
4805
4806 @DataDefs_v2 = (@DataDefs_v2, "long long func_return_type_and_size(int param);");
4807 @Sources_v2 = (@Sources_v2, "long long func_return_type_and_size(int param)\n{\n return 2^(sizeof(long long)*8-1)-1;\n}");
4808
4809 #Return_Type
4810 @DataDefs_v1 = (@DataDefs_v1, "int func_return_type(int param);");
4811 @Sources_v1 = (@Sources_v1, "int func_return_type(int param)\n{\n return 2^(sizeof(int)*8-1)-1;\n}");
4812
4813 @DataDefs_v2 = (@DataDefs_v2, "float func_return_type(int param);");
4814 @Sources_v2 = (@Sources_v2, "float func_return_type(int param)\n{\n return 0.7;\n}");
4815
4816 #Return_BaseType
4817 @DataDefs_v1 = (@DataDefs_v1, "int *func_return_basetype(int param);");
4818 @Sources_v1 = (@Sources_v1, "int *func_return_basetype(int param)\n{\n int *x = new int[10];\n return x;\n}");
4819
4820 @DataDefs_v2 = (@DataDefs_v2, "long long *func_return_basetype(int param);");
4821 @Sources_v2 = (@Sources_v2, "long long *func_return_basetype(int param)\n{\n long long *x = new long long[10];\n return x;\n}");
4822
4823 #Return_PointerLevel_And_Size
4824 @DataDefs_v1 = (@DataDefs_v1, "long long func_return_pointerlevel_and_size(int param);");
4825 @Sources_v1 = (@Sources_v1, "long long func_return_pointerlevel_and_size(int param)\n{\n return 100;\n}");
4826
4827 @DataDefs_v2 = (@DataDefs_v2, "long long *func_return_pointerlevel_and_size(int param);");
4828 @Sources_v2 = (@Sources_v2, "long long *func_return_pointerlevel_and_size(int param)\n{\n long long* x = new long long[10];\n return x;\n}");
4829
4830 #Return_PointerLevel
4831 @DataDefs_v1 = (@DataDefs_v1, "int* func_return_pointerlevel(int param);");
4832 @Sources_v1 = (@Sources_v1, "int* func_return_pointerlevel(int param)\n{\n int* x = new int[10];\n return x;\n}");
4833
4834 @DataDefs_v2 = (@DataDefs_v2, "int **func_return_pointerlevel(int param);");
4835 @Sources_v2 = (@Sources_v2, "int **func_return_pointerlevel(int param)\n{\n int** x = new int*[10];\n return x;\n}");
4836
4837 #typedef to anon struct
4838 @DataDefs_v1 = (@DataDefs_v1, "
4839typedef struct
4840{
4841public:
4842 int i;
4843 long j;
4844 double k;
4845} type_test_anon_typedef;
4846int func_test_anon_typedef(type_test_anon_typedef param);");
4847 @Sources_v1 = (@Sources_v1, "int func_test_anon_typedef(type_test_anon_typedef param)\n{\n return 0;\n}");
4848
4849 @DataDefs_v2 = (@DataDefs_v2, "
4850typedef struct
4851{
4852public:
4853 int i;
4854 long j;
4855 double k;
4856 union {
4857 int dummy[256];
4858 struct {
4859 char q_skiptable[256];
4860 const char *p;
4861 int l;
4862 } p;
4863 };
4864} type_test_anon_typedef;
4865int func_test_anon_typedef(type_test_anon_typedef param);");
4866 @Sources_v2 = (@Sources_v2, "int func_test_anon_typedef(type_test_anon_typedef param)\n{\n return 0;\n}");
4867
4868 #opaque type
4869 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_opaque\n{\npublic:\n virtual type_test_opaque func1(type_test_opaque param);\n int i;\n long j;\n double k;\n type_test_opaque* p;\n};");
4870 @Sources_v1 = (@Sources_v1, "type_test_opaque type_test_opaque::func1(type_test_opaque param)\n{\n return param;\n}");
4871
4872 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_opaque\n{\npublic:\n virtual type_test_opaque func1(type_test_opaque param);\n int i;\n long j;\n double k;\n type_test_opaque* p;\n int added_member;\n};");
4873 @Sources_v2 = (@Sources_v2, "type_test_opaque type_test_opaque::func1(type_test_opaque param)\n{\n return param;\n}");
4874
4875 #internal function
4876 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_internal\n{\npublic:\n virtual type_test_internal func1(type_test_internal param);\n int i;\n long j;\n double k;\n type_test_internal* p;\n};");
4877 @Sources_v1 = (@Sources_v1, "type_test_internal type_test_internal::func1(type_test_internal param)\n{\n return param;\n}");
4878
4879 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_internal\n{\npublic:\n virtual type_test_internal func1(type_test_internal param);\n int i;\n long j;\n double k;\n type_test_internal* p;\n int added_member;\n};");
4880 @Sources_v2 = (@Sources_v2, "type_test_internal type_test_internal::func1(type_test_internal param)\n{\n return param;\n}");
4881
4882 #starting versioning
4883 @DataDefs_v1 = (@DataDefs_v1, "int func_return_type_and_start_versioning(int param);");
4884 @Sources_v1 = (@Sources_v1, "int func_return_type_and_start_versioning(int param)\n{\n return 2^(sizeof(int)*8-1)-1;\n}");
4885
4886 @DataDefs_v2 = (@DataDefs_v2, "int func_return_type_and_start_versioning(int param);");
4887 @Sources_v2 = (@Sources_v2, "int func_return_type_and_start_versioning(int param)\n{\n return 2^(sizeof(int)*8-1)-1;\n}\n__asm__(\".symver _Z37func_return_type_and_start_versioningi,_Z37func_return_type_and_start_versioningi\@TEST_2.0\");");
4888
4889 #Return_Type And Good Versioning
4890 @DataDefs_v1 = (@DataDefs_v1, "int func_return_type_and_good_versioning(int param);");
4891 @Sources_v1 = (@Sources_v1, "int func_return_type_and_good_versioning(int param)\n{\n return 2^(sizeof(int)*8-1)-1;\n}\n__asm__(\".symver _Z36func_return_type_and_good_versioningi,_Z36func_return_type_and_good_versioningi\@TEST_1.0\");");
4892
4893 @DataDefs_v2 = (@DataDefs_v2, "int func_return_type_and_good_versioning_old(int param);");
4894 @Sources_v2 = (@Sources_v2, "int func_return_type_and_good_versioning_old(int param)\n{\n return 2^(sizeof(int)*8-1)-1;\n}\n__asm__(\".symver _Z40func_return_type_and_good_versioning_oldi,_Z36func_return_type_and_good_versioningi\@TEST_1.0\");");
4895
4896 @DataDefs_v2 = (@DataDefs_v2, "float func_return_type_and_good_versioning(int param);");
4897 @Sources_v2 = (@Sources_v2, "float func_return_type_and_good_versioning(int param)\n{\n return 0.7;\n}\n__asm__(\".symver _Z36func_return_type_and_good_versioningi,_Z36func_return_type_and_good_versioningi\@TEST_2.0\");");
4898
4899 #Return_Type and bad versioning
4900 @DataDefs_v1 = (@DataDefs_v1, "int func_return_type_and_bad_versioning(int param);");
4901 @Sources_v1 = (@Sources_v1, "int func_return_type_and_bad_versioning(int param)\n{\n return 2^(sizeof(int)*8-1)-1;\n}\n__asm__(\".symver _Z35func_return_type_and_bad_versioningi,_Z35func_return_type_and_bad_versioningi\@TEST_1.0\");");
4902
4903 @DataDefs_v2 = (@DataDefs_v2, "float func_return_type_and_bad_versioning_old(int param);");
4904 @Sources_v2 = (@Sources_v2, "float func_return_type_and_bad_versioning_old(int param)\n{\n return 0.7;\n}\n__asm__(\".symver _Z39func_return_type_and_bad_versioning_oldi,_Z35func_return_type_and_bad_versioningi\@TEST_1.0\");");
4905
4906 @DataDefs_v2 = (@DataDefs_v2, "float func_return_type_and_bad_versioning(int param);");
4907 @Sources_v2 = (@Sources_v2, "float func_return_type_and_bad_versioning(int param)\n{\n return 0.7;\n}\n__asm__(\".symver _Z35func_return_type_and_bad_versioningi,_Z35func_return_type_and_bad_versioningi\@TEST_2.0\");");
4908
4909 #unnamed struct fields within structs
4910 @DataDefs_v1 = (@DataDefs_v1, "
4911typedef struct {
4912 int a;
4913 struct {
4914 int b;
4915 float c;
4916 };
4917 int d;
4918} type_test_unnamed;
4919int func_test_unnamed(type_test_unnamed param);");
4920 @Sources_v1 = (@Sources_v1, "int func_test_unnamed(type_test_unnamed param)\n{\n return 0;\n}");
4921
4922 @DataDefs_v2 = (@DataDefs_v2, "
4923typedef struct {
4924 int a;
4925 struct {
4926 long double b;
4927 float c;
4928 };
4929 int d;
4930} type_test_unnamed;
4931int func_test_unnamed(type_test_unnamed param);");
4932 @Sources_v2 = (@Sources_v2, "int func_test_unnamed(type_test_unnamed param)\n{\n return 0;\n}");
4933
4934 #constants
4935 @DataDefs_v1 = (@DataDefs_v1, "#define TEST_PUBLIC_CONSTANT \"old_value\"");
4936 @DataDefs_v2 = (@DataDefs_v2, "#define TEST_PUBLIC_CONSTANT \"new_value\"");
4937
4938 @DataDefs_v1 = (@DataDefs_v1, "#define TEST_PRIVATE_CONSTANT \"old_value\"\n#undef TEST_PRIVATE_CONSTANT");
4939 @DataDefs_v2 = (@DataDefs_v2, "#define TEST_PRIVATE_CONSTANT \"new_value\"\n#undef TEST_PRIVATE_CONSTANT");
4940
4941 #unions
4942 @DataDefs_v1 = (@DataDefs_v1, "
4943union type_test_union {
4944 int a;
4945 struct {
4946 int b;
4947 float c;
4948 };
4949 int d;
4950};
4951int func_test_union(type_test_union param);");
4952 @Sources_v1 = (@Sources_v1, "int func_test_union(type_test_union param)\n{\n return 0;\n}");
4953
4954 @DataDefs_v2 = (@DataDefs_v2, "
4955union type_test_union {
4956 int a;
4957 long double new_member;
4958 struct {
4959 int b;
4960 float c;
4961 };
4962 int d;
4963};
4964int func_test_union(type_test_union param);");
4965 @Sources_v2 = (@Sources_v2, "int func_test_union(type_test_union param)\n{\n return 0;\n}");
4966
4967 #typedefs
4968 @DataDefs_v1 = (@DataDefs_v1, "typedef float TYPEDEF_TYPE;\nint func_parameter_typedef_change(TYPEDEF_TYPE param);");
4969 @Sources_v1 = (@Sources_v1, "int func_parameter_typedef_change(TYPEDEF_TYPE param)\n{\n return 1;\n}");
4970
4971 @DataDefs_v2 = (@DataDefs_v2, "typedef int TYPEDEF_TYPE;\nint func_parameter_typedef_change(TYPEDEF_TYPE param);");
4972 @Sources_v2 = (@Sources_v2, "int func_parameter_typedef_change(TYPEDEF_TYPE param)\n{\n return 1;\n}");
4973
4974 #typedefs in member type
4975 @DataDefs_v1 = (@DataDefs_v1, "typedef float TYPEDEF_TYPE_2;\nstruct type_test_member_typedef_change{\n public:\nTYPEDEF_TYPE_2 m;};\nint func_test_member_typedef_change(type_test_member_typedef_change param);");
4976 @Sources_v1 = (@Sources_v1, "int func_test_member_typedef_change(type_test_member_typedef_change param)\n{\n return 1;\n}");
4977
4978 @DataDefs_v2 = (@DataDefs_v2, "typedef int TYPEDEF_TYPE_2;\nstruct type_test_member_typedef_change{\n public:\nTYPEDEF_TYPE_2 m;};\nint func_test_member_typedef_change(type_test_member_typedef_change param);");
4979 @Sources_v2 = (@Sources_v2, "int func_test_member_typedef_change(type_test_member_typedef_change param)\n{\n return 1;\n}");
4980
4981 create_TestSuite("abi_changes_test_cpp", "C++", join("\n\n", @DataDefs_v1), join("\n\n", @Sources_v1), join("\n\n", @DataDefs_v2), join("\n\n", @Sources_v2), "type_test_opaque", "_ZN18type_test_internal5func1ES_");
4982}
4983
4984sub testSystem_c()
4985{
4986 print "\ntesting for C library changes\n";
4987 my (@DataDefs_v1, @Sources_v1, @DataDefs_v2, @Sources_v2) = ();
4988
4989 #Withdrawn_Parameter
4990 @DataDefs_v1 = (@DataDefs_v1, "int func_withdrawn_parameter(int param, int withdrawn_param);");
4991 @Sources_v1 = (@Sources_v1, "int func_withdrawn_parameter(int param, int withdrawn_param)\n{\n return 0;\n}");
4992
4993 @DataDefs_v2 = (@DataDefs_v2, "int func_withdrawn_parameter(int param);");
4994 @Sources_v2 = (@Sources_v2, "int func_withdrawn_parameter(int param)\n{\n return 0;\n}");
4995
4996 #Added_Parameter
4997 @DataDefs_v1 = (@DataDefs_v1, "int func_added_parameter(int param);");
4998 @Sources_v1 = (@Sources_v1, "int func_added_parameter(int param)\n{\n return 0;\n}");
4999
5000 @DataDefs_v2 = (@DataDefs_v2, "int func_added_parameter(int param, int added_param);");
5001 @Sources_v2 = (@Sources_v2, "int func_added_parameter(int param, int added_param)\n{\n return 0;\n}");
5002
5003 #added function with typedef funcptr parameter
5004 @DataDefs_v2 = (@DataDefs_v2, "typedef int (*FUNCPTR_TYPE)(int a, int b);\nint added_function_param_typedef_funcptr(FUNCPTR_TYPE*const** f);");
5005 @Sources_v2 = (@Sources_v2, "int added_function_param_typedef_funcptr(FUNCPTR_TYPE*const** f)\n{\n return 0;\n}");
5006
5007 #added function with funcptr parameter
5008 @DataDefs_v2 = (@DataDefs_v2, "int added_function_param_funcptr(int(*func)(int, int));");
5009 @Sources_v2 = (@Sources_v2, "int added_function_param_funcptr(int(*func)(int, int))\n{\n return 0;\n}");
5010
5011 #added function with no limited parameters
5012 @DataDefs_v2 = (@DataDefs_v2, "int added_function_nolimit_param(float p1, ...);");
5013 @Sources_v2 = (@Sources_v2, "int added_function_nolimit_param(float p1, ...)\n{\n return 0;\n}");
5014
5015 #size change
5016 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_size\n{\n long long i[5];\n long j;\n double k;\n struct type_test_size* p;\n};");
5017 @DataDefs_v1 = (@DataDefs_v1, "int func_test_type_size(struct type_test_size param, int param_2);");
5018 @Sources_v1 = (@Sources_v1, "int func_test_type_size(struct type_test_size param, int param_2)\n{\n return param_2;\n}");
5019
5020 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_size\n{\n long long i[5];\n long long j;\n double k;\n struct type_test_size* p;\n};");
5021 @DataDefs_v2 = (@DataDefs_v2, "int func_test_type_size(struct type_test_size param, int param_2);");
5022 @Sources_v2 = (@Sources_v2, "int func_test_type_size(struct type_test_size param, int param_2)\n{\n return param_2;\n}");
5023
5024 #Added_Member_And_Size
5025 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_added_member\n{\n int i;\n long j;\n double k;\n struct type_test_added_member* p;\n};");
5026 @DataDefs_v1 = (@DataDefs_v1, "int func_test_added_member(struct type_test_added_member param, int param_2);");
5027 @Sources_v1 = (@Sources_v1, "int func_test_added_member(struct type_test_added_member param, int param_2)\n{\n return param_2;\n}");
5028
5029 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_added_member\n{\n int i;\n long j;\n double k;\n struct type_test_added_member* p;\n int added_member;\n};");
5030 @DataDefs_v2 = (@DataDefs_v2, "int func_test_added_member(struct type_test_added_member param, int param_2);");
5031 @Sources_v2 = (@Sources_v2, "int func_test_added_member(struct type_test_added_member param, int param_2)\n{\n return param_2;\n}");
5032
5033 #Added_Middle_Member_And_Size
5034 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_added_middle_member\n{\n int i;\n long j;\n double k;\n struct type_test_added_member* p;\n};");
5035 @DataDefs_v1 = (@DataDefs_v1, "int func_test_added_middle_member(struct type_test_added_middle_member param, int param_2);");
5036 @Sources_v1 = (@Sources_v1, "int func_test_added_middle_member(struct type_test_added_middle_member param, int param_2)\n{\n return param_2;\n}");
5037
5038 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_added_middle_member\n{\n int i;\n int added_middle_member;\n long j;\n double k;\n struct type_test_added_member* p;\n};");
5039 @DataDefs_v2 = (@DataDefs_v2, "int func_test_added_middle_member(struct type_test_added_middle_member param, int param_2);");
5040 @Sources_v2 = (@Sources_v2, "int func_test_added_middle_member(struct type_test_added_middle_member param, int param_2)\n{\n return param_2;\n}");
5041
5042 #Member_Rename
5043 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_member_rename\n{\n long i;\n long j;\n double k;\n struct type_test_member_rename* p;\n};");
5044 @DataDefs_v1 = (@DataDefs_v1, "int func_test_member_rename(struct type_test_member_rename param, int param_2);");
5045 @Sources_v1 = (@Sources_v1, "int func_test_member_rename(struct type_test_member_rename param, int param_2)\n{\n return param_2;\n}");
5046
5047 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_member_rename\n{\n long renamed_member;\n long j;\n double k;\n struct type_test_member_rename* p;\n};");
5048 @DataDefs_v2 = (@DataDefs_v2, "int func_test_member_rename(struct type_test_member_rename param, int param_2);");
5049 @Sources_v2 = (@Sources_v2, "int func_test_member_rename(struct type_test_member_rename param, int param_2)\n{\n return param_2;\n}");
5050
5051 #Withdrawn_Member_And_Size
5052 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_withdrawn_member\n{\n int i;\n long j;\n double k;\n struct type_test_withdrawn_member* p;\n int withdrawn_member;\n};");
5053 @DataDefs_v1 = (@DataDefs_v1, "int func_test_withdrawn_member(struct type_test_withdrawn_member param, int param_2);");
5054 @Sources_v1 = (@Sources_v1, "int func_test_withdrawn_member(struct type_test_withdrawn_member param, int param_2)\n{\n return param_2;\n}");
5055
5056 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_withdrawn_member\n{\n int i;\n long j;\n double k;\n struct type_test_withdrawn_member* p;\n};");
5057 @DataDefs_v2 = (@DataDefs_v2, "int func_test_withdrawn_member(struct type_test_withdrawn_member param, int param_2);");
5058 @Sources_v2 = (@Sources_v2, "int func_test_withdrawn_member(struct type_test_withdrawn_member param, int param_2)\n{\n return param_2;\n}");
5059
5060 #Withdrawn_Middle_Member
5061 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_withdrawn_middle_member\n{\n int i;\n int withdrawn_middle_member;\n long j;\n double k;\n struct type_test_withdrawn_middle_member* p;\n};");
5062 @DataDefs_v1 = (@DataDefs_v1, "int func_test_withdrawn_middle_member(struct type_test_withdrawn_middle_member param, int param_2);");
5063 @Sources_v1 = (@Sources_v1, "int func_test_withdrawn_middle_member(struct type_test_withdrawn_middle_member param, int param_2)\n{\n return param_2;\n}");
5064
5065 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_withdrawn_middle_member\n{\n int i;\n long j;\n double k;\n struct type_test_withdrawn_middle_member* p;\n};");
5066 @DataDefs_v2 = (@DataDefs_v2, "int func_test_withdrawn_middle_member(struct type_test_withdrawn_middle_member param, int param_2);");
5067 @Sources_v2 = (@Sources_v2, "int func_test_withdrawn_middle_member(struct type_test_withdrawn_middle_member param, int param_2)\n{\n return param_2;\n}");
5068
5069 #Enum_Member_Value
5070 @DataDefs_v1 = (@DataDefs_v1, "enum type_test_enum_member_value_change\n{\n MEMBER_1=1,\n MEMBER_2=2\n};");
5071 @DataDefs_v1 = (@DataDefs_v1, "int func_test_enum_member_value_change(enum type_test_enum_member_value_change param);");
5072 @Sources_v1 = (@Sources_v1,
5073"int func_test_enum_member_value_change(enum type_test_enum_member_value_change param)
5074{
5075 switch(param)
5076 {
5077 case 1:
5078 return 1;
5079 case 2:
5080 return 2;
5081 }
5082 return 0;
5083}");
5084
5085 @DataDefs_v2 = (@DataDefs_v2, "enum type_test_enum_member_value_change\n{\n MEMBER_1=2,\n MEMBER_2=1\n};");
5086 @DataDefs_v2 = (@DataDefs_v2, "int func_test_enum_member_value_change(enum type_test_enum_member_value_change param);");
5087 @Sources_v2 = (@Sources_v2,
5088"int func_test_enum_member_value_change(enum type_test_enum_member_value_change param)
5089{
5090 switch(param)
5091 {
5092 case 1:
5093 return 1;
5094 case 2:
5095 return 2;
5096 }
5097 return 0;
5098}");
5099
5100 #Enum_Member_Name
5101 @DataDefs_v1 = (@DataDefs_v1, "enum type_test_enum_member_rename\n{\n BRANCH_1=1,\n BRANCH_2=2\n};");
5102 @DataDefs_v1 = (@DataDefs_v1, "int func_test_enum_member_rename(enum type_test_enum_member_rename param);");
5103 @Sources_v1 = (@Sources_v1,
5104"int func_test_enum_member_rename(enum type_test_enum_member_rename param)
5105{
5106 switch(param)
5107 {
5108 case 1:
5109 return 1;
5110 case 2:
5111 return 2;
5112 }
5113 return 0;
5114}");
5115
5116 @DataDefs_v2 = (@DataDefs_v2, "enum type_test_enum_member_rename\n{\n BRANCH_FIRST=1,\n BRANCH_SECOND=1\n};");
5117 @DataDefs_v2 = (@DataDefs_v2, "int func_test_enum_member_rename(enum type_test_enum_member_rename param);");
5118 @Sources_v2 = (@Sources_v2,
5119"int func_test_enum_member_rename(enum type_test_enum_member_rename param)
5120{
5121 switch(param)
5122 {
5123 case 1:
5124 return 1;
5125 case 2:
5126 return 2;
5127 }
5128 return 0;
5129}");
5130
5131 #Member_Type_And_Size
5132 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_member_type_and_size\n{\n int i;\n long j;\n double k;\n struct type_test_member_type_and_size* p;\n};");
5133 @DataDefs_v1 = (@DataDefs_v1, "int func_test_member_type_and_size(struct type_test_member_type_and_size param, int param_2);");
5134 @Sources_v1 = (@Sources_v1, "int func_test_member_type_and_size(struct type_test_member_type_and_size param, int param_2)\n{\n return param_2;\n}");
5135
5136 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_member_type_and_size\n{\n int i;\n long j;\n long double k;\n struct type_test_member_type_and_size* p;\n};");
5137 @DataDefs_v2 = (@DataDefs_v2, "int func_test_member_type_and_size(struct type_test_member_type_and_size param, int param_2);");
5138 @Sources_v2 = (@Sources_v2, "int func_test_member_type_and_size(struct type_test_member_type_and_size param, int param_2)\n{\n return param_2;\n}");
5139
5140 #Member_Type
5141 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_member_type\n{\n int i;\n long j;\n double k;\n struct type_test_member_type* p;\n};");
5142 @DataDefs_v1 = (@DataDefs_v1, "int func_test_member_type(struct type_test_member_type param, int param_2);");
5143 @Sources_v1 = (@Sources_v1, "int func_test_member_type(struct type_test_member_type param, int param_2)\n{\n return param_2;\n}");
5144
5145 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_member_type\n{\n float i;\n long j;\n double k;\n struct type_test_member_type* p;\n};");
5146 @DataDefs_v2 = (@DataDefs_v2, "int func_test_member_type(struct type_test_member_type param, int param_2);");
5147 @Sources_v2 = (@Sources_v2, "int func_test_member_type(struct type_test_member_type param, int param_2)\n{\n return param_2;\n}");
5148
5149 #Member_BaseType
5150 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_member_basetype\n{\n int i;\n long *j;\n double k;\n struct type_test_member_basetype* p;\n};");
5151 @DataDefs_v1 = (@DataDefs_v1, "int func_test_member_basetype(struct type_test_member_basetype param, int param_2);");
5152 @Sources_v1 = (@Sources_v1, "int func_test_member_basetype(struct type_test_member_basetype param, int param_2)\n{\n return param_2;\n}");
5153
5154 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_member_basetype\n{\n int i;\n long long *j;\n double k;\n struct type_test_member_basetype* p;\n};");
5155 @DataDefs_v2 = (@DataDefs_v2, "int func_test_member_basetype(struct type_test_member_basetype param, int param_2);");
5156 @Sources_v2 = (@Sources_v2, "int func_test_member_basetype(struct type_test_member_basetype param, int param_2)\n{\n return param_2;\n}");
5157
5158 #Member_PointerLevel_And_Size
5159 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_member_pointerlevel_and_size\n{\n int i;\n long long j;\n double k;\n struct type_test_member_pointerlevel_and_size* p;\n};");
5160 @DataDefs_v1 = (@DataDefs_v1, "int func_test_member_pointerlevel_and_size(struct type_test_member_pointerlevel_and_size param, int param_2);");
5161 @Sources_v1 = (@Sources_v1, "int func_test_member_pointerlevel_and_size(struct type_test_member_pointerlevel_and_size param, int param_2)\n{\n return param_2;\n}");
5162
5163 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_member_pointerlevel_and_size\n{\n int i;\n long long *j;\n double k;\n struct type_test_member_pointerlevel_and_size* p;\n};");
5164 @DataDefs_v2 = (@DataDefs_v2, "int func_test_member_pointerlevel_and_size(struct type_test_member_pointerlevel_and_size param, int param_2);");
5165 @Sources_v2 = (@Sources_v2, "int func_test_member_pointerlevel_and_size(struct type_test_member_pointerlevel_and_size param, int param_2)\n{\n return param_2;\n}");
5166
5167 #Member_PointerLevel
5168 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_member_pointerlevel\n{\n int i;\n long *j;\n double k;\n struct type_test_member_pointerlevel* p;\n};");
5169 @DataDefs_v1 = (@DataDefs_v1, "int func_test_member_pointerlevel(struct type_test_member_pointerlevel param, int param_2);");
5170 @Sources_v1 = (@Sources_v1, "int func_test_member_pointerlevel(struct type_test_member_pointerlevel param, int param_2)\n{\n return param_2;\n}");
5171
5172 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_member_pointerlevel\n{\n int i;\n long **j;\n double k;\n struct type_test_member_pointerlevel* p;\n};");
5173 @DataDefs_v2 = (@DataDefs_v2, "int func_test_member_pointerlevel(struct type_test_member_pointerlevel param, int param_2);");
5174 @Sources_v2 = (@Sources_v2, "int func_test_member_pointerlevel(struct type_test_member_pointerlevel param, int param_2)\n{\n return param_2;\n}");
5175
5176 #Added_Interface
5177 @DataDefs_v2 = (@DataDefs_v2, "int added_func(int param);");
5178 @Sources_v2 = (@Sources_v2, "int added_func(int param)\n{\n return param;\n}");
5179
5180 #Withdrawn_Interface
5181 @DataDefs_v1 = (@DataDefs_v1, "int withdrawn_func(int param);");
5182 @Sources_v1 = (@Sources_v1, "int withdrawn_func(int param)\n{\n return param;\n}");
5183
5184 #Parameter_Type_And_Size
5185 @DataDefs_v1 = (@DataDefs_v1, "int func_parameter_type_and_size(int param, int other_param);");
5186 @Sources_v1 = (@Sources_v1, "int func_parameter_type_and_size(int param, int other_param)\n{\n return other_param;\n}");
5187
5188 @DataDefs_v2 = (@DataDefs_v2, "int func_parameter_type_and_size(long long param, int other_param);");
5189 @Sources_v2 = (@Sources_v2, "int func_parameter_type_and_size(long long param, int other_param)\n{\n return other_param;\n}");
5190
5191 #Parameter_Type
5192 @DataDefs_v1 = (@DataDefs_v1, "int func_parameter_type(int param, int other_param);");
5193 @Sources_v1 = (@Sources_v1, "int func_parameter_type(int param, int other_param)\n{\n return other_param;\n}");
5194
5195 @DataDefs_v2 = (@DataDefs_v2, "int func_parameter_type(float param, int other_param);");
5196 @Sources_v2 = (@Sources_v2, "int func_parameter_type(float param, int other_param)\n{\n return other_param;\n}");
5197
5198 #Parameter_BaseType (Typedef)
5199 @DataDefs_v1 = (@DataDefs_v1, "typedef int* PARAM_TYPEDEF;\nint func_parameter_basetypechange_typedef(PARAM_TYPEDEF param);");
5200 @Sources_v1 = (@Sources_v1, "int func_parameter_basetypechange_typedef(PARAM_TYPEDEF param)\n{\n return 0;\n}");
5201
5202 @DataDefs_v2 = (@DataDefs_v2, "typedef const int* PARAM_TYPEDEF;\nint func_parameter_basetypechange_typedef(PARAM_TYPEDEF param);");
5203 @Sources_v2 = (@Sources_v2, "int func_parameter_basetypechange_typedef(PARAM_TYPEDEF param)\n{\n return 0;\n}");
5204
5205 #Parameter_BaseType
5206 @DataDefs_v1 = (@DataDefs_v1, "int func_parameter_basetypechange(int *param);");
5207 @Sources_v1 = (@Sources_v1, "int func_parameter_basetypechange(int *param)\n{\n return sizeof(*param);\n}");
5208
5209 @DataDefs_v2 = (@DataDefs_v2, "int func_parameter_basetypechange(long long *param);");
5210 @Sources_v2 = (@Sources_v2, "int func_parameter_basetypechange(long long *param)\n{\n return sizeof(*param);\n}");
5211
5212 #Parameter_PointerLevel_And_Size
5213 @DataDefs_v1 = (@DataDefs_v1, "long long func_parameter_pointerlevel_and_size(long long param);");
5214 @Sources_v1 = (@Sources_v1, "long long func_parameter_pointerlevel_and_size(long long param)\n{\n return param;\n}");
5215
5216 @DataDefs_v2 = (@DataDefs_v2, "long long func_parameter_pointerlevel_and_size(long long *param);");
5217 @Sources_v2 = (@Sources_v2, "long long func_parameter_pointerlevel_and_size(long long *param)\n{\n return param[5];\n}");
5218
5219 #Parameter_PointerLevel
5220 @DataDefs_v1 = (@DataDefs_v1, "int func_parameter_pointerlevel(int *param);");
5221 @Sources_v1 = (@Sources_v1, "int func_parameter_pointerlevel(int *param)\n{\n return param[5];\n}");
5222
5223 @DataDefs_v2 = (@DataDefs_v2, "int func_parameter_pointerlevel(int **param);");
5224 @Sources_v2 = (@Sources_v2, "int func_parameter_pointerlevel(int **param)\n{\n return param[5][5];\n}");
5225
5226 #Return_Type_And_Size
5227 @DataDefs_v1 = (@DataDefs_v1, "int func_return_type_and_size(int param);");
5228 @Sources_v1 = (@Sources_v1, "int func_return_type_and_size(int param)\n{\n return 2^(sizeof(int)*8-1)-1;\n}");
5229
5230 @DataDefs_v2 = (@DataDefs_v2, "long long func_return_type_and_size(int param);");
5231 @Sources_v2 = (@Sources_v2, "long long func_return_type_and_size(int param)\n{\n return 2^(sizeof(long long)*8-1)-1;\n}");
5232
5233 #Return_Type
5234 @DataDefs_v1 = (@DataDefs_v1, "int func_return_type(int param);");
5235 @Sources_v1 = (@Sources_v1, "int func_return_type(int param)\n{\n return 2^(sizeof(int)*8-1)-1;\n}");
5236
5237 @DataDefs_v2 = (@DataDefs_v2, "float func_return_type(int param);");
5238 @Sources_v2 = (@Sources_v2, "float func_return_type(int param)\n{\n return 0.7;\n}");
5239
5240 #Return_BaseType
5241 @DataDefs_v1 = (@DataDefs_v1, "int *func_return_basetypechange(int param);");
5242 @Sources_v1 = (@Sources_v1, "int *func_return_basetypechange(int param)\n{\n int *x = (int*)malloc(10*sizeof(int));\n *x = 2^(sizeof(int)*8-1)-1;\n return x;\n}");
5243
5244 @DataDefs_v2 = (@DataDefs_v2, "long long *func_return_basetypechange(int param);");
5245 @Sources_v2 = (@Sources_v2, "long long *func_return_basetypechange(int param)\n{\n long long *x = (long long*)malloc(10*sizeof(long long));\n *x = 2^(sizeof(long long)*8-1)-1;\n return x;\n}");
5246
5247 #Return_PointerLevel_And_Size
5248 @DataDefs_v1 = (@DataDefs_v1, "long long func_return_pointerlevel_and_size(int param);");
5249 @Sources_v1 = (@Sources_v1, "long long func_return_pointerlevel_and_size(int param)\n{\n return 100;\n}");
5250
5251 @DataDefs_v2 = (@DataDefs_v2, "long long *func_return_pointerlevel_and_size(int param);");
5252 @Sources_v2 = (@Sources_v2, "long long *func_return_pointerlevel_and_size(int param)\n{\n long long *x = (long long*)malloc(10*sizeof(long long));\n *x = 2^(sizeof(long long)*8-1)-1;\n return x;\n}");
5253
5254 #Return_PointerLevel
5255 @DataDefs_v1 = (@DataDefs_v1, "long long *func_return_pointerlevel(int param);");
5256 @Sources_v1 = (@Sources_v1, "long long *func_return_pointerlevel(int param)\n{\n long long *x = (long long*)malloc(10*sizeof(long long));\n *x = 2^(sizeof(long long)*8-1)-1;\n return x;\n}");
5257
5258 @DataDefs_v2 = (@DataDefs_v2, "long long **func_return_pointerlevel(int param);");
5259 @Sources_v2 = (@Sources_v2, "long long **func_return_pointerlevel(int param)\n{\n long long *x = (long long*)malloc(10*sizeof(long long));\n *x = 2^(sizeof(long long)*8-1)-1;\n long *y = (long*)malloc(sizeof(long long));\n *y=(long)&x;\n return (long long **)y;\n}");
5260
5261 #typedef to anon struct
5262 @DataDefs_v1 = (@DataDefs_v1, "
5263typedef struct
5264{
5265 int i;
5266 long j;
5267 double k;
5268} type_test_anon_typedef;
5269int func_test_anon_typedef(type_test_anon_typedef param);");
5270 @Sources_v1 = (@Sources_v1, "int func_test_anon_typedef(type_test_anon_typedef param)\n{\n return 0;\n}");
5271
5272 @DataDefs_v2 = (@DataDefs_v2, "
5273typedef struct
5274{
5275 int i;
5276 long j;
5277 double k;
5278 union {
5279 int dummy[256];
5280 struct {
5281 char q_skiptable[256];
5282 const char *p;
5283 int l;
5284 } p;
5285 };
5286} type_test_anon_typedef;
5287int func_test_anon_typedef(type_test_anon_typedef param);");
5288 @Sources_v2 = (@Sources_v2, "int func_test_anon_typedef(type_test_anon_typedef param)\n{\n return 0;\n}");
5289
5290 #opaque type
5291 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_opaque\n{\n long long i[5];\n long j;\n double k;\n struct type_test_opaque* p;\n};");
5292 @DataDefs_v1 = (@DataDefs_v1, "int func_test_opaque(struct type_test_opaque param, int param_2);");
5293 @Sources_v1 = (@Sources_v1, "int func_test_opaque(struct type_test_opaque param, int param_2)\n{\n return param_2;\n}");
5294
5295 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_opaque\n{\n long long i[5];\n long long j;\n double k;\n struct type_test_opaque* p;\n};");
5296 @DataDefs_v2 = (@DataDefs_v2, "int func_test_opaque(struct type_test_opaque param, int param_2);");
5297 @Sources_v2 = (@Sources_v2, "int func_test_opaque(struct type_test_opaque param, int param_2)\n{\n return param_2;\n}");
5298
5299 #internal function
5300 @DataDefs_v1 = (@DataDefs_v1, "struct type_test_internal\n{\n long long i[5];\n long j;\n double k;\n struct type_test_internal* p;\n};");
5301 @DataDefs_v1 = (@DataDefs_v1, "int func_test_internal(struct type_test_internal param, int param_2);");
5302 @Sources_v1 = (@Sources_v1, "int func_test_internal(struct type_test_internal param, int param_2)\n{\n return param_2;\n}");
5303
5304 @DataDefs_v2 = (@DataDefs_v2, "struct type_test_internal\n{\n long long i[5];\n long long j;\n double k;\n struct type_test_internal* p;\n};");
5305 @DataDefs_v2 = (@DataDefs_v2, "int func_test_internal(struct type_test_internal param, int param_2);");
5306 @Sources_v2 = (@Sources_v2, "int func_test_internal(struct type_test_internal param, int param_2)\n{\n return param_2;\n}");
5307
5308 #starting versioning
5309 @DataDefs_v1 = (@DataDefs_v1, "int func_return_type_and_start_versioning(int param);");
5310 @Sources_v1 = (@Sources_v1, "int func_return_type_and_start_versioning(int param)\n{\n return 2^(sizeof(int)*8-1)-1;\n}");
5311
5312 @DataDefs_v2 = (@DataDefs_v2, "int func_return_type_and_start_versioning(int param);");
5313 @Sources_v2 = (@Sources_v2, "int func_return_type_and_start_versioning(int param)\n{\n return 2^(sizeof(int)*8-1)-1;\n}\n__asm__(\".symver func_return_type_and_start_versioning,func_return_type_and_start_versioning\@TEST_2.0\");");
5314
5315 #Return_Type and good versioning
5316 @DataDefs_v1 = (@DataDefs_v1, "int func_return_type_and_good_versioning(int param);");
5317 @Sources_v1 = (@Sources_v1, "int func_return_type_and_good_versioning(int param)\n{\n return 2^(sizeof(int)*8-1)-1;\n}\n__asm__(\".symver func_return_type_and_good_versioning,func_return_type_and_good_versioning\@TEST_1.0\");");
5318
5319 @DataDefs_v2 = (@DataDefs_v2, "int func_return_type_and_good_versioning_old(int param);");
5320 @Sources_v2 = (@Sources_v2, "int func_return_type_and_good_versioning_old(int param)\n{\n return 2^(sizeof(int)*8-1)-1;\n}\n__asm__(\".symver func_return_type_and_good_versioning_old,func_return_type_and_good_versioning\@TEST_1.0\");");
5321
5322 @DataDefs_v2 = (@DataDefs_v2, "float func_return_type_and_good_versioning(int param);");
5323 @Sources_v2 = (@Sources_v2, "float func_return_type_and_good_versioning(int param)\n{\n return 0.7;\n}\n__asm__(\".symver func_return_type_and_good_versioning,func_return_type_and_good_versioning\@TEST_2.0\");");
5324
5325 #Return_Type and bad versioning
5326 @DataDefs_v1 = (@DataDefs_v1, "int func_return_type_and_bad_versioning(int param);");
5327 @Sources_v1 = (@Sources_v1, "int func_return_type_and_bad_versioning(int param)\n{\n return 2^(sizeof(int)*8-1)-1;\n}\n__asm__(\".symver func_return_type_and_bad_versioning,func_return_type_and_bad_versioning\@TEST_1.0\");");
5328
5329 @DataDefs_v2 = (@DataDefs_v2, "float func_return_type_and_bad_versioning_old(int param);");
5330 @Sources_v2 = (@Sources_v2, "float func_return_type_and_bad_versioning_old(int param)\n{\n return 0.7;\n}\n__asm__(\".symver func_return_type_and_bad_versioning_old,func_return_type_and_bad_versioning\@TEST_1.0\");");
5331
5332 @DataDefs_v2 = (@DataDefs_v2, "float func_return_type_and_bad_versioning(int param);");
5333 @Sources_v2 = (@Sources_v2, "float func_return_type_and_bad_versioning(int param)\n{\n return 0.7;\n}\n__asm__(\".symver func_return_type_and_bad_versioning,func_return_type_and_bad_versioning\@TEST_2.0\");");
5334
5335 #unnamed struct/union fields within structs/unions
5336 @DataDefs_v1 = (@DataDefs_v1, "
5337typedef struct {
5338 int a;
5339 union {
5340 int b;
5341 float c;
5342 };
5343 int d;
5344} type_test_unnamed;
5345int func_test_unnamed(type_test_unnamed param);");
5346 @Sources_v1 = (@Sources_v1, "int func_test_unnamed(type_test_unnamed param)\n{\n return 0;\n}");
5347
5348 @DataDefs_v2 = (@DataDefs_v2, "
5349typedef struct {
5350 int a;
5351 union {
5352 long double b;
5353 float c;
5354 };
5355 int d;
5356} type_test_unnamed;
5357int func_test_unnamed(type_test_unnamed param);");
5358 @Sources_v2 = (@Sources_v2, "int func_test_unnamed(type_test_unnamed param)\n{\n return 0;\n}");
5359
5360 #constants
5361 @DataDefs_v1 = (@DataDefs_v1, "#define TEST_PUBLIC_CONSTANT \"old_value\"");
5362 @DataDefs_v2 = (@DataDefs_v2, "#define TEST_PUBLIC_CONSTANT \"new_value\"");
5363
5364 @DataDefs_v1 = (@DataDefs_v1, "#define TEST_PRIVATE_CONSTANT \"old_value\"\n#undef TEST_PRIVATE_CONSTANT");
5365 @DataDefs_v2 = (@DataDefs_v2, "#define TEST_PRIVATE_CONSTANT \"new_value\"\n#undef TEST_PRIVATE_CONSTANT");
5366
5367 #anon ptr typedef
5368 @DataDefs_v1 = (@DataDefs_v1, "
5369#ifdef __cplusplus
5370extern \"C\" {
5371#endif
5372typedef struct {
5373 int a;
5374} *type_test_anonptr_typedef;
5375extern __attribute__ ((visibility(\"default\"))) int func_test_anonptr_typedef(type_test_anonptr_typedef param);
5376#ifdef __cplusplus
5377}
5378#endif");
5379 @Sources_v1 = (@Sources_v1, "__attribute__ ((visibility(\"default\"))) int func_test_anonptr_typedef(type_test_anonptr_typedef param)\n{\n return 0;\n}");
5380
5381 @DataDefs_v2 = (@DataDefs_v2, "
5382#ifdef __cplusplus
5383extern \"C\" {
5384#endif
5385typedef struct {
5386 float a;
5387} *type_test_anonptr_typedef;
5388extern __attribute__ ((visibility(\"default\"))) int func_test_anonptr_typedef(type_test_anonptr_typedef param);
5389#ifdef __cplusplus
5390}
5391#endif");
5392 @Sources_v2 = (@Sources_v2, "__attribute__ ((visibility(\"default\"))) int func_test_anonptr_typedef(type_test_anonptr_typedef param)\n{\n return 0;\n}");
5393
5394 #typedefs
5395 @DataDefs_v1 = (@DataDefs_v1, "typedef float TYPEDEF_TYPE;\nint func_parameter_typedef_change(TYPEDEF_TYPE param);");
5396 @Sources_v1 = (@Sources_v1, "int func_parameter_typedef_change(TYPEDEF_TYPE param)\n{\n return 1.0;\n}");
5397
5398 @DataDefs_v2 = (@DataDefs_v2, "typedef int TYPEDEF_TYPE;\nint func_parameter_typedef_change(TYPEDEF_TYPE param);");
5399 @Sources_v2 = (@Sources_v2, "int func_parameter_typedef_change(TYPEDEF_TYPE param)\n{\n return 1;\n}");
5400
5401 #typedefs in member type
5402 @DataDefs_v1 = (@DataDefs_v1, "typedef float TYPEDEF_TYPE_2;\nstruct type_test_member_typedef_change{\nTYPEDEF_TYPE_2 m;};\nint func_test_member_typedef_change(struct type_test_member_typedef_change param);");
5403 @Sources_v1 = (@Sources_v1, "int func_test_member_typedef_change(struct type_test_member_typedef_change param)\n{\n return 1;\n}");
5404
5405 @DataDefs_v2 = (@DataDefs_v2, "typedef int TYPEDEF_TYPE_2;\nstruct type_test_member_typedef_change{\nTYPEDEF_TYPE_2 m;};\nint func_test_member_typedef_change(struct type_test_member_typedef_change param);");
5406 @Sources_v2 = (@Sources_v2, "int func_test_member_typedef_change(struct type_test_member_typedef_change param)\n{\n return 1;\n}");
5407
5408 create_TestSuite("abi_changes_test_c", "C", join("\n\n", @DataDefs_v1), join("\n\n", @Sources_v1), join("\n\n", @DataDefs_v2), join("\n\n", @Sources_v2), "type_test_opaque", "func_test_internal");
5409}
5410
5411sub create_TestSuite($$$$$$$$)
5412{
5413 my ($Dir, $Lang, $DataDefs_v1, $Sources_v1, $DataDefs_v2, $Sources_v2, $Opaque, $Private) = @_;
5414 my $Ext = ($Lang eq "C++")?"cpp":"c";
5415 my $Gcc = ($Lang eq "C++")?"g++":"gcc";
5416 #creating test suite
5417 my $Path_v1 = "$Dir/lib_abi_changes_test.v1";
5418 my $Path_v2 = "$Dir/lib_abi_changes_test.v2";
5419
5420 system("rm", "-fr", $Path_v1, $Path_v2);
5421 system("mkdir", "-p", $Path_v1, $Path_v2);
5422
5423 writeFile("$Path_v1/version", "TEST_1.0 {\n};\nTEST_2.0 {\n};\n");
5424 writeFile("$Path_v1/lib_abi_changes_test.h", "#include <stdlib.h>\n".$DataDefs_v1."\n");
5425 writeFile("$Path_v1/lib_abi_changes_test.$Ext", "#include \"lib_abi_changes_test.h\"\n".$Sources_v1."\n");
5426 writeFile("$Dir/descriptor.v1", "<version>\n 1.0.0\n</version>\n\n<headers>\n ".$ENV{"PWD"}."/$Path_v1/\n</headers>\n\n<libs>\n ".$ENV{"PWD"}."/$Path_v1/\n</libs>\n\n<opaque_types>\n $Opaque\n</opaque_types>\n\n<skip_interfaces>\n $Private\n</skip_interfaces>\n\n<include_paths>\n ".$ENV{"PWD"}."/$Path_v1\n</include_paths>\n");
5427
5428 writeFile("$Path_v2/version", "TEST_1.0 {\n};\nTEST_2.0 {\n};\n");
5429 writeFile("$Path_v2/lib_abi_changes_test.h", "#include <stdlib.h>\n".$DataDefs_v2."\n");
5430 writeFile("$Path_v2/lib_abi_changes_test.$Ext", "#include \"lib_abi_changes_test.h\"\n".$Sources_v2."\n");
5431 writeFile("$Dir/descriptor.v2", "<version>\n 2.0.0\n</version>\n\n<headers>\n ".$ENV{"PWD"}."/$Path_v2/\n</headers>\n\n<libs>\n ".$ENV{"PWD"}."/$Path_v2/\n</libs>\n\n<opaque_types>\n $Opaque\n</opaque_types>\n\n<skip_interfaces>\n $Private\n</skip_interfaces>\n\n<include_paths>\n ".$ENV{"PWD"}."/$Path_v2\n</include_paths>\n");
5432
5433 system("$Gcc $Path_v1/lib_abi_changes_test.h");
5434 if($?)
5435 {
5436 print "ERROR: can't compile \'$Path_v1/lib_abi_changes_test.h\'\n";
5437 return;
5438 }
5439 system("$Gcc -Wl,--version-script $Path_v1/version -shared $Path_v1/lib_abi_changes_test.$Ext -o $Path_v1/lib_abi_changes_test.so");
5440 if($?)
5441 {
5442 print "ERROR: can't compile \'$Path_v1/lib_abi_changes_test.$Ext\'\n";
5443 return;
5444 }
5445 system("$Gcc $Path_v2/lib_abi_changes_test.h");
5446 if($?)
5447 {
5448 print "ERROR: can't compile \'$Path_v2/lib_abi_changes_test.h\'\n";
5449 return;
5450 }
5451 system("$Gcc -Wl,--version-script $Path_v2/version -shared $Path_v2/lib_abi_changes_test.$Ext -o $Path_v2/lib_abi_changes_test.so");
5452 if($?)
5453 {
5454 print "ERROR: can't compile \'$Path_v2/lib_abi_changes_test.$Ext\'\n";
5455 return;
5456 }
5457
5458 #running abi-compliance-checker
5459 system("$0 -l lib_$Dir -d1 $Dir/descriptor.v1 -d2 $Dir/descriptor.v2");
5460}
5461
5462sub writeFile($$)
5463{
5464 my ($Path, $Content) = @_;
5465 return if(not $Path);
5466 open (FILE, ">".$Path) || die ("Can't open file $Path\n");
5467 print FILE $Content;
5468 close(FILE);
5469}
5470
5471sub readFile($)
5472{
5473 my $Path = $_[0];
5474 return "" if(not $Path or not -f $Path);
5475 open (FILE, $Path);
5476 my $Content = join("\n", <FILE>);
5477 close(FILE);
5478 return toUnix($Content);
5479}
5480
5481sub toUnix($)
5482{
5483 my $Text = $_[0];
5484 $Text=~s/\r//g;
5485 return $Text;
5486}
5487
5488sub getArch()
5489{
5490 my $Arch = $ENV{"CPU"};
5491 if(not $Arch)
5492 {
5493 $Arch = `uname -m`;
5494 chomp($Arch);
5495 }
5496 if(not $Arch)
5497 {
5498 $Arch = `uname -p`;
5499 chomp($Arch);
5500 }
5501 $Arch = "x86" if($Arch =~ /i[3-7]86/);
5502 return $Arch;
5503}
5504
5505sub get_Report_Header()
5506{
5507 my $Report_Header = "<h1>ABI compliance report for the library <span style='color:Blue;white-space:nowrap;'>$TargetLibraryName </span> from version <span style='color:Red;white-space:nowrap;'>".$Descriptor{1}{"Version"}."</span> to <span style='color:Red;white-space:nowrap;'>".$Descriptor{2}{"Version"}."</span> on <span style='color:Blue;'>".getArch()."</span> ".(($AppPath)?"relating to the portability of application <span style='color:Blue;'>".get_FileName($AppPath)."</span>":"")."</h1>\n";
5508 return "<!--Header-->\n".$Report_Header."<!--Header_End-->\n";
5509}
5510
5511sub get_SourceInfo()
5512{
5513 my $CheckedHeaders = "<!--Checked_Headers-->\n<a name='Checked_Headers'></a><h2 style='margin-bottom:0px;padding-bottom:0px;'>Checked header files (".keys(%{$Headers{1}}).")</h2><hr/>\n";
5514 foreach my $Header_Dest (sort {lc($Headers{1}{$a}{"Name"}) cmp lc($Headers{1}{$b}{"Name"})} keys(%{$Headers{1}}))
5515 {
5516 my $Header_Name = $Headers{1}{$Header_Dest}{"Name"};
5517 my $Dest_Count = keys(%{$HeaderName_Destinations{1}{$Header_Name}});
5518 my $Identity = $Headers{1}{$Header_Dest}{"Identity"};
5519 my $Dest_Comment = ($Dest_Count>1 and $Identity=~/\//)?" ($Identity)":"";
5520 $CheckedHeaders .= "<span class='header_list_elem'>$Header_Name"."$Dest_Comment</span><br/>\n";
5521 }
5522 $CheckedHeaders .= "<!--Checked_Headers_End--><br/><a style='font-size:11px;' href='#Top'>to the top</a><br/>\n";
5523 my $CheckedLibs = "<!--Checked_Libs-->\n<a name='Checked_Libs'></a><h2 style='margin-bottom:0px;padding-bottom:0px;'>Checked shared objects (".keys(%{$SoNames_All{1}}).")</h2><hr/>\n";
5524 foreach my $Library (sort {lc($a) cmp lc($b)} keys(%{$SoNames_All{1}}))
5525 {
5526 $CheckedLibs .= "<span class='solib_list_elem'>$Library</span><br/>\n";
5527 }
5528 $CheckedLibs .= "<!--Checked_Libs_End--><br/><a style='font-size:11px;' href='#Top'>to the top</a><br/>\n";
5529 return $CheckedHeaders.$CheckedLibs;
5530}
5531
5532sub get_TypeProblems_Count($$)
5533{
5534 my ($TypeChanges, $TargetPriority) = @_;
5535 my $Type_Problems_Count = 0;
5536 foreach my $TypeName (sort keys(%{$TypeChanges}))
5537 {
5538 my %Kinds_Target = ();
5539 foreach my $Kind (keys(%{$TypeChanges->{$TypeName}}))
5540 {
5541 foreach my $Location (keys(%{$TypeChanges->{$TypeName}{$Kind}}))
5542 {
5543 my $Priority = $TypeChanges->{$TypeName}{$Kind}{$Location}{"Priority"};
5544 next if($Priority ne $TargetPriority);
5545 my $Target = $TypeChanges->{$TypeName}{$Kind}{$Location}{"Target"};
5546 next if($Kinds_Target{$Kind}{$Target});
5547 $Kinds_Target{$Kind}{$Target} = 1;
5548 $Type_Problems_Count += 1;
5549 }
5550 }
5551 }
5552 return $Type_Problems_Count;
5553}
5554
5555sub get_Summary()
5556{
5557 my ($Added, $Withdrawn, $I_Problems_High, $I_Problems_Medium, $I_Problems_Low, $T_Problems_High, $T_Problems_Medium, $T_Problems_Low) = (0,0,0,0,0,0,0,0);
5558 foreach my $Interface (sort keys(%CompatProblems))
5559 {
5560 foreach my $Kind (sort keys(%{$CompatProblems{$Interface}}))
5561 {
5562 if($InterfaceProblems_Kind{$Kind})
5563 {
5564 foreach my $Location (sort keys(%{$CompatProblems{$Interface}{$Kind}}))
5565 {
5566 if($Kind eq "Added_Interface")
5567 {
5568 $Added += 1;
5569 }
5570 elsif($Kind eq "Withdrawn_Interface")
5571 {
5572 $Withdrawn += 1;
5573 }
5574 else
5575 {
5576 if($CompatProblems{$Interface}{$Kind}{$Location}{"Priority"} eq "High")
5577 {
5578 $I_Problems_High += 1;
5579 }
5580 elsif($CompatProblems{$Interface}{$Kind}{$Location}{"Priority"} eq "Medium")
5581 {
5582 $I_Problems_Medium += 1;
5583 }
5584 elsif($CompatProblems{$Interface}{$Kind}{$Location}{"Priority"} eq "Low")
5585 {
5586 $I_Problems_Low += 1;
5587 }
5588 }
5589 }
5590 }
5591 }
5592 }
5593
5594 my (%TypeChanges, %Type_MaxPriority);
5595 foreach my $Interface (sort keys(%CompatProblems))
5596 {
5597 foreach my $Kind (keys(%{$CompatProblems{$Interface}}))
5598 {
5599 if($TypeProblems_Kind{$Kind})
5600 {
5601 foreach my $Location (keys(%{$CompatProblems{$Interface}{$Kind}}))
5602 {
5603 my $Type_Name = $CompatProblems{$Interface}{$Kind}{$Location}{"Type_Name"};
5604 my $Priority = $CompatProblems{$Interface}{$Kind}{$Location}{"Priority"};
5605 %{$TypeChanges{$Type_Name}{$Kind}{$Location}} = %{$CompatProblems{$Interface}{$Kind}{$Location}};
5606 $Type_MaxPriority{$Type_Name}{$Kind} = max_priority($Type_MaxPriority{$Type_Name}{$Kind}, $Priority);
5607 }
5608 }
5609 }
5610 }
5611
5612 foreach my $Type_Name (keys(%TypeChanges))
5613 {
5614 foreach my $Kind (keys(%{$TypeChanges{$Type_Name}}))
5615 {
5616 foreach my $Location (keys(%{$TypeChanges{$Type_Name}{$Kind}}))
5617 {
5618 my $Priority = $TypeChanges{$Type_Name}{$Kind}{$Location}{"Priority"};
5619 if(cmp_priority($Type_MaxPriority{$Type_Name}{$Kind}, $Priority))
5620 {
5621 delete($TypeChanges{$Type_Name}{$Kind}{$Location});
5622 }
5623 }
5624 }
5625 }
5626
5627 $T_Problems_High = get_TypeProblems_Count(\%TypeChanges, "High");
5628 $T_Problems_Medium = get_TypeProblems_Count(\%TypeChanges, "Medium");
5629 $T_Problems_Low = get_TypeProblems_Count(\%TypeChanges, "Low");
5630
5631 #summary
5632 my $Summary = "<h2 style='margin-bottom:0px;padding-bottom:0px;'>Summary</h2><hr/>";
5633 $Summary .= "<table cellpadding='3' border='1' style='border-collapse:collapse;'>";
5634
5635
5636 my $Checked_Headers_Link = "0";
5637 $Checked_Headers_Link = "<a href='#Checked_Headers' style='color:Blue;'>".keys(%{$Headers{1}})."</a>" if(keys(%{$Headers{1}})>0);
5638 $Summary .= "<tr><td class='table_header summary_item'>Total header files checked</td><td class='summary_item_value'>$Checked_Headers_Link</td></tr>";
5639
5640 my $Checked_Libs_Link = "0";
5641 $Checked_Libs_Link = "<a href='#Checked_Libs' style='color:Blue;'>".keys(%{$SoNames_All{1}})."</a>" if(keys(%{$SoNames_All{1}})>0);
5642 $Summary .= "<tr><td class='table_header summary_item'>Total shared objects checked</td><td class='summary_item_value'>$Checked_Libs_Link</td></tr>";
5643 $Summary .= "<tr><td class='table_header summary_item'>Total interfaces / types checked</td><td class='summary_item_value'>".keys(%CheckedInterfaces)." / ".keys(%CheckedTypes)."</td></tr>";
5644
5645 my $Verdict = "<span style='color:Green;'><b>Compatible</b></span>";
5646 $Verdict = "<span style='color:Red;'><b>Incompatible</b></span>" if(($Withdrawn>0) or ($I_Problems_High>0) or ($T_Problems_High>0));
5647 $Summary .= "<tr><td class='table_header summary_item'>Verdict</td><td class='summary_item_value'>$Verdict</td></tr>";
5648
5649 $Summary .= "</table>\n";
5650
5651 #problem summary
5652 my $Problem_Summary = "<h2 style='margin-bottom:0px;padding-bottom:0px;'>Problem Summary</h2><hr/>";
5653 $Problem_Summary .= "<table cellpadding='3' border='1' style='border-collapse:collapse;'>";
5654
5655 my $Added_Link = "0";
5656 $Added_Link = "<a href='#Added' style='color:Blue;'>$Added</a>" if($Added>0);
5657 $Problem_Summary .= "<tr><td class='table_header summary_item' colspan='2'>Added interfaces</td><td class='summary_item_value'>$Added_Link</td></tr>";
5658
5659 my $WIthdrawn_Link = "0";
5660 $WIthdrawn_Link = "<a href='#Withdrawn' style='color:Blue;'>$Withdrawn</a>" if($Withdrawn>0);
5661 $Problem_Summary .= "<tr><td class='table_header summary_item' colspan='2'>Withdrawn interfaces</td><td class='summary_item_value'>$WIthdrawn_Link</td></tr>";
5662
5663 my $TH_Link = "0";
5664 $TH_Link = "<a href='#Type_Problems_High' style='color:Blue;'>$T_Problems_High</a>" if($T_Problems_High>0);
5665 $Problem_Summary .= "<tr><td class='table_header summary_item' rowspan='3'>Problems in<br/>Data Types</td><td class='table_header summary_item' style='color:Red;'>High risk</td><td align='right' class='summary_item_value'>$TH_Link</td></tr>";
5666
5667 my $TM_Link = "0";
5668 $TM_Link = "<a href='#Type_Problems_Medium' style='color:Blue;'>$T_Problems_Medium</a>" if($T_Problems_Medium>0);
5669 $Problem_Summary .= "<tr><td class='table_header summary_item'>Medium risk</td><td class='summary_item_value'>$TM_Link</td></tr>";
5670
5671 my $TL_Link = "0";
5672 $TL_Link = "<a href='#Type_Problems_Low' style='color:Blue;'>$T_Problems_Low</a>" if($T_Problems_Low>0);
5673 $Problem_Summary .= "<tr><td class='table_header summary_item'>Low risk</td><td class='summary_item_value'>$TL_Link</td></tr>";
5674
5675 my $IH_Link = "0";
5676 $IH_Link = "<a href='#Interface_Problems_High' style='color:Blue;'>$I_Problems_High</a>" if($I_Problems_High>0);
5677 $Problem_Summary .= "<tr><td class='table_header summary_item' rowspan='3'>Interface<br/>problems</td><td class='table_header summary_item' style='color:Red;'>High risk</td><td class='summary_item_value'>$IH_Link</td></tr>";
5678
5679 my $IM_Link = "0";
5680 $IM_Link = "<a href='#Interface_Problems_Medium' style='color:Blue;'>$I_Problems_Medium</a>" if($I_Problems_Medium>0);
5681 $Problem_Summary .= "<tr><td class='table_header summary_item'>Medium risk</td><td class='summary_item_value'>$IM_Link</td></tr>";
5682
5683 my $IL_Link = "0";
5684 $IL_Link = "<a href='#Interface_Problems_Low' style='color:Blue;'>$I_Problems_Low</a>" if($I_Problems_Low>0);
5685 $Problem_Summary .= "<tr><td class='table_header summary_item'>Low risk</td><td class='summary_item_value'>$IL_Link</td></tr>";
5686
5687 my $ChangedConstants_Link = "0";
5688 $ChangedConstants_Link = "<a href='#Constants' style='color:Blue;'>".keys(%ConstantProblems)."</a>" if(keys(%ConstantProblems)>0);
5689 $Problem_Summary .= "<tr><td class='table_header summary_item' colspan='2'>Constants Problems</td><td class='summary_item_value'>$ChangedConstants_Link</td></tr>";
5690
5691 $Problem_Summary .= "</table>\n";
5692 return "<!--Summary-->\n".$Summary.$Problem_Summary."<!--Summary_End-->\n";
5693}
5694
5695sub get_Report_ChangedConstants()
5696{
5697 my ($CHANGED_CONSTANTS, %HeaderConstant);
5698 foreach my $Name (keys(%ConstantProblems))
5699 {
5700 $HeaderConstant{$ConstantProblems{$Name}{"Header"}}{$Name} = 1;
5701 }
5702 my $Constants_Number = 0;
5703 foreach my $HeaderName (sort {lc($a) cmp lc($b)} keys(%HeaderConstant))
5704 {
5705 $CHANGED_CONSTANTS .= "<span class='header_name'>$HeaderName</span><br/>\n";
5706 foreach my $Name (sort {lc($a) cmp lc($b)} keys(%{$HeaderConstant{$HeaderName}}))
5707 {
5708 $Constants_Number += 1;
5709 my $Old_Value = htmlSpecChars($ConstantProblems{$Name}{"Old_Value"});
5710 my $New_Value = htmlSpecChars($ConstantProblems{$Name}{"New_Value"});
5711 my $Incompatibility = "The value of constant <b>$Name</b> has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b></span> to <span style='white-space:nowrap;'><b>$New_Value</b></span>.";
5712 my $Effect = "If application uses this constant as a parameter of some interface than its execution may change.";
5713 my $ConstantProblemsReport = "<tr><td align='center' valign='top' class='table_header'><span class='problem_num'>1</span></td><td align='left' valign='top'><span class='problem_body'>".$Incompatibility."</span></td><td align='left' valign='top'><span class='problem_body'>$Effect</span></td></tr>\n";
5714 $CHANGED_CONSTANTS .= $ContentSpanStart."<span class='extension'>[+]</span> ".$Name.$ContentSpanEnd."<br/>\n$ContentDivStart<table width='900px' cellpadding='3' cellspacing='0' class='problems_table'><tr><td align='center' width='2%' class='table_header'><span class='problem_title' style='white-space:nowrap;'></span></td><td width='47%' align='center' class='table_header'><span class='problem_sub_title'>Incompatibility</span></td><td align='center' class='table_header'><span class='problem_sub_title'>Effect</span></td></tr>$ConstantProblemsReport</table><br/>$ContentDivEnd\n";
5715 $CHANGED_CONSTANTS = insertIDs($CHANGED_CONSTANTS);
5716 }
5717 $CHANGED_CONSTANTS .= "<br/>\n";
5718 }
5719 if($CHANGED_CONSTANTS)
5720 {
5721 $CHANGED_CONSTANTS = "<a name='Constants'></a><h2 style='margin-bottom:0px;padding-bottom:0px;'>Constants Problems ($Constants_Number)</h2><hr/>\n"."<!--Changed_Constants-->\n".$CHANGED_CONSTANTS."<!--Changed_Constants_End-->\n"."<input id='Changed_Constants_Count' type='hidden' value=\'$Constants_Number\' /><a style='font-size:11px;' href='#Top'>to the top</a><br/>\n";
5722 }
5723 return $CHANGED_CONSTANTS;
5724}
5725
5726sub get_Report_Added()
5727{
5728 my $ADDED_INTERFACES;
5729 #added interfaces
5730 my %FuncAddedInHeaderLib;
5731 foreach my $Interface (sort keys(%CompatProblems))
5732 {
5733 foreach my $Kind (sort keys(%{$CompatProblems{$Interface}}))
5734 {
5735 foreach my $Location (sort keys(%{$CompatProblems{$Interface}{$Kind}}))
5736 {
5737 if($Kind eq "Added_Interface")
5738 {
5739 $FuncAddedInHeaderLib{$CompatProblems{$Interface}{$Kind}{$Location}{"Header"}}{$CompatProblems{$Interface}{$Kind}{$Location}{"New_SoName"}}{$Interface} = 1;
5740 last;
5741 }
5742 }
5743 }
5744 }
5745 my $Added_Number = 0;
5746 foreach my $HeaderName (sort {lc($a) cmp lc($b)} keys(%FuncAddedInHeaderLib))
5747 {
5748 foreach my $SoName (sort {lc($a) cmp lc($b)} keys(%{$FuncAddedInHeaderLib{$HeaderName}}))
5749 {
5750 if($HeaderName)
5751 {
5752 $ADDED_INTERFACES .= "<span class='header_name'>$HeaderName</span>, <span class='solib_name'>$SoName</span><br/>\n";
5753 }
5754 else
5755 {
5756 $ADDED_INTERFACES .= "<span class='solib_name'>$SoName</span><br/>\n";
5757 }
5758 foreach my $Interface (sort {lc($CompatProblems{$a}{"Added_Interface"}{"SharedLibrary"}{"Signature"}) cmp lc($CompatProblems{$b}{"Added_Interface"}{"SharedLibrary"}{"Signature"})} keys(%{$FuncAddedInHeaderLib{$HeaderName}{$SoName}}))
5759 {
5760 $Added_Number += 1;
5761 my $SubReport = "";
5762 my $Signature = $CompatProblems{$Interface}{"Added_Interface"}{"SharedLibrary"}{"Signature"};
5763 if($Interface =~ /\A_Z/)
5764 {
5765 if($Signature)
5766 {
5767 $SubReport = insertIDs($ContentSpanStart.highLight_Signature_Italic_Color(htmlSpecChars($Signature)).$ContentSpanEnd."<br/>\n".$ContentDivStart."<span class='mangled'>[ symbol: <b>$Interface</b> ]</span><br/><br/>".$ContentDivEnd."\n");
5768 }
5769 else
5770 {
5771 $SubReport = "<span class=\"interface_name\">".$Interface."</span>"."<br/>\n";
5772 }
5773 }
5774 else
5775 {
5776 if($Signature)
5777 {
5778 $SubReport = "<span class=\"interface_name\">".highLight_Signature_Italic_Color($Signature)."</span>"."<br/>\n";
5779 }
5780 else
5781 {
5782 $SubReport = "<span class=\"interface_name\">".$Interface."</span>"."<br/>\n";
5783 }
5784 }
5785 $ADDED_INTERFACES .= $SubReport;
5786 }
5787 $ADDED_INTERFACES .= "<br/>\n";
5788 }
5789 }
5790 if($ADDED_INTERFACES)
5791 {
5792 $ADDED_INTERFACES = "<a name='Added'></a><h2 style='margin-bottom:0px;padding-bottom:0px;'>Added Interfaces ($Added_Number)</h2><hr/>\n"."<!--Added_Interfaces-->\n".$ADDED_INTERFACES."<!--Added_Interfaces_End-->\n"."<input id='Added_Interfaces_Count' type='hidden' value=\'$Added_Number\' /><a style='font-size:11px;' href='#Top'>to the top</a><br/>\n";
5793 }
5794 return $ADDED_INTERFACES;
5795}
5796
5797sub get_Report_Withdrawn()
5798{
5799 my $WITHDRAWN_INTERFACES;
5800 #withdrawn interfaces
5801 my %FuncWithdrawnFromHeaderLib;
5802 foreach my $Interface (sort keys(%CompatProblems))
5803 {
5804 foreach my $Kind (sort keys(%{$CompatProblems{$Interface}}))
5805 {
5806 foreach my $Location (sort keys(%{$CompatProblems{$Interface}{$Kind}}))
5807 {
5808 if($Kind eq "Withdrawn_Interface")
5809 {
5810 $FuncWithdrawnFromHeaderLib{$CompatProblems{$Interface}{$Kind}{$Location}{"Header"}}{$CompatProblems{$Interface}{$Kind}{$Location}{"Old_SoName"}}{$Interface} = 1;
5811 last;
5812 }
5813 }
5814 }
5815 }
5816 my $Withdrawn_Number = 0;
5817 foreach my $HeaderName (sort {lc($a) cmp lc($b)} keys(%FuncWithdrawnFromHeaderLib))
5818 {
5819 foreach my $SoName (sort {lc($a) cmp lc($b)} keys(%{$FuncWithdrawnFromHeaderLib{$HeaderName}}))
5820 {
5821 if($HeaderName)
5822 {
5823 $WITHDRAWN_INTERFACES .= "<span class='header_name'>$HeaderName</span>, <span class='solib_name'>$SoName</span><br/>\n";
5824 }
5825 else
5826 {
5827 $WITHDRAWN_INTERFACES .= "<span class='solib_name'>$SoName</span><br/>\n";
5828 }
5829 foreach my $Interface (sort {lc($CompatProblems{$a}{"Withdrawn_Interface"}{"SharedLibrary"}{"Signature"}) cmp lc($CompatProblems{$b}{"Withdrawn_Interface"}{"SharedLibrary"}{"Signature"})} keys(%{$FuncWithdrawnFromHeaderLib{$HeaderName}{$SoName}}))
5830 {
5831 $Withdrawn_Number += 1;
5832 my $SubReport = "";
5833 my $Signature = $CompatProblems{$Interface}{"Withdrawn_Interface"}{"SharedLibrary"}{"Signature"};
5834 if($Interface =~ /\A_Z/)
5835 {
5836 if($Signature)
5837 {
5838 $SubReport = insertIDs($ContentSpanStart.highLight_Signature_Italic_Color(htmlSpecChars($Signature)).$ContentSpanEnd."<br/>\n".$ContentDivStart."<span class='mangled'>[ symbol: <b>$Interface</b> ]</span><br/><br/>".$ContentDivEnd."\n");
5839 }
5840 else
5841 {
5842 $SubReport = "<span class=\"interface_name\">".$Interface."</span>"."<br/>\n";
5843 }
5844 }
5845 else
5846 {
5847 if($Signature)
5848 {
5849 $SubReport = "<span class=\"interface_name\">".highLight_Signature_Italic_Color($Signature)."</span>"."<br/>\n";
5850 }
5851 else
5852 {
5853 $SubReport = "<span class=\"interface_name\">".$Interface."</span>"."<br/>\n";
5854 }
5855 }
5856 $WITHDRAWN_INTERFACES .= $SubReport;
5857 }
5858 $WITHDRAWN_INTERFACES .= "<br/>\n";
5859 }
5860 }
5861 if($WITHDRAWN_INTERFACES)
5862 {
5863 $WITHDRAWN_INTERFACES = "<a name='Withdrawn'></a><h2 style='margin-bottom:0px;padding-bottom:0px;'>Withdrawn Interfaces ($Withdrawn_Number)</h2><hr/>\n"."<!--Withdrawn_Interfaces-->\n".$WITHDRAWN_INTERFACES."<!--Withdrawn_Interfaces_End-->\n"."<input id='Withdrawn_Interfaces_Count' type='hidden' value=\'$Withdrawn_Number\' /><a style='font-size:11px;' href='#Top'>to the top</a><br/>\n";
5864 }
5865 return $WITHDRAWN_INTERFACES;
5866}
5867
5868sub get_Report_InterfaceProblems($)
5869{
5870 my $TargetPriority = $_[0];
5871 my ($INTERFACE_PROBLEMS, %FuncHeaderLib);
5872 foreach my $Interface (sort keys(%CompatProblems))
5873 {
5874 foreach my $Kind (sort keys(%{$CompatProblems{$Interface}}))
5875 {
5876 if($InterfaceProblems_Kind{$Kind} and ($Kind ne "Added_Interface") and ($Kind ne "Withdrawn_Interface"))
5877 {
5878 foreach my $Location (sort keys(%{$CompatProblems{$Interface}{$Kind}}))
5879 {
5880 my $SoName = $CompatProblems{$Interface}{$Kind}{$Location}{"Old_SoName"};
5881 my $HeaderName = $CompatProblems{$Interface}{$Kind}{$Location}{"Header"};
5882 $FuncHeaderLib{$HeaderName}{$SoName}{$Interface} = 1;
5883 last;
5884 }
5885 }
5886 }
5887 }
5888 my $Problems_Number = 0;
5889 #interface problems
5890 foreach my $HeaderName (sort {lc($a) cmp lc($b)} keys(%FuncHeaderLib))
5891 {
5892 foreach my $SoName (sort {lc($a) cmp lc($b)} keys(%{$FuncHeaderLib{$HeaderName}}))
5893 {
5894 my $HEADER_LIB_REPORT = "";
5895 foreach my $Interface (sort {lc($tr_name{$a}) cmp lc($tr_name{$b})} keys(%{$FuncHeaderLib{$HeaderName}{$SoName}}))
5896 {
5897 my $Signature = "";
5898 my $InterfaceProblemsReport = "";
5899 my $ProblemNum = 1;
5900 foreach my $Kind (keys(%{$CompatProblems{$Interface}}))
5901 {
5902 foreach my $Location (keys(%{$CompatProblems{$Interface}{$Kind}}))
5903 {
5904 my $Incompatibility = "";
5905 my $Effect = "";
5906 my $Old_Value = htmlSpecChars($CompatProblems{$Interface}{$Kind}{$Location}{"Old_Value"});
5907 my $New_Value = htmlSpecChars($CompatProblems{$Interface}{$Kind}{$Location}{"New_Value"});
5908 my $Priority = $CompatProblems{$Interface}{$Kind}{$Location}{"Priority"};
5909 my $Target = $CompatProblems{$Interface}{$Kind}{$Location}{"Target"};
5910 my $Old_Size = $CompatProblems{$Interface}{$Kind}{$Location}{"Old_Size"};
5911 my $New_Size = $CompatProblems{$Interface}{$Kind}{$Location}{"New_Size"};
5912 my $InitialType_Type = $CompatProblems{$Interface}{$Kind}{$Location}{"InitialType_Type"};
5913 my $Parameter_Position = $CompatProblems{$Interface}{$Kind}{$Location}{"Parameter_Position"};
5914 my $Parameter_Position_Str = num_to_str($Parameter_Position + 1);
5915 $Signature = $CompatProblems{$Interface}{$Kind}{$Location}{"Signature"} if(not $Signature);
5916 next if($Priority ne $TargetPriority);
5917 if($Kind eq "Function_Become_Static")
5918 {
5919 $Incompatibility = "Function become <b>static</b>.\n";
5920 $Effect = "Layout of parameter's stack has been changed and therefore parameters in higher positions in the stack may be incorrectly initialized by applications.";
5921 }
5922 elsif($Kind eq "Function_Become_NonStatic")
5923 {
5924 $Incompatibility = "Function become <b>non-static</b>.\n";
5925 $Effect = "Layout of parameter's stack has been changed and therefore parameters in higher positions in the stack may be incorrectly initialized by applications.";
5926 }
5927 elsif($Kind eq "Parameter_Type_And_Size")
5928 {
5929 $Incompatibility = "Type of $Parameter_Position_Str parameter <b>$Target</b> has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b> (<b>$Old_Size</b> bytes)</span> to <span style='white-space:nowrap;'><b>$New_Value</b> (<b>$New_Size</b> bytes)</span>.\n";
5930 $Effect = "Layout of parameter's stack has been changed and therefore parameters in higher positions in the stack may be incorrectly initialized by applications.";
5931 }
5932 elsif($Kind eq "Parameter_Type")
5933 {
5934 $Incompatibility = "Type of $Parameter_Position_Str parameter <b>$Target</b> has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b></span> to <span style='white-space:nowrap;'><b>$New_Value</b></span>.\n";
5935 $Effect = "Replacement of parameter data type may indicate a change in the semantic meaning of this parameter.";
5936 }
5937 elsif($Kind eq "Withdrawn_Parameter")
5938 {
5939 $Incompatibility = "$Parameter_Position_Str parameter <b>$Target</b> has been withdrawn from the interface signature.\n";
5940 $Effect = "This parameter will be ignored by the interface.";
5941 }
5942 elsif($Kind eq "Added_Parameter")
5943 {
5944 $Incompatibility = "$Parameter_Position_Str parameter <b>$Target</b> has been added to the interface signature.\n";
5945 $Effect = "This parameter will not be initialized by applications.";
5946 }
5947 elsif($Kind eq "Parameter_BaseType_And_Size")
5948 {
5949 if($InitialType_Type eq "Pointer")
5950 {
5951 $Incompatibility = "Base type of $Parameter_Position_Str parameter <b>$Target</b> (pointer) has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b> (<b>$Old_Size</b> bytes)</span> to <span style='white-space:nowrap;'><b>$New_Value</b> (<b>$New_Size</b> bytes)</span>.\n";
5952 $Effect = "Memory stored by pointer may be incorrectly initialized by applications.";
5953 }
5954 else
5955 {
5956 $Incompatibility = "Base type of $Parameter_Position_Str parameter <b>$Target</b> has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b> (<b>$Old_Size</b> bytes)</span> to <span style='white-space:nowrap;'><b>$New_Value</b> (<b>$New_Size</b> bytes)</span>.\n";
5957 $Effect = "Layout of parameter's stack has been changed and therefore parameters in higher positions in the stack may be incorrectly initialized by applications.";
5958 }
5959 }
5960 elsif($Kind eq "Parameter_BaseType")
5961 {
5962 if($InitialType_Type eq "Pointer")
5963 {
5964 $Incompatibility = "Base type of $Parameter_Position_Str parameter <b>$Target</b> (pointer) has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b></span> to <span style='white-space:nowrap;'><b>$New_Value</b></span>.\n";
5965 $Effect = "Memory stored by pointer may be incorrectly initialized by applications.";
5966 }
5967 else
5968 {
5969 $Incompatibility = "Base type of $Parameter_Position_Str parameter <b>$Target</b> has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b></span> to <span style='white-space:nowrap;'><b>$New_Value</b></span>.\n";
5970 $Effect = "Replacement of parameter base type may indicate a change in the semantic meaning of this parameter.";
5971 }
5972 }
5973 elsif($Kind eq "Parameter_PointerLevel")
5974 {
5975 $Incompatibility = "Type pointer level of $Parameter_Position_Str parameter <b>$Target</b> has been changed from <b>$Old_Value</b> to <b>$New_Value</b>.\n";
5976 $Effect = "Possible incorrect initialization of $Parameter_Position_Str parameter <b>$Target</b> by applications.";
5977 }
5978 elsif($Kind eq "Return_Type_And_Size")
5979 {
5980 $Incompatibility = "Type of return value has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b> (<b>$Old_Size</b> bytes)</span> to <span style='white-space:nowrap;'><b>$New_Value</b> (<b>$New_Size</b> bytes)</span>.\n";
5981 $Effect = "Applications will get a different return value and execution may change.";
5982 }
5983 elsif($Kind eq "Return_Type")
5984 {
5985 $Incompatibility = "Type of return value has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b></span> to <span style='white-space:nowrap;'><b>$New_Value</b></span>.\n";
5986 $Effect = "Replacement of return type may indicate a change in its semantic meaning.";
5987 }
5988 elsif($Kind eq "Return_BaseType_And_Size")
5989 {
5990 $Incompatibility = "Base type of return value has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b> (<b>$Old_Size</b> bytes)</span> to <span style='white-space:nowrap;'><b>$New_Value</b> (<b>$New_Size</b> bytes)</span>.\n";
5991 $Effect = "Applications will get a different return value and execution may change.";
5992 }
5993 elsif($Kind eq "Return_BaseType")
5994 {
5995 $Incompatibility = "Base type of return value has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b></span> to <span style='white-space:nowrap;'><b>$New_Value</b></span>.\n";
5996 $Effect = "Replacement of return base type may indicate a change in its semantic meaning.";
5997 }
5998 elsif($Kind eq "Return_PointerLevel")
5999 {
6000 $Incompatibility = "Type pointer level of return value has been changed from <b>$Old_Value</b> to <b>$New_Value</b>.\n";
6001 $Effect = "Applications will get a different return value and execution may change.";
6002 }
6003 if($Incompatibility)
6004 {
6005 $InterfaceProblemsReport .= "<tr><td align='center' class='table_header'><span class='problem_num'>$ProblemNum</span></td><td align='left' valign='top'><span class='problem_body'>".$Incompatibility."</span></td><td align='left' valign='top'><span class='problem_body'>".$Effect."</span></td></tr>\n";
6006 $ProblemNum += 1;
6007 $Problems_Number += 1;
6008 }
6009 }
6010 }
6011 $ProblemNum -= 1;
6012 if($InterfaceProblemsReport)
6013 {
6014 if($Interface =~ /\A_Z/)
6015 {
6016 if($Signature)
6017 {
6018 $HEADER_LIB_REPORT .= $ContentSpanStart."<span class='extension'>[+]</span> ".highLight_Signature_Italic_Color(htmlSpecChars($Signature))." ($ProblemNum)".$ContentSpanEnd."<br/>\n$ContentDivStart<span class='mangled'>[ symbol: <b>$Interface</b> ]</span><br/>\n";
6019 }
6020 else
6021 {
6022 $HEADER_LIB_REPORT .= $ContentSpanStart."<span class='extension'>[+]</span> ".$Interface." ($ProblemNum)".$ContentSpanEnd."<br/>\n$ContentDivStart\n";
6023 }
6024 }
6025 else
6026 {
6027 if($Signature)
6028 {
6029 $HEADER_LIB_REPORT .= $ContentSpanStart."<span class='extension'>[+]</span> ".highLight_Signature_Italic_Color(htmlSpecChars($Signature))." ($ProblemNum)".$ContentSpanEnd."<br/>\n$ContentDivStart\n";
6030 }
6031 else
6032 {
6033 $HEADER_LIB_REPORT .= $ContentSpanStart."<span class='extension'>[+]</span> ".$Interface." ($ProblemNum)".$ContentSpanEnd."<br/>\n$ContentDivStart\n";
6034 }
6035 }
6036 $HEADER_LIB_REPORT .= "<table width='900px' cellpadding='3' cellspacing='0' class='problems_table'><tr><td align='center' width='2%' class='table_header'><span class='problem_title' style='white-space:nowrap;'></span></td><td width='47%' align='center' class='table_header'><span class='problem_sub_title'>Incompatibility</span></td><td align='center' class='table_header'><span class='problem_sub_title'>Effect</span></td></tr>$InterfaceProblemsReport</table><br/>$ContentDivEnd\n";
6037 $HEADER_LIB_REPORT = insertIDs($HEADER_LIB_REPORT);
6038 }
6039 }
6040 if($HEADER_LIB_REPORT)
6041 {
6042 $INTERFACE_PROBLEMS .= "<span class='header_name'>$HeaderName</span>, <span class='solib_name'>$SoName</span><br/>\n".$HEADER_LIB_REPORT."<br/>";
6043 }
6044 }
6045 }
6046 if($INTERFACE_PROBLEMS)
6047 {
6048 $INTERFACE_PROBLEMS = "<a name=\'Interface_Problems_$TargetPriority\'></a>\n<h2 style='margin-bottom:0px;padding-bottom:0px;'>Interface problems, $TargetPriority risk ($Problems_Number)</h2><hr/>\n"."<!--Interface_Problems_".$TargetPriority."-->\n".$INTERFACE_PROBLEMS."<!--Interface_Problems_".$TargetPriority."_End-->\n"."<input id=\'Interface_Problems_$TargetPriority"."_Count"."\' type='hidden' value=\'$Problems_Number\' /><a style='font-size:11px;' href='#Top'>to the top</a><br/>\n";
6049 }
6050 return $INTERFACE_PROBLEMS;
6051}
6052
6053sub get_Report_TypeProblems($)
6054{
6055 my $TargetPriority = $_[0];
6056 my ($TYPE_PROBLEMS, %TypeHeader, %TypeChanges, %Type_MaxPriority) = ();
6057 foreach my $Interface (sort keys(%CompatProblems))
6058 {
6059 foreach my $Kind (keys(%{$CompatProblems{$Interface}}))
6060 {
6061 if($TypeProblems_Kind{$Kind})
6062 {
6063 foreach my $Location (keys(%{$CompatProblems{$Interface}{$Kind}}))
6064 {
6065 my $Type_Name = $CompatProblems{$Interface}{$Kind}{$Location}{"Type_Name"};
6066 my $Priority = $CompatProblems{$Interface}{$Kind}{$Location}{"Priority"};
6067 my $Type_Header = $CompatProblems{$Interface}{$Kind}{$Location}{"Header"};
6068 %{$TypeChanges{$Type_Name}{$Kind}{$Location}} = %{$CompatProblems{$Interface}{$Kind}{$Location}};
6069 $TypeHeader{$Type_Header}{$Type_Name} = 1;
6070 $Type_MaxPriority{$Type_Name}{$Kind} = max_priority($Type_MaxPriority{$Type_Name}{$Kind}, $Priority);
6071 }
6072 }
6073 }
6074 }
6075 foreach my $Type_Name (keys(%TypeChanges))
6076 {
6077 foreach my $Kind (keys(%{$TypeChanges{$Type_Name}}))
6078 {
6079 foreach my $Location (keys(%{$TypeChanges{$Type_Name}{$Kind}}))
6080 {
6081 my $Priority = $TypeChanges{$Type_Name}{$Kind}{$Location}{"Priority"};
6082 if(cmp_priority($Type_MaxPriority{$Type_Name}{$Kind}, $Priority))
6083 {
6084 delete($TypeChanges{$Type_Name}{$Kind}{$Location});
6085 }
6086 }
6087 }
6088 }
6089 my $Problems_Number = 0;
6090 foreach my $HeaderName (sort {lc($a) cmp lc($b)} keys(%TypeHeader))
6091 {
6092 my $HEADER_REPORT = "";
6093 foreach my $TypeName (sort {lc($a) cmp lc($b)} keys(%{$TypeHeader{$HeaderName}}))
6094 {
6095 my $ProblemNum = 1;
6096 my $TypeProblemsReport = "";
6097 my %Kinds_Locations = ();
6098 my %Kinds_Target = ();
6099 foreach my $Kind (keys(%{$TypeChanges{$TypeName}}))
6100 {
6101 foreach my $Location (keys(%{$TypeChanges{$TypeName}{$Kind}}))
6102 {
6103 my $Priority = $TypeChanges{$TypeName}{$Kind}{$Location}{"Priority"};
6104 next if($Priority ne $TargetPriority);
6105 $Kinds_Locations{$Kind}{$Location} = 1;
6106 my $Incompatibility = "";
6107 my $Effect = "";
6108 my $Target = $TypeChanges{$TypeName}{$Kind}{$Location}{"Target"};
6109 next if($Kinds_Target{$Kind}{$Target});
6110 $Kinds_Target{$Kind}{$Target} = 1;
6111 my $Old_Value = htmlSpecChars($TypeChanges{$TypeName}{$Kind}{$Location}{"Old_Value"});
6112 my $New_Value = htmlSpecChars($TypeChanges{$TypeName}{$Kind}{$Location}{"New_Value"});
6113 my $Old_Size = $TypeChanges{$TypeName}{$Kind}{$Location}{"Old_Size"};
6114 my $New_Size = $TypeChanges{$TypeName}{$Kind}{$Location}{"New_Size"};
6115 my $Type_Type = $TypeChanges{$TypeName}{$Kind}{$Location}{"Type_Type"};
6116 my $InitialType_Type = $TypeChanges{$TypeName}{$Kind}{$Location}{"InitialType_Type"};
6117
6118 if($Kind eq "Added_Virtual_Function")
6119 {
6120 $Incompatibility = "Virtual method "."<span class='interface_name_black'>".highLight_Signature(htmlSpecChars($Target))."</span>"." has been added to this class and therefore the layout of virtual table has been changed.";
6121 $Effect = "Call of any virtual method in this class or its subclasses will result in crash of application.";
6122 }
6123 elsif($Kind eq "Withdrawn_Virtual_Function")
6124 {
6125 $Incompatibility = "Virtual method "."<span class='interface_name_black'>".highLight_Signature(htmlSpecChars($Target))."</span>"." has been withdrawn from this class and therefore the layout of virtual table has been changed.";
6126 $Effect = "Call of any virtual method in this class or its subclasses will result in crash of application.";
6127 }
6128 elsif($Kind eq "Virtual_Function_Position")
6129 {
6130 $Incompatibility = "The relative position of virtual method "."<span class='interface_name_black'>".highLight_Signature(htmlSpecChars($Target))."</span>"." has been changed from <b>$Old_Value</b> to <b>$New_Value</b> and therefore the layout of virtual table has been changed.";
6131 $Effect = "Call of this virtual method will result in crash of application.";
6132 }
6133 elsif($Kind eq "Virtual_Function_Redefinition")
6134 {
6135 $Incompatibility = "Virtual method "."<span class='interface_name_black'>".highLight_Signature(htmlSpecChars($Old_Value))."</span>"." has been redefined by "."<span class='interface_name_black'>".highLight_Signature(htmlSpecChars($New_Value))."</span>";
6136 $Effect = "Method <span class='interface_name_black'>".highLight_Signature(htmlSpecChars($New_Value))."</span> will be called instead of <span class='interface_name_black'>".highLight_Signature(htmlSpecChars($Old_Value))."</span>";
6137 }
6138 elsif($Kind eq "Virtual_Function_Redefinition_B")
6139 {
6140 $Incompatibility = "Virtual method "."<span class='interface_name_black'>".highLight_Signature(htmlSpecChars($New_Value))."</span>"." has been redefined by "."<span class='interface_name_black'>".highLight_Signature(htmlSpecChars($Old_Value))."</span>";
6141 $Effect = "Method <span class='interface_name_black'>".highLight_Signature(htmlSpecChars($Old_Value))."</span> will be called instead of <span class='interface_name_black'>".highLight_Signature(htmlSpecChars($New_Value))."</span>";
6142 }
6143 elsif($Kind eq "Size")
6144 {
6145 $Incompatibility = "Size of this type has been changed from <b>$Old_Value</b> to <b>$New_Value</b> bytes.";
6146 $Effect = "Change of type size may lead to different effects in different contexts. $ContentSpanStart"."<span style='color:Black'>[+] ...</span>"."$ContentSpanEnd <label id=\"CONTENT_ID\" style=\"display:none;\"> In the context of function parameters, this change affects the parameter's stack layout and may lead to incorrect initialization of parameters in higher positions in the stack. In the context of structure members, this change affects the member's layout and may lead to incorrect attempts to access members in higher positions. Other effects are possible.</label>";
6147 }
6148 elsif($Kind eq "BaseType")
6149 {
6150 $Incompatibility = "Base of this type has been changed from <b>$Old_Value</b> to <b>$New_Value</b>.";
6151 $Effect = "Possible incorrect initialization of interface parameters by applications.";
6152 }
6153 elsif($Kind eq "Added_Member_And_Size")
6154 {
6155 $Incompatibility = "Member <b>$Target</b> has been added to this type.";
6156 $Effect = "The size of the inclusive type has been changed.";
6157 }
6158 elsif($Kind eq "Added_Middle_Member_And_Size")
6159 {
6160 $Incompatibility = "Member <b>$Target</b> has been added between the first member and the last member of this structural type.";
6161 $Effect = "1) Layout of structure members has been changed and therefore members in higher positions in the structure definition may be incorrectly accessed by applications.<br/>2) The size of the inclusive type will also be affected.";
6162 }
6163 elsif($Kind eq "Member_Rename")
6164 {
6165 $Incompatibility = "Member <b>$Target</b> has been renamed to <b>$New_Value</b>.";
6166 $Effect = "Renaming of a member in a structural data type may indicate a change in the semantic meaning of the member.";
6167 }
6168 elsif($Kind eq "Withdrawn_Member_And_Size")
6169 {
6170 $Incompatibility = "Member <b>$Target</b> has been withdrawn from this type.";
6171 $Effect = "1) Applications will access incorrect memory when attempting to access this member.<br/>2) The size of the inclusive type will also be affected.";
6172 }
6173 elsif($Kind eq "Withdrawn_Member")
6174 {
6175 $Incompatibility = "Member <b>$Target</b> has been withdrawn from this type.";
6176 $Effect = "Applications will access incorrect memory when attempting to access this member.";
6177 }
6178 elsif($Kind eq "Withdrawn_Middle_Member_And_Size")
6179 {
6180 $Incompatibility = "Member <b>$Target</b> has been withdrawn from this structural type between the first member and the last member.";
6181 $Effect = "1) Layout of structure members has been changed and therefore members in higher positions in the structure definition may be incorrectly accessed by applications.<br/>2) Previous accesses of applications to the withdrawn member will be incorrect.";
6182 }
6183 elsif($Kind eq "Withdrawn_Middle_Member")
6184 {
6185 $Incompatibility = "Member <b>$Target</b> has been withdrawn from this structural type between the first member and the last member.";
6186 $Effect = "1) Layout of structure members has been changed and therefore members in higher positions in the structure definition may be incorrectly accessed by applications.<br/>2) Applications will access incorrect memory when attempting to access this member.";
6187 }
6188 elsif($Kind eq "Enum_Member_Value")
6189 {
6190 $Incompatibility = "Value of member <b>$Target</b> has been changed from <b>$Old_Value</b> to <b>$New_Value</b>.";
6191 $Effect = "Applications may execute another branch of library code.";
6192 }
6193 elsif($Kind eq "Enum_Member_Name")
6194 {
6195 $Incompatibility = "Name of member with value <b>$Target</b> has been changed from <b>$Old_Value</b> to <b>$New_Value</b>.";
6196 $Effect = "Applications may execute another branch of library code.";
6197 }
6198 elsif($Kind eq "Member_Type_And_Size")
6199 {
6200 $Incompatibility = "Type of member <b>$Target</b> has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b> (<b>$Old_Size</b> bytes)</span> to <span style='white-space:nowrap;'><b>$New_Value</b> (<b>$New_Size</b> bytes)</span>.";
6201 $Effect = "Layout of structure members has been changed and therefore members in higher positions in the structure definition may be incorrectly accessed by applications.";
6202 }
6203 elsif($Kind eq "Member_Type")
6204 {
6205 $Incompatibility = "Type of member <b>$Target</b> has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b></span> to <span style='white-space:nowrap;'><b>$New_Value</b></span>.";
6206 $Effect = "Replacement of the member data type may indicate a change in the semantic meaning of the member.";
6207 }
6208 elsif($Kind eq "Member_BaseType_And_Size")
6209 {
6210 if($InitialType_Type eq "Pointer")
6211 {
6212 $Incompatibility = "Base type of member <b>$Target</b> (pointer) has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b> (<b>$Old_Size</b> bytes)</span> to <span style='white-space:nowrap;'><b>$New_Value</b> (<b>$New_Size</b> bytes)</span>.";
6213 $Effect = "Possible access of applications to incorrect memory via member pointer.";
6214 }
6215 else
6216 {
6217 $Incompatibility = "Base type of member <b>$Target</b> has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b> (<b>$Old_Size</b> bytes)</span> to <span style='white-space:nowrap;'><b>$New_Value</b> (<b>$New_Size</b> bytes)</span>.";
6218 $Effect = "Layout of structure members has been changed and therefore members in higher positions in structure definition may be incorrectly accessed by applications.";
6219 }
6220 }
6221 elsif($Kind eq "Member_BaseType")
6222 {
6223 if($InitialType_Type eq "Pointer")
6224 {
6225 $Incompatibility = "Base type of member <b>$Target</b> (pointer) has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b></span> to <span style='white-space:nowrap;'><b>$New_Value</b></span>.";
6226 $Effect = "Possible access of applications to incorrect memory via member pointer.";
6227 }
6228 else
6229 {
6230 $Incompatibility = "Base type of member <b>$Target</b> has been changed from <span style='white-space:nowrap;'><b>$Old_Value</b></span> to <span style='white-space:nowrap;'><b>$New_Value</b></span>.";
6231 $Effect = "Replacement of member base type may indicate a change in the semantic meaning of this member.";
6232 }
6233 }
6234 elsif($Kind eq "Member_PointerLevel")
6235 {
6236 $Incompatibility = "Type pointer level of member <b>$Target</b> has been changed from <b>$Old_Value</b> to <b>$New_Value</b>.";
6237 $Effect = "Possible incorrect initialization of member <b>$Target</b> by applications.";
6238 }
6239 if($Incompatibility)
6240 {
6241 $TypeProblemsReport .= "<tr><td align='center' valign='top' class='table_header'><span class='problem_num'>$ProblemNum</span></td><td align='left' valign='top'><span class='problem_body'>".$Incompatibility."</span></td><td align='left' valign='top'><span class='problem_body'>$Effect</span></td></tr>\n";
6242 $ProblemNum += 1;
6243 $Problems_Number += 1;
6244 $Kinds_Locations{$Kind}{$Location} = 1;
6245 }
6246 }
6247 }
6248 $ProblemNum -= 1;
6249 if($TypeProblemsReport)
6250 {
6251 my ($Affected_Interfaces_Header, $Affected_Interfaces) = getAffectedInterfaces($TypeName, \%Kinds_Locations);
6252 $HEADER_REPORT .= $ContentSpanStart."<span class='extension'>[+]</span> ".htmlSpecChars($TypeName)." ($ProblemNum)".$ContentSpanEnd."<br/>\n$ContentDivStart<table width='900px' cellpadding='3' cellspacing='0' class='problems_table'><tr><td align='center' width='2%' class='table_header'><span class='problem_title' style='white-space:nowrap;'></span></td><td width='47%' align='center' class='table_header'><span class='problem_sub_title'>Incompatibility</span></td><td align='center' class='table_header'><span class='problem_sub_title'>Effect</span></td></tr>$TypeProblemsReport</table>"."<span style='padding-left:10px'>$Affected_Interfaces_Header</span>$Affected_Interfaces<br/><br/>$ContentDivEnd\n";
6253 $HEADER_REPORT = insertIDs($HEADER_REPORT);
6254 }
6255 }
6256 if($HEADER_REPORT)
6257 {
6258 $TYPE_PROBLEMS .= "<span class='header_name'>$HeaderName</span><br/>\n".$HEADER_REPORT."<br/>";
6259 }
6260 }
6261 if($TYPE_PROBLEMS)
6262 {
6263 my $Notations = "";
6264 if($TYPE_PROBLEMS =~ /'RetVal|'Obj/)
6265 {
6266 my @Notations_Array = ();
6267 if($TYPE_PROBLEMS =~ /'RetVal/)
6268 {
6269 @Notations_Array = (@Notations_Array, "<span style='color:#444444;padding-left:5px;'><b>RetVal</b></span> - function's return value");
6270 }
6271 if($TYPE_PROBLEMS =~ /'Obj/)
6272 {
6273 @Notations_Array = (@Notations_Array, "<span style='color:#444444;'><b>Obj</b></span> - method's object (C++)");
6274 }
6275 $Notations = "Shorthand notations: ".join("; ", @Notations_Array).".<br/>\n";
6276 }
6277 $TYPE_PROBLEMS = "<a name=\'Type_Problems_$TargetPriority\'></a>\n<h2 style='margin-bottom:0px;padding-bottom:0px;'>Problems in Data Types, $TargetPriority risk ($Problems_Number)</h2><hr/>\n".$Notations."<!--Type_Problems_".$TargetPriority."-->\n".$TYPE_PROBLEMS."<!--Type_Problems_".$TargetPriority."_End-->\n"."<input id=\'Type_Problems_$TargetPriority"."_Count"."\' type='hidden' value=\'$Problems_Number\' /><a style='font-size:11px;' href='#Top'>to the top</a><br/>\n";
6278 }
6279 return $TYPE_PROBLEMS;
6280}
6281
6282my $ContentSpanStart_2 = "<span style='line-height:25px;' class=\"section_2\" onclick=\"javascript:showContent(this, 'CONTENT_ID')\">\n";
6283
6284sub getAffectedInterfaces($$)
6285{
6286 my ($Target_TypeName, $Kinds_Locations) = @_;
6287 my ($Affected_Interfaces_Header, $Affected_Interfaces, %FunctionNumber) = ();
6288 foreach my $Interface (sort {lc($tr_name{$a}) cmp lc($tr_name{$b})} keys(%CompatProblems))
6289 {
6290 next if(($Interface =~ /C2/) or ($Interface =~ /D2/) or ($Interface =~ /D0/));
6291 next if(keys(%FunctionNumber)>1000);
6292 my $FunctionProblem = "";
6293 my $MinPath_Length = "";
6294 my $MaxPriority = 0;
6295 my $Location_Last = "";
6296 foreach my $Kind (keys(%{$CompatProblems{$Interface}}))
6297 {
6298 foreach my $Location (keys(%{$CompatProblems{$Interface}{$Kind}}))
6299 {
6300 next if(not $Kinds_Locations->{$Kind}{$Location});
6301 my $Type_Name = $CompatProblems{$Interface}{$Kind}{$Location}{"Type_Name"};
6302 my $Signature = $CompatProblems{$Interface}{$Kind}{$Location}{"Signature"};
6303 my $Parameter_Position = $CompatProblems{$Interface}{$Kind}{$Location}{"Parameter_Position"};
6304 my $Priority = $CompatProblems{$Interface}{$Kind}{$Location}{"Priority"};
6305 if($Type_Name eq $Target_TypeName)
6306 {
6307 $FunctionNumber{$Interface} = 1;
6308 my $Path_Length = 0;
6309 while($Location =~ /\-\>/g){$Path_Length += 1;}
6310 if(($MinPath_Length eq "") or ($Path_Length<$MinPath_Length and $Priority_Value{$Priority}>$MaxPriority) or (($Location_Last =~ /RetVal/ or $Location_Last =~ /Obj/) and $Location !~ /RetVal|Obj/ and $Location !~ /\-\>/) or ($Location_Last =~ /RetVal|Obj/ and $Location_Last =~ /\-\>/ and $Location !~ /RetVal|Obj/ and $Location =~ /\-\>/))
6311 {
6312 $MinPath_Length = $Path_Length;
6313 $MaxPriority = $Priority_Value{$Priority};
6314 $Location_Last = $Location;
6315 my $Description = get_AffectDescription($Interface, $Kind, $Location);
6316 $FunctionProblem = "<span class='interface_name_black' style='padding-left:20px;'>".highLight_Signature_PPos_Italic(htmlSpecChars($Signature), $Parameter_Position, 1, 0)."</span>:<br/>"."<span class='affect_description'>".addArrows($Description)."</span><br/><div style='height:4px;'>&nbsp;</div>\n";
6317 }
6318 }
6319 }
6320 }
6321 $Affected_Interfaces .= $FunctionProblem;
6322 }
6323 $Affected_Interfaces .= "and other...<br/>" if(keys(%FunctionNumber)>5000);
6324 if($Affected_Interfaces)
6325 {
6326 $Affected_Interfaces_Header = $ContentSpanStart_2."[+] affected interfaces (".keys(%FunctionNumber).")".$ContentSpanEnd;
6327 $Affected_Interfaces = $ContentDivStart.$Affected_Interfaces.$ContentDivEnd;
6328 }
6329 return ($Affected_Interfaces_Header, $Affected_Interfaces);
6330}
6331
6332my %Kind_TypeStructureChanged=(
6333 "Size"=>1,
6334 "Added_Member_And_Size"=>1,
6335 "Added_Middle_Member_And_Size"=>1,
6336 "Member_Rename"=>1,
6337 "Withdrawn_Member_And_Size"=>1,
6338 "Withdrawn_Member"=>1,
6339 "Withdrawn_Middle_Member_And_Size"=>1,
6340 "Enum_Member_Value"=>1,
6341 "Enum_Member_Name"=>1,
6342 "Member_Type_And_Size"=>1,
6343 "Member_Type"=>1,
6344 "Member_BaseType_And_Size"=>1,
6345 "Member_BaseType"=>1,
6346 "Member_PointerLevel"=>1,
6347 "BaseType"=>1
6348);
6349
6350my %Kind_VirtualTableChanged=(
6351 "Added_Virtual_Function"=>1,
6352 "Withdrawn_Virtual_Function"=>1,
6353 "Virtual_Function_Position"=>1,
6354 "Virtual_Function_Redefinition"=>1,
6355 "Virtual_Function_Redefinition_B"=>1
6356);
6357
6358sub get_AffectDescription($$$)
6359{
6360 my ($Interface, $Kind, $Location) = @_;
6361 my $Target = $CompatProblems{$Interface}{$Kind}{$Location}{"Target"};
6362 my $Old_Value = $CompatProblems{$Interface}{$Kind}{$Location}{"Old_Value"};
6363 my $New_Value = $CompatProblems{$Interface}{$Kind}{$Location}{"New_Value"};
6364 my $Type_Name = $CompatProblems{$Interface}{$Kind}{$Location}{"Type_Name"};
6365 my $Parameter_Position = $CompatProblems{$Interface}{$Kind}{$Location}{"Parameter_Position"};
6366 my $Parameter_Name = $CompatProblems{$Interface}{$Kind}{$Location}{"Parameter_Name"};
6367 my $Parameter_Type_Name = $CompatProblems{$Interface}{$Kind}{$Location}{"Parameter_Type_Name"};
6368 my $Member_Type_Name = $CompatProblems{$Interface}{$Kind}{$Location}{"Member_Type_Name"};
6369 my $Object_Type_Name = $CompatProblems{$Interface}{$Kind}{$Location}{"Object_Type_Name"};
6370 my $Return_Type_Name = $CompatProblems{$Interface}{$Kind}{$Location}{"Return_Type_Name"};
6371 my $Start_Type_Name = $CompatProblems{$Interface}{$Kind}{$Location}{"Start_Type_Name"};
6372 my $InitialType_Type = $CompatProblems{$Interface}{$Kind}{$Location}{"InitialType_Type"};
6373 my $Parameter_Position_Str = num_to_str($Parameter_Position + 1);
6374 my @Sentence_Parts = ();
6375 my $Location_To_Type = $Location;
6376 $Location_To_Type =~ s/\-\>[^>]+?\Z//;
6377 if($Kind_VirtualTableChanged{$Kind})
6378 {
6379 if($Kind eq "Virtual_Function_Redefinition")
6380 {
6381 @Sentence_Parts = (@Sentence_Parts, "This method become virtual and will be called instead of redefined method '".highLight_Signature(htmlSpecChars($Old_Value))."'.");
6382 }
6383 elsif($Kind eq "Virtual_Function_Redefinition_B")
6384 {
6385 @Sentence_Parts = (@Sentence_Parts, "This method become non-virtual and redefined method '".highLight_Signature(htmlSpecChars($Old_Value))."' will be called instead of it.");
6386 }
6387 else
6388 {
6389 @Sentence_Parts = (@Sentence_Parts, "Call of this virtual method will result in crash of application because the layout of virtual table has been changed.");
6390 }
6391 }
6392 elsif($Kind_TypeStructureChanged{$Kind})
6393 {
6394 if($Location_To_Type =~ /RetVal/)
6395 {#return value
6396 if($Location_To_Type =~ /\-\>/)
6397 {
6398 @Sentence_Parts = (@Sentence_Parts, "Member \'$Location_To_Type\' in return value");
6399 }
6400 else
6401 {
6402 @Sentence_Parts = (@Sentence_Parts, "Return value");
6403 }
6404 }
6405 elsif($Location_To_Type =~ /Obj/)
6406 {#object
6407 if($Location_To_Type =~ /\-\>/)
6408 {
6409 @Sentence_Parts = (@Sentence_Parts, "Member \'$Location_To_Type\' in the object of this method");
6410 }
6411 else
6412 {
6413 @Sentence_Parts = (@Sentence_Parts, "Object");
6414 }
6415 }
6416 else
6417 {#parameters
6418 if($Location_To_Type =~ /\-\>/)
6419 {
6420 @Sentence_Parts = (@Sentence_Parts, "Member \'$Location_To_Type\' of $Parameter_Position_Str parameter");
6421 }
6422 else
6423 {
6424 @Sentence_Parts = (@Sentence_Parts, "$Parameter_Position_Str parameter");
6425 }
6426 if($Parameter_Name)
6427 {
6428 @Sentence_Parts = (@Sentence_Parts, "\'$Parameter_Name\'");
6429 }
6430 if($InitialType_Type eq "Pointer")
6431 {
6432 @Sentence_Parts = (@Sentence_Parts, "(pointer)");
6433 }
6434 }
6435 if($Start_Type_Name eq $Type_Name)
6436 {
6437 @Sentence_Parts = (@Sentence_Parts, "has type \'$Type_Name\'.");
6438 }
6439 else
6440 {
6441 @Sentence_Parts = (@Sentence_Parts, "has base type \'$Type_Name\'.");
6442 }
6443 }
6444 return join(" ", @Sentence_Parts);
6445}
6446
6447sub create_HtmlReport()
6448{
6449 my $CssStyles = "<style type=\"text/css\">
6450 body{font-family:Arial;}
6451 hr{color:Black;background-color:Black;height:1px;border:0;}
6452 span.section{font-weight:bold;cursor:pointer;margin-left:7px;font-size:16px;font-family:Arial;color:#003E69;}
6453 span:hover.section{color:#336699;}
6454 span.section_2{cursor:pointer;margin-left:7px;font-size:14px;font-family:Arial;color:#cc3300;}
6455 span.extension{font-weight:100;font-size:16px;}
6456 span.problem_exact_location{color:Red;font-size:14px;}
6457 span.header_name{color:#cc3300;font-size:14px;font-family:Arial;font-weight:bold;}
6458 span.header_list_elem{padding-left:10px;color:#333333;font-size:15px;font-family:Arial;}
6459 span.solib_list_elem{padding-left:10px;color:#333333;font-size:15px;font-family:Arial;}
6460 span.solib_name{color:Green;font-size:14px;font-family:Arial;font-weight:bold;}
6461 span.interface_name{font-weight:bold;font-size:16px;font-family:Arial;color:#003E69;margin-left:7px;}
6462 span.interface_name_black{font-weight:bold;font-size:15px;font-family:Arial;color:#333333;}
6463 span.problem_title{color:#333333;font-weight:bold;font-size:13px;font-family:Verdana;}
6464 span.problem_sub_title{color:#333333;text-decoration:none;font-weight:bold;font-size:13px;font-family:Verdana;}
6465 span.problem_body{color:Black;font-size:14px;}
6466 span.int_p{font-weight:normal;}
6467 span.affect_description{padding-left:30px;font-size:14px;font-style:italic;line-height:13px;}
6468 table.problems_table{line-height:16px;margin-left:15px;margin-top:3px;border-collapse:collapse;}
6469 table.problems_table td{border-style:solid;border-color:Gray;border-width:1px;}
6470 td.table_header{background-color:#eeeeee;}
6471 td.summary_item{font-size:15px;font-family:Arial;text-align:left;}
6472 td.summary_item_value{padding-left:5px;padding-right:5px;width:35px;text-align:right;}
6473 span.problem_num{color:#333333;font-weight:bold;font-size:13px;font-family:Verdana;}
6474 span.mangled{padding-left:15px;font-size:13px;cursor:text;color:#444444;}
6475 span.symver{color:#555555;font-size:13px;white-space:nowrap;}
6476 span.color_param{font-style:italic;color:Brown;}
6477 span.focus_param{font-style:italic;color:Red;}</style>";
6478
6479 my $JScripts = "<script type=\"text/javascript\" language=\"JavaScript\">
6480 function showContent(header, id) {
6481 e = document.getElementById(id);
6482 if(e.style.display == 'none')
6483 {
6484 e.style.display = '';
6485 e.style.visibility = 'visible';
6486 header.innerHTML = header.innerHTML.replace(/\\\[[^0-9 ]\\\]/gi,\"[&minus;]\");
6487 }
6488 else
6489 {
6490 e.style.display = 'none';
6491 e.style.visibility = 'hidden';
6492 header.innerHTML = header.innerHTML.replace(/\\\[[^0-9 ]\\\]/gi,\"[+]\");
6493 }
6494 }</script>";
6495
6496 writeFile("$REPORT_PATH/abi_compat_report.html", "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\" lang=\"en\">\n<head>\n<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />
6497 <title>ABI compliance report for the library $TargetLibraryName from version ".$Descriptor{1}{"Version"}." to ".$Descriptor{2}{"Version"}." on ".getArch()."\n</title>\n<!--Styles-->\n".$CssStyles."\n<!--Styles_End-->\n"."<!--JScripts-->\n".$JScripts."\n<!--JScripts_End-->\n</head>\n<body>\n<div><a name='Top'></a>\n".get_Report_Header()."<br/>\n".get_Summary()."<br/>\n".get_Report_Added().get_Report_Withdrawn().get_Report_TypeProblems("High").get_Report_TypeProblems("Medium").get_Report_TypeProblems("Low").get_Report_InterfaceProblems("High").get_Report_InterfaceProblems("Medium").get_Report_InterfaceProblems("Low").get_Report_ChangedConstants().get_SourceInfo()."</div>\n"."<br/><br/><br/><hr/><div style='width:100%;font-family:Arial;font-size:11px;' align='right'><i>Generated on ".(localtime time)." for <span style='font-weight:bold'>$TargetLibraryName</span> by <a href='http://ispras.linux-foundation.org/index.php/ABI_compliance_checker'>ABI-compliance-checker</a> $ABI_COMPLIANCE_CHECKER_VERSION &nbsp;</i></div>\n<div style='height:999px;'></div>\n</body></html>");
6498}
6499
6500sub trivialCmp($$)
6501{
6502 if(int($_[0]) > int($_[1]))
6503 {
6504 return 1;
6505 }
6506 elsif($_[0] eq $_[1])
6507 {
6508 return 0;
6509 }
6510 else
6511 {
6512 return -1;
6513 }
6514}
6515
6516sub addArrows($)
6517{
6518 my $Text = $_[0];
6519 #$Text =~ s/\-\>/&#8594;/g;
6520 $Text =~ s/\-\>/&minus;&gt;/g;
6521 return $Text;
6522}
6523
6524sub insertIDs($)
6525{
6526 my $Text = $_[0];
6527 while($Text =~ /CONTENT_ID/)
6528 {
6529 if(int($Content_Counter)%2)
6530 {
6531 $ContentID -= 1;
6532 }
6533 $Text =~ s/CONTENT_ID/c_$ContentID/;
6534 $ContentID += 1;
6535 $Content_Counter += 1;
6536 }
6537 return $Text;
6538}
6539
6540sub restrict_num_decimal_digits
6541{
6542 my $num=shift;
6543 my $digs_to_cut=shift;
6544
6545 if ($num=~/\d+\.(\d){$digs_to_cut,}/)
6546 {
6547 $num=sprintf("%.".($digs_to_cut-1)."f", $num);
6548 }
6549 return $num;
6550}
6551
6552sub parse_constants()
6553{
6554 my $CurHeader = "";
6555 foreach my $String (split("\n", $ConstantsSrc{$Version}))
6556 {#detecting public and private constants using sources
6557 if($String=~/#[ \t]+\d+[ \t]+\"(.+)\"/)
6558 {
6559 $CurHeader=$1;
6560 }
6561 if($String=~/\#[ \t]*define[ \t]+([_A-Z]+)[ \t]+(.*)[ \t]*\Z/)
6562 {
6563 my ($Name, $Value) = ($1, $2);
6564 if(not $Constants{$Version}{$Name}{"Access"})
6565 {
6566 $Constants{$Version}{$Name}{"Access"} = "public";
6567 $Constants{$Version}{$Name}{"Value"} = $Value;
6568 $Constants{$Version}{$Name}{"Header"} = get_FileName($CurHeader);
6569 }
6570 }
6571 elsif($String=~/\#[ \t]*undef[ \t]+([_A-Z]+)[ \t]*/)
6572 {
6573 my $Name = $1;
6574 $Constants{$Version}{$Name}{"Access"} = "private";
6575 }
6576 }
6577 foreach my $Constant (keys(%{$Constants{$Version}}))
6578 {
6579 if(($Constants{$Version}{$Constant}{"Access"} eq "private") or not $Constants{$Version}{$Constant}{"Value"}
6580 or $Constant=~/_h\Z/i)
6581 {
6582 delete($Constants{$Version}{$Constant});
6583 }
6584 else
6585 {
6586 delete($Constants{$Version}{$Constant}{"Access"});
6587 }
6588 }
6589}
6590
6591sub mergeConstants()
6592{
6593 return if(defined $AppPath);
6594 foreach my $Constant (keys(%{$Constants{1}}))
6595 {
6596 my $Old_Value = $Constants{1}{$Constant}{"Value"};
6597 my $New_Value = $Constants{2}{$Constant}{"Value"};
6598 my $Header = $Constants{1}{$Constant}{"Header"};
6599 if($New_Value and $Old_Value and ($New_Value ne $Old_Value))
6600 {
6601 %{$ConstantProblems{$Constant}} = (
6602 "Old_Value"=>$Old_Value,
6603 "New_Value"=>$New_Value,
6604 "Header"=>$Header
6605 );
6606 }
6607 }
6608}
6609
6610sub mergeHeaders_Separately()
6611{
6612 system("mkdir", "-p", "header_compile_errors/".$TargetLibraryName);
6613 system("rm", "-fr", $ERR_PATH{1}, $ERR_PATH{2});
6614 my ($Header_Num, $Prev_Header_Length) = (0, 0);
6615 my $All_Count = keys(%{$Headers{1}});
6616 foreach my $Header_Dest (sort {int($Headers{1}{$a}{"Position"})<=>int($Headers{1}{$b}{"Position"})} keys(%{$Headers{1}}))
6617 {
6618 my $Header_Name = $Headers{1}{$Header_Dest}{"Name"};
6619 my $Dest_Count = keys(%{$HeaderName_Destinations{1}{$Header_Name}});
6620 my $Identity = $Headers{1}{$Header_Dest}{"Identity"};
6621 my $Dest_Comment = ($Dest_Count>1 and $Identity=~/\//)?" ($Identity)":"";
6622 print get_one_step_title($Header_Name.$Dest_Comment, $Header_Num, $All_Count, $Prev_Header_Length, 1)."\r";
6623 %TypeDescr = ();
6624 %FuncDescr = ();
6625 %ClassFunc = ();
6626 %ClassVirtFunc = ();
6627 %LibInfo = ();
6628 %CompleteSignature = ();
6629 %Cache = ();
6630 $Version = 1;
6631 parseHeader($Header_Dest);
6632 $Version = 2;
6633 my $PairHeaderDest = find_pair_header($Header_Dest);
6634 if(not $PairHeaderDest)
6635 {
6636 $Header_Num += 1;
6637 next;
6638 }
6639 parseHeader($PairHeaderDest);
6640 mergeSignatures();
6641 mergeConstants();
6642 $Header_Num += 1;
6643 $Prev_Header_Length = length($Header_Name.$Dest_Comment);
6644 }
6645 print get_one_step_title("", $All_Count, $All_Count, $Prev_Header_Length, 0)."\n";
6646}
6647
6648sub get_one_step_title($$$$$)
6649{
6650 my ($Header_Name, $Num, $All_Count, $SpacesAtTheEnd, $ShowCurrent) = @_;
6651 my ($Spaces_1, $Spaces_2, $Title) = ();
6652 my $Title_1 = "checking headers: $Num/$All_Count [".restrict_num_decimal_digits($Num*100/$All_Count, 3)."%]".(($ShowCurrent)?",":"");
6653 foreach (0 .. length("checking headers: ")+length($All_Count)*2+11 - length($Title_1))
6654 {
6655 $Spaces_1 .= " ";
6656 }
6657 $Title .= $Title_1.$Spaces_1;
6658 if($ShowCurrent)
6659 {
6660 my $Title_2 = "current: $Header_Name";
6661 foreach (0 .. $SpacesAtTheEnd - length($Header_Name)-1)
6662 {
6663 $Spaces_2 .= " ";
6664 }
6665 $Title .= $Title_2.$Spaces_2;
6666 }
6667 else
6668 {
6669 foreach (0 .. $SpacesAtTheEnd + length(" current: ") - 1)
6670 {
6671 $Title .= " ";
6672 }
6673 }
6674 return $Title."\r";
6675}
6676
6677sub find_pair_header($)
6678{
6679 my $Header_Dest = $_[0];
6680 my $Header_Name = $Headers{1}{$Header_Dest}{"Name"};
6681 my $Identity = $Headers{1}{$Header_Dest}{"Identity"};
6682 my @Pair_Dest = keys(%{$HeaderName_Destinations{2}{$Header_Name}});
6683 if($#Pair_Dest==0)
6684 {
6685 return $Pair_Dest[0];
6686 }
6687 elsif($#Pair_Dest==-1)
6688 {
6689 return "";
6690 }
6691 else
6692 {
6693 foreach my $Pair_Dest (@Pair_Dest)
6694 {
6695 my $Pair_Identity = $Headers{2}{$Pair_Dest}{"Identity"};
6696 if($Identity eq $Pair_Identity)
6697 {
6698 return $Pair_Dest;
6699 }
6700 }
6701 return "";
6702 }
6703}
6704
6705sub getSymbols($)
6706{
6707 my $LibVersion = $_[0];
6708 my @SoLibPaths = getSoPaths($LibVersion);
6709 if($#SoLibPaths eq -1 and not $CheckHeadersOnly)
6710 {
6711 print "ERROR: shared objects were not found\n";
6712 exit(1);
6713 }
6714 foreach my $SoLibPath (@SoLibPaths)
6715 {
6716 getSymbols_Lib($LibVersion, $SoLibPath, 0);
6717 }
6718}
6719
6720sub separatePath($)
6721{
6722 return ("", $_[0])if($_[0] !~ /\//);
6723 if($_[0] =~ /\A(.*\/)([^\/]*)\Z/)
6724 {
6725 return ($1, $2);
6726 }
6727 else
6728 {
6729 return ("", $_[0]);
6730 }
6731}
6732
6733sub translateSymbols($)
6734{
6735 my $LibVersion = $_[0];
6736 my (@MnglNames, @UnMnglNames) = ();
6737 foreach my $Interface (sort keys(%{$Interface_Library{$LibVersion}}))
6738 {
6739 if($Interface =~ /\A_Z/)
6740 {
6741 $Interface =~ s/[\@]+(.*)\Z//;
6742 push(@MnglNames, $Interface);
6743 }
6744 else
6745 {
6746 $tr_name{$Interface} = $Interface;
6747 $mangled_name{$tr_name{$Interface}} = $Interface;
6748 }
6749 }
6750 if($#MnglNames > -1)
6751 {
6752 @UnMnglNames = reverse(unmangleArray(@MnglNames));
6753 foreach my $Interface (sort keys(%{$Interface_Library{$LibVersion}}))
6754 {
6755 if($Interface =~ /\A_Z/)
6756 {
6757 $Interface =~ s/[\@]+(.*)\Z//;
6758 $tr_name{$Interface} = pop(@UnMnglNames);
6759 $mangled_name{correctName($tr_name{$Interface})} = $Interface;
6760 }
6761 }
6762 }
6763}
6764
6765sub detectAdded()
6766{
6767 #detecting added
6768 foreach my $Interface (keys(%{$Interface_Library{2}}))
6769 {
6770 if(not $Interface_Library{1}{$Interface})
6771 {
6772 $AddedInt{$Interface} = 1;
6773 my ($MnglName, $SymbolVersion) = ($Interface, "");
6774 if($Interface =~ /\A(.+)[\@]+(.+)\Z/)
6775 {
6776 ($MnglName, $SymbolVersion) = ($1, $2);
6777 }
6778 $FuncAttr{2}{$Interface}{"Signature"} = $tr_name{$MnglName}.(($SymbolVersion)?"\@".$SymbolVersion:"");
6779 }
6780 }
6781}
6782
6783sub detectWithdrawn()
6784{
6785 #detecting withdrawn
6786 foreach my $Interface (keys(%{$Interface_Library{1}}))
6787 {
6788 if(not $Interface_Library{2}{$Interface} and not $Interface_Library{2}{$SymVer{2}{$Interface}})
6789 {
6790 next if($DepInterfaces{2}{$Interface});
6791 $WithdrawnInt{$Interface} = 1;
6792 my ($MnglName, $SymbolVersion) = ($Interface, "");
6793 if($Interface =~ /\A(.+)[\@]+(.+)\Z/)
6794 {
6795 ($MnglName, $SymbolVersion) = ($1, $2);
6796 }
6797 $FuncAttr{1}{$Interface}{"Signature"} = $tr_name{$MnglName}.(($SymbolVersion)?"\@".$SymbolVersion:"");
6798 }
6799 }
6800}
6801
6802sub isRecurLib($)
6803{
6804 my $LibName = $_[0];
6805 foreach my $LibNameInStack (@RecurLib)
6806 {
6807 if($LibName eq $LibNameInStack)
6808 {
6809 return 1;
6810 }
6811 }
6812 return 0;
6813}
6814
6815sub getSymbols_App($)
6816{
6817 my $Path = $_[0];
6818 return () if(not $Path or not -f $Path);
6819 my @Ints = ();
6820 open(APP, "readelf -WhlSsdA $Path |");
6821 my $symtab=0;#indicates that we are processing 'symtab' section of 'readelf' output
6822 while(<APP>)
6823 {
6824 if($symtab == 1) {
6825 #do nothing with symtab (but there are some plans for the future)
6826 next;
6827 }
6828 if( /'.dynsym'/ ) {
6829 $symtab=0;
6830 }
6831 elsif( /'.symtab'/ ) {
6832 $symtab=1;
6833 }
6834 elsif(my ($fullname, $idx, $Ndx) = readlile_ELF($_)) {
6835 if( $Ndx eq "UND" ) {
6836 #only exported interfaces
6837 push(@Ints, $fullname);
6838 }
6839 }
6840 }
6841 close(APP);
6842 return @Ints;
6843}
6844
6845sub readlile_ELF($)
6846{
6847 if($_[0]=~/\s*\d+:\s+(\w*)\s+\w+\s+(\w+)\s+(\w+)\s+(\w+)\s+(\w+)\s((\w|@|\.)+)/)
6848 {#the line of 'readelf' output corresponding to the interface
6849 my ($value, $type, $bind, $vis, $Ndx, $fullname)=($1, $2, $3, $4, $5, $6);
6850 if(($bind ne "WEAK") and ($bind ne "GLOBAL")) {
6851 return ();
6852 }
6853 if(($type ne "FUNC") and ($type ne "OBJECT") and ($type ne "COMMON")) {
6854 return ();
6855 }
6856 if($vis ne "DEFAULT") {
6857 return ();
6858 }
6859 if(($Ndx eq "ABS") and ($value !~ /\D|1|2|3|4|5|6|7|8|9/)) {
6860 return ();
6861 }
6862 return ($fullname, $value, $Ndx);
6863 }
6864 else
6865 {
6866 return ();
6867 }
6868}
6869
6870sub getSymbols_Lib($$$)
6871{
6872 my ($LibVersion, $Lib_Path, $IsNeededLib) = @_;
6873 return if(not $Lib_Path or not -f $Lib_Path);
6874 my ($Lib_Dir, $Lib_SoName) = separatePath($Lib_Path);
6875 return if($CheckedSoLib{$LibVersion}{$Lib_SoName} and $IsNeededLib);
6876 return if(isRecurLib($Lib_SoName) or $#RecurLib>=1);
6877 $CheckedSoLib{$LibVersion}{$Lib_SoName} = 1;
6878 push(@RecurLib, $Lib_SoName);
6879 my (%Value_Interface, %Interface_Value, %NeededLib) = ();
6880 if(not $IsNeededLib)
6881 {
6882 $SoNames_All{$LibVersion}{$Lib_SoName} = 1;
6883 }
6884 open(SOLIB, "readelf -WhlSsdA $Lib_Path |");
6885 my $symtab=0;#indicates that we are processing 'symtab' section of 'readelf' output
6886 while(<SOLIB>)
6887 {
6888 if($symtab == 1) {
6889 #do nothing with symtab (but there are some plans for the future)
6890 next;
6891 }
6892 if(/'.dynsym'/) {
6893 $symtab=0;
6894 }
6895 elsif(/'.symtab'/) {
6896 $symtab=1;
6897 }
6898 elsif(/NEEDED.+\[([^\[\]]+)\]/)
6899 {
6900 $NeededLib{$1} = 1;
6901 }
6902 elsif(my ($fullname, $idx, $Ndx) = readlile_ELF($_)) {
6903 if( $Ndx eq "UND" ) {
6904 #ignore interfaces that are exported form somewhere else
6905 next;
6906 }
6907 my ($realname, $version) = ($fullname, "");
6908 if($fullname =~ /\A([^@]+)[\@]+([^@]+)\Z/)
6909 {
6910 ($realname, $version) = ($1, $2);
6911 }
6912 next if(defined $InterfacesListPath and not $InterfacesList{$realname});
6913 next if(defined $AppPath and not $InterfacesList_App{$realname});
6914 if($IsNeededLib)
6915 {
6916 $DepInterfaces{$LibVersion}{$fullname} = 1;
6917 }
6918 if(not $IsNeededLib or (defined $InterfacesListPath and $InterfacesList{$realname}) or (defined $AppPath and $InterfacesList_App{$realname}))
6919 {
6920 $Interface_Library{$LibVersion}{$fullname} = $Lib_SoName;
6921 $Library_Interface{$LibVersion}{$Lib_SoName}{$fullname} = 1;
6922 $Interface_Value{$LibVersion}{$fullname} = $idx;
6923 $Value_Interface{$LibVersion}{$idx}{$fullname} = 1;
6924 if(not $Language{$LibVersion}{$Lib_SoName})
6925 {
6926 if($fullname =~ /\A_Z[A-Z]*[0-9]+/)
6927 {
6928 $Language{$LibVersion}{$Lib_SoName} = "C++";
6929 }
6930 }
6931 }
6932 }
6933 }
6934 close(SOLIB);
6935 if(not $IsNeededLib)
6936 {
6937 foreach my $Interface_Name (keys(%{$Interface_Library{$LibVersion}}))
6938 {
6939 next if($Interface_Name !~ /\@/);
6940 my $Interface_SymName = "";
6941 foreach my $InterfaceName_SameValue (keys(%{$Value_Interface{$LibVersion}{$Interface_Value{$LibVersion}{$Interface_Name}}}))
6942 {
6943 if($InterfaceName_SameValue ne $Interface_Name)
6944 {
6945 $SymVer{$LibVersion}{$InterfaceName_SameValue} = $Interface_Name;
6946 $Interface_SymName = $InterfaceName_SameValue;
6947 last;
6948 }
6949 }
6950 if(not $Interface_SymName)
6951 {
6952 if($Interface_Name =~ /\A([^@]*)[\@]+([^@]*)\Z/ and not $SymVer{$LibVersion}{$1})
6953 {
6954 $SymVer{$LibVersion}{$1} = $Interface_Name;
6955 }
6956 }
6957 }
6958 }
6959 foreach my $SoLib (keys(%NeededLib))
6960 {
6961 getSymbols_Lib($LibVersion, find_solib_path($Lib_Dir, $SoLib), 1);
6962 }
6963 pop(@RecurLib);
6964}
6965
6966sub find_solib_path($$)
6967{
6968 my ($Dir, $SoName) = @_;
6969 $Dir=~s/\/\Z//g;
6970 if(-f $Dir."/".$SoName)
6971 {
6972 return $Dir."/".$SoName;
6973 }
6974 else
6975 {
6976 return $SoLib_DefaultPath{$SoName};
6977 }
6978}
6979
6980sub symbols_Preparation($)
6981{#recreate %SoNames and %Language using info from *.abi file
6982 my $LibVersion = $_[0];
6983 foreach my $Lib_SoName (keys(%{$Library_Interface{$LibVersion}}))
6984 {
6985 foreach my $Interface_Name (keys(%{$Library_Interface{$LibVersion}{$Lib_SoName}}))
6986 {
6987 $Interface_Library{$LibVersion}{$Interface_Name} = $Lib_SoName;
6988 $SoNames_All{$LibVersion}{$Lib_SoName} = 1;
6989 if(not $Language{$LibVersion}{$Lib_SoName})
6990 {
6991 if($Interface_Name =~ /\A_Z[A-Z]*[0-9]+/)
6992 {
6993 $Language{$LibVersion}{$Lib_SoName} = "C++";
6994 }
6995 }
6996 }
6997 }
6998}
6999
7000sub getSoPaths($)
7001{
7002 my $LibVersion = $_[0];
7003 my @SoPaths = ();
7004 foreach my $Dest (split("\n", $Descriptor{$LibVersion}{"Libs"}))
7005 {
7006 $Dest =~ s/\A\s+|\s+\Z//g;
7007 next if(not $Dest);
7008 if(not -e $Dest)
7009 {
7010 print "ERROR: can't access \'$Dest\'\n";
7011 }
7012 my @SoPaths_Dest = getSOPaths_Dest($Dest);
7013 foreach (@SoPaths_Dest)
7014 {
7015 push(@SoPaths, $_);
7016 }
7017 }
7018 return @SoPaths;
7019}
7020
7021sub getSOPaths_Dest($)
7022{
7023 my $Dest = $_[0];
7024 if(-f $Dest)
7025 {
7026 return $Dest;
7027 }
7028 my @AllObjects = cmd_find($Dest,"f","*\.so*");
7029 my @SOPaths = ();
7030 foreach my $SharedObject (@AllObjects)
7031 {
7032 if(cmd_file($SharedObject) =~ /shared object/)
7033 {
7034 @SOPaths = (@SOPaths, $SharedObject);
7035 }
7036 }
7037 return @SOPaths;
7038}
7039
7040sub genDescriptorTemplate()
7041{
7042 writeFile("library-descriptor.xml", $Descriptor_Template."\n");
7043 print "descriptor template named 'library-descriptor.xml' has been generated in the current directory\n";
7044}
7045
7046sub detectPointerSize()
7047{
7048 `mkdir -p temp`;
7049 writeFile("temp/get_pointer_size.c", "#include <stdio.h>
7050int main()
7051{
7052 printf(\"\%d\", sizeof(int*));
7053 return 0;
7054}\n");
7055 system("gcc temp/get_pointer_size.c -o temp/get_pointer_size");
7056 $POINTER_SIZE = `./temp/get_pointer_size`;
7057 `rm -fr temp`;
7058}
7059
7060sub data_Preparation($)
7061{
7062 my $LibVersion = $_[0];
7063 if($Descriptor{$LibVersion}{"Path"} =~ /\.abi\.tar\.gz/)
7064 {
7065 my $FileName = cmd_tar($Descriptor{$LibVersion}{"Path"});
7066 if($FileName =~ /\.abi/)
7067 {
7068 chomp($FileName);
7069 my $LibraryABI = eval readFile($FileName);
7070 system("rm", "-f", $FileName);
7071 $TypeDescr{$LibVersion} = $LibraryABI->{"TypeDescr"};
7072 $FuncDescr{$LibVersion} = $LibraryABI->{"FuncDescr"};
7073 $Library_Interface{$LibVersion} = $LibraryABI->{"Interfaces"};
7074 $SymVer{$LibVersion} = $LibraryABI->{"SymVer"};
7075 $Tid_TDid{$LibVersion} = $LibraryABI->{"Tid_TDid"};
7076 $Descriptor{$LibVersion}{"Version"} = $LibraryABI->{"LibraryVersion"};
7077 $OpaqueTypes{$LibVersion} = $LibraryABI->{"OpaqueTypes"};
7078 $InternalInterfaces{$LibVersion} = $LibraryABI->{"InternalInterfaces"};
7079 $Headers{$LibVersion} = $LibraryABI->{"Headers"};
7080 $SoNames_All{$LibVersion} = $LibraryABI->{"SharedObjects"};
7081 $Constants{$LibVersion} = $LibraryABI->{"Constants"};
7082 if($LibraryABI->{"ABI_COMPLIANCE_CHECKER_VERSION"} ne $ABI_COMPLIANCE_CHECKER_VERSION)
7083 {
7084 print "ERROR: incompatible version of specified ABI dump (allowed only $ABI_COMPLIANCE_CHECKER_VERSION)\n";
7085 exit(1);
7086 }
7087 foreach my $Destination (keys(%{$Headers{$LibVersion}}))
7088 {
7089 my $Header = get_FileName($Destination);
7090 $HeaderName_Destinations{$LibVersion}{$Header}{$Destination} = 1;
7091 }
7092 symbols_Preparation($LibVersion);
7093 }
7094 }
7095 elsif($Descriptor{$LibVersion}{"Path"} =~ /\.tar\.gz\Z/)
7096 {
7097 print "ERROR: descriptor must be an XML file or '*.abi.tar.gz' ABI dump\n";
7098 exit(1);
7099 }
7100 else
7101 {
7102 readDescriptor($LibVersion);
7103 if(not $CheckHeadersOnly)
7104 {
7105 getSymbols($LibVersion);
7106 }
7107 headerSearch($LibVersion);
7108 }
7109}
7110
7111sub dump_sorting($)
7112{
7113 my $hash = $_[0];
7114 if((keys(%{$hash}))[0] =~ /\A[0-9]+\Z/)
7115 {
7116 return [sort {int($a) <=> int($b)} keys %{$hash}];
7117 }
7118 else
7119 {
7120 return [sort {$a cmp $b} keys %{$hash}];
7121 }
7122}
7123
7124sub get_solib_default_paths()
7125{
7126 foreach my $Line (split("\n", `ldconfig -p`))
7127 {
7128 if($Line=~/\A[ \t]*([^ \t]+) .* \=\> (.+)\Z/)
7129 {
7130 $SoLib_DefaultPath{$1} = $2;
7131 }
7132 }
7133}
7134
7135sub scenario()
7136{
7137 if(defined $Help)
7138 {
7139 HELP_MESSAGE();
7140 exit(0);
7141 }
7142 if(defined $ShowVersion)
7143 {
7144 print "ABI Compliance Checker $ABI_COMPLIANCE_CHECKER_VERSION\nCopyright (C) The Linux Foundation\nCopyright (C) Institute for System Programming, RAS\nLicense GPLv2: GNU GPL version 2 <http://www.gnu.org/licenses/>\nThis program is free software: you can redistribute it and/or modify it.\n\nWritten by Andrey Ponomarenko.\n";
7145 exit(0);
7146 }
7147 $Data::Dumper::Sortkeys = \&dump_sorting;
7148 if(defined $TestSystem)
7149 {
7150 testSystem_cpp();
7151 testSystem_c();
7152 exit(0);
7153 }
7154 if($GenerateDescriptor)
7155 {
7156 genDescriptorTemplate();
7157 exit(0);
7158 }
7159 if(not defined $TargetLibraryName)
7160 {
7161 print "select library name (option -l <name>)\n";
7162 exit(1);
7163 }
7164 if(defined $InterfacesListPath)
7165 {
7166 if(not -f $InterfacesListPath)
7167 {
7168 print "ERROR: can't access file $InterfacesListPath\n";
7169 exit(1);
7170 }
7171 foreach my $Interface (split("\n", readFile($InterfacesListPath)))
7172 {
7173 $InterfacesList{$Interface} = 1;
7174 }
7175 }
7176 if($AppPath)
7177 {
7178 if(-f $AppPath)
7179 {
7180 foreach my $Interface (getSymbols_App($AppPath))
7181 {
7182 $InterfacesList_App{$Interface} = 1;
7183 }
7184 }
7185 else
7186 {
7187 print "ERROR: can't access file \'$AppPath\'\n";
7188 exit(1);
7189 }
7190 }
7191 get_solib_default_paths();
7192 if($DumpInfo_DescriptorPath)
7193 {
7194 if(not -f $DumpInfo_DescriptorPath)
7195 {
7196 print "ERROR: can't access file \'$DumpInfo_DescriptorPath\'\n";
7197 exit(1);
7198 }
7199 $Descriptor{1}{"Path"} = $DumpInfo_DescriptorPath;
7200 readDescriptor(1);
7201 detectPointerSize();
7202 getSymbols(1);
7203 translateSymbols(1);
7204 headerSearch(1);
7205 parseHeaders_AllInOne(1);
7206 cleanData(1);
7207 my %LibraryABI = ();
7208 print "creating library ABI info dump ...\n";
7209 $LibraryABI{"TypeDescr"} = $TypeDescr{1};
7210 $LibraryABI{"FuncDescr"} = $FuncDescr{1};
7211 $LibraryABI{"Interfaces"} = $Library_Interface{1};
7212 $LibraryABI{"SymVer"} = $SymVer{1};
7213 $LibraryABI{"LibraryVersion"} = $Descriptor{1}{"Version"};
7214 $LibraryABI{"Library"} = $TargetLibraryName;
7215 $LibraryABI{"SharedObjects"} = $SoNames_All{1};
7216 $LibraryABI{"Tid_TDid"} = $Tid_TDid{1};
7217 $LibraryABI{"OpaqueTypes"} = $OpaqueTypes{1};
7218 $LibraryABI{"InternalInterfaces"} = $InternalInterfaces{1};
7219 $LibraryABI{"Headers"} = $Headers{1};
7220 $LibraryABI{"Constants"} = $Constants{1};
7221 $LibraryABI{"ABI_COMPLIANCE_CHECKER_VERSION"} = $ABI_COMPLIANCE_CHECKER_VERSION;
7222 my $InfoDump_FilePath = "abi_dumps/$TargetLibraryName";
7223 my $InfoDump_FileName = $TargetLibraryName."_".$Descriptor{1}{"Version"}.".abi";
7224 system("mkdir", "-p", $InfoDump_FilePath);
7225 system("rm", "-f", $InfoDump_FilePath."/".$InfoDump_FileName.".tar.gz");
7226 writeFile("$InfoDump_FilePath/$InfoDump_FileName", Dumper(\%LibraryABI));
7227 system("cd ".esc($InfoDump_FilePath)." && tar -cf ".esc($InfoDump_FileName).".tar ".esc($InfoDump_FileName));
7228 system("cd ".esc($InfoDump_FilePath)." && gzip ".esc($InfoDump_FileName).".tar --best");
7229 system("rm", "-f", $InfoDump_FilePath."/".$InfoDump_FileName);
7230 if($?)
7231 {
7232 print "ERROR: can't create library ABI info dump\n";
7233 exit(1);
7234 }
7235 else
7236 {
7237 print "see library ABI info dump in \'$InfoDump_FilePath/$InfoDump_FileName\.tar\.gz\': use it instead of library version descriptor on other machine\n";
7238 exit(0);
7239 }
7240 }
7241 if(not $Descriptor{1}{"Path"})
7242 {
7243 print "select 1st library descriptor (option -d1 <path>)\n";
7244 exit(1);
7245 }
7246 if(not -f $Descriptor{1}{"Path"})
7247 {
7248 print "ERROR: descriptor d1 does not exist, incorrect file path '".$Descriptor{1}{"Path"}."'\n";
7249 exit(1);
7250 }
7251 if(not $Descriptor{2}{"Path"})
7252 {
7253 print "select 2nd library descriptor (option -d2 <path>)\n";
7254 exit(1);
7255 }
7256 if(not -f $Descriptor{2}{"Path"})
7257 {
7258 print "ERROR: descriptor d2 does not exist, incorrect file path '".$Descriptor{2}{"Path"}."'\n";
7259 exit(1);
7260 }
7261 $StartTime = localtime time;
7262 print "preparation...\n";
7263 data_Preparation(1);
7264 data_Preparation(2);
7265 if($AppPath and not keys(%{$Interface_Library{1}}))
7266 {
7267 print "WARNING: symbols from the specified application were not found in the specified library shared objects\n";
7268 }
7269 $REPORT_PATH = "compat_reports/$TargetLibraryName/".$Descriptor{1}{"Version"}."_to_".$Descriptor{2}{"Version"};
7270 system("mkdir", "-p", $REPORT_PATH);
7271 system("rm", "-f", $REPORT_PATH."/abi_compat_report.html");
7272 detectPointerSize();
7273 translateSymbols(1);
7274 translateSymbols(2);
7275 if(not $CheckHeadersOnly)
7276 {
7277 detectAdded();
7278 detectWithdrawn();
7279 }
7280 #headers merging
7281 if($HeaderCheckingMode_Separately and $Descriptor{1}{"Path"} !~ /\.abi\.tar\.gz/ and $Descriptor{2}{"Path"} !~ /\.abi\.tar\.gz/)
7282 {
7283 mergeHeaders_Separately();
7284 }
7285 else
7286 {
7287 if($Descriptor{1}{"Path"} !~ /\.abi\.tar\.gz/)
7288 {
7289 parseHeaders_AllInOne(1);
7290 }
7291 if($Descriptor{2}{"Path"} !~ /\.abi\.tar\.gz/)
7292 {
7293 parseHeaders_AllInOne(2);
7294 }
7295 print "comparing headers ...\n";
7296 mergeSignatures();
7297 mergeConstants();
7298 }
7299 #libraries merging
7300 if(not $CheckHeadersOnly)
7301 {
7302 print "comparing shared objects ...\n";
7303 mergeLibs();
7304 }
7305 print "creating ABI compliance report ...\n";
7306 create_HtmlReport();
7307 if($HeaderCheckingMode_Separately)
7308 {
7309 if(keys(%HeaderCompileError))
7310 {
7311 print "\nWARNING: compilation errors in following headers:\n";
7312 foreach my $Header (keys(%HeaderCompileError))
7313 {
7314 print $Header." ";
7315 }
7316 print "\nyou can see compilation errors in the following files:\n '$ERR_PATH{1}'\n '$ERR_PATH{2}'\n";
7317 }
7318 }
7319 `rm -fr temp`;
7320 print "\nstarted: $StartTime, finished: ".(localtime time)."\n" if($ShowExpendTime);
7321 print "see the ABI compliance report in the file '$REPORT_PATH/abi_compat_report.html'\n";
7322 exit(0);
7323}
7324
7325scenario();
APT (for Cydia)