| ########################################################################### |
| # Module for ABI Compliance Checker to compare Operating Systems |
| # |
| # Copyright (C) 2009-2011 Institute for System Programming, RAS |
| # Copyright (C) 2011-2012 Nokia Corporation and/or its subsidiary(-ies) |
| # Copyright (C) 2011-2012 ROSA Laboratory |
| # Copyright (C) 2012-2016 Andrey Ponomarenko's ABI Laboratory |
| # |
| # Written by Andrey Ponomarenko |
| # |
| # This program is free software: you can redistribute it and/or modify |
| # it under the terms of the GNU General Public License or the GNU Lesser |
| # General Public License as published by the Free Software Foundation. |
| # |
| # This program is distributed in the hope that it will be useful, |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| # GNU General Public License for more details. |
| # |
| # You should have received a copy of the GNU General Public License |
| # and the GNU Lesser General Public License along with this program. |
| # If not, see <http://www.gnu.org/licenses/>. |
| ########################################################################### |
| use strict; |
| use File::Temp qw(tempdir); |
| use Cwd qw(abs_path cwd); |
| use Fcntl; |
| |
| my ($Debug, $Quiet, $LogMode, $CheckHeadersOnly, $SystemRoot, $GCC_PATH, |
| $CrossPrefix, $TargetSysInfo, $TargetLibraryName, $CrossGcc, $UseStaticLibs, |
| $NoStdInc, $CxxIncompat, $SkipUnidentified, $OStarget, $BinaryOnly, |
| $SourceOnly, $DisableConstantsCheck); |
| |
| my $OSgroup = get_OSgroup(); |
| my $TMP_DIR = tempdir(CLEANUP=>1); |
| my $ORIG_DIR = cwd(); |
| my $LIB_EXT = getLIB_EXT($OSgroup); |
| |
| my %SysDescriptor; |
| my %Cache; |
| my %NonPrefix; |
| |
| sub cmpSystems($$$) |
| { # -cmp-systems option handler |
| # should be used with -d1 and -d2 options |
| my ($SPath1, $SPath2, $Opts) = @_; |
| initModule($Opts); |
| if(not $SPath1) { |
| exitStatus("Error", "the option -d1 should be specified"); |
| } |
| elsif(not -d $SPath1) { |
| exitStatus("Access_Error", "can't access directory \'".$SPath1."\'"); |
| } |
| elsif(not -d $SPath1."/abi_dumps") { |
| exitStatus("Access_Error", "can't access directory \'".$SPath1."/abi_dumps\'"); |
| } |
| if(not $SPath2) { |
| exitStatus("Error", "the option -d2 should be specified"); |
| } |
| elsif(not -d $SPath2) { |
| exitStatus("Access_Error", "can't access directory \'".$SPath2."\'"); |
| } |
| elsif(not -d $SPath2."/abi_dumps") { |
| exitStatus("Access_Error", "can't access directory \'".$SPath2."/abi_dumps\'"); |
| } |
| # sys_dumps/<System>/<Arch>/... |
| my $SystemName1 = get_filename(get_dirname($SPath1)); |
| my $SystemName2 = get_filename(get_dirname($SPath2)); |
| |
| my $SystemName1_P = $SystemName1; |
| my $SystemName2_P = $SystemName2; |
| |
| $SystemName1=~s/_/ /g; |
| $SystemName2=~s/_/ /g; |
| |
| # sys_dumps/<System>/<Arch>/... |
| my $ArchName = get_filename($SPath1); |
| if($ArchName ne get_filename($SPath2)) { |
| exitStatus("Error", "can't compare systems of different CPU architecture"); |
| } |
| if(my $OStarget_Dump = readFile($SPath1."/target.txt")) |
| { # change target |
| $OStarget = $OStarget_Dump; |
| $LIB_EXT = getLIB_EXT($OStarget); |
| } |
| my $GroupByHeaders = 0; |
| if(my $Mode = readFile($SPath1."/mode.txt")) |
| { # change mode |
| if($Mode eq "headers-only") |
| { # -headers-only mode |
| $CheckHeadersOnly = 1; |
| $GroupByHeaders = 1; |
| } |
| if($Mode eq "group-by-headers") { |
| $GroupByHeaders = 1; |
| } |
| } |
| my $SYS_REPORT_PATH = "sys_compat_reports/".$SystemName1_P."_to_".$SystemName2_P."/$ArchName"; |
| rmtree($SYS_REPORT_PATH); |
| my (%LibSoname1, %LibSoname2) = (); |
| foreach (split(/\n/, readFile($SPath1."/sonames.txt"))) |
| { |
| if(my ($LFName, $Soname) = split(/;/, $_)) |
| { |
| if($OStarget eq "symbian") { |
| $Soname=~s/\{.+\}//; |
| } |
| $LibSoname1{$LFName} = $Soname; |
| } |
| } |
| foreach (split(/\n/, readFile($SPath2."/sonames.txt"))) |
| { |
| if(my ($LFName, $Soname) = split(/;/, $_)) |
| { |
| if($OStarget eq "symbian") { |
| $Soname=~s/\{.+\}//; |
| } |
| $LibSoname2{$LFName} = $Soname; |
| } |
| } |
| my (%LibV1, %LibV2) = (); |
| foreach (split(/\n/, readFile($SPath1."/versions.txt"))) |
| { |
| if(my ($LFName, $V) = split(/;/, $_)) { |
| $LibV1{$LFName} = $V; |
| } |
| } |
| foreach (split(/\n/, readFile($SPath2."/versions.txt"))) |
| { |
| if(my ($LFName, $V) = split(/;/, $_)) { |
| $LibV2{$LFName} = $V; |
| } |
| } |
| my @Dumps1 = cmd_find($SPath1."/abi_dumps","f","*.abi",1); |
| my @Dumps2 = cmd_find($SPath2."/abi_dumps","f","*.abi",1); |
| |
| my (%LibVers1, %LibVers2) = (); |
| my (%ShortNames1, %ShortNames2) = (); |
| foreach my $DPath (@Dumps1) |
| { |
| if(my $Name = isDump($DPath)) |
| { |
| my ($Soname, $V) = ($LibSoname1{$Name}, $LibV1{$Name}); |
| if(not $V) { |
| $V = parse_libname($Name, "version", $OStarget); |
| } |
| if($GroupByHeaders) { |
| $Soname = $Name; |
| } |
| $LibVers1{$Soname}{$V} = $DPath; |
| $ShortNames1{parse_libname($Soname, "short", $OStarget)}{$Soname} = 1; |
| } |
| } |
| foreach my $DPath (@Dumps2) |
| { |
| if(my $Name = isDump($DPath)) |
| { |
| my ($Soname, $V) = ($LibSoname2{$Name}, $LibV2{$Name}); |
| if(not $V) { |
| $V = parse_libname($Name, "version", $OStarget); |
| } |
| if($GroupByHeaders) { |
| $Soname = $Name; |
| } |
| $LibVers2{$Soname}{$V} = $DPath; |
| $ShortNames2{parse_libname($Soname, "short", $OStarget)}{$Soname} = 1; |
| } |
| } |
| my (%Added, %Removed) = (); |
| my (%ChangedSoname, %TestResults) = (); |
| my (%AddedShort, %RemovedShort) = (); |
| if(not $GroupByHeaders) |
| { |
| my %ChangedSoname_Safe = (); |
| foreach my $LName (sort keys(%LibSoname2)) |
| { # libcurl.so.3 -> libcurl.so.4 (search for SONAME by the file name) |
| # OS #1 => OS #2 |
| if(defined $LibVers2{$LName}) |
| { # already registered |
| next; |
| } |
| my $Soname = $LibSoname2{$LName}; |
| if(defined $LibVers2{$Soname} |
| and defined $LibVers1{$LName}) |
| { |
| $LibVers2{$LName} = $LibVers2{$Soname}; |
| $ChangedSoname_Safe{$Soname}=$LName; |
| } |
| } |
| foreach my $LName (sort keys(%LibSoname1)) |
| { # libcurl.so.3 -> libcurl.so.4 (search for SONAME by the file name) |
| # OS #1 <= OS #2 |
| if(defined $LibVers1{$LName}) |
| { # already registered |
| next; |
| } |
| my $Soname = $LibSoname1{$LName}; |
| if(defined $LibVers1{$Soname} |
| and defined $LibVers2{$LName}) { |
| $LibVers1{$LName} = $LibVers1{$Soname}; |
| } |
| } |
| if(not $GroupByHeaders) { |
| printMsg("INFO", "Checking added/removed libs"); |
| } |
| foreach my $LName (sort {lc($a) cmp lc($b)} keys(%LibVers1)) |
| { # removed libs |
| if(not is_target_lib($LName)) { |
| next; |
| } |
| if(not defined $LibVers1{$LName}) { |
| next; |
| } |
| my @Versions1 = keys(%{$LibVers1{$LName}}); |
| if($#Versions1>=1) |
| { # should be only one version |
| next; |
| } |
| if(not defined $LibVers2{$LName} |
| or not keys(%{$LibVers2{$LName}})) |
| { # removed library |
| if(not $LibSoname2{$LName}) |
| { |
| my $LSName = parse_libname($LName, "short", $OStarget); |
| $RemovedShort{$LSName}{$LName} = 1; |
| my $V = $Versions1[0]; |
| $Removed{$LName}{"version"} = $V; |
| |
| my $ListPath = "info/$LName/symbols.html"; |
| my $FV = $SystemName1; |
| if($V) { |
| $FV = $V."-".$FV; |
| } |
| createSymbolsList($LibVers1{$LName}{$V}, |
| $SYS_REPORT_PATH."/".$ListPath, $LName, $FV, $ArchName); |
| $Removed{$LName}{"list"} = $ListPath; |
| } |
| } |
| } |
| foreach my $LName (sort {lc($a) cmp lc($b)} keys(%LibVers2)) |
| { # added libs |
| if(not is_target_lib($LName)) { |
| next; |
| } |
| if(not defined $LibVers2{$LName}) { |
| next; |
| } |
| my @Versions2 = keys(%{$LibVers2{$LName}}); |
| if($#Versions2>=1) |
| { # should be only one version |
| next; |
| } |
| if($ChangedSoname_Safe{$LName}) |
| { # changed soname but added the symbolic link for old-version library |
| next; |
| } |
| if(not defined $LibVers1{$LName} |
| or not keys(%{$LibVers1{$LName}})) |
| { # added library |
| if(not $LibSoname1{$LName}) |
| { |
| my $LSName = parse_libname($LName, "short", $OStarget); |
| $AddedShort{$LSName}{$LName} = 1; |
| my $V = $Versions2[0]; |
| $Added{$LName}{"version"} = $V; |
| |
| my $ListPath = "info/$LName/symbols.html"; |
| my $FV = $SystemName2; |
| if($V) { |
| $FV = $V."-".$FV; |
| } |
| createSymbolsList($LibVers2{$LName}{$V}, |
| $SYS_REPORT_PATH."/".$ListPath, $LName, $FV, $ArchName); |
| $Added{$LName}{"list"} = $ListPath; |
| } |
| } |
| } |
| foreach my $LSName (keys(%AddedShort)) |
| { # changed SONAME |
| my @AddedSonames = sort keys(%{$AddedShort{$LSName}}); |
| next if($#AddedSonames!=0); |
| |
| if(defined $RemovedShort{$LSName}) |
| { # removed old soname |
| my @RemovedSonames = sort keys(%{$RemovedShort{$LSName}}); |
| $ChangedSoname{$AddedSonames[0]} = $RemovedSonames[0]; |
| $ChangedSoname{$RemovedSonames[0]} = $AddedSonames[0]; |
| } |
| elsif(defined $ShortNames1{$LSName}) |
| { # saved old soname |
| my @Sonames = sort keys(%{$ShortNames1{$LSName}}); |
| $ChangedSoname{$AddedSonames[0]} = $Sonames[0]; |
| $ChangedSoname{$Sonames[0]} = $AddedSonames[0]; |
| } |
| } |
| } |
| |
| my %SONAME_Changed = (); |
| my %SONAME_Added = (); |
| |
| foreach my $LName (sort {lc($a) cmp lc($b)} keys(%LibVers1)) |
| { |
| if(not is_target_lib($LName)) { |
| next; |
| } |
| my @Versions1 = keys(%{$LibVers1{$LName}}); |
| if(not @Versions1 or $#Versions1>=1) |
| { # should be only one version |
| next; |
| } |
| my $LV1 = $Versions1[0]; |
| my $DPath1 = $LibVers1{$LName}{$LV1}; |
| my @Versions2 = keys(%{$LibVers2{$LName}}); |
| if($#Versions2>=1) |
| { # should be only one version |
| next; |
| } |
| my ($LV2, $LName2, $DPath2) = (); |
| my $LName_Short = parse_libname($LName, "name+ext", $OStarget); |
| if($LName2 = $ChangedSoname{$LName}) |
| { # changed SONAME |
| @Versions2 = keys(%{$LibVers2{$LName2}}); |
| if(not @Versions2 or $#Versions2>=1) { |
| next; |
| } |
| $LV2 = $Versions2[0]; |
| $DPath2 = $LibVers2{$LName2}{$LV2}; |
| |
| if(defined $LibVers2{$LName}) |
| { # show old soname in the table |
| $TestResults{$LName}{"v1"} = $LV1; |
| $TestResults{$LName}{"v2"} = $LV1; |
| } |
| |
| if(defined $LibVers2{$LName}) |
| { # do not count results |
| $SONAME_Added{$LName_Short} = 1; |
| } |
| $SONAME_Changed{$LName_Short} = 1; |
| $LName = $LName_Short; |
| } |
| elsif(@Versions2) |
| { |
| $LV2 = $Versions2[0]; |
| $DPath2 = $LibVers2{$LName}{$LV2}; |
| } |
| else |
| { # removed |
| next; |
| } |
| my $ACC_compare = "perl $0 -l $LName -d1 \"$DPath1\" -d2 \"$DPath2\""; |
| |
| my $BinReportPath = "compat_reports/$LName/abi_compat_report.html"; |
| my $SrcReportPath = "compat_reports/$LName/src_compat_report.html"; |
| my $BinReportPath_Full = $SYS_REPORT_PATH."/".$BinReportPath; |
| my $SrcReportPath_Full = $SYS_REPORT_PATH."/".$SrcReportPath; |
| |
| if($BinaryOnly) |
| { |
| $ACC_compare .= " -binary"; |
| $ACC_compare .= " -bin-report-path \"$BinReportPath_Full\""; |
| } |
| if($SourceOnly) |
| { |
| $ACC_compare .= " -source"; |
| $ACC_compare .= " -src-report-path \"$SrcReportPath_Full\""; |
| } |
| |
| if($CheckHeadersOnly) { |
| $ACC_compare .= " -headers-only"; |
| } |
| if($GroupByHeaders) { |
| $ACC_compare .= " -component header"; |
| } |
| |
| if($DisableConstantsCheck) { |
| $ACC_compare .= " -disable-constants-check"; |
| } |
| |
| $ACC_compare .= " -skip-added-constants"; |
| $ACC_compare .= " -skip-removed-constants"; |
| |
| if($Quiet) |
| { # quiet mode |
| $ACC_compare .= " -quiet"; |
| } |
| if($LogMode eq "n") { |
| $ACC_compare .= " -logging-mode n"; |
| } |
| elsif($Quiet) { |
| $ACC_compare .= " -logging-mode a"; |
| } |
| if($Debug) |
| { # debug mode |
| $ACC_compare .= " -debug"; |
| printMsg("INFO", "$ACC_compare"); |
| } |
| printMsg("INFO_C", "Checking $LName: "); |
| system($ACC_compare." 1>$TMP_DIR/null 2>$TMP_DIR/$LName.stderr"); |
| if(-s "$TMP_DIR/$LName.stderr") |
| { |
| my $ErrorLog = readFile("$TMP_DIR/$LName.stderr"); |
| chomp($ErrorLog); |
| printMsg("INFO", "Failed ($ErrorLog)"); |
| } |
| else |
| { |
| printMsg("INFO", "Ok"); |
| if($BinaryOnly) |
| { |
| $TestResults{$LName}{"Binary"} = readAttributes($BinReportPath_Full, 0); |
| $TestResults{$LName}{"Binary"}{"path"} = $BinReportPath; |
| } |
| if($SourceOnly) |
| { |
| $TestResults{$LName}{"Source"} = readAttributes($SrcReportPath_Full, 0); |
| $TestResults{$LName}{"Source"}{"path"} = $SrcReportPath; |
| } |
| $TestResults{$LName}{"v1"} = $LV1; |
| $TestResults{$LName}{"v2"} = $LV2; |
| } |
| |
| my $HP1 = $SPath1."/headers/".$LName; |
| my $HP2 = $SPath2."/headers/".$LName; |
| |
| if(-d $HP1 |
| and -d $HP2 |
| and my $RfcDiff = get_CmdPath("rfcdiff")) |
| { |
| my @Headers1 = cmd_find($HP1,"f"); |
| my @Headers2 = cmd_find($HP2,"f"); |
| |
| my (%Files1, %Files2) = (); |
| |
| foreach my $P (@Headers1) { |
| $Files1{get_filename($P)} = $P; |
| } |
| |
| foreach my $P (@Headers2) { |
| $Files2{get_filename($P)} = $P; |
| } |
| |
| my $Diff = ""; |
| foreach my $N (sort {lc($a) cmp lc($b)} keys(%Files1)) |
| { |
| my $Path1 = $Files1{$N}; |
| my $Path2 = undef; |
| |
| if(defined $Files2{$N}) { |
| $Path2 = $Files2{$N}; |
| } |
| else { |
| next; |
| } |
| |
| if(-s $Path1 == -s $Path2) |
| { |
| if(readFile($Path1) eq readFile($Path2)) { |
| next; |
| } |
| } |
| |
| my $DiffOut = $TMP_DIR."/rfcdiff"; |
| |
| if(-e $DiffOut) { |
| unlink($DiffOut); |
| } |
| |
| my $Cmd_R = $RfcDiff." --width 80 --stdout \"$Path1\" \"$Path2\" >$DiffOut 2>/dev/null"; |
| qx/$Cmd_R/; # execute |
| |
| if(-s $DiffOut) |
| { |
| my $Content = readFile($DiffOut); |
| if(length($Content)<3500 and $Content=~/The files are identical|No changes|Failed to create/i) { |
| next; |
| } |
| |
| $Content=~s/<\!--(.|\n)+?-->\s*//g; |
| $Content=~s/\A((.|\n)+<body\s*>)((.|\n)+)(<\/body>(.|\n)+)\Z/$3/; |
| $Content=~s/(<td colspan=\"5\"[^>]*>)(.+)(<\/td>)/$1$3/; |
| $Content=~s/(<table) /$1 class='diff_tbl' /g; |
| |
| $Content=~s&<td class="lineno" valign="top"></td>&&g; |
| $Content=~s&<td class="lineno"></td>&&g; |
| $Content=~s&<th></th>&&g; |
| $Content=~s&<td></td>&&g; |
| |
| $Content=~s/(\Q$N\E)( )/$1 ($LV1-$SystemName1)$2/; |
| $Content=~s/(\Q$N\E)( )/$1 ($LV2-$SystemName2)$2/; |
| |
| if($Diff) { |
| $Diff .= "<br/><br/>\n"; |
| } |
| $Diff .= $Content; |
| } |
| } |
| |
| if($Diff) |
| { |
| my $Title = $LName.": headers diff between $LV1-$SystemName1 and $LV2-$SystemName2 versions"; |
| my $Keywords = $LName.", header, diff"; |
| my $Description = "Diff for header files between $LV1-$SystemName1 and $LV2-$SystemName2 versions of $LName"; |
| my $Styles = readModule("Styles", "HeadersDiff.css"); |
| |
| my $Link = "This html diff was produced by <a href='http://tools.ietf.org/tools/rfcdiff/'>rfcdiff</a> 1.41."; |
| |
| $Diff .= "<br/>"; |
| $Diff .= "<div style='width:100%;' align='left'>$Link</div>\n"; |
| |
| $Diff = "<h1>Headers diff for <span style='color:Blue;'>$LName</span> between <span style='color:Red;'>$LV1-$SystemName1</span> and <span style='color:Red;'>$LV2-$SystemName2</span> versions</h1><br/><br/>".$Diff; |
| |
| $Diff = "<table width='100%' cellpadding='0' cellspacing='0'><tr><td>$Diff</td></tr></table>"; |
| |
| $Diff = composeHTML_Head($Title, $Keywords, $Description, $Styles, "")."\n<body>\n$Diff\n</body>\n</html>\n"; |
| |
| my $Output = $SYS_REPORT_PATH."/headers_diff/$LName"; |
| writeFile($Output."/diff.html", $Diff); |
| } |
| } |
| } |
| |
| my %TOTAL = (); |
| foreach my $LName (keys(%TestResults)) |
| { |
| if($SONAME_Changed{$LName}) { |
| next; |
| } |
| foreach my $Comp ("Binary", "Source") |
| { |
| if(not defined $TestResults{$LName}{$Comp}) { |
| next; |
| } |
| foreach my $Kind (keys(%{$TestResults{$LName}{$Comp}})) |
| { |
| if($Kind=~/_problems_(high|medium|low)/) { |
| $TOTAL{$LName}{$Comp} += $TestResults{$LName}{$Comp}{$Kind}; |
| } |
| } |
| } |
| } |
| |
| my %META_DATA = (); |
| my %STAT = (); |
| foreach my $Comp ("Binary", "Source") |
| { |
| $STAT{$Comp}{"total"} = keys(%TestResults) - keys(%SONAME_Changed); |
| $STAT{$Comp}{"added"} = keys(%Added); |
| $STAT{$Comp}{"removed"} = keys(%Removed); |
| |
| foreach ("added", "removed") |
| { |
| my $Kind = $_."_interfaces"; |
| foreach my $LName (keys(%TestResults)) |
| { |
| next if($SONAME_Changed{$LName}); |
| $STAT{$Comp}{$Kind} += $TestResults{$LName}{$Comp}{$_}; |
| } |
| push(@{$META_DATA{$Comp}}, $Kind.":".$STAT{$Comp}{$Kind}); |
| } |
| foreach my $T ("type", "interface") |
| { |
| foreach my $S ("high", "medium", "low") |
| { |
| my $Kind = $T."_problems_".$S; |
| foreach my $LName (keys(%TestResults)) |
| { |
| next if($SONAME_Changed{$LName}); |
| $STAT{$Comp}{$Kind} += $TestResults{$LName}{$Comp}{$Kind}; |
| } |
| push(@{$META_DATA{$Comp}}, $Kind.":".$STAT{$Comp}{$Kind}); |
| } |
| } |
| foreach my $LName (keys(%TestResults)) |
| { |
| next if($SONAME_Changed{$LName}); |
| foreach ("affected", "changed_constants") { |
| $STAT{$Comp}{$_} += $TestResults{$LName}{$Comp}{$_}; |
| } |
| if(not defined $STAT{$Comp}{"verdict"} |
| and $TestResults{$LName}{$Comp}{"verdict"} eq "incompatible") { |
| $STAT{$Comp}{"verdict"} = "incompatible"; |
| } |
| } |
| if(not defined $STAT{$Comp}{"verdict"}) { |
| $STAT{$Comp}{"verdict"} = "compatible"; |
| } |
| if($STAT{$Comp}{"total"}) { |
| $STAT{$Comp}{"affected"} /= $STAT{$Comp}{"total"}; |
| } |
| else { |
| $STAT{$Comp}{"affected"} = 0; |
| } |
| $STAT{$Comp}{"affected"} = show_number($STAT{$Comp}{"affected"}); |
| if($STAT{$Comp}{"verdict"}>1) { |
| $STAT{$Comp}{"verdict"} = 1; |
| } |
| push(@{$META_DATA{$Comp}}, "changed_constants:".$STAT{$Comp}{"changed_constants"}); |
| push(@{$META_DATA{$Comp}}, "tool_version:".get_dumpversion("perl $0")); |
| foreach ("removed", "added", "total", "affected", "verdict") { |
| @{$META_DATA{$Comp}} = ($_.":".$STAT{$Comp}{$_}, @{$META_DATA{$Comp}}); |
| } |
| } |
| |
| my $SONAME_Title = "SONAME"; |
| if($OStarget eq "windows") { |
| $SONAME_Title = "DLL"; |
| } |
| elsif($OStarget eq "symbian") { |
| $SONAME_Title = "DSO"; |
| } |
| if($GroupByHeaders) |
| { # show the list of headers |
| $SONAME_Title = "Header File"; |
| } |
| |
| my $SYS_REPORT = "<h1>"; |
| |
| if($BinaryOnly and $SourceOnly) { |
| $SYS_REPORT .= "API compatibility"; |
| } |
| elsif($BinaryOnly) { |
| $SYS_REPORT .= "Binary compatibility"; |
| } |
| elsif($SourceOnly) { |
| $SYS_REPORT .= "Source compatibility"; |
| } |
| |
| $SYS_REPORT .= " report between <span style='color:Blue;'>$SystemName1</span> and <span style='color:Blue;'>$SystemName2</span>"; |
| $SYS_REPORT .= " on <span style='color:Blue;'>".showArch($ArchName)."</span>\n"; |
| |
| $SYS_REPORT .= "</h1>"; |
| $SYS_REPORT .= "<br/>\n"; |
| |
| # legend |
| my $LEGEND = "<table class='legend'><tr>\n"; |
| $LEGEND .= "<td class='new' width='70px' style='text-align:left'>ADDED</td>\n"; |
| $LEGEND .= "<td class='passed' width='70px' style='text-align:left'>COMPATIBLE</td>\n"; |
| $LEGEND .= "</tr><tr>\n"; |
| $LEGEND .= "<td class='warning' style='text-align:left'>WARNING</td>\n"; |
| $LEGEND .= "<td class='failed' style='text-align:left'>INCOMPATIBLE</td>\n"; |
| $LEGEND .= "</tr></table>\n"; |
| |
| $SYS_REPORT .= $LEGEND; |
| $SYS_REPORT .= "<br/>\n"; |
| |
| my $Columns = 2; |
| |
| my $Total = (keys(%TestResults) + keys(%Added) + keys(%Removed) - keys(%SONAME_Changed)); |
| my $HDiff = $SYS_REPORT_PATH."/headers_diff"; |
| |
| $SYS_REPORT .= "<table class='summary'>\n"; |
| $SYS_REPORT .= "<tr>\n"; |
| $SYS_REPORT .= "<th rowspan='2'>$SONAME_Title<sup>$Total</sup></th>\n"; |
| if(not $GroupByHeaders) { |
| $SYS_REPORT .= "<th colspan='2'>Version</th>\n"; |
| } |
| if($BinaryOnly and $SourceOnly) { |
| $SYS_REPORT .= "<th colspan='2'>Compatibility</th>\n"; |
| } |
| else { |
| $SYS_REPORT .= "<th rowspan='2'>Compatibility</th>\n"; |
| } |
| $SYS_REPORT .= "<th rowspan='2'>Added<br/>Symbols</th>\n"; |
| $SYS_REPORT .= "<th rowspan='2'>Removed<br/>Symbols</th>\n"; |
| if(-d $HDiff) |
| { |
| $SYS_REPORT .= "<th rowspan='2'>Headers<br/>Diff</th>\n"; |
| $Columns += 1; |
| } |
| $SYS_REPORT .= "</tr>\n"; |
| |
| $SYS_REPORT .= "<tr>\n"; |
| if(not $GroupByHeaders) { |
| $SYS_REPORT .= "<th class='ver'>$SystemName1</th><th class='ver'>$SystemName2</th>\n"; |
| } |
| if($BinaryOnly and $SourceOnly) { |
| $SYS_REPORT .= "<th>Binary</th><th>Source</th>\n"; |
| } |
| $SYS_REPORT .= "</tr>\n"; |
| my %RegisteredPairs = (); |
| |
| foreach my $LName (sort {lc($a) cmp lc($b)} (keys(%TestResults), keys(%Added), keys(%Removed))) |
| { |
| next if($SONAME_Changed{$LName}); |
| my $LName_Short = parse_libname($LName, "name+ext", $OStarget); |
| my $Anchor = $LName; |
| $Anchor=~s/\+/p/g; # anchor for libFLAC++ is libFLACpp |
| $Anchor=~s/\~/-/g; # libqttracker.so.1~6 |
| |
| $SYS_REPORT .= "<tr>\n"; |
| $SYS_REPORT .= "<td class='object'>$LName<a name=\'$Anchor\'></a></td>\n"; |
| if(defined $Removed{$LName}) { |
| $SYS_REPORT .= "<td class='failed ver'>".printVer($Removed{$LName}{"version"})."</td>\n"; |
| } |
| elsif(defined $Added{$LName}) { |
| $SYS_REPORT .= "<td class='new'><a href='".$Added{$LName}{"list"}."'>added</a></td>\n"; |
| } |
| elsif(not $GroupByHeaders) |
| { |
| $SYS_REPORT .= "<td class='ver'>".printVer($TestResults{$LName}{"v1"})."</td>\n"; |
| } |
| my $SONAME_report = "<td colspan=\'$Columns\' rowspan='2'>\n"; |
| if($BinaryOnly and $SourceOnly) { |
| $SONAME_report .= "SONAME has been changed (see <a href='".$TestResults{$LName_Short}{"Binary"}{"path"}."'>binary</a> and <a href='".$TestResults{$LName_Short}{"Source"}{"path"}."'>source</a> compatibility reports)\n"; |
| } |
| elsif($BinaryOnly) { |
| $SONAME_report .= "SONAME has been <a href='".$TestResults{$LName_Short}{"Binary"}{"path"}."'>changed</a>\n"; |
| } |
| elsif($SourceOnly) { |
| $SONAME_report .= "SONAME has been <a href='".$TestResults{$LName_Short}{"Source"}{"path"}."'>changed</a>\n"; |
| } |
| $SONAME_report .= "</td>\n"; |
| |
| if(defined $Added{$LName}) |
| { # added library |
| $SYS_REPORT .= "<td class='new ver'>".printVer($Added{$LName}{"version"})."</td>\n"; |
| $SYS_REPORT .= "<td class='passed'>100%</td>\n" if($BinaryOnly); |
| $SYS_REPORT .= "<td class='passed'>100%</td>\n" if($SourceOnly); |
| if($RegisteredPairs{$LName}) { |
| # do nothing |
| } |
| elsif(my $To = $ChangedSoname{$LName}) |
| { |
| $RegisteredPairs{$To}=1; |
| $SYS_REPORT .= $SONAME_report; |
| } |
| else |
| { |
| foreach (1 .. $Columns) { |
| $SYS_REPORT .= "<td>N/A</td>\n"; # colspan='5' |
| } |
| } |
| $SYS_REPORT .= "</tr>\n"; |
| next; |
| } |
| elsif(defined $Removed{$LName}) |
| { # removed library |
| $SYS_REPORT .= "<td class='failed'><a href='".$Removed{$LName}{"list"}."'>removed</a></td>\n"; |
| $SYS_REPORT .= "<td class='failed'>0%</td>\n" if($BinaryOnly); |
| $SYS_REPORT .= "<td class='failed'>0%</td>\n" if($SourceOnly); |
| if($RegisteredPairs{$LName}) { |
| # do nothing |
| } |
| elsif(my $To = $ChangedSoname{$LName}) |
| { |
| $RegisteredPairs{$To}=1; |
| $SYS_REPORT .= $SONAME_report; |
| } |
| else |
| { |
| foreach (1 .. $Columns) { |
| $SYS_REPORT .= "<td>N/A</td>\n"; # colspan='5' |
| } |
| } |
| $SYS_REPORT .= "</tr>\n"; |
| next; |
| } |
| elsif(defined $ChangedSoname{$LName}) |
| { # added library |
| $SYS_REPORT .= "<td class='ver'>".printVer($TestResults{$LName}{"v2"})."</td>\n"; |
| $SYS_REPORT .= "<td class='passed'>100%</td>\n" if($BinaryOnly); |
| $SYS_REPORT .= "<td class='passed'>100%</td>\n" if($SourceOnly); |
| if($RegisteredPairs{$LName}) { |
| # do nothing |
| } |
| elsif(my $To = $ChangedSoname{$LName}) |
| { |
| $RegisteredPairs{$To}=1; |
| $SYS_REPORT .= $SONAME_report; |
| } |
| else |
| { |
| foreach (1 .. $Columns) { |
| $SYS_REPORT .= "<td>N/A</td>\n"; # colspan='5' |
| } |
| } |
| $SYS_REPORT .= "</tr>\n"; |
| next; |
| } |
| elsif(not $GroupByHeaders) |
| { |
| $SYS_REPORT .= "<td class='ver'>".printVer($TestResults{$LName}{"v2"})."</td>\n"; |
| } |
| |
| my $BinCompatReport = $TestResults{$LName}{"Binary"}{"path"}; |
| my $SrcCompatReport = $TestResults{$LName}{"Source"}{"path"}; |
| |
| if($BinaryOnly) |
| { |
| if($TestResults{$LName}{"Binary"}{"verdict"} eq "compatible") |
| { |
| my $Cl = "passed"; |
| if($TOTAL{$LName}{"Binary"}) { |
| $Cl = "warning"; |
| } |
| $SYS_REPORT .= "<td class=\'$Cl\'><a href=\'$BinCompatReport\'>100%</a></td>\n"; |
| } |
| else |
| { |
| my $Compatible = 100 - $TestResults{$LName}{"Binary"}{"affected"}; |
| my $Cl = "incompatible"; |
| if($Compatible>=90) { |
| $Cl = "warning"; |
| } |
| elsif($Compatible>=80) { |
| $Cl = "almost_compatible"; |
| } |
| $SYS_REPORT .= "<td class=\'$Cl\'><a href=\'$BinCompatReport\'>$Compatible%</a></td>\n"; |
| } |
| } |
| if($SourceOnly) |
| { |
| if($TestResults{$LName}{"Source"}{"verdict"} eq "compatible") |
| { |
| my $Cl = "passed"; |
| if($TOTAL{$LName}{"Source"}) { |
| $Cl = "warning"; |
| } |
| $SYS_REPORT .= "<td class=\'$Cl\'><a href=\'$SrcCompatReport\'>100%</a></td>\n"; |
| } |
| else |
| { |
| my $Compatible = 100 - $TestResults{$LName}{"Source"}{"affected"}; |
| my $Cl = "incompatible"; |
| if($Compatible>=90) { |
| $Cl = "warning"; |
| } |
| elsif($Compatible>=80) { |
| $Cl = "almost_compatible"; |
| } |
| $SYS_REPORT .= "<td class=\'$Cl\'><a href=\'$SrcCompatReport\'>$Compatible%</a></td>\n"; |
| } |
| } |
| if($BinaryOnly) |
| { # show added/removed symbols at binary level |
| # for joined and -binary-only reports |
| my $AddedSym=""; |
| if(my $Count = $TestResults{$LName}{"Binary"}{"added"}) { |
| $AddedSym="<a href='$BinCompatReport\#Added'>$Count new</a>"; |
| } |
| if($AddedSym) { |
| $SYS_REPORT.="<td class='new'>$AddedSym</td>\n"; |
| } |
| else { |
| $SYS_REPORT.="<td class='passed'>0</td>\n"; |
| } |
| my $RemovedSym=""; |
| if(my $Count = $TestResults{$LName}{"Binary"}{"removed"}) { |
| $RemovedSym="<a href='$BinCompatReport\#Removed'>$Count removed</a>"; |
| } |
| if($RemovedSym) { |
| $SYS_REPORT.="<td class='failed'>$RemovedSym</td>\n"; |
| } |
| else { |
| $SYS_REPORT.="<td class='passed'>0</td>\n"; |
| } |
| } |
| elsif($SourceOnly) |
| { |
| my $AddedSym=""; |
| if(my $Count = $TestResults{$LName}{"Source"}{"added"}) { |
| $AddedSym="<a href='$SrcCompatReport\#Added'>$Count new</a>"; |
| } |
| if($AddedSym) { |
| $SYS_REPORT.="<td class='new'>$AddedSym</td>\n"; |
| } |
| else { |
| $SYS_REPORT.="<td class='passed'>0</td>\n"; |
| } |
| my $RemovedSym=""; |
| if(my $Count = $TestResults{$LName}{"Source"}{"removed"}) { |
| $RemovedSym="<a href='$SrcCompatReport\#Removed'>$Count removed</a>"; |
| } |
| if($RemovedSym) { |
| $SYS_REPORT.="<td class='failed'>$RemovedSym</td>\n"; |
| } |
| else { |
| $SYS_REPORT.="<td class='passed'>0</td>\n"; |
| } |
| } |
| |
| if(-d $HDiff) |
| { |
| if(-d $HDiff."/".$LName) { |
| $SYS_REPORT .= "<td><a href=\'headers_diff/$LName/diff.html\'>diff</a></td>\n"; |
| } |
| elsif(defined $Added{$LName} or defined $Removed{$LName}) { |
| $SYS_REPORT .= "<td>N/A</td>\n"; |
| } |
| else { |
| $SYS_REPORT .= "<td>Empty</td>\n"; |
| } |
| } |
| |
| $SYS_REPORT .= "</tr>\n"; |
| } |
| |
| $SYS_REPORT .= "</table>"; |
| |
| my $Title = "$SystemName1 vs $SystemName2 compatibility report"; |
| my $Keywords = "compatibility, $SystemName1, $SystemName2, API, changes"; |
| my $Description = "API compatibility report between $SystemName1 and $SystemName2 on ".showArch($ArchName); |
| my $Styles = readModule("Styles", "CmpSystems.css"); |
| |
| $SYS_REPORT = composeHTML_Head($Title, $Keywords, $Description, $Styles, "")."\n<body>\n<div>".$SYS_REPORT."</div>\n"; |
| $SYS_REPORT .= "<br/><br/>\n"; |
| $SYS_REPORT .= getReportFooter(); |
| $SYS_REPORT .= "</body></html>\n"; |
| |
| if($SourceOnly) { |
| $SYS_REPORT = "<!-\- kind:source;".join(";", @{$META_DATA{"Source"}})." -\->\n".$SYS_REPORT; |
| } |
| if($BinaryOnly) { |
| $SYS_REPORT = "<!-\- kind:binary;".join(";", @{$META_DATA{"Binary"}})." -\->\n".$SYS_REPORT; |
| } |
| my $REPORT_PATH = $SYS_REPORT_PATH."/"; |
| if($BinaryOnly and $SourceOnly) { |
| $REPORT_PATH .= "compat_report.html"; |
| } |
| elsif($BinaryOnly) { |
| $REPORT_PATH .= "abi_compat_report.html"; |
| } |
| elsif($SourceOnly) { |
| $REPORT_PATH .= "src_compat_report.html"; |
| } |
| writeFile($REPORT_PATH, $SYS_REPORT); |
| printMsg("INFO", "\nSee detailed report:\n $REPORT_PATH"); |
| } |
| |
| sub printVer($) |
| { |
| if($_[0] eq "") { |
| return 0; |
| } |
| return $_[0]; |
| } |
| |
| sub getPrefix_S($) |
| { |
| my $Prefix = getPrefix($_[0]); |
| if(not $Prefix or defined $NonPrefix{lc($Prefix)}) { |
| return "NONE"; |
| } |
| return $Prefix; |
| } |
| |
| sub problem_title($) |
| { |
| if($_[0]==1) { |
| return "1 change"; |
| } |
| else { |
| return $_[0]." changes"; |
| } |
| } |
| |
| sub warning_title($) |
| { |
| if($_[0]==1) { |
| return "1 warning"; |
| } |
| else { |
| return $_[0]." warnings"; |
| } |
| } |
| |
| sub readSystemDescriptor($) |
| { |
| my $Content = $_[0]; |
| $Content=~s/\/\*(.|\n)+?\*\///g; |
| $Content=~s/<\!--(.|\n)+?-->//g; |
| $SysDescriptor{"Name"} = parseTag(\$Content, "name"); |
| my @Tools = (); |
| if(not $SysDescriptor{"Name"}) { |
| exitStatus("Error", "system name is not specified (<name> section)"); |
| } |
| foreach my $Path (split(/\s*\n\s*/, parseTag(\$Content, "libs"))) |
| { # target libs |
| if(not -e $Path) { |
| exitStatus("Access_Error", "can't access \'$Path\'"); |
| } |
| $Path = get_abs_path($Path); |
| $Path=~s/[\/\\]+\Z//g; |
| $SysDescriptor{"Libs"}{$Path} = 1; |
| } |
| foreach my $Path (split(/\s*\n\s*/, parseTag(\$Content, "search_libs"))) |
| { # target libs |
| if(not -d $Path) { |
| exitStatus("Access_Error", "can't access directory \'$Path\'"); |
| } |
| $Path = get_abs_path($Path); |
| $Path=~s/[\/\\]+\Z//g; |
| $SysDescriptor{"SearchLibs"}{$Path} = 1; |
| } |
| foreach my $Path (split(/\s*\n\s*/, parseTag(\$Content, "skip_libs"))) |
| { # skip libs |
| $SysDescriptor{"SkipLibs"}{$Path} = 1; |
| } |
| foreach my $Path (split(/\s*\n\s*/, parseTag(\$Content, "headers"))) |
| { |
| if(not -e $Path) { |
| exitStatus("Access_Error", "can't access \'$Path\'"); |
| } |
| $Path = get_abs_path($Path); |
| $Path=~s/[\/\\]+\Z//g; |
| $SysDescriptor{"Headers"}{$Path} = 1; |
| } |
| foreach my $Path (split(/\s*\n\s*/, parseTag(\$Content, "search_headers"))) |
| { |
| if(not -d $Path) { |
| exitStatus("Access_Error", "can't access directory \'$Path\'"); |
| } |
| $Path = get_abs_path($Path); |
| $Path=~s/[\/\\]+\Z//g; |
| $SysDescriptor{"SearchHeaders"}{$Path} = 1; |
| } |
| foreach my $Path (split(/\s*\n\s*/, parseTag(\$Content, "tools"))) |
| { |
| if(not -d $Path) { |
| exitStatus("Access_Error", "can't access directory \'$Path\'"); |
| } |
| $Path = get_abs_path($Path); |
| $Path=~s/[\/\\]+\Z//g; |
| $SysDescriptor{"Tools"}{$Path} = 1; |
| push(@Tools, $Path); |
| } |
| foreach my $Path (split(/\s*\n\s*/, parseTag(\$Content, "gcc_options"))) |
| { |
| $Path=~s/[\/\\]+\Z//g; |
| $SysDescriptor{"GccOpts"}{$Path} = 1; |
| } |
| if($SysDescriptor{"CrossPrefix"} = parseTag(\$Content, "cross_prefix")) |
| { # <cross_prefix> section of XML descriptor |
| $CrossPrefix = $SysDescriptor{"CrossPrefix"}; |
| } |
| elsif($CrossPrefix) |
| { # -cross-prefix tool option |
| $SysDescriptor{"CrossPrefix"} = $CrossPrefix; |
| } |
| $SysDescriptor{"Defines"} = parseTag(\$Content, "defines"); |
| if($SysDescriptor{"Image"} = parseTag(\$Content, "image")) |
| { # <image> |
| # FIXME: isn't implemented yet |
| if(not -f $SysDescriptor{"Image"}) { |
| exitStatus("Access_Error", "can't access \'".$SysDescriptor{"Image"}."\'"); |
| } |
| } |
| return {"Tools"=>\@Tools,"CrossPrefix"=>$CrossPrefix}; |
| } |
| |
| sub initModule($) |
| { |
| my $S = $_[0]; |
| |
| $OStarget = $S->{"OStarget"}; |
| $Debug = $S->{"Debug"}; |
| $Quiet = $S->{"Quiet"}; |
| $LogMode = $S->{"LogMode"}; |
| $CheckHeadersOnly = $S->{"CheckHeadersOnly"}; |
| |
| $SystemRoot = $S->{"SystemRoot"}; |
| $GCC_PATH = $S->{"GCC_PATH"}; |
| $TargetSysInfo = $S->{"TargetSysInfo"}; |
| $CrossPrefix = $S->{"CrossPrefix"}; |
| $TargetLibraryName = $S->{"TargetLibraryName"}; |
| $CrossGcc = $S->{"CrossGcc"}; |
| $UseStaticLibs = $S->{"UseStaticLibs"}; |
| $NoStdInc = $S->{"NoStdInc"}; |
| $CxxIncompat = $S->{"CxxIncompat"}; |
| $SkipUnidentified = $S->{"SkipUnidentified"}; |
| $DisableConstantsCheck = $S->{"DisableConstantsCheck"}; |
| |
| $BinaryOnly = $S->{"BinaryOnly"}; |
| $SourceOnly = $S->{"SourceOnly"}; |
| |
| if(not $BinaryOnly and not $SourceOnly) |
| { # default |
| $BinaryOnly = 1; |
| } |
| } |
| |
| sub check_list($$) |
| { |
| my ($Item, $Skip) = @_; |
| return 0 if(not $Skip); |
| foreach (@{$Skip}) |
| { |
| my $Pattern = $_; |
| if(index($Pattern, "*")!=-1) |
| { # wildcards |
| $Pattern=~s/\*/.*/g; # to perl format |
| if($Item=~/$Pattern/) { |
| return 1; |
| } |
| } |
| elsif(index($Pattern, "/")!=-1 |
| or index($Pattern, "\\")!=-1) |
| { # directory |
| if(index($Item, $Pattern)!=-1) { |
| return 1; |
| } |
| } |
| elsif($Item eq $Pattern |
| or get_filename($Item) eq $Pattern) |
| { # by name |
| return 1; |
| } |
| } |
| return 0; |
| } |
| |
| sub filter_format($) |
| { |
| my $FiltRef = $_[0]; |
| foreach my $Entry (keys(%{$FiltRef})) |
| { |
| foreach my $Filt (@{$FiltRef->{$Entry}}) |
| { |
| if($Filt=~/[\/\\]/) { |
| $Filt = path_format($Filt, $OSgroup); |
| } |
| } |
| } |
| } |
| |
| sub readSysDescriptor($) |
| { |
| my $Path = $_[0]; |
| my $Content = readFile($Path); |
| my %Tags = ( |
| "headers" => "mf", |
| "skip_headers" => "mf", |
| "skip_including" => "mf", |
| "skip_include_paths" => "mf", |
| "skip_libs" => "mf", |
| "include_preamble" => "mf", |
| "add_include_paths" => "mf", |
| "gcc_options" => "m", |
| "skip_symbols" => "m", |
| "skip_types" => "m", |
| "ignore_symbols" => "h", |
| "non_prefix" => "h", |
| "defines" => "s", |
| "cxx_incompatible" => "s" |
| ); |
| my %DInfo = (); |
| foreach my $Tag (keys(%Tags)) |
| { |
| if(my $TContent = parseTag(\$Content, $Tag)) |
| { |
| if($Tags{$Tag}=~/m/) |
| { # multi-line (+order) |
| my @Items = split(/\s*\n\s*/, $TContent); |
| $DInfo{$Tag} = []; |
| foreach my $Item (@Items) |
| { |
| if($Tags{$Tag}=~/f/) { |
| $Item = path_format($Item, $OSgroup); |
| } |
| push(@{$DInfo{$Tag}}, $Item); |
| } |
| |
| } |
| elsif($Tags{$Tag}=~/s/) |
| { # single element |
| $DInfo{$Tag} = $TContent; |
| } |
| else |
| { # hash array |
| my @Items = split(/\s*\n\s*/, $TContent); |
| foreach my $Item (@Items) { |
| $DInfo{$Tag}{$Item}=1; |
| } |
| } |
| } |
| } |
| |
| if(defined $DInfo{"non_self_compiled"}) |
| { # support for old ABI dumps |
| $DInfo{"skip_including"} = $DInfo{"non_self_compiled"}; |
| } |
| |
| return \%DInfo; |
| } |
| |
| sub readSysInfo($) |
| { |
| my $Target = $_[0]; |
| |
| if(not $TargetSysInfo) { |
| exitStatus("Error", "system info path is not specified"); |
| } |
| if(not -d $TargetSysInfo) { |
| exitStatus("Module_Error", "can't access \'$TargetSysInfo\'"); |
| } |
| # Library Specific Info |
| my %SysInfo = (); |
| if(-d $TargetSysInfo."/descriptors/") |
| { |
| foreach my $DPath (cmd_find($TargetSysInfo."/descriptors/","f","",1)) |
| { |
| my $LSName = get_filename($DPath); |
| $LSName=~s/\.xml\Z//; |
| $SysInfo{$LSName} = readSysDescriptor($DPath); |
| } |
| } |
| else { |
| printMsg("WARNING", "can't find \'$TargetSysInfo/descriptors\'"); |
| } |
| |
| # Exceptions |
| if(check_gcc($GCC_PATH, "4.4")) |
| { # exception for libstdc++ |
| $SysInfo{"libstdc++"}{"gcc_options"} = ["-std=c++0x"]; |
| } |
| if($OStarget eq "symbian") |
| { # exception for libstdcpp |
| $SysInfo{"libstdcpp"}{"defines"} = "namespace std { struct nothrow_t {}; }"; |
| } |
| if($SysDescriptor{"Name"}=~/maemo/i) |
| { # GL/gl.h: No such file |
| $SysInfo{"libSDL"}{"skip_headers"}=["SDL_opengl.h"]; |
| } |
| |
| # Common Info |
| my $SysCInfo = {}; |
| if(-f $TargetSysInfo."/common.xml") { |
| $SysCInfo = readSysDescriptor($TargetSysInfo."/common.xml"); |
| } |
| else { |
| printMsg("Module_Error", "can't find \'$TargetSysInfo/common.xml\'"); |
| } |
| |
| my @CompilerOpts = (); |
| if($SysDescriptor{"Name"}=~/maemo|meego/i) { |
| push(@CompilerOpts, "-DMAEMO_CHANGES", "-DM_APPLICATION_NAME=\\\"app\\\""); |
| } |
| if(my @Opts = keys(%{$SysDescriptor{"GccOpts"}})) { |
| push(@CompilerOpts, @Opts); |
| } |
| if(@CompilerOpts) |
| { |
| if(not $SysCInfo->{"gcc_options"}) { |
| $SysCInfo->{"gcc_options"} = []; |
| } |
| push(@{$SysCInfo->{"gcc_options"}}, @CompilerOpts); |
| } |
| return (\%SysInfo, $SysCInfo); |
| } |
| |
| sub get_binversion($) |
| { |
| my $Path = $_[0]; |
| if($OStarget eq "windows" |
| and $LIB_EXT eq "dll") |
| { # get version of DLL using "sigcheck" |
| my $SigcheckCmd = get_CmdPath("sigcheck"); |
| if(not $SigcheckCmd) { |
| return ""; |
| } |
| my $VInfo = `$SigcheckCmd -nobanner -n $Path 2>$TMP_DIR/null`; |
| $VInfo=~s/\s*\(.*\)\s*//; |
| chomp($VInfo); |
| |
| if($VInfo eq "n/a") { |
| $VInfo = uc($VInfo); |
| } |
| |
| return $VInfo; |
| } |
| return ""; |
| } |
| |
| sub readBytes($) |
| { |
| sysopen(FILE, $_[0], O_RDONLY); |
| sysread(FILE, my $Header, 4); |
| close(FILE); |
| my @Bytes = map { sprintf('%02x', ord($_)) } split (//, $Header); |
| return join("", @Bytes); |
| } |
| |
| sub dumpSystem($) |
| { # -dump-system option handler |
| # should be used with -sysroot and -cross-gcc options |
| my $Opts = $_[0]; |
| initModule($Opts); |
| |
| my $SysName_P = $SysDescriptor{"Name"}; |
| $SysName_P=~s/ /_/g; |
| |
| my $SYS_DUMP_PATH = "sys_dumps/".$SysName_P."/".getArch(1); |
| if(not $TargetLibraryName) { |
| rmtree($SYS_DUMP_PATH); |
| } |
| my (@SystemLibs, @SysHeaders) = (); |
| |
| foreach my $Path (keys(%{$SysDescriptor{"Libs"}})) |
| { |
| if(not -e $Path) { |
| exitStatus("Access_Error", "can't access \'$Path\'"); |
| } |
| if(-d $Path) |
| { |
| if(my @SubLibs = find_libs($Path,"",1)) { |
| push(@SystemLibs, @SubLibs); |
| } |
| $SysDescriptor{"SearchLibs"}{$Path}=1; |
| } |
| else |
| { # single file |
| push(@SystemLibs, $Path); |
| $SysDescriptor{"SearchLibs"}{get_dirname($Path)}=1; |
| } |
| } |
| foreach my $Path (keys(%{$SysDescriptor{"Headers"}})) |
| { |
| if(not -e $Path) { |
| exitStatus("Access_Error", "can't access \'$Path\'"); |
| } |
| if(-d $Path) |
| { |
| if(my @SubHeaders = cmd_find($Path,"f","","")) { |
| push(@SysHeaders, @SubHeaders); |
| } |
| $SysDescriptor{"SearchHeaders"}{$Path}=1; |
| } |
| else |
| { # single file |
| push(@SysHeaders, $Path); |
| $SysDescriptor{"SearchHeaders"}{get_dirname($Path)}=1; |
| } |
| } |
| my $GroupByHeaders = 0; |
| if($CheckHeadersOnly) |
| { # -headers-only |
| $GroupByHeaders = 1; |
| # @SysHeaders = optimize_set(@SysHeaders); |
| } |
| elsif($SysDescriptor{"Image"}) |
| { # one big image |
| $GroupByHeaders = 1; |
| @SystemLibs = ($SysDescriptor{"Image"}); |
| } |
| writeFile($SYS_DUMP_PATH."/target.txt", $OStarget); |
| my (%SysLib_Symbols, %SymbolGroup, %Symbol_SysHeaders, |
| %SysHeader_Symbols, %SysLib_SysHeaders) = (); |
| my (%Skipped, %Failed) = (); |
| my (%SysHeaderDir_Used, %SysHeaderDir_SysHeaders) = (); |
| my (%SymbolCounter, %TotalLibs) = (); |
| my (%PrefixToLib, %LibPrefix, %PrefixSymbols) = (); |
| |
| my %Glibc = map {$_=>1} ( |
| "libc", |
| "libpthread" |
| ); |
| my ($SysInfo, $SysCInfo) = readSysInfo($OStarget); |
| |
| foreach (keys(%{$SysCInfo->{"non_prefix"}})) |
| { |
| $NonPrefix{$_} = 1; |
| $NonPrefix{$_."_"} = 1; |
| $NonPrefix{"_".$_} = 1; |
| $NonPrefix{"_".$_."_"} = 1; |
| } |
| |
| if(not $GroupByHeaders) |
| { |
| if($Debug) { |
| printMsg("INFO", localtime(time)); |
| } |
| printMsg("INFO", "Indexing sonames ...\n"); |
| } |
| my (%LibSoname, %SysLibVersion) = (); |
| my %DevelPaths = map {$_=>1} @SystemLibs; |
| foreach my $Path (sort keys(%{$SysDescriptor{"SearchLibs"}})) |
| { |
| foreach my $LPath (find_libs($Path,"",1)) { |
| $DevelPaths{$LPath}=1; |
| } |
| } |
| foreach my $LPath (keys(%DevelPaths)) |
| { # register SONAMEs |
| my $LName = get_filename($LPath); |
| if(not is_target_lib($LName)) { |
| next; |
| } |
| if($OSgroup=~/\A(linux|macos|freebsd)\Z/ |
| and $LName!~/\Alib/) { |
| next; |
| } |
| if(my $Soname = getSONAME($LPath)) |
| { |
| if($OStarget eq "symbian") |
| { |
| if($Soname=~/[\/\\]/) |
| { # L://epoc32/release/armv5/lib/gfxtrans{000a0000}.dso |
| $Soname = get_filename($Soname); |
| } |
| $Soname = lc($Soname); |
| } |
| if(not defined $LibSoname{$LName}) { |
| $LibSoname{$LName}=$Soname; |
| } |
| if(-l $LPath and my $Path = realpath_F($LPath)) |
| { |
| my $Name = get_filename($Path); |
| if(not defined $LibSoname{$Name}) { |
| $LibSoname{$Name}=$Soname; |
| } |
| } |
| } |
| else |
| { # windows and others |
| $LibSoname{$LName}=$LName; |
| } |
| } |
| my $SONAMES = ""; |
| foreach (sort {lc($a) cmp lc($b)} keys(%LibSoname)) { |
| $SONAMES .= $_.";".$LibSoname{$_}."\n"; |
| } |
| if(not $GroupByHeaders) { |
| writeFile($SYS_DUMP_PATH."/sonames.txt", $SONAMES); |
| } |
| foreach my $LPath (sort keys(%DevelPaths)) |
| { # register VERSIONs |
| my $LName = get_filename($LPath); |
| if(not is_target_lib($LName) |
| and not is_target_lib($LibSoname{$LName})) { |
| next; |
| } |
| if(my $BV = get_binversion($LPath)) |
| { # binary version |
| $SysLibVersion{$LName} = $BV; |
| } |
| elsif(my $PV = parse_libname($LName, "version", $OStarget)) |
| { # source version |
| $SysLibVersion{$LName} = $PV; |
| } |
| elsif(my $SV = parse_libname(getSONAME($LPath), "version", $OStarget)) |
| { # soname version |
| $SysLibVersion{$LName} = $SV; |
| } |
| elsif($LName=~/(\d[\d\.\-\_]*)\.$LIB_EXT\Z/) |
| { # libfreebl3.so |
| if($1 ne 32 and $1 ne 64) { |
| $SysLibVersion{$LName} = $1; |
| } |
| } |
| } |
| my $VERSIONS = ""; |
| foreach (sort {lc($a) cmp lc($b)} keys(%SysLibVersion)) { |
| $VERSIONS .= $_.";".$SysLibVersion{$_}."\n"; |
| } |
| if(not $GroupByHeaders) { |
| writeFile($SYS_DUMP_PATH."/versions.txt", $VERSIONS); |
| } |
| |
| # create target list |
| my @SkipLibs = keys(%{$SysDescriptor{"SkipLibs"}}); |
| if(my $CSkip = $SysCInfo->{"skip_libs"}) { |
| push(@SkipLibs, @{$CSkip}); |
| } |
| if(@SkipLibs and not $TargetLibraryName) |
| { |
| my %SkipLibs = map {$_ => 1} @SkipLibs; |
| my @Target = (); |
| foreach my $LPath (@SystemLibs) |
| { |
| my $LName = get_filename($LPath); |
| my $LName_Short = parse_libname($LName, "name+ext", $OStarget); |
| if(not defined $SkipLibs{$LName_Short} |
| and not defined $SkipLibs{$LName} |
| and not check_list($LPath, \@SkipLibs)) { |
| push(@Target, $LName); |
| } |
| } |
| add_target_libs(\@Target); |
| } |
| |
| my %SysLibs = (); |
| foreach my $LPath (sort @SystemLibs) |
| { |
| my $LName = get_filename($LPath); |
| my $LSName = parse_libname($LName, "short", $OStarget); |
| my $LRelPath = cut_path_prefix($LPath, $SystemRoot); |
| if(not is_target_lib($LName)) { |
| next; |
| } |
| if($OSgroup=~/\A(linux|macos|freebsd)\Z/ |
| and $LName!~/\Alib/) { |
| next; |
| } |
| if($OStarget eq "symbian") |
| { |
| if(my $V = parse_libname($LName, "version", $OStarget)) |
| { # skip qtcore.dso |
| # register qtcore{00040604}.dso |
| delete($SysLibs{get_dirname($LPath)."\\".$LSName.".".$LIB_EXT}); |
| my $MV = parse_libname($LibSoname{$LSName.".".$LIB_EXT}, "version", $OStarget); |
| if($MV and $V ne $MV) |
| { # skip other versions: |
| # qtcore{00040700}.dso |
| # qtcore{00040702}.dso |
| next; |
| } |
| } |
| } |
| if(-l $LPath) |
| { # symlinks |
| if(my $Path = realpath_F($LPath)) { |
| $SysLibs{$Path} = 1; |
| } |
| } |
| elsif(-f $LPath) |
| { |
| if($Glibc{$LSName} |
| and cmd_file($LPath)=~/ASCII/) |
| { # GNU ld scripts (libc.so, libpthread.so) |
| my @Candidates = cmd_find($SystemRoot."/lib","",$LSName.".".$LIB_EXT."*","1"); |
| if(@Candidates) |
| { |
| my $Candidate = $Candidates[0]; |
| if(-l $Candidate |
| and my $Path = realpath_F($Candidate)) { |
| $Candidate = $Path; |
| } |
| $SysLibs{$Candidate} = 1; |
| } |
| } |
| else { |
| $SysLibs{$LPath} = 1; |
| } |
| } |
| } |
| @SystemLibs = (); # clear memory |
| |
| if(not keys(%SysLibs)) { |
| exitStatus("Error", "can't find libraries"); |
| } |
| |
| if(not $CheckHeadersOnly) |
| { |
| if($Debug) { |
| printMsg("INFO", localtime(time)); |
| } |
| if($SysDescriptor{"Image"}) { |
| printMsg("INFO", "Reading symbols from image ...\n"); |
| } |
| else { |
| printMsg("INFO", "Reading symbols from libraries ...\n"); |
| } |
| } |
| |
| my %Syms = (); |
| my @AllSyms = {}; |
| my %ShortestNames = (); |
| |
| foreach my $LPath (sort {lc($a) cmp lc($b)} keys(%SysLibs)) |
| { |
| my $LRelPath = cut_path_prefix($LPath, $SystemRoot); |
| my $LName = get_filename($LPath); |
| |
| $ShortestNames{$LPath} = parse_libname($LName, "shortest", $OStarget); |
| |
| my $Res = readSymbols_Lib(1, $LPath, 0, "-Weak", 0, 0); |
| |
| if(not keys(%{$Res}) and $TargetLibraryName) { |
| exitStatus("Error", "can't find exported symbols in the library"); |
| } |
| |
| $Syms{$LPath} = $Res->{$LName}; |
| push(@AllSyms, keys(%{$Syms{$LPath}})); |
| } |
| |
| my $Translate = translateSymbols(@AllSyms, 1); |
| |
| my %DupSymbols = (); |
| |
| foreach my $LPath (sort {lc($a) cmp lc($b)} keys(%SysLibs)) |
| { |
| my $LRelPath = cut_path_prefix($LPath, $SystemRoot); |
| my $LName = get_filename($LPath); |
| foreach my $Symbol (keys(%{$Syms{$LPath}})) |
| { |
| $Symbol=~s/[\@\$]+(.*)\Z//g; |
| if($Symbol=~/\A(_Z|\?)/) |
| { |
| if(isPrivateData($Symbol)) { |
| next; |
| } |
| if($Symbol=~/(C1|C2|D0|D1|D2)E/) |
| { # do NOT analyze constructors |
| # and destructors |
| next; |
| } |
| my $Unmangled = $Translate->{$Symbol}; |
| $Unmangled=~s/<.+>//g; |
| if($Unmangled=~/\A([\w:]+)/) |
| { # cut out the parameters |
| my @Elems = split(/::/, $1); |
| my ($Class, $Short) = ("", ""); |
| $Short = $Elems[$#Elems]; |
| if($#Elems>=1) |
| { |
| $Class = $Elems[$#Elems-1]; |
| pop(@Elems); |
| } |
| # the short and class name should be |
| # matched in one header file |
| $SymbolGroup{$LRelPath}{$Class} = $Short; |
| foreach my $Sym (@Elems) |
| { |
| if($SysCInfo->{"ignore_symbols"}{$Symbol}) |
| { # do NOT match this symbol |
| next; |
| } |
| $SysLib_Symbols{$LPath}{$Sym} = 1; |
| if(my $Prefix = getPrefix_S($Sym)) |
| { |
| $PrefixToLib{$Prefix}{$LName} += 1; |
| $LibPrefix{$LPath}{$Prefix} += 1; |
| $PrefixSymbols{$LPath}{$Prefix}{$Sym} = 1; |
| } |
| $SymbolCounter{$Sym}{$LPath} = 1; |
| |
| if(my @Libs = keys(%{$SymbolCounter{$Sym}})) |
| { |
| if($#Libs>=1) |
| { |
| foreach (@Libs) { |
| $DupSymbols{$_}{$Sym} = 1; |
| } |
| } |
| } |
| } |
| } |
| } |
| else |
| { |
| if($SysCInfo->{"ignore_symbols"}{$Symbol}) |
| { # do NOT match this symbol |
| next; |
| } |
| $SysLib_Symbols{$LPath}{$Symbol} = 1; |
| if(my $Prefix = getPrefix_S($Symbol)) |
| { |
| $PrefixToLib{$Prefix}{$LName} += 1; |
| $LibPrefix{$LPath}{$Prefix} += 1; |
| $PrefixSymbols{$LPath}{$Prefix}{$Symbol} = 1; |
| } |
| $SymbolCounter{$Symbol}{$LPath} = 1; |
| |
| if(my @Libs = keys(%{$SymbolCounter{$Symbol}})) |
| { |
| if($#Libs>=1) |
| { |
| foreach (@Libs) { |
| $DupSymbols{$_}{$Symbol} = 1; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| %Syms = (); |
| %{$Translate} = (); |
| |
| # remove minor symbols |
| foreach my $LPath (keys(%SysLib_Symbols)) |
| { |
| my $SName = $ShortestNames{$LPath}; |
| my $Count = keys(%{$SysLib_Symbols{$LPath}}); |
| my %Prefixes = %{$LibPrefix{$LPath}}; |
| my @Prefixes = sort {$Prefixes{$b}<=>$Prefixes{$a}} keys(%Prefixes); |
| |
| if($#Prefixes>=1) |
| { |
| my $MaxPrefix = $Prefixes[0]; |
| if($MaxPrefix eq "NONE") { |
| $MaxPrefix = $Prefixes[1]; |
| } |
| my $Max = $Prefixes{$MaxPrefix}; |
| my $None = $Prefixes{"NONE"}; |
| |
| next if($None*100/$Count>=50); |
| next if($None>=$Max); |
| |
| foreach my $Prefix (@Prefixes) |
| { |
| next if($Prefix eq $MaxPrefix); |
| my $Num = $Prefixes{$Prefix}; |
| my $Rm = 0; |
| |
| if($Prefix eq "NONE") { |
| $Rm = 1; |
| } |
| else |
| { |
| if($Num*100/$Max<5) { |
| $Rm = 1; |
| } |
| } |
| |
| if($Rm) |
| { |
| next if($Prefix=~/\Q$MaxPrefix\E/i); |
| next if($MaxPrefix=~/\Q$Prefix\E/i); |
| next if($Prefix=~/\Q$SName\E/i); |
| |
| foreach my $Symbol (keys(%{$PrefixSymbols{$LPath}{$Prefix}})) { |
| delete($SysLib_Symbols{$LPath}{$Symbol}); |
| } |
| } |
| } |
| } |
| } |
| |
| %PrefixSymbols = (); # free memory |
| |
| if(not $CheckHeadersOnly) { |
| writeFile($SYS_DUMP_PATH."/debug/symbols.txt", Dumper(\%SysLib_Symbols)); |
| } |
| |
| my (%DupLibs, %VersionedLibs) = (); |
| foreach my $LPath (sort keys(%DupSymbols)) |
| { # match duplicated libs |
| # libmenu contains all symbols from libmenuw |
| my @Syms = keys(%{$SysLib_Symbols{$LPath}}); |
| next if($#Syms==-1); |
| if($#Syms+1==keys(%{$DupSymbols{$LPath}})) { |
| $DupLibs{$LPath} = 1; |
| } |
| } |
| foreach my $Prefix (keys(%PrefixToLib)) |
| { |
| my @Libs = keys(%{$PrefixToLib{$Prefix}}); |
| @Libs = sort {$PrefixToLib{$Prefix}{$b}<=>$PrefixToLib{$Prefix}{$a}} @Libs; |
| $PrefixToLib{$Prefix} = $Libs[0]; |
| } |
| |
| my %PackageFile = (); # to improve results |
| my %FilePackage = (); |
| my %LibraryFile = (); |
| |
| if(0) |
| { |
| if($Debug) { |
| printMsg("INFO", localtime(time)); |
| } |
| printMsg("INFO", "Reading info from packages ...\n"); |
| if(my $Urpmf = get_CmdPath("urpmf")) |
| { # Mandriva, ROSA |
| my $Out = $TMP_DIR."/urpmf.out"; |
| system("urpmf : >\"$Out\""); |
| open(FILE, $Out); |
| while(<FILE>) |
| { |
| chomp($_); |
| if(my $M = index($_, ":")) |
| { |
| my $Pkg = substr($_, 0, $M); |
| my $File = substr($_, $M+1); |
| $PackageFile{$Pkg}{$File} = 1; |
| $FilePackage{$File} = $Pkg; |
| } |
| } |
| close(FILE); |
| } |
| } |
| |
| if(keys(%FilePackage)) |
| { |
| foreach my $LPath (sort {lc($a) cmp lc($b)} keys(%SysLibs)) |
| { |
| my $LName = get_filename($LPath); |
| my $LDir = get_dirname($LPath); |
| my $LName_Short = parse_libname($LName, "name+ext", $OStarget); |
| |
| my $Pkg = $FilePackage{$LDir."/".$LName_Short}; |
| if(not $Pkg) |
| { |
| my $RPkg = $FilePackage{$LPath}; |
| if(defined $PackageFile{$RPkg."-devel"}) { |
| $Pkg = $RPkg."-devel"; |
| } |
| if($RPkg=~s/[\d\.]+\Z//g) |
| { |
| if(defined $PackageFile{$RPkg."-devel"}) { |
| $Pkg = $RPkg."-devel"; |
| } |
| } |
| } |
| if($Pkg) |
| { |
| foreach (keys(%{$PackageFile{$Pkg}})) |
| { |
| if(index($_, "/usr/include/")==0) { |
| $LibraryFile{$LPath}{$_} = 1; |
| } |
| } |
| } |
| |
| $LName_Short=~s/\.so\Z/.a/; |
| if($Pkg = $FilePackage{$LDir."/".$LName_Short}) |
| { # headers for static library |
| foreach (keys(%{$PackageFile{$Pkg}})) |
| { |
| if(index($_, "/usr/include/")==0) { |
| $LibraryFile{$LPath}{$_} = 1; |
| } |
| } |
| } |
| } |
| } |
| |
| my %HeaderFile_Path = (); |
| |
| if($Debug) { |
| printMsg("INFO", localtime(time)); |
| } |
| printMsg("INFO", "Reading symbols from headers ...\n"); |
| foreach my $HPath (@SysHeaders) |
| { |
| $HPath = path_format($HPath, $OSgroup); |
| if(readBytes($HPath) eq "7f454c46") |
| { # skip ELF files |
| next; |
| } |
| my $HRelPath = cut_path_prefix($HPath, $SystemRoot); |
| my ($HDir, $HName) = separate_path($HRelPath); |
| if(is_not_header($HName)) |
| { # have a wrong extension: .gch, .in |
| next; |
| } |
| if($HName=~/~\Z/) |
| { # reserved copy |
| next; |
| } |
| if(index($HRelPath, "/_gen")!=-1) |
| { # telepathy-1.0/telepathy-glib/_gen |
| # telepathy-1.0/libtelepathy/_gen-tp-constants-deprecated.h |
| next; |
| } |
| if(index($HRelPath, "include/linux/")!=-1) |
| { # kernel-space headers |
| next; |
| } |
| if(index($HRelPath, "include/asm/")!=-1) |
| { # asm headers |
| next; |
| } |
| if(index($HRelPath, "/microb-engine/")!=-1) |
| { # MicroB engine (Maemo 4) |
| next; |
| } |
| if($HRelPath=~/\Wprivate(\W|\Z)/) |
| { # private directories (include/tcl-private, ...) |
| next; |
| } |
| if(index($HRelPath, "/lib/")!=-1) |
| { |
| if(not is_header_file($HName)) |
| { # without or with a wrong extension |
| # under the /lib directory |
| next; |
| } |
| } |
| my $Content = readFile($HPath); |
| $Content=~s/\/\*(.|\n)+?\*\///g; |
| $Content=~s/\/\/.*?\n//g; # remove comments |
| $Content=~s/#\s*define[^\n\\]*(\\\n[^\n\\]*)+\n*//g; # remove defines |
| $Content=~s/#[^\n]*?\n//g; # remove directives |
| $Content=~s/(\A|\n)class\s+\w+;\n//g; # remove forward declarations |
| # FIXME: try to add preprocessing stage |
| foreach my $Symbol (split(/\W+/, $Content)) |
| { |
| next if(not $Symbol); |
| $Symbol_SysHeaders{$Symbol}{$HRelPath} = 1; |
| $SysHeader_Symbols{$HRelPath}{$Symbol} = 1; |
| } |
| $SysHeaderDir_SysHeaders{$HDir}{$HName} = 1; |
| $HeaderFile_Path{get_filename($HRelPath)}{$HRelPath} = 1; |
| } |
| |
| # writeFile($SYS_DUMP_PATH."/debug/headers.txt", Dumper(\%SysHeader_Symbols)); |
| |
| my %SkipDHeaders = ( |
| # header files, that should be in the <skip_headers> section |
| # but should be matched in the algorithm |
| # MeeGo 1.2 Harmattan |
| "libtelepathy-qt4" => ["TelepathyQt4/_gen", "client.h", |
| "TelepathyQt4/*-*", "debug.h", "global.h", |
| "properties.h", "Channel", "channel.h", "message.h"], |
| ); |
| filter_format(\%SkipDHeaders); |
| if(not $GroupByHeaders) |
| { |
| if($Debug) { |
| printMsg("INFO", localtime(time)); |
| } |
| printMsg("INFO", "Matching symbols ...\n"); |
| } |
| |
| foreach my $LPath (sort {lc($a) cmp lc($b)} keys(%SysLibs)) |
| { # matching |
| my $LName = get_filename($LPath); |
| } |
| |
| foreach my $LPath (sort {lc($a) cmp lc($b)} keys(%SysLibs)) |
| { # matching |
| my $LName = get_filename($LPath); |
| my $LName_Short = parse_libname($LName, "name", $OStarget); |
| my $LRelPath = cut_path_prefix($LPath, $SystemRoot); |
| my $LSName = parse_libname($LName, "short", $OStarget); |
| my $SName = $ShortestNames{$LPath}; |
| |
| my @TryNames = (); # libX-N.so.M |
| |
| if(my $Ver = $SysLibVersion{$LName}) |
| { # libX-N-M |
| if($LSName."-".$Ver ne $LName_Short) |
| { |
| push(@TryNames, $LName_Short."-".$Ver); |
| #while($Ver=~s/\.\d+\Z//) { # partial versions |
| # push(@TryNames, $LName_Short."-".$Ver); |
| #} |
| } |
| } |
| push(@TryNames, $LName_Short); # libX-N |
| if($LSName ne $LName_Short) |
| { # libX |
| push(@TryNames, $LSName); |
| } |
| |
| if($LRelPath=~/\/debug\//) |
| { # debug libs |
| $Skipped{$LRelPath} = 1; |
| next; |
| } |
| $TotalLibs{$LRelPath} = 1; |
| $SysLib_SysHeaders{$LRelPath} = (); |
| |
| my (%SymbolDirs, %SymbolFiles) = (); |
| |
| foreach my $Symbol (sort {length($b) cmp length($a)} |
| sort keys(%{$SysLib_Symbols{$LPath}})) |
| { |
| if($SysCInfo->{"ignore_symbols"}{$Symbol}) { |
| next; |
| } |
| if(not $DupLibs{$LPath} |
| and not $VersionedLibs{$LPath} |
| and keys(%{$SymbolCounter{$Symbol}})>=2 |
| and my $Prefix = getPrefix_S($Symbol)) |
| { # duplicated symbols |
| if($PrefixToLib{$Prefix} |
| and $PrefixToLib{$Prefix} ne $LName |
| and not $Glibc{$LSName}) { |
| next; |
| } |
| } |
| if(length($Symbol)<=2) { |
| next; |
| } |
| if($Symbol!~/[A-Z_0-9]/ |
| and length($Symbol)<10 |
| and keys(%{$Symbol_SysHeaders{$Symbol}})>=3) |
| { # undistinguished symbols |
| # FIXME: improve this filter |
| # signalfd (libc.so) |
| # regcomp (libpcreposix.so) |
| next; |
| } |
| if($Symbol=~/\A(_M_|_Rb_|_S_)/) |
| { # _M_insert, _Rb_tree, _S_destroy_c_locale |
| next; |
| } |
| if($Symbol=~/\A[A-Z][a-z]+\Z/) |
| { # Clone, Initialize, Skip, Unlock, Terminate, Chunk |
| next; |
| } |
| if($Symbol=~/\A[A-Z][A-Z]\Z/) |
| { # BC, PC, UP, SP |
| next; |
| } |
| if($Symbol=~/_t\Z/) |
| { # pthread_mutex_t, wchar_t |
| next; |
| } |
| my @SymHeaders = keys(%{$Symbol_SysHeaders{$Symbol}}); |
| @SymHeaders = sort {lc($a) cmp lc($b)} @SymHeaders; # sort by name |
| @SymHeaders = sort {length(get_dirname($a))<=>length(get_dirname($b))} @SymHeaders; # sort by length |
| if(length($SName)>=3) |
| { # sort candidate headers by name |
| @SymHeaders = sort {$b=~/\Q$SName\E/i<=>$a=~/\Q$SName\E/i} @SymHeaders; |
| } |
| else |
| { # libz, libX11 |
| @SymHeaders = sort {$b=~/lib\Q$SName\E/i<=>$a=~/lib\Q$SName\E/i} @SymHeaders; |
| @SymHeaders = sort {$b=~/\Q$SName\Elib/i<=>$a=~/\Q$SName\Elib/i} @SymHeaders; |
| } |
| @SymHeaders = sort {$b=~/\Q$LSName\E/i<=>$a=~/\Q$LSName\E/i} @SymHeaders; |
| @SymHeaders = sort {$SymbolDirs{get_dirname($b)}<=>$SymbolDirs{get_dirname($a)}} @SymHeaders; |
| @SymHeaders = sort {$SymbolFiles{get_filename($b)}<=>$SymbolFiles{get_filename($a)}} @SymHeaders; |
| foreach my $HRelPath (@SymHeaders) |
| { |
| my $HDir = get_dirname($HRelPath); |
| my $HName = get_filename($HRelPath); |
| |
| if(my $Group = $SymbolGroup{$LRelPath}{$Symbol}) |
| { |
| if(not $SysHeader_Symbols{$HRelPath}{$Group}) { |
| next; |
| } |
| } |
| my $Filter = 0; |
| foreach (@TryNames) |
| { |
| if(my $Filt = $SysInfo->{$_}{"headers"}) |
| { # search for specified headers |
| if(not check_list($HRelPath, $Filt)) |
| { |
| $Filter = 1; |
| last; |
| } |
| } |
| if(my $Filt = $SysInfo->{$_}{"skip_headers"}) |
| { # do NOT search for some headers |
| if(check_list($HRelPath, $Filt)) |
| { |
| $Filter = 1; |
| last; |
| } |
| } |
| if(my $Filt = $SysInfo->{$_}{"skip_including"}) |
| { # do NOT search for some headers |
| if(check_list($HRelPath, $Filt)) |
| { |
| $SymbolDirs{$HDir}+=1; |
| $SymbolFiles{$HName}+=1; |
| $Filter = 1; |
| last; |
| } |
| } |
| } |
| if($Filter) { |
| next; |
| } |
| if(my $Filt = $SysCInfo->{"skip_headers"}) |
| { # do NOT search for some headers |
| if(check_list($HRelPath, $Filt)) { |
| next; |
| } |
| } |
| if(my $Filt = $SysCInfo->{"skip_including"}) |
| { # do NOT search for some headers |
| if(check_list($HRelPath, $Filt)) { |
| next; |
| } |
| } |
| |
| if(defined $LibraryFile{$LRelPath}) |
| { # skip wrongly matched headers |
| if(not defined $LibraryFile{$LRelPath}{$HRelPath}) |
| { print "WRONG: $LRelPath $HRelPath\n"; |
| # next; |
| } |
| } |
| |
| $SysLib_SysHeaders{$LRelPath}{$HRelPath} = $Symbol; |
| |
| $SysHeaderDir_Used{$HDir}{$LName_Short} = 1; |
| $SysHeaderDir_Used{get_dirname($HDir)}{$LName_Short} = 1; |
| |
| $SymbolDirs{$HDir} += 1; |
| $SymbolFiles{$HName} +=1 ; |
| |
| # select one header for one symbol |
| last; |
| } |
| } |
| |
| if(keys(%{$SysLib_Symbols{$LPath}}) |
| and not $SysInfo->{$_}{"headers"}) |
| { # try to match by name of the header |
| if(length($SName)>=3) |
| { |
| my @Paths = (); |
| foreach my $Path (keys(%{$HeaderFile_Path{$SName.".h"}}), keys(%{$HeaderFile_Path{$LSName.".h"}})) |
| { |
| my $Dir = get_dirname($Path); |
| if(defined $SymbolDirs{$Dir} or $Dir eq "/usr/include") { |
| push(@Paths, $Path); |
| } |
| } |
| if($#Paths==0) |
| { |
| my $Path = $Paths[0]; |
| if(not defined $SysLib_SysHeaders{$LRelPath}{$Path}) { |
| $SysLib_SysHeaders{$LRelPath}{$Path} = "by name ($LSName)"; |
| } |
| } |
| } |
| } |
| |
| if(not keys(%{$SysLib_SysHeaders{$LRelPath}})) |
| { |
| foreach (@TryNames) |
| { |
| if(my $List = $SysInfo->{$_}{"headers"}) |
| { |
| foreach my $HName (@{$List}) |
| { |
| next if($HName=~/[\*\/\\]/); |
| if(my $HPath = selectSystemHeader($HName, 1)) |
| { |
| my $HRelPath = cut_path_prefix($HPath, $SystemRoot); |
| $SysLib_SysHeaders{$LRelPath}{$HRelPath} = "by descriptor"; |
| } |
| } |
| } |
| } |
| } |
| |
| if(not keys(%{$SysLib_SysHeaders{$LRelPath}})) { |
| $Failed{$LRelPath} = 1; |
| } |
| } |
| |
| if(not $GroupByHeaders) |
| { # matching results |
| writeFile($SYS_DUMP_PATH."/debug/match.txt", Dumper(\%SysLib_SysHeaders)); |
| writeFile($SYS_DUMP_PATH."/debug/skipped.txt", join("\n", sort keys(%Skipped))); |
| writeFile($SYS_DUMP_PATH."/debug/failed.txt", join("\n", sort keys(%Failed))); |
| } |
| (%SysLib_Symbols, %SymbolGroup, %Symbol_SysHeaders, %SysHeader_Symbols) = (); # free memory |
| if($GroupByHeaders) |
| { |
| if($SysDescriptor{"Image"} and not $CheckHeadersOnly) { |
| @SysHeaders = keys(%{$SysLib_SysHeaders{$SysDescriptor{"Image"}}}); |
| } |
| %SysLib_SysHeaders = (); |
| foreach my $Path (@SysHeaders) |
| { |
| if(my $Skip = $SysCInfo->{"skip_headers"}) |
| { # do NOT search for some headers |
| if(check_list($Path, $Skip)) { |
| next; |
| } |
| } |
| if(my $Skip = $SysCInfo->{"skip_including"}) |
| { # do NOT search for some headers |
| if(check_list($Path, $Skip)) { |
| next; |
| } |
| } |
| $SysLib_SysHeaders{$Path}{$Path} = 1; |
| } |
| if($CheckHeadersOnly) { |
| writeFile($SYS_DUMP_PATH."/mode.txt", "headers-only"); |
| } |
| else { |
| writeFile($SYS_DUMP_PATH."/mode.txt", "group-by-headers"); |
| } |
| } |
| @SysHeaders = (); # clear memory |
| |
| if($Debug) { |
| printMsg("INFO", localtime(time)); |
| } |
| printMsg("INFO", "Generating XML descriptors ..."); |
| my %Generated = (); |
| my %CxxIncompat_L = (); |
| foreach my $LRelPath (keys(%SysLib_SysHeaders)) |
| { |
| my $LName = get_filename($LRelPath); |
| my $DPath = $SYS_DUMP_PATH."/descriptors/$LName.xml"; |
| unlink($DPath); |
| if(my @LibHeaders = keys(%{$SysLib_SysHeaders{$LRelPath}})) |
| { |
| my $LSName = parse_libname($LName, "short", $OStarget); |
| my $LName_Short = parse_libname($LName, "name", $OStarget); |
| my $LName_Shortest = parse_libname($LName, "shortest", $OStarget); |
| if($GroupByHeaders) |
| { # header short name |
| $LSName = $LName; |
| $LSName=~s/\.(.+?)\Z//; |
| } |
| |
| my (%DirsHeaders, %Includes, %MainDirs) = (); |
| foreach my $HRelPath (@LibHeaders) |
| { |
| my $Dir = get_dirname($HRelPath); |
| $DirsHeaders{$Dir}{$HRelPath} = 1; |
| |
| if($Dir=~/\/\Q$LName_Shortest\E(\/|\Z)/i |
| or $Dir=~/\/\Q$LName_Short\E(\/|\Z)/i) |
| { |
| if(get_filename($Dir) ne "include") |
| { # except /usr/include |
| $MainDirs{$Dir} += 1; |
| } |
| } |
| } |
| |
| if($#LibHeaders==0) |
| { # one header at all |
| $Includes{$LibHeaders[0]} = 1; |
| } |
| else |
| { |
| foreach my $Dir (keys(%DirsHeaders)) |
| { |
| if(keys(%MainDirs) and not defined $MainDirs{$Dir}) |
| { # search in /X/ dir for libX headers |
| if(get_filename($Dir) ne "include") |
| { # except /usr/include |
| next; |
| } |
| } |
| my $DirPart = 0; |
| my $TotalHeaders = keys(%{$SysHeaderDir_SysHeaders{$Dir}}); |
| if($TotalHeaders) { |
| $DirPart = (keys(%{$DirsHeaders{$Dir}})*100)/$TotalHeaders; |
| } |
| my $Neighbourhoods = keys(%{$SysHeaderDir_Used{$Dir}}); |
| if($Neighbourhoods==1) |
| { # one lib in this directory |
| if(get_filename($Dir) ne "include" |
| and $DirPart>=5) |
| { # complete directory |
| $Includes{$Dir} = 1; |
| } |
| else |
| { # list of headers |
| foreach (keys(%{$DirsHeaders{$Dir}})) { |
| $Includes{$_} = 1; |
| } |
| } |
| } |
| elsif((keys(%{$DirsHeaders{$Dir}})*100)/($#LibHeaders+1)>5) |
| { # remove 5% divergence |
| if(get_filename($Dir) ne "include" |
| and $DirPart>=50) |
| { # complete directory if more than 50% |
| $Includes{$Dir} = 1; |
| } |
| else |
| { # list of headers |
| foreach (keys(%{$DirsHeaders{$Dir}})) { |
| $Includes{$_} = 1; |
| } |
| } |
| } |
| else |
| { # noise |
| foreach (keys(%{$DirsHeaders{$Dir}})) |
| { # NOTE: /usr/include/libX.h |
| if(/\Q$LName_Shortest\E/i) { |
| $Includes{$_} = 1; |
| } |
| } |
| } |
| } |
| } |
| if($GroupByHeaders) |
| { # one header in one ABI dump |
| %Includes = ($LibHeaders[0] => 1); |
| } |
| my $LVersion = $SysLibVersion{$LName}; |
| if($LVersion) |
| { # append by system name |
| $LVersion .= "-".$SysDescriptor{"Name"}; |
| } |
| else { |
| $LVersion = $SysDescriptor{"Name"}; |
| } |
| my @Content = ("<version>\n $LVersion\n</version>"); |
| |
| my @IncHeaders = sort keys(%Includes); |
| |
| # sort files up |
| @IncHeaders = sort {$b=~/\.h\Z/<=>$a=~/\.h\Z/} @IncHeaders; |
| |
| # sort by name |
| @IncHeaders = sort {sortHeaders($a, $b)} @IncHeaders; |
| |
| # sort by library name |
| sortByWord(\@IncHeaders, parse_libname($LName, "shortest", $OStarget)); |
| |
| if(is_abs($IncHeaders[0]) or -f $IncHeaders[0]) { |
| push(@Content, "<headers>\n ".join("\n ", @IncHeaders)."\n</headers>"); |
| } |
| else { |
| push(@Content, "<headers>\n {RELPATH}/".join("\n {RELPATH}/", @IncHeaders)."\n</headers>"); |
| } |
| if($GroupByHeaders) |
| { |
| if($SysDescriptor{"Image"}) { |
| push(@Content, "<libs>\n ".$SysDescriptor{"Image"}."\n</libs>"); |
| } |
| } |
| else |
| { |
| if(is_abs($LRelPath) or -f $LRelPath) { |
| push(@Content, "<libs>\n $LRelPath\n</libs>"); |
| } |
| else { |
| push(@Content, "<libs>\n {RELPATH}/$LRelPath\n</libs>"); |
| } |
| } |
| |
| # system |
| if(my @SearchHeaders = sort keys(%{$SysDescriptor{"SearchHeaders"}})) { |
| push(@Content, "<search_headers>\n ".join("\n ", @SearchHeaders)."\n</search_headers>"); |
| } |
| if(my @SearchLibs = sort keys(%{$SysDescriptor{"SearchLibs"}})) { |
| push(@Content, "<search_libs>\n ".join("\n ", @SearchLibs)."\n</search_libs>"); |
| } |
| if(my @Tools = sort keys(%{$SysDescriptor{"Tools"}})) { |
| push(@Content, "<tools>\n ".join("\n ", @Tools)."\n</tools>"); |
| } |
| if(my $Prefix = $SysDescriptor{"CrossPrefix"}) { |
| push(@Content, "<cross_prefix>\n $Prefix\n</cross_prefix>"); |
| } |
| |
| # library |
| my (@Skip, @SkipInc, @AddIncPath, @SkipIncPath, |
| @SkipTypes, @SkipSymb, @Preamble, @Defines, @CompilerOpts) = (); |
| |
| my @TryNames = (); |
| if(my $Ver = $SysLibVersion{$LName}) |
| { |
| if($LSName."-".$Ver ne $LName_Short) { |
| push(@TryNames, $LName_Short."-".$Ver); |
| } |
| } |
| push(@TryNames, $LName_Short); |
| if($LSName ne $LName_Short) { |
| push(@TryNames, $LSName); |
| } |
| |
| # common |
| if(my $List = $SysCInfo->{"include_preamble"}) { |
| push(@Preamble, @{$List}); |
| } |
| if(my $List = $SysCInfo->{"skip_headers"}) { |
| @Skip = (@Skip, @{$List}); |
| } |
| if(my $List = $SysCInfo->{"skip_including"}) { |
| @SkipInc = (@SkipInc, @{$List}); |
| } |
| if(my $List = $SysCInfo->{"skip_symbols"}) { |
| push(@SkipSymb, @{$List}); |
| } |
| if(my $List = $SysCInfo->{"gcc_options"}) { |
| push(@CompilerOpts, @{$List}); |
| } |
| if($SysCInfo->{"defines"}) { |
| push(@Defines, $SysCInfo->{"defines"}); |
| } |
| |
| # particular |
| foreach (@TryNames) |
| { |
| if(my $List = $SysInfo->{$_}{"include_preamble"}) { |
| push(@Preamble, @{$List}); |
| } |
| if(my $List = $SysInfo->{$_}{"skip_headers"}) { |
| @Skip = (@Skip, @{$List}); |
| } |
| if(my $List = $SysInfo->{$_}{"skip_including"}) { |
| @SkipInc = (@SkipInc, @{$List}); |
| } |
| if(my $List = $SysInfo->{$_}{"add_include_paths"}) { |
| @AddIncPath = (@AddIncPath, @{$List}); |
| } |
| if(my $List = $SysInfo->{$_}{"skip_include_paths"}) { |
| @SkipIncPath = (@SkipIncPath, @{$List}); |
| } |
| if(my $List = $SysInfo->{$_}{"skip_symbols"}) { |
| push(@SkipSymb, @{$List}); |
| } |
| if(my $List = $SysInfo->{$_}{"skip_types"}) { |
| @SkipTypes = (@SkipTypes, @{$List}); |
| } |
| if(my $List = $SysInfo->{$_}{"gcc_options"}) { |
| push(@CompilerOpts, @{$List}); |
| } |
| if(my $List = $SysInfo->{$_}{"defines"}) { |
| push(@Defines, $List); |
| } |
| if($SysInfo->{$_}{"cxx_incompatible"}) { |
| $CxxIncompat_L{$LName} = 1; |
| } |
| } |
| |
| # common other |
| if($LSName=~/\AlibX\w+\Z/) |
| { # add Xlib.h for libXt, libXaw, libXext and others |
| push(@Preamble, "Xlib.h", "X11/Intrinsic.h"); |
| } |
| if($SkipDHeaders{$LSName}) { |
| @SkipInc = (@SkipInc, @{$SkipDHeaders{$LSName}}); |
| } |
| if($SysDescriptor{"Defines"}) { |
| push(@Defines, $SysDescriptor{"Defines"}); |
| } |
| |
| # add sections |
| if(@Preamble) { |
| push(@Content, "<include_preamble>\n ".join("\n ", @Preamble)."\n</include_preamble>"); |
| } |
| if(@Skip) { |
| push(@Content, "<skip_headers>\n ".join("\n ", @Skip)."\n</skip_headers>"); |
| } |
| if(@SkipInc) { |
| push(@Content, "<skip_including>\n ".join("\n ", @SkipInc)."\n</skip_including>"); |
| } |
| if(@AddIncPath) { |
| push(@Content, "<add_include_paths>\n ".join("\n ", @AddIncPath)."\n</add_include_paths>"); |
| } |
| if(@SkipIncPath) { |
| push(@Content, "<skip_include_paths>\n ".join("\n ", @SkipIncPath)."\n</skip_include_paths>"); |
| } |
| if(@SkipSymb) { |
| push(@Content, "<skip_symbols>\n ".join("\n ", @SkipSymb)."\n</skip_symbols>"); |
| } |
| if(@SkipTypes) { |
| push(@Content, "<skip_types>\n ".join("\n ", @SkipTypes)."\n</skip_types>"); |
| } |
| if(@CompilerOpts) { |
| push(@Content, "<gcc_options>\n ".join("\n ", @CompilerOpts)."\n</gcc_options>"); |
| } |
| if(@Defines) { |
| push(@Content, "<defines>\n ".join("\n ", @Defines)."\n</defines>"); |
| } |
| |
| writeFile($DPath, join("\n\n", @Content)); |
| $Generated{$LRelPath} = 1; |
| |
| # save header files to create visual diff later |
| my $HSDir = $SYS_DUMP_PATH."/headers/".$LName; |
| rmtree($HSDir); |
| mkpath($HSDir); |
| foreach my $H_P (@IncHeaders) |
| { |
| if(-f $H_P) { |
| copy($H_P, $HSDir); |
| } |
| } |
| } |
| } |
| printMsg("INFO", "Created descriptors: ".keys(%Generated)." ($SYS_DUMP_PATH/descriptors/)\n"); |
| |
| if($Debug) { |
| printMsg("INFO", localtime(time)); |
| } |
| printMsg("INFO", "Dumping ABIs:"); |
| my %Dumped = (); |
| my @Descriptors = cmd_find($SYS_DUMP_PATH."/descriptors","f","*.xml","1"); |
| if(-d $SYS_DUMP_PATH."/descriptors" and $#Descriptors==-1) { |
| printMsg("ERROR", "internal problem with \'find\' utility"); |
| } |
| foreach my $DPath (sort {lc($a) cmp lc($b)} @Descriptors) |
| { |
| my $DName = get_filename($DPath); |
| my $LName = ""; |
| if($DName=~/\A(.+).xml\Z/) { |
| $LName = $1; |
| } |
| else { |
| next; |
| } |
| if(not is_target_lib($LName) |
| and not is_target_lib($LibSoname{$LName})) { |
| next; |
| } |
| $DPath = cut_path_prefix($DPath, $ORIG_DIR); |
| my $ACC_dump = "perl $0"; |
| if($GroupByHeaders) |
| { # header name is going here |
| $ACC_dump .= " -l $LName"; |
| } |
| else { |
| $ACC_dump .= " -l ".parse_libname($LName, "name", $OStarget); |
| } |
| $ACC_dump .= " -dump \"$DPath\""; |
| if($SystemRoot) |
| { |
| $ACC_dump .= " -relpath \"$SystemRoot\""; |
| $ACC_dump .= " -sysroot \"$SystemRoot\""; |
| } |
| my $DumpPath = "$SYS_DUMP_PATH/abi_dumps/$LName.abi"; |
| $ACC_dump .= " -dump-path \"$DumpPath\""; |
| my $LogPath = "$SYS_DUMP_PATH/logs/$LName.txt"; |
| unlink($LogPath); |
| $ACC_dump .= " -log-path \"$LogPath\""; |
| if($CrossGcc) { |
| $ACC_dump .= " -cross-gcc \"$CrossGcc\""; |
| } |
| if($CheckHeadersOnly) { |
| $ACC_dump .= " -headers-only"; |
| } |
| if($UseStaticLibs) { |
| $ACC_dump .= " -static-libs"; |
| } |
| if($GroupByHeaders) { |
| $ACC_dump .= " -header $LName"; |
| } |
| if($NoStdInc |
| or $OStarget=~/windows|symbian/) |
| { # 1. user-defined |
| # 2. windows/minGW |
| # 3. symbian/GCC |
| $ACC_dump .= " -nostdinc"; |
| } |
| if($CxxIncompat or $CxxIncompat_L{$LName}) { |
| $ACC_dump .= " -cxx-incompatible"; |
| } |
| if($SkipUnidentified) { |
| $ACC_dump .= " -skip-unidentified"; |
| } |
| if($Quiet) |
| { # quiet mode |
| $ACC_dump .= " -quiet"; |
| } |
| if($LogMode eq "n") { |
| $ACC_dump .= " -logging-mode n"; |
| } |
| elsif($Quiet) { |
| $ACC_dump .= " -logging-mode a"; |
| } |
| if($Debug) |
| { # debug mode |
| $ACC_dump .= " -debug"; |
| printMsg("INFO", "$ACC_dump"); |
| } |
| printMsg("INFO_C", "Dumping $LName: "); |
| system($ACC_dump." 1>$TMP_DIR/null 2>$TMP_DIR/$LName.stderr"); |
| my $ErrCode = $?; |
| appendFile("$SYS_DUMP_PATH/logs/$LName.txt", "The ACC parameters:\n $ACC_dump\n"); |
| my $ErrCont = readFile("$TMP_DIR/$LName.stderr"); |
| if($ErrCont) { |
| appendFile("$SYS_DUMP_PATH/logs/$LName.txt", $ErrCont); |
| } |
| |
| if(filterError($ErrCont)) |
| { |
| if(get_CodeError($ErrCode>>8) eq "Invalid_Dump") { |
| printMsg("INFO", "Empty"); |
| } |
| else { |
| printMsg("INFO", "Errors (\'$SYS_DUMP_PATH/logs/$LName.txt\')"); |
| } |
| } |
| elsif(not -f $DumpPath) { |
| printMsg("INFO", "Failed (\'$SYS_DUMP_PATH/logs/$LName.txt\')"); |
| } |
| else |
| { |
| $Dumped{$LName}=1; |
| printMsg("INFO", "Ok"); |
| } |
| } |
| printMsg("INFO", "\n"); |
| if(not $GroupByHeaders) |
| { # general mode |
| printMsg("INFO", "Total libraries: ".keys(%TotalLibs)); |
| printMsg("INFO", "Skipped libraries: ".keys(%Skipped)." ($SYS_DUMP_PATH/skipped.txt)"); |
| printMsg("INFO", "Failed to find headers: ".keys(%Failed)." ($SYS_DUMP_PATH/failed.txt)"); |
| } |
| printMsg("INFO", "Dumped ABIs: ".keys(%Dumped)." ($SYS_DUMP_PATH/abi_dumps/)"); |
| printMsg("INFO", "The ".$SysDescriptor{"Name"}." system ABI has been dumped to:\n $SYS_DUMP_PATH"); |
| } |
| |
| sub filterError($) |
| { |
| my $Error = $_[0]; |
| |
| if(not $Error) { |
| return undef; |
| } |
| |
| my @Err = (); |
| foreach my $L (split(/\n/, $Error)) |
| { |
| if($L!~/warning:/) { |
| push(@Err, $L); |
| } |
| } |
| |
| return join("\n", @Err); |
| } |
| |
| return 1; |
