Merge lp:~brian-murray/apt/history-log into lp:~ubuntu-core-dev/apt/ubuntu

[Brian Murray]

This branch adds in /var/log/apt/history.log to apport-package bug reports. Additionally, it prevents writing of apport reports in the event that dpkg returns an ENOENT error.

[Michael Vogt (mvo)]

Thanks a bunch! I fixed a small typo and merged it. Please note that I couldn't merge directly as lp:ubuntu/apt does not point to lp:~ubuntu-core-dev/apt/ubuntu I need to figure out how to fix this.

review: Approve

=== added directory '.bzr-builddeb'
=== renamed directory '.bzr-builddeb' => '.bzr-builddeb.moved'
=== added file '.bzr-builddeb/default.conf'
--- .bzr-builddeb/default.conf	1970-01-01 00:00:00 +0000
+++ .bzr-builddeb/default.conf	2011-06-01 19:45:47 +0000
@@ -0,0 +1,2 @@
+[BUILDDEB]
+native = True

=== added file 'AUTHORS'
--- AUTHORS	1970-01-01 00:00:00 +0000
+++ AUTHORS	2011-06-01 19:45:47 +0000
@@ -0,0 +1,64 @@
+The  project contributors:
+
+Michael Vogt <[e-mail]>
+- Development, bug fixes
+
+David Kalnischkies <[e-mail]>
+- Development, bug fixes
+
+Christian Perrier <[e-mail]>
+- Translations hero/coordinator
+
+
+Past Contributors:
+
+Robert Collins <[e-mail]>
+- Change the package index Info methods to allow apt-cache policy to be useful
+  when using several different archives on the same host.
+
+Julian Andres Klode
+- Development, bug fixes
+
+Eugene V. Lyubimkin
+- Development, bug fixes
+
+Otavio Salvador
+- Development, bug fixes
+
+Luca Bruno
+- Development, bug fixes
+
+CVS:jgg Jason Gunthorpe <[e-mail]>
+- The Mad Cow incarnate
+
+CVS:mdz Matt Zimmerman <[e-mail]>
+- Ongoing maintenance and coordination of development
+
+CVS:piefel Michael Piefel <[e-mail]>
+- i18n and l10n
+
+CVS:che Ben Gertzfield <[e-mail]>
+- Packaging and Releases
+
+CVS:bod Brendan O'Dea <[e-mail]>
+- Perl Bindings
+
+CVS:tausq Randolph Chung <[e-mail]>
+- Patches, Fixes, Debugging, GUIs and Releases
+
+Isaac Jones <[e-mail]> and Colin Walters <[e-mail]>
+        Initial implementation of authentication support (Release.gpg)
+
+Brian White <[e-mail]> - Project originator
+Tom Lees <[e-mail]> - DPKG documentation and ideas
+Behan Webster <[e-mail]> - Original GUI design
+Scott Ellis <[e-mail]> - Original packaging and beta releases
+Branden Robinson <[e-mail]> - Man Page Documentation
+Manoj Srivastava <[e-mail]> - 1st Generation FTP method and
+                                           dselect setup script
+Adam Heath <[e-mail]> - 2nd Generation FTP method author
+Ben Collins <[e-mail]> - Initial RSH method
+Many other bug reports through the Debian Bug system
+
+NOTE: The ChangeLog generator will parse for names and email addresses. The
+'CVS:<name>' tag should indicate who this pair refers to.

=== renamed file 'AUTHORS' => 'AUTHORS.moved'
=== added file 'BUGS'
--- BUGS	1970-01-01 00:00:00 +0000
+++ BUGS	2011-06-01 19:45:47 +0000
@@ -0,0 +1,9 @@
+
+DDTP problems:
+--------------
+- apt-get update clean the /var/lib/apt/lists dir 
+  from all Translation-$index that are not in the current
+  enviroment or Translations apt variable
+- there needs to be a list of locales (pt, sv, en) that need
+  both language and country code to get the right file
+  (is in the code in indexfile::LanguageCode(), just a bit ugly 

=== renamed file 'BUGS' => 'BUGS.moved'
=== added file 'COMPILING'
--- COMPILING	1970-01-01 00:00:00 +0000
+++ COMPILING	2011-06-01 19:45:47 +0000
@@ -0,0 +1,85 @@
+General Information
+~~~~~~~~~~~~~~~~~~~
+To compile this you need a couple things
+  - A working POSIX system with working POSIX gcc, g++, make (GNU),
+    ar, sh, awk and sed in the path
+  - GNU Make 3.74 or so, -- normal UNIX make will NOT work
+    * Note 3.77 is broken.    
+  - A working ANSI C++ compiler, this is not g++ 2.7.* 
+    g++ 2.8 works OK and newer egcs work well also. Nobody has tried it
+    on other compilers :< You will need a properly working STL as well.
+  - A C library with the usual POSIX functions and a BSD socket layer. 
+    If your OS conforms to the Single Unix Spec then you are fine:
+      http://www.opengroup.org/onlinepubs/7908799/index.html      
+  - Refer to the Build-Depends information in debian/control for
+    additional requirements (some of which are Debian-specific)
+
+** NOTICE **
+The C++ global constructors do not link correctly when using non-shared
+libraries. This is probably the correct behavior of the linker, but I have
+not yet had time to devise a work around for it. The correct thing to 
+do is add a reference to debSystem in apt-pkg/init.cc, 
+assert(&debSystem == 0) would be fine for instance.
+
+Guidelines
+~~~~~~~~~~
+I am not interested in making 'ultra portable code'. I will accept patches
+to make the code that already exists conform more to SUS or POSIX, but
+I don't really care if your not-SUS OS doesn't work. It is simply too
+much work to maintain patches for dysfunctional OSs. I highly suggest you
+contact your vendor and express intrest in a conforming C library.
+
+That said, there are lots of finicky problems that must be dealt with even
+between the supported OS's. Primarily the path I choose to take is to put
+a shim header file in build/include that transparently adds the required 
+functionality. Patches to make autoconf detect these cases and generate the 
+required shims are OK.
+
+Current shims:
+  * C99 integer types 'inttypes.h' 
+  * sys/statvfs.h to convert from BSD/old-glibc statfs to SUS statvfs
+  * rfc2553 hostname resolution (methods/rfc*), shims to normal gethostbyname.
+    The more adventurous could steal the KAME IPv6 enabled resolvers for those
+    OS's with IPv6 support but no rfc2553 (why?)
+  * define _XOPEN_EXTENDED_SOURCE to bring in h_errno on HP-UX
+  * socklen_t shim in netdb.h if the OS does not have socklen_t
+  
+The only completely non-shimmed OS is Linux with glibc2.1, glibc2.0 requires
+the first three shims.
+
+Platform Notes
+~~~~~~~~~~~~~~
+Debian GNU Linux 2.1 'slink'
+Debian GNU Linux 'potato'
+Debian GNU Linux 'woody'
+  * All Archs
+  - Works flawlessly
+  - You will want to have debiandoc-sgml and docbook2man installed to get
+    best results.
+  - No IPv6 Support in glibc's < 2.1.
+
+Sun Solaris
+  SunOS cab101 5.7 Generic_106541-04 sun4u sparc
+  SunOS csu201 5.8 Generic_108528-04 sun4u sparc  
+  - Works fine
+  - Note, no IPv6 Support, OS lacks RFC 2553 hostname resolution
+
+OpenBSD
+  OpenBSD gsb086 2.5 CMPUT#0 i386 unknown
+  OpenBSD csu101 2.7 CMPUT#1 i386 unknown  
+  - OS needs 'ranlib' to generate the symbol table after 'ar'.. (not using
+    GNU ar with the gnu tool chain :<)
+  - '2.5' does not have RFC 2553 hostname resolution, but '2.7' does
+  - Testing on '2.7' suggests the OS has a bug in its handling of 
+    ftruncate on files that have been written via mmap. It fills the page 
+    that crosses the truncation boundary with 0's. 
+    
+HP-UX
+  HP-UX nyquist B.10.20 C 9000/780 2016574337 32-user license
+  - Evil OS, does not conform very well to SUS
+     1) snprintf exists but is not prototyped, ignore spurious warnings
+     2) No socklen_t
+     3) Requires -D_XOPEN_SOURCE_EXTENDED for h_errno
+    configure should fix the last two (see above)
+  - Note, no IPv6 Support, OS lacks RFC 2553 hostname resolution
+    

=== renamed file 'COMPILING' => 'COMPILING.moved'
=== added file 'COPYING'
--- COPYING	1970-01-01 00:00:00 +0000
+++ COPYING	2011-06-01 19:45:47 +0000
@@ -0,0 +1,23 @@
+Apt is copyright 1997, 1998, 1999 Jason Gunthorpe and others.
+Apt is currently developed by APT Development Team <[e-mail]>.
+
+License: GPLv2+
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    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
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+
+See /usr/share/common-licenses/GPL-2, or
+<http://www.gnu.org/copyleft/gpl.txt> for the terms of the latest version
+of the GNU General Public License.
+

=== added file 'COPYING.GPL'
--- COPYING.GPL	1970-01-01 00:00:00 +0000
+++ COPYING.GPL	2011-06-01 19:45:47 +0000
@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+

+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+

+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+

+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+

+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+

+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 19yy  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    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
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) 19yy name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

=== renamed file 'COPYING.GPL' => 'COPYING.GPL.moved'
=== renamed file 'COPYING' => 'COPYING.moved'
=== added file 'Makefile'
--- Makefile	1970-01-01 00:00:00 +0000
+++ Makefile	2011-06-01 19:45:47 +0000
@@ -0,0 +1,34 @@
+# -*- make -*-
+
+# This is the top level make file for APT, it recurses to each lower
+# level make file and runs it with the proper target
+ifndef NOISY
+.SILENT:
+endif
+
+.PHONY: default
+default: startup all
+
+.PHONY: headers library clean veryclean all binary program doc
+all headers library clean veryclean binary program doc dirs:
+	$(MAKE) -C apt-pkg $@
+	$(MAKE) -C apt-inst $@
+	$(MAKE) -C methods $@
+	$(MAKE) -C cmdline $@
+	$(MAKE) -C ftparchive $@
+	$(MAKE) -C dselect $@
+	$(MAKE) -C doc $@
+	$(MAKE) -C po $@
+
+# Some very common aliases
+.PHONY: maintainer-clean dist-clean distclean pristine sanity 
+maintainer-clean dist-clean distclean pristine sanity: veryclean
+
+# The startup target builds the necessary configure scripts. It should
+# be used after a CVS checkout.
+CONVERTED=environment.mak include/config.h include/apti18n.h build/doc/Doxyfile makefile
+include buildlib/configure.mak
+$(BUILDDIR)/include/config.h: buildlib/config.h.in
+$(BUILDDIR)/include/apti18n.h: buildlib/apti18n.h.in
+$(BUILDDIR)/environment.mak: buildlib/environment.mak.in
+$(BUILDDIR)/makefile: buildlib/makefile.in

=== renamed file 'Makefile' => 'Makefile.moved'
=== added file 'README.MultiArch'
--- README.MultiArch	1970-01-01 00:00:00 +0000
+++ README.MultiArch	2011-06-01 19:45:47 +0000
@@ -0,0 +1,63 @@
+Before we start with this topic: Note that MultiArch is not yet ready for
+prime time and/or for the casual user. The implementation is so far widely
+untested and only useful for developers of packagemanagment tools which
+use APT and his friends and maintainers of (upcoming) MultiArch packages.
+This README is especially NOT written for the casual user and is NOT a
+usage guide - you have been warned. It is assumed that the reader has
+at least a bit of knowledge about APT internals, dependency relations
+and the MultiArch spec [0].
+
+Note also that the toolchain isn't ready yet, e.g. while you can simulate
+the installation of MultiArch packages they will more sooner than later
+cause enormous problems if really installed as dpkg can't handle MultiArch
+yet (no, --force-{overwrite,architecture} aren't good options here).
+Other parts of the big picture are missing and/or untested too.
+You have been warned!
+
+
+The implementation is focused on NOT breaking existing singleArch-only
+applications and/or systems as this is the current status-quo for all
+systems. Also, many systems don't need (or can't make use of) MultiArch,
+so APT will proceed in thinking SingleArch as long as it is not explicitly
+told to handle MultiArch:
+To activate MultiArch handling you need to specify architectures you
+want to be considered by APT with the config list APT::Architectures
+(Insert architectures in order of preference).
+APT will download Packages files for all these architectures in the
+update step. Exception: In the sourcelist is the optionfield used:
+deb [ arch=amd64,i386 ] http://example.org/ experimental main
+(This optionfield is a NOP in previous apt versions)
+
+Internally in APT a package is represented as a PkgIterator -
+before MultiArch this PkgIterator was architecture unaware,
+only VerIterators include the architecture they came from.
+This is/was a big problem as all versions in a package are
+considered for dependency resolution, so pinning will not work in all cases.
+
+The problem is solved by a conceptional change:
+A PkgIterator is now architecture aware, so the packages
+of foobar for amd64 and for i386 are now for apt internal totally
+different packages. That is a good thing for e.g. pinning, but
+sometimes you need the information that such packages are belonging together:
+All these foobar packages therefore form a Group accessible with GrpIterators.
+Note that the GrpIterator has the same name as all the packages in this group,
+so e.g. apt-cache pkgnames iterates over GrpIterator to get the package names:
+This is compatible to SingleArch as a Group consists only of a single package
+and also to MultiArch as a Group consists of possible many packages which
+all have the same name and are therefore out of interest for pkgnames.
+
+
+Given all these internal changes it is quite interesting that the actual
+implementation of MultiArch is trivial: Some implicit dependencies and a few
+more provides are all changes needed to get it working. Especially noteworthy
+is that it wasn't needed to change the resolver in any way and other parts only
+need to be told about using GrpIterator instead of PkgIterator, so chances are
+good that libapt-applications will proceed to work without or at least only
+require minor changes, but your mileage may vary…
+
+
+Known Issues and/or noteworthy stuff:
+* The implementation is mostly untested, so it is very likely that APT will
+  eat your kids if you aren't as lucky as the author of these patches.
+
+[0] https://wiki.ubuntu.com/MultiarchSpec

=== renamed file 'README.MultiArch' => 'README.MultiArch.moved'
=== added file 'README.ddtp'
--- README.ddtp	1970-01-01 00:00:00 +0000
+++ README.ddtp	2011-06-01 19:45:47 +0000
@@ -0,0 +1,74 @@
+TODO:
+- URL-Remap for the translation files (to hack around the problem that
+  they are not on any ftp server yet but only on http://ddtp.debian.org/)
+
+Here is the original announcement of the ddtp support:
+
+* To: [e-mail]
+* Subject: Translate files
+* From: Michael Bramer <[e-mail]>
+* Date: Sun, 6 Oct 2002 21:56:06 +0200
+* Mail-followup-to: [e-mail]
+* Message-id: <[e-mail]>
+* Old-return-path: <[e-mail]>
+* User-agent: Mutt/1.3.28i
+
+Hello all
+
+After some discussion between Anthony Towns (a ftpmaster), Jason
+Gunthorpe (APT Developer) and some DDTP Coordinators we find a way to
+transfer the translated package descriptions from the archive to the
+user. 
+
+The translated descriptions need to be downloadable befor any
+installation process, like the other package meta information. We
+choose a new file per languages with all translated package
+descriptions. The package system can download one or more of this
+files at 'apt-get update' time and know the translations.
+
+The new files are names 'Translate-$lang' and the file have this
+rfc822-format:
+  Package: &lt;package-name&gt;
+  Description-md5: &lt;the md5 checksum of the english description&gt;
+  Description-$lang.$encoding: &lt;translated headline&gt;
+   &lt;translated section&gt;
+
+The encoding of the Description is 'UTF-8' in all languages normal.
+The files will be located at 'debian/dists/sid/main/i18n/' on the ftp
+server (for all architecture). In addition of the plain
+'Translate-$lang' file, there will be a 'gz' and a 'bz2' version and
+in future also the new incremental format version.
+
+The &lt;the md5 checksum of the english description&gt; is the md5 checksum
+of the full english description, without the 'Description: '-tag and
+with all spaces and newlines. Look at this example:
+ Description: XXX
+  YYY
+  .
+  ZZZ
+is md5(&quot;XXX\n YYY\n .\n ZZZ\n&quot;) (perl-syntax).
+
+
+A future APT version will download one or some 'Translate-$lang'
+file(s) at 'update'-time. After this download it show a translated
+description instead of the english form, if it found a translated
+description of the package with the right md5 chechsum. The enviroment
+of the user will controlled this process (LANG, LANGUAGE, LC_MESSAGES,
+etc). With this the package system will never show a outdated
+translation.
+
+The translations come all from the DDTP. A daily process on
+ddtp.debian.org make new 'Translated-$lang' files and a script on
+ftp-master request this files and move this to the debian archive.
+Now the first files are accessable at 
+	<a  href="http://ddtp.debian.org/pdesc/translatefiles/">http://ddtp.debian.org/pdesc/translatefiles/</a>
+
+If you found wrong translations, please read the guides on
+ddtp.debian.org, make a better translation and send this per mail to
+the DDTP server. Don't bug the package maintainer!
+
+Thanks
+Grisu
+-- 
+Michael Bramer  -  a Debian Linux Developer      <a  href="http://www.debsupport.de">http://www.debsupport.de</a>
+PGP: finger [e-mail]  -- Linux Sysadmin   -- Use Debian Linux

=== renamed file 'README.ddtp' => 'README.ddtp.moved'
=== added file 'README.make'
--- README.make	1970-01-01 00:00:00 +0000
+++ README.make	2011-06-01 19:45:47 +0000
@@ -0,0 +1,112 @@
+The Make System
+~~~ ~~~~ ~~~~~~
+To compile this program you require GNU Make. In fact you probably need
+GNU Make 3.76.1 or newer. The makefiles contained make use of many 
+GNU Make specific features and will not run on other makes.
+
+The make system has a number of interesting properties that are not found
+in other systems such as automake or the GNU makefile standards. In
+general some semblance of expectedness is kept so as not to be too
+surprising. Basically the following will work as expected:
+
+   ./configure
+   make
+ or
+   cd build
+   ../configure
+   make
+
+There are a number of other things that are possible that may make software
+development and software packaging simpler. The first of these is the
+environment.mak file. When configure is run it creates an environment.mak
+file in the build directory. This contains -all- configurable parameters
+for all of the make files in all of the subdirectories. Changing one
+of these parameters will have an immediate effect. The use of makefile.in 
+and configure substitutions across build makefiles is not used at all.
+
+Furthermore, the make system runs with a current directory equal to the
+source directory irregardless of the destination directory. This means
+#include "" and #include <> work as expected and more importantly
+running 'make' in the source directory will work as expected. The
+environment variable or make parameter 'BUILD' sets the build directory.
+It may be an absolute path or a path relative to the top level directory.
+By default build-arch/ then build/ will be used with a fall back to ./ This 
+means you can get all the advantages of a build directory without having to
+cd into it to edit your source code!
+
+The make system also performs dependency generation on the fly as the
+compiler runs. This is extremely fast and accurate. There is however
+one failure condition that occurs when a header file is erased. In
+this case you should run make clean to purge the .o and .d files to
+rebuild.
+
+The final significant deviation from normal make practices is 
+in how the build directory is managed. It is not nearly a mirror of
+the source directory but is logically divided in the following manner
+   bin/
+     methods/
+   doc/
+     examples/
+   include/
+     apt-pkg/
+   obj/
+     apt-pkg/
+     cmdline/
+     [...]
+Only .o and .d files are placed in the obj/ subdirectory. The final compiled
+binaries are placed in bin, published headers for inter-component linking
+are placed in include/ and documentation is generated into doc/. This means
+all runnable programs are within the bin/ directory, a huge benefit for
+debugging inter-program relationships. The .so files are also placed in
+bin/ for simplicity.
+
+By default make is put into silent mode. During operation there should be
+no shell or compiler messages only status messages from the makefiles, 
+if any pop up that indicates there may be a problem with your environment.
+For debugging you can disable this by setting NOISY=1, ala
+   make NOISY=1
+
+Using the makefiles
+~~~~~ ~~~ ~~~~~~~~~
+The makefiles for the components are really simple. The complexity is hidden
+within the buildlib/ directory. Each makefile defines a set of make variables
+for the bit it is going to make then includes a makefile fragment from
+the buildlib/. This fragment generates the necessary rules based on the
+originally defined variables. This process can be repeated as many times as
+necessary for as many programs or libraries as are in the directory.
+
+Many of the make fragments have some useful properties involving sub
+directories and other interesting features. They are more completely 
+described in the fragment code in buildlib. Some tips on writing fragments
+are included in buildlib/defaults.mak
+
+The fragments are NEVER processed by configure, so if you make changes to 
+them they will have an immediate effect.
+
+Autoconf
+~~~~~~~~
+Straight out of CVS you have to initialize autoconf. This requires 
+automake (I really don't know why) and autoconf and requires doing 
+  aclocal -I buildlib
+  autoconf
+[Alternatively you can run make startup in the top level build dir]
+
+Autoconf is configured to do some basic system probes for optional and 
+required functionality and generate an environment.mak and include/config.h 
+from it's findings. It will then write a 'makefile' and run make dirs to 
+create the output directory tree.
+
+It is not my belief that autoconf should be used to generate substantial 
+source code markup to escape OS problems. If an OS problem does crop up 
+it can likely be corrected by installing the correct files into the 
+build include/ dir and perhaps writing some replacement code and 
+linking it in. To the fullest extent possible the source code should conform
+to standards and not cater to broken systems.
+
+Autoconf will also write a makefile into the top level of the build dir, 
+this simply acts as a wrapper to the main top level make in the source tree.
+There is one big warning, you can't use both this make file and the
+ones in the top level tree. Make is not able to resolve rules that 
+go to the same file through different paths and this will confuse the
+depends mechanism. I recommend always using the makefiles in the
+source directory and exporting BUILD.

=== renamed file 'README.make' => 'README.make.moved'
=== added file 'README.progress-reporting'
--- README.progress-reporting	1970-01-01 00:00:00 +0000
+++ README.progress-reporting	2011-06-01 19:45:47 +0000
@@ -0,0 +1,69 @@
+Install-progress reporting 
+--------------------------
+
+If the apt options: "APT::Status-Fd" is set, apt will send status
+reports to that fd. The status information is seperated with a ':', 
+there are the following status conditions:
+
+status = {"pmstatus", "dlstatus", "conffile-prompt", "error", "media-change" } 
+
+The reason for using a fd instead of a OpProgress class is that many
+apt frontend fork a (vte) terminal for the actual installation.
+
+The reason to do the mapping and l10n of the dpkg states to human
+readable (and translatable) strings is that this way the translation
+needs to be done only once for all frontends.
+
+
+pmstatus
+--------
+Status of the package manager (dpkg). This is send when packages
+are installed/removed.
+pmstatus:pkgname:TotalPercentage:action-description
+
+PkgName = the name of the package
+TotalPercentage = the total progress between [0..100] 
+description = a i18ned human readable decription of the current action
+
+
+Example:
+# ./apt-get install -o APT::Status-Fd=2 3dchess >/dev/null
+pmstatus:3dchess:20:Preparing 3dchess
+pmstatus:3dchess:40:Unpacking 3dchess
+pmstatus:3dchess:60:Preparing to configure 3dchess
+pmstatus:3dchess:80:Configuring 3dchess
+pmstatus:3dchess:100:Installed 3dchess
+
+pmerror
+-------
+pmerror:deb:TotalPercentage:error string
+
+Example:
+pmerror: /var/cache/apt/archives/krecipes_0.8.1-0ubuntu1_i386.deb : 75% : trying to overwrite `/usr/share/doc/kde/HTML/en/krecipes/krectip.png', which is also in package krecipes-data 
+
+
+pmconffile
+----------
+pmconffile:conffile:percent:'current-conffile' 'new-conffile' useredited distedited
+
+
+media-change
+------------
+media-change:medium:drive:human-readable string
+
+example:
+media-change: Ubuntu 5.10 _Breezy Badger_ - Alpha i386 (20050830):/cdrom/:Please insert the disc labeled: 'Ubuntu 5.10 _Breezy Badger_ - Alpha i386 (20050830)' in the drive '/cdrom/' and press enter.
+
+
+dlstatus
+--------
+dlstatus:AlreadDownloaded:TotalPercentage:action-description
+
+AlreadyDownloaded = the number of already downloaded packages
+TotalPercentage = the total progress between [0..100] 
+description = a i18ned human readable decription of the current action
+
+Example:
+dlstatus:1:9.05654:Downloading file 1 of 3 (4m40s remaining)
+dlstatus:1:9.46357:Downloading file 1 of 3 (4m39s remaining)
+dlstatus:1:9.61022:Downloading file 1 of 3 (4m38s remaining)
\ No newline at end of file

=== renamed file 'README.progress-reporting' => 'README.progress-reporting.moved'
=== added directory 'abicheck'
=== renamed directory 'abicheck' => 'abicheck.moved'
=== added file 'abicheck/abi-compliance-checker.pl'
--- abicheck/abi-compliance-checker.pl	1970-01-01 00:00:00 +0000
+++ abicheck/abi-compliance-checker.pl	2011-06-01 19:45:47 +0000
@@ -0,0 +1,7325 @@
+#!/usr/bin/perl
+###########################################################################
+# ABI-compliance-checker v1.13, lightweight tool for statically checking
+# backward binary compatibility of shared C/C++ libraries in Linux.
+# Copyright (C) The Linux Foundation
+# Copyright (C) Institute for System Programming, RAS
+# Author: Andrey Ponomarenko
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#
+# 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
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+###########################################################################
+use Getopt::Long;
+Getopt::Long::Configure ("posix_default", "no_ignore_case");
+use Data::Dumper;
+
+my $ABI_COMPLIANCE_CHECKER_VERSION = "1.13";
+my ($Help, $ShowVersion, %Descriptor, $TargetLibraryName, $HeaderCheckingMode_Separately, $GenerateDescriptor, $TestSystem, $DumpInfo_DescriptorPath, $CheckHeadersOnly, $InterfacesListPath, $AppPath, $ShowExpendTime);
+
+my $CmdName = get_FileName($0);
+GetOptions("h|help!" => \$Help,
+  "v|version!" => \$ShowVersion,
+#general options
+  "l|library=s" => \$TargetLibraryName,
+  "d1|descriptor1=s" => \$Descriptor{1}{"Path"},
+  "d2|descriptor2=s" => \$Descriptor{2}{"Path"},
+#extra options
+  "app|application=s" => \$AppPath,
+  "symbols_list|int_list=s" => \$InterfacesListPath,
+  "dump_abi|dump_info=s" => \$DumpInfo_DescriptorPath,
+  "headers_only!" => \$CheckHeadersOnly,
+#other options
+  "d|descriptor_template!" => \$GenerateDescriptor,
+  "separately!" => \$HeaderCheckingMode_Separately,
+  "test!" => \$TestSystem,
+  "time!" => \$ShowExpendTime
+) or exit(1);
+
+sub HELP_MESSAGE()
+{
+    print STDERR <<"EOM"
+
+NAME:
+  $CmdName - check ABI compatibility of shared C/C++ library versions
+
+DESCRIPTION:
+  Lightweight tool for statically checking backward binary compatibility of shared C/C++ libraries
+  in Linux. It checks header files along with shared objects in two library versions and searches
+  for ABI changes that may lead to incompatibility. Breakage of the binary compatibility may result
+  in crashing or incorrect behavior of applications built with an old version of a library when
+  it is running with a new one.
+
+  ABI Compliance Checker was intended for library developers that are interested in ensuring
+  backward binary compatibility. Also it can be used for checking forward binary compatibility
+  and checking applications portability to the new library version.
+  
+  This tool is free software: you can redistribute it and/or modify it under the terms of the GNU GPL.
+
+USAGE:
+  $CmdName [options]
+
+EXAMPLE OF USE:
+  $CmdName -l <library_name> -d1 <1st_version_descriptor> -d2 <2nd_version_descriptor>
+
+GENERAL OPTIONS:
+  -h|-help
+      Print this help.
+
+  -v|-version
+      Print version.
+
+  -l|-library <name>
+      Library name (without version).
+      It affects only on the path and the title of the report.
+
+  -d1|-descriptor1 <path>
+      Path to descriptor of 1st library version.
+
+  -d2|-descriptor2 <path>
+      Path to descriptor of 2nd library version.
+
+EXTRA OPTIONS:
+  -app|-application <path>
+      This option allow to specify the application that should be tested for portability
+      to the new library version.
+
+  -dump_abi|-dump_info <descriptor_path>
+      Dump library ABI information using specified descriptor.
+      This command will create '<library>_<ver1>.abi.tar.gz' file in the directory 'abi_dumps/<library>/'.
+      You can transfer it anywhere and pass instead of library descriptor.
+
+  -headers_only
+      Check header files without shared objects. It is easy to run, but may provide
+      a low quality ABI compliance report with false positives and without
+      detecting of added/withdrawn interfaces.
+
+  -symbols_list|-int_list <path>
+      This option allow to specify a file with a list of interfaces (mangled names in C++)
+      that should be checked, other library interfaces will not be checked.
+
+OTHER OPTIONS:
+  -d|-descriptor_template
+      Create library descriptor template 'library-descriptor.xml' in the current directory.
+
+  -separately
+      Check headers individually. This mode requires more time for checking ABI compliance,
+      but possible compiler errors in one header can't affect others.
+
+  -test
+      Run internal tests (create two binary-incompatible versions of an artificial library
+      and run ABI-Compliance-Checker on it).
+
+DESCRIPTOR EXAMPLE:
+  <version>
+     1.28.0
+  </version>
+
+  <headers>
+     /usr/local/atk/atk-1.28.0/include/
+  </headers>
+
+  <libs>
+     /usr/local/atk/atk-1.28.0/lib/libatk-1.0.so
+  </libs>
+
+  <include_paths>
+     /usr/include/glib-2.0/
+     /usr/lib/glib-2.0/include/
+  </include_paths>
+
+
+Report bugs to <abi-compliance-checker\@linuxtesting.org>
+For more information, please see: http://ispras.linux-foundation.org/index.php/ABI_compliance_checker
+EOM
+      ;
+}
+
+my $Descriptor_Template = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>
+<descriptor>
+
+<!-- Template for the library version descriptor -->
+
+<!--
+     Necessary sections  
+                        -->
+
+<version>
+    <!-- Version of the library -->
+</version>
+
+<headers>
+    <!-- The list of paths to header files and/or
+         directories with header files, one per line -->
+</headers>
+
+<libs>
+    <!-- The list of paths to shared objects and/or
+         directories with shared objects, one per line -->
+</libs>
+
+<!--
+     Additional sections
+                         -->
+
+<include_paths>
+    <!-- The list of paths to be searched for header files
+         needed for compiling of library headers, one per line -->
+</include_paths>
+
+<gcc_options>
+    <!-- Additional gcc options, one per line -->
+</gcc_options>
+
+<opaque_types>
+    <!-- The list of opaque types, one per line -->
+</opaque_types>
+
+<skip_interfaces>
+    <!-- The list of functions (mangled/symbol names in C++)
+         that should be skipped while testing, one per line -->
+</skip_interfaces>
+
+<include_preamble>
+    <!-- The list of header files that should be included before other headers, one per line.
+         For example, it is a tree.h for libxml2 and ft2build.h for freetype2 -->
+</include_preamble>
+
+</descriptor>";
+
+my %Operator_Indication = (
+"not" => "~",
+"assign" => "=",
+"andassign" => "&=",
+"orassign" => "|=",
+"xorassign" => "^=",
+"or" => "|",
+"xor" => "^",
+"addr" => "&",
+"and" => "&",
+"lnot" => "!",
+"eq" => "==",
+"ne" => "!=",
+"lt" => "<",
+"lshift" => "<<",
+"lshiftassign" => "<<=",
+"rshiftassign" => ">>=",
+"call" => "()",
+"mod" => "%",
+"modassign" => "%=",
+"subs" => "[]",
+"land" => "&&",
+"lor" => "||",
+"rshift" => ">>",
+"ref" => "->",
+"le" => "<=",
+"deref" => "*",
+"mult" => "*",
+"preinc" => "++",
+"delete" => " delete",
+"vecnew" => " new[]",
+"vecdelete" => " delete[]",
+"predec" => "--",
+"postinc" => "++",
+"postdec" => "--",
+"plusassign" => "+=",
+"plus" => "+",
+"minus" => "-",
+"minusassign" => "-=",
+"gt" => ">",
+"ge" => ">=",
+"new" => " new",
+"multassign" => "*=",
+"divassign" => "/=",
+"div" => "/",
+"neg" => "-",
+"pos" => "+",
+"memref" => "->*",
+"compound" => ","
+);
+
+sub num_to_str($)
+{
+    my $Number = $_[0];
+    if(int($Number)>3)
+    {
+        return $Number."th";
+    }
+    elsif(int($Number)==1)
+    {
+        return "1st";
+    }
+    elsif(int($Number)==2)
+    {
+        return "2nd";
+    }
+    elsif(int($Number)==3)
+    {
+        return "3rd";
+    }
+    else
+    {
+        return "";
+    }
+}
+
+#Global variables
+my $REPORT_PATH;
+my %ERR_PATH;
+my $POINTER_SIZE;
+my $MAX_COMMAND_LINE_ARGUMENTS = 4096;
+my %Cache;
+my %FuncAttr;
+my %LibInfo;
+my %HeaderCompileError;
+my $StartTime;
+my %CompilerOptions;
+my %AddedInt;
+my %WithdrawnInt;
+my @RecurLib;
+my %CheckedSoLib;
+
+#Constants checking
+my %ConstantsSrc;
+my %Constants;
+
+#Types
+my %TypeDescr;
+my %TemplateInstance_Func;
+my %TemplateInstance;
+my %OpaqueTypes;
+my %Tid_TDid;
+my %CheckedTypes;
+my %Typedef_BaseName;
+my %StdCxxTypedef;
+my %TName_Tid;
+my %EnumMembName_Id;
+
+#Interfaces
+my %FuncDescr;
+my %ClassFunc;
+my %ClassVirtFunc;
+my %ClassIdVirtFunc;
+my %ClassId;
+my %tr_name;
+my %mangled_name;
+my %InternalInterfaces;
+my %InterfacesList;
+my %InterfacesList_App;
+my %CheckedInterfaces;
+my %DepInterfaces;
+
+#Headers
+my %Include_Preamble;
+my %Headers;
+my %HeaderName_Destinations;
+my %Header_Dependency;
+
+#Shared objects
+my %SoLib_DefaultPath;
+
+#Merging
+my %CompleteSignature;
+my @RecurTypes;
+my %Interface_Library;
+my %Library_Interface;
+my %Language;
+my %SoNames_All;
+my $Version;
+
+#Symbols versioning
+my %SymVer;
+
+#Problem descriptions
+my %CompatProblems;
+my %ConstantProblems;
+
+#Rerorts
+my $ContentID = 1;
+my $ContentSpanStart = "<span class=\"section\" onclick=\"javascript:showContent(this, 'CONTENT_ID')\">\n";
+my $ContentSpanEnd = "</span>\n";
+my $ContentDivStart = "<div id=\"CONTENT_ID\" style=\"display:none;\">\n";
+my $ContentDivEnd = "</div>\n";
+my $Content_Counter = 0;
+
+sub readDescriptor($)
+{
+    my $LibVersion = $_[0];
+    if(not -e $Descriptor{$LibVersion}{"Path"})
+    {
+        return;
+    }
+    my $Descriptor_File = readFile($Descriptor{$LibVersion}{"Path"});
+    $Descriptor_File =~ s/\/\*(.|\n)+?\*\///g;
+    $Descriptor_File =~ s/<\!--(.|\n)+?-->//g;
+    if(not $Descriptor_File)
+    {
+        print "ERROR: descriptor d$LibVersion is empty\n";
+        exit(1);
+    }
+    $Descriptor{$LibVersion}{"Version"} = parseTag(\$Descriptor_File, "version");
+    if(not $Descriptor{$LibVersion}{"Version"})
+    {
+        print "ERROR: version in the descriptor d$LibVersion was not specified (section <version>)\n\n";
+        exit(1);
+    }
+    $Descriptor{$LibVersion}{"Headers"} = parseTag(\$Descriptor_File, "headers");
+    if(not $Descriptor{$LibVersion}{"Headers"})
+    {
+        print "ERROR: header files in the descriptor d$LibVersion were not specified (section <headers>)\n";
+        exit(1);
+    }
+    if(not $CheckHeadersOnly)
+    {
+        $Descriptor{$LibVersion}{"Libs"} = parseTag(\$Descriptor_File, "libs");
+        if(not $Descriptor{$LibVersion}{"Libs"})
+        {
+            print "ERROR: shared objects in the descriptor d$LibVersion were not specified (section <libs>)\n";
+            exit(1);
+        }
+    }
+    $Descriptor{$LibVersion}{"Include_Paths"} = parseTag(\$Descriptor_File, "include_paths");
+    $Descriptor{$LibVersion}{"Gcc_Options"} = parseTag(\$Descriptor_File, "gcc_options");
+    foreach my $Option (split("\n", $Descriptor{$LibVersion}{"Gcc_Options"}))
+    {
+        $Option =~ s/\A\s+|\s+\Z//g;
+        next if(not $Option);
+        $CompilerOptions{$LibVersion} .= " ".$Option;
+    }
+    $Descriptor{$LibVersion}{"Opaque_Types"} = parseTag(\$Descriptor_File, "opaque_types");
+    foreach my $Type_Name (split("\n", $Descriptor{$LibVersion}{"Opaque_Types"}))
+    {
+        $Type_Name =~ s/\A\s+|\s+\Z//g;
+        next if(not $Type_Name);
+        $OpaqueTypes{$LibVersion}{$Type_Name} = 1;
+    }
+    $Descriptor{$LibVersion}{"Skip_interfaces"} = parseTag(\$Descriptor_File, "skip_interfaces");
+    foreach my $Interface_Name (split("\n", $Descriptor{$LibVersion}{"Skip_interfaces"}))
+    {
+        $Interface_Name =~ s/\A\s+|\s+\Z//g;
+        next if(not $Interface_Name);
+        $InternalInterfaces{$LibVersion}{$Interface_Name} = 1;
+    }
+    $Descriptor{$LibVersion}{"Include_Preamble"} = parseTag(\$Descriptor_File, "include_preamble");
+    my $Position = 0;
+    foreach my $Header_Name (split("\n", $Descriptor{$LibVersion}{"Include_Preamble"}))
+    {
+        $Header_Name =~ s/\A\s+|\s+\Z//g;
+        next if(not $Header_Name);
+        $Include_Preamble{$LibVersion}{$Header_Name}{"Position"} = $Position;
+        $Position+=1;
+    }
+    my $Descriptors_Dir = "descriptors_storage/$TargetLibraryName";
+    system("mkdir", "-p", $Descriptors_Dir);
+    my $Descriptor_Name = $TargetLibraryName."_".$Descriptor{$LibVersion}{"Version"}.".desc";
+    if($Descriptor{$LibVersion}{"Path"} ne $Descriptors_Dir."/".$Descriptor_Name)
+    {
+        system("cp", "-f", $Descriptor{$LibVersion}{"Path"}, $Descriptors_Dir."/".$Descriptor_Name);
+    }
+    $ERR_PATH{$LibVersion} = "header_compile_errors/$TargetLibraryName/".$Descriptor{$LibVersion}{"Version"};
+}
+
+sub parseTag($$)
+{
+    my ($CodeRef, $Tag) = @_;
+    return "" if(not $CodeRef or not ${$CodeRef} or not $Tag);
+    if(${$CodeRef} =~ s/\<$Tag\>((.|\n)+?)\<\/$Tag\>//)
+    {
+        my $Content = $1;
+        $Content=~s/(\A\s+|\s+\Z)//g;
+        return $Content;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+my %check_node=(
+"array_type"=>1,
+"binfo"=>1,
+"boolean_type"=>1,
+"complex_type"=>1,
+"const_decl"=>1,
+"enumeral_type"=>1,
+"field_decl"=>1,
+"function_decl"=>1,
+"function_type"=>1,
+"identifier_node"=>1,
+"integer_cst"=>1,
+"integer_type"=>1,
+"method_type"=>1,
+"namespace_decl"=>1,
+"parm_decl"=>1,
+"pointer_type"=>1,
+"real_cst"=>1,
+"real_type"=>1,
+"record_type"=>1,
+"reference_type"=>1,
+"string_cst"=>1,
+"template_decl"=>1,
+"template_type_parm"=>1,
+"tree_list"=>1,
+"tree_vec"=>1,
+"type_decl"=>1,
+"union_type"=>1,
+"var_decl"=>1,
+"void_type"=>1);
+
+sub getInfo($)
+{
+	my $InfoPath = $_[0];
+    return if(not $InfoPath or not -f $InfoPath);
+    my $InfoPath_New = $InfoPath.".1";
+    #my $Keywords = join("\\|", keys(%check_node));#|grep "$Keywords"
+    system("sed ':a;N;\$!ba;s/\\n[^\@]//g' ".esc($InfoPath)."|sed 's/ [ ]\\+/  /g' > ".esc($InfoPath_New));
+    system("rm", "-fr", $InfoPath);
+    #getting info
+    open(INFO, $InfoPath_New) || die ("can't open file '\$InfoPath_New\': $!\n");
+    while(<INFO>)
+    {
+        chomp;
+        if(/\A@([0-9]+)[ ]+([a-zA-Z_]+)[ ]+(.*)\Z/)
+        {
+            next if(not $check_node{$2});
+            $LibInfo{$Version}{$1}{"info_type"}=$2;
+            $LibInfo{$Version}{$1}{"info"}=$3;
+        }
+    }
+    close(INFO);
+    system("rm", "-fr", $InfoPath_New);
+    #processing info
+	setTemplateParams_All();
+	getTypeDescr_All();
+	getFuncDescr_All();
+	getVarDescr_All();
+    %LibInfo = ();
+    %TemplateInstance = ();
+}
+
+sub setTemplateParams_All()
+{
+    foreach (keys(%{$LibInfo{$Version}}))
+    {
+        if($LibInfo{$Version}{$_}{"info_type"} eq "template_decl")
+        {
+            setTemplateParams($_);
+        }
+    }
+}
+
+sub setTemplateParams($)
+{
+    my $TypeInfoId = $_[0];
+    my $Info = $LibInfo{$Version}{$TypeInfoId}{"info"};
+    if($Info =~ /(inst|spcs)[ ]*:[ ]*@([0-9]+) /)
+    {
+        my $TmplInst_InfoId = $2;
+        setTemplateInstParams($TmplInst_InfoId);
+        my $TmplInst_Info = $LibInfo{$Version}{$TmplInst_InfoId}{"info"};
+        while($TmplInst_Info =~ /chan[ ]*:[ ]*@([0-9]+) /)
+        {
+            $TmplInst_InfoId = $1;
+            $TmplInst_Info = $LibInfo{$Version}{$TmplInst_InfoId}{"info"};
+            setTemplateInstParams($TmplInst_InfoId);
+        }
+    }
+}
+
+sub setTemplateInstParams($)
+{
+    my $TmplInst_Id = $_[0];
+    my $Info = $LibInfo{$Version}{$TmplInst_Id}{"info"};
+    my ($Params_InfoId, $ElemId) = ();
+    if($Info =~ /purp[ ]*:[ ]*@([0-9]+) /)
+    {
+        $Params_InfoId = $1;
+    }
+    if($Info =~ /valu[ ]*:[ ]*@([0-9]+) /)
+    {
+        $ElemId = $1;
+    }
+    if($Params_InfoId and $ElemId)
+    {
+        my $Params_Info = $LibInfo{$Version}{$Params_InfoId}{"info"};
+        while($Params_Info =~ s/ ([0-9]+)[ ]*:[ ]*@([0-9]+) //)
+        {
+            my ($Param_Pos, $Param_TypeId) = ($1, $2);
+            return if($LibInfo{$Version}{$Param_TypeId}{"info_type"} eq "template_type_parm");
+            if($LibInfo{$ElemId}{"info_type"} eq "function_decl")
+            {
+                $TemplateInstance_Func{$Version}{$ElemId}{$Param_Pos} = $Param_TypeId;
+            }
+            else
+            {
+                $TemplateInstance{$Version}{getTypeDeclId($ElemId)}{$ElemId}{$Param_Pos} = $Param_TypeId;
+            }
+        }
+    }
+}
+
+sub getTypeDeclId($)
+{
+	my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
+	if($TypeInfo =~ /name[ ]*:[ ]*@([0-9]+)/)
+    {
+        return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub isFuncPtr($)
+{
+    my $Ptd = pointTo($_[0]);
+	if($Ptd)
+	{
+		if(($LibInfo{$Version}{$_[0]}{"info"} =~ m/unql[ ]*:/) and not ($LibInfo{$Version}{$_[0]}{"info"} =~ m/qual[ ]*:/))
+		{
+			return 0;
+		}
+		elsif(($LibInfo{$Version}{$_[0]}{"info_type"} eq "pointer_type") and ($LibInfo{$Version}{$Ptd}{"info_type"} eq "function_type" or $LibInfo{$Version}{$Ptd}{"info_type"} eq "method_type"))
+		{
+			return 1;
+		}
+		else
+		{
+			return 0;
+		}
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+sub pointTo($)
+{
+	my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
+	if($TypeInfo =~ /ptd[ ]*:[ ]*@([0-9]+)/)
+    {
+	    return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getTypeDescr_All()
+{
+    foreach (sort {int($a)<=>int($b)} keys(%{$LibInfo{$Version}}))
+    {
+        if($LibInfo{$Version}{$_}{"info_type"}=~/_type\Z/ and $LibInfo{$Version}{$_}{"info_type"}!~/function_type|method_type/)
+        {
+            getTypeDescr(getTypeDeclId($_), $_);
+        }
+    }
+    $TypeDescr{$Version}{""}{-1}{"Name"} = "...";
+    $TypeDescr{$Version}{""}{-1}{"Type"} = "Intrinsic";
+    $TypeDescr{$Version}{""}{-1}{"Tid"} = -1;
+}
+
+sub getTypeDescr($$)
+{
+    my ($TypeDeclId, $TypeId) = @_;
+    $Tid_TDid{$Version}{$TypeId} = $TypeDeclId;
+    %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}} = getTypeAttr($TypeDeclId, $TypeId);
+    if(not $TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"})
+    {
+        delete($TypeDescr{$Version}{$TypeDeclId}{$TypeId});
+        return;
+    }
+    if(not $TName_Tid{$Version}{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"}})
+    {
+        $TName_Tid{$Version}{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"}} = $TypeId;
+    }
+}
+
+sub getTypeAttr($$)
+{
+    my ($TypeDeclId, $TypeId) = @_;
+    my ($BaseTypeSpec, %TypeAttr) = ();
+    if($TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"})
+    {
+        return %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}};
+    }
+    $TypeAttr{"Tid"} = $TypeId;
+    $TypeAttr{"TDid"} = $TypeDeclId;
+    $TypeAttr{"Type"} = getTypeType($TypeDeclId, $TypeId);
+    if($TypeAttr{"Type"} eq "Unknown")
+    {
+        return ();
+    }
+    elsif($TypeAttr{"Type"} eq "FuncPtr")
+    {
+        %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}} = getFuncPtrAttr(pointTo($TypeId), $TypeDeclId, $TypeId);
+        $TName_Tid{$Version}{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"}} = $TypeId;
+        return %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}};
+    }
+    elsif($TypeAttr{"Type"} eq "Array")
+    {
+        ($TypeAttr{"BaseType"}{"Tid"}, $TypeAttr{"BaseType"}{"TDid"}, $BaseTypeSpec) = selectBaseType($TypeDeclId, $TypeId);
+        my %BaseTypeAttr = getTypeAttr($TypeAttr{"BaseType"}{"TDid"}, $TypeAttr{"BaseType"}{"Tid"});
+        my $ArrayElemNum = getSize($TypeId)/8;
+        $ArrayElemNum = $ArrayElemNum/$BaseTypeAttr{"Size"} if($BaseTypeAttr{"Size"});
+        $TypeAttr{"Size"} = $ArrayElemNum;
+        if($ArrayElemNum)
+        {
+            $TypeAttr{"Name"} = $BaseTypeAttr{"Name"}."[".$ArrayElemNum."]";
+        }
+        else
+        {
+            $TypeAttr{"Name"} = $BaseTypeAttr{"Name"}."[]";
+        }
+        $TypeAttr{"Name"} = correctName($TypeAttr{"Name"});
+        $TypeAttr{"Library"} = $BaseTypeAttr{"Library"};
+        $TypeAttr{"Header"} = $BaseTypeAttr{"Header"};
+        %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}} = %TypeAttr;
+        $TName_Tid{$Version}{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"}} = $TypeId;
+        return %TypeAttr;
+    }
+    elsif($TypeAttr{"Type"} =~ /Intrinsic|Union|Struct|Enum|Class/)
+    {
+        if($TemplateInstance{$Version}{$TypeDeclId}{$TypeId})
+        {
+            my @Template_Params = ();
+            foreach my $Param_Pos (sort {int($a)<=>int($b)} keys(%{$TemplateInstance{$Version}{$TypeDeclId}{$TypeId}}))
+            {
+                my $Type_Id = $TemplateInstance{$Version}{$TypeDeclId}{$TypeId}{$Param_Pos};
+                my $Param = get_TemplateParam($Type_Id);
+                if($Param eq "")
+                {
+                    return ();
+                }
+                @Template_Params = (@Template_Params, $Param);
+            }
+            %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}} = getTrivialTypeAttr($TypeDeclId, $TypeId);
+            $TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"} = $TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"}."< ".join(", ", @Template_Params)." >";
+            $TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"} = correctName($TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"});
+            $TName_Tid{$Version}{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"}} = $TypeId;
+            return %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}};
+        }
+        else
+        {
+            %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}} = getTrivialTypeAttr($TypeDeclId, $TypeId);
+            return %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}};
+        }
+    }
+    else
+    {
+        ($TypeAttr{"BaseType"}{"Tid"}, $TypeAttr{"BaseType"}{"TDid"}, $BaseTypeSpec) = selectBaseType($TypeDeclId, $TypeId);
+        my %BaseTypeAttr = getTypeAttr($TypeAttr{"BaseType"}{"TDid"}, $TypeAttr{"BaseType"}{"Tid"});
+        if($BaseTypeSpec and $BaseTypeAttr{"Name"})
+        {
+            if(($TypeAttr{"Type"} eq "Pointer") and $BaseTypeAttr{"Name"}=~/\([\*]+\)/)
+            {
+                $TypeAttr{"Name"} = $BaseTypeAttr{"Name"};
+                $TypeAttr{"Name"} =~ s/\(([*]+)\)/($1*)/g;
+            }
+            else
+            {
+                $TypeAttr{"Name"} = $BaseTypeAttr{"Name"}." ".$BaseTypeSpec;
+            }
+        }
+        elsif($BaseTypeAttr{"Name"})
+        {
+            $TypeAttr{"Name"} = $BaseTypeAttr{"Name"};
+        }
+        if($TypeAttr{"Type"} eq "Typedef")
+        {
+            $TypeAttr{"Name"} = getNameByInfo($TypeDeclId);
+            $TypeAttr{"NameSpace"} = getNameSpace($TypeDeclId);
+            if($TypeAttr{"NameSpace"})
+            {
+                $TypeAttr{"Name"} = $TypeAttr{"NameSpace"}."::".$TypeAttr{"Name"};
+            }
+            ($TypeAttr{"Header"}, $TypeAttr{"Line"}) = getLocation($TypeDeclId);
+            if($TypeAttr{"NameSpace"}=~/\Astd(::|\Z)/ and $BaseTypeAttr{"NameSpace"}=~/\Astd(::|\Z)/)
+            {
+                $StdCxxTypedef{$Version}{$BaseTypeAttr{"Name"}} = $TypeAttr{"Name"};
+            }
+            $Typedef_BaseName{$Version}{$TypeAttr{"Name"}} = $BaseTypeAttr{"Name"};
+        }
+        if(not $TypeAttr{"Size"})
+        {
+            if($TypeAttr{"Type"} eq "Pointer")
+            {
+                $TypeAttr{"Size"} = $POINTER_SIZE;
+            }
+            else
+            {
+                $TypeAttr{"Size"} = $BaseTypeAttr{"Size"};
+            }
+        }
+        $TypeAttr{"Name"} = correctName($TypeAttr{"Name"});
+        $TypeAttr{"Library"} = $BaseTypeAttr{"Library"};
+        $TypeAttr{"Header"} = $BaseTypeAttr{"Header"} if(not $TypeAttr{"Header"});
+        %{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}} = %TypeAttr;
+        $TName_Tid{$Version}{$TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"Name"}} = $TypeId;
+        return %TypeAttr;
+    }
+}
+
+sub get_TemplateParam($)
+{
+    my $Type_Id = $_[0];
+    if(getNodeType($Type_Id) eq "integer_cst")
+    {
+        return getNodeIntCst($Type_Id);
+    }
+    elsif(getNodeType($Type_Id) eq "string_cst")
+    {
+        return getNodeStrCst($Type_Id);
+    }
+    else
+    {
+        my $Type_DId = getTypeDeclId($Type_Id);
+        my %ParamAttr = getTypeAttr($Type_DId, $Type_Id);
+        if(not $ParamAttr{"Name"})
+        {
+            return "";
+        }
+        if($ParamAttr{"Name"}=~/\>/)
+        {
+            if($StdCxxTypedef{$Version}{$ParamAttr{"Name"}})
+            {
+                return $StdCxxTypedef{$Version}{$ParamAttr{"Name"}};
+            }
+            elsif(my $Covered = cover_stdcxx_typedef($ParamAttr{"Name"}))
+            {
+                return $Covered;
+            }
+            else
+            {
+                return $ParamAttr{"Name"};
+            }
+        }
+        else
+        {
+            return $ParamAttr{"Name"};
+        }
+    }
+}
+
+sub cover_stdcxx_typedef($)
+{
+    my $TypeName = $_[0];
+    my $TypeName_Covered = $TypeName;
+    while($TypeName=~s/>[ ]*(const|volatile|restrict| |\*|\&)\Z/>/g){};
+    if(my $Cover = $StdCxxTypedef{$Version}{$TypeName})
+    {
+        $TypeName = esc_l($TypeName);
+        $TypeName_Covered=~s/$TypeName/$Cover /g;
+    }
+    return correctName($TypeName_Covered);
+}
+
+sub getNodeType($)
+{
+    return $LibInfo{$Version}{$_[0]}{"info_type"};
+}
+
+sub getNodeIntCst($)
+{
+    my $CstId = $_[0];
+    my $CstTypeId = getTreeAttr($CstId, "type");
+    if($EnumMembName_Id{$Version}{$CstId})
+    {
+        return $EnumMembName_Id{$Version}{$CstId};
+    }
+    elsif($LibInfo{$Version}{$_[0]}{"info"} =~ /low[ ]*:[ ]*([^ ]+) /)
+    {
+        if($1 eq "0")
+        {
+            if(getNodeType($CstTypeId) eq "boolean_type")
+            {
+                return "false";
+            }
+            else
+            {
+                return "0";
+            }
+        }
+        elsif($1 eq "1")
+        {
+            if(getNodeType($CstTypeId) eq "boolean_type")
+            {
+                return "true";
+            }
+            else
+            {
+                return "1";
+            }
+        }
+        else
+        {
+            return $1;
+        }
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getNodeStrCst($)
+{
+    if($LibInfo{$Version}{$_[0]}{"info"} =~ /low[ ]*:[ ]*(.+)[ ]+lngt/)
+    {
+        return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub esc_l($)
+{
+    my $String = $_[0];
+    $String=~s/([()*])/\\$1/g;
+    return $String;
+}
+
+sub getFuncPtrAttr($$$)
+{
+    my ($FuncTypeId, $TypeDeclId, $TypeId) = @_;
+    my $FuncInfo = $LibInfo{$Version}{$FuncTypeId}{"info"};
+    my $FuncInfo_Type = $LibInfo{$Version}{$FuncTypeId}{"info_type"};
+    my $FuncPtrCorrectName = "";
+    my %TypeAttr = ("Size"=>$POINTER_SIZE, "Type"=>"FuncPtr", "TDid"=>$TypeDeclId, "Tid"=>$TypeId);
+    my @ParamTypeName;
+    if($FuncInfo =~ /retn[ ]*:[ ]*\@([0-9]+) /)
+    {
+        my $ReturnTypeId = $1;
+        my %ReturnAttr = getTypeAttr(getTypeDeclId($ReturnTypeId), $ReturnTypeId);
+        $FuncPtrCorrectName .= $ReturnAttr{"Name"};
+        $TypeAttr{"Return"} = $ReturnTypeId;
+    }
+    if($FuncInfo =~ /prms[ ]*:[ ]*@([0-9]+) /)
+    {
+        my $ParamTypeInfoId = $1;
+        my $Position = 0;
+        while($ParamTypeInfoId)
+        {
+            my $ParamTypeInfo = $LibInfo{$Version}{$ParamTypeInfoId}{"info"};
+            last if($ParamTypeInfo !~ /valu[ ]*:[ ]*@([0-9]+) /);
+            my $ParamTypeId = $1;
+            my %ParamAttr = getTypeAttr(getTypeDeclId($ParamTypeId), $ParamTypeId);
+            last if($ParamAttr{"Name"} eq "void");
+            $TypeAttr{"Memb"}{$Position}{"type"} = $ParamTypeId;
+            push(@ParamTypeName, $ParamAttr{"Name"});
+            last if($ParamTypeInfo !~ /chan[ ]*:[ ]*@([0-9]+) /);
+            $ParamTypeInfoId = $1;
+            $Position+=1;
+        }
+    }
+    if($FuncInfo_Type eq "function_type")
+    {
+        $FuncPtrCorrectName .= " (*) (".join(", ", @ParamTypeName).")";
+    }
+    elsif($FuncInfo_Type eq "method_type")
+    {
+        if($FuncInfo =~ /clas[ ]*:[ ]*@([0-9]+) /)
+        {
+            my $ClassId = $1;
+            my $ClassName = $TypeDescr{$Version}{getTypeDeclId($ClassId)}{$ClassId}{"Name"};
+            if($ClassName)
+            {
+                $FuncPtrCorrectName .= " ($ClassName\:\:*) (".join(", ", @ParamTypeName).")";
+            }
+            else
+            {
+                $FuncPtrCorrectName .= " (*) (".join(", ", @ParamTypeName).")";
+            }
+        }
+        else
+        {
+            $FuncPtrCorrectName .= " (*) (".join(", ", @ParamTypeName).")";
+        }
+    }
+    $TypeAttr{"Name"} = correctName($FuncPtrCorrectName);
+    return %TypeAttr;
+}
+
+sub getTypeName($)
+{
+	my $Info = $LibInfo{$Version}{$_[0]}{"info"};
+	if($Info =~ /name[ ]*:[ ]*@([0-9]+) /)
+	{
+		return getNameByInfo($1);
+	}
+	else
+	{
+		if($LibInfo{$Version}{$_[0]}{"info_type"} eq "integer_type")
+		{
+			if($LibInfo{$Version}{$_[0]}{"info"} =~ /unsigned/)
+			{
+				return "unsigned int";
+			}
+			else
+			{
+				return "int";
+			}
+		}
+		else
+		{
+			return "";
+		}
+	}
+}
+
+sub selectBaseType($$)
+{
+	my ($TypeDeclId, $TypeId) = @_;
+	my $TypeInfo = $LibInfo{$Version}{$TypeId}{"info"};
+	my $BaseTypeDeclId;
+    my $Type_Type = getTypeType($TypeDeclId, $TypeId);
+	#qualifications
+	if(($LibInfo{$Version}{$TypeId}{"info"} =~ /qual[ ]*:[ ]*c /) and ($LibInfo{$Version}{$TypeId}{"info"} =~ /unql[ ]*:[ ]*\@([0-9]+) /))
+	{
+		return ($1, getTypeDeclId($1), "const");
+	}
+	elsif(($LibInfo{$Version}{$TypeId}{"info"} =~ /qual[ ]*:[ ]*r /) and ($LibInfo{$Version}{$TypeId}{"info"} =~ /unql[ ]*:[ ]*\@([0-9]+) /))
+	{
+		return ($1, getTypeDeclId($1), "restrict");
+	}
+	elsif(($LibInfo{$Version}{$TypeId}{"info"} =~ /qual[ ]*:[ ]*v /) and ($LibInfo{$Version}{$TypeId}{"info"} =~ /unql[ ]*:[ ]*\@([0-9]+) /))
+	{
+		return ($1, getTypeDeclId($1), "volatile");
+	}
+	elsif((not ($LibInfo{$Version}{$TypeId}{"info"} =~ /qual[ ]*:/)) and ($LibInfo{$Version}{$TypeId}{"info"} =~ /unql[ ]*:[ ]*\@([0-9]+) /))
+	{#typedefs
+		return ($1, getTypeDeclId($1), "");
+	}
+	elsif($LibInfo{$Version}{$TypeId}{"info_type"} eq "reference_type")
+	{
+		if($TypeInfo =~ /refd[ ]*:[ ]*@([0-9]+) /)
+        {
+		    return ($1, getTypeDeclId($1), "&");
+        }
+        else
+        {
+            return (0, 0, "");
+        }
+	}
+	elsif($LibInfo{$Version}{$TypeId}{"info_type"} eq "array_type")
+	{
+		if($TypeInfo =~ /elts[ ]*:[ ]*@([0-9]+) /)
+        {
+		    return ($1, getTypeDeclId($1), "");
+        }
+        else
+        {
+            return (0, 0, "");
+        }
+	}
+	elsif($LibInfo{$Version}{$TypeId}{"info_type"} eq "pointer_type")
+	{
+		if($TypeInfo =~ /ptd[ ]*:[ ]*@([0-9]+) /)
+        {
+		    return ($1, getTypeDeclId($1), "*");
+        }
+        else
+        {
+            return (0, 0, "");
+        }
+	}
+	else
+	{
+		return (0, 0, "");
+	}
+}
+
+sub getFuncDescr_All()
+{
+	foreach (sort {int($b)<=>int($a)} keys(%{$LibInfo{$Version}}))
+	{
+		if($LibInfo{$Version}{$_}{"info_type"} eq "function_decl")
+		{
+			getFuncDescr($_);
+		}
+	}
+}
+
+sub getVarDescr_All()
+{
+	foreach (sort {int($b)<=>int($a)} keys(%{$LibInfo{$Version}}))
+	{
+		if($LibInfo{$Version}{$_}{"info_type"} eq "var_decl")
+		{
+			getVarDescr($_);
+		}
+	}
+}
+
+sub getVarDescr($)
+{
+	my $FuncInfoId = $_[0];
+    if($LibInfo{$Version}{getNameSpaceId($FuncInfoId)}{"info_type"} eq "function_decl")
+    {
+        return;
+    }
+    ($FuncDescr{$Version}{$FuncInfoId}{"Header"}, $FuncDescr{$Version}{$FuncInfoId}{"Line"}) = getLocation($FuncInfoId);
+    if((not $FuncDescr{$Version}{$FuncInfoId}{"Header"}) or ($FuncDescr{$Version}{$FuncInfoId}{"Header"}=~/\<built\-in\>|\<internal\>/))
+    {
+        delete($FuncDescr{$Version}{$FuncInfoId});
+        return;
+    }
+    $FuncDescr{$Version}{$FuncInfoId}{"ShortName"} = getNameByInfo($FuncInfoId);
+    $FuncDescr{$Version}{$FuncInfoId}{"MnglName"} = getFuncMnglName($FuncInfoId);
+    if($FuncDescr{$Version}{$FuncInfoId}{"MnglName"} and $FuncDescr{$Version}{$FuncInfoId}{"MnglName"}!~/\A_Z/)
+    {
+        delete($FuncDescr{$Version}{$FuncInfoId});
+        return;
+    }
+    if(not $FuncDescr{$Version}{$FuncInfoId}{"MnglName"})
+    {
+        $FuncDescr{$Version}{$FuncInfoId}{"Name"} = $FuncDescr{$Version}{$FuncInfoId}{"ShortName"};
+        $FuncDescr{$Version}{$FuncInfoId}{"MnglName"} = $FuncDescr{$Version}{$FuncInfoId}{"ShortName"};
+    }
+    if(not is_in_library($FuncDescr{$Version}{$FuncInfoId}{"MnglName"}, $Version) and not $CheckHeadersOnly)
+    {
+        delete $FuncDescr{$Version}{$FuncInfoId};
+        return;
+    }
+	$FuncDescr{$Version}{$FuncInfoId}{"Return"} = getTypeId($FuncInfoId);
+    delete($FuncDescr{$Version}{$FuncInfoId}{"Return"}) if(not $FuncDescr{$Version}{$FuncInfoId}{"Return"});
+	$FuncDescr{$Version}{$FuncInfoId}{"Data"} = 1;
+	set_Class_And_Namespace($FuncInfoId);
+	setFuncAccess($FuncInfoId);
+	if($FuncDescr{$Version}{$FuncInfoId}{"MnglName"} =~ /\A_ZTV/)
+    {
+        delete($FuncDescr{$Version}{$FuncInfoId}{"Return"});
+    }
+    if($FuncDescr{$Version}{$FuncInfoId}{"ShortName"} =~ /\A_Z/)
+    {
+        delete($FuncDescr{$Version}{$FuncInfoId}{"ShortName"});
+    }
+}
+
+sub getTrivialTypeAttr($$)
+{
+	my ($TypeInfoId, $TypeId) = @_;
+    my %TypeAttr = ();
+    return if(getTypeTypeByTypeId($TypeId)!~/Intrinsic|Union|Struct|Enum/);
+	setTypeAccess($TypeId, \%TypeAttr);
+	($TypeAttr{"Header"}, $TypeAttr{"Line"}) = getLocation($TypeInfoId);
+	if(($TypeAttr{"Header"} eq "<built-in>") or ($TypeAttr{"Header"} eq "<internal>"))
+	{
+        delete($TypeAttr{"Header"});
+	}
+    $TypeAttr{"Name"} = getNameByInfo($TypeInfoId);
+    $TypeAttr{"Name"} = getTypeName($TypeId) if(not $TypeAttr{"Name"});
+    my $NameSpaceId = getNameSpaceId($TypeInfoId);
+    if($NameSpaceId ne $TypeId)
+    {
+        $TypeAttr{"NameSpace"} = getNameSpace($TypeInfoId);
+    }
+    if($TypeAttr{"NameSpace"} and isNotAnon($TypeAttr{"Name"}))
+    {
+        $TypeAttr{"Name"} = $TypeAttr{"NameSpace"}."::".$TypeAttr{"Name"};
+    }
+    $TypeAttr{"Name"} = correctName($TypeAttr{"Name"});
+	if(isAnon($TypeAttr{"Name"}))
+	{
+		$TypeAttr{"Name"} = "anon-";
+		$TypeAttr{"Name"} .= $TypeAttr{"Header"}."-".$TypeAttr{"Line"};
+	}
+	$TypeAttr{"Size"} = getSize($TypeId)/8;
+	$TypeAttr{"Type"} = getTypeType($TypeInfoId, $TypeId);
+    if($TypeAttr{"Type"} eq "Struct" and has_methods($TypeId))
+    {
+        $TypeAttr{"Type"} = "Class";
+    }
+    if(($TypeAttr{"Type"} eq "Struct") or ($TypeAttr{"Type"} eq "Class"))
+    {
+        setBaseClasses($TypeInfoId, $TypeId, \%TypeAttr);
+    }
+	setTypeMemb($TypeInfoId, $TypeId, \%TypeAttr);
+    $TypeAttr{"Tid"} = $TypeId;
+    $TypeAttr{"TDid"} = $TypeInfoId;
+    $Tid_TDid{$Version}{$TypeId} = $TypeInfoId;
+    if(not $TName_Tid{$Version}{$TypeAttr{"Name"}})
+    {
+        $TName_Tid{$Version}{$TypeAttr{"Name"}} = $TypeId;
+    }
+    return %TypeAttr;
+}
+
+sub has_methods($)
+{
+    my $TypeId = $_[0];
+    my $Info = $LibInfo{$Version}{$TypeId}{"info"};
+    return ($Info=~/(fncs)[ ]*:[ ]*@([0-9]+) /);
+}
+
+sub setBaseClasses($$$)
+{
+    my ($TypeInfoId, $TypeId, $TypeAttr) = @_;
+    my $Info = $LibInfo{$Version}{$TypeId}{"info"};
+    if($Info =~ /binf[ ]*:[ ]*@([0-9]+) /)
+    {
+        $Info = $LibInfo{$Version}{$1}{"info"};
+        while($Info =~ /accs[ ]*:[ ]*([a-z]+) /)
+        {
+            last if($Info !~ s/accs[ ]*:[ ]*([a-z]+) //);
+            my $Access = $1;
+            last if($Info !~ s/binf[ ]*:[ ]*@([0-9]+) //);
+            my $BInfoId = $1;
+            my $ClassId = getBinfClassId($BInfoId);
+            if($Access eq "pub")
+            {
+                $TypeAttr->{"BaseClass"}{$ClassId} = "public";
+            }
+            elsif($Access eq "prot")
+            {
+                $TypeAttr->{"BaseClass"}{$ClassId} = "protected";
+            }
+            elsif($Access eq "priv")
+            {
+                $TypeAttr->{"BaseClass"}{$ClassId} = "private";
+            }
+            else
+            {
+                $TypeAttr->{"BaseClass"}{$ClassId} = "private";
+            }
+        }
+    }
+}
+
+sub getBinfClassId($)
+{
+    my $Info = $LibInfo{$Version}{$_[0]}{"info"};
+    $Info =~ /type[ ]*:[ ]*@([0-9]+) /;
+    return $1;
+}
+
+sub get_func_signature($)
+{
+    my $FuncInfoId = $_[0];
+    my $PureSignature = $FuncDescr{$Version}{$FuncInfoId}{"ShortName"};
+    my @ParamTypes = ();
+    foreach my $ParamPos (sort {int($a) <=> int($b)} keys(%{$FuncDescr{$Version}{$FuncInfoId}{"Param"}}))
+    {#checking parameters
+        my $ParamType_Id = $FuncDescr{$Version}{$FuncInfoId}{"Param"}{$ParamPos}{"type"};
+        my $ParamType_Name = uncover_typedefs($TypeDescr{$Version}{getTypeDeclId($ParamType_Id)}{$ParamType_Id}{"Name"});
+        @ParamTypes = (@ParamTypes, $ParamType_Name);
+    }
+    $PureSignature = $PureSignature."(".join(", ", @ParamTypes).")";
+    $PureSignature = delete_keywords($PureSignature);
+    return correctName($PureSignature);
+}
+
+sub delete_keywords($)
+{
+    my $TypeName = $_[0];
+    $TypeName =~ s/(\W|\A)(enum |struct |union |class )/$1/g;
+    return $TypeName;
+}
+
+sub uncover_typedefs($)
+{
+    my $TypeName = $_[0];
+    return "" if(not $TypeName);
+    return $Cache{"uncover_typedefs"}{$Version}{$TypeName} if(defined $Cache{"uncover_typedefs"}{$Version}{$TypeName});
+    my ($TypeName_New, $TypeName_Pre) = (correctName($TypeName), "");
+    while($TypeName_New ne $TypeName_Pre)
+    {
+        $TypeName_Pre = $TypeName_New;
+        my $TypeName_Copy = $TypeName_New;
+        my %Words = ();
+        while($TypeName_Copy=~s/(\W|\A)([a-z_][\w:]*)(\W|\Z)//io)
+        {
+            my $Word = $2;
+            next if(not $Word or $Word=~/\A(true|false|const|int|long|void|short|float|unsigned|char|double|class|struct|union|enum)\Z/);
+            $Words{$Word} = 1;
+        }
+        foreach my $Word (keys(%Words))
+        {
+            my $BaseType_Name = $Typedef_BaseName{$Version}{$Word};
+            next if($TypeName_New=~/(\W|\A)(struct $Word|union $Word|enum $Word)(\W|\Z)/);
+            next if(not $BaseType_Name);
+            if($BaseType_Name=~/\([*]+\)/)
+            {
+                $TypeName_New =~ /$Word(.*)\Z/;
+                my $Type_Suffix = $1;
+                $TypeName_New = $BaseType_Name;
+                if($TypeName_New =~ s/\(([*]+)\)/($1 $Type_Suffix)/)
+                {
+                    $TypeName_New = correctName($TypeName_New);
+                }
+            }
+            else
+            {
+                if($TypeName_New =~ s/(\W|\A)$Word(\W|\Z)/$1$BaseType_Name$2/g)
+                {
+                    $TypeName_New = correctName($TypeName_New);
+                }
+            }
+        }
+    }
+    $Cache{"uncover_typedefs"}{$Version}{$TypeName} = $TypeName_New;
+    return $TypeName_New;
+}
+
+sub isInternal($)
+{
+    my $FuncInfoId = $_[0];
+    my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
+    return 0 if($FuncInfo !~ /mngl[ ]*:[ ]*@([0-9]+) /);
+    my $FuncMnglNameInfoId = $1;
+    return ($LibInfo{$Version}{$FuncMnglNameInfoId}{"info"} =~ /\*[ ]*INTERNAL[ ]*\*/);
+}
+
+sub set_Class_And_Namespace($)
+{
+    my $FuncInfoId = $_[0];
+    my $FuncInfo = $LibInfo{$Version}{$FuncInfoId}{"info"};
+    if($FuncInfo =~ /scpe[ ]*:[ ]*@([0-9]+) /)
+    {
+        my $NameSpaceInfoId = $1;
+        if($LibInfo{$Version}{$NameSpaceInfoId}{"info_type"} eq "namespace_decl")
+        {
+            my $NameSpaceInfo = $LibInfo{$Version}{$NameSpaceInfoId}{"info"};
+            if($NameSpaceInfo =~ /name[ ]*:[ ]*@([0-9]+) /)
+            {
+                my $NameSpaceId = $1;
+                my $NameSpaceIdentifier = $LibInfo{$Version}{$NameSpaceId}{"info"};
+                if($NameSpaceIdentifier =~ /strg[ ]*:[ ]*(.*)[ ]+lngt/)
+                {
+                    my $NameSpace = $1;
+                    $NameSpace =~ s/[ ]+\Z//g;
+                    $FuncDescr{$Version}{$FuncInfoId}{"NameSpace"} = $NameSpace;
+                }
+            }
+        }
+        elsif($LibInfo{$Version}{$NameSpaceInfoId}{"info_type"} eq "record_type")
+        {
+            $FuncDescr{$Version}{$FuncInfoId}{"Class"} = $NameSpaceInfoId;
+        }
+    }
+}
+
+sub getFuncDescr($)
+{
+	my $FuncInfoId = $_[0];
+    return if(isInternal($FuncInfoId));
+    ($FuncDescr{$Version}{$FuncInfoId}{"Header"}, $FuncDescr{$Version}{$FuncInfoId}{"Line"}) = getLocation($FuncInfoId);
+    if(not $FuncDescr{$Version}{$FuncInfoId}{"Header"} or $FuncDescr{$Version}{$FuncInfoId}{"Header"}=~/\<built\-in\>|\<internal\>/)
+    {
+        delete($FuncDescr{$Version}{$FuncInfoId});
+        return;
+    }
+    setFuncAccess($FuncInfoId);
+	setFuncKind($FuncInfoId);
+	if($FuncDescr{$Version}{$FuncInfoId}{"PseudoTemplate"})
+    {
+        delete($FuncDescr{$Version}{$FuncInfoId});
+        return;
+    }
+    $FuncDescr{$Version}{$FuncInfoId}{"Type"} = getFuncType($FuncInfoId);
+    $FuncDescr{$Version}{$FuncInfoId}{"Return"} = getFuncReturn($FuncInfoId);
+    delete($FuncDescr{$Version}{$FuncInfoId}{"Return"}) if(not $FuncDescr{$Version}{$FuncInfoId}{"Return"});
+    $FuncDescr{$Version}{$FuncInfoId}{"ShortName"} = getFuncShortName(getFuncOrig($FuncInfoId));
+    if($FuncDescr{$Version}{$FuncInfoId}{"ShortName"} =~ /\._/)
+    {
+        delete($FuncDescr{$Version}{$FuncInfoId});
+        return;
+    }
+    if(defined $TemplateInstance_Func{$Version}{$FuncInfoId})
+    {
+        my @TmplParams = ();
+        foreach my $ParamPos (sort {int($a) <=> int($b)} keys(%{$TemplateInstance_Func{$Version}{$FuncInfoId}}))
+        {
+            my $Param = get_TemplateParam($TemplateInstance_Func{$Version}{$FuncInfoId}{$ParamPos});
+            if($Param eq "")
+            {
+                delete($FuncDescr{$Version}{$FuncInfoId});
+                return;
+            }
+            push(@TmplParams, $Param);
+        }
+        $FuncDescr{$Version}{$FuncInfoId}{"ShortName"} .= "<".join(", ", @TmplParams).">";
+    }
+    setFuncParams($FuncInfoId);
+    $FuncDescr{$Version}{$FuncInfoId}{"MnglName"} = getFuncMnglName($FuncInfoId);
+    if($FuncDescr{$Version}{$FuncInfoId}{"MnglName"} and $FuncDescr{$Version}{$FuncInfoId}{"MnglName"}!~/\A_Z/)
+    {
+        delete($FuncDescr{$Version}{$FuncInfoId});
+        return;
+    }
+    
+    if((is_in_library($FuncDescr{$Version}{$FuncInfoId}{"ShortName"}, $Version) or $CheckHeadersOnly) and not $FuncDescr{$Version}{$FuncInfoId}{"MnglName"} and ($FuncDescr{$Version}{$FuncInfoId}{"Type"} eq "Function"))
+    {
+        $FuncDescr{$Version}{$FuncInfoId}{"MnglName"} = $FuncDescr{$Version}{$FuncInfoId}{"ShortName"};
+    }
+    set_Class_And_Namespace($FuncInfoId);
+    if(not $FuncDescr{$Version}{$FuncInfoId}{"MnglName"} and not $FuncDescr{$Version}{$FuncInfoId}{"Class"})
+    {#this section only for c++ functions without class that have not been mangled in the tree
+        $FuncDescr{$Version}{$FuncInfoId}{"MnglName"} = $mangled_name{get_func_signature($FuncInfoId)};
+    }
+    if(not is_in_library($FuncDescr{$Version}{$FuncInfoId}{"MnglName"}, $Version) and not $CheckHeadersOnly)
+    {#src only
+        delete($FuncDescr{$Version}{$FuncInfoId});
+        return;
+    }
+    if($FuncDescr{$Version}{$FuncInfoId}{"Constructor"} or $FuncDescr{$Version}{$FuncInfoId}{"Destructor"})
+    {
+        delete($FuncDescr{$Version}{$FuncInfoId}{"Return"});
+    }
+    my $FuncBody = getFuncBody($FuncInfoId);
+    if($FuncBody eq "defined")
+    {
+        $FuncDescr{$Version}{$FuncInfoId}{"InLine"} = 1;
+    }
+    if($CheckHeadersOnly and $FuncDescr{$Version}{$FuncInfoId}{"InLine"})
+    {
+        delete($FuncDescr{$Version}{$FuncInfoId});
+        return;
+    }
+    if(($FuncDescr{$Version}{$FuncInfoId}{"Type"} eq "Method") or $FuncDescr{$Version}{$FuncInfoId}{"Constructor"} or $FuncDescr{$Version}{$FuncInfoId}{"Destructor"})
+    {
+        if($FuncDescr{$Version}{$FuncInfoId}{"MnglName"}!~/\A_Z/)
+        {
+            delete($FuncDescr{$Version}{$FuncInfoId});
+            return;
+        }
+    }
+	if(getFuncSpec($FuncInfoId) eq "Virt")
+	{#virtual methods
+		$FuncDescr{$Version}{$FuncInfoId}{"Virt"} = 1;
+	}
+	if(getFuncSpec($FuncInfoId) eq "PureVirt")
+	{#pure virtual methods
+		$FuncDescr{$Version}{$FuncInfoId}{"PureVirt"} = 1;
+	}
+    if($FuncDescr{$Version}{$FuncInfoId}{"MnglName"} =~ /\A_Z/ and $FuncDescr{$Version}{$FuncInfoId}{"Class"})
+    {
+	    if($FuncDescr{$Version}{$FuncInfoId}{"Type"} eq "Function")
+	    {#static methods
+		    $FuncDescr{$Version}{$FuncInfoId}{"Static"} = 1;
+	    }
+    }
+	if(getFuncLink($FuncInfoId) eq "Static")
+    {
+        $FuncDescr{$Version}{$FuncInfoId}{"Static"} = 1;
+    }
+    delete($FuncDescr{$Version}{$FuncInfoId}{"Type"});
+}
+
+sub getFuncBody($)
+{
+    my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
+    if($FuncInfo =~ /body[ ]*:[ ]*undefined(\ |\Z)/i)
+    {
+        return "undefined";
+    }
+    elsif($FuncInfo =~ /body[ ]*:[ ]*@([0-9]+)(\ |\Z)/i)
+    {
+        return "defined";
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getTypeShortName($)
+{
+	my $TypeName = $_[0];
+	$TypeName =~ s/\<.*\>//g;
+	$TypeName =~ s/.*\:\://g;
+	return $TypeName;
+}
+
+sub getBackRef($)
+{
+	my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
+	if($TypeInfo =~ /name[ ]*:[ ]*@([0-9]+) /)
+    {
+	    return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getTypeId($)
+{
+	my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
+	if($TypeInfo =~ /type[ ]*:[ ]*@([0-9]+) /)
+    {
+	    return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getFuncId($)
+{
+	my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
+	if($FuncInfo =~ /type[ ]*:[ ]*@([0-9]+) /)
+    {
+	    return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub setTypeMemb($$)
+{
+    my ($TypeDeclId, $TypeId, $TypeAttr) = @_;
+	my $TypeInfo = $LibInfo{$Version}{$TypeId}{"info"};
+	my $TypeMembInfoId;
+	my $TypeType = $TypeAttr->{"Type"};
+	my $Position = 0;
+    my $BasePosition = 0;
+	my $TypeTypeInfoId;
+	my $StructMembName;
+	if($TypeType eq "Enum")
+	{
+		$TypeMembInfoId = getEnumMembInfoId($TypeId);
+		while($TypeMembInfoId)
+		{
+			$TypeAttr->{"Memb"}{$Position}{"value"} = getEnumMembVal($TypeMembInfoId);
+            my $MembName = getEnumMembName($TypeMembInfoId);
+			$TypeAttr->{"Memb"}{$Position}{"name"} = getEnumMembName($TypeMembInfoId);
+            $EnumMembName_Id{$Version}{getTreeAttr($TypeMembInfoId, "valu")} = ($TypeAttr->{"NameSpace"})?$TypeAttr->{"NameSpace"}."::".$MembName:$MembName;
+			$TypeMembInfoId = getNextMembInfoId($TypeMembInfoId);
+			$Position += 1;
+		}
+	}
+	elsif(($TypeType eq "Struct") or ($TypeType eq "Class") or ($TypeType eq "Union"))
+	{
+		$TypeMembInfoId = getStructMembInfoId($TypeId);
+		while($TypeMembInfoId)
+		{
+            if($LibInfo{$Version}{$TypeMembInfoId}{"info_type"} ne "field_decl")
+            {
+                $TypeMembInfoId = getNextStructMembInfoId($TypeMembInfoId);
+                next;
+            }
+            $StructMembName = getStructMembName($TypeMembInfoId);
+            if($StructMembName =~ /_vptr\./)
+            {#virtual tables
+                $TypeMembInfoId = getNextStructMembInfoId($TypeMembInfoId);
+                next;
+            }
+            if(not $StructMembName)
+            {#base classes
+                #$TypeAttr->{"Base"}{$BasePosition}{"type"} = getStructMembType($TypeMembInfoId);
+                #$TypeAttr->{"Base"}{$BasePosition}{"access"} = getStructMembAccess($TypeMembInfoId);
+                $BasePosition += 1;
+                $TypeMembInfoId = getNextStructMembInfoId($TypeMembInfoId);
+                next;
+            }
+            $TypeAttr->{"Memb"}{$Position}{"type"} = getStructMembType($TypeMembInfoId);
+            $TypeAttr->{"Memb"}{$Position}{"name"} = $StructMembName;
+            $TypeAttr->{"Memb"}{$Position}{"access"} = getStructMembAccess($TypeMembInfoId);
+            $TypeAttr->{"Memb"}{$Position}{"bitfield"} = getStructMembBitFieldSize($TypeMembInfoId);
+            
+			$TypeMembInfoId = getNextStructMembInfoId($TypeMembInfoId);
+			$Position += 1;
+		}
+	}
+}
+
+sub setFuncParams($)
+{
+	my $FuncInfoId = $_[0];
+	my $ParamInfoId = getFuncParamInfoId($FuncInfoId);
+	my $FunctionType = getFuncType($FuncInfoId);
+	if($FunctionType eq "Method")
+	{
+		$ParamInfoId = getNextElem($ParamInfoId);
+	}
+    my $Position = 0;
+	while($ParamInfoId)
+	{
+		my $ParamTypeId = getFuncParamType($ParamInfoId);
+		last if($TypeDescr{$Version}{getTypeDeclId($ParamTypeId)}{$ParamTypeId}{"Name"} eq "void");
+		if($TypeDescr{$Version}{getTypeDeclId($ParamTypeId)}{$ParamTypeId}{"Type"} eq "Restrict")
+		{#delete restrict spec
+			$ParamTypeId = getRestrictBase($ParamTypeId);
+		}
+		$FuncDescr{$Version}{$FuncInfoId}{"Param"}{$Position}{"type"} = $ParamTypeId;
+		$FuncDescr{$Version}{$FuncInfoId}{"Param"}{$Position}{"name"} = getFuncParamName($ParamInfoId);
+        if(not $FuncDescr{$Version}{$FuncInfoId}{"Param"}{$Position}{"name"})
+        {
+            $FuncDescr{$Version}{$FuncInfoId}{"Param"}{$Position}{"name"} = "p".($Position+1);
+        }
+		$ParamInfoId = getNextElem($ParamInfoId);
+		$Position += 1;
+	}
+    if(detect_nolimit_args($FuncInfoId))
+    {
+        $FuncDescr{$Version}{$FuncInfoId}{"Param"}{$Position}{"type"} = -1;
+    }
+}
+
+sub detect_nolimit_args($)
+{
+    my $FuncInfoId = $_[0];
+    my $FuncTypeId = getFuncTypeId($FuncInfoId);
+    my $ParamListElemId = getFuncParamTreeListId($FuncTypeId);
+    my $HaveVoid = 0;
+    my $Position = 0;
+    while($ParamListElemId)
+    {
+        my $ParamTypeId = getTreeAttr($ParamListElemId, "valu");
+        if($TypeDescr{$Version}{getTypeDeclId($ParamTypeId)}{$ParamTypeId}{"Name"} eq "void")
+        {
+            $HaveVoid = 1;
+            last;
+        }
+        $ParamListElemId = getNextElem($ParamListElemId);
+        $Position += 1;
+    }
+    return ($Position>=1 and not $HaveVoid);
+}
+
+sub getFuncParamTreeListId($)
+{
+    my $FuncTypeId = $_[0];
+    if($LibInfo{$Version}{$FuncTypeId}{"info"} =~ /prms[ ]*:[ ]*@([0-9]+) /)
+    {
+        return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getTreeAttr($$)
+{
+    my ($Id, $Attr) = @_;
+    if($LibInfo{$Version}{$Id}{"info"} =~ /$Attr[ ]*:[ ]*@([0-9]+) /)
+    {
+        return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getRestrictBase($)
+{
+	my $TypeId = $_[0];
+	my $TypeDeclId = getTypeDeclId($TypeId);
+	my $BaseTypeId = $TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"BaseType"}{"Tid"};
+	my $BaseTypeDeclId = $TypeDescr{$Version}{$TypeDeclId}{$TypeId}{"BaseType"}{"TDid"};
+	return $BaseTypeId;
+}
+
+sub setFuncAccess($)
+{
+	my $FuncInfoId = $_[0];
+    if($LibInfo{$Version}{$FuncInfoId}{"info"} =~ /accs[ ]*:[ ]*([a-zA-Z]+) /)
+    {
+        my $Access = $1;
+        if($Access eq "prot")
+        {
+            $FuncDescr{$Version}{$FuncInfoId}{"Protected"} = 1;
+        }
+        elsif($Access eq "priv")
+        {
+            $FuncDescr{$Version}{$FuncInfoId}{"Private"} = 1;
+        }
+    }
+}
+
+sub setTypeAccess($$)
+{
+    my ($TypeId, $TypeAttr) = @_;
+	my $TypeInfo = $LibInfo{$Version}{$TypeId}{"info"};
+	if($TypeInfo =~ /accs[ ]*:[ ]*([a-zA-Z]+) /)
+    {
+	    my $Access = $1;
+	    if($Access eq "prot")
+	    {
+		    $TypeAttr->{"Protected"} = 1;
+	    }
+	    elsif($Access eq "priv")
+	    {
+		    $TypeAttr->{"Private"} = 1;
+	    }
+    }
+}
+
+sub setFuncKind($)
+{
+	my $FuncInfoId = $_[0];
+    if($LibInfo{$Version}{$FuncInfoId}{"info"} =~ /pseudo tmpl/)
+    {
+        $FuncDescr{$Version}{$FuncInfoId}{"PseudoTemplate"} = 1;
+    }
+    elsif($LibInfo{$Version}{$FuncInfoId}{"info"} =~ /note[ ]*:[ ]*constructor /)
+    {
+        $FuncDescr{$Version}{$FuncInfoId}{"Constructor"} = 1;
+    }
+    elsif($LibInfo{$Version}{$FuncInfoId}{"info"} =~ /note[ ]*:[ ]*destructor /)
+    {
+        $FuncDescr{$Version}{$FuncInfoId}{"Destructor"} = 1;
+    }
+}
+
+sub getFuncSpec($)
+{
+	my $FuncInfoId = $_[0];
+	my $FuncInfo = $LibInfo{$Version}{$FuncInfoId}{"info"};
+	if($FuncInfo =~ m/spec[ ]*:[ ]*pure /)
+	{
+		return "PureVirt";
+	}
+	elsif($FuncInfo =~ m/spec[ ]*:[ ]*virt /)
+	{
+		return "Virt";
+	}
+	else
+	{
+		if($FuncInfo =~ /spec[ ]*:[ ]*([a-zA-Z]+) /)
+        {
+		    return $1;
+        }
+        else
+        {
+            return "";
+        }
+	}
+}
+
+sub getFuncClass($)
+{
+	my $FuncInfoId = $_[0];
+	my $FuncInfo = $LibInfo{$Version}{$FuncInfoId}{"info"};
+	if($FuncInfo =~ /scpe[ ]*:[ ]*@([0-9]+) /)
+    {
+        return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getFuncLink($)
+{
+	my $FuncInfoId = $_[0];
+	my $FuncInfo = $LibInfo{$Version}{$FuncInfoId}{"info"};
+	if($FuncInfo =~ /link[ ]*:[ ]*static /)
+	{
+		return "Static";
+	}
+	else
+	{
+		if($FuncInfo =~ /link[ ]*:[ ]*([a-zA-Z]+) /)
+        {
+            return $1;
+        }
+        else
+        {
+            return "";
+        }
+	}
+}
+
+sub getNextElem($)
+{
+	my $FuncInfoId = $_[0];
+	my $FuncInfo = $LibInfo{$Version}{$FuncInfoId}{"info"};
+	if($FuncInfo =~ /chan[ ]*:[ ]*@([0-9]+) /)
+    {
+        return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getFuncParamInfoId($)
+{
+	my $FuncInfoId = $_[0];
+	my $FuncInfo = $LibInfo{$Version}{$FuncInfoId}{"info"};
+	if($FuncInfo =~ /args[ ]*:[ ]*@([0-9]+) /)
+    {
+        return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getFuncParamType($)
+{
+	my $ParamInfoId = $_[0];
+	my $ParamInfo = $LibInfo{$Version}{$ParamInfoId}{"info"};
+	if($ParamInfo =~ /type[ ]*:[ ]*@([0-9]+) /)
+    {
+        return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getFuncParamName($)
+{
+	my $ParamInfoId = $_[0];
+	my $ParamInfo = $LibInfo{$Version}{$ParamInfoId}{"info"};
+	return "" if($ParamInfo !~ /name[ ]*:[ ]*@([0-9]+) /);
+	my $NameInfoId = $1;
+	return "" if($LibInfo{$Version}{$NameInfoId}{"info"} !~ /strg[ ]*:[ ]*(.*)[ ]+lngt/);
+	my $FuncParamName = $1;
+	$FuncParamName =~ s/[ ]+\Z//g;
+	return $FuncParamName;
+}
+
+sub getEnumMembInfoId($)
+{
+	my $TypeInfoId = $_[0];
+	my $TypeInfo = $LibInfo{$Version}{$TypeInfoId}{"info"};
+	if($TypeInfo =~ /csts[ ]*:[ ]*@([0-9]+) /)
+    {
+        return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getStructMembInfoId($)
+{
+	my $TypeInfoId = $_[0];
+	my $TypeInfo = $LibInfo{$Version}{$TypeInfoId}{"info"};
+	if($TypeInfo =~ /flds[ ]*:[ ]*@([0-9]+) /)
+    {
+        return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getNameSpace($)
+{
+    my $TypeInfoId = $_[0];
+    my $TypeInfo = $LibInfo{$Version}{$TypeInfoId}{"info"};
+    return "" if($TypeInfo !~ /scpe[ ]*:[ ]*@([0-9]+) /);
+    my $NameSpaceInfoId = $1;
+    if($LibInfo{$Version}{$NameSpaceInfoId}{"info_type"} eq "namespace_decl")
+    {
+        my $NameSpaceInfo = $LibInfo{$Version}{$NameSpaceInfoId}{"info"};
+        if($NameSpaceInfo =~ /name[ ]*:[ ]*@([0-9]+) /)
+        {
+            my $NameSpaceId = $1;
+            my $NameSpaceIdentifier = $LibInfo{$Version}{$NameSpaceId}{"info"};
+            return "" if($NameSpaceIdentifier !~ /strg[ ]*:[ ]*(.*)[ ]+lngt/);
+            my $NameSpace = $1;
+            $NameSpace =~ s/[ ]+\Z//g;
+            my $BaseNameSpace = getNameSpace($NameSpaceInfoId);
+            $NameSpace = $BaseNameSpace."::".$NameSpace if($BaseNameSpace);
+            return $NameSpace;
+        }
+        else
+        {
+            return "";
+        }
+    }
+    elsif($LibInfo{$Version}{$NameSpaceInfoId}{"info_type"} eq "record_type")
+    {
+        my %NameSpaceAttr = getTypeAttr(getTypeDeclId($NameSpaceInfoId), $NameSpaceInfoId);
+        return $NameSpaceAttr{"Name"};
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getNameSpaceId($)
+{
+	my $TypeInfoId = $_[0];
+	my $TypeInfo = $LibInfo{$Version}{$TypeInfoId}{"info"};
+	if($TypeInfo =~ /scpe[ ]*:[ ]*@([0-9]+) /)
+    {
+	    return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getEnumMembName($)
+{
+	my $TypeMembInfoId = $_[0];
+	return "" if($LibInfo{$Version}{$TypeMembInfoId}{"info"} !~ /purp[ ]*:[ ]*@([0-9]+)/);
+	my $Purp = $1;
+	return "" if($LibInfo{$Version}{$Purp}{"info"} !~ /strg[ ]*:[ ]*(.*)[ ]+lngt/);
+	my $EnumMembName = $1;
+	$EnumMembName =~ s/[ ]+\Z//g;
+	return $EnumMembName;
+}
+
+sub getStructMembName($)
+{
+	my $TypeMembInfoId = $_[0];
+	return "" if($LibInfo{$Version}{$TypeMembInfoId}{"info"} !~ /name[ ]*:[ ]*@([0-9]+) /);
+	my $NameInfoId = $1;
+	return "" if($LibInfo{$Version}{$NameInfoId}{"info"} !~ /strg[ ]*:[ ]*(.*)[ ]+lngt/);
+	my $StructMembName = $1;
+	$StructMembName =~ s/[ ]+\Z//g;
+	return $StructMembName;
+}
+
+sub getEnumMembVal($)
+{
+	my $TypeMembInfoId = $_[0];
+	return "" if($LibInfo{$Version}{$TypeMembInfoId}{"info"} !~ /valu[ ]*:[ ]*@([0-9]+) /);
+	my $Valu = $1;
+	if($LibInfo{$Version}{$Valu}{"info"} =~ /low[ ]*:[ ]*(-?[0-9]+) /)
+    {
+        return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getSize($)
+{
+	my $Info = $LibInfo{$Version}{$_[0]}{"info"};
+	if($Info =~ /size[ ]*:[ ]*@([0-9]+) /)
+	{
+        my $SizeInfoId = $1;
+		if($LibInfo{$Version}{$SizeInfoId}{"info"} =~ /low[ ]*:[ ]*(-?[0-9]+) /)
+        {
+		    return $1;
+        }
+        else
+        {
+            return "";
+        }
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+sub getStructMembType($)
+{
+	my $TypeMembInfoId = $_[0];
+	if($LibInfo{$Version}{$TypeMembInfoId}{"info"} =~ /type[ ]*:[ ]*@([0-9]+) /)
+    {
+        return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getStructMembBitFieldSize($)
+{
+	my $TypeMembInfoId = $_[0];
+	if($LibInfo{$Version}{$TypeMembInfoId}{"info"} =~ / bitfield /)
+	{
+		return getSize($TypeMembInfoId);
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+sub getStructMembAccess($)
+{
+	my $MembInfo = $LibInfo{$Version}{$_[0]}{"info"};
+	if($MembInfo =~ /accs[ ]*:[ ]*([a-zA-Z]+) /)
+    {
+	    my $Access = $1;
+	    if($Access eq "prot")
+	    {
+		    return "protected";
+	    }
+	    elsif($Access eq "priv")
+	    {
+		    return "private";
+	    }
+	    else
+	    {
+		    return "public";
+	    }
+    }
+    else
+    {
+        return "public";
+    }
+}
+
+sub getNextMembInfoId($)
+{
+	my $TypeMembInfoId = $_[0];
+	if($LibInfo{$Version}{$TypeMembInfoId}{"info"} =~ /chan[ ]*:[ ]*@([0-9]+) /)
+    {
+        return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getNextStructMembInfoId($)
+{
+	my $TypeMembInfoId = $_[0];
+	if($LibInfo{$Version}{$TypeMembInfoId}{"info"} =~ /chan[ ]*:[ ]*@([0-9]+) /)
+    {
+        return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub fieldHasName($)
+{
+	my $TypeMembInfoId = $_[0];
+	if($LibInfo{$Version}{$TypeMembInfoId}{"info_type"} eq "field_decl")
+	{
+		if($LibInfo{$Version}{$TypeMembInfoId}{"info"} =~ /name[ ]*:[ ]*@([0-9]+) /)
+        {
+            return $1;
+        }
+        else
+        {
+            return "";
+        }
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+sub getTypeHeader($)
+{
+	my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
+	if($TypeInfo =~ /srcp[ ]*:[ ]*([0-9a-zA-Z\_\-\<\>\.\+]+):([0-9]+) /)
+    {
+        return ($1, $2);
+    }
+    else
+    {
+        return ();
+    }
+}
+
+sub register_header($$$)
+{
+    my ($Destination, $Position, $LibVersion) = @_;
+    return if(not $Destination);
+    if($Destination=~/\A\// and not -f $Destination)
+    {
+        print "\nERROR: specified header \'$Destination\' does not exist\n";
+        return;
+    }
+    my $Header_Name = get_FileName($Destination);
+    $Headers{$LibVersion}{$Destination}{"Name"} = $Header_Name;
+    $Headers{$LibVersion}{$Destination}{"Position"} = $Position;
+    $Headers{$LibVersion}{$Destination}{"Identity"} = $Destination;
+    $HeaderName_Destinations{$LibVersion}{$Header_Name}{$Destination} = 1;
+}
+
+sub headerSearch($)
+{
+    my $LibVersion = $_[0];
+    foreach my $Dest (split("\n", $Descriptor{$LibVersion}{"Include_Paths"}))
+    {
+        $Dest =~ s/\A\s+|\s+\Z//g;
+        next if(not $Dest);
+        if(not -e $Dest)
+        {
+            print "ERROR: can't access \'$Dest\'\n";
+        }
+        $Header_Dependency{$LibVersion}{$Dest} = 1;
+    }
+    foreach my $Dest (split("\n", $Descriptor{$LibVersion}{"Headers"}))
+    {#fill %Header_Dependency
+        if(-d $Dest)
+        {
+            foreach my $Dir (cmd_find($Dest,"d",""))
+            {
+                chomp($Dir);
+                $Header_Dependency{$LibVersion}{$Dir} = 1;
+            }
+        }
+        elsif(-f $Dest)
+        {
+            $Header_Dependency{$LibVersion}{get_Dir($Dest)} = 1;
+        }
+    }
+    my $Position = 0;
+	foreach my $Dest (split("\n", $Descriptor{$LibVersion}{"Headers"}))
+	{
+        $Dest =~ s/\A\s+|\s+\Z//g;
+        next if(not $Dest);
+        if(is_header($Dest, $LibVersion))
+        {
+            register_header($Dest, $Position, $LibVersion);
+            $Position += 1;
+        }
+        elsif(-d $Dest)
+        {
+            foreach my $Destination (sort {lc($a) cmp lc($b)} (cmd_find($Dest,"f","")))
+            {
+                chomp($Destination);
+                next if(not is_header($Destination, $LibVersion));
+                register_header($Destination, $Position, $LibVersion);
+                $Position += 1;
+            }
+        }
+        else
+        {
+            print "WARNING: \'$Dest\' was not found in the specified include paths\n";
+            register_header($Dest, $Position, $LibVersion);
+            $Position += 1;
+        }
+	}
+    if(keys(%{$Headers{$LibVersion}})==1)
+    {
+        my $Destination = (keys(%{$Headers{$LibVersion}}))[0];
+        $Headers{$LibVersion}{$Destination}{"Identity"} = $Headers{$LibVersion}{$Destination}{"Name"};
+    }
+    foreach my $Header_Name (keys(%{$HeaderName_Destinations{$LibVersion}}))
+    {#set relative paths (for dublicates)
+        if(keys(%{$HeaderName_Destinations{$LibVersion}{$Header_Name}})>1)
+        {
+            my $FirstDest = (keys(%{$HeaderName_Destinations{$LibVersion}{$Header_Name}}))[0];
+            my $Prefix = get_Dir($FirstDest);
+            while($Prefix =~ /\A(.+)\/[^\/]+\Z/)
+            {
+                my $NewPrefix = $1;
+                my $Changes_Number = 0;
+                my %Identity = ();
+                foreach my $Dest (keys(%{$HeaderName_Destinations{$LibVersion}{$Header_Name}}))
+                {
+                    if($Dest =~ /\A$Prefix\/(.*)\Z/)
+                    {
+                        $Identity{$Dest} = $1;
+                        $Changes_Number+=1;
+                    }
+                }
+                if($Changes_Number eq keys(%{$HeaderName_Destinations{$LibVersion}{$Header_Name}}))
+                {
+                    foreach my $Dest (keys(%{$HeaderName_Destinations{$LibVersion}{$Header_Name}}))
+                    {
+                        $Headers{$LibVersion}{$Dest}{"Identity"} = $Identity{$Dest};
+                    }
+                    last;
+                }
+                $Prefix = $NewPrefix;
+            }
+        }
+    }
+    if(not keys(%{$Headers{$LibVersion}}))
+    {
+        print "ERROR: header files were not found\n";
+        exit(1);
+    }
+}
+
+sub get_FileName($)
+{
+    my $Path = $_[0];
+    if($Path =~ /\A(.*\/)([^\/]*)\Z/)
+    {
+        return $2;
+    }
+    else
+    {
+        return $Path;
+    }
+}
+
+sub get_Dir($)
+{
+    my $Path = $_[0];
+    return "" if($Path =~ m*\A\./*);
+    if($Path =~ /\A(.*)\/([^\/]*)\Z/)
+    {
+        return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub esc($)
+{
+	my $Str = $_[0];
+	$Str =~ s/([()\[\]{}$ &'"`;,<>])/\\$1/g;
+	return $Str;
+}
+
+sub getLocation($)
+{
+	my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
+	if($TypeInfo =~ /srcp[ ]*:[ ]*([0-9a-zA-Z\_\-\<\>\.\+]+):([0-9]+) /)
+    {
+	    return ($1, $2);
+    }
+    else
+    {
+        return ();
+    }
+}
+
+sub getHeader($)
+{
+    my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
+    if($TypeInfo =~ /srcp[ ]*:[ ]*([0-9a-zA-Z\_\-\<\>\.\+]+):([0-9]+) /)
+    {
+        return $1;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getLine($)
+{
+    my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
+    if($TypeInfo =~ /srcp[ ]*:[ ]*([0-9a-zA-Z\_\-\<\>\.\+]+):([0-9]+) /)
+    {
+        return $2;
+    }
+    else
+    {
+        return "";
+    }
+}
+
+sub getTypeType($$)
+{
+	my ($TypeDeclId, $TypeId) = @_;
+	return "Const" if($LibInfo{$Version}{$TypeId}{"info"} =~ /qual[ ]*:[ ]*c / and $LibInfo{$Version}{$TypeId}{"info"} =~ /unql[ ]*:[ ]*\@/);
+	return "Typedef" if($LibInfo{$Version}{$TypeId}{"info"} =~ /unql[ ]*:/ and $LibInfo{$Version}{$TypeId}{"info"} !~ /qual[ ]*:/);
+	return "Volatile" if($LibInfo{$Version}{$TypeId}{"info"} =~ /qual[ ]*:[ ]*v / and $LibInfo{$Version}{$TypeId}{"info"} =~ /unql[ ]*:[ ]*\@/);
+	return "Restrict" if($LibInfo{$Version}{$TypeId}{"info"} =~ /qual[ ]*:[ ]*r / and $LibInfo{$Version}{$TypeId}{"info"} =~ /unql[ ]*:[ ]*\@/);
+	my $TypeType = getTypeTypeByTypeId($TypeId);
+	if($TypeType eq "Struct")
+	{
+		if($TypeDeclId and $LibInfo{$Version}{$TypeDeclId}{"info_type"} eq "template_decl")
+        {
+            return "Template";
+        }
+        else
+        {
+            return "Struct";
+        }
+	}
+	else
+	{
+		return $TypeType;
+	}
+	
+}
+
+sub getTypeTypeByTypeId($)
+{
+	my $TypeId = $_[0];
+	my $TypeType = $LibInfo{$Version}{$TypeId}{"info_type"};
+	if($TypeType =~ /integer_type|real_type|boolean_type|void_type|complex_type/)
+	{
+		return "Intrinsic";
+	}
+	elsif(isFuncPtr($TypeId))
+	{
+		return "FuncPtr";
+	}
+	elsif($TypeType eq "pointer_type")
+	{
+		return "Pointer";
+	}
+	elsif($TypeType eq "reference_type")
+	{
+		return "Ref";
+	}
+	elsif($TypeType eq "union_type")
+	{
+		return "Union";
+	}
+	elsif($TypeType eq "enumeral_type")
+	{
+		return "Enum";
+	}
+	elsif($TypeType eq "record_type")
+	{
+		return "Struct";
+	}
+	elsif($TypeType eq "array_type")
+	{
+		return "Array";
+	}
+	elsif($TypeType eq "complex_type")
+	{
+		return "Intrinsic";
+	}
+	elsif($TypeType eq "function_type")
+	{
+		return "FunctionType";
+	}
+    elsif($TypeType eq "method_type")
+    {
+        return "MethodType";
+    }
+	else
+	{
+		return "Unknown";
+	}
+}
+
+sub getNameByInfo($)
+{
+	my $TypeInfo = $LibInfo{$Version}{$_[0]}{"info"};
+	return "" if($TypeInfo !~ /name[ ]*:[ ]*@([0-9]+) /);
+	my $TypeNameInfoId = $1;
+	return "" if($LibInfo{$Version}{$TypeNameInfoId}{"info"} !~ /strg[ ]*:[ ]*(.*)[ ]+lngt/);
+	my $TypeName = $1;
+	$TypeName =~ s/[ ]+\Z//g;
+	return $TypeName;
+}
+
+sub getFuncShortName($)
+{
+	my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
+    if($FuncInfo =~ / operator /)
+    {
+        if($FuncInfo =~ /note[ ]*:[ ]*conversion /)
+        {
+            return "operator ".get_TypeName($FuncDescr{$Version}{$_[0]}{"Return"});
+        }
+        else
+        {
+            return "" if($FuncInfo !~ / operator[ ]+([a-zA-Z]+) /);
+            return "operator".$Operator_Indication{$1};
+        }
+    }
+    else
+    {
+        return "" if($FuncInfo !~ /name[ ]*:[ ]*@([0-9]+) /);
+        my $FuncNameInfoId = $1;
+        return "" if($LibInfo{$Version}{$FuncNameInfoId}{"info"} !~ /strg[ ]*:[ ]*([^ ]*)[ ]+lngt/);
+        return $1;
+    }
+}
+
+sub getFuncMnglName($)
+{
+	my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
+	return "" if($FuncInfo !~ /mngl[ ]*:[ ]*@([0-9]+) /);
+	my $FuncMnglNameInfoId = $1;
+	return "" if($LibInfo{$Version}{$FuncMnglNameInfoId}{"info"} !~ /strg[ ]*:[ ]*([^ ]*)[ ]+/);
+	my $FuncMnglName = $1;
+	$FuncMnglName =~ s/[ ]+\Z//g;
+	return $FuncMnglName;
+}
+
+sub getFuncReturn($)
+{
+	my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
+	return "" if($FuncInfo !~ /type[ ]*:[ ]*@([0-9]+) /);
+	my $FuncTypeInfoId = $1;
+	return "" if($LibInfo{$Version}{$FuncTypeInfoId}{"info"} !~ /retn[ ]*:[ ]*@([0-9]+) /);
+	my $FuncReturnTypeId = $1;
+	if($TypeDescr{$Version}{getTypeDeclId($FuncReturnTypeId)}{$FuncReturnTypeId}{"Type"} eq "Restrict")
+	{#delete restrict spec
+		$FuncReturnTypeId = getRestrictBase($FuncReturnTypeId);
+	}
+	return $FuncReturnTypeId;
+}
+
+sub getFuncOrig($)
+{
+	my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
+	if($FuncInfo =~ /orig[ ]*:[ ]*@([0-9]+) /)
+    {
+	    return $1;
+    }
+    else
+    {
+        return $_[0];
+    }
+}
+
+sub unmangleArray(@)
+{
+    if($#_>$MAX_COMMAND_LINE_ARGUMENTS)
+    {
+        my @Half = splice(@_, 0, ($#_+1)/2);
+        return (unmangleArray(@Half), unmangleArray(@_))
+    }
+    else
+    {
+        my $UnmangleCommand = "c++filt ".join(" ", @_);
+        return split("\n", `$UnmangleCommand`);
+    }
+}
+
+sub get_Signature($$)
+{
+	my ($Interface, $LibVersion) = @_;
+    return $Cache{"get_Signature"}{$Interface}{$LibVersion} if($Cache{"get_Signature"}{$Interface}{$LibVersion});
+    my ($MnglName, $SymbolVersion) = ($Interface, "");
+    if($Interface =~ /\A([^@]+)[\@]+([^@]+)\Z/)
+    {
+        ($MnglName, $SymbolVersion) = ($1, $2);
+    }
+    if($MnglName =~ /\A(_ZGV|_ZTI|_ZTS|_ZTT|_ZTV|_ZThn|_ZTv0_n)/)
+    {
+        $Cache{"get_Signature"}{$Interface}{$LibVersion} = $tr_name{$MnglName}.(($SymbolVersion)?"\@".$SymbolVersion:"");
+        return $Cache{"get_Signature"}{$Interface}{$LibVersion};
+    }
+    if(not $CompleteSignature{$LibVersion}{$Interface})
+    {
+        if($Interface =~ /\A_Z/)
+        {
+            $Cache{"get_Signature"}{$Interface}{$LibVersion} = $tr_name{$MnglName}.(($SymbolVersion)?"\@".$SymbolVersion:"");
+            return $Cache{"get_Signature"}{$Interface}{$LibVersion};
+        }
+        else
+        {
+            $Cache{"get_Signature"}{$Interface}{$LibVersion} = $Interface;
+            return $Interface;
+        }
+    }
+    my ($Func_Signature, @Param_Types_FromUnmangledName) = ();
+    my $ShortName = $CompleteSignature{$LibVersion}{$Interface}{"ShortName"};
+    if($Interface =~ /\A_Z/)
+    {
+        if($CompleteSignature{$LibVersion}{$Interface}{"Class"})
+        {
+            $Func_Signature = get_TypeName($CompleteSignature{$LibVersion}{$Interface}{"Class"}, $LibVersion)."::".(($CompleteSignature{$LibVersion}{$Interface}{"Destructor"})?"~":"").$ShortName;
+        }
+        else
+        {
+            $Func_Signature = $ShortName;
+        }
+        @Param_Types_FromUnmangledName = get_Signature_Parts($tr_name{$MnglName}, 0);
+    }
+    else
+    {
+        $Func_Signature = $MnglName;
+    }
+    my @ParamArray = ();
+    foreach my $Pos (sort {int($a) <=> int($b)} keys(%{$CompleteSignature{$LibVersion}{$Interface}{"Param"}}))
+    {
+        next if($Pos eq "");
+        my $ParamTypeId = $CompleteSignature{$LibVersion}{$Interface}{"Param"}{$Pos}{"type"};
+        my $ParamTypeName = $TypeDescr{$LibVersion}{$Tid_TDid{$LibVersion}{$ParamTypeId}}{$ParamTypeId}{"Name"};
+        $ParamTypeName = $Param_Types_FromUnmangledName[$Pos] if(not $ParamTypeName);
+        if(my $ParamName = $CompleteSignature{$LibVersion}{$Interface}{"Param"}{$Pos}{"name"})
+        {
+            if($ParamTypeName=~/\([*]+\)/)
+            {
+                $ParamTypeName=~s/\(([*]+)\)/\($1$ParamName\)/;
+                push(@ParamArray, $ParamTypeName);
+            }
+            else
+            {
+                push(@ParamArray, $ParamTypeName." ".$ParamName);
+            }
+        }
+        else
+        {
+            push(@ParamArray, $ParamTypeName);
+        }
+    }
+    if(not $CompleteSignature{$LibVersion}{$Interface}{"Data"})
+    {
+        if($Interface=~/\A_Z/)
+        {
+            if($CompleteSignature{$LibVersion}{$Interface}{"Constructor"})
+            {
+                if($Interface=~/C1/)
+                {
+                    $Func_Signature .= " [in-charge]";
+                }
+                elsif($Interface=~/C2/)
+                {
+                    $Func_Signature .= " [not-in-charge]";
+                }
+            }
+            elsif($CompleteSignature{$LibVersion}{$Interface}{"Destructor"})
+            {
+                if($Interface=~/D1/)
+                {
+                    $Func_Signature .= " [in-charge]";
+                }
+                elsif($Interface=~/D2/)
+                {
+                    $Func_Signature .= " [not-in-charge]";
+                }
+                elsif($Interface=~/D0/)
+                {
+                    $Func_Signature .= " [in-charge-deleting]";
+                }
+            }
+        }
+        $Func_Signature .= " (".join(", ", @ParamArray).")";
+    }
+    if($Interface=~/\A_ZNK/)
+    {
+        $Func_Signature .= " const";
+    }
+    $Func_Signature .= "\@".$SymbolVersion if($SymbolVersion);
+    $Cache{"get_Signature"}{$Interface}{$LibVersion} = $Func_Signature;
+    return $Func_Signature;
+}
+
+sub getVarNameByAttr($)
+{
+	my $FuncInfoId = $_[0];
+	my $VarName;
+	return "" if(not $FuncDescr{$Version}{$FuncInfoId}{"ShortName"});
+	if($FuncDescr{$Version}{$FuncInfoId}{"Class"})
+	{
+		$VarName .= $TypeDescr{$Version}{getTypeDeclId($FuncDescr{$Version}{$FuncInfoId}{"Class"})}{$FuncDescr{$Version}{$FuncInfoId}{"Class"}}{"Name"};
+		$VarName .= "::";
+	}
+	$VarName .= $FuncDescr{$Version}{$FuncInfoId}{"ShortName"};
+	return $VarName;
+}
+
+sub mangleFuncName($)
+{
+	my $FuncId = $_[0];
+}
+
+sub getFuncType($)
+{
+	my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
+	return "" if($FuncInfo !~ /type[ ]*:[ ]*@([0-9]+) /);
+	my $FuncTypeInfoId = $1;
+	my $FunctionType = $LibInfo{$Version}{$FuncTypeInfoId}{"info_type"};
+	if($FunctionType eq "method_type")
+	{
+		return "Method";
+	}
+	elsif($FunctionType eq "function_type")
+	{
+		return "Function";
+	}
+	else
+	{
+		return $FunctionType;
+	}
+}
+
+sub getFuncTypeId($)
+{
+    my $FuncInfo = $LibInfo{$Version}{$_[0]}{"info"};
+    if($FuncInfo =~ /type[ ]*:[ ]*@([0-9]+)( |\Z)/)
+    {
+        return $1;
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+sub isNotAnon($)
+{
+	return (not isAnon($_[0]));
+}
+
+sub isAnon($)
+{
+	return (($_[0] =~ m/\.\_[0-9]+/) or ($_[0] =~ m/anon-/));
+}
+
+sub unmangled_Compact($$)
+#Removes all non-essential (for C++ language) whitespace from a string.  If 
+#the whitespace is essential it will be replaced with exactly one ' ' 
+#character. Works correctly only for unmangled names.
+#If level > 1 is supplied, can relax its intent to compact the string.
+{
+  my $result=$_[0];
+  my $level = $_[1] || 1;
+  my $o1 = ($level>1)?' ':'';
+  #First, we reduce all spaces that we can
+  my $coms='[-()<>:*&~!|+=%@~"?.,/[^'."']";
+  my $coms_nobr='[-()<:*&~!|+=%@~"?.,'."']";
+  my $clos='[),;:\]]';
+  $result=~s/^\s+//gm;
+  $result=~s/\s+$//gm;
+  $result=~s/((?!\n)\s)+/ /g;
+  $result=~s/(\w+)\s+($coms+)/$1$o1$2/gm;
+  #$result=~s/(\w)(\()/$1$o1$2/gm if $o1;
+  $result=~s/($coms+)\s+(\w+)/$1$o1$2/gm;
+  $result=~s/(\()\s+(\w)/$1$2/gm if $o1;
+  $result=~s/(\w)\s+($clos)/$1$2/gm;
+  $result=~s/($coms+)\s+($coms+)/$1 $2/gm;
+  $result=~s/($coms_nobr+)\s+($coms+)/$1$o1$2/gm;
+  $result=~s/($coms+)\s+($coms_nobr+)/$1$o1$2/gm;
+  #don't forget about >> and <:.  In unmangled names global-scope modifier 
+  #is not used, so <: will always be a digraph and requires no special treatment.
+  #We also try to remove other parts that are better to be removed here than in other places
+  #double-cv
+  $result=~s/\bconst\s+const\b/const/gm;
+  $result=~s/\bvolatile\s+volatile\b/volatile/gm;
+  $result=~s/\bconst\s+volatile\b\s+const\b/const volatile/gm;
+  $result=~s/\bvolatile\s+const\b\s+volatile\b/const volatile/gm;
+  #Place cv in proper order
+  $result=~s/\bvolatile\s+const\b/const volatile/gm;
+  return $result;
+}
+
+sub unmangled_PostProcess($)
+{
+  my $result = $_[0];
+  #s/\bunsigned int\b/unsigned/g;
+  $result =~ s/\bshort unsigned int\b/unsigned short/g;
+  $result =~ s/\bshort int\b/short/g;
+  $result =~ s/\blong long unsigned int\b/unsigned long long/g;
+  $result =~ s/\blong unsigned int\b/unsigned long/g;
+  $result =~ s/\blong long int\b/long long/g;
+  $result =~ s/\blong int\b/long/g;
+  $result =~ s/\)const\b/\) const/g;
+  $result =~ s/\blong long unsigned\b/unsigned long long/g;
+  $result =~ s/\blong unsigned\b/unsigned long/g;
+  return $result;
+}
+
+# From libtodb2/libtodb.pm
+# Trim string spaces.
+sub trim($)
+{
+        my $string = shift;
+        $string =~ s/^\s+//;
+        $string =~ s/\s+$//;
+        return $string;
+}
+
+sub correctName($)
+{#type name correction
+    my $CorrectName = $_[0];
+    $CorrectName = unmangled_Compact($CorrectName, 1);
+    $CorrectName = unmangled_PostProcess($CorrectName);
+	return $CorrectName;
+}
+
+sub getDump_AllInOne()
+{
+    return if(not keys(%Headers));
+    `mkdir -p temp && rm -f temp/*`;
+	my $Header_Depend = "";
+    foreach my $Dep (sort {length($a) <=> length($b)} keys(%{$Header_Dependency{$Version}}))
+    {
+        $Header_Depend .= " -I".esc($Dep);
+    }
+    my $Lib_VersionName = esc($TargetLibraryName)."_v".$Version;
+    open(LIB_HEADER, ">temp/$TargetLibraryName"."_v$Version.h");
+    foreach my $Preamble_Header (sort {int($Include_Preamble{$Version}{$a}{"Position"})<=>int($Include_Preamble{$Version}{$b}{"Position"})} keys(%{$Include_Preamble{$Version}}))
+    {
+        print LIB_HEADER "#include <$Preamble_Header>\n";
+    }
+	foreach my $Destination (sort {int($Headers{$Version}{$a}{"Position"})<=>int($Headers{$Version}{$b}{"Position"})} keys(%{$Headers{$Version}}))
+	{
+        my $HName = get_FileName($Destination);
+        next if($Include_Preamble{$Version}{$Destination} or ($Include_Preamble{$Version}{$HName} and $HeaderName_Destinations{$Version}{$HName} and keys(%{$HeaderName_Destinations{$Version}{$HName}})==1));
+		print LIB_HEADER "#include <$Destination>\n";
+	}
+	close(LIB_HEADER);
+	system("g++ >".esc($ERR_PATH{$Version})." 2>&1 -fdump-translation-unit temp/$Lib_VersionName.h $CompilerOptions{$Version} $Header_Depend");
+    if($?)
+    {
+        print "WARNING: some errors have occured while compiling header(s), fix it first!\nyou can see compilation errors in the file \'$ERR_PATH{$Version}\'\n";
+    }
+    $ConstantsSrc{$Version} = cmd_preprocessor("temp/$Lib_VersionName.h", $CompilerOptions{$Version}." ".$Header_Depend, "define\\ \\|undef\\ \\|#[ ]\\+[0-9]\\+ \".*\"");
+    system("mkdir", "-p", "header_compile_errors/$TargetLibraryName/temp/");
+    system("cp", "-f", "temp/$TargetLibraryName"."_v$Version.h", "header_compile_errors/$TargetLibraryName/temp/");
+	return (split("\n", `find . -maxdepth 1 -name "$Lib_VersionName\.h*\.tu"`))[0];
+}
+
+sub getDump_Separately($)
+{
+    `mkdir -p temp`;
+    `rm -f temp/*`;
+	my $Destination = $_[0];
+	my $Header_Depend = "";
+    foreach my $Dep (sort {length($a) <=> length($b)} keys(%{$Header_Dependency{$Version}}))
+    {
+        $Header_Depend .= " -I".esc($Dep);
+    }
+    my $Lib_VersionName = esc($TargetLibraryName)."_v".$Version;
+	open(LIB_HEADER, ">temp/$TargetLibraryName"."_v$Version.h");
+    foreach my $Preamble_Header (sort {int($Include_Preamble{$Version}{$a}{"Position"})<=>int($Include_Preamble{$Version}{$b}{"Position"})} keys(%{$Include_Preamble{$Version}}))
+    {
+        print LIB_HEADER "#include <$Preamble_Header>\n";
+    }
+    my $Destination_HName = get_FileName($Destination);
+    if(not ( $Include_Preamble{$Version}{$Destination} or ($Include_Preamble{$Version}{$Destination_HName} and $HeaderName_Destinations{$Version}{$Destination_HName} and keys(%{$HeaderName_Destinations{$Version}{$Destination_HName}})==1) ))
+    {
+        print LIB_HEADER "#include <$Destination>\n";
+    }
+	close(LIB_HEADER);
+	system("g++ >>".esc($ERR_PATH{$Version})." 2>&1 -fdump-translation-unit temp/$Lib_VersionName.h $CompilerOptions{$Version} $Header_Depend");
+    if($?)
+    {
+        $HeaderCompileError{get_FileName($Destination)} = 1;
+    }
+    $ConstantsSrc{$Version} .= cmd_preprocessor("temp/$Lib_VersionName.h", $CompilerOptions{$Version}." ".$Header_Depend, "define\\ \\|undef\\ \\|#[ ]\\+[0-9]\\+ \".*\"");
+	return (split("\n", `find . -maxdepth 1 -name "$Lib_VersionName\.h*\.tu"`))[0];
+}
+
+sub cmd_file($)
+{
+    my $Path = $_[0];
+    return "" if(not $Path or not -e $Path);
+    my $Cmd = "file ".esc($Path);
+    my $Cmd_Out = `$Cmd`;
+    return $Cmd_Out;
+}
+
+sub cmd_preprocessor($$$)
+{
+    my ($Path, $AddOpt, $Grep) = @_;
+    return "" if(not $Path or not -f $Path);
+    my $Cmd = "g++ -dD -E -x c++-header ".esc($Path)." 2>/dev/null $AddOpt";
+    if($Grep)
+    {
+        $Cmd .= " | grep \"$Grep\"";
+    }
+    my $Cmd_Out = `$Cmd`;
+    return $Cmd_Out;
+}
+
+sub cmd_cat($$)
+{
+    my ($Path, $Grep) = @_;
+    return "" if(not $Path or not -e $Path);
+    my $Cmd = "cat ".esc($Path);
+    if($Grep)
+    {
+        $Cmd .= " | grep \"$Grep\"";
+    }
+    my $Cmd_Out = `$Cmd`;
+    return $Cmd_Out;
+}
+
+sub cmd_find($$$)
+{
+    my ($Path, $Type, $Name) = @_;
+    return () if(not $Path or not -e $Path);
+    my $Cmd = "find ".esc($Path);
+    if($Type)
+    {
+        $Cmd .= " -type $Type";
+    }
+    if($Name)
+    {
+        $Cmd .= " -name \"$Name\"";
+    }
+    return split("\n", `$Cmd`);
+}
+
+sub cmd_tar($)
+{
+    my $Path = $_[0];
+    return "" if(not $Path or not -e $Path);
+    my $Cmd = "tar -xvzf ".esc($Path);
+    my $Cmd_Out = `$Cmd`;
+    return $Cmd_Out;
+}
+
+sub is_header($$)
+{
+	my ($Destination, $LibVersion) = @_;
+    return 0 if(-d $Destination);
+    return 1 if($Destination =~ /\.(h|hh|hhh|hpp|tcc)\Z/i);
+    return 0 if($Destination =~ /\.\w+\Z/i);#cpp|c|gch|tu|fs|pas
+    if($Destination =~ /\A\//)
+    {
+        return (cmd_file($Destination) =~ /:[ ]*ASCII C[\+]* program text/);
+    }
+    else
+    {
+        foreach my $Prefix (keys(%{$Header_Dependency{$LibVersion}}))
+        {
+            my $Path = $Prefix."/".$Destination;
+            if(-f $Path)
+            {
+                if(cmd_file($Path) =~ /:[ ]*ASCII C[\+]* program text/)
+                {
+                    return 1;
+                }
+            }
+        }
+        return 0;
+    }
+}
+
+sub parseHeaders_AllInOne($)
+{
+    $Version = $_[0];
+    print "checking header(s) ".$Descriptor{$Version}{"Version"}." ...\n";
+    system("mkdir", "-p", "header_compile_errors/".$TargetLibraryName);
+    system("rm", "-fr", $ERR_PATH{$Version});
+	my $DumpPath = getDump_AllInOne();
+	if(not $DumpPath)
+	{
+		print "\nERROR: can't create gcc syntax tree for header(s)\nyou can see compilation errors in the file '$ERR_PATH{$Version}'\n";
+		exit(1);
+	}
+	getInfo($DumpPath);
+    parse_constants();
+    system("rm", "-fr", "temp");
+}
+
+sub parseHeader($)
+{
+	my $Destination = $_[0];
+	my $DumpPath = getDump_Separately($Destination);
+	if(not $DumpPath)
+	{
+		print "ERROR: can't create gcc syntax tree for header\nyou can see compilation errors in the file '$ERR_PATH{$Version}'\n";
+		exit(1);
+	}
+	getInfo($DumpPath);
+    parse_constants();
+    system("rm", "-fr", "temp");
+}
+
+sub is_in_library($$)
+{
+    my ($MnglName, $LibVersion) = @_;
+    return ($Interface_Library{$LibVersion}{$MnglName} or ($SymVer{$LibVersion}{$MnglName} and $Interface_Library{$LibVersion}{$SymVer{$LibVersion}{$MnglName}}));
+}
+
+sub prepareInterfaces($)
+{
+	my $LibVersion = $_[0];
+    my (@MnglNames, @UnMnglNames) = ();
+    if($CheckHeadersOnly)
+    {
+        foreach my $FuncInfoId (sort keys(%{$FuncDescr{$LibVersion}}))
+        {
+            if($FuncDescr{$LibVersion}{$FuncInfoId}{"MnglName"} =~ /\A_Z/)
+            {
+                push(@MnglNames, $FuncDescr{$LibVersion}{$FuncInfoId}{"MnglName"});
+            }
+        }
+        if($#MnglNames > -1)
+        {
+            @UnMnglNames = reverse(unmangleArray(@MnglNames));
+            foreach my $FuncInfoId (sort keys(%{$FuncDescr{$LibVersion}}))
+            {
+                if($FuncDescr{$LibVersion}{$FuncInfoId}{"MnglName"} =~ /\A_Z/)
+                {
+                    my $UnmangledName = pop(@UnMnglNames);
+                    $tr_name{$FuncDescr{$LibVersion}{$FuncInfoId}{"MnglName"}} = $UnmangledName;
+                }
+            }
+        }
+    }
+    my (%NotMangled_Int, %Mangled_Int) = ();
+    foreach my $FuncInfoId (keys(%{$FuncDescr{$LibVersion}}))
+    {
+        my $MnglName = $FuncDescr{$LibVersion}{$FuncInfoId}{"MnglName"};
+        if($MnglName=~/\A_Z/)
+        {
+            $Mangled_Int{$FuncInfoId} = $MnglName;
+        }
+        else
+        {
+            $NotMangled_Int{$FuncInfoId} = $MnglName;
+        }
+        next if(not $MnglName or not is_in_library($MnglName, $LibVersion) and not $CheckHeadersOnly);
+        next if($MnglName =~ /\A_Z/ and $tr_name{$MnglName} =~ /\.\_[0-9]/);
+        next if(not $FuncDescr{$LibVersion}{$FuncInfoId}{"Header"});
+        %{$CompleteSignature{$LibVersion}{$MnglName}} = %{$FuncDescr{$LibVersion}{$FuncInfoId}};
+        #interface and its symlink have same signatures
+        if($SymVer{$LibVersion}{$MnglName})
+        {
+            %{$CompleteSignature{$LibVersion}{$SymVer{$LibVersion}{$MnglName}}} = %{$FuncDescr{$LibVersion}{$FuncInfoId}};
+        }
+        delete($FuncDescr{$LibVersion}{$FuncInfoId});
+    }
+    if(keys(%Mangled_Int))
+    {
+        foreach my $Interface_Id (keys(%NotMangled_Int))
+        {
+            delete($CompleteSignature{$LibVersion}{$NotMangled_Int{$Interface_Id}});
+        }
+    }
+}
+
+my %UsedType;
+sub cleanData($)
+{
+    my $LibVersion = $_[0];
+    foreach my $FuncInfoId (keys(%{$FuncDescr{$LibVersion}}))
+    {
+        my $MnglName = $FuncDescr{$LibVersion}{$FuncInfoId}{"MnglName"};
+        if(not $MnglName or not is_in_library($MnglName, $LibVersion) and not $CheckHeadersOnly)
+        {
+            delete($FuncDescr{$LibVersion}{$FuncInfoId});
+            next;
+        }
+        if(defined $InterfacesListPath and not $InterfacesList{$MnglName})
+        {
+            delete($FuncDescr{$LibVersion}{$FuncInfoId});
+            next;
+        }
+        if(defined $AppPath and not $InterfacesList_App{$MnglName})
+        {
+            delete($FuncDescr{$LibVersion}{$FuncInfoId});
+            next;
+        }
+        my %FuncInfo = %{$FuncDescr{$LibVersion}{$FuncInfoId}};
+        detect_TypeUsing($Tid_TDid{$LibVersion}{$FuncInfo{"Return"}}, $FuncInfo{"Return"}, $LibVersion);
+        detect_TypeUsing($Tid_TDid{$LibVersion}{$FuncInfo{"Class"}}, $FuncInfo{"Class"}, $LibVersion);
+        foreach my $Param_Pos (keys(%{$FuncInfo{"Param"}}))
+        {
+            my $Param_TypeId = $FuncInfo{"Param"}{$Param_Pos}{"type"};
+            detect_TypeUsing($Tid_TDid{$LibVersion}{$Param_TypeId}, $Param_TypeId, $LibVersion);
+        }
+    }
+    foreach my $TDid (keys(%{$TypeDescr{$LibVersion}}))
+    {
+        foreach my $Tid (keys(%{$TypeDescr{$LibVersion}{$TDid}}))
+        {
+            if(not $UsedType{$LibVersion}{$TDid}{$Tid})
+            {
+                delete($TypeDescr{$LibVersion}{$TDid}{$Tid});
+                if(not keys(%{$TypeDescr{$LibVersion}{$TDid}}))
+                {
+                    delete($TypeDescr{$LibVersion}{$TDid});
+                }
+                delete($Tid_TDid{$LibVersion}{$Tid}) if($Tid_TDid{$LibVersion}{$Tid} eq $TDid);
+            }
+        }
+    }
+}
+
+sub detect_TypeUsing($$$)
+{
+    my ($TypeDeclId, $TypeId, $LibVersion) = @_;
+    return if($UsedType{$LibVersion}{$TypeDeclId}{$TypeId});
+    my %Type = get_Type($TypeDeclId, $TypeId, $LibVersion);
+    if($Type{"Type"} =~ /Struct|Union|Class|FuncPtr|Enum/)
+    {
+        $UsedType{$LibVersion}{$TypeDeclId}{$TypeId} = 1;
+        foreach my $Memb_Pos (keys(%{$Type{"Memb"}}))
+        {
+            my $Member_TypeId = $Type{"Memb"}{$Memb_Pos}{"type"};
+            detect_TypeUsing($Tid_TDid{$LibVersion}{$Member_TypeId}, $Member_TypeId, $LibVersion);
+        }
+        if($Type{"Type"} eq "FuncPtr")
+        {
+            my $ReturnType = $Type{"Return"};
+            detect_TypeUsing($Tid_TDid{$LibVersion}{$ReturnType}, $ReturnType, $LibVersion);
+        }
+    }
+    elsif($Type{"Type"} =~ /Const|Pointer|Ref|Volatile|Restrict|Array|/)
+    {
+        $UsedType{$LibVersion}{$TypeDeclId}{$TypeId} = 1;
+        detect_TypeUsing($Type{"BaseType"}{"TDid"}, $Type{"BaseType"}{"Tid"}, $LibVersion);
+    }
+    elsif($Type{"Type"} eq "Intrinsic")
+    {
+        $UsedType{$LibVersion}{$TypeDeclId}{$TypeId} = 1;
+    }
+    else
+    {
+        delete($TypeDescr{$LibVersion}{$TypeDeclId}{$TypeId});
+        if(not keys(%{$TypeDescr{$LibVersion}{$TypeDeclId}}))
+        {
+            delete($TypeDescr{$LibVersion}{$TypeDeclId});
+        }
+        delete($Tid_TDid{$LibVersion}{$TypeId}) if($Tid_TDid{$LibVersion}{$TypeId} eq $TypeDeclId);
+    }
+}
+
+sub initializeClassVirtFunc($)
+{
+    my $LibVersion = $_[0];
+    foreach my $Interface (keys(%{$CompleteSignature{$LibVersion}}))
+    {
+        if($CompleteSignature{$LibVersion}{$Interface}{"Virt"})
+        {
+            my $ClassName = $TypeDescr{$LibVersion}{$Tid_TDid{$LibVersion}{$CompleteSignature{$LibVersion}{$Interface}{"Class"}}}{$CompleteSignature{$LibVersion}{$Interface}{"Class"}}{"Name"};
+            $ClassVirtFunc{$LibVersion}{$ClassName}{$Interface} = 1;
+            $ClassIdVirtFunc{$LibVersion}{$CompleteSignature{$LibVersion}{$Interface}{"Class"}}{$Interface} = 1;
+            $ClassId{$LibVersion}{$ClassName} = $CompleteSignature{$LibVersion}{$Interface}{"Class"};
+        }
+    }
+}
+
+sub checkVirtFuncRedefinitions($)
+{
+    my $LibVersion = $_[0];
+    foreach my $Class_Name (keys(%{$ClassVirtFunc{$LibVersion}}))
+    {
+        $CheckedTypes{$Class_Name} = 1;
+        foreach my $VirtFuncName (keys(%{$ClassVirtFunc{$LibVersion}{$Class_Name}}))
+        {
+            $CompleteSignature{$LibVersion}{$VirtFuncName}{"VirtualRedefine"} = find_virtual_method_in_base_classes($VirtFuncName, $ClassId{$LibVersion}{$Class_Name}, $LibVersion);
+        }
+    }
+}
+
+sub setVirtFuncPositions($)
+{
+    my $LibVersion = $_[0];
+    foreach my $Class_Name (keys(%{$ClassVirtFunc{$LibVersion}}))
+    {
+        $CheckedTypes{$Class_Name} = 1;
+        my $Position = 0;
+        foreach my $VirtFuncName (sort {int($CompleteSignature{$LibVersion}{$a}{"Line"}) <=> int($CompleteSignature{$LibVersion}{$b}{"Line"})} keys(%{$ClassVirtFunc{$LibVersion}{$Class_Name}}))
+        {
+            if($ClassVirtFunc{1}{$Class_Name}{$VirtFuncName} and $ClassVirtFunc{2}{$Class_Name}{$VirtFuncName} and not $CompleteSignature{1}{$VirtFuncName}{"VirtualRedefine"} and not $CompleteSignature{2}{$VirtFuncName}{"VirtualRedefine"})
+            {
+                $CompleteSignature{$LibVersion}{$VirtFuncName}{"Position"} = $Position;
+                $Position += 1;
+            }
+        }
+    }
+}
+
+sub check_VirtualTable($$)
+{
+    my ($TargetFunction, $LibVersion) = @_;
+    my $Class_Id = $CompleteSignature{$LibVersion}{$TargetFunction}{"Class"};
+    my $Class_DId = $Tid_TDid{$LibVersion}{$Class_Id};
+    my %Class_Type = get_Type($Class_DId, $Class_Id, $LibVersion);
+    $CheckedTypes{$Class_Type{"Name"}} = 1;
+    foreach my $VirtFuncName (keys(%{$ClassVirtFunc{2}{$Class_Type{"Name"}}}))
+    {#Added
+        if($ClassId{1}{$Class_Type{"Name"}} and not $ClassVirtFunc{1}{$Class_Type{"Name"}}{$VirtFuncName} and $AddedInt{$VirtFuncName})
+        {
+            if($CompleteSignature{2}{$VirtFuncName}{"VirtualRedefine"})
+            {
+                if($TargetFunction eq $VirtFuncName)
+                {
+                    my $BaseClass_Id = $CompleteSignature{2}{$CompleteSignature{2}{$VirtFuncName}{"VirtualRedefine"}}{"Class"};
+                    my %BaseClass_Type = get_Type($Tid_TDid{2}{$BaseClass_Id}, $BaseClass_Id, 2);
+                    my $BaseClass_Name = $BaseClass_Type{"Name"};
+                    %{$CompatProblems{$TargetFunction}{"Virtual_Function_Redefinition"}{$tr_name{$CompleteSignature{2}{$VirtFuncName}{"VirtualRedefine"}}}}=(
+                        "Type_Name"=>$Class_Type{"Name"},
+                        "Type_Type"=>$Class_Type{"Type"},
+                        "Header"=>$CompleteSignature{2}{$TargetFunction}{"Header"},
+                        "Line"=>$CompleteSignature{2}{$TargetFunction}{"Line"},
+                        "Target"=>$tr_name{$CompleteSignature{2}{$VirtFuncName}{"VirtualRedefine"}},
+                        "Signature"=>$tr_name{$TargetFunction},
+                        "Old_Value"=>$tr_name{$CompleteSignature{2}{$VirtFuncName}{"VirtualRedefine"}},
+                        "New_Value"=>$tr_name{$TargetFunction},
+                        "Old_SoName"=>$Interface_Library{1}{$TargetFunction},
+                        "New_SoName"=>$Interface_Library{2}{$TargetFunction}  );
+                }
+            }
+            elsif($TargetFunction ne $VirtFuncName)
+            {
+                %{$CompatProblems{$TargetFunction}{"Added_Virtual_Function"}{$tr_name{$VirtFuncName}}}=(
+                "Type_Name"=>$Class_Type{"Name"},
+                "Type_Type"=>$Class_Type{"Type"},
+                "Header"=>$Class_Type{"Header"},
+                "Line"=>$Class_Type{"Line"},
+                "Target"=>$tr_name{$VirtFuncName},
+                "Signature"=>$tr_name{$TargetFunction},
+                "Old_SoName"=>$Interface_Library{1}{$TargetFunction},
+                "New_SoName"=>$Interface_Library{2}{$TargetFunction}  );
+            }
+        }
+    }
+    foreach my $VirtFuncName (keys(%{$ClassVirtFunc{1}{$Class_Type{"Name"}}}))
+    {#Withdrawn
+        if($ClassId{2}{$Class_Type{"Name"}} and not $ClassVirtFunc{2}{$Class_Type{"Name"}}{$VirtFuncName} and $WithdrawnInt{$VirtFuncName})
+        {
+            if($CompleteSignature{1}{$VirtFuncName}{"VirtualRedefine"})
+            {
+                if($TargetFunction eq $VirtFuncName)
+                {
+                    my $BaseClass_Id = $CompleteSignature{1}{$CompleteSignature{1}{$VirtFuncName}{"VirtualRedefine"}}{"Class"};
+                    my $BaseClass_Name = $TypeDescr{1}{$Tid_TDid{1}{$BaseClass_Id}}{$BaseClass_Id}{"Name"};
+                    %{$CompatProblems{$TargetFunction}{"Virtual_Function_Redefinition_B"}{$tr_name{$CompleteSignature{1}{$VirtFuncName}{"VirtualRedefine"}}}}=(
+                        "Type_Name"=>$Class_Type{"Name"},
+                        "Type_Type"=>$Class_Type{"Type"},
+                        "Header"=>$CompleteSignature{2}{$TargetFunction}{"Header"},
+                        "Line"=>$CompleteSignature{2}{$TargetFunction}{"Line"},
+                        "Target"=>$tr_name{$CompleteSignature{1}{$VirtFuncName}{"VirtualRedefine"}},
+                        "Signature"=>$tr_name{$TargetFunction},
+                        "Old_Value"=>$tr_name{$TargetFunction},
+                        "New_Value"=>$tr_name{$CompleteSignature{1}{$VirtFuncName}{"VirtualRedefine"}},
+                        "Old_SoName"=>$Interface_Library{1}{$TargetFunction},
+                        "New_SoName"=>$Interface_Library{2}{$TargetFunction}  );
+                }
+            }
+            else
+            {
+                %{$CompatProblems{$TargetFunction}{"Withdrawn_Virtual_Function"}{$tr_name{$VirtFuncName}}}=(
+                "Type_Name"=>$Class_Type{"Name"},
+                "Type_Type"=>$Class_Type{"Type"},
+                "Header"=>$Class_Type{"Header"},
+                "Line"=>$Class_Type{"Line"},
+                "Target"=>$tr_name{$VirtFuncName},
+                "Signature"=>$tr_name{$TargetFunction},
+                "Old_SoName"=>$Interface_Library{1}{$TargetFunction},
+                "New_SoName"=>$Interface_Library{2}{$TargetFunction}  );
+            }
+        }
+    }
+}
+
+sub find_virtual_method_in_base_classes($$$)
+{
+    my ($VirtFuncName, $Checked_ClassId, $LibVersion) = @_;
+    foreach my $BaseClass_Id (keys(%{$TypeDescr{$LibVersion}{$Tid_TDid{$LibVersion}{$Checked_ClassId}}{$Checked_ClassId}{"BaseClass"}}))
+    {
+        my $VirtMethodInClass = find_virtual_method_in_class($VirtFuncName, $BaseClass_Id, $LibVersion);
+        if($VirtMethodInClass)
+        {
+            return $VirtMethodInClass;
+        }
+        my $VirtMethodInBaseClasses = find_virtual_method_in_base_classes($VirtFuncName, $BaseClass_Id, $LibVersion);
+        if($VirtMethodInBaseClasses)
+        {
+            return $VirtMethodInBaseClasses;
+        }
+    }
+    return "";
+}
+
+sub find_virtual_method_in_class($$$)
+{
+    my ($VirtFuncName, $Checked_ClassId, $LibVersion) = @_;
+    my $Suffix = getFuncSuffix($VirtFuncName, $LibVersion);
+    foreach my $Checked_VirtFuncName (keys(%{$ClassIdVirtFunc{$LibVersion}{$Checked_ClassId}}))
+    {
+        if($Suffix eq getFuncSuffix($Checked_VirtFuncName, $LibVersion)
+            and ((not $CompleteSignature{$LibVersion}{$VirtFuncName}{"Constructor"} and not $CompleteSignature{$LibVersion}{$VirtFuncName}{"Destructor"} and $CompleteSignature{$LibVersion}{$VirtFuncName}{"ShortName"} eq $CompleteSignature{$LibVersion}{$Checked_VirtFuncName}{"ShortName"}) or ($CompleteSignature{$LibVersion}{$VirtFuncName}{"Constructor"} or $CompleteSignature{$LibVersion}{$VirtFuncName}{"Destructor"})))
+        {
+            return $Checked_VirtFuncName;
+        }
+    }
+    return "";
+}
+
+sub getFuncSuffix($$)
+{
+    my ($FuncName, $LibVersion) = @_;
+    my $ClassId = $CompleteSignature{$LibVersion}{$FuncName}{"Class"};
+    my $ClassName = $TypeDescr{$LibVersion}{$Tid_TDid{$LibVersion}{$ClassId}}{$ClassId}{"Name"};
+    my $ShortName = $CompleteSignature{$LibVersion}{$FuncName}{"ShortName"};
+    my $Suffix = $tr_name{$FuncName};
+    $Suffix =~ s/\A$ClassName\:\:[~]*$ShortName[ ]*//g;
+    return $Suffix;
+}
+
+sub isRecurType($$$$)
+{
+	foreach (@RecurTypes)
+	{
+		if($_->{"Tid1"} eq $_[0]
+            and $_->{"TDid1"} eq $_[1]
+            and $_->{"Tid2"} eq $_[2]
+            and $_->{"TDid2"} eq $_[3])
+		{
+			return 1;
+		}
+	}
+	return 0;
+}
+
+sub find_MemberPair_Pos_byName($$)
+{
+    my ($Member_Name, $Pair_Type) = @_;
+    foreach my $MemberPair_Pos (sort keys(%{$Pair_Type->{"Memb"}}))
+    {
+        if($Pair_Type->{"Memb"}{$MemberPair_Pos}{"name"} eq $Member_Name)
+        {
+            return $MemberPair_Pos;
+        }
+    }
+    return "lost";
+}
+
+sub getBitfieldSum($$)
+{
+    my ($Member_Pos, $Pair_Type) = @_;
+    my $BitfieldSum = 0;
+    while($Member_Pos>-1)
+    {
+        return $BitfieldSum if(not $Pair_Type->{"Memb"}{$Member_Pos}{"bitfield"});
+        $BitfieldSum += $Pair_Type->{"Memb"}{$Member_Pos}{"bitfield"};
+        $Member_Pos -= 1;
+    }
+    return $BitfieldSum;
+}
+
+sub find_MemberPair_Pos_byVal($$)
+{
+    my ($Member_Value, $Pair_Type) = @_;
+    foreach my $MemberPair_Pos (sort keys(%{$Pair_Type->{"Memb"}}))
+    {
+        if($Pair_Type->{"Memb"}{$MemberPair_Pos}{"value"} eq $Member_Value)
+        {
+            return $MemberPair_Pos;
+        }
+    }
+    return "lost";
+}
+
+my %Priority_Value=(
+"High"=>3,
+"Medium"=>2,
+"Low"=>1
+);
+
+sub max_priority($$)
+{
+    my ($Priority1, $Priority2) = @_;
+    if(cmp_priority($Priority1, $Priority2))
+    {
+        return $Priority1;
+    }
+    else
+    {
+        return $Priority2;
+    }
+}
+
+sub cmp_priority($$)
+{
+    my ($Priority1, $Priority2) = @_;
+    return ($Priority_Value{$Priority1}>$Priority_Value{$Priority2});
+}
+
+sub set_Problems_Priority()
+{
+    foreach my $InterfaceName (sort keys(%CompatProblems))
+    {
+        foreach my $Kind (sort keys(%{$CompatProblems{$InterfaceName}}))
+        {
+            foreach my $Location (sort keys(%{$CompatProblems{$InterfaceName}{$Kind}}))
+            {
+                my $IsInTypeInternals = $CompatProblems{$InterfaceName}{$Kind}{$Location}{"IsInTypeInternals"};
+                my $InitialType_Type = $CompatProblems{$InterfaceName}{$Kind}{$Location}{"InitialType_Type"};
+                if($Kind eq "Function_Become_Static")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
+                }
+                elsif($Kind eq "Function_Become_NonStatic")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
+                }
+                elsif($Kind eq "Parameter_Type_And_Size")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
+                }
+                elsif($Kind eq "Parameter_Type")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                }
+                elsif($Kind eq "Withdrawn_Parameter")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
+                }
+                elsif($Kind eq "Added_Parameter")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
+                }
+                elsif($Kind eq "Parameter_BaseType_And_Size")
+                {
+                    if($InitialType_Type eq "Pointer")
+                    {
+                        $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                    }
+                    else
+                    {
+                        $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
+                    }
+                }
+                elsif($Kind eq "Parameter_BaseType")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                }
+                elsif($Kind eq "Parameter_PointerLevel")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
+                }
+                elsif($Kind eq "Return_Type_And_Size")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
+                }
+                elsif($Kind eq "Return_Type")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                }
+                elsif($Kind eq "Return_BaseType_And_Size")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
+                }
+                elsif($Kind eq "Return_BaseType")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                }
+                elsif($Kind eq "Return_PointerLevel")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                }
+                if($Kind eq "Added_Virtual_Function")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
+                }
+                elsif($Kind eq "Withdrawn_Virtual_Function")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
+                }
+                elsif($Kind eq "Virtual_Function_Position")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
+                }
+                elsif($Kind eq "Virtual_Function_Redefinition")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                }
+                elsif($Kind eq "Virtual_Function_Redefinition_B")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                }
+                elsif($Kind eq "Size")
+                {
+                    if(($InitialType_Type eq "Pointer") or ($InitialType_Type eq "Array"))
+                    {
+                        $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                    }
+                    else
+                    {
+                        if($IsInTypeInternals)
+                        {
+                            $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
+                        }
+                        else
+                        {
+                            $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
+                        }
+                    }
+                }
+                elsif($Kind eq "BaseType")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                }
+                elsif($Kind eq "Added_Member_And_Size")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                }
+                elsif($Kind eq "Added_Middle_Member_And_Size")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
+                }
+                elsif($Kind eq "Withdrawn_Member_And_Size")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
+                }
+                elsif($Kind eq "Withdrawn_Member")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                }
+                elsif($Kind eq "Withdrawn_Middle_Member_And_Size")
+                {
+                    if($IsInTypeInternals)
+                    {
+                        $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
+                    }
+                    else
+                    {
+                        $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
+                    }
+                }
+                elsif($Kind eq "Withdrawn_Middle_Member")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
+                }
+                elsif($Kind eq "Member_Rename")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                }
+                elsif($Kind eq "Enum_Member_Value")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
+                }
+                elsif($Kind eq "Enum_Member_Name")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                }
+                elsif($Kind eq "Member_Type_And_Size")
+                {
+                    if(($InitialType_Type eq "Pointer") or ($InitialType_Type eq "Array"))
+                    {
+                        $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                    }
+                    else
+                    {
+                        if($IsInTypeInternals)
+                        {
+                            $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                        }
+                        else
+                        {
+                            $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
+                        }
+                    }
+                }
+                elsif($Kind eq "Member_Type")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                }
+                elsif($Kind eq "Member_BaseType_And_Size")
+                {
+                    if(($InitialType_Type eq "Pointer") or ($InitialType_Type eq "Array"))
+                    {
+                        $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                    }
+                    else
+                    {
+                        if($IsInTypeInternals)
+                        {
+                            $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                        }
+                        else
+                        {
+                            $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "High";
+                        }
+                    }
+                }
+                elsif($Kind eq "Member_BaseType")
+                {
+                    $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                }
+                elsif($Kind eq "Member_PointerLevel")
+                {
+                    if(($InitialType_Type eq "Pointer") or ($InitialType_Type eq "Array"))
+                    {
+                        $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                    }
+                    else
+                    {
+                        if($IsInTypeInternals)
+                        {
+                            $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Low";
+                        }
+                        else
+                        {
+                            $CompatProblems{$InterfaceName}{$Kind}{$Location}{"Priority"} = "Medium";
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+sub pushType($$$$)
+{
+    my %TypeDescriptor=(
+        "Tid1"  => $_[0],
+        "TDid1" => $_[1],
+        "Tid2"  => $_[2],
+        "TDid2" => $_[3]  );
+    push(@RecurTypes, \%TypeDescriptor);
+}
+
+sub mergeTypes($$$$)
+{
+    my ($Type1_Id, $Type1_DId, $Type2_Id, $Type2_DId) = @_;
+    my (%Sub_SubProblems, %SubProblems) = ();
+    if((not $Type1_Id and not $Type1_DId) or (not $Type2_Id and not $Type2_DId))
+    {#Not Empty Inputs Only
+        return ();
+    }
+    if($Cache{"mergeTypes"}{$Type1_Id}{$Type1_DId}{$Type2_Id}{$Type2_DId})
+    {#Already Merged
+        return %{$Cache{"mergeTypes"}{$Type1_Id}{$Type1_DId}{$Type2_Id}{$Type2_DId}};
+    }
+    my %Type1 = get_Type($Type1_DId, $Type1_Id, 1);
+    my %Type2 = get_Type($Type2_DId, $Type2_Id, 2);
+	my %Type1_Pure = get_PureType($Type1_DId, $Type1_Id, 1);
+    my %Type2_Pure = get_PureType($Type2_DId, $Type2_Id, 2);
+    return () if(not $Type1_Pure{"Size"} or not $Type2_Pure{"Size"});
+    if(isRecurType($Type1_Pure{"Tid"}, $Type1_Pure{"TDid"}, $Type2_Pure{"Tid"}, $Type2_Pure{"TDid"}))
+    {#Recursive Declarations
+        return ();
+    }
+    return if(not $Type1_Pure{"Name"} or not $Type2_Pure{"Name"});
+    return if($OpaqueTypes{1}{$Type1_Pure{"Name"}} or $OpaqueTypes{2}{$Type1_Pure{"Name"}} or $OpaqueTypes{1}{$Type1{"Name"}} or $OpaqueTypes{2}{$Type1{"Name"}});
+    
+    my %Typedef_1 = goToFirst($Type1{"TDid"}, $Type1{"Tid"}, 1, "Typedef");
+    my %Typedef_2 = goToFirst($Type2{"TDid"}, $Type2{"Tid"}, 2, "Typedef");
+    if($Typedef_1{"Type"} eq "Typedef" and $Typedef_2{"Type"} eq "Typedef" and $Typedef_1{"Name"} eq $Typedef_2{"Name"})
+    {
+        my %Base_1 = get_OneStep_BaseType($Typedef_1{"TDid"}, $Typedef_1{"Tid"}, 1);
+        my %Base_2 = get_OneStep_BaseType($Typedef_2{"TDid"}, $Typedef_2{"Tid"}, 2);
+        if($Base_1{"Name"}!~/anon\-/ and $Base_2{"Name"}!~/anon\-/
+            and ($Base_1{"Name"} ne $Base_2{"Name"}))
+        {
+            %{$SubProblems{"BaseType"}{$Typedef_1{"Name"}}}=(
+                "Type_Name"=>$Typedef_1{"Name"},
+                "Type_Type"=>"Typedef",
+                "Header"=>$Typedef_2{"Header"},
+                "Line"=>$Typedef_2{"Line"},
+                "Old_Value"=>$Base_1{"Name"},
+                "New_Value"=>$Base_2{"Name"}  );
+        }
+    }
+    
+    if(($Type1_Pure{"Name"} ne $Type2_Pure{"Name"}) and ($Type1_Pure{"Type"} ne "Pointer") and $Type1_Pure{"Name"}!~/anon\-/)
+    {#Different types
+        return ();
+    }
+    
+	pushType($Type1_Pure{"Tid"}, $Type1_Pure{"TDid"}, $Type2_Pure{"Tid"}, $Type2_Pure{"TDid"});
+	if(($Type1_Pure{"Name"} eq $Type2_Pure{"Name"}) and ($Type1_Pure{"Type"} =~ /Struct|Class|Union/))
+	{#Check Size
+		if($Type1_Pure{"Size"} ne $Type2_Pure{"Size"})
+		{
+            %{$SubProblems{"Size"}{$Type1_Pure{"Name"}}}=(
+                "Type_Name"=>$Type1_Pure{"Name"},
+                "Type_Type"=>$Type1_Pure{"Type"},
+                "Header"=>$Type2_Pure{"Header"},
+                "Line"=>$Type2_Pure{"Line"},
+                "Old_Value"=>$Type1_Pure{"Size"},
+                "New_Value"=>$Type2_Pure{"Size"}  );
+		}
+	}
+    if($Type1_Pure{"Name"} and $Type2_Pure{"Name"} and ($Type1_Pure{"Name"} ne $Type2_Pure{"Name"}) and ($Type1_Pure{"Name"} !~ /\Avoid[ ]*\*/) and ($Type2_Pure{"Name"} =~ /\Avoid[ ]*\*/))
+    {#Check "void *"
+        pop(@RecurTypes);
+        return ();
+    }
+	if($Type1_Pure{"BaseType"}{"Tid"} and $Type2_Pure{"BaseType"}{"Tid"})
+	{#Check Base Types
+		%Sub_SubProblems = &mergeTypes($Type1_Pure{"BaseType"}{"Tid"}, $Type1_Pure{"BaseType"}{"TDid"}, $Type2_Pure{"BaseType"}{"Tid"}, $Type2_Pure{"BaseType"}{"TDid"});
+        foreach my $Sub_SubProblemType (keys(%Sub_SubProblems))
+        {
+            foreach my $Sub_SubLocation (keys(%{$Sub_SubProblems{$Sub_SubProblemType}}))
+            {
+                %{$SubProblems{$Sub_SubProblemType}{$Sub_SubLocation}} = %{$Sub_SubProblems{$Sub_SubProblemType}{$Sub_SubLocation}};
+                $SubProblems{$Sub_SubProblemType}{$Sub_SubLocation}{"InitialType_Type"} = $Type1_Pure{"Type"};
+            }
+        }
+	}
+    foreach my $Member_Pos (sort keys(%{$Type1_Pure{"Memb"}}))
+    {#Check Members
+        next if($Type1_Pure{"Memb"}{$Member_Pos}{"access"} eq "private");
+        my $Member_Name = $Type1_Pure{"Memb"}{$Member_Pos}{"name"};
+        next if(not $Member_Name);
+        my $Member_Location = $Member_Name;
+        my $MemberPair_Pos = find_MemberPair_Pos_byName($Member_Name, \%Type2_Pure);
+        if(($MemberPair_Pos eq "lost") and (($Type2_Pure{"Type"} eq "Struct") or ($Type2_Pure{"Type"} eq "Class")))
+        {#Withdrawn_Member
+            if($Member_Pos > keys(%{$Type2_Pure{"Memb"}}) - 1)
+            {
+                if($Type1_Pure{"Size"} ne $Type2_Pure{"Size"})
+                {
+                    %{$SubProblems{"Withdrawn_Member_And_Size"}{$Member_Name}}=(
+                        "Target"=>$Member_Name,
+                        "Type_Name"=>$Type1_Pure{"Name"},
+                        "Type_Type"=>$Type1_Pure{"Type"},
+                        "Header"=>$Type2_Pure{"Header"},
+                        "Line"=>$Type2_Pure{"Line"},
+                        "Old_Size"=>$Type1_Pure{"Size"},
+                        "New_Size"=>$Type2_Pure{"Size"}  );
+                }
+                else
+                {
+                    %{$SubProblems{"Withdrawn_Member"}{$Member_Name}}=(
+                        "Target"=>$Member_Name,
+                        "Type_Name"=>$Type1_Pure{"Name"},
+                        "Type_Type"=>$Type1_Pure{"Type"},
+                        "Header"=>$Type2_Pure{"Header"},
+                        "Line"=>$Type2_Pure{"Line"}  );
+                }
+                next;
+            }
+            elsif($Member_Pos < keys(%{$Type1_Pure{"Memb"}}) - 1)
+            {
+                my $MemberType_Id = $Type1_Pure{"Memb"}{$Member_Pos}{"type"};
+                my %MemberType_Pure = get_PureType($Tid_TDid{1}{$MemberType_Id}, $MemberType_Id, 1);
+                my $MemberStraightPairType_Id = $Type2_Pure{"Memb"}{$Member_Pos}{"type"};
+                my %MemberStraightPairType_Pure = get_PureType($Tid_TDid{2}{$MemberStraightPairType_Id}, $MemberStraightPairType_Id, 2);
+                
+                if(($MemberType_Pure{"Size"} eq $MemberStraightPairType_Pure{"Size"}) and find_MemberPair_Pos_byName($Type2_Pure{"Memb"}{$Member_Pos}{"name"}, \%Type1_Pure) eq "lost")
+                {
+                    %{$SubProblems{"Member_Rename"}{$Member_Name}}=(
+                        "Target"=>$Member_Name,
+                        "Type_Name"=>$Type1_Pure{"Name"},
+                        "Type_Type"=>$Type1_Pure{"Type"},
+                        "Header"=>$Type2_Pure{"Header"},
+                        "Line"=>$Type2_Pure{"Line"},
+                        "Old_Value"=>$Type1_Pure{"Memb"}{$Member_Pos}{"name"},
+                        "New_Value"=>$Type2_Pure{"Memb"}{$Member_Pos}{"name"}  );
+                    $MemberPair_Pos = $Member_Pos;
+                }
+                else
+                {
+                    if($Type1_Pure{"Memb"}{$Member_Pos}{"bitfield"})
+                    {
+                        my $BitfieldSum = getBitfieldSum($Member_Pos-1, \%Type1_Pure)%($POINTER_SIZE*8);
+                        if($BitfieldSum and $BitfieldSum-$Type2_Pure{"Memb"}{$Member_Pos}{"bitfield"}>=0)
+                        {
+                            %{$SubProblems{"Withdrawn_Middle_Member"}{$Member_Name}}=(
+                            "Target"=>$Member_Name,
+                            "Type_Name"=>$Type1_Pure{"Name"},
+                            "Type_Type"=>$Type1_Pure{"Type"},
+                            "Header"=>$Type2_Pure{"Header"},
+                            "Line"=>$Type2_Pure{"Line"}  );
+                            next;
+                        }
+                    }
+                    %{$SubProblems{"Withdrawn_Middle_Member_And_Size"}{$Member_Name}}=(
+                        "Target"=>$Member_Name,
+                        "Type_Name"=>$Type1_Pure{"Name"},
+                        "Type_Type"=>$Type1_Pure{"Type"},
+                        "Header"=>$Type2_Pure{"Header"},
+                        "Line"=>$Type2_Pure{"Line"}  );
+                    next;
+                }
+            }
+        }
+        if($Type1_Pure{"Type"} eq "Enum")
+        {
+            my $Member_Value1 = $Type1_Pure{"Memb"}{$Member_Pos}{"value"};
+            next if(not $Member_Value1);
+            my $Member_Value2 = $Type2_Pure{"Memb"}{$MemberPair_Pos}{"value"};
+            if($MemberPair_Pos eq "lost")
+            {
+                $MemberPair_Pos = find_MemberPair_Pos_byVal($Member_Value1, \%Type2_Pure);
+                if($MemberPair_Pos ne "lost")
+                {
+                    %{$SubProblems{"Enum_Member_Name"}{$Type1_Pure{"Memb"}{$Member_Pos}{"value"}}}=(
+                        "Target"=>$Type1_Pure{"Memb"}{$Member_Pos}{"value"},
+                        "Type_Name"=>$Type1_Pure{"Name"},
+                        "Type_Type"=>"Enum",
+                        "Header"=>$Type2_Pure{"Header"},
+                        "Line"=>$Type2_Pure{"Line"},
+                        "Old_Value"=>$Type1_Pure{"Memb"}{$Member_Pos}{"name"},
+                        "New_Value"=>$Type2_Pure{"Memb"}{$MemberPair_Pos}{"name"}  );
+                }
+            }
+            else
+            {
+                if($Member_Value1 ne "" and $Member_Value2 ne "")
+                {
+                    if($Member_Value1 ne $Member_Value2)
+                    {
+                        %{$SubProblems{"Enum_Member_Value"}{$Member_Name}}=(
+                            "Target"=>$Member_Name,
+                            "Type_Name"=>$Type1_Pure{"Name"},
+                            "Type_Type"=>"Enum",
+                            "Header"=>$Type2_Pure{"Header"},
+                            "Line"=>$Type2_Pure{"Line"},
+                            "Old_Value"=>$Type1_Pure{"Memb"}{$Member_Pos}{"value"},
+                            "New_Value"=>$Type2_Pure{"Memb"}{$MemberPair_Pos}{"value"}  );
+                    }
+                }
+            }
+            next;
+        }
+        my $MemberType1_Id = $Type1_Pure{"Memb"}{$Member_Pos}{"type"};
+        my $MemberType2_Id = $Type2_Pure{"Memb"}{$MemberPair_Pos}{"type"};
+        %Sub_SubProblems = detectTypeChange($MemberType1_Id, $MemberType2_Id, "Member");
+        foreach my $Sub_SubProblemType (keys(%Sub_SubProblems))
+        {
+            %{$SubProblems{$Sub_SubProblemType}{$Member_Name}}=(
+                "Target"=>$Member_Name,
+                "Member_Position"=>$Member_Pos,
+                "Type_Name"=>$Type1_Pure{"Name"},
+                "Type_Type"=>$Type1_Pure{"Type"},
+                "Header"=>$Type2_Pure{"Header"},
+                "Line"=>$Type2_Pure{"Line"});
+            @{$SubProblems{$Sub_SubProblemType}{$Member_Name}}{keys(%{$Sub_SubProblems{$Sub_SubProblemType}})} = values %{$Sub_SubProblems{$Sub_SubProblemType}};
+        }
+        if($MemberType1_Id and $MemberType2_Id)
+        {#checking member type change (replace)
+            %Sub_SubProblems = &mergeTypes($MemberType1_Id, $Tid_TDid{1}{$MemberType1_Id}, $MemberType2_Id, $Tid_TDid{2}{$MemberType2_Id});
+            foreach my $Sub_SubProblemType (keys(%Sub_SubProblems))
+            {
+                foreach my $Sub_SubLocation (keys(%{$Sub_SubProblems{$Sub_SubProblemType}}))
+                {
+                    my $NewLocation = ($Sub_SubLocation)?$Member_Location."->".$Sub_SubLocation:$Member_Location;
+                    %{$SubProblems{$Sub_SubProblemType}{$NewLocation}}=(
+                        "IsInTypeInternals"=>"Yes");
+                    @{$SubProblems{$Sub_SubProblemType}{$NewLocation}}{keys(%{$Sub_SubProblems{$Sub_SubProblemType}{$Sub_SubLocation}})} = values %{$Sub_SubProblems{$Sub_SubProblemType}{$Sub_SubLocation}};
+                    if($Sub_SubLocation !~ /\-\>/)
+                    {
+                        $SubProblems{$Sub_SubProblemType}{$NewLocation}{"Member_Type_Name"} = get_TypeName($MemberType1_Id, 1);
+                        $SubProblems{$Sub_SubProblemType}{$NewLocation}{"Start_Type_Name"} = get_TypeName($MemberType1_Id, 1);
+                    }
+                }
+            }
+        }
+    }
+    if(($Type2_Pure{"Type"} eq "Struct") or ($Type2_Pure{"Type"} eq "Class"))
+    {
+        foreach my $Member_Pos (sort keys(%{$Type2_Pure{"Memb"}}))
+        {#checking added members
+            next if(not $Type2_Pure{"Memb"}{$Member_Pos}{"name"});
+            my $MemberPair_Pos = find_MemberPair_Pos_byName($Type2_Pure{"Memb"}{$Member_Pos}{"name"}, \%Type1_Pure);
+            if($MemberPair_Pos eq "lost")
+            {#Added_Member
+                if($Member_Pos > keys(%{$Type1_Pure{"Memb"}}) - 1)
+                {
+                    if($Type1_Pure{"Size"} ne $Type2_Pure{"Size"})
+                    {
+                        if($Type2_Pure{"Memb"}{$Member_Pos}{"bitfield"})
+                        {
+                            my $BitfieldSum = getBitfieldSum($Member_Pos-1, \%Type2_Pure)%($POINTER_SIZE*8);
+                            next if($BitfieldSum and $BitfieldSum<=$POINTER_SIZE*8-$Type2_Pure{"Memb"}{$Member_Pos}{"bitfield"});
+                        }
+                        %{$SubProblems{"Added_Member_And_Size"}{$Type2_Pure{"Memb"}{$Member_Pos}{"name"}}}=(
+                            "Target"=>$Type2_Pure{"Memb"}{$Member_Pos}{"name"},
+                            "Type_Name"=>$Type1_Pure{"Name"},
+                            "Type_Type"=>$Type1_Pure{"Type"},
+                            "Header"=>$Type2_Pure{"Header"},
+                            "Line"=>$Type2_Pure{"Line"}  );
+                    }
+                }
+                else
+                {
+                    my $MemberType_Id = $Type2_Pure{"Memb"}{$Member_Pos}{"type"};
+                    my $MemberType_DId = $Tid_TDid{2}{$MemberType_Id};
+                    my %MemberType_Pure = get_PureType($MemberType_DId, $MemberType_Id, 2);
+                    
+                    my $MemberStraightPairType_Id = $Type1_Pure{"Memb"}{$Member_Pos}{"type"};
+                    my %MemberStraightPairType_Pure = get_PureType($Tid_TDid{1}{$MemberStraightPairType_Id}, $MemberStraightPairType_Id, 1);
+                    
+                    if(($MemberType_Pure{"Size"} eq $MemberStraightPairType_Pure{"Size"}) and find_MemberPair_Pos_byName($Type1_Pure{"Memb"}{$Member_Pos}{"name"}, \%Type2_Pure) eq "lost")
+                    {
+                        next if($Type1_Pure{"Memb"}{$Member_Pos}{"access"} eq "private");
+                        %{$SubProblems{"Member_Rename"}{$Type2_Pure{"Memb"}{$Member_Pos}{"name"}}}=(
+                            "Target"=>$Type1_Pure{"Memb"}{$Member_Pos}{"name"},
+                            "Type_Name"=>$Type1_Pure{"Name"},
+                            "Type_Type"=>$Type1_Pure{"Type"},
+                            "Header"=>$Type2_Pure{"Header"},
+                            "Line"=>$Type2_Pure{"Line"},
+                            "Old_Value"=>$Type1_Pure{"Memb"}{$Member_Pos}{"name"},
+                            "New_Value"=>$Type2_Pure{"Memb"}{$Member_Pos}{"name"}  );
+                    }
+                    else
+                    {
+                        if($Type1_Pure{"Size"} ne $Type2_Pure{"Size"})
+                        {
+                            if($Type2_Pure{"Memb"}{$Member_Pos}{"bitfield"})
+                            {
+                                my $BitfieldSum = getBitfieldSum($Member_Pos-1, \%Type2_Pure)%($POINTER_SIZE*8);
+                                next if($BitfieldSum and $BitfieldSum<=$POINTER_SIZE*8-$Type2_Pure{"Memb"}{$Member_Pos}{"bitfield"});
+                            }
+                            %{$SubProblems{"Added_Middle_Member_And_Size"}{$Type2_Pure{"Memb"}{$Member_Pos}{"name"}}}=(
+                                "Target"=>$Type2_Pure{"Memb"}{$Member_Pos}{"name"},
+                                "Type_Name"=>$Type1_Pure{"Name"},
+                                "Type_Type"=>$Type1_Pure{"Type"},
+                                "Header"=>$Type2_Pure{"Header"},
+                                "Line"=>$Type2_Pure{"Line"}  );
+                        }
+                    }
+                }
+            }
+        }
+    }
+    %{$Cache{"mergeTypes"}{$Type1_Id}{$Type1_DId}{$Type2_Id}{$Type2_DId}} = %SubProblems;
+	pop(@RecurTypes);
+    return %SubProblems;
+}
+
+sub get_TypeName($$)
+{
+    my ($TypeId, $LibVersion) = @_;
+    return $TypeDescr{$LibVersion}{$Tid_TDid{$LibVersion}{$TypeId}}{$TypeId}{"Name"};
+}
+
+sub goToFirst($$$$)
+{
+    my ($TypeDId, $TypeId, $LibVersion, $Type_Type) = @_;
+    if(defined $Cache{"goToFirst"}{$TypeDId}{$TypeId}{$LibVersion}{$Type_Type})
+    {
+        return %{$Cache{"goToFirst"}{$TypeDId}{$TypeId}{$LibVersion}{$Type_Type}};
+    }
+    return () if(not $TypeDescr{$LibVersion}{$TypeDId}{$TypeId});
+    my %Type = %{$TypeDescr{$LibVersion}{$TypeDId}{$TypeId}};
+    return () if(not $Type{"Type"});
+    if($Type{"Type"} ne $Type_Type)
+    {
+        return () if(not $Type{"BaseType"}{"TDid"} and not $Type{"BaseType"}{"Tid"});
+        %Type = goToFirst($Type{"BaseType"}{"TDid"}, $Type{"BaseType"}{"Tid"}, $LibVersion, $Type_Type);
+    }
+    $Cache{"goToFirst"}{$TypeDId}{$TypeId}{$LibVersion}{$Type_Type} = \%Type;
+    return %Type;
+}
+
+my %TypeSpecAttributes = (
+    "Ref" => 1,
+    "Const" => 1,
+    "Volatile" => 1,
+    "Restrict" => 1,
+    "Typedef" => 1
+);
+
+sub get_PureType($$$)
+{
+    my ($TypeDId, $TypeId, $LibVersion) = @_;
+    return "" if(not $TypeId);
+    if(defined $Cache{"get_PureType"}{$TypeDId}{$TypeId}{$LibVersion})
+    {
+        return %{$Cache{"get_PureType"}{$TypeDId}{$TypeId}{$LibVersion}};
+    }
+    return "" if(not $TypeDescr{$LibVersion}{$TypeDId}{$TypeId});
+    my %Type = %{$TypeDescr{$LibVersion}{$TypeDId}{$TypeId}};
+    if($Type{"Type"} =~ /Struct|Union|Typedef|Class|Enum/)
+    {
+        $CheckedTypes{$Type{"Name"}} = 1;
+    }
+    return %Type if(not $Type{"BaseType"}{"TDid"} and not $Type{"BaseType"}{"Tid"});
+    if($TypeSpecAttributes{$Type{"Type"}})
+    {
+        %Type = get_PureType($Type{"BaseType"}{"TDid"}, $Type{"BaseType"}{"Tid"}, $LibVersion);
+    }
+    $Cache{"get_PureType"}{$TypeDId}{$TypeId}{$LibVersion} = \%Type;
+    return %Type;
+}
+
+sub get_PointerLevel($$$)
+{
+    my ($TypeDId, $TypeId, $LibVersion) = @_;
+    return "" if(not $TypeId);
+    if(defined $Cache{"get_PointerLevel"}{$TypeDId}{$TypeId}{$LibVersion})
+    {
+        return $Cache{"get_PointerLevel"}{$TypeDId}{$TypeId}{$LibVersion};
+    }
+    return "" if(not $TypeDescr{$LibVersion}{$TypeDId}{$TypeId});
+    my %Type = %{$TypeDescr{$LibVersion}{$TypeDId}{$TypeId}};
+    return 0 if(not $Type{"BaseType"}{"TDid"} and not $Type{"BaseType"}{"Tid"});
+    my $PointerLevel = 0;
+    if($Type{"Type"} eq "Pointer")
+    {
+        $PointerLevel += 1;
+    }
+    $PointerLevel += get_PointerLevel($Type{"BaseType"}{"TDid"}, $Type{"BaseType"}{"Tid"}, $LibVersion);
+    $Cache{"get_PointerLevel"}{$TypeDId}{$TypeId}{$LibVersion} = $PointerLevel;
+    return $PointerLevel;
+}
+
+sub get_BaseType($$$)
+{
+    my ($TypeDId, $TypeId, $LibVersion) = @_;
+    return "" if(not $TypeId);
+    if(defined $Cache{"get_BaseType"}{$TypeDId}{$TypeId}{$LibVersion})
+    {
+        return %{$Cache{"get_BaseType"}{$TypeDId}{$TypeId}{$LibVersion}};
+    }
+    return "" if(not $TypeDescr{$LibVersion}{$TypeDId}{$TypeId});
+    my %Type = %{$TypeDescr{$LibVersion}{$TypeDId}{$TypeId}};
+    if($Type{"Type"} =~ /Struct|Union|Typedef|Class|Enum/)
+    {
+        $CheckedTypes{$Type{"Name"}} = 1;
+    }
+    return %Type if(not $Type{"BaseType"}{"TDid"} and not $Type{"BaseType"}{"Tid"});
+    %Type = get_BaseType($Type{"BaseType"}{"TDid"}, $Type{"BaseType"}{"Tid"}, $LibVersion);
+    $Cache{"get_BaseType"}{$TypeDId}{$TypeId}{$LibVersion} = \%Type;
+    return %Type;
+}
+
+sub get_OneStep_BaseType($$$)
+{
+    my ($TypeDId, $TypeId, $LibVersion) = @_;
+    return "" if(not $TypeId);
+    return "" if(not $TypeDescr{$LibVersion}{$TypeDId}{$TypeId});
+    my %Type = %{$TypeDescr{$LibVersion}{$TypeDId}{$TypeId}};
+    return %Type if(not $Type{"BaseType"}{"TDid"} and not $Type{"BaseType"}{"Tid"});
+    return get_Type($Type{"BaseType"}{"TDid"}, $Type{"BaseType"}{"Tid"}, $LibVersion);
+}
+
+sub get_Type($$$)
+{
+    my ($TypeDId, $TypeId, $LibVersion) = @_;
+    return "" if(not $TypeId);
+    return "" if(not $TypeDescr{$LibVersion}{$TypeDId}{$TypeId});
+    return %{$TypeDescr{$LibVersion}{$TypeDId}{$TypeId}};
+}
+
+sub mergeLibs()
+{
+    foreach my $Interface (sort keys(%AddedInt))
+    {#checking added interfaces
+        next if($InternalInterfaces{1}{$Interface} or $InternalInterfaces{2}{$Interface});
+        next if(defined $InterfacesListPath and not $InterfacesList{$Interface});
+        next if(defined $AppPath and not $InterfacesList_App{$Interface});
+        next if($FuncAttr{2}{$Interface}{"Private"});
+        next if(not $FuncAttr{2}{$Interface}{"Header"});
+        %{$CompatProblems{$Interface}{"Added_Interface"}{"SharedLibrary"}}=(
+            "Header"=>$FuncAttr{2}{$Interface}{"Header"},
+            "Line"=>$FuncAttr{2}{$Interface}{"Line"},
+            "Signature"=>$FuncAttr{2}{$Interface}{"Signature"},
+            "New_SoName"=>$Interface_Library{2}{$Interface}  );
+    }
+    foreach my $Interface (sort keys(%WithdrawnInt))
+    {#checking withdrawn interfaces
+        next if($InternalInterfaces{1}{$Interface} or $InternalInterfaces{2}{$Interface});
+        next if(defined $InterfacesListPath and not $InterfacesList{$Interface});
+        next if(defined $AppPath and not $InterfacesList_App{$Interface});
+        next if($FuncAttr{1}{$Interface}{"Private"});
+        next if(not $FuncAttr{1}{$Interface}{"Header"});
+        %{$CompatProblems{$Interface}{"Withdrawn_Interface"}{"SharedLibrary"}}=(
+            "Header"=>$FuncAttr{1}{$Interface}{"Header"},
+            "Line"=>$FuncAttr{1}{$Interface}{"Line"},
+            "Signature"=>$FuncAttr{1}{$Interface}{"Signature"},
+            "Old_SoName"=>$Interface_Library{1}{$Interface}  );
+    }
+}
+
+sub mergeSignatures()
+{
+    my %SubProblems = ();
+    
+	prepareInterfaces(1);
+	prepareInterfaces(2);
+    %FuncDescr=();
+    
+    initializeClassVirtFunc(1);
+    initializeClassVirtFunc(2);
+    
+    checkVirtFuncRedefinitions(1);
+    checkVirtFuncRedefinitions(2);
+    
+    setVirtFuncPositions(1);
+    setVirtFuncPositions(2);
+    
+    foreach my $Interface (sort keys(%AddedInt))
+    {#collecting the attributes of added interfaces
+        next if($CheckedInterfaces{$Interface});
+        if($CompleteSignature{2}{$Interface})
+        {
+            if($CompleteSignature{2}{$Interface}{"Private"})
+            {
+                $FuncAttr{2}{$Interface}{"Private"} = 1;
+            }
+            if($CompleteSignature{2}{$Interface}{"Protected"})
+            {
+                $FuncAttr{2}{$Interface}{"Protected"} = 1;
+            }
+            if($CompleteSignature{2}{$Interface}{"Header"})
+            {
+                $FuncAttr{2}{$Interface}{"Header"} = $CompleteSignature{2}{$Interface}{"Header"};
+            }
+            if($CompleteSignature{2}{$Interface}{"Line"})
+            {
+                $FuncAttr{2}{$Interface}{"Line"} = $CompleteSignature{2}{$Interface}{"Line"};
+            }
+            $FuncAttr{2}{$Interface}{"Signature"} = get_Signature($Interface, 2);
+            foreach my $ParamPos (keys(%{$CompleteSignature{2}{$Interface}{"Param"}}))
+            {
+                my $ParamType_Id = $CompleteSignature{2}{$Interface}{"Param"}{$ParamPos}{"type"};
+                my $ParamType_DId = $Tid_TDid{2}{$ParamType_Id};
+                my %ParamType = get_Type($ParamType_DId, $ParamType_Id, 2);
+            }
+            #checking virtual table
+            check_VirtualTable($Interface, 2);
+            $CheckedInterfaces{$Interface} = 1;
+        }
+    }
+    foreach my $Interface (sort keys(%WithdrawnInt))
+    {#collecting the attributes of withdrawn interfaces
+        next if($CheckedInterfaces{$Interface});
+        if($CompleteSignature{1}{$Interface})
+        {
+            if($CompleteSignature{1}{$Interface}{"Private"})
+            {
+                $FuncAttr{1}{$Interface}{"Private"} = 1;
+            }
+            if($CompleteSignature{1}{$Interface}{"Protected"})
+            {
+                $FuncAttr{1}{$Interface}{"Protected"} = 1;
+            }
+            if($CompleteSignature{1}{$Interface}{"Header"})
+            {
+                $FuncAttr{1}{$Interface}{"Header"} = $CompleteSignature{1}{$Interface}{"Header"};
+            }
+            if($CompleteSignature{1}{$Interface}{"Line"})
+            {
+                $FuncAttr{1}{$Interface}{"Line"} = $CompleteSignature{1}{$Interface}{"Line"};
+            }
+            $FuncAttr{1}{$Interface}{"Signature"} = get_Signature($Interface, 1);
+            foreach my $ParamPos (keys(%{$CompleteSignature{1}{$Interface}{"Param"}}))
+            {
+                my $ParamType_Id = $CompleteSignature{1}{$Interface}{"Param"}{$ParamPos}{"type"};
+                my $ParamType_DId = $Tid_TDid{1}{$ParamType_Id};
+                my %ParamType = get_Type($ParamType_DId, $ParamType_Id, 1);
+            }
+            #checking virtual table
+            check_VirtualTable($Interface, 1);
+            $CheckedInterfaces{$Interface} = 1;
+        }
+    }
+    
+	foreach my $Interface (sort keys(%{$CompleteSignature{1}}))
+	{#checking interfaces
+        if(($Interface !~ /\@/) and ($SymVer{1}{$Interface} =~ /\A(.*)[\@]+/))
+        {
+            next if($1 eq $Interface);
+        }
+        my ($MnglName, $SymbolVersion) = ($Interface, "");
+        if($Interface =~ /\A([^@]+)[\@]+([^@]+)\Z/)
+        {
+            ($MnglName, $SymbolVersion) = ($1, $2);
+        }
+        next if($InternalInterfaces{1}{$Interface} or $InternalInterfaces{2}{$Interface});
+        next if(defined $InterfacesListPath and not $InterfacesList{$Interface});
+        next if(defined $AppPath and not $InterfacesList_App{$Interface});
+        next if($CheckedInterfaces{$Interface});
+        next if($CompleteSignature{1}{$Interface}{"Private"});
+        next if(not $CompleteSignature{1}{$Interface}{"Header"} or not $CompleteSignature{2}{$Interface}{"Header"});
+		next if(not $CompleteSignature{1}{$Interface}{"MnglName"} or not $CompleteSignature{2}{$Interface}{"MnglName"});
+        next if((not $CompleteSignature{1}{$Interface}{"PureVirt"} and $CompleteSignature{2}{$Interface}{"PureVirt"}) or ($CompleteSignature{1}{$Interface}{"PureVirt"} and not $CompleteSignature{2}{$Interface}{"PureVirt"}));
+        $CheckedInterfaces{$Interface} = 1;
+        #checking virtual table
+        check_VirtualTable($Interface, 1);
+        #checking attributes
+		if($CompleteSignature{2}{$Interface}{"Static"} and not $CompleteSignature{1}{$Interface}{"Static"})
+		{
+            %{$CompatProblems{$Interface}{"Function_Become_Static"}{"Attributes"}}=(
+                "Header"=>$CompleteSignature{1}{$Interface}{"Header"},
+                "Line"=>$CompleteSignature{1}{$Interface}{"Line"},
+                "Signature"=>get_Signature($Interface, 1),
+                "Old_SoName"=>$Interface_Library{1}{$Interface},
+                "New_SoName"=>$Interface_Library{2}{$Interface}  );
+		}
+		elsif(not $CompleteSignature{2}{$Interface}{"Static"} and $CompleteSignature{1}{$Interface}{"Static"})
+		{
+            %{$CompatProblems{$Interface}{"Function_Become_NonStatic"}{"Attributes"}}=(
+                "Header"=>$CompleteSignature{1}{$Interface}{"Header"},
+                "Line"=>$CompleteSignature{1}{$Interface}{"Line"},
+                "Signature"=>get_Signature($Interface, 1),
+                "Old_SoName"=>$Interface_Library{1}{$Interface},
+                "New_SoName"=>$Interface_Library{2}{$Interface}  );
+		}
+        if($CompleteSignature{1}{$Interface}{"Virt"} and $CompleteSignature{2}{$Interface}{"Virt"})
+        {
+            if($CompleteSignature{1}{$Interface}{"Position"}!=$CompleteSignature{2}{$Interface}{"Position"})
+            {
+                my $Class_Id = $CompleteSignature{1}{$Interface}{"Class"};
+                my $Class_DId = $Tid_TDid{1}{$Class_Id};
+                my %Class_Type = get_Type($Class_DId, $Class_Id, 1);
+                %{$CompatProblems{$Interface}{"Virtual_Function_Position"}{$tr_name{$MnglName}}}=(
+                "Type_Name"=>$Class_Type{"Name"},