ABI Compliance Checker 1.98.2

3 files changed, 458 insertions, 38 deletions

diff --git a/modules/Internals/RegTests.pm b/modules/Internals/RegTests.pm
index c5fe7cd..48ef2e0 100644
--- a/modules/Internals/RegTests.pm
+++ b/modules/Internals/RegTests.pm
@@ -24,13 +24,14 @@
 use strict;
 
 my ($TestDump, $Debug, $Quiet, $ExtendedCheck, $LogMode, $ReportFormat,
-$LIB_EXT, $GCC_PATH, $Browse, $OpenReport, $SortDump);
+$DumpFormat, $LIB_EXT, $GCC_PATH, $Browse, $OpenReport, $SortDump);
 my $OSgroup = get_OSgroup();
 
 sub testTool($$$$$$$$$$$)
 {
     ($TestDump, $Debug, $Quiet, $ExtendedCheck, $LogMode, $ReportFormat,
-    $LIB_EXT, $GCC_PATH, $Browse, $OpenReport, $SortDump) = @_;
+    $DumpFormat, $LIB_EXT, $GCC_PATH, $Browse, $OpenReport, $SortDump) = @_;
+    
     testC();
     testCpp();
 }
@@ -4241,6 +4242,10 @@ sub runTests($$$$$$$$)
             @Cmd = (@Cmd, "-sort");
         }
     }
+    if($DumpFormat and $DumpFormat ne "perl")
+    { # Perl Data::Dumper is default format
+        @Cmd = (@Cmd, "-dump-format", $DumpFormat);
+    }
     if($GCC_PATH ne "gcc") {
         @Cmd = (@Cmd, "-cross-gcc", $GCC_PATH);
     }
diff --git a/modules/Internals/SysCheck.pm b/modules/Internals/SysCheck.pm
index d5c8ffd..5c6f873 100644
--- a/modules/Internals/SysCheck.pm
+++ b/modules/Internals/SysCheck.pm
@@ -720,6 +720,7 @@ sub read_sys_descriptor($)
         "headers" => "mf",
         "skip_headers" => "mf",
         "skip_including" => "mf",
+        "skip_include_paths" => "mf",
         "skip_libs" => "mf",
         "include_preamble" => "mf",
         "non_self_compiled" => "mf",
@@ -1476,7 +1477,7 @@ sub dumpSystem($)
             writeFile($SYS_DUMP_PATH."/mode.txt", "group-by-headers");
         }
     }
-    @SysHeaders = ();# clear memory
+    @SysHeaders = (); # clear memory
     (%Skipped, %Failed, %Success) = ();
     printMsg("INFO", "Generating XML descriptors ...");
     foreach my $LRelPath (keys(%SysLib_SysHeaders))
@@ -1487,6 +1488,7 @@ sub dumpSystem($)
         if(my @LibHeaders = keys(%{$SysLib_SysHeaders{$LRelPath}}))
         {
             my $LSName = parse_libname($LName, "short", $OStarget);
+            my $SName = parse_libname($LName, "shortest", $OStarget);
             if($GroupByHeaders)
             { # header short name
                 $LSName = $LName;
@@ -1496,36 +1498,43 @@ sub dumpSystem($)
             foreach my $HRelPath (@LibHeaders) {
                 $DirsHeaders{get_dirname($HRelPath)}{$HRelPath}=1;
             }
-            foreach my $Dir (keys(%DirsHeaders))
+            if($#LibHeaders==0)
+            { # one header at all
+                $Includes{$LibHeaders[0]} = 1;
+            }
+            else
             {
-                my $DirPart = 0;
-                my $TotalHeaders = keys(%{$SysHeaderDir_SysHeaders{$Dir}});
-                if($TotalHeaders) {
-                    $DirPart = (keys(%{$DirsHeaders{$Dir}})*100)/$TotalHeaders;
-                }
-                my $Neighbourhoods = keys(%{$SysHeaderDir_SysLibs{$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
-                        @Includes{keys(%{$DirsHeaders{$Dir}})}=values(%{$DirsHeaders{$Dir}});
+                foreach my $Dir (keys(%DirsHeaders))
+                {
+                    my $DirPart = 0;
+                    my $TotalHeaders = keys(%{$SysHeaderDir_SysHeaders{$Dir}});
+                    if($TotalHeaders) {
+                        $DirPart = (keys(%{$DirsHeaders{$Dir}})*100)/$TotalHeaders;
                     }
-                }
-                elsif((keys(%{$DirsHeaders{$Dir}})*100)/($#LibHeaders+1)>5)
-                {# remove 5% divergence
-                    if(get_filename($Dir) ne "include"
-                    and $DirPart>=50)
-                    { # complete directory
-                        $Includes{$Dir} = 1;
+                    my $Neighbourhoods = keys(%{$SysHeaderDir_SysLibs{$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
+                            @Includes{keys(%{$DirsHeaders{$Dir}})}=values(%{$DirsHeaders{$Dir}});
+                        }
                     }
-                    else
-                    { # list of headers
-                        @Includes{keys(%{$DirsHeaders{$Dir}})}=values(%{$DirsHeaders{$Dir}});
+                    elsif((keys(%{$DirsHeaders{$Dir}})*100)/($#LibHeaders+1)>5)
+                    { # remove 5% divergence
+                        if(get_filename($Dir) ne "include"
+                        and $DirPart>=50)
+                        { # complete directory
+                            $Includes{$Dir} = 1;
+                        }
+                        else
+                        { # list of headers
+                            @Includes{keys(%{$DirsHeaders{$Dir}})}=values(%{$DirsHeaders{$Dir}});
+                        }
                     }
                 }
             }
@@ -1535,7 +1544,7 @@ sub dumpSystem($)
             }
             my $LVersion = $SysLibVersion{$LName};
             if($LVersion)
-            {# append by system name
+            { # append by system name
                 $LVersion .= "-".$SysDescriptor{"Name"};
             }
             else {
@@ -1603,6 +1612,9 @@ sub dumpSystem($)
             if($SysInfo->{$LSName}{"add_include_paths"}) {
                 push(@Content, "<add_include_paths>\n    ".join("\n    ", @{$SysInfo->{$LSName}{"add_include_paths"}})."\n</add_include_paths>");
             }
+            if($SysInfo->{$LSName}{"skip_include_paths"}) {
+                push(@Content, "<skip_include_paths>\n    ".join("\n    ", @{$SysInfo->{$LSName}{"skip_include_paths"}})."\n</skip_include_paths>");
+            }
             if($SysInfo->{$LSName}{"skip_types"}) {
                 push(@Content, "<skip_types>\n    ".join("\n    ", @{$SysInfo->{$LSName}{"skip_types"}})."\n</skip_types>");
             }
diff --git a/modules/Internals/XmlDump.pm b/modules/Internals/XmlDump.pm
index 3d243ae..4fa84af 100644
--- a/modules/Internals/XmlDump.pm
+++ b/modules/Internals/XmlDump.pm
@@ -101,6 +101,9 @@ sub createXmlDump($)
                     if(my $MTid = $TInfo{"Memb"}{$Pos}{"type"}) {
                         $ABI_DUMP .= addTag("type", $MTid);
                     }
+                    if(my $Access = $TInfo{"Memb"}{$Pos}{"access"}) {
+                        $ABI_DUMP .= addTag("access", $Access);
+                    }
                     my $Val = $TInfo{"Memb"}{$Pos}{"value"};
                     if(defined $Val) {
                         $ABI_DUMP .= addTag("value", $Val);
@@ -108,11 +111,31 @@ sub createXmlDump($)
                     if(my $Align = $TInfo{"Memb"}{$Pos}{"algn"}) {
                         $ABI_DUMP .= addTag("algn", $Align);
                     }
+                    if(my $Bitfield = $TInfo{"Memb"}{$Pos}{"bitfield"}) {
+                        $ABI_DUMP .= addTag("bitfield", $Bitfield);
+                    }
+                    if($TInfo{"Memb"}{$Pos}{"mutable"}) {
+                        $ABI_DUMP .= addTag("spec", "mutable");
+                    }
                     $ABI_DUMP .= addTag("pos", $Pos);
                     $ABI_DUMP .= closeTag("field");
                 }
                 $ABI_DUMP .= closeTag("members");
             }
+            if(my @Positions = keys(%{$TInfo{"Param"}}))
+            {
+                $ABI_DUMP .= openTag("parameters");
+                foreach my $Pos (sort { $a<=>$b } @Positions)
+                {
+                    $ABI_DUMP .= openTag("param");
+                    if(my $PTid = $TInfo{"Param"}{$Pos}{"type"}) {
+                        $ABI_DUMP .= addTag("type", $PTid);
+                    }
+                    $ABI_DUMP .= addTag("pos", $Pos);
+                    $ABI_DUMP .= closeTag("param");
+                }
+                $ABI_DUMP .= closeTag("parameters");
+            }
             if(my @Positions = keys(%{$TInfo{"TParam"}}))
             {
                 $ABI_DUMP .= openTag("template_parameters");
@@ -160,7 +183,10 @@ sub createXmlDump($)
                 $ABI_DUMP .= closeTag("base");
             }
             if($TInfo{"Copied"}) {
-                $ABI_DUMP .= addTag("kind", "copied");
+                $ABI_DUMP .= addTag("note", "copied");
+            }
+            if($TInfo{"Spec"}) {
+                $ABI_DUMP .= addTag("note", "specialization");
             }
             $ABI_DUMP .= closeTag("data_type");
         }
@@ -195,7 +221,7 @@ sub createXmlDump($)
             $ABI_DUMP .= openTag("symbol");
             $ABI_DUMP .= addTag("id", $ID);
             foreach my $Attr ("MnglName", "ShortName", "Class",
-            "Header", "Line", "Return")
+            "Header", "Line", "Return", "NameSpace", "Value")
             {
                 if(defined $SInfo{$Attr})
                 {
@@ -212,6 +238,9 @@ sub createXmlDump($)
             if($SInfo{"Destructor"}) {
                 $ABI_DUMP .= addTag("kind", "destructor");
             }
+            if($SInfo{"Data"}) {
+                $ABI_DUMP .= addTag("kind", "data");
+            }
             if($SInfo{"Virt"}) {
                 $ABI_DUMP .= addTag("spec", "virtual");
             }
@@ -227,6 +256,9 @@ sub createXmlDump($)
             if($SInfo{"Const"}) {
                 $ABI_DUMP .= addTag("spec", "const");
             }
+            if($SInfo{"Volatile"}) {
+                $ABI_DUMP .= addTag("spec", "volatile");
+            }
             if($SInfo{"Private"}) {
                 $ABI_DUMP .= addTag("access", "private");
             }
@@ -245,16 +277,22 @@ sub createXmlDump($)
                 foreach my $Pos (sort { $a<=>$b } @Positions)
                 {
                     $ABI_DUMP .= openTag("param");
-                    $ABI_DUMP .= addTag("name", $SInfo{"Param"}{$Pos}{"name"});
-                    if(my $MTid = $SInfo{"Param"}{$Pos}{"type"}) {
-                        $ABI_DUMP .= addTag("type", $MTid);
+                    if(my $PName = $SInfo{"Param"}{$Pos}{"name"}) {
+                        $ABI_DUMP .= addTag("name", $PName);
+                    }
+                    if(my $PTid = $SInfo{"Param"}{$Pos}{"type"}) {
+                        $ABI_DUMP .= addTag("type", $PTid);
                     }
-                    if(my $Default = $SInfo{"Param"}{$Pos}{"default"}) {
+                    my $Default = $SInfo{"Param"}{$Pos}{"default"};
+                    if(defined $Default) {
                         $ABI_DUMP .= addTag("default", $Default);
                     }
                     if(my $Align = $SInfo{"Param"}{$Pos}{"algn"}) {
                         $ABI_DUMP .= addTag("algn", $Align);
                     }
+                    if(defined $SInfo{"Param"}{$Pos}{"reg"}) {
+                        $ABI_DUMP .= addTag("call", "register");
+                    }
                     $ABI_DUMP .= addTag("pos", $Pos);
                     $ABI_DUMP .= closeTag("param");
                 }
@@ -306,7 +344,14 @@ sub createXmlDump($)
             $ABI_DUMP .= openTag("library", "name", $Lib);
             foreach my $Symbol (sort {lc($a) cmp lc($b)} keys(%{$ABI->{"DepSymbols"}{$Lib}}))
             {
-                $ABI_DUMP .= addTag("symbol", $Symbol);
+                if((my $Size = $ABI->{"DepSymbols"}{$Lib}{$Symbol})<0)
+                { # data
+                    $ABI_DUMP .= addTag("symbol", $Symbol, "size", -$Size);
+                }
+                else
+                { # functions
+                    $ABI_DUMP .= addTag("symbol", $Symbol);
+                }
             }
             $ABI_DUMP .= closeTag("library");
         }
@@ -378,4 +423,362 @@ sub createXmlDump($)
     return $ABI_DUMP;
 }
 
+sub readXmlDump($)
+{
+    my $ABI_DUMP = readFile($_[0]);
+    my %ABI = {};
+    
+    $ABI{"LibraryName"} = parseTag(\$ABI_DUMP, "library");
+    $ABI{"LibraryVersion"} = parseTag(\$ABI_DUMP, "library_version");
+    $ABI{"Language"} = parseTag(\$ABI_DUMP, "language");
+    $ABI{"GccVersion"} = parseTag(\$ABI_DUMP, "gcc");
+    $ABI{"Arch"} = parseTag(\$ABI_DUMP, "architecture");
+    $ABI{"Target"} = parseTag(\$ABI_DUMP, "target");
+    $ABI{"WordSize"} = parseTag(\$ABI_DUMP, "word_size");
+    
+    my $Pos = 0;
+    
+    if(my $Headers = parseTag(\$ABI_DUMP, "headers"))
+    {
+        while(my $Name = parseTag(\$Headers, "name")) {
+            $ABI{"Headers"}{$Name} = $Pos++;
+        }
+    }
+    
+    if(my $NameSpaces = parseTag(\$ABI_DUMP, "namespaces"))
+    {
+        while(my $Name = parseTag(\$NameSpaces, "name")) {
+            $ABI{"NameSpaces"}{$Name} = 1;
+        }
+    }
+    
+    if(my $TypeInfo = parseTag(\$ABI_DUMP, "type_info"))
+    {
+        while(my $DataType = parseTag(\$TypeInfo, "data_type"))
+        {
+            my %TInfo = ();
+            my $ID = parseTag(\$DataType, "id");
+            
+            if(my $Members = parseTag(\$DataType, "members"))
+            {
+                $Pos = 0;
+                while(my $Field = parseTag(\$Members, "field"))
+                {
+                    my %MInfo = ();
+                    $MInfo{"name"} = parseTag(\$Field, "name");
+                    if(my $Tid = parseTag(\$Field, "type")) {
+                        $MInfo{"type"} = $Tid;
+                    }
+                    if(my $Access = parseTag(\$Field, "access")) {
+                        $MInfo{"access"} = $Access;
+                    }
+                    my $Val = parseTag(\$Field, "value");
+                    if(defined $Val) {
+                        $MInfo{"value"} = $Val;
+                    }
+                    if(my $Align = parseTag(\$Field, "algn")) {
+                        $MInfo{"algn"} = $Align;
+                    }
+                    if(my $Bitfield = parseTag(\$Field, "bitfield")) {
+                        $MInfo{"bitfield"} = $Bitfield;
+                    }
+                    if(my $Spec = parseTag(\$Field, "spec")) {
+                        $MInfo{$Spec} = 1;
+                    }
+                    $TInfo{"Memb"}{$Pos++} = \%MInfo;
+                }
+            }
+            
+            if(my $Parameters = parseTag(\$DataType, "parameters"))
+            {
+                $Pos = 0;
+                while(my $Parameter = parseTag(\$Parameters, "param"))
+                {
+                    my %PInfo = ();
+                    if(my $Tid = parseTag(\$Parameter, "type")) {
+                        $PInfo{"type"} = $Tid;
+                    }
+                    $TInfo{"Param"}{$Pos++} = \%PInfo;
+                }
+            }
+            if(my $TParams = parseTag(\$DataType, "template_parameters"))
+            {
+                $Pos = 0;
+                while(my $TParam = parseTag(\$TParams, "param")) {
+                    $TInfo{"TParam"}{$Pos++}{"name"} = parseTag(\$TParam, "name");
+                }
+            }
+            if(my $VTable = parseTag(\$DataType, "vtable"))
+            {
+                $Pos = 0;
+                while(my $Entry = parseTag(\$VTable, "entry")) {
+                    $TInfo{"VTable"}{parseTag(\$Entry, "offset")} = parseTag(\$Entry, "value");
+                }
+            }
+            if(my $BTid = parseTag(\$DataType, "base_type")) {
+                $TInfo{"BaseType"}{"Tid"} = $BTid;
+            }
+            if(my $Base = parseTag(\$DataType, "base"))
+            {
+                $Pos = 0;
+                while(my $Class = parseTag(\$Base, "class"))
+                {
+                    my %CInfo = ();
+                    $CInfo{"pos"} = parseTag(\$Class, "pos");
+                    if(my $Access = parseTag(\$Class, "access")) {
+                        $CInfo{"access"} = $Access;
+                    }
+                    if(my $Inherit = parseTag(\$Class, "inherit"))
+                    {
+                        if($Inherit eq "virtual") {
+                            $CInfo{"virtual"} = 1;
+                        }
+                    }
+                    $TInfo{"Base"}{parseTag(\$Class, "id")} = \%CInfo;
+                }
+            }
+            while(my $Note = parseTag(\$DataType, "note"))
+            {
+                if($Note eq "copied") {
+                    $TInfo{"Copied"} = 1;
+                }
+                elsif($Note eq "specialization") {
+                    $TInfo{"Spec"} = 1;
+                }
+            }
+            foreach my $Attr ("Name", "Type", "Class",
+            "Header", "Line", "NameSpace", "Return", "Size")
+            {
+                my $Val = parseTag(\$DataType, lc($Attr));
+                if(defined $Val) {
+                    $TInfo{$Attr} = $Val;
+                }
+            }
+            if(my $Access = parseTag(\$DataType, "access")) {
+                $TInfo{ucfirst($Access)} = 1;
+            }
+            $ABI{"TypeInfo"}{$ID} = \%TInfo;
+        }
+    }
+    
+    if(my $Constants = parseTag(\$ABI_DUMP, "constants"))
+    {
+        while(my $Constant = parseTag(\$Constants, "constant"))
+        {
+            if(my $Name = parseTag(\$Constant, "name"))
+            {
+                my %CInfo = ();
+                $CInfo{"Value"} = parseTag(\$Constant, "value");
+                $CInfo{"Header"} = parseTag(\$Constant, "header");
+                $ABI{"Constants"}{$Name} = \%CInfo;
+            }
+        }
+    }
+    
+    if(my $SymbolInfo = parseTag(\$ABI_DUMP, "symbol_info"))
+    {
+        my %TR = (
+            "MnglName"=>"mangled",
+            "ShortName"=>"short"
+        );
+        while(my $Symbol = parseTag(\$SymbolInfo, "symbol"))
+        {
+            my %SInfo = ();
+            my $ID = parseTag(\$Symbol, "id");
+            
+            if(my $Parameters = parseTag(\$Symbol, "parameters"))
+            {
+                $Pos = 0;
+                while(my $Parameter = parseTag(\$Parameters, "param"))
+                {
+                    my %PInfo = ();
+                    if(my $PName = parseTag(\$Parameter, "name")) {
+                        $PInfo{"name"} = $PName;
+                    }
+                    if(my $PTid = parseTag(\$Parameter, "type")) {
+                        $PInfo{"type"} = $PTid;
+                    }
+                    my $Default = parseTag(\$Parameter, "default", "spaces");
+                    if(defined $Default) {
+                        $PInfo{"default"} = $Default;
+                    }
+                    if(my $Align = parseTag(\$Parameter, "algn")) {
+                        $PInfo{"algn"} = $Align;
+                    }
+                    if(my $Call = parseTag(\$Parameter, "call"))
+                    {
+                        if($Call eq "register") {
+                            $PInfo{"reg"} = 1;
+                        }
+                    }
+                    $SInfo{"Param"}{$Pos++} = \%PInfo;
+                }
+            }
+            if(my $TParams = parseTag(\$Symbol, "template_parameters"))
+            {
+                $Pos = 0;
+                while(my $TParam = parseTag(\$TParams, "param")) {
+                    $SInfo{"TParam"}{$Pos++}{"name"} = parseTag(\$TParam, "name");
+                }
+            }
+            
+            foreach my $Attr ("MnglName", "ShortName", "Class",
+            "Header", "Line", "Return", "NameSpace", "Value")
+            {
+                my $Tag = lc($Attr);
+                if($TR{$Attr}) {
+                    $Tag = $TR{$Attr};
+                }
+                my $Val = parseTag(\$Symbol, $Tag);
+                if(defined $Val) {
+                    $SInfo{$Attr} = $Val;
+                }
+            }
+            if(my $Kind = parseTag(\$Symbol, "kind")) {
+                $SInfo{ucfirst($Kind)} = 1;
+            }
+            while(my $Spec = parseTag(\$Symbol, "spec"))
+            {
+                if($Spec eq "virtual") {
+                    $SInfo{"Virt"} = 1;
+                }
+                elsif($Spec eq "pure virtual") {
+                    $SInfo{"PureVirt"} = 1;
+                }
+                elsif($Spec eq "inline") {
+                    $SInfo{"InLine"} = 1;
+                }
+                else
+                { # const, volatile, static
+                    $SInfo{ucfirst($Spec)} = 1;
+                }
+            }
+            if(my $Access = parseTag(\$Symbol, "access")) {
+                $SInfo{ucfirst($Access)} = 1;
+            }
+            if(my $Note = parseTag(\$Symbol, "note")) {
+                $SInfo{ucfirst($Note)} = 1;
+            }
+            if(my $Lang = parseTag(\$Symbol, "lang")) {
+                $SInfo{"Lang"} = $Lang;
+            }
+            $ABI{"SymbolInfo"}{$ID} = \%SInfo;
+        }
+    }
+    
+    if(my $Symbols = parseTag(\$ABI_DUMP, "symbols"))
+    {
+        my %LInfo = ();
+        while(my $LibSymbols = parseTag_E(\$Symbols, "library", \%LInfo))
+        {
+            my %SInfo = ();
+            while(my $Symbol = parseTag_E(\$LibSymbols, "symbol", \%SInfo))
+            {
+                if(my $Size = $SInfo{"size"}) {
+                    $ABI{"Symbols"}{$LInfo{"name"}}{$Symbol} = -$Size;
+                }
+                else {
+                    $ABI{"Symbols"}{$LInfo{"name"}}{$Symbol} = 1;
+                }
+                %SInfo = ();
+            }
+            %LInfo = ();
+        }
+    }
+    
+    if(my $DepSymbols = parseTag(\$ABI_DUMP, "dep_symbols"))
+    {
+        my %LInfo = ();
+        while(my $LibSymbols = parseTag_E(\$DepSymbols, "library", \%LInfo))
+        {
+            my %SInfo = ();
+            while(my $Symbol = parseTag_E(\$LibSymbols, "symbol", \%SInfo))
+            {
+                if(my $Size = $SInfo{"size"}) {
+                    $ABI{"DepSymbols"}{$LInfo{"name"}}{$Symbol} = -$Size;
+                }
+                else {
+                    $ABI{"DepSymbols"}{$LInfo{"name"}}{$Symbol} = 1;
+                }
+                %SInfo = ();
+            }
+            %LInfo = ();
+        }
+    }
+    
+    $ABI{"SymbolVersion"} = {};
+    
+    if(my $SymbolVersion = parseTag(\$ABI_DUMP, "symbol_version"))
+    {
+        while(my $Symbol = parseTag(\$SymbolVersion, "symbol")) {
+            $ABI{"SymbolVersion"}{parseTag(\$Symbol, "name")} = parseTag(\$Symbol, "version");
+        }
+    }
+    
+    $ABI{"SkipTypes"} = {};
+    
+    if(my $SkipTypes = parseTag(\$ABI_DUMP, "skip_types"))
+    {
+        while(my $Name = parseTag(\$SkipTypes, "name")) {
+            $ABI{"SkipTypes"}{$Name} = 1;
+        }
+    }
+    
+    $ABI{"SkipSymbols"} = {};
+    
+    if(my $SkipSymbols = parseTag(\$ABI_DUMP, "skip_symbols"))
+    {
+        while(my $Name = parseTag(\$SkipSymbols, "name")) {
+            $ABI{"SkipSymbols"}{$Name} = 1;
+        }
+    }
+    
+    $ABI{"SkipNameSpaces"} = {};
+    
+    if(my $SkipNameSpaces = parseTag(\$ABI_DUMP, "skip_namespaces"))
+    {
+        while(my $Name = parseTag(\$SkipNameSpaces, "name")) {
+            $ABI{"SkipNameSpaces"}{$Name} = 1;
+        }
+    }
+    
+    $ABI{"SkipHeaders"} = {};
+    
+    if(my $SkipHeaders = parseTag(\$ABI_DUMP, "skip_headers"))
+    {
+        while(my $Name = parseTag(\$SkipHeaders, "name")) {
+            $ABI{"SkipHeaders"}{$Name} = 1;
+        }
+    }
+    
+    if(my $TargetHeaders = parseTag(\$ABI_DUMP, "target_headers"))
+    {
+        while(my $Name = parseTag(\$TargetHeaders, "name")) {
+            $ABI{"TargetHeaders"}{$Name} = 1;
+        }
+    }
+    
+    if(my $Mode = parseTag(\$ABI_DUMP, "mode")) {
+        $ABI{"Mode"} = $Mode;
+    }
+    if(my $Kind = parseTag(\$ABI_DUMP, "kind"))
+    {
+        if($Kind eq "BinOnly") {
+            $ABI{"BinOnly"} = 1;
+        }
+        elsif($Kind eq "SrcBin") {
+            $ABI{"SrcBin"} = 1;
+        }
+    }
+    
+    my %RInfo = ();
+    parseTag_E(\$ABI_DUMP, "ABI_dump", \%RInfo);
+    
+    $ABI{"ABI_DUMP_VERSION"} = $RInfo{"version"};
+    $ABI{"XML_ABI_DUMP_VERSION"} = $RInfo{"xml_format"};
+    $ABI{"ABI_COMPLIANCE_CHECKER_VERSION"} = $RInfo{"acc"};
+    
+    return \%ABI;
+}
+
 return 1;
\ No newline at end of file