Move ApiExtractor into ApiExtractor directory to ease the merge into Shiboken.

206 files changed, 41665 insertions, 0 deletions

diff --git a/ApiExtractor/AUTHORS b/ApiExtractor/AUTHORS
new file mode 100644
index 000000000..6e802fb53
--- /dev/null
+++ b/ApiExtractor/AUTHORS
@@ -0,0 +1,8 @@
+Anderson Lizardo <anderson.lizardo@openbossa.org>
+Bruno Araujo <bruno.araujo@openbossa.org>
+Hugo Parente Lima <hugo.lima@openbossa.org>
+Lauro Moura <lauro.neto@openbossa.org>
+Luciano Wolf <luciano.wolf@openbossa.org>
+Marcelo Lira <marcelo.lira@openbossa.org>
+Renato Araujo Oliveira Filho <renato.filho@openbossa.org>
+
diff --git a/ApiExtractor/CMakeLists.txt b/ApiExtractor/CMakeLists.txt
new file mode 100644
index 000000000..a7280d114
--- /dev/null
+++ b/ApiExtractor/CMakeLists.txt
@@ -0,0 +1,179 @@
+include(icecc.cmake)
+project(apiextractor)
+
+cmake_minimum_required(VERSION 2.6)
+
+find_package(Qt4 4.5.0 REQUIRED)
+
+find_package(LibXml2 2.6.32)
+find_package(LibXslt 1.1.19)
+
+option(DISABLE_DOCSTRINGS "Disable documentation extraction." FALSE)
+option(BUILD_TESTS "Build tests." TRUE)
+option(INSTALL_TESTS "Install tests" FALSE)
+option(ENABLE_VERSION_SUFFIX "Used to use current version in suffix to generated files. This is used to allow multiples versions installed simultaneous." FALSE)
+
+if (NOT DISABLE_DOCSTRINGS)
+    if (NOT LIBXSLT_FOUND OR NOT LIBXML2_FOUND)
+        set(DISABLE_DOCSTRINGS TRUE)
+        message(WARNING "libxslt and/or libxml not found, disabling support to doc strings!")
+    endif()
+endif()
+
+if(MSVC)
+    set(CMAKE_CXX_FLAGS "/Zc:wchar_t- /GR /EHsc /DWIN32 /D_WINDOWS /D_SCL_SECURE_NO_WARNINGS")
+elseif(CMAKE_HOST_UNIX)
+    option(ENABLE_GCC_OPTIMIZATION "Enable specific GCC flags to optimize library size and performance. Only available on Release Mode" 0)
+    if(NOT CYGWIN)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -fvisibility=hidden")
+    endif()
+    set(CMAKE_CXX_FLAGS_DEBUG "-g")
+    if(ENABLE_GCC_OPTIMIZATION)
+        set(CMAKE_BUILD_TYPE Release)
+        set(CMAKE_CXX_FLAGS_RELEASE "-DNDEBUG -Os -Wno-strict-aliasing -Wl,-O1")
+        if (NOT CMAKE_HOST_APPLE)
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,--hash-style=gnu")
+        endif()
+    endif()
+    if(NOT CMAKE_HOST_APPLE)
+        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--version-script,${CMAKE_CURRENT_SOURCE_DIR}/symbols.filter")
+    endif()
+endif()
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release)
+endif()
+
+if(BUILD_TESTS)
+    set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/tests)
+endif ()
+
+set(apiextractor_MAJOR_VERSION 0)
+set(apiextractor_MINOR_VERSION 10)
+set(apiextractor_MICRO_VERSION 11)
+set(apiextractor_VERSION "${apiextractor_MAJOR_VERSION}.${apiextractor_MINOR_VERSION}.${apiextractor_MICRO_VERSION}")
+configure_file(apiextractorversion.h.in ${CMAKE_CURRENT_BINARY_DIR}/apiextractorversion.h @ONLY)
+set(apiextractor_SOVERSION ${apiextractor_MAJOR_VERSION}.${apiextractor_MINOR_VERSION})
+set(QT_USE_QTCORE 1)
+set(QT_USE_QTXML 1)
+include(${QT_USE_FILE})
+add_definitions(${QT_DEFINITIONS})
+add_definitions(-DQT_PLUGIN)
+add_definitions(-DQT_SHARED)
+add_definitions(-DRXX_ALLOCATOR_INIT_0)
+
+if(ENABLE_VERSION_SUFFIX)
+    set(apiextractor_SUFFIX "-${apiextractor_MAJOR_VERSION}.${apiextractor_MINOR_VERSION}")
+else()
+    set(apiextractor_SUFFIX "")
+endif()
+
+set(apiextractor_SRC
+apiextractor.cpp
+abstractmetabuilder.cpp
+abstractmetalang.cpp
+asttoxml.cpp
+fileout.cpp
+graph.cpp
+reporthandler.cpp
+typeparser.cpp
+typesystem.cpp
+include.cpp
+typedatabase.cpp
+parser/ast.cpp
+parser/binder.cpp
+parser/class_compiler.cpp
+parser/codemodel.cpp
+parser/codemodel_finder.cpp
+parser/compiler_utils.cpp
+parser/control.cpp
+parser/declarator_compiler.cpp
+parser/default_visitor.cpp
+parser/dumptree.cpp
+parser/lexer.cpp
+parser/list.cpp
+parser/name_compiler.cpp
+parser/parser.cpp
+parser/smallobject.cpp
+parser/tokens.cpp
+parser/type_compiler.cpp
+parser/visitor.cpp
+parser/rpp/builtin-macros.cpp
+parser/rpp/preprocessor.cpp
+)
+
+if (NOT DISABLE_DOCSTRINGS)
+    set(apiextractor_SRC
+        ${apiextractor_SRC}
+        docparser.cpp
+        doxygenparser.cpp
+        qtdocparser.cpp
+    )
+    set(APIEXTRACTOR_EXTRA_INCLUDES ${LIBXSLT_INCLUDE_DIR} ${LIBXML2_INCLUDE_DIR})
+    set(APIEXTRACTOR_EXTRA_LIBRARIES ${LIBXSLT_LIBRARIES} ${LIBXML2_LIBRARIES})
+else()
+    set(APIEXTRACTOR_EXTRA_INCLUDES "")
+    set(APIEXTRACTOR_EXTRA_LIBRARIES "")
+endif()
+
+set(LIB_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}" CACHE PATH "The subdirectory relative to the install prefix where libraries will be installed (default is /lib${LIB_SUFFIX})" FORCE)
+
+qt4_add_resources(apiextractor_RCCS_SRC generator.qrc)
+qt4_automoc(apiextractor_SRC)
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}
+                    ${CMAKE_CURRENT_BINARY_DIR}
+                    ${CMAKE_CURRENT_SOURCE_DIR}/parser
+                    ${CMAKE_CURRENT_SOURCE_DIR}/parser/rpp
+                    ${QT_INCLUDE_DIR}
+                    ${APIEXTRACTOR_EXTRA_INCLUDES}
+                    )
+
+add_library(apiextractor SHARED ${apiextractor_SRC} ${apiextractor_RCCS_SRC})
+target_link_libraries(apiextractor ${APIEXTRACTOR_EXTRA_LIBRARIES} ${QT_QTCORE_LIBRARY} ${QT_QTXMLPATTERNS_LIBRARY} ${QT_QTXML_LIBRARY})
+set_target_properties(apiextractor PROPERTIES VERSION ${apiextractor_VERSION}
+                                              SOVERSION ${apiextractor_SOVERSION}
+                                              OUTPUT_NAME "apiextractor${apiextractor_SUFFIX}"
+                                              DEFINE_SYMBOL APIEXTRACTOR_EXPORTS)
+
+# uninstall target
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake" "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" IMMEDIATE @ONLY)
+add_custom_target(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
+
+set(ARCHIVE_NAME ${CMAKE_PROJECT_NAME}-${apiextractor_VERSION})
+add_custom_target(dist
+    COMMAND mkdir -p "${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}" &&
+            git log > "${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}/ChangeLog" &&
+            git archive --prefix=${ARCHIVE_NAME}/ HEAD --format=tar --output="${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}.tar" &&
+            tar -C "${CMAKE_BINARY_DIR}" --owner=root --group=root -r "${ARCHIVE_NAME}/ChangeLog" -f "${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}.tar" &&
+            bzip2 -f9 "${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}.tar" &&
+            echo "Source package created at ${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}.tar.bz2.\n"
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+
+set(root_HEADERS
+apiextractormacros.h
+abstractmetalang.h
+apiextractor.h
+graph.h
+reporthandler.h
+typesystem.h
+fileout.h
+docparser.h
+qtdocparser.h
+include.h
+typedatabase.h
+doxygenparser.h
+)
+
+if (BUILD_TESTS)
+    enable_testing()
+    add_subdirectory(tests)
+endif()
+add_subdirectory(data)
+add_subdirectory(doc)
+
+install(FILES ${root_HEADERS} DESTINATION include/apiextractor${apiextractor_SUFFIX})
+install(TARGETS apiextractor EXPORT apiextractor
+                             LIBRARY DESTINATION "${LIB_INSTALL_DIR}"
+                             ARCHIVE DESTINATION "${LIB_INSTALL_DIR}"
+                             RUNTIME DESTINATION bin)
diff --git a/ApiExtractor/COPYING b/ApiExtractor/COPYING
new file mode 100644
index 000000000..4ccd71466
--- /dev/null
+++ b/ApiExtractor/COPYING
@@ -0,0 +1,342 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       51 Franklin St, Fifth Floor, Boston, MA  02110-1301  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) <year>  <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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  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) year 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.
+
+-------------------------------------------------------------------------
diff --git a/ApiExtractor/abstractmetabuilder.cpp b/ApiExtractor/abstractmetabuilder.cpp
new file mode 100644
index 000000000..1d01e9ce2
--- /dev/null
+++ b/ApiExtractor/abstractmetabuilder.cpp
@@ -0,0 +1,2962 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "abstractmetabuilder.h"
+#include "reporthandler.h"
+#include "typedatabase.h"
+
+#include "parser/ast.h"
+#include "parser/binder.h"
+#include "parser/control.h"
+#include "parser/default_visitor.h"
+#include "parser/dumptree.h"
+#include "parser/lexer.h"
+#include "parser/parser.h"
+#include "parser/tokens.h"
+
+#include <QDebug>
+#include <QFile>
+#include <QFileInfo>
+#include <QTextCodec>
+#include <QTextStream>
+#include <QVariant>
+#include <QTime>
+#include <QQueue>
+#include <QDir>
+
+#include <cstdio>
+#include <algorithm>
+#include "graph.h"
+#include <QTemporaryFile>
+
+static QString stripTemplateArgs(const QString &name)
+{
+    int pos = name.indexOf('<');
+    return pos < 0 ? name : name.left(pos);
+}
+
+AbstractMetaBuilder::AbstractMetaBuilder() : m_currentClass(0), m_logDirectory(QString('.')+QDir::separator())
+{
+}
+
+AbstractMetaBuilder::~AbstractMetaBuilder()
+{
+    qDeleteAll(m_globalEnums);
+    qDeleteAll(m_globalFunctions);
+    qDeleteAll(m_templates);
+    qDeleteAll(m_metaClasses);
+}
+
+void AbstractMetaBuilder::checkFunctionModifications()
+{
+    TypeDatabase *types = TypeDatabase::instance();
+    SingleTypeEntryHash entryHash = types->entries();
+    QList<TypeEntry*> entries = entryHash.values();
+
+    foreach (TypeEntry* entry, entries) {
+        if (!entry)
+            continue;
+        if (!entry->isComplex() || entry->codeGeneration() == TypeEntry::GenerateNothing)
+            continue;
+
+        ComplexTypeEntry* centry = static_cast<ComplexTypeEntry*>(entry);
+        FunctionModificationList modifications = centry->functionModifications();
+
+        foreach (FunctionModification modification, modifications) {
+            QString signature = modification.signature;
+
+            QString name = signature.trimmed();
+            name = name.mid(0, signature.indexOf("("));
+
+            AbstractMetaClass* clazz = m_metaClasses.findClass(centry->qualifiedCppName());
+            if (!clazz)
+                continue;
+
+            AbstractMetaFunctionList functions = clazz->functions();
+            bool found = false;
+            QStringList possibleSignatures;
+            foreach (AbstractMetaFunction *function, functions) {
+                if (function->minimalSignature() == signature && function->implementingClass() == clazz) {
+                    found = true;
+                    break;
+                }
+
+                if (function->originalName() == name)
+                    possibleSignatures.append(function->minimalSignature() + " in " + function->implementingClass()->name());
+            }
+
+            if (!found) {
+                QString warning
+                = QString("signature '%1' for function modification in '%2' not found. Possible candidates: %3")
+                  .arg(signature)
+                  .arg(clazz->qualifiedCppName())
+                  .arg(possibleSignatures.join(", "));
+
+                ReportHandler::warning(warning);
+            }
+        }
+    }
+}
+
+AbstractMetaClass* AbstractMetaBuilder::argumentToClass(ArgumentModelItem argument)
+{
+    AbstractMetaClass* returned = 0;
+    bool ok = false;
+    AbstractMetaType* type = translateType(argument->type(), &ok);
+    if (ok && type && type->typeEntry() && type->typeEntry()->isComplex()) {
+        const TypeEntry *entry = type->typeEntry();
+        returned = m_metaClasses.findClass(entry->name());
+    }
+    delete type;
+    return returned;
+}
+
+/**
+ * Checks the argument of a hash function and flags the type if it is a complex type
+ */
+void AbstractMetaBuilder::registerHashFunction(FunctionModelItem function_item)
+{
+    ArgumentList arguments = function_item->arguments();
+    if (arguments.size() == 1) {
+        if (AbstractMetaClass *cls = argumentToClass(arguments.at(0)))
+            cls->setHasHashFunction(true);
+    }
+}
+
+/**
+ * Check if a class has a debug stream operator that can be used as toString
+ */
+
+void AbstractMetaBuilder::registerToStringCapability(FunctionModelItem function_item)
+{
+    ArgumentList arguments = function_item->arguments();
+    if (arguments.size() == 2) {
+        if (arguments.at(0)->type().toString() == "QDebug") {
+            ArgumentModelItem arg = arguments.at(1);
+            if (AbstractMetaClass *cls = argumentToClass(arg)) {
+                if (arg->type().indirections() < 2)
+                    cls->setToStringCapability(true);
+            }
+        }
+    }
+}
+
+void AbstractMetaBuilder::traverseOperatorFunction(FunctionModelItem item)
+{
+    if (item->accessPolicy() != CodeModel::Public)
+        return;
+
+    ArgumentList arguments = item->arguments();
+    AbstractMetaClass* baseoperandClass;
+    bool firstArgumentIsSelf = true;
+    bool unaryOperator = false;
+
+    baseoperandClass = argumentToClass(arguments.at(0));
+
+    if (arguments.size() == 1) {
+        unaryOperator = true;
+    } else if (!baseoperandClass
+               || !(baseoperandClass->typeEntry()->codeGeneration() & TypeEntry::GenerateTargetLang)) {
+        baseoperandClass = argumentToClass(arguments.at(1));
+        firstArgumentIsSelf = false;
+    } else {
+        bool ok;
+        AbstractMetaType* type = translateType(item->type(), &ok);
+        const TypeEntry* retType = ok ? type->typeEntry() : 0;
+        AbstractMetaClass* otherArgClass = argumentToClass(arguments.at(1));
+        if (otherArgClass && retType
+            && (retType->isValue() || retType->isObject())
+            && retType != baseoperandClass->typeEntry()
+            && retType == otherArgClass->typeEntry()) {
+            baseoperandClass = m_metaClasses.findClass(retType);
+            firstArgumentIsSelf = false;
+        }
+        delete type;
+    }
+
+    if (baseoperandClass) {
+        AbstractMetaClass* oldCurrentClass = m_currentClass;
+        m_currentClass = baseoperandClass;
+        AbstractMetaFunction *metaFunction = traverseFunction(item);
+        if (metaFunction && !metaFunction->isInvalid()) {
+            // Strip away first argument, since that is the containing object
+            AbstractMetaArgumentList arguments = metaFunction->arguments();
+            if (firstArgumentIsSelf || unaryOperator) {
+                AbstractMetaArgument* first = arguments.takeFirst();
+                if (!unaryOperator && first->type()->indirections())
+                    metaFunction->setPointerOperator(true);
+                delete first;
+                metaFunction->setArguments(arguments);
+            } else {
+                // If the operator method is not unary and the first operator is
+                // not of the same type of its owning class we suppose that it
+                // must be an reverse operator (e.g. CLASS::operator(TYPE, CLASS)).
+                // All operator overloads that operate over a class are already
+                // being added as member functions of that class by the API Extractor.
+                AbstractMetaArgument* last = arguments.takeLast();
+                if (last->type()->indirections())
+                    metaFunction->setPointerOperator(true);
+                delete last;
+
+                metaFunction->setArguments(arguments);
+                metaFunction->setReverseOperator(true);
+            }
+            metaFunction->setFunctionType(AbstractMetaFunction::NormalFunction);
+            metaFunction->setVisibility(AbstractMetaFunction::Public);
+            metaFunction->setOriginalAttributes(metaFunction->attributes());
+            setupFunctionDefaults(metaFunction, baseoperandClass);
+            baseoperandClass->addFunction(metaFunction);
+            Q_ASSERT(!metaFunction->wasPrivate());
+        } else if (metaFunction) {
+            delete metaFunction;
+        }
+
+        m_currentClass = oldCurrentClass;
+    }
+}
+
+void AbstractMetaBuilder::traverseStreamOperator(FunctionModelItem item)
+{
+    ArgumentList arguments = item->arguments();
+    if (arguments.size() == 2 && item->accessPolicy() == CodeModel::Public) {
+        AbstractMetaClass* streamClass = argumentToClass(arguments.at(0));
+        AbstractMetaClass* streamedClass = argumentToClass(arguments.at(1));
+
+        if (streamClass && streamedClass && (streamClass->isStream())) {
+            AbstractMetaClass *oldCurrentClass = m_currentClass;
+            m_currentClass = streamedClass;
+            AbstractMetaFunction *streamFunction = traverseFunction(item);
+
+            if (streamFunction && !streamFunction->isInvalid()) {
+                QString name = item->name();
+                streamFunction->setFunctionType(AbstractMetaFunction::GlobalScopeFunction);
+                // Strip first argument, since that is the containing object
+                AbstractMetaArgumentList arguments = streamFunction->arguments();
+                if (!streamClass->typeEntry()->generateCode())
+                    delete arguments.takeLast();
+                else
+                    delete arguments.takeFirst();
+
+                streamFunction->setArguments(arguments);
+
+                *streamFunction += AbstractMetaAttributes::Final;
+                *streamFunction += AbstractMetaAttributes::Public;
+                streamFunction->setOriginalAttributes(streamFunction->attributes());
+
+//              streamFunction->setType(0);
+
+                AbstractMetaClass *funcClass;
+
+                if (!streamClass->typeEntry()->generateCode()) {
+                    AbstractMetaArgumentList reverseArgs = reverseList(streamFunction->arguments());
+                    streamFunction->setArguments(reverseArgs);
+                    streamFunction->setReverseOperator(true);
+                    funcClass = streamedClass;
+                } else {
+                    funcClass = streamClass;
+                }
+
+                setupFunctionDefaults(streamFunction, funcClass);
+                funcClass->addFunction(streamFunction);
+                if (funcClass == streamClass)
+                    funcClass->typeEntry()->addExtraInclude(streamedClass->typeEntry()->include());
+                else
+                    funcClass->typeEntry()->addExtraInclude(streamClass->typeEntry()->include());
+
+                m_currentClass = oldCurrentClass;
+            } else if (streamFunction) {
+                delete streamFunction;
+            }
+
+        }
+    }
+}
+
+void AbstractMetaBuilder::fixQObjectForScope(TypeDatabase *types,
+                                             NamespaceModelItem scope)
+{
+    foreach (ClassModelItem item, scope->classes()) {
+        QString qualifiedName = item->qualifiedName().join("::");
+        TypeEntry* entry = types->findType(qualifiedName);
+        if (entry) {
+            if (isQObject(qualifiedName) && entry->isComplex())
+                ((ComplexTypeEntry*) entry)->setQObject(true);
+        }
+    }
+
+    foreach (NamespaceModelItem item, scope->namespaceMap().values()) {
+        if (scope != item)
+            fixQObjectForScope(types, item);
+    }
+}
+
+void AbstractMetaBuilder::sortLists()
+{
+    foreach (AbstractMetaClass *cls, m_metaClasses)
+        cls->sortFunctions();
+}
+
+bool AbstractMetaBuilder::build(QIODevice* input)
+{
+    Q_ASSERT(input);
+
+    if (!input->isOpen()) {
+        if (!input->open(QIODevice::ReadOnly))
+            return false;
+    }
+
+    TypeDatabase* types = TypeDatabase::instance();
+
+    QByteArray contents = input->readAll();
+    input->close();
+
+    Control control;
+    Parser p(&control);
+    pool __pool;
+
+    TranslationUnitAST* ast = p.parse(contents, contents.size(), &__pool);
+
+    CodeModel model;
+    Binder binder(&model, p.location());
+    m_dom = binder.run(ast);
+
+    pushScope(model_dynamic_cast<ScopeModelItem>(m_dom));
+
+    QHash<QString, ClassModelItem> typeMap = m_dom->classMap();
+
+    // fix up QObject's in the type system..
+    fixQObjectForScope(types, model_dynamic_cast<NamespaceModelItem>(m_dom));
+
+    // Start the generation...
+    ClassList typeValues = typeMap.values();
+    qSort(typeValues);
+    ClassList::iterator it = std::unique(typeValues.begin(), typeValues.end());
+    typeValues.erase(it, typeValues.end());
+
+    ReportHandler::setProgressReference(typeValues);
+    foreach (ClassModelItem item, typeValues) {
+        ReportHandler::progress("Generating class model...");
+        AbstractMetaClass *cls = traverseClass(item);
+        if (!cls)
+            continue;
+
+        addAbstractMetaClass(cls);
+    }
+    ReportHandler::flush();
+
+    // We need to know all global enums
+    QHash<QString, EnumModelItem> enumMap = m_dom->enumMap();
+    ReportHandler::setProgressReference(enumMap);
+    foreach (EnumModelItem item, enumMap) {
+        ReportHandler::progress("Generating enum model...");
+        AbstractMetaEnum *metaEnum = traverseEnum(item, 0, QSet<QString>());
+        if (metaEnum) {
+            if (metaEnum->typeEntry()->generateCode())
+                m_globalEnums << metaEnum;
+        }
+    }
+    ReportHandler::flush();
+
+    QHash<QString, NamespaceModelItem> namespaceMap = m_dom->namespaceMap();
+    NamespaceList namespaceTypeValues = namespaceMap.values();
+    qSort(namespaceTypeValues);
+    NamespaceList::iterator nsit = std::unique(namespaceTypeValues.begin(), namespaceTypeValues.end());
+    namespaceTypeValues.erase(nsit, namespaceTypeValues.end());
+
+    ReportHandler::setProgressReference(namespaceMap);
+    foreach (NamespaceModelItem item, namespaceTypeValues) {
+        ReportHandler::progress("Generating namespace model...");
+        AbstractMetaClass *metaClass = traverseNamespace(item);
+        if (metaClass)
+            m_metaClasses << metaClass;
+    }
+    ReportHandler::flush();
+
+    // Go through all typedefs to see if we have defined any
+    // specific typedefs to be used as classes.
+    TypeAliasList typeAliases = m_dom->typeAliases();
+    ReportHandler::setProgressReference(typeAliases);
+    foreach (TypeAliasModelItem typeAlias, typeAliases) {
+        ReportHandler::progress("Resolving typedefs...");
+        AbstractMetaClass* cls = traverseTypeAlias(typeAlias);
+        addAbstractMetaClass(cls);
+    }
+    ReportHandler::flush();
+
+    figureOutEnumValues();
+
+    foreach (ClassModelItem item, typeValues)
+        traverseClassMembers(item);
+
+    foreach (NamespaceModelItem item, namespaceTypeValues)
+        traverseNamespaceMembers(item);
+
+    // Global functions
+    foreach (FunctionModelItem func, m_dom->functions()) {
+        if (func->accessPolicy() != CodeModel::Public || func->name().startsWith("operator"))
+            continue;
+
+        FunctionTypeEntry* funcEntry = types->findFunctionType(func->name());
+        if (!funcEntry || !funcEntry->generateCode())
+            continue;
+
+        AbstractMetaFunction* metaFunc = traverseFunction(func);
+        if (!metaFunc)
+            continue;
+
+        if (!funcEntry->hasSignature(metaFunc->minimalSignature())) {
+            delete metaFunc;
+            continue;
+        }
+
+        applyFunctionModifications(metaFunc);
+
+        setInclude(funcEntry, func->fileName());
+        if (metaFunc->typeEntry())
+            delete metaFunc->typeEntry();
+
+        metaFunc->setTypeEntry(funcEntry);
+        m_globalFunctions << metaFunc;
+    }
+
+    ReportHandler::setProgressReference(m_metaClasses);
+    foreach (AbstractMetaClass* cls, m_metaClasses) {
+        ReportHandler::progress("Fixing class inheritance...");
+        if (!cls->isInterface() && !cls->isNamespace())
+            setupInheritance(cls);
+    }
+    ReportHandler::flush();
+
+    ReportHandler::setProgressReference(m_metaClasses);
+    foreach (AbstractMetaClass* cls, m_metaClasses) {
+        ReportHandler::progress("Detecting inconsistencies in class model...");
+        cls->fixFunctions();
+
+        if (!cls->typeEntry()) {
+            ReportHandler::warning(QString("class '%1' does not have an entry in the type system")
+                                   .arg(cls->name()));
+        } else {
+            bool couldAddDefaultCtors = !cls->isFinalInCpp() && !cls->isInterface() && !cls->isNamespace();
+            if (couldAddDefaultCtors) {
+                if (!cls->hasConstructors())
+                    cls->addDefaultConstructor();
+                if (cls->typeEntry()->isValue() && !cls->isAbstract() && !cls->hasCopyConstructor())
+                    cls->addDefaultCopyConstructor(ancestorHasPrivateCopyConstructor(cls));
+            }
+        }
+
+        if (cls->isAbstract() && !cls->isInterface())
+            cls->typeEntry()->setLookupName(cls->typeEntry()->targetLangName() + "$ConcreteWrapper");
+    }
+    ReportHandler::flush();
+
+    TypeEntryHash allEntries = types->allEntries();
+    ReportHandler::progress("Detecting inconsistencies in typesystem...");
+    foreach (QList<TypeEntry*> entries, allEntries) {
+        foreach (TypeEntry* entry, entries) {
+
+            if (entry->isPrimitive())
+                continue;
+
+            if ((entry->isValue() || entry->isObject())
+                && !entry->isString()
+                && !entry->isChar()
+                && !entry->isContainer()
+                && !entry->isCustom()
+                && !entry->isVariant()
+                && !m_metaClasses.findClass(entry->qualifiedCppName())) {
+                ReportHandler::warning(QString("type '%1' is specified in typesystem, but not defined. This could potentially lead to compilation errors.")
+                                    .arg(entry->qualifiedCppName()));
+            } else if (entry->generateCode() && entry->type() == TypeEntry::FunctionType) {
+                const FunctionTypeEntry* fte = static_cast<const FunctionTypeEntry*>(entry);
+                foreach (QString signature, fte->signatures()) {
+                    bool ok = false;
+                    foreach (AbstractMetaFunction* func, m_globalFunctions) {
+                        if (signature == func->minimalSignature()) {
+                            ok = true;
+                            break;
+                        }
+                    }
+                    if (!ok) {
+                        ReportHandler::warning(QString("Global function '%1' is specified in typesystem, but not defined. This could potentially lead to compilation errors.")
+                        .arg(signature));
+                    }
+                }
+            } else if (entry->isEnum()) {
+                const QString name = ((EnumTypeEntry*) entry)->targetLangQualifier();
+                AbstractMetaClass* cls = m_metaClasses.findClass(name);
+
+                bool enumFound = false;
+                if (cls) {
+                    enumFound = cls->findEnum(entry->targetLangName());
+                } else { // Global enum
+                    foreach (AbstractMetaEnum* metaEnum, m_enums) {
+                        if (metaEnum->typeEntry() == entry) {
+                            enumFound = true;
+                            break;
+                        }
+                    }
+                }
+                if (!enumFound) {
+                    entry->setCodeGeneration(TypeEntry::GenerateNothing);
+                    ReportHandler::warning(QString("enum '%1' is specified in typesystem, but not declared")
+                                           .arg(entry->qualifiedCppName()));
+                }
+
+            }
+        }
+    }
+    ReportHandler::flush();
+
+    {
+        FunctionList hashFunctions = m_dom->findFunctions("qHash");
+        foreach (FunctionModelItem item, hashFunctions)
+            registerHashFunction(item);
+    }
+
+    {
+        FunctionList hashFunctions = m_dom->findFunctions("operator<<");
+        foreach (FunctionModelItem item, hashFunctions)
+            registerToStringCapability(item);
+    }
+
+    {
+        FunctionList binaryOperators = m_dom->findFunctions("operator==")
+                                        + m_dom->findFunctions("operator!=")
+                                        + m_dom->findFunctions("operator<=")
+                                        + m_dom->findFunctions("operator>=")
+                                        + m_dom->findFunctions("operator<")
+                                        + m_dom->findFunctions("operator+")
+                                        + m_dom->findFunctions("operator/")
+                                        + m_dom->findFunctions("operator*")
+                                        + m_dom->findFunctions("operator-")
+                                        + m_dom->findFunctions("operator&")
+                                        + m_dom->findFunctions("operator|")
+                                        + m_dom->findFunctions("operator^")
+                                        + m_dom->findFunctions("operator~")
+                                        + m_dom->findFunctions("operator>");
+
+        foreach (FunctionModelItem item, binaryOperators)
+            traverseOperatorFunction(item);
+    }
+
+    {
+        FunctionList streamOperators = m_dom->findFunctions("operator<<") + m_dom->findFunctions("operator>>");
+        foreach (FunctionModelItem item, streamOperators)
+            traverseStreamOperator(item);
+    }
+
+    figureOutDefaultEnumArguments();
+    checkFunctionModifications();
+
+    // sort all classes topologically
+    m_metaClasses = classesTopologicalSorted();
+
+    foreach (AbstractMetaClass* cls, m_metaClasses) {
+//         setupEquals(cls);
+//         setupComparable(cls);
+        setupClonable(cls);
+        setupExternalConversion(cls);
+
+        // sort all inner classes topologically
+        if (!cls->typeEntry()->codeGeneration() || cls->innerClasses().size() < 2)
+            continue;
+
+        cls->setInnerClasses(classesTopologicalSorted(cls));
+    }
+
+    dumpLog();
+
+    sortLists();
+
+    m_currentClass = 0;
+
+    // Functions added to the module on the type system.
+    foreach (AddedFunction addedFunc, types->globalUserFunctions()) {
+        AbstractMetaFunction* metaFunc = traverseFunction(addedFunc);
+        metaFunc->setFunctionType(AbstractMetaFunction::NormalFunction);
+        m_globalFunctions << metaFunc;
+    }
+
+    std::puts("");
+    return true;
+}
+
+void AbstractMetaBuilder::setLogDirectory(const QString& logDir)
+{
+    m_logDirectory = logDir;
+    if (!m_logDirectory.endsWith(QDir::separator()))
+       m_logDirectory.append(QDir::separator());
+}
+
+void AbstractMetaBuilder::addAbstractMetaClass(AbstractMetaClass *cls)
+{
+    if (!cls)
+        return;
+
+    cls->setOriginalAttributes(cls->attributes());
+    if (cls->typeEntry()->isContainer()) {
+        m_templates << cls;
+    } else {
+        m_metaClasses << cls;
+        if (cls->typeEntry()->designatedInterface()) {
+            AbstractMetaClass* interface = cls->extractInterface();
+            m_metaClasses << interface;
+            ReportHandler::debugSparse(QString(" -> interface '%1'").arg(interface->name()));
+        }
+    }
+}
+
+AbstractMetaClass* AbstractMetaBuilder::traverseNamespace(NamespaceModelItem namespaceItem)
+{
+    QString namespaceName = (!m_namespacePrefix.isEmpty() ? m_namespacePrefix + "::" : QString()) + namespaceItem->name();
+    NamespaceTypeEntry *type = TypeDatabase::instance()->findNamespaceType(namespaceName);
+
+    if (TypeDatabase::instance()->isClassRejected(namespaceName)) {
+        m_rejectedClasses.insert(namespaceName, GenerationDisabled);
+        return 0;
+    }
+
+    if (!type) {
+        ReportHandler::warning(QString("namespace '%1' does not have a type entry").arg(namespaceName));
+        return 0;
+    }
+
+    AbstractMetaClass* metaClass = createMetaClass();
+    metaClass->setTypeEntry(type);
+
+    *metaClass += AbstractMetaAttributes::Public;
+
+    m_currentClass = metaClass;
+
+    ReportHandler::debugSparse(QString("namespace '%1.%2'")
+                               .arg(metaClass->package())
+                               .arg(namespaceItem->name()));
+
+    traverseEnums(model_dynamic_cast<ScopeModelItem>(namespaceItem), metaClass, namespaceItem->enumsDeclarations());
+
+    pushScope(model_dynamic_cast<ScopeModelItem>(namespaceItem));
+    m_namespacePrefix = currentScope()->qualifiedName().join("::");
+
+    ClassList classes = namespaceItem->classes();
+    foreach (ClassModelItem cls, classes) {
+        AbstractMetaClass* mjc = traverseClass(cls);
+        if (mjc) {
+            metaClass->addInnerClass(mjc);
+            mjc->setEnclosingClass(metaClass);
+            addAbstractMetaClass(mjc);
+        }
+    }
+
+    // Go through all typedefs to see if we have defined any
+    // specific typedefs to be used as classes.
+    TypeAliasList typeAliases = namespaceItem->typeAliases();
+    foreach (TypeAliasModelItem typeAlias, typeAliases) {
+        AbstractMetaClass* cls = traverseTypeAlias(typeAlias);
+        if (cls) {
+            metaClass->addInnerClass(cls);
+            cls->setEnclosingClass(metaClass);
+            addAbstractMetaClass(cls);
+        }
+    }
+
+    // Traverse namespaces recursively
+    NamespaceList innerNamespaces = namespaceItem->namespaceMap().values();
+    qSort(innerNamespaces);
+    NamespaceList::iterator it = std::unique(innerNamespaces.begin(), innerNamespaces.end());
+    innerNamespaces.erase(it, innerNamespaces.end());
+    foreach (const NamespaceModelItem &ni, innerNamespaces) {
+        AbstractMetaClass* mjc = traverseNamespace(ni);
+        if (mjc) {
+            metaClass->addInnerClass(mjc);
+            mjc->setEnclosingClass(metaClass);
+            addAbstractMetaClass(mjc);
+        }
+    }
+
+    m_currentClass = 0;
+
+    popScope();
+    m_namespacePrefix = currentScope()->qualifiedName().join("::");
+
+    if (!type->include().isValid())
+        setInclude(type, namespaceItem->fileName());
+
+    return metaClass;
+}
+
+struct Operator
+{
+    enum Type { Complement, Plus, ShiftRight, ShiftLeft, None };
+
+    Operator() : type(None) {}
+
+    int calculate(int x)
+    {
+        switch (type) {
+        case Complement: return ~value;
+        case Plus: return x + value;
+        case ShiftRight: return x >> value;
+        case ShiftLeft: return x << value;
+        case None: return x;
+        }
+        return x;
+    }
+
+    Type type;
+    int value;
+};
+
+
+
+Operator findOperator(QString* s)
+{
+    const char *names[] = {
+        "~",
+        "+",
+        ">>",
+        "<<"
+    };
+
+    for (int i = 0; i < Operator::None; ++i) {
+        QString name = QLatin1String(names[i]);
+        QString str = *s;
+        int splitPoint = str.indexOf(name);
+        if (splitPoint > -1) {
+            bool ok;
+            QString right = str.mid(splitPoint + name.length());
+            Operator op;
+
+            op.value = right.toInt(&ok);
+            if (!ok && right.length() > 0 && right.at(right.length() - 1).toLower() == QLatin1Char('u'))
+                op.value = right.left(right.length() - 1).toUInt(&ok, 0);
+
+            if (ok) {
+                op.type = Operator::Type(i);
+                if (splitPoint > 0)
+                    *s = str.left(splitPoint).trimmed();
+                else
+                    *s = QString();
+                return op;
+            }
+        }
+    }
+    return Operator();
+}
+
+int AbstractMetaBuilder::figureOutEnumValue(const QString &stringValue,
+                                            int oldValuevalue,
+                                            AbstractMetaEnum *metaEnum,
+                                            AbstractMetaFunction *metaFunction)
+{
+    if (stringValue.isEmpty())
+        return oldValuevalue;
+
+    QStringList stringValues = stringValue.split("|");
+
+    int returnValue = 0;
+
+    bool matched = false;
+
+    for (int i = 0; i < stringValues.size(); ++i) {
+        QString s = stringValues.at(i).trimmed();
+
+        bool ok;
+        int v;
+
+        Operator op = findOperator(&s);
+
+        if (s.length() > 0 && s.at(0) == QLatin1Char('0'))
+            v = s.toUInt(&ok, 0);
+        else if (s.length() > 0 && s.at(s.length() - 1).toLower() == QLatin1Char('u'))
+            v = s.left(s.length() - 1).toUInt(&ok, 0);
+        else
+            v = s.toInt(&ok);
+
+        if (ok || s.isEmpty()) {
+            matched = true;
+        } else if (m_enumValues.contains(s)) {
+            v = m_enumValues[s]->value();
+            matched = true;
+        } else {
+            if (metaEnum) {
+                v = findOutValueFromString(s, matched);
+                if (!matched) {
+                    QString enclosingClass = QString(metaEnum->enclosingClass() ? metaEnum->enclosingClass()->name() + "::" : QString());
+                    ReportHandler::warning("unhandled enum value: " + s + " in "
+                                           + enclosingClass + metaEnum->name()
+                                           + " from header '" + metaEnum->typeEntry()->include().name() + "'");
+                }
+            } else {
+                ReportHandler::warning("unhandled enum value: Unknown enum");
+            }
+        }
+
+        if (matched)
+            returnValue |= op.calculate(v);
+    }
+
+    if (!matched) {
+        QString warn = QString("unmatched enum %1").arg(stringValue);
+
+        if (metaFunction) {
+            warn += QString(" when parsing default value of '%1' in class '%2'")
+                    .arg(metaFunction->name())
+                    .arg(metaFunction->implementingClass()->name());
+        }
+        warn += " from header '" + metaEnum->typeEntry()->include().name() + "'";
+
+        ReportHandler::warning(warn);
+        returnValue = oldValuevalue;
+    }
+
+    return returnValue;
+}
+
+void AbstractMetaBuilder::figureOutEnumValuesForClass(AbstractMetaClass* metaClass,
+                                                      QSet<AbstractMetaClass*>* classes)
+{
+    AbstractMetaClass* base = metaClass->baseClass();
+
+    if (base && !classes->contains(base))
+        figureOutEnumValuesForClass(base, classes);
+
+    if (classes->contains(metaClass))
+        return;
+
+    AbstractMetaEnumList enums = metaClass->enums();
+    foreach (AbstractMetaEnum* e, enums) {
+        if (!e) {
+            ReportHandler::warning("bad enum in class " + metaClass->name());
+            continue;
+        }
+        AbstractMetaEnumValueList lst = e->values();
+        int value = 0;
+        for (int i = 0; i < lst.size(); ++i) {
+            value = figureOutEnumValue(lst.at(i)->stringValue(), value, e);
+            lst.at(i)->setValue(value);
+            value++;
+        }
+    }
+
+    *classes += metaClass;
+}
+
+
+void AbstractMetaBuilder::figureOutEnumValues()
+{
+    // Keep a set of classes that we already traversed. We use this to
+    // enforce that we traverse base classes prior to subclasses.
+    QSet<AbstractMetaClass*> classes;
+    foreach (AbstractMetaClass *c, m_metaClasses)
+        figureOutEnumValuesForClass(c, &classes);
+
+    foreach (AbstractMetaEnum* metaEnum, m_globalEnums) {
+        AbstractMetaEnumValueList enumValues = metaEnum->values();
+        int value = 0;
+        for (int i = 0; i < enumValues.size(); ++i) {
+            value = figureOutEnumValue(enumValues.at(i)->stringValue(), value, metaEnum);
+            enumValues.at(i)->setValue(value);
+            value++;
+        }
+    }
+}
+
+void AbstractMetaBuilder::figureOutDefaultEnumArguments()
+{
+    foreach (AbstractMetaClass* metaClass, m_metaClasses) {
+        foreach (AbstractMetaFunction* metaFunction, metaClass->functions()) {
+            foreach (AbstractMetaArgument *arg, metaFunction->arguments()) {
+                QString expr = arg->defaultValueExpression();
+                if (expr.isEmpty())
+                    continue;
+
+                if (!metaFunction->replacedDefaultExpression(metaFunction->implementingClass(),
+                                                             arg->argumentIndex() + 1).isEmpty()) {
+                    continue;
+                }
+
+                arg->setDefaultValueExpression(expr);
+            }
+        }
+    }
+}
+
+
+AbstractMetaEnum* AbstractMetaBuilder::traverseEnum(EnumModelItem enumItem, AbstractMetaClass* enclosing, const QSet<QString> &enumsDeclarations)
+{
+    QString qualifiedName = enumItem->qualifiedName().join("::");
+
+    TypeEntry* typeEntry = 0;
+    if (enumItem->accessPolicy() == CodeModel::Private) {
+        QStringList names = enumItem->qualifiedName();
+        QString enumName = names.last();
+        QString nspace;
+        if (names.size() > 1)
+            nspace = QStringList(names.mid(0, names.size() - 1)).join("::");
+        typeEntry = new EnumTypeEntry(nspace, enumName, 0);
+        TypeDatabase::instance()->addType(typeEntry);
+    } else if (!enumItem->isAnonymous()) {
+        typeEntry = TypeDatabase::instance()->findType(qualifiedName);
+    } else {
+        QStringList tmpQualifiedName = enumItem->qualifiedName();
+        foreach (const EnumeratorModelItem& enumValue, enumItem->enumerators()) {
+            tmpQualifiedName.removeLast();
+            tmpQualifiedName << enumValue->name();
+            qualifiedName = tmpQualifiedName.join("::");
+            typeEntry = TypeDatabase::instance()->findType(qualifiedName);
+            if (typeEntry)
+                break;
+        }
+    }
+
+    QString enumName = enumItem->name();
+
+    QString className;
+    if (m_currentClass)
+        className = m_currentClass->typeEntry()->qualifiedCppName();
+
+    if (TypeDatabase::instance()->isEnumRejected(className, enumName)) {
+        if (typeEntry)
+            typeEntry->setCodeGeneration(TypeEntry::GenerateNothing);
+        m_rejectedEnums.insert(qualifiedName, GenerationDisabled);
+        return 0;
+    }
+
+    if (!typeEntry || !typeEntry->isEnum()) {
+        ReportHandler::warning(QString("enum '%1' does not have a type entry or is not an enum")
+                               .arg(qualifiedName));
+        m_rejectedEnums.insert(qualifiedName, NotInTypeSystem);
+        return 0;
+    }
+
+    AbstractMetaEnum* metaEnum = createMetaEnum();
+    if (enumsDeclarations.contains(qualifiedName)
+        || enumsDeclarations.contains(enumName)) {
+        metaEnum->setHasQEnumsDeclaration(true);
+    }
+
+    metaEnum->setTypeEntry((EnumTypeEntry*) typeEntry);
+    switch (enumItem->accessPolicy()) {
+    case CodeModel::Public:
+        *metaEnum += AbstractMetaAttributes::Public;
+        break;
+    case CodeModel::Protected:
+        *metaEnum += AbstractMetaAttributes::Protected;
+        break;
+    case CodeModel::Private:
+        *metaEnum += AbstractMetaAttributes::Private;
+        typeEntry->setCodeGeneration(TypeEntry::GenerateNothing);
+        break;
+    default:
+        break;
+    }
+
+    ReportHandler::debugMedium(QString(" - traversing enum %1").arg(metaEnum->fullName()));
+
+    foreach (EnumeratorModelItem value, enumItem->enumerators()) {
+
+        AbstractMetaEnumValue* metaEnumValue = createMetaEnumValue();
+        metaEnumValue->setName(value->name());
+        // Deciding the enum value...
+
+        metaEnumValue->setStringValue(value->value());
+        metaEnum->addEnumValue(metaEnumValue);
+
+        ReportHandler::debugFull("   - " + metaEnumValue->name() + " = "
+                                 + metaEnumValue->value());
+
+        // Add into global register...
+        if (enclosing)
+            m_enumValues[enclosing->name() + "::" + metaEnumValue->name()] = metaEnumValue;
+        else
+            m_enumValues[metaEnumValue->name()] = metaEnumValue;
+    }
+
+    m_enums << metaEnum;
+
+    if (!metaEnum->typeEntry()->include().isValid())
+        setInclude(metaEnum->typeEntry(), enumItem->fileName());
+
+    metaEnum->setOriginalAttributes(metaEnum->attributes());
+
+    // Register all enum values on Type database
+    foreach(EnumeratorModelItem e, enumItem->enumerators()) {
+        QString name;
+        if (enclosing) {
+            name += enclosing->name();
+            name += "::";
+        }
+        name += e->name();
+        EnumValueTypeEntry* enumValue = new EnumValueTypeEntry(name, e->value(), static_cast<EnumTypeEntry*>(typeEntry), typeEntry->version());
+        TypeDatabase::instance()->addType(enumValue);
+    }
+
+    return metaEnum;
+}
+
+AbstractMetaClass* AbstractMetaBuilder::traverseTypeAlias(TypeAliasModelItem typeAlias)
+{
+    TypeDatabase* types = TypeDatabase::instance();
+    QString className = stripTemplateArgs(typeAlias->name());
+
+    QString fullClassName = className;
+    // we have an inner class
+    if (m_currentClass) {
+        fullClassName = stripTemplateArgs(m_currentClass->typeEntry()->qualifiedCppName())
+                          + "::" + fullClassName;
+    }
+
+    // If this is the alias for a primitive type
+    // we store the aliased type on the alias
+    // TypeEntry
+    PrimitiveTypeEntry* ptype = types->findPrimitiveType(className);
+    if (ptype) {
+        QString typeAliasName = typeAlias->type().qualifiedName()[0];
+        ptype->setAliasedTypeEntry(types->findPrimitiveType(typeAliasName));
+        return 0;
+    }
+
+
+    // If we haven't specified anything for the typedef, then we don't care
+    ComplexTypeEntry* type = types->findComplexType(fullClassName);
+    if (!type)
+        return 0;
+
+    if (type->isObject())
+        static_cast<ObjectTypeEntry *>(type)->setQObject(isQObject(stripTemplateArgs(typeAlias->type().qualifiedName().join("::"))));
+
+    AbstractMetaClass *metaClass = createMetaClass();
+    metaClass->setTypeAlias(true);
+    metaClass->setTypeEntry(type);
+    metaClass->setBaseClassNames(QStringList() << typeAlias->type().qualifiedName().join("::"));
+    *metaClass += AbstractMetaAttributes::Public;
+
+    // Set the default include file name
+    if (!type->include().isValid())
+        setInclude(type, typeAlias->fileName());
+
+    fillAddedFunctions(metaClass);
+
+    return metaClass;
+}
+
+AbstractMetaClass* AbstractMetaBuilder::traverseClass(ClassModelItem classItem)
+{
+    QString className = stripTemplateArgs(classItem->name());
+    QString fullClassName = className;
+
+    // we have inner an class
+    if (m_currentClass) {
+        fullClassName = stripTemplateArgs(m_currentClass->typeEntry()->qualifiedCppName())
+                          + "::" + fullClassName;
+    }
+
+    ComplexTypeEntry* type = TypeDatabase::instance()->findComplexType(fullClassName);
+    RejectReason reason = NoReason;
+
+    if (fullClassName == "QMetaTypeId") {
+        // QtScript: record which types have been declared
+        int lpos = classItem->name().indexOf('<');
+        int rpos = classItem->name().lastIndexOf('>');
+        if ((lpos != -1) && (rpos != -1)) {
+            QString declaredTypename = classItem->name().mid(lpos + 1, rpos - lpos - 1);
+            m_qmetatypeDeclaredTypenames.insert(declaredTypename);
+        }
+    }
+
+    if (TypeDatabase::instance()->isClassRejected(fullClassName)) {
+        reason = GenerationDisabled;
+    } else if (!type) {
+        TypeEntry *te = TypeDatabase::instance()->findType(fullClassName);
+        if (te && !te->isComplex())
+            reason = RedefinedToNotClass;
+        else
+            reason = NotInTypeSystem;
+    } else if (type->codeGeneration() == TypeEntry::GenerateNothing) {
+        reason = GenerationDisabled;
+    }
+    if (reason != NoReason) {
+        m_rejectedClasses.insert(fullClassName, reason);
+        return 0;
+    }
+
+    if (type->isObject())
+        ((ObjectTypeEntry*)type)->setQObject(isQObject(fullClassName));
+
+    AbstractMetaClass* metaClass = createMetaClass();
+    metaClass->setTypeEntry(type);
+    metaClass->setBaseClassNames(classItem->baseClasses());
+    *metaClass += AbstractMetaAttributes::Public;
+    if (type->stream())
+        metaClass->setStream(true);
+
+    AbstractMetaClass* oldCurrentClass = m_currentClass;
+    m_currentClass = metaClass;
+
+    if (type->isContainer())
+        ReportHandler::debugSparse(QString("container: '%1'").arg(fullClassName));
+    else
+        ReportHandler::debugSparse(QString("class: '%1'").arg(metaClass->fullName()));
+
+    TemplateParameterList template_parameters = classItem->templateParameters();
+    QList<TypeEntry *> template_args;
+    template_args.clear();
+    for (int i = 0; i < template_parameters.size(); ++i) {
+        const TemplateParameterModelItem &param = template_parameters.at(i);
+        TemplateArgumentEntry *param_type = new TemplateArgumentEntry(param->name(), type->version());
+        param_type->setOrdinal(i);
+        template_args.append(param_type);
+    }
+    metaClass->setTemplateArguments(template_args);
+
+    parseQ_Property(metaClass, classItem->propertyDeclarations());
+
+    traverseEnums(model_dynamic_cast<ScopeModelItem>(classItem), metaClass, classItem->enumsDeclarations());
+
+    // Inner classes
+    {
+        QList<ClassModelItem> innerClasses = classItem->classMap().values();
+        foreach (const ClassModelItem &ci, innerClasses) {
+            AbstractMetaClass *cl = traverseClass(ci);
+            if (cl) {
+                cl->setEnclosingClass(metaClass);
+                metaClass->addInnerClass(cl);
+                m_metaClasses << cl;
+            }
+        }
+
+    }
+
+    // Go through all typedefs to see if we have defined any
+    // specific typedefs to be used as classes.
+    TypeAliasList typeAliases = classItem->typeAliases();
+    foreach (TypeAliasModelItem typeAlias, typeAliases) {
+        AbstractMetaClass* cls = traverseTypeAlias(typeAlias);
+        if (cls) {
+            cls->setEnclosingClass(metaClass);
+            addAbstractMetaClass(cls);
+        }
+    }
+
+
+    m_currentClass = oldCurrentClass;
+
+    // Set the default include file name
+    if (!type->include().isValid())
+        setInclude(type, classItem->fileName());
+
+    return metaClass;
+}
+
+void AbstractMetaBuilder::traverseScopeMembers(ScopeModelItem item, AbstractMetaClass* metaClass)
+{
+    // Classes/Namespace members
+    traverseFields(item, metaClass);
+    traverseFunctions(item, metaClass);
+
+    // Inner classes
+    ClassList innerClasses = item->classMap().values();
+    qSort(innerClasses);
+    ClassList::iterator it = std::unique(innerClasses.begin(), innerClasses.end());
+    innerClasses.erase(it, innerClasses.end());
+    foreach (const ClassModelItem& ci, innerClasses)
+        traverseClassMembers(ci);
+}
+
+AbstractMetaClass* AbstractMetaBuilder::currentTraversedClass(ScopeModelItem item)
+{
+    QString className = stripTemplateArgs(item->name());
+    QString fullClassName = className;
+
+    // This is an inner class
+    if (m_currentClass)
+        fullClassName = stripTemplateArgs(m_currentClass->typeEntry()->qualifiedCppName()) + "::" + fullClassName;
+
+    AbstractMetaClass* metaClass = m_metaClasses.findClass(fullClassName);
+    if (!metaClass)
+        metaClass = m_templates.findClass(fullClassName);
+    return metaClass;
+}
+
+void AbstractMetaBuilder::traverseClassMembers(ClassModelItem item)
+{
+    AbstractMetaClass* metaClass = currentTraversedClass(model_dynamic_cast<ScopeModelItem>(item));
+    if (!metaClass)
+        return;
+
+    AbstractMetaClass* oldCurrentClass = m_currentClass;
+    m_currentClass = metaClass;
+
+    // Class members
+    traverseScopeMembers(model_dynamic_cast<ScopeModelItem>(item), metaClass);
+
+    m_currentClass = oldCurrentClass;
+}
+
+void AbstractMetaBuilder::traverseNamespaceMembers(NamespaceModelItem item)
+{
+    AbstractMetaClass* metaClass = currentTraversedClass(model_dynamic_cast<ScopeModelItem>(item));
+    if (!metaClass)
+        return;
+
+    AbstractMetaClass* oldCurrentClass = m_currentClass;
+    m_currentClass = metaClass;
+
+    // Namespace members
+    traverseScopeMembers(model_dynamic_cast<ScopeModelItem>(item), metaClass);
+
+    // Inner namespaces
+    NamespaceList innerNamespaces = item->namespaceMap().values();
+    qSort(innerNamespaces);
+    NamespaceList::iterator it = std::unique(innerNamespaces.begin(), innerNamespaces.end());
+    innerNamespaces.erase(it, innerNamespaces.end());
+    foreach (const NamespaceModelItem &ni, innerNamespaces)
+        traverseNamespaceMembers(ni);
+
+    m_currentClass = oldCurrentClass;
+}
+
+AbstractMetaField* AbstractMetaBuilder::traverseField(VariableModelItem field, const AbstractMetaClass *cls)
+{
+    QString fieldName = field->name();
+    QString className = m_currentClass->typeEntry()->qualifiedCppName();
+
+    // Ignore friend decl.
+    if (field->isFriend())
+        return 0;
+
+    if (field->accessPolicy() == CodeModel::Private)
+        return 0;
+
+    if (TypeDatabase::instance()->isFieldRejected(className, fieldName)) {
+        m_rejectedFields.insert(className + "::" + fieldName, GenerationDisabled);
+        return 0;
+    }
+
+
+    AbstractMetaField* metaField = createMetaField();
+    metaField->setName(fieldName);
+    metaField->setEnclosingClass(cls);
+
+    bool ok;
+    TypeInfo fieldType = field->type();
+    AbstractMetaType *metaType = translateType(fieldType, &ok);
+
+    if (!metaType || !ok) {
+        ReportHandler::warning(QString("skipping field '%1::%2' with unmatched type '%3'")
+                               .arg(m_currentClass->name())
+                               .arg(fieldName)
+                               .arg(TypeInfo::resolveType(fieldType, currentScope()->toItem()).qualifiedName().join("::")));
+        delete metaField;
+        return 0;
+    }
+
+    metaField->setType(metaType);
+
+    uint attr = 0;
+    if (field->isStatic())
+        attr |= AbstractMetaAttributes::Static;
+
+    CodeModel::AccessPolicy policy = field->accessPolicy();
+    if (policy == CodeModel::Public)
+        attr |= AbstractMetaAttributes::Public;
+    else if (policy == CodeModel::Protected)
+        attr |= AbstractMetaAttributes::Protected;
+    else
+        attr |= AbstractMetaAttributes::Private;
+    metaField->setAttributes(attr);
+
+    return metaField;
+}
+
+void AbstractMetaBuilder::traverseFields(ScopeModelItem scope_item, AbstractMetaClass *metaClass)
+{
+    foreach (VariableModelItem field, scope_item->variables()) {
+        AbstractMetaField* metaField = traverseField(field, metaClass);
+
+        if (metaField && !metaField->isModifiedRemoved()) {
+            metaField->setOriginalAttributes(metaField->attributes());
+            metaClass->addField(metaField);
+        }
+    }
+}
+
+void AbstractMetaBuilder::setupFunctionDefaults(AbstractMetaFunction* metaFunction, AbstractMetaClass *metaClass)
+{
+    // Set the default value of the declaring class. This may be changed
+    // in fixFunctions later on
+    metaFunction->setDeclaringClass(metaClass);
+
+    // Some of the queries below depend on the implementing class being set
+    // to function properly. Such as function modifications
+    metaFunction->setImplementingClass(metaClass);
+
+    if (metaFunction->name() == "operator_equal")
+        metaClass->setHasEqualsOperator(true);
+
+    if (!metaFunction->isFinalInTargetLang()
+        && metaFunction->isRemovedFrom(metaClass, TypeSystem::TargetLangCode)) {
+        *metaFunction += AbstractMetaAttributes::FinalInCpp;
+    }
+}
+
+void AbstractMetaBuilder::fixReturnTypeOfConversionOperator(AbstractMetaFunction* metaFunction)
+{
+    if (!metaFunction->isConversionOperator()
+        || metaFunction->implementingClass()->typeEntry() != metaFunction->type()->typeEntry())
+        return;
+
+    TypeDatabase* types = TypeDatabase::instance();
+    QString castTo = metaFunction->name().remove(QRegExp("^operator ")).trimmed();
+
+    if (castTo.endsWith('&'))
+        castTo.chop(1);
+    if (castTo.startsWith("const "))
+        castTo.remove(0, 6);
+
+    TypeEntry* retType = types->findType(castTo);
+    if (!retType)
+        return;
+
+    AbstractMetaType* metaType = createMetaType();
+    metaType->setTypeEntry(retType);
+    metaFunction->replaceType(metaType);
+}
+
+static bool _compareAbstractMetaTypes(const AbstractMetaType* type, const AbstractMetaType* other)
+{
+    if (!type && !other)
+        return true;
+    if (!type || !other)
+        return false;
+    return type->typeEntry() == other->typeEntry()
+            && type->isConstant() == other->isConstant()
+            && type->isReference() == other->isReference()
+            && type->indirections() == other->indirections();
+}
+
+static bool _compareAbstractMetaFunctions(const AbstractMetaFunction* func, const AbstractMetaFunction* other)
+{
+    if (!func && !other)
+        return true;
+    if (!func || !other)
+        return false;
+    if (func->arguments().count() != other->arguments().count()
+        || func->isConstant() != other->isConstant()
+        || func->isStatic() != other->isStatic()
+        || !_compareAbstractMetaTypes(func->type(), other->type())) {
+        return false;
+    }
+    for (int i = 0; i < func->arguments().count(); ++i) {
+        if (!_compareAbstractMetaTypes(func->arguments().at(i)->type(), other->arguments().at(i)->type()))
+            return false;
+    }
+    return true;
+}
+
+static bool _fixFunctionModelItemType(TypeInfo& type, const AbstractMetaClass* metaClass)
+{
+    if (metaClass->templateArguments().isEmpty()
+        || type.qualifiedName().isEmpty()
+        || type.qualifiedName().first() != metaClass->typeEntry()->qualifiedCppName()) {
+        return false;
+    }
+    QStringList templateTypes;
+    foreach (TypeEntry* templateType, metaClass->templateArguments())
+        templateTypes << templateType->qualifiedCppName();
+    QString fixedTypeName = QString("%1<%2 >").arg(metaClass->typeEntry()->qualifiedCppName()).arg(templateTypes.join(", "));
+    type.setQualifiedName(QStringList(fixedTypeName));
+    return true;
+}
+
+static bool _fixFunctionModelItemTypes(FunctionModelItem& function, const AbstractMetaClass* metaClass)
+{
+    TypeInfo functionType = function->type();
+    bool templateTypeFixed = _fixFunctionModelItemType(functionType, metaClass);
+    if (templateTypeFixed)
+        function->setType(functionType);
+
+    ArgumentList arguments = function->arguments();
+    for (int i = 0; i < arguments.size(); ++i) {
+        ArgumentModelItem arg = arguments.at(i);
+        TypeInfo type = arg->type();
+        bool tmpTypeFixed = _fixFunctionModelItemType(type, metaClass);
+        if (tmpTypeFixed)
+            arg->setType(type);
+        templateTypeFixed |= tmpTypeFixed;
+    }
+    return templateTypeFixed;
+}
+
+void AbstractMetaBuilder::traverseFunctions(ScopeModelItem scopeItem, AbstractMetaClass* metaClass)
+{
+    foreach (FunctionModelItem function, scopeItem->functions()) {
+
+        // This fixes method's arguments and return types that are templates
+        // but the template variable wasn't declared in the C++ header.
+        bool templateTypeFixed = _fixFunctionModelItemTypes(function, metaClass);
+
+        AbstractMetaFunction* metaFunction = traverseFunction(function);
+
+        if (!metaFunction)
+            continue;
+
+        if (templateTypeFixed) {
+            foreach (AbstractMetaFunction* func, metaClass->queryFunctionsByName(metaFunction->name())) {
+                if (_compareAbstractMetaFunctions(metaFunction, func)) {
+                    delete metaFunction;
+                    metaFunction = 0;
+                    break;
+                }
+            }
+            if (!metaFunction)
+                continue;
+        }
+
+        metaFunction->setOriginalAttributes(metaFunction->attributes());
+        if (metaClass->isNamespace())
+            *metaFunction += AbstractMetaAttributes::Static;
+
+        QPropertySpec *read = 0;
+        if (!metaFunction->isSignal() && (read = metaClass->propertySpecForRead(metaFunction->name()))) {
+            // Property reader must be in the form "<type> name()"
+            if (metaFunction->type() && (read->type() == metaFunction->type()->typeEntry()) && (metaFunction->arguments().size() == 0)) {
+                *metaFunction += AbstractMetaAttributes::PropertyReader;
+                metaFunction->setPropertySpec(read);
+            }
+        } else if (QPropertySpec* write = metaClass->propertySpecForWrite(metaFunction->name())) {
+            // Property setter must be in the form "void name(<type>)"
+            // make sure the function was created with all aguments, some argument can be missing during the pareser because of errors on typesystem
+            if ((!metaFunction->type()) && (metaFunction->arguments().size() == 1) && (write->type() == metaFunction->arguments().at(0)->type()->typeEntry())) {
+                *metaFunction += AbstractMetaAttributes::PropertyWriter;
+                metaFunction->setPropertySpec(write);
+            }
+        } else if (QPropertySpec* reset = metaClass->propertySpecForReset(metaFunction->name())) {
+            // Property resetter must be in the form "void name()"
+            if ((!metaFunction->type()) && (metaFunction->arguments().size() == 0)) {
+                *metaFunction += AbstractMetaAttributes::PropertyResetter;
+                metaFunction->setPropertySpec(reset);
+            }
+        }
+
+        // Can not use metaFunction->isCopyConstructor() because
+        // the function wasn't assigned to its owner class yet.
+        bool isCopyCtor = false;
+        if (metaFunction->isConstructor() && metaFunction->arguments().size() == 1) {
+            const AbstractMetaType* argType = metaFunction->arguments().first()->type();
+            isCopyCtor = argType->isConstant()
+                         && argType->isReference()
+                         && argType->typeEntry()->name() == metaFunction->name();
+        }
+
+        bool isInvalidDestructor = metaFunction->isDestructor() && metaFunction->isPrivate();
+        bool isInvalidConstructor = metaFunction->isConstructor()
+                                    && ((metaFunction->isPrivate() && !isCopyCtor) || metaFunction->isInvalid());
+
+        if ((isInvalidDestructor || isInvalidConstructor)
+            && !metaClass->hasNonPrivateConstructor()) {
+            *metaClass += AbstractMetaAttributes::Final;
+        } else if (metaFunction->isConstructor() && !metaFunction->isPrivate()) {
+            *metaClass -= AbstractMetaAttributes::Final;
+            metaClass->setHasNonPrivateConstructor(true);
+        }
+
+        // Classes with virtual destructors should always have a shell class
+        // (since we aren't registering the destructors, we need this extra check)
+        if (metaFunction->isDestructor() && !metaFunction->isFinal())
+            metaClass->setForceShellClass(true);
+
+        if (!metaFunction->isDestructor()
+            && !metaFunction->isInvalid()
+            && !(metaFunction->isPrivate() && metaFunction->isConstructor() && !isCopyCtor)) {
+
+            setupFunctionDefaults(metaFunction, metaClass);
+
+            if (metaFunction->isSignal() && metaClass->hasSignal(metaFunction)) {
+                QString warn = QString("signal '%1' in class '%2' is overloaded.")
+                               .arg(metaFunction->name()).arg(metaClass->name());
+                ReportHandler::warning(warn);
+            }
+
+            if (metaFunction->isSignal() && !metaClass->isQObject()) {
+                QString warn = QString("signal '%1' in non-QObject class '%2'")
+                               .arg(metaFunction->name()).arg(metaClass->name());
+                ReportHandler::warning(warn);
+            }
+
+            if (metaFunction->isConversionOperator())
+                fixReturnTypeOfConversionOperator(metaFunction);
+
+            metaClass->addFunction(metaFunction);
+            applyFunctionModifications(metaFunction);
+        } else if (metaFunction->isDestructor()) {
+            metaClass->setHasPrivateDestructor(metaFunction->isPrivate());
+            metaClass->setHasProtectedDestructor(metaFunction->isProtected());
+            metaClass->setHasVirtualDestructor(metaFunction->isVirtual());
+        }
+        if (!metaFunction->ownerClass()) {
+            delete metaFunction;
+            metaFunction = 0;
+        }
+    }
+
+    fillAddedFunctions(metaClass);
+}
+
+void AbstractMetaBuilder::fillAddedFunctions(AbstractMetaClass* metaClass)
+{
+    // Add the functions added by the typesystem
+    foreach (AddedFunction addedFunc, metaClass->typeEntry()->addedFunctions())
+        traverseFunction(addedFunc, metaClass);
+}
+
+void AbstractMetaBuilder::applyFunctionModifications(AbstractMetaFunction* func)
+{
+    FunctionModificationList mods = func->modifications(func->implementingClass());
+    AbstractMetaFunction& funcRef = *func;
+    foreach (FunctionModification mod, mods) {
+        if (mod.isRenameModifier()) {
+            func->setOriginalName(func->name());
+            func->setName(mod.renamedTo());
+        } else if (mod.isAccessModifier()) {
+            funcRef -= AbstractMetaAttributes::Public;
+            funcRef -= AbstractMetaAttributes::Protected;
+            funcRef -= AbstractMetaAttributes::Private;
+            funcRef -= AbstractMetaAttributes::Friendly;
+
+            if (mod.isPublic())
+                funcRef += AbstractMetaAttributes::Public;
+            else if (mod.isProtected())
+                funcRef += AbstractMetaAttributes::Protected;
+            else if (mod.isPrivate())
+                funcRef += AbstractMetaAttributes::Private;
+            else if (mod.isFriendly())
+                funcRef += AbstractMetaAttributes::Friendly;
+        }
+
+        if (mod.isFinal())
+            funcRef += AbstractMetaAttributes::FinalInTargetLang;
+        else if (mod.isNonFinal())
+            funcRef -= AbstractMetaAttributes::FinalInTargetLang;
+    }
+}
+
+bool AbstractMetaBuilder::setupInheritance(AbstractMetaClass *metaClass)
+{
+    Q_ASSERT(!metaClass->isInterface());
+
+    if (m_setupInheritanceDone.contains(metaClass))
+        return true;
+
+    m_setupInheritanceDone.insert(metaClass);
+
+    QStringList baseClasses = metaClass->baseClassNames();
+
+    TypeDatabase* types = TypeDatabase::instance();
+
+    // we only support our own containers and ONLY if there is only one baseclass
+    if (baseClasses.size() == 1 && baseClasses.first().count('<') == 1) {
+        QStringList scope = metaClass->typeEntry()->qualifiedCppName().split("::");
+        scope.removeLast();
+        for (int i = scope.size(); i >= 0; --i) {
+            QString prefix = i > 0 ? QStringList(scope.mid(0, i)).join("::") + "::" : QString();
+            QString completeName = prefix + baseClasses.first();
+            TypeParser::Info info = TypeParser::parse(completeName);
+            QString baseName = info.qualified_name.join("::");
+
+            AbstractMetaClass* templ = 0;
+            foreach (AbstractMetaClass *c, m_templates) {
+                if (c->typeEntry()->name() == baseName) {
+                    templ = c;
+                    break;
+                }
+            }
+
+            if (!templ)
+                templ = m_metaClasses.findClass(baseName);
+
+            if (templ) {
+                setupInheritance(templ);
+                inheritTemplate(metaClass, templ, info);
+                metaClass->typeEntry()->setBaseContainerType(templ->typeEntry());
+                return true;
+            }
+            ComplexTypeEntry* baseContainerType = types->findContainerType(baseName);
+            if (baseContainerType)
+                metaClass->typeEntry()->setBaseContainerType(baseContainerType);
+        }
+
+        ReportHandler::warning(QString("template baseclass '%1' of '%2' is not known")
+                               .arg(baseClasses.first())
+                               .arg(metaClass->name()));
+        return false;
+    }
+
+    int primary = -1;
+    int primaries = 0;
+    for (int i = 0; i < baseClasses.size(); ++i) {
+
+        if (types->isClassRejected(baseClasses.at(i)))
+            continue;
+
+        TypeEntry* baseClassEntry = types->findType(baseClasses.at(i));
+        if (!baseClassEntry)
+            ReportHandler::warning(QString("class '%1' inherits from unknown base class '%2'")
+                                   .arg(metaClass->name()).arg(baseClasses.at(i)));
+
+        // true for primary base class
+        else if (!baseClassEntry->designatedInterface()) {
+            primaries++;
+            primary = i;
+        }
+    }
+
+    if (primary >= 0) {
+        AbstractMetaClass* baseClass = m_metaClasses.findClass(baseClasses.at(primary));
+        if (!baseClass) {
+            ReportHandler::warning(QString("unknown baseclass for '%1': '%2'")
+                                   .arg(metaClass->name())
+                                   .arg(baseClasses.at(primary)));
+            return false;
+        }
+        metaClass->setBaseClass(baseClass);
+    }
+
+    for (int i = 0; i < baseClasses.size(); ++i) {
+        if (types->isClassRejected(baseClasses.at(i)))
+            continue;
+
+        if (i != primary) {
+            AbstractMetaClass* baseClass = m_metaClasses.findClass(baseClasses.at(i));
+            if (!baseClass) {
+                ReportHandler::warning(QString("class not found for setup inheritance '%1'").arg(baseClasses.at(i)));
+                return false;
+            }
+
+            setupInheritance(baseClass);
+
+            QString interfaceName = baseClass->isInterface() ? InterfaceTypeEntry::interfaceName(baseClass->name()) : baseClass->name();
+            AbstractMetaClass* iface = m_metaClasses.findClass(interfaceName);
+            if (!iface) {
+                ReportHandler::warning(QString("unknown interface for '%1': '%2'")
+                                       .arg(metaClass->name())
+                                       .arg(interfaceName));
+                return false;
+            }
+            metaClass->addInterface(iface);
+
+            AbstractMetaClassList interfaces = iface->interfaces();
+            foreach (AbstractMetaClass* iface, interfaces)
+                metaClass->addInterface(iface);
+        }
+    }
+
+    return true;
+}
+
+void AbstractMetaBuilder::traverseEnums(ScopeModelItem scopeItem, AbstractMetaClass* metaClass, const QStringList &enumsDeclarations)
+{
+    EnumList enums = scopeItem->enums();
+    foreach (EnumModelItem enumItem, enums) {
+        AbstractMetaEnum* metaEnum = traverseEnum(enumItem, metaClass, QSet<QString>::fromList(enumsDeclarations));
+        if (metaEnum) {
+            metaClass->addEnum(metaEnum);
+            metaEnum->setEnclosingClass(metaClass);
+        }
+    }
+}
+
+AbstractMetaFunction* AbstractMetaBuilder::traverseFunction(const AddedFunction& addedFunc)
+{
+    return traverseFunction(addedFunc, 0);
+}
+
+AbstractMetaFunction* AbstractMetaBuilder::traverseFunction(const AddedFunction& addedFunc, AbstractMetaClass* metaClass)
+{
+    AbstractMetaFunction* metaFunction = createMetaFunction();
+    metaFunction->setConstant(addedFunc.isConstant());
+    metaFunction->setName(addedFunc.name());
+    metaFunction->setOriginalName(addedFunc.name());
+    int visibility = addedFunc.access() == AddedFunction::Public ? AbstractMetaAttributes::Public : AbstractMetaAttributes::Protected;
+    metaFunction->setVisibility(visibility);
+    metaFunction->setUserAdded(true);
+    AbstractMetaAttributes::Attribute isStatic = addedFunc.isStatic() ? AbstractMetaFunction::Static : AbstractMetaFunction::None;
+    metaFunction->setAttributes(metaFunction->attributes() | AbstractMetaAttributes::Final | isStatic);
+    metaFunction->setType(translateType(addedFunc.version(), addedFunc.returnType()));
+
+
+    QList<AddedFunction::TypeInfo> args = addedFunc.arguments();
+    AbstractMetaArgumentList metaArguments;
+
+    for (int i = 0; i < args.count(); ++i) {
+        AddedFunction::TypeInfo& typeInfo = args[i];
+        AbstractMetaArgument* metaArg = createMetaArgument();
+        AbstractMetaType* type = translateType(addedFunc.version(), typeInfo);
+        decideUsagePattern(type);
+        metaArg->setType(type);
+        metaArg->setArgumentIndex(i);
+        metaArg->setDefaultValueExpression(typeInfo.defaultValue);
+        metaArg->setOriginalDefaultValueExpression(typeInfo.defaultValue);
+        metaArguments.append(metaArg);
+    }
+
+    metaFunction->setArguments(metaArguments);
+    if (metaFunction->isOperatorOverload() && !metaFunction->isCallOperator()) {
+        if (metaArguments.size() > 2) {
+            ReportHandler::warning("An operator overload need to have 0, 1 or 2 arguments if it's reverse.");
+        } else if (metaArguments.size() == 2) {
+            // Check if it's a reverse operator
+            if (metaArguments[1]->type()->typeEntry() == metaClass->typeEntry()) {
+                metaFunction->setReverseOperator(true);
+                // we need to call these two function to cache the old signature (with two args)
+                // we do this buggy behaviour to comply with the original apiextractor buggy behaviour.
+                metaFunction->signature();
+                metaFunction->minimalSignature();
+                metaArguments.removeLast();
+                metaFunction->setArguments(metaArguments);
+            } else {
+                ReportHandler::warning("Operator overload can have two arguments only if it's a reverse operator!");
+            }
+        }
+    }
+
+
+    // Find the correct default values
+    for (int i = 0; i < metaArguments.size(); ++i) {
+        AbstractMetaArgument* metaArg = metaArguments.at(i);
+
+        //use relace-default-expression for set default value
+        QString replacedExpression;
+        if (m_currentClass)
+            replacedExpression = metaFunction->replacedDefaultExpression(m_currentClass, i + 1);
+
+        if (!replacedExpression.isEmpty()) {
+            QString expr = replacedExpression;
+            if (!metaFunction->removedDefaultExpression(m_currentClass, i + 1)) {
+                metaArg->setDefaultValueExpression(expr);
+                metaArg->setOriginalDefaultValueExpression(expr);
+
+                if (metaArg->type()->isEnum() || metaArg->type()->isFlags())
+                    m_enumDefaultArguments << QPair<AbstractMetaArgument*, AbstractMetaFunction*>(metaArg, metaFunction);
+            }
+        }
+    }
+
+    metaFunction->setOriginalAttributes(metaFunction->attributes());
+    fixArgumentNames(metaFunction);
+
+    if (metaClass) {
+        const AbstractMetaArgumentList fargs = metaFunction->arguments();
+        if (metaClass->isNamespace())
+            *metaFunction += AbstractMetaFunction::Static;
+        if (metaFunction->name() == metaClass->name()) {
+            metaFunction->setFunctionType(AbstractMetaFunction::ConstructorFunction);
+            if (fargs.size() == 1 && fargs.first()->type()->typeEntry()->isCustom())
+                metaFunction->setExplicit(true);
+        } else {
+            metaFunction->setFunctionType(AbstractMetaFunction::NormalFunction);
+        }
+
+        metaFunction->setDeclaringClass(metaClass);
+        metaFunction->setImplementingClass(metaClass);
+        metaClass->addFunction(metaFunction);
+        metaClass->setHasNonPrivateConstructor(true);
+    }
+
+    return metaFunction;
+}
+
+void AbstractMetaBuilder::fixArgumentNames(AbstractMetaFunction* func)
+{
+    if (func->arguments().isEmpty())
+        return;
+    foreach (FunctionModification mod, func->modifications(m_currentClass)) {
+        foreach (ArgumentModification argMod, mod.argument_mods) {
+            if (!argMod.renamed_to.isEmpty()) {
+                AbstractMetaArgument* arg = func->arguments().at(argMod.index - 1);
+                arg->setOriginalName(arg->name());
+                arg->setName(argMod.renamed_to, false);
+            }
+        }
+    }
+
+    int i = 1;
+    foreach (AbstractMetaArgument* arg, func->arguments()) {
+        if (arg->name().isEmpty())
+            arg->setName("arg__" + QString::number(i), false);
+        ++i;
+    }
+}
+
+AbstractMetaFunction* AbstractMetaBuilder::traverseFunction(FunctionModelItem functionItem)
+{
+    QString functionName = functionItem->name();
+    QString className;
+    if (m_currentClass)
+        className = m_currentClass->typeEntry()->qualifiedCppName();
+
+    if (TypeDatabase::instance()->isFunctionRejected(className, functionName)) {
+        m_rejectedFunctions.insert(className + "::" + functionName, GenerationDisabled);
+        return 0;
+    }
+
+    Q_ASSERT(functionItem->functionType() == CodeModel::Normal
+             || functionItem->functionType() == CodeModel::Signal
+             || functionItem->functionType() == CodeModel::Slot);
+
+    if (functionItem->isFriend())
+        return 0;
+
+    AbstractMetaFunction* metaFunction = createMetaFunction();
+    metaFunction->setConstant(functionItem->isConstant());
+
+    ReportHandler::debugMedium(QString(" - %2()").arg(functionName));
+
+    metaFunction->setName(functionName);
+    metaFunction->setOriginalName(functionItem->name());
+
+    if (functionItem->isAbstract())
+        *metaFunction += AbstractMetaAttributes::Abstract;
+
+    if (!metaFunction->isAbstract())
+        *metaFunction += AbstractMetaAttributes::Native;
+
+    if (!functionItem->isVirtual())
+        *metaFunction += AbstractMetaAttributes::Final;
+
+    if (functionItem->isInvokable())
+        *metaFunction += AbstractMetaAttributes::Invokable;
+
+    if (functionItem->isStatic()) {
+        *metaFunction += AbstractMetaAttributes::Static;
+        *metaFunction += AbstractMetaAttributes::Final;
+    }
+
+    // Access rights
+    if (functionItem->accessPolicy() == CodeModel::Public)
+        *metaFunction += AbstractMetaAttributes::Public;
+    else if (functionItem->accessPolicy() == CodeModel::Private)
+        *metaFunction += AbstractMetaAttributes::Private;
+    else
+        *metaFunction += AbstractMetaAttributes::Protected;
+
+
+    QString strippedClassName = className;
+    int cc_pos = strippedClassName.lastIndexOf("::");
+    if (cc_pos > 0)
+        strippedClassName = strippedClassName.mid(cc_pos + 2);
+
+    TypeInfo functionType = functionItem->type();
+    if (functionName.startsWith('~')) {
+        metaFunction->setFunctionType(AbstractMetaFunction::DestructorFunction);
+        metaFunction->setInvalid(true);
+    } else if (stripTemplateArgs(functionName) == strippedClassName) {
+        metaFunction->setFunctionType(AbstractMetaFunction::ConstructorFunction);
+        metaFunction->setExplicit(functionItem->isExplicit());
+        metaFunction->setName(m_currentClass->name());
+    } else {
+        bool ok;
+        AbstractMetaType* type = translateType(functionType, &ok);
+
+        if (!ok) {
+            Q_ASSERT(type == 0);
+            ReportHandler::warning(QString("skipping function '%1::%2', unmatched return type '%3'")
+                                   .arg(className)
+                                   .arg(functionItem->name())
+                                   .arg(functionItem->type().toString()));
+            m_rejectedFunctions[className + "::" + functionName] =
+                UnmatchedReturnType;
+            metaFunction->setInvalid(true);
+            return metaFunction;
+        }
+
+        metaFunction->setType(type);
+
+        if (functionItem->functionType() == CodeModel::Signal)
+            metaFunction->setFunctionType(AbstractMetaFunction::SignalFunction);
+        else if (functionItem->functionType() == CodeModel::Slot)
+            metaFunction->setFunctionType(AbstractMetaFunction::SlotFunction);
+    }
+
+    ArgumentList arguments = functionItem->arguments();
+
+    if (arguments.size() == 1) {
+        ArgumentModelItem arg = arguments.at(0);
+        TypeInfo type = arg->type();
+        if (type.qualifiedName().first() == "void" && type.indirections() == 0)
+            delete arguments.takeFirst();
+    }
+
+    AbstractMetaArgumentList metaArguments;
+
+    for (int i = 0; i < arguments.size(); ++i) {
+        ArgumentModelItem arg = arguments.at(i);
+
+        bool ok;
+        AbstractMetaType* metaType = translateType(arg->type(), &ok);
+        if (!ok) {
+            Q_ASSERT(metaType == 0);
+            ReportHandler::warning(QString("skipping function '%1::%2', "
+                                           "unmatched parameter type '%3'")
+                                   .arg(className)
+                                   .arg(functionItem->name())
+                                   .arg(arg->type().toString()));
+            m_rejectedFunctions[className + "::" + functionName] =
+                UnmatchedArgumentType;
+            metaFunction->setInvalid(true);
+            return metaFunction;
+        }
+
+        AbstractMetaArgument* metaArgument = createMetaArgument();
+
+        metaArgument->setType(metaType);
+        metaArgument->setName(arg->name());
+        metaArgument->setArgumentIndex(i);
+        metaArguments << metaArgument;
+    }
+
+    metaFunction->setArguments(metaArguments);
+
+    // Find the correct default values
+    for (int i = 0; i < arguments.size(); ++i) {
+        ArgumentModelItem arg = arguments.at(i);
+        AbstractMetaArgument* metaArg = metaArguments.at(i);
+
+        //use relace-default-expression for set default value
+        QString replacedExpression;
+        if (m_currentClass) {
+            replacedExpression = metaFunction->replacedDefaultExpression(m_currentClass, i + 1);
+        } else {
+            FunctionModificationList mods = TypeDatabase::instance()->functionModifications(metaFunction->minimalSignature());
+            if (!mods.isEmpty()) {
+                QList<ArgumentModification> argMods = mods.first().argument_mods;
+                if (!argMods.isEmpty())
+                    replacedExpression = argMods.first().replacedDefaultExpression;
+            }
+        }
+
+        bool hasDefaultValue = false;
+        if (arg->defaultValue() || !replacedExpression.isEmpty()) {
+            QString expr = arg->defaultValueExpression();
+            expr = fixDefaultValue(arg, metaArg->type(), metaFunction, m_currentClass, i);
+            metaArg->setOriginalDefaultValueExpression(expr);
+
+            if (metaFunction->removedDefaultExpression(m_currentClass, i + 1)) {
+                expr = "";
+            } else if (!replacedExpression.isEmpty()) {
+                expr = replacedExpression;
+            }
+            metaArg->setDefaultValueExpression(expr);
+
+            if (metaArg->type()->isEnum() || metaArg->type()->isFlags())
+                m_enumDefaultArguments << QPair<AbstractMetaArgument *, AbstractMetaFunction *>(metaArg, metaFunction);
+
+            hasDefaultValue = !expr.isEmpty();
+        }
+
+        //Check for missing argument name
+        if (hasDefaultValue
+            && !metaArg->hasName()
+            && !metaFunction->isOperatorOverload()
+            && !metaFunction->isSignal()
+            && metaFunction->argumentName(i+1, false, m_currentClass).isEmpty()) {
+            ReportHandler::warning(QString("Argument %1 on function '%2::%3' has default expression but does not have name.").arg(i+1).arg(className).arg(metaFunction->minimalSignature()));
+        }
+
+    }
+
+    fixArgumentNames(metaFunction);
+    return metaFunction;
+}
+
+AbstractMetaType* AbstractMetaBuilder::translateType(double vr, const AddedFunction::TypeInfo& typeInfo)
+{
+    Q_ASSERT(!typeInfo.name.isEmpty());
+    TypeDatabase* typeDb = TypeDatabase::instance();
+    TypeEntry* type;
+
+    QString typeName = typeInfo.name;
+
+    if (typeName == "void")
+        return 0;
+
+    type = typeDb->findType(typeName);
+
+    // test if the type is a template, like a container
+    bool isTemplate = false;
+    QString templateArg;
+    if (!type) {
+        QRegExp r("(.*)<(.*)>$");
+        if (r.indexIn(typeInfo.name) != -1) {
+            templateArg = r.cap(2);
+            if (templateArg.contains(','))
+                ReportHandler::warning("add-function tag doesn't support container types with more than one argument or template arguments.");
+            else
+                isTemplate = (type = typeDb->findContainerType(r.cap(1)));
+        }
+    }
+
+    if (!type) {
+        QStringList candidates;
+        SingleTypeEntryHash entries = typeDb->entries();
+        foreach (QString candidate, entries.keys()) {
+            // Let's try to find the type in different scopes.
+            if (candidate.endsWith("::"+typeName))
+                candidates << candidate;
+        }
+
+        QString msg = QString("Type '%1' wasn't found in the type database.\n").arg(typeName);
+
+        if (candidates.isEmpty())
+            qFatal(qPrintable(QString(msg + "Declare it in the type system using the proper <*-type> tag.")), NULL);
+
+        msg += "Remember to inform the full qualified name for the type you want to use.\nCandidates are:\n";
+        candidates.sort();
+        foreach (const QString& candidate, candidates) {
+            msg += "    " + candidate + "\n";
+        }
+        qFatal(qPrintable(msg), NULL);
+    }
+
+    AbstractMetaType* metaType = createMetaType();
+    metaType->setTypeEntry(type);
+    metaType->setIndirections(typeInfo.indirections);
+    metaType->setReference(typeInfo.isReference);
+    metaType->setConstant(typeInfo.isConstant);
+    if (isTemplate) {
+        type = typeDb->findType(templateArg);
+        if (type) {
+            AbstractMetaType* metaArgType = createMetaType();
+            metaArgType->setTypeEntry(type);
+            metaType->addInstantiation(metaArgType);
+            metaType->setTypeUsagePattern(AbstractMetaType::ContainerPattern);
+        }
+    }
+
+    return metaType;
+}
+
+static const TypeEntry* findTypeEntryUsingContext(const AbstractMetaClass* metaClass, const QString& qualifiedName)
+{
+    const TypeEntry* type = 0;
+    QStringList context = metaClass->qualifiedCppName().split("::");
+    while(!type && (context.size() > 0) ) {
+        type = TypeDatabase::instance()->findType(context.join("::") + "::" + qualifiedName);
+        context.removeLast();
+    }
+    return type;
+}
+
+AbstractMetaType* AbstractMetaBuilder::translateType(const TypeInfo& _typei, bool *ok, bool resolveType, bool resolveScope)
+{
+    Q_ASSERT(ok);
+    *ok = true;
+
+    // 1. Test the type info without resolving typedefs in case this is present in the
+    //    type system
+    TypeInfo typei;
+    if (resolveType) {
+        bool ok;
+        AbstractMetaType* t = translateType(_typei, &ok, false, resolveScope);
+        if (t && ok)
+            return t;
+        Q_ASSERT(t == 0);
+    }
+
+    if (!resolveType) {
+        typei = _typei;
+    } else {
+        // Go through all parts of the current scope (including global namespace)
+        // to resolve typedefs. The parser does not properly resolve typedefs in
+        // the global scope when they are referenced from inside a namespace.
+        // This is a work around to fix this bug since fixing it in resolveType
+        // seemed non-trivial
+        int i = m_scopes.size() - 1;
+        while (i >= 0) {
+            typei = TypeInfo::resolveType(_typei, m_scopes.at(i--)->toItem());
+            if (typei.qualifiedName().join("::") != _typei.qualifiedName().join("::"))
+                break;
+        }
+
+    }
+
+    if (typei.isFunctionPointer()) {
+        *ok = false;
+        return 0;
+    }
+
+    TypeParser::Info typeInfo = TypeParser::parse(typei.toString());
+    if (typeInfo.is_busted) {
+        *ok = false;
+        return 0;
+    }
+
+    // 2. Handle pointers specified as arrays with unspecified size
+    bool arrayOfUnspecifiedSize = false;
+    if (typeInfo.arrays.size() > 0) {
+        arrayOfUnspecifiedSize = true;
+        for (int i = 0; i < typeInfo.arrays.size(); ++i)
+            arrayOfUnspecifiedSize = arrayOfUnspecifiedSize && typeInfo.arrays.at(i).isEmpty();
+
+        if (!arrayOfUnspecifiedSize) {
+            TypeInfo newInfo;
+            //newInfo.setArguments(typei.arguments());
+            newInfo.setIndirections(typei.indirections());
+            newInfo.setConstant(typei.isConstant());
+            newInfo.setFunctionPointer(typei.isFunctionPointer());
+            newInfo.setQualifiedName(typei.qualifiedName());
+            newInfo.setReference(typei.isReference());
+            newInfo.setVolatile(typei.isVolatile());
+
+            AbstractMetaType* elementType = translateType(newInfo, ok);
+            if (!(*ok))
+                return 0;
+
+            for (int i = typeInfo.arrays.size() - 1; i >= 0; --i) {
+                QString s = typeInfo.arrays.at(i);
+                bool _ok;
+                int elems = findOutValueFromString(s, _ok);
+
+                AbstractMetaType* arrayType = createMetaType();
+                arrayType->setArrayElementCount(elems);
+                arrayType->setArrayElementType(elementType);
+                arrayType->setTypeEntry(new ArrayTypeEntry(elementType->typeEntry() , elementType->typeEntry()->version()));
+                decideUsagePattern(arrayType);
+
+                elementType = arrayType;
+            }
+
+            return elementType;
+        }  else {
+            typeInfo.indirections += typeInfo.arrays.size();
+        }
+    }
+
+    QStringList qualifierList = typeInfo.qualified_name;
+    if (qualifierList.isEmpty()) {
+        ReportHandler::warning(QString("horribly broken type '%1'").arg(_typei.toString()));
+        *ok = false;
+        return 0;
+    }
+
+    QString qualifiedName = qualifierList.join("::");
+    QString name = qualifierList.takeLast();
+
+    // 3. Special case 'void' type
+    if (name == "void" && !typeInfo.indirections)
+        return 0;
+
+    // 4. Special case QFlags (include instantiation in name)
+    if (qualifiedName == "QFlags")
+        qualifiedName = typeInfo.toString();
+
+    const TypeEntry *type = 0;
+    // 5. Try to find the type
+
+    // 5.1 - Try first using the current scope
+    if (m_currentClass) {
+        type = findTypeEntryUsingContext(m_currentClass, qualifiedName);
+
+        // 5.1.1 - Try using the class parents' scopes
+        if (!type && !m_currentClass->baseClassNames().isEmpty()) {
+            foreach (const AbstractMetaClass* cls, getBaseClasses(m_currentClass)) {
+                type = findTypeEntryUsingContext(cls, qualifiedName);
+                if (type)
+                    break;
+            }
+        }
+    }
+
+    // 5.2 - Try without scope
+    if (!type)
+        type = TypeDatabase::instance()->findType(qualifiedName);
+
+    // 6. No? Try looking it up as a flags type
+    if (!type)
+        type = TypeDatabase::instance()->findFlagsType(qualifiedName);
+
+    // 7. No? Try looking it up as a container type
+    if (!type)
+        type = TypeDatabase::instance()->findContainerType(name);
+
+    // 8. No? Check if the current class is a template and this type is one
+    //    of the parameters.
+    if (!type && m_currentClass) {
+        QList<TypeEntry *> template_args = m_currentClass->templateArguments();
+        foreach (TypeEntry *te, template_args) {
+            if (te->name() == qualifiedName)
+                type = te;
+        }
+    }
+
+    // 9. Try finding the type by prefixing it with the current
+    //    context and all baseclasses of the current context
+    if (!type && !TypeDatabase::instance()->isClassRejected(qualifiedName) && m_currentClass && resolveScope) {
+        QStringList contexts;
+        contexts.append(m_currentClass->qualifiedCppName());
+        contexts.append(currentScope()->qualifiedName().join("::"));
+
+
+        TypeInfo info = typei;
+        bool subclassesDone = false;
+        while (!contexts.isEmpty() && !type) {
+            type = TypeDatabase::instance()->findType(contexts.at(0) + "::" + qualifiedName);
+            contexts.pop_front();
+
+            // 10. Last resort: Special cased prefix of Qt namespace since the meta object implicitly inherits this, so
+            //     enum types from there may be addressed without any scope resolution in properties.
+            if (!contexts.size() && !subclassesDone) {
+                contexts << "Qt";
+                subclassesDone = true;
+            }
+        }
+
+    }
+
+    if (!type) {
+        *ok = false;
+        return 0;
+    }
+
+    // Used to for diagnostics later...
+    m_usedTypes << type;
+
+    // These are only implicit and should not appear in code...
+    Q_ASSERT(!type->isInterface());
+
+    AbstractMetaType* metaType = createMetaType();
+    metaType->setTypeEntry(type);
+    metaType->setIndirections(typeInfo.indirections);
+    metaType->setReference(typeInfo.is_reference);
+    metaType->setConstant(typeInfo.is_constant);
+    metaType->setOriginalTypeDescription(_typei.toString());
+
+    foreach (const TypeParser::Info &ta, typeInfo.template_instantiations) {
+        TypeInfo info;
+        info.setConstant(ta.is_constant);
+        info.setReference(ta.is_reference);
+        info.setIndirections(ta.indirections);
+
+        info.setFunctionPointer(false);
+        info.setQualifiedName(ta.instantiationName().split("::"));
+
+        AbstractMetaType* targType = translateType(info, ok);
+        if (!(*ok)) {
+            delete metaType;
+            return 0;
+        }
+
+        metaType->addInstantiation(targType, true);
+    }
+
+    // The usage pattern *must* be decided *after* the possible template
+    // instantiations have been determined, or else the absence of
+    // such instantiations will break the caching scheme of
+    // AbstractMetaType::cppSignature().
+    decideUsagePattern(metaType);
+
+    return metaType;
+}
+
+
+int AbstractMetaBuilder::findOutValueFromString(const QString& stringValue, bool& ok)
+{
+    int value = stringValue.toInt(&ok);
+    if (ok)
+        return value;
+
+    if (stringValue == "true" || stringValue == "false") {
+        ok = true;
+        return (stringValue == "true");
+    }
+
+    // This is a very lame way to handle expression evaluation,
+    // but it is not critical and will do for the time being.
+    static QRegExp variableNameRegExp("^[a-zA-Z_][a-zA-Z0-9_]*$");
+    if (!variableNameRegExp.exactMatch(stringValue)) {
+        ok = true;
+        return 0;
+    }
+
+    AbstractMetaEnumValue* enumValue = m_metaClasses.findEnumValue(stringValue);
+    if (enumValue) {
+        ok = true;
+        return enumValue->value();
+    }
+
+    foreach (AbstractMetaEnum* metaEnum, m_globalEnums) {
+        foreach (AbstractMetaEnumValue* ev, metaEnum->values()) {
+            if (ev->name() == stringValue) {
+                ok = true;
+                return ev->value();
+            }
+        }
+    }
+
+    ok = false;
+    return 0;
+}
+
+void AbstractMetaBuilder::decideUsagePattern(AbstractMetaType *metaType)
+{
+    metaType->decideUsagePattern();
+}
+
+QString AbstractMetaBuilder::fixDefaultValue(ArgumentModelItem item, AbstractMetaType* type,
+                                                   AbstractMetaFunction* fnc, AbstractMetaClass* implementingClass,
+                                                   int argumentIndex)
+{
+    QString functionName = fnc->name();
+    QString className = implementingClass ? implementingClass->qualifiedCppName() : QString();
+
+    QString expr = item->defaultValueExpression();
+    if (type) {
+        if (type->isPrimitive()) {
+            if (type->name() == "boolean") {
+                if (expr != "false" && expr != "true") {
+                    bool ok = false;
+                    int number = expr.toInt(&ok);
+                    if (ok && number)
+                        expr = "true";
+                    else
+                        expr = "false";
+                }
+            } else {
+                // This can be an enum or flag so I need to delay the
+                // translation untill all namespaces are completly
+                // processed. This is done in figureOutEnumValues()
+            }
+        } else if (type->isFlags() || type->isEnum()) {
+            bool isNumber;
+            expr.toInt(&isNumber);
+            if (!isNumber && expr.indexOf("::") < 0) {
+                // Add the enum/flag scope to default value, making it usable
+                // from other contexts beside its owner class hierarchy
+                QRegExp typeRegEx("[^<]*[<]([^:]*::).*");
+                typeRegEx.indexIn(type->minimalSignature());
+                expr = typeRegEx.cap(1) + expr;
+            }
+        } else if (type->isContainer() && expr.contains('<')) {
+            QRegExp typeRegEx("[^<]*<(.*)>");
+            typeRegEx.indexIn(type->minimalSignature());
+            QRegExp defaultRegEx("([^<]*<).*(>[^>]*)");
+            defaultRegEx.indexIn(expr);
+            expr = defaultRegEx.cap(1) + typeRegEx.cap(1) + defaultRegEx.cap(2);
+        } else {
+            // Here the default value is supposed to be a constructor,
+            // a class field, or a constructor receiving a class field
+            QRegExp defaultRegEx("([^\\(]*\\(|)([^\\)]*)(\\)|)");
+            defaultRegEx.indexIn(expr);
+
+            QString defaultValueCtorName = defaultRegEx.cap(1);
+            if (defaultValueCtorName.endsWith('('))
+                defaultValueCtorName.chop(1);
+
+            // Fix the scope for constructor using the already
+            // resolved argument type as a reference.
+            // The following regular expression extracts any
+            // use of namespaces/scopes from the type string.
+            QRegExp typeRegEx("^(?:const[\\s]+|)([\\w:]*::|)([A-Za-z_]\\w*)\\s*[&\\*]?$");
+            typeRegEx.indexIn(type->minimalSignature());
+
+            QString typeNamespace = typeRegEx.cap(1);
+            QString typeCtorName = typeRegEx.cap(2);
+            if (!typeNamespace.isEmpty() && defaultValueCtorName == typeCtorName)
+                expr.prepend(typeNamespace);
+
+            // Fix scope if the parameter is a field of the current class
+            if (implementingClass) {
+                foreach (const AbstractMetaField* field, implementingClass->fields()) {
+                    if (defaultRegEx.cap(2) == field->name()) {
+                        expr = defaultRegEx.cap(1) + implementingClass->name() + "::" + defaultRegEx.cap(2) + defaultRegEx.cap(3);
+                        break;
+                    }
+                }
+            }
+        }
+    } else {
+        QString warn = QString("undefined type for default value '%3' of argument in function '%1', class '%2'")
+                       .arg(functionName).arg(className).arg(item->defaultValueExpression());
+        ReportHandler::warning(warn);
+        expr = QString();
+    }
+
+    return expr;
+}
+
+bool AbstractMetaBuilder::isQObject(const QString& qualifiedName)
+{
+    if (qualifiedName == "QObject")
+        return true;
+
+    ClassModelItem classItem = m_dom->findClass(qualifiedName);
+
+    if (!classItem) {
+        QStringList names = qualifiedName.split(QLatin1String("::"));
+        NamespaceModelItem ns = model_dynamic_cast<NamespaceModelItem>(m_dom);
+        for (int i = 0; i < names.size() - 1 && ns; ++i)
+            ns = ns->namespaceMap().value(names.at(i));
+        if (ns && names.size() >= 2)
+            classItem = ns->findClass(names.at(names.size() - 1));
+    }
+
+    bool isqobject = classItem && classItem->extendsClass("QObject");
+
+    if (classItem && !isqobject) {
+        QStringList baseClasses = classItem->baseClasses();
+        for (int i = 0; i < baseClasses.count(); ++i) {
+
+            isqobject = isQObject(baseClasses.at(i));
+            if (isqobject)
+                break;
+        }
+    }
+
+    return isqobject;
+}
+
+
+bool AbstractMetaBuilder::isEnum(const QStringList& qualified_name)
+{
+    CodeModelItem item = m_dom->model()->findItem(qualified_name, m_dom->toItem());
+    return item && item->kind() == _EnumModelItem::__node_kind;
+}
+
+AbstractMetaClassList AbstractMetaBuilder::getBaseClasses(const AbstractMetaClass* metaClass) const
+{
+    AbstractMetaClassList baseClasses;
+    foreach (const QString& parent, metaClass->baseClassNames()) {
+        AbstractMetaClass* cls = m_metaClasses.findClass(parent);
+        if (cls)
+            baseClasses << cls;
+    }
+    return baseClasses;
+}
+
+bool AbstractMetaBuilder::ancestorHasPrivateCopyConstructor(const AbstractMetaClass* metaClass) const
+{
+    if (metaClass->hasPrivateCopyConstructor())
+        return true;
+    foreach (const AbstractMetaClass* cls, getBaseClasses(metaClass)) {
+        if (ancestorHasPrivateCopyConstructor(cls))
+            return true;
+    }
+    return false;
+}
+
+AbstractMetaType* AbstractMetaBuilder::inheritTemplateType(const QList<AbstractMetaType*>& templateTypes,
+                                                           const AbstractMetaType* metaType, bool* ok)
+{
+    if (ok)
+        *ok = true;
+    if (!metaType || (!metaType->typeEntry()->isTemplateArgument() && !metaType->hasInstantiations()))
+        return metaType ? metaType->copy() : 0;
+
+    AbstractMetaType *returned = metaType->copy();
+    returned->setOriginalTemplateType(metaType->copy());
+
+    if (returned->typeEntry()->isTemplateArgument()) {
+        const TemplateArgumentEntry* tae = static_cast<const TemplateArgumentEntry*>(returned->typeEntry());
+
+        // If the template is intantiated with void we special case this as rejecting the functions that use this
+        // parameter from the instantiation.
+        if (templateTypes.size() <= tae->ordinal() || templateTypes.at(tae->ordinal())->typeEntry()->name() == "void") {
+            if (ok)
+                *ok = false;
+            return 0;
+        }
+
+        AbstractMetaType* t = returned->copy();
+        t->setTypeEntry(templateTypes.at(tae->ordinal())->typeEntry());
+        t->setIndirections(templateTypes.at(tae->ordinal())->indirections() + t->indirections() ? 1 : 0);
+        decideUsagePattern(t);
+
+        delete returned;
+        returned = inheritTemplateType(templateTypes, t, ok);
+        if (ok && !(*ok))
+            return 0;
+    }
+
+    if (returned->hasInstantiations()) {
+        AbstractMetaTypeList instantiations = returned->instantiations();
+        for (int i = 0; i < instantiations.count(); ++i) {
+            AbstractMetaType *type = instantiations[i];
+            instantiations[i] = inheritTemplateType(templateTypes, type, ok);
+            if (ok && !(*ok))
+                return 0;
+        }
+        returned->setInstantiations(instantiations, true);
+    }
+
+    return returned;
+}
+
+bool AbstractMetaBuilder::inheritTemplate(AbstractMetaClass* subclass,
+                                          const AbstractMetaClass* templateClass,
+                                          const TypeParser::Info& info)
+{
+    QList<TypeParser::Info> targs = info.template_instantiations;
+    QList<AbstractMetaType*> templateTypes;
+
+    if (subclass->isTypeAlias()) {
+        subclass->setHasCloneOperator(templateClass->hasCloneOperator());
+        subclass->setHasEqualsOperator(templateClass->hasEqualsOperator());
+        subclass->setHasHashFunction(templateClass->hasHashFunction());
+        subclass->setHasNonPrivateConstructor(templateClass->hasNonPrivateConstructor());
+        subclass->setHasPrivateDestructor(templateClass->hasPrivateDestructor());
+        subclass->setHasProtectedDestructor(templateClass->hasProtectedDestructor());
+        subclass->setHasVirtualDestructor(templateClass->hasVirtualDestructor());
+    }
+
+    foreach (const TypeParser::Info &i, targs) {
+        QString typeName = i.qualified_name.join("::");
+        QStringList possibleNames;
+        possibleNames << subclass->qualifiedCppName() + "::" + typeName;
+        possibleNames << templateClass->qualifiedCppName() + "::" + typeName;
+        if (subclass->enclosingClass())
+            possibleNames << subclass->enclosingClass()->qualifiedCppName() + "::" + typeName;
+        possibleNames << typeName;
+
+        TypeDatabase* typeDb = TypeDatabase::instance();
+        TypeEntry* t = 0;
+        QString templateParamName;
+        foreach (QString possibleName, possibleNames) {
+            t = typeDb->findType(possibleName);
+            if (t) {
+                QString templateParamName = possibleName;
+                break;
+            }
+        }
+
+        if (t) {
+            AbstractMetaType* temporaryType = createMetaType();
+            temporaryType->setTypeEntry(t);
+            temporaryType->setConstant(i.is_constant);
+            temporaryType->setReference(i.is_reference);
+            temporaryType->setIndirections(i.indirections);
+            temporaryType->decideUsagePattern();
+            templateTypes << temporaryType;
+        } else {
+            ReportHandler::warning("Ignoring template parameter " + templateParamName + " from " + info.instantiationName() + ", because I don't know what it is.");
+        }
+    }
+
+    AbstractMetaFunctionList funcs = subclass->functions();
+    foreach (const AbstractMetaFunction* function, templateClass->functions()) {
+        if (function->isModifiedRemoved(TypeSystem::All))
+            continue;
+
+        AbstractMetaFunction *f = function->copy();
+        f->setArguments(AbstractMetaArgumentList());
+
+        bool ok = true;
+        AbstractMetaType *ftype = function->type();
+        f->replaceType(inheritTemplateType(templateTypes, ftype, &ok));
+        if (!ok) {
+            delete f;
+            continue;
+        }
+
+        foreach (AbstractMetaArgument* argument, function->arguments()) {
+            AbstractMetaType* atype = argument->type();
+
+            AbstractMetaArgument *arg = argument->copy();
+            arg->replaceType(inheritTemplateType(templateTypes, atype, &ok));
+            if (!ok)
+                break;
+            f->addArgument(arg);
+        }
+
+        if (!ok) {
+            delete f;
+            continue;
+        }
+
+        // There is no base class in the target language to inherit from here, so
+        // the template instantiation is the class that implements the function.
+        f->setImplementingClass(subclass);
+
+        // We also set it as the declaring class, since the superclass is
+        // supposed to disappear. This allows us to make certain function modifications
+        // on the inherited functions.
+        f->setDeclaringClass(subclass);
+
+
+        if (f->isConstructor() && subclass->isTypeAlias()) {
+            f->setName(subclass->name());
+            f->setOriginalName(subclass->name());
+        } else if (f->isConstructor()) {
+            delete f;
+            continue;
+        }
+
+        // if the instantiation has a function named the same as an existing
+        // function we have shadowing so we need to skip it.
+        bool found = false;
+        for (int i = 0; i < funcs.size(); ++i) {
+            if (funcs.at(i)->name() == f->name()) {
+                found = true;
+                continue;
+            }
+        }
+        if (found) {
+            delete f;
+            continue;
+        }
+
+        ComplexTypeEntry* te = subclass->typeEntry();
+        FunctionModificationList mods = function->modifications(templateClass);
+        for (int i = 0; i < mods.size(); ++i) {
+            FunctionModification mod = mods.at(i);
+            mod.signature = f->minimalSignature();
+
+            // If we ever need it... Below is the code to do
+            // substitution of the template instantation type inside
+            // injected code..
+#if 0
+            if (mod.modifiers & Modification::CodeInjection) {
+                for (int j = 0; j < template_types.size(); ++j) {
+                    CodeSnip &snip = mod.snips.last();
+                    QString code = snip.code();
+                    code.replace(QString::fromLatin1("$$QT_TEMPLATE_%1$$").arg(j),
+                                 template_types.at(j)->typeEntry()->qualifiedCppName());
+                    snip.codeList.clear();
+                    snip.addCode(code);
+                }
+            }
+#endif
+            te->addFunctionModification(mod);
+        }
+
+        subclass->addFunction(f);
+    }
+
+    subclass->setTemplateBaseClass(templateClass);
+    subclass->setTemplateBaseClassInstantiations(templateTypes);
+    subclass->setInterfaces(templateClass->interfaces());
+    subclass->setBaseClass(templateClass->baseClass());
+
+    return true;
+}
+
+void AbstractMetaBuilder::parseQ_Property(AbstractMetaClass* metaClass, const QStringList& declarations)
+{
+    for (int i = 0; i < declarations.size(); ++i) {
+        QString p = declarations.at(i);
+
+        QStringList l = p.split(QLatin1String(" "));
+
+
+        QStringList qualifiedScopeName = currentScope()->qualifiedName();
+        bool ok = false;
+        AbstractMetaType* type = 0;
+        QString scope;
+        for (int j = qualifiedScopeName.size(); j >= 0; --j) {
+            scope = j > 0 ? QStringList(qualifiedScopeName.mid(0, j)).join("::") + "::" : QString();
+            TypeInfo info;
+            info.setQualifiedName((scope + l.at(0)).split("::"));
+
+            type = translateType(info, &ok);
+            if (type && ok)
+                break;
+        }
+
+        if (!type || !ok) {
+            ReportHandler::warning(QString("Unable to decide type of property: '%1' in class '%2'")
+                                   .arg(l.at(0)).arg(metaClass->name()));
+            continue;
+        }
+
+        QString typeName = scope + l.at(0);
+
+        QPropertySpec* spec = new QPropertySpec(type->typeEntry());
+        spec->setName(l.at(1));
+        spec->setIndex(i);
+
+        for (int pos = 2; pos + 1 < l.size(); pos += 2) {
+            if (l.at(pos) == QLatin1String("READ"))
+                spec->setRead(l.at(pos + 1));
+            else if (l.at(pos) == QLatin1String("WRITE"))
+                spec->setWrite(l.at(pos + 1));
+            else if (l.at(pos) == QLatin1String("DESIGNABLE"))
+                spec->setDesignable(l.at(pos + 1));
+            else if (l.at(pos) == QLatin1String("RESET"))
+                spec->setReset(l.at(pos + 1));
+        }
+
+        metaClass->addPropertySpec(spec);
+        delete type;
+    }
+}
+
+static AbstractMetaFunction* findCopyCtor(AbstractMetaClass* cls)
+{
+    AbstractMetaFunctionList functions = cls->queryFunctions(AbstractMetaClass::Invisible);
+    functions <<  cls->queryFunctions(AbstractMetaClass::Visible);
+
+    foreach (AbstractMetaFunction* f, functions) {
+        if (f->isConstructor() || f->name() == "operator=") {
+            AbstractMetaArgumentList arguments = f->arguments();
+            if (arguments.size() == 1) {
+                if (cls->typeEntry()->qualifiedCppName() == arguments.at(0)->type()->typeEntry()->qualifiedCppName())
+                    return f;
+            }
+        }
+    }
+    return 0;
+}
+
+void AbstractMetaBuilder::setupClonable(AbstractMetaClass* cls)
+{
+    bool result = true;
+
+    // find copy ctor for the current class
+    AbstractMetaFunction* copyCtor = findCopyCtor(cls);
+    if (copyCtor) { // if exists a copy ctor in this class
+        result = copyCtor->isPublic();
+    } else { // else... lets find one in the parent class
+        QQueue<AbstractMetaClass*> baseClasses;
+        if (cls->baseClass())
+            baseClasses.enqueue(cls->baseClass());
+        baseClasses << cls->interfaces();
+
+        while (!baseClasses.isEmpty()) {
+            AbstractMetaClass* currentClass = baseClasses.dequeue();
+            baseClasses << currentClass->interfaces();
+            if (currentClass->baseClass())
+                baseClasses.enqueue(currentClass->baseClass());
+
+            copyCtor = findCopyCtor(currentClass);
+            if (copyCtor) {
+                result = copyCtor->isPublic();
+                break;
+            }
+        }
+    }
+    cls->setHasCloneOperator(result);
+}
+
+void AbstractMetaBuilder::setupExternalConversion(AbstractMetaClass* cls) {
+    AbstractMetaFunctionList convOps = cls->operatorOverloads(AbstractMetaClass::ConversionOp);
+    foreach (AbstractMetaFunction* func, convOps) {
+        if (func->isModifiedRemoved())
+            continue;
+        AbstractMetaClass* metaClass = m_metaClasses.findClass(func->type()->typeEntry());
+        if (!metaClass)
+            continue;
+        metaClass->addExternalConversionOperator(func);
+    }
+    foreach (AbstractMetaClass* innerClass, cls->innerClasses())
+        setupExternalConversion(innerClass);
+}
+
+static void writeRejectLogFile(const QString &name,
+                                  const QMap<QString, AbstractMetaBuilder::RejectReason> &rejects)
+{
+    QFile f(name);
+    if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) {
+        ReportHandler::warning(QString("failed to write log file: '%1'")
+                               .arg(f.fileName()));
+        return;
+    }
+
+    QTextStream s(&f);
+
+
+    for (int reason = 0; reason < AbstractMetaBuilder::NoReason; ++reason) {
+        s << QString(72, '*') << endl;
+        switch (reason) {
+        case AbstractMetaBuilder::NotInTypeSystem:
+            s << "Not in type system";
+            break;
+        case AbstractMetaBuilder::GenerationDisabled:
+            s << "Generation disabled by type system";
+            break;
+        case AbstractMetaBuilder::RedefinedToNotClass:
+            s << "Type redefined to not be a class";
+            break;
+
+        case AbstractMetaBuilder::UnmatchedReturnType:
+            s << "Unmatched return type";
+            break;
+
+        case AbstractMetaBuilder::UnmatchedArgumentType:
+            s << "Unmatched argument type";
+            break;
+
+        case AbstractMetaBuilder::ApiIncompatible:
+            s << "Incompatible API";
+            break;
+
+        default:
+            s << "unknown reason";
+            break;
+        }
+
+        s << endl;
+
+        for (QMap<QString, AbstractMetaBuilder::RejectReason>::const_iterator it = rejects.constBegin();
+             it != rejects.constEnd(); ++it) {
+            if (it.value() != reason)
+                continue;
+            s << " - " << it.key() << endl;
+        }
+
+        s << QString(72, '*') << endl << endl;
+    }
+
+}
+
+
+void AbstractMetaBuilder::dumpLog()
+{
+    writeRejectLogFile(m_logDirectory + "mjb_rejected_classes.log", m_rejectedClasses);
+    writeRejectLogFile(m_logDirectory + "mjb_rejected_enums.log", m_rejectedEnums);
+    writeRejectLogFile(m_logDirectory + "mjb_rejected_functions.log", m_rejectedFunctions);
+    writeRejectLogFile(m_logDirectory + "mjb_rejected_fields.log", m_rejectedFields);
+}
+
+AbstractMetaClassList AbstractMetaBuilder::classesTopologicalSorted(const AbstractMetaClass* cppClass) const
+{
+    QLinkedList<int> unmappedResult;
+    QHash<QString, int> map;
+    QHash<int, AbstractMetaClass*> reverseMap;
+
+    const AbstractMetaClassList& classList = cppClass ? cppClass->innerClasses() : m_metaClasses;
+
+    int i = 0;
+    foreach (AbstractMetaClass* clazz, classList) {
+        if (map.contains(clazz->qualifiedCppName()))
+            continue;
+        map[clazz->qualifiedCppName()] = i;
+        reverseMap[i] = clazz;
+        i++;
+    }
+
+    Graph graph(map.count());
+
+    // TODO choose a better name to these regexs
+    QRegExp regex1("\\(.*\\)");
+    QRegExp regex2("::.*");
+    foreach (AbstractMetaClass* clazz, classList) {
+        if (clazz->isInterface() || !clazz->typeEntry()->generateCode())
+            continue;
+
+        if (clazz->enclosingClass() && map.contains(clazz->enclosingClass()->qualifiedCppName()))
+            graph.addEdge(map[clazz->enclosingClass()->qualifiedCppName()], map[clazz->qualifiedCppName()]);
+
+        AbstractMetaClassList bases = getBaseClasses(clazz);
+        foreach(AbstractMetaClass* baseClass, bases) {
+            // Fix polymorphic expression
+            if (clazz->baseClass() == baseClass)
+                clazz->setBaseClass(baseClass);
+
+            if (map.contains(baseClass->qualifiedCppName()))
+                graph.addEdge(map[baseClass->qualifiedCppName()], map[clazz->qualifiedCppName()]);
+        }
+
+        foreach (AbstractMetaFunction* func, clazz->functions()) {
+            foreach (AbstractMetaArgument* arg, func->arguments()) {
+                // check methods with default args
+                QString defaultExpression = arg->originalDefaultValueExpression();
+                if (!defaultExpression.isEmpty()) {
+                    if ((defaultExpression == "0") && (arg->type()->isValue()))
+                        defaultExpression = arg->type()->name();
+
+                    defaultExpression.replace(regex1, "");
+                    defaultExpression.replace(regex2, "");
+                }
+                if (!defaultExpression.isEmpty()) {
+                    QString exprClassName = clazz->qualifiedCppName() + "::" + defaultExpression;
+                    if (!map.contains(exprClassName)) {
+                        bool found = false;
+                        foreach(AbstractMetaClass* baseClass, bases) {
+                            exprClassName = baseClass->qualifiedCppName() + "::" + defaultExpression;
+                            if (map.contains(exprClassName)) {
+                                found = true;
+                                break;
+                            }
+                        }
+                        if (!found) {
+                            if (map.contains(defaultExpression))
+                                exprClassName = defaultExpression;
+                            else
+                                exprClassName.clear();
+                        }
+                    }
+                    if (!exprClassName.isEmpty() && exprClassName != clazz->qualifiedCppName())
+                        graph.addEdge(map[exprClassName], map[clazz->qualifiedCppName()]);
+                }
+            }
+        }
+    }
+
+    AbstractMetaClassList result;
+    unmappedResult = graph.topologicalSort();
+    if (unmappedResult.isEmpty() && graph.nodeCount()) {
+        QTemporaryFile tempFile;
+        tempFile.setAutoRemove(false);
+        tempFile.open();
+        QHash<int, QString> hash;
+        QHash<QString, int>::iterator it = map.begin();
+        for (; it != map.end(); ++it)
+            hash[it.value()] = it.key();
+        graph.dumpDot(hash, tempFile.fileName());
+        ReportHandler::warning("Cyclic dependency found! Graph can be found at "+tempFile.fileName());
+    } else {
+        foreach (int i, unmappedResult) {
+            Q_ASSERT(reverseMap.contains(i));
+            if (!reverseMap[i]->isInterface())
+                result << reverseMap[i];
+        }
+    }
+
+    return result;
+}
+
+AbstractMetaArgumentList AbstractMetaBuilder::reverseList(const AbstractMetaArgumentList& list)
+{
+    AbstractMetaArgumentList ret;
+
+    int index = list.size();
+    foreach (AbstractMetaArgument* arg, list) {
+        arg->setArgumentIndex(index);
+        ret.prepend(arg);
+        index--;
+    }
+
+    return ret;
+}
+
+void AbstractMetaBuilder::setGlobalHeader(const QString& globalHeader)
+{
+    m_globalHeader = QFileInfo(globalHeader);
+}
+
+void AbstractMetaBuilder::setInclude(TypeEntry* te, const QString& fileName) const
+{
+    QFileInfo info(fileName);
+    if (m_globalHeader.fileName() != info.fileName())
+        te->setInclude(Include(Include::IncludePath, info.fileName()));
+}
diff --git a/ApiExtractor/abstractmetabuilder.h b/ApiExtractor/abstractmetabuilder.h
new file mode 100644
index 000000000..b4a2863ac
--- /dev/null
+++ b/ApiExtractor/abstractmetabuilder.h
@@ -0,0 +1,271 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef ABSTRACTMETABUILDER_H
+#define ABSTRACTMETABUILDER_H
+
+#include "parser/codemodel.h"
+#include "abstractmetalang.h"
+#include "typesystem.h"
+#include "typeparser.h"
+
+#include <QSet>
+#include <QFileInfo>
+
+class TypeDatabase;
+
+class APIEXTRACTOR_API AbstractMetaBuilder
+{
+public:
+    enum RejectReason {
+        NotInTypeSystem,
+        GenerationDisabled,
+        RedefinedToNotClass,
+        UnmatchedArgumentType,
+        UnmatchedReturnType,
+        ApiIncompatible,
+        NoReason
+    };
+
+    AbstractMetaBuilder();
+    virtual ~AbstractMetaBuilder();
+
+    AbstractMetaClassList classes() const
+    {
+        return m_metaClasses;
+    }
+    AbstractMetaClassList templates() const
+    {
+        return m_templates;
+    }
+    /**
+    *   Sorts a list of classes topologically, if an AbstractMetaClass object
+    *   is passed the list of classes will be its inner classes, otherwise
+    *   the list will be the module global classes.
+    *   \return a list of classes sorted topologically
+    */
+    AbstractMetaClassList classesTopologicalSorted(const AbstractMetaClass* cppClass = 0) const;
+
+    FileModelItem model() const
+    {
+        return m_dom;
+    }
+
+    void setModel(FileModelItem item)
+    {
+        m_dom = item;
+    }
+
+    ScopeModelItem popScope()
+    {
+        return m_scopes.takeLast();
+    }
+
+    void pushScope(ScopeModelItem item)
+    {
+        m_scopes << item;
+    }
+
+    ScopeModelItem currentScope() const
+    {
+        return m_scopes.last();
+    }
+
+    void dumpLog();
+
+    bool build(QIODevice* input);
+    void setLogDirectory(const QString& logDir);
+
+    void figureOutEnumValuesForClass(AbstractMetaClass *metaClass, QSet<AbstractMetaClass *> *classes);
+    int figureOutEnumValue(const QString &name, int value, AbstractMetaEnum *meta_enum, AbstractMetaFunction *metaFunction = 0);
+    void figureOutEnumValues();
+    void figureOutDefaultEnumArguments();
+
+    void addAbstractMetaClass(AbstractMetaClass *cls);
+    AbstractMetaClass *traverseTypeAlias(TypeAliasModelItem item);
+    AbstractMetaClass *traverseClass(ClassModelItem item);
+    AbstractMetaClass* currentTraversedClass(ScopeModelItem item);
+    void traverseScopeMembers(ScopeModelItem item, AbstractMetaClass* metaClass);
+    void traverseClassMembers(ClassModelItem scopeItem);
+    void traverseNamespaceMembers(NamespaceModelItem scopeItem);
+    bool setupInheritance(AbstractMetaClass *metaClass);
+    AbstractMetaClass *traverseNamespace(NamespaceModelItem item);
+    AbstractMetaEnum *traverseEnum(EnumModelItem item, AbstractMetaClass *enclosing, const QSet<QString> &enumsDeclarations);
+    void traverseEnums(ScopeModelItem item, AbstractMetaClass *parent, const QStringList &enumsDeclarations);
+    void traverseFunctions(ScopeModelItem item, AbstractMetaClass *parent);
+    void applyFunctionModifications(AbstractMetaFunction* func);
+    void traverseFields(ScopeModelItem item, AbstractMetaClass *parent);
+    void traverseStreamOperator(FunctionModelItem functionItem);
+    void traverseOperatorFunction(FunctionModelItem item);
+    AbstractMetaFunction* traverseFunction(const AddedFunction& addedFunc);
+    AbstractMetaFunction* traverseFunction(const AddedFunction& addedFunc, AbstractMetaClass* metaClass);
+    AbstractMetaFunction *traverseFunction(FunctionModelItem function);
+    AbstractMetaField *traverseField(VariableModelItem field, const AbstractMetaClass *cls);
+    void checkFunctionModifications();
+    void registerHashFunction(FunctionModelItem functionItem);
+    void registerToStringCapability(FunctionModelItem functionItem);
+
+    /**
+     *   A conversion operator function should not have its owner class as
+     *   its return type, but unfortunately it does. This function fixes the
+     *   return type of operator functions of this kind making the return type
+     *   be the same as it is supposed to generate when used in C++.
+     *   If the returned type is a wrapped C++ class, this method also adds the
+     *   conversion operator to the collection of external conversions of the
+     *   said class.
+     *   \param metaFunction conversion operator function to be fixed.
+     */
+    void fixReturnTypeOfConversionOperator(AbstractMetaFunction* metaFunction);
+
+    void parseQ_Property(AbstractMetaClass *metaClass, const QStringList &declarations);
+    void setupEquals(AbstractMetaClass *metaClass);
+    void setupComparable(AbstractMetaClass *metaClass);
+    void setupClonable(AbstractMetaClass *cls);
+    void setupExternalConversion(AbstractMetaClass* cls);
+    void setupFunctionDefaults(AbstractMetaFunction *metaFunction, AbstractMetaClass *metaClass);
+
+    QString fixDefaultValue(ArgumentModelItem item, AbstractMetaType *type,
+                                  AbstractMetaFunction *fnc, AbstractMetaClass *,
+                                  int argumentIndex);
+    AbstractMetaType* translateType(double vr, const AddedFunction::TypeInfo& typeInfo);
+    AbstractMetaType *translateType(const TypeInfo &type, bool *ok, bool resolveType = true, bool resolveScope = true);
+
+    int findOutValueFromString(const QString& stringValue, bool& ok);
+
+    void decideUsagePattern(AbstractMetaType *type);
+
+    const AbstractMetaFunctionList globalFunctions() const
+    {
+        return m_globalFunctions;
+    }
+
+    const AbstractMetaEnumList globalEnums() const
+    {
+        return m_globalEnums;
+    }
+
+    AbstractMetaClassList getBaseClasses(const AbstractMetaClass* metaClass) const;
+    bool ancestorHasPrivateCopyConstructor(const AbstractMetaClass* metaClass) const;
+
+    bool inheritTemplate(AbstractMetaClass *subclass,
+                         const AbstractMetaClass *templateClass,
+                         const TypeParser::Info &info);
+    AbstractMetaType *inheritTemplateType(const QList<AbstractMetaType *> &templateTypes, const AbstractMetaType *metaType, bool *ok = 0);
+
+    bool isQObject(const QString &qualifiedName);
+    bool isEnum(const QStringList &qualifiedName);
+
+    void fixQObjectForScope(TypeDatabase* types, NamespaceModelItem item);
+
+    // QtScript
+    QSet<QString> qtMetaTypeDeclaredTypeNames() const
+    {
+        return m_qmetatypeDeclaredTypenames;
+    }
+
+    /**
+    *   AbstractMetaBuilder should know what's the global header being used,
+    *   so any class declared under this header wont have the include file
+    *   filled.
+    */
+    void setGlobalHeader(const QString& globalHeader);
+
+protected:
+    AbstractMetaClass *argumentToClass(ArgumentModelItem);
+
+    virtual AbstractMetaClass *createMetaClass()
+    {
+        return new AbstractMetaClass();
+    }
+
+    virtual AbstractMetaEnum *createMetaEnum()
+    {
+        return new AbstractMetaEnum();
+    }
+
+    virtual AbstractMetaEnumValue *createMetaEnumValue()
+    {
+        return new AbstractMetaEnumValue();
+    }
+
+    virtual AbstractMetaField *createMetaField()
+    {
+        return new AbstractMetaField();
+    }
+
+    virtual AbstractMetaFunction *createMetaFunction()
+    {
+        return new AbstractMetaFunction();
+    }
+
+    virtual AbstractMetaArgument *createMetaArgument()
+    {
+        return new AbstractMetaArgument();
+    }
+
+    virtual AbstractMetaType *createMetaType()
+    {
+        return new AbstractMetaType();
+    }
+
+    FileModelItem m_dom;
+
+private:
+    void sortLists();
+    AbstractMetaArgumentList reverseList(const AbstractMetaArgumentList& list);
+    void setInclude(TypeEntry* te, const QString& fileName) const;
+    void fixArgumentNames(AbstractMetaFunction* func);
+    void fillAddedFunctions(AbstractMetaClass* metaClass);
+
+    AbstractMetaClassList m_metaClasses;
+    AbstractMetaClassList m_templates;
+    AbstractMetaFunctionList m_globalFunctions;
+    AbstractMetaEnumList m_globalEnums;
+
+    QSet<const TypeEntry *> m_usedTypes;
+
+    QMap<QString, RejectReason> m_rejectedClasses;
+    QMap<QString, RejectReason> m_rejectedEnums;
+    QMap<QString, RejectReason> m_rejectedFunctions;
+    QMap<QString, RejectReason> m_rejectedFields;
+
+    QList<AbstractMetaEnum *> m_enums;
+
+    QList<QPair<AbstractMetaArgument *, AbstractMetaFunction *> > m_enumDefaultArguments;
+
+    QHash<QString, AbstractMetaEnumValue *> m_enumValues;
+
+    AbstractMetaClass *m_currentClass;
+    QList<ScopeModelItem> m_scopes;
+    QString m_namespacePrefix;
+
+    QSet<AbstractMetaClass *> m_setupInheritanceDone;
+
+    // QtScript
+    QSet<QString> m_qmetatypeDeclaredTypenames;
+
+    QString m_logDirectory;
+    QFileInfo m_globalHeader;
+};
+
+#endif // ABSTRACTMETBUILDER_H
diff --git a/ApiExtractor/abstractmetalang.cpp b/ApiExtractor/abstractmetalang.cpp
new file mode 100644
index 000000000..fefda5046
--- /dev/null
+++ b/ApiExtractor/abstractmetalang.cpp
@@ -0,0 +1,2426 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "abstractmetalang.h"
+#include "reporthandler.h"
+#include "typedatabase.h"
+
+/*******************************************************************************
+ * AbstractMetaVariable
+ */
+
+AbstractMetaVariable::AbstractMetaVariable(const AbstractMetaVariable &other)
+{
+    m_originalName = other.m_originalName;
+    m_name = other.m_name;
+    m_type = other.m_type->copy();
+    m_hasName = other.m_hasName;
+    m_doc = other.m_doc;
+}
+
+/*******************************************************************************
+ * AbstractMetaType
+ */
+
+AbstractMetaType::AbstractMetaType()
+    :m_typeEntry(0),
+    m_arrayElementCount(0),
+    m_arrayElementType(0),
+    m_originalTemplateType(0),
+    m_pattern(InvalidPattern),
+    m_constant(false),
+    m_reference(false),
+    m_cppInstantiation(true),
+    m_indirections(0),
+    m_reserved(0)
+{
+}
+
+AbstractMetaType::~AbstractMetaType()
+{
+    qDeleteAll(m_children);
+    m_instantiations.clear();
+}
+
+AbstractMetaType *AbstractMetaType::copy() const
+{
+    AbstractMetaType *cpy = new AbstractMetaType;
+
+    cpy->setTypeUsagePattern(typeUsagePattern());
+    cpy->setConstant(isConstant());
+    cpy->setReference(isReference());
+    cpy->setIndirections(indirections());
+    cpy->setInstantiations(instantiations());
+    cpy->setArrayElementCount(arrayElementCount());
+    cpy->setOriginalTypeDescription(originalTypeDescription());
+    cpy->setOriginalTemplateType(originalTemplateType() ? originalTemplateType()->copy() : 0);
+
+    cpy->setArrayElementType(arrayElementType() ? arrayElementType()->copy() : 0);
+
+    cpy->setTypeEntry(typeEntry());
+
+    return cpy;
+}
+
+QString AbstractMetaType::cppSignature() const
+{
+    if (m_cachedCppSignature.isEmpty()) {
+        if (isConstant())
+            m_cachedCppSignature += "const ";
+
+        m_cachedCppSignature += typeEntry()->qualifiedCppName();
+
+        if (hasInstantiationInCpp()) {
+            AbstractMetaTypeList types = instantiations();
+            m_cachedCppSignature += "<";
+            for (int i = 0; i < types.count(); ++i) {
+                if (i > 0)
+                    m_cachedCppSignature += ", ";
+                m_cachedCppSignature += types[i]->cppSignature();
+            }
+            m_cachedCppSignature += " >";
+        }
+
+        if (actualIndirections()) {
+            m_cachedCppSignature += ' ';
+            if (indirections())
+                m_cachedCppSignature += QString(indirections(), '*');
+            if (isReference())
+                m_cachedCppSignature += '&';
+        }
+    }
+    return m_cachedCppSignature;
+}
+
+void AbstractMetaType::decideUsagePattern()
+{
+    const TypeEntry* type = typeEntry();
+
+    if (type->isPrimitive() && (!actualIndirections()
+        || (isConstant() && isReference() && !indirections()))) {
+        setTypeUsagePattern(AbstractMetaType::PrimitivePattern);
+
+    } else if (type->isVoid()) {
+        setTypeUsagePattern(AbstractMetaType::NativePointerPattern);
+
+    } else if (type->isVarargs()) {
+        setTypeUsagePattern(AbstractMetaType::VarargsPattern);
+
+    } else if (type->isString()
+               && indirections() == 0
+               && (isConstant() == isReference()
+                   || isConstant())) {
+        setTypeUsagePattern(AbstractMetaType::StringPattern);
+
+    } else if (type->isChar()
+               && !indirections()
+               && isConstant() == isReference()) {
+        setTypeUsagePattern(AbstractMetaType::CharPattern);
+
+    } else if (type->isJObjectWrapper()
+               && !indirections()
+               && isConstant() == isReference()) {
+        setTypeUsagePattern(AbstractMetaType::JObjectWrapperPattern);
+
+    } else if (type->isVariant()
+               && !indirections()
+               && isConstant() == isReference()) {
+        setTypeUsagePattern(AbstractMetaType::VariantPattern);
+
+    } else if (type->isEnum() && !actualIndirections()) {
+        setTypeUsagePattern(AbstractMetaType::EnumPattern);
+
+    } else if (type->isObject() && indirections() == 0) {
+        if (isReference()) {
+            if (((ComplexTypeEntry*) type)->isQObject())
+                setTypeUsagePattern(AbstractMetaType::QObjectPattern);
+            else
+                setTypeUsagePattern(AbstractMetaType::ObjectPattern);
+        } else {
+            setTypeUsagePattern(AbstractMetaType::ValuePattern);
+        }
+
+    } else if (type->isObject()
+               && indirections() == 1) {
+        if (((ComplexTypeEntry*) type)->isQObject())
+            setTypeUsagePattern(AbstractMetaType::QObjectPattern);
+        else
+            setTypeUsagePattern(AbstractMetaType::ObjectPattern);
+
+        // const-references to pointers can be passed as pointers
+        if (isReference() && isConstant()) {
+            setReference(false);
+            setConstant(false);
+        }
+
+    } else if (type->isContainer() && !indirections()) {
+        setTypeUsagePattern(AbstractMetaType::ContainerPattern);
+
+    } else if (type->isTemplateArgument()) {
+
+    } else if (type->isFlags()
+               && !indirections()
+               && (isConstant() == isReference())) {
+        setTypeUsagePattern(AbstractMetaType::FlagsPattern);
+
+    } else if (type->isArray()) {
+        setTypeUsagePattern(AbstractMetaType::ArrayPattern);
+
+    } else if (type->isThread()) {
+        Q_ASSERT(indirections() == 1);
+        setTypeUsagePattern(AbstractMetaType::ThreadPattern);
+    } else if (type->isValue()) {
+        if (indirections() == 1) {
+            setTypeUsagePattern(AbstractMetaType::ValuePointerPattern);
+        } else {
+            setTypeUsagePattern(AbstractMetaType::ValuePattern);
+        }
+    } else {
+        setTypeUsagePattern(AbstractMetaType::NativePointerPattern);
+        ReportHandler::debugFull(QString("native pointer pattern for '%1'")
+                                 .arg(cppSignature()));
+    }
+}
+
+/*******************************************************************************
+ * AbstractMetaArgument
+ */
+AbstractMetaArgument *AbstractMetaArgument::copy() const
+{
+    return new AbstractMetaArgument(*this);
+}
+
+/*******************************************************************************
+ * AbstractMetaFunction
+ */
+AbstractMetaFunction::~AbstractMetaFunction()
+{
+    qDeleteAll(m_arguments);
+    delete m_type;
+}
+
+/*******************************************************************************
+ * Indicates that this function has a modification that removes it
+ */
+bool AbstractMetaFunction::isModifiedRemoved(int types) const
+{
+    FunctionModificationList mods = modifications(implementingClass());
+    foreach (FunctionModification mod, mods) {
+        if (!mod.isRemoveModifier())
+            continue;
+
+        if ((mod.removal & types) == types)
+            return true;
+    }
+
+    return false;
+}
+
+bool AbstractMetaFunction::needsCallThrough() const
+{
+    if (ownerClass()->isInterface())
+        return false;
+    if (referenceCounts(implementingClass()).size() > 0)
+        return true;
+    if (argumentsHaveNativeId() || !isStatic())
+        return true;
+
+    foreach (const AbstractMetaArgument *arg, arguments()) {
+        if (arg->type()->isArray() || arg->type()->isTargetLangEnum() || arg->type()->isTargetLangFlags())
+            return true;
+    }
+
+    if (type() && (type()->isArray() || type()->isTargetLangEnum() || type()->isTargetLangFlags()))
+        return true;
+
+    for (int i = -1; i <= arguments().size(); ++i) {
+        TypeSystem::Ownership owner = this->ownership(implementingClass(), TypeSystem::TargetLangCode, i);
+        if (owner != TypeSystem::InvalidOwnership)
+            return true;
+    }
+
+    return false;
+}
+
+bool AbstractMetaFunction::needsSuppressUncheckedWarning() const
+{
+    for (int i = -1; i <= arguments().size(); ++i) {
+        QList<ReferenceCount> referenceCounts = this->referenceCounts(implementingClass(), i);
+        foreach (ReferenceCount referenceCount, referenceCounts) {
+            if (referenceCount.action != ReferenceCount::Set)
+                return true;
+        }
+    }
+    return false;
+}
+
+QString AbstractMetaFunction::marshalledName() const
+{
+    QString returned = "__qt_" + name();
+    AbstractMetaArgumentList arguments = this->arguments();
+    foreach (const AbstractMetaArgument *arg, arguments) {
+        returned += "_";
+        if (arg->type()->isNativePointer())
+            returned += "nativepointer";
+        else if (arg->type()->isIntegerEnum() || arg->type()->isIntegerFlags())
+            returned += "int";
+        else
+            returned += arg->type()->name().replace("[]", "_3").replace(".", "_");
+    }
+    return returned;
+}
+
+bool AbstractMetaFunction::operator<(const AbstractMetaFunction &other) const
+{
+    uint result = compareTo(&other);
+    return result & NameLessThan;
+}
+
+
+/*!
+    Returns a mask of CompareResult describing how this function is
+    compares to another function
+*/
+uint AbstractMetaFunction::compareTo(const AbstractMetaFunction *other) const
+{
+    uint result = 0;
+
+    // Enclosing class...
+    if (ownerClass() == other->ownerClass())
+        result |= EqualImplementor;
+
+    // Attributes
+    if (attributes() == other->attributes())
+        result |= EqualAttributes;
+
+    // Compare types
+    AbstractMetaType *t = type();
+    AbstractMetaType *ot = other->type();
+    if ((!t && !ot) || ((t && ot && t->name() == ot->name())))
+        result |= EqualReturnType;
+
+    // Compare names
+    int cmp = originalName().compare(other->originalName());
+
+    if (cmp < 0)
+        result |= NameLessThan;
+    else if (!cmp)
+        result |= EqualName;
+
+    // compare name after modification...
+    cmp = modifiedName().compare(other->modifiedName());
+    if (!cmp)
+        result |= EqualModifiedName;
+
+    // Compare arguments...
+    AbstractMetaArgumentList minArguments;
+    AbstractMetaArgumentList maxArguments;
+    if (arguments().size() < other->arguments().size()) {
+        minArguments = arguments();
+        maxArguments = other->arguments();
+    } else {
+        minArguments = other->arguments();
+        maxArguments = arguments();
+    }
+
+    int minCount = minArguments.size();
+    int maxCount = maxArguments.size();
+    bool same = true;
+    for (int i = 0; i < maxCount; ++i) {
+        if (i < minCount) {
+            const AbstractMetaArgument *min_arg = minArguments.at(i);
+            const AbstractMetaArgument *max_arg = maxArguments.at(i);
+            if (min_arg->type()->name() != max_arg->type()->name()
+                && (min_arg->defaultValueExpression().isEmpty() || max_arg->defaultValueExpression().isEmpty())) {
+                same = false;
+                break;
+            }
+        } else {
+            if (maxArguments.at(i)->defaultValueExpression().isEmpty()) {
+                same = false;
+                break;
+            }
+        }
+    }
+
+    if (same)
+        result |= minCount == maxCount ? EqualArguments : EqualDefaultValueOverload;
+
+    return result;
+}
+
+AbstractMetaFunction *AbstractMetaFunction::copy() const
+{
+    AbstractMetaFunction *cpy = new AbstractMetaFunction;
+    cpy->setName(name());
+    cpy->setOriginalName(originalName());
+    cpy->setOwnerClass(ownerClass());
+    cpy->setImplementingClass(implementingClass());
+    cpy->setInterfaceClass(interfaceClass());
+    cpy->setFunctionType(functionType());
+    cpy->setAttributes(attributes());
+    cpy->setDeclaringClass(declaringClass());
+    if (type())
+        cpy->setType(type()->copy());
+    cpy->setConstant(isConstant());
+    cpy->setOriginalAttributes(originalAttributes());
+
+    foreach (AbstractMetaArgument *arg, arguments())
+    cpy->addArgument(arg->copy());
+
+    Q_ASSERT((!type() && !cpy->type())
+             || (type()->instantiations() == cpy->type()->instantiations()));
+
+    return cpy;
+}
+
+QStringList AbstractMetaFunction::introspectionCompatibleSignatures(const QStringList &resolvedArguments) const
+{
+    AbstractMetaArgumentList arguments = this->arguments();
+    if (arguments.size() == resolvedArguments.size()) {
+        return (QStringList() << TypeDatabase::normalizedSignature((name() + "(" + resolvedArguments.join(",") + ")").toUtf8().constData()));
+    } else {
+        QStringList returned;
+
+        AbstractMetaArgument *argument = arguments.at(resolvedArguments.size());
+        QStringList minimalTypeSignature = argument->type()->minimalSignature().split("::");
+        for (int i = 0; i < minimalTypeSignature.size(); ++i) {
+            returned += introspectionCompatibleSignatures(QStringList(resolvedArguments)
+                                                          << QStringList(minimalTypeSignature.mid(minimalTypeSignature.size() - i - 1)).join("::"));
+        }
+
+        return returned;
+    }
+}
+
+QString AbstractMetaFunction::signature() const
+{
+    if (m_cachedSignature.isEmpty()) {
+        m_cachedSignature = m_originalName;
+
+        m_cachedSignature += '(';
+
+        for (int i = 0; i < m_arguments.count(); ++i) {
+            if (i > 0)
+                m_cachedSignature += ", ";
+            AbstractMetaArgument *a = m_arguments.at(i);
+            m_cachedSignature += a->type()->cppSignature();
+
+            // We need to have the argument names in the qdoc files
+            m_cachedSignature += ' ';
+            m_cachedSignature += a->name();
+        }
+        m_cachedSignature += ")";
+
+        if (isConstant())
+            m_cachedSignature += " const";
+    }
+    return m_cachedSignature;
+}
+
+int AbstractMetaFunction::actualMinimumArgumentCount() const
+{
+    AbstractMetaArgumentList arguments = this->arguments();
+
+    int count = 0;
+    for (int i = 0; i < arguments.size(); ++i && ++count) {
+        if (argumentRemoved(i + 1))
+            --count;
+        else if (!arguments.at(i)->defaultValueExpression().isEmpty())
+            break;
+    }
+
+    return count;
+}
+
+// Returns reference counts for argument at idx, or all arguments if idx == -2
+QList<ReferenceCount> AbstractMetaFunction::referenceCounts(const AbstractMetaClass *cls, int idx) const
+{
+    QList<ReferenceCount> returned;
+
+    FunctionModificationList mods = this->modifications(cls);
+    foreach (FunctionModification mod, mods) {
+        QList<ArgumentModification> argumentMods = mod.argument_mods;
+        foreach (ArgumentModification argumentMod, argumentMods) {
+            if (argumentMod.index != idx && idx != -2)
+                continue;
+            returned += argumentMod.referenceCounts;
+        }
+    }
+
+    return returned;
+}
+
+
+ArgumentOwner AbstractMetaFunction::argumentOwner(const AbstractMetaClass *cls, int idx) const
+{
+    FunctionModificationList mods = this->modifications(cls);
+    foreach (FunctionModification mod, mods) {
+        QList<ArgumentModification> argumentMods = mod.argument_mods;
+        foreach (ArgumentModification argumentMod, argumentMods) {
+            if (argumentMod.index != idx)
+                continue;
+            return argumentMod.owner;
+        }
+    }
+    return ArgumentOwner();
+}
+
+
+QString AbstractMetaFunction::replacedDefaultExpression(const AbstractMetaClass *cls, int key) const
+{
+    FunctionModificationList modifications = this->modifications(cls);
+    foreach (FunctionModification modification, modifications) {
+        QList<ArgumentModification> argumentModifications = modification.argument_mods;
+        foreach (ArgumentModification argumentModification, argumentModifications) {
+            if (argumentModification.index == key
+                && !argumentModification.replacedDefaultExpression.isEmpty()) {
+                return argumentModification.replacedDefaultExpression;
+            }
+        }
+    }
+
+    return QString();
+}
+
+bool AbstractMetaFunction::removedDefaultExpression(const AbstractMetaClass *cls, int key) const
+{
+    FunctionModificationList modifications = this->modifications(cls);
+    foreach (FunctionModification modification, modifications) {
+        QList<ArgumentModification> argumentModifications = modification.argument_mods;
+        foreach (ArgumentModification argumentModification, argumentModifications) {
+            if (argumentModification.index == key
+                && argumentModification.removedDefaultExpression) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+bool AbstractMetaFunction::resetObjectAfterUse(int argumentIdx) const
+{
+    const AbstractMetaClass *cls = declaringClass();
+    FunctionModificationList modifications = this->modifications(cls);
+    foreach (FunctionModification modification, modifications) {
+        QList<ArgumentModification> argumentModifications = modification.argument_mods;
+        foreach (ArgumentModification argumentModification, argumentModifications) {
+            if (argumentModification.index == argumentIdx && argumentModification.resetAfterUse)
+                return true;
+        }
+    }
+
+    return false;
+}
+
+QString AbstractMetaFunction::nullPointerDefaultValue(const AbstractMetaClass *mainClass, int argumentIdx) const
+{
+    Q_ASSERT(nullPointersDisabled(mainClass, argumentIdx));
+
+    const AbstractMetaClass *cls = mainClass;
+    if (!cls)
+        cls = implementingClass();
+
+    do {
+        FunctionModificationList modifications = this->modifications(cls);
+        foreach (FunctionModification modification, modifications) {
+            QList<ArgumentModification> argumentModifications = modification.argument_mods;
+            foreach (ArgumentModification argumentModification, argumentModifications) {
+                if (argumentModification.index == argumentIdx
+                    && argumentModification.noNullPointers) {
+                    return argumentModification.nullPointerDefaultValue;
+                }
+            }
+        }
+        cls = cls->baseClass();
+    } while (cls && !mainClass); // Once when mainClass, or once for all base classes of implementing class
+
+    return QString();
+
+}
+
+bool AbstractMetaFunction::nullPointersDisabled(const AbstractMetaClass *mainClass, int argumentIdx) const
+{
+    const AbstractMetaClass *cls = mainClass;
+    if (!cls)
+        cls = implementingClass();
+
+    do {
+        FunctionModificationList modifications = this->modifications(cls);
+        foreach (FunctionModification modification, modifications) {
+            QList<ArgumentModification> argumentModifications = modification.argument_mods;
+            foreach (ArgumentModification argumentModification, argumentModifications) {
+                if (argumentModification.index == argumentIdx
+                    && argumentModification.noNullPointers) {
+                    return true;
+                }
+            }
+        }
+
+        cls = cls->baseClass();
+    } while (cls && !mainClass); // Once when mainClass, or once for all base classes of implementing class
+
+    return false;
+}
+
+QString AbstractMetaFunction::conversionRule(TypeSystem::Language language, int key) const
+{
+    FunctionModificationList modifications = this->modifications(declaringClass());
+    foreach (FunctionModification modification, modifications) {
+        QList<ArgumentModification> argumentModifications = modification.argument_mods;
+        foreach (ArgumentModification argumentModification, argumentModifications) {
+            if (argumentModification.index != key)
+                continue;
+
+            foreach (CodeSnip snip, argumentModification.conversion_rules) {
+                if (snip.language == language && !snip.code().isEmpty())
+                    return snip.code();
+            }
+        }
+    }
+
+    return QString();
+}
+
+QString AbstractMetaFunction::argumentReplaced(int key) const
+{
+    FunctionModificationList modifications = this->modifications(declaringClass());
+    foreach (FunctionModification modification, modifications) {
+        QList<ArgumentModification>& argumentModifications = modification.argument_mods;
+        foreach (ArgumentModification argumentModification, argumentModifications) {
+            if (argumentModification.index == key && !argumentModification.replace_value.isEmpty())
+                return argumentModification.replace_value;
+        }
+    }
+
+    return "";
+}
+
+// FIXME If we remove a arg. in the method at the base class, it will not reflect here.
+bool AbstractMetaFunction::argumentRemoved(int key) const
+{
+    FunctionModificationList modifications = this->modifications(declaringClass());
+    foreach (FunctionModification modification, modifications) {
+        QList<ArgumentModification> argumentModifications = modification.argument_mods;
+        foreach (ArgumentModification argumentModification, argumentModifications) {
+            if (argumentModification.index == key) {
+                if (argumentModification.removed)
+                    return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+bool AbstractMetaFunction::isVirtualSlot() const
+{
+    FunctionModificationList modifications = this->modifications(declaringClass());
+    foreach (FunctionModification modification, modifications) {
+        if (modification.isVirtualSlot())
+            return true;
+    }
+
+    return false;
+}
+
+bool AbstractMetaFunction::disabledGarbageCollection(const AbstractMetaClass *cls, int key) const
+{
+    FunctionModificationList modifications = this->modifications(cls);
+    foreach (FunctionModification modification, modifications) {
+        QList<ArgumentModification> argumentModifications = modification.argument_mods;
+        foreach (ArgumentModification argumentModification, argumentModifications) {
+            if (argumentModification.index != key)
+                continue;
+
+            foreach (TypeSystem::Ownership ownership, argumentModification.ownerships.values()) {
+                if (ownership == TypeSystem::CppOwnership)
+                    return true;
+            }
+
+        }
+    }
+
+    return false;
+}
+
+bool AbstractMetaFunction::isDeprecated() const
+{
+    FunctionModificationList modifications = this->modifications(declaringClass());
+    foreach (FunctionModification modification, modifications) {
+        if (modification.isDeprecated())
+            return true;
+    }
+    return false;
+}
+
+bool AbstractMetaFunction::isThread() const
+{
+    FunctionModificationList modifications = this->modifications(declaringClass());
+    foreach (FunctionModification modification, modifications) {
+        if (modification.isThread())
+            return true;
+    }
+    return false;
+}
+
+bool AbstractMetaFunction::allowThread() const
+{
+    FunctionModificationList modifications = this->modifications(declaringClass());
+    foreach (FunctionModification modification, modifications) {
+        if (modification.allowThread())
+            return true;
+    }
+    return false;
+}
+
+
+TypeSystem::Ownership AbstractMetaFunction::ownership(const AbstractMetaClass *cls, TypeSystem::Language language, int key) const
+{
+    FunctionModificationList modifications = this->modifications(cls);
+    foreach (FunctionModification modification, modifications) {
+        QList<ArgumentModification> argumentModifications = modification.argument_mods;
+        foreach (ArgumentModification argumentModification, argumentModifications) {
+            if (argumentModification.index == key)
+                return argumentModification.ownerships.value(language, TypeSystem::InvalidOwnership);
+        }
+    }
+
+    return TypeSystem::InvalidOwnership;
+}
+
+bool AbstractMetaFunction::isRemovedFromAllLanguages(const AbstractMetaClass *cls) const
+{
+    return isRemovedFrom(cls, TypeSystem::All);
+}
+
+bool AbstractMetaFunction::isRemovedFrom(const AbstractMetaClass *cls, TypeSystem::Language language) const
+{
+    FunctionModificationList modifications = this->modifications(cls);
+    foreach (FunctionModification modification, modifications) {
+        if ((modification.removal & language) == language)
+            return true;
+    }
+
+    return false;
+
+}
+
+QString AbstractMetaFunction::typeReplaced(int key) const
+{
+    FunctionModificationList modifications = this->modifications(declaringClass());
+    foreach (FunctionModification modification, modifications) {
+        QList<ArgumentModification> argumentModifications = modification.argument_mods;
+        foreach (ArgumentModification argumentModification, argumentModifications) {
+            if (argumentModification.index == key
+                && !argumentModification.modified_type.isEmpty()) {
+                return argumentModification.modified_type;
+            }
+        }
+    }
+
+    return QString();
+}
+
+QString AbstractMetaFunction::minimalSignature() const
+{
+    if (!m_cachedMinimalSignature.isEmpty())
+        return m_cachedMinimalSignature;
+
+    QString minimalSignature = originalName() + "(";
+    AbstractMetaArgumentList arguments = this->arguments();
+
+    for (int i = 0; i < arguments.count(); ++i) {
+        AbstractMetaType *t = arguments.at(i)->type();
+
+        if (i > 0)
+            minimalSignature += ",";
+
+        minimalSignature += t->minimalSignature();
+    }
+    minimalSignature += ")";
+    if (isConstant())
+        minimalSignature += "const";
+
+    minimalSignature = TypeDatabase::normalizedSignature(minimalSignature.toLocal8Bit().constData());
+    m_cachedMinimalSignature = minimalSignature;
+
+    return minimalSignature;
+}
+
+FunctionModificationList AbstractMetaFunction::modifications(const AbstractMetaClass* implementor) const
+{
+    if (!implementor)
+        implementor = ownerClass();
+
+    if (!implementor)
+        return TypeDatabase::instance()->functionModifications(minimalSignature());
+
+    FunctionModificationList mods;
+    while (implementor) {
+        mods += implementor->typeEntry()->functionModifications(minimalSignature());
+        if ((implementor == implementor->baseClass()) ||
+            (implementor == implementingClass() && (mods.size() > 0)))
+                break;
+        implementor = implementor->baseClass();
+    }
+    return mods;
+}
+
+bool AbstractMetaFunction::hasModifications(const AbstractMetaClass *implementor) const
+{
+    return !modifications(implementor).isEmpty();
+}
+
+QString AbstractMetaFunction::argumentName(int index, bool create, const AbstractMetaClass *implementor) const
+{
+    return m_arguments[--index]->name();
+}
+
+bool AbstractMetaFunction::isCallOperator() const
+{
+    return m_name == "operator()";
+}
+
+bool AbstractMetaFunction::hasInjectedCode() const
+{
+    foreach (const FunctionModification mod, modifications(ownerClass())) {
+        if (mod.isCodeInjection())
+            return true;
+    }
+    return false;
+}
+
+CodeSnipList AbstractMetaFunction::injectedCodeSnips(CodeSnip::Position position, TypeSystem::Language language) const
+{
+    CodeSnipList result;
+    foreach (const FunctionModification mod, modifications(ownerClass())) {
+        if (mod.isCodeInjection()) {
+            QList<CodeSnip>::const_iterator it = mod.snips.constBegin();
+            for (;it != mod.snips.constEnd(); ++it) {
+                if ((it->language & language) && (it->position == position || position == CodeSnip::Any))
+                    result << *it;
+            }
+        }
+    }
+    return result;
+}
+
+bool AbstractMetaFunction::hasSignatureModifications() const
+{
+    foreach (const FunctionModification mod, modifications()) {
+        if (mod.isRenameModifier())
+            return true;
+        foreach (const ArgumentModification argmod, mod.argument_mods) {
+            // since zero represents the return type and we're
+            // interested only in checking the function arguments,
+            // it will be ignored.
+            if (argmod.index > 0)
+                return true;
+        }
+    }
+    return false;
+}
+
+bool AbstractMetaFunction::isConversionOperator(QString funcName)
+{
+    static QRegExp opRegEx("^operator(?:\\s+(?:const|volatile))?\\s+(\\w+\\s*)&?$");
+    return opRegEx.indexIn(funcName) > -1;
+}
+
+bool AbstractMetaFunction::isOperatorOverload(QString funcName)
+{
+    if (isConversionOperator(funcName))
+        return true;
+
+    static QRegExp opRegEx("^operator([+\\-\\*/%=&\\|\\^\\<>!][=]?"
+                    "|\\+\\+|\\-\\-|&&|\\|\\||<<[=]?|>>[=]?|~"
+                    "|\\[\\]|\\s+delete\\[?\\]?"
+                    "|\\(\\)"
+                    "|\\s+new\\[?\\]?)$");
+    return opRegEx.indexIn(funcName) > -1;
+}
+
+bool AbstractMetaFunction::isCastOperator() const
+{
+    return originalName().startsWith("operator ");
+}
+
+bool AbstractMetaFunction::isArithmeticOperator() const
+{
+    if (!isOperatorOverload())
+        return false;
+
+    QString name = originalName();
+
+    // It's a dereference operator!
+    if (name == "operator*" && m_arguments.isEmpty())
+        return false;
+
+    return name == "operator+" || name == "operator+="
+            || name == "operator-" || name == "operator-="
+            || name == "operator*" || name == "operator*="
+            || name == "operator/" || name == "operator/="
+            || name == "operator%" || name == "operator%="
+            || name == "operator++" || name == "operator--";
+}
+
+bool AbstractMetaFunction::isBitwiseOperator() const
+{
+    if (!isOperatorOverload())
+        return false;
+
+    QString name = originalName();
+    return name == "operator<<" || name == "operator<<="
+            || name == "operator>>" || name == "operator>>="
+            || name == "operator&" || name == "operator&="
+            || name == "operator|" || name == "operator|="
+            || name == "operator^" || name == "operator^="
+            || name == "operator~";
+}
+
+bool AbstractMetaFunction::isComparisonOperator() const
+{
+    if (!isOperatorOverload())
+        return false;
+
+    QString name = originalName();
+    return name == "operator<" || name == "operator<="
+            || name == "operator>" || name == "operator>="
+            || name == "operator==" || name == "operator!=";
+}
+
+bool AbstractMetaFunction::isLogicalOperator() const
+{
+    if (!isOperatorOverload())
+        return false;
+
+    QString name = originalName();
+    return name == "operator!"
+            || name == "operator&&"
+            || name == "operator||";
+}
+
+bool AbstractMetaFunction::isSubscriptOperator() const
+{
+    if (!isOperatorOverload())
+        return false;
+
+    return originalName() == "operator[]";
+}
+
+bool AbstractMetaFunction::isAssignmentOperator() const
+{
+    if (!isOperatorOverload())
+        return false;
+
+    return originalName() == "operator=";
+}
+
+bool AbstractMetaFunction::isOtherOperator() const
+{
+    if (!isOperatorOverload())
+        return false;
+
+    return !isArithmeticOperator()
+            && !isBitwiseOperator()
+            && !isComparisonOperator()
+            && !isLogicalOperator()
+            && !isConversionOperator()
+            && !isSubscriptOperator()
+            && !isAssignmentOperator();
+}
+
+int AbstractMetaFunction::arityOfOperator() const
+{
+    if (!isOperatorOverload() || isCallOperator())
+        return -1;
+
+    int arity = m_arguments.size();
+
+    // Operator overloads that are class members
+    // implicitly includes the instance and have
+    // one parameter less than their arity,
+    // so we increment it.
+    if (ownerClass() && arity < 2)
+        arity++;
+
+    return arity;
+}
+
+bool AbstractMetaFunction::isInplaceOperator() const
+{
+    if (!isOperatorOverload())
+        return false;
+
+    QString name = originalName();
+    return name == "operator+=" || name == "operator&="
+           || name == "operator-=" || name == "operator|="
+           || name == "operator*=" || name == "operator^="
+           || name == "operator/=" || name == "operator<<="
+           || name == "operator%=" || name == "operator>>=";
+}
+
+bool AbstractMetaFunction::isVirtual() const
+{
+    return !isFinal() && !isSignal() && !isStatic() && !isFinalInCpp() && !isConstructor();
+}
+
+bool AbstractMetaFunction::isCopyConstructor() const
+{
+    if (!ownerClass() || !isConstructor() || arguments().count() != 1)
+        return false;
+
+    const AbstractMetaType* type = arguments().first()->type();
+    return type->typeEntry() == ownerClass()->typeEntry() &&
+           type->isConstant() && type->isReference();
+}
+
+QString AbstractMetaFunction::modifiedName() const
+{
+    if (m_cachedModifiedName.isEmpty()) {
+        FunctionModificationList mods = modifications(implementingClass());
+        foreach (FunctionModification mod, mods) {
+            if (mod.isRenameModifier()) {
+                m_cachedModifiedName = mod.renamedToName;
+                break;
+            }
+        }
+        if (m_cachedModifiedName.isEmpty())
+            m_cachedModifiedName = name();
+    }
+    return m_cachedModifiedName;
+}
+
+QString AbstractMetaFunction::targetLangSignature(bool minimal) const
+{
+    QString s;
+
+    // Attributes...
+    if (!minimal) {
+        // Return type
+        if (type())
+            s += type()->name() + " ";
+        else
+            s += "void ";
+    }
+
+    s += modifiedName();
+    s += "(";
+
+    int j = 0;
+    for (int i = 0; i < m_arguments.size(); ++i) {
+        if (argumentRemoved(i + 1))
+            continue;
+        if (j) {
+            s += ",";
+            if (!minimal)
+                s += QLatin1Char(' ');
+        }
+        s += m_arguments.at(i)->type()->name();
+
+        if (!minimal) {
+            s += " ";
+            s += m_arguments.at(i)->name();
+        }
+        ++j;
+    }
+
+    s += ")";
+
+    return s;
+}
+
+
+bool function_sorter(AbstractMetaFunction *a, AbstractMetaFunction *b)
+{
+    return a->signature() < b->signature();
+}
+
+/*******************************************************************************
+ * AbstractMetaClass
+ */
+AbstractMetaClass::~AbstractMetaClass()
+{
+    qDeleteAll(m_functions);
+    qDeleteAll(m_fields);
+    qDeleteAll(m_enums);
+    qDeleteAll(m_orphanInterfaces);
+    if (hasTemplateBaseClassInstantiations()) {
+        foreach (AbstractMetaType* inst, templateBaseClassInstantiations())
+            delete inst;
+    }
+}
+
+/*******************************************************************************
+ * Returns true if this class is a subclass of the given class
+ */
+bool AbstractMetaClass::inheritsFrom(const AbstractMetaClass *cls) const
+{
+    Q_ASSERT(cls);
+
+    const AbstractMetaClass *clazz = this;
+    while (clazz) {
+        if (clazz == cls)
+            return true;
+
+        clazz = clazz->baseClass();
+    }
+
+    return false;
+}
+
+/*******************************************************************************
+ * Constructs an interface based on the functions and enums in this
+ * class and returns it...
+ */
+AbstractMetaClass *AbstractMetaClass::extractInterface()
+{
+    Q_ASSERT(typeEntry()->designatedInterface());
+
+    if (!m_extractedInterface) {
+        AbstractMetaClass *iface = new AbstractMetaClass;
+        iface->setAttributes(attributes());
+        iface->setBaseClass(0);
+        iface->setPrimaryInterfaceImplementor(this);
+
+        iface->setTypeEntry(typeEntry()->designatedInterface());
+
+        foreach (AbstractMetaFunction *function, functions()) {
+            if (!function->isConstructor())
+                iface->addFunction(function->copy());
+        }
+
+//         iface->setEnums(enums());
+//         setEnums(AbstractMetaEnumList());
+
+        foreach (const AbstractMetaField *field, fields()) {
+            if (field->isPublic()) {
+                AbstractMetaField *new_field = field->copy();
+                new_field->setEnclosingClass(iface);
+                iface->addField(new_field);
+            }
+        }
+
+        m_extractedInterface = iface;
+        addInterface(iface);
+        m_orphanInterfaces << iface;
+    }
+
+    return m_extractedInterface;
+}
+
+/*******************************************************************************
+ * Returns a list of all the functions with a given name
+ */
+AbstractMetaFunctionList AbstractMetaClass::queryFunctionsByName(const QString &name) const
+{
+    AbstractMetaFunctionList returned;
+    AbstractMetaFunctionList functions = this->functions();
+    foreach (AbstractMetaFunction *function, functions) {
+        if (function->name() == name)
+            returned.append(function);
+    }
+
+    return returned;
+}
+
+/*******************************************************************************
+ * Returns all reference count modifications for any function in the class
+ */
+QList<ReferenceCount> AbstractMetaClass::referenceCounts() const
+{
+    QList<ReferenceCount> returned;
+
+    AbstractMetaFunctionList functions = this->functions();
+    foreach (AbstractMetaFunction *function, functions)
+        returned += function->referenceCounts(this);
+
+    return returned;
+}
+
+/*******************************************************************************
+ * Returns a list of all the functions retrieved during parsing which should
+ * be added to the API.
+ */
+AbstractMetaFunctionList AbstractMetaClass::functionsInTargetLang() const
+{
+    int default_flags = NormalFunctions | Visible | NotRemovedFromTargetLang;
+
+    // Interfaces don't implement functions
+    default_flags |= isInterface() ? 0 : ClassImplements;
+
+    // Only public functions in final classes
+    // default_flags |= isFinal() ? WasPublic : 0;
+    int public_flags = isFinal() ? WasPublic : 0;
+
+    // Constructors
+    AbstractMetaFunctionList returned = queryFunctions(Constructors | default_flags | public_flags);
+
+    // Final functions
+    returned += queryFunctions(FinalInTargetLangFunctions | NonStaticFunctions | default_flags | public_flags);
+
+    // Virtual functions
+    returned += queryFunctions(VirtualInTargetLangFunctions | NonStaticFunctions | default_flags | public_flags);
+
+    // Static functions
+    returned += queryFunctions(StaticFunctions | default_flags | public_flags);
+
+    // Empty, private functions, since they aren't caught by the other ones
+    returned += queryFunctions(Empty | Invisible);
+
+    return returned;
+}
+
+AbstractMetaFunctionList AbstractMetaClass::virtualFunctions() const
+{
+    AbstractMetaFunctionList list = functionsInShellClass();
+
+    AbstractMetaFunctionList returned;
+    foreach (AbstractMetaFunction *f, list) {
+        if (!f->isFinalInCpp() || f->isVirtualSlot())
+            returned += f;
+    }
+
+    return returned;
+}
+
+AbstractMetaFunctionList AbstractMetaClass::nonVirtualShellFunctions() const
+{
+    AbstractMetaFunctionList list = functionsInShellClass();
+    AbstractMetaFunctionList returned;
+    foreach (AbstractMetaFunction *f, list) {
+        if (f->isFinalInCpp() && !f->isVirtualSlot())
+            returned += f;
+    }
+
+    return returned;
+}
+
+AbstractMetaFunctionList AbstractMetaClass::implicitConversions() const
+{
+    if (!hasCloneOperator() && !hasExternalConversionOperators())
+        return AbstractMetaFunctionList();
+
+    AbstractMetaFunctionList returned;
+    AbstractMetaFunctionList list = queryFunctions(Constructors);
+    list.append(externalConversionOperators());
+
+    foreach (AbstractMetaFunction *f, list) {
+        if ((f->actualMinimumArgumentCount() == 1 || f->arguments().size() == 1 || f->isConversionOperator())
+            && !f->isExplicit()
+            && !f->isCopyConstructor()
+            && !f->isModifiedRemoved()
+            && (f->originalAttributes() & Public)) {
+            returned += f;
+        }
+    }
+    return returned;
+}
+
+AbstractMetaFunctionList AbstractMetaClass::operatorOverloads(uint query) const
+{
+    AbstractMetaFunctionList list = queryFunctions(OperatorOverloads | Visible);
+    AbstractMetaFunctionList returned;
+    foreach (AbstractMetaFunction *f, list) {
+        if (((query & ArithmeticOp) && f->isArithmeticOperator())
+            || ((query & BitwiseOp) && f->isBitwiseOperator())
+            || ((query & ComparisonOp) && f->isComparisonOperator())
+            || ((query & LogicalOp) && f->isLogicalOperator())
+            || ((query & SubscriptionOp) && f->isSubscriptOperator())
+            || ((query & AssignmentOp) && f->isAssignmentOperator())
+            || ((query & ConversionOp) && f->isConversionOperator())
+            || ((query & OtherOp) && f->isOtherOperator()))
+            returned += f;
+    }
+
+    return returned;
+}
+
+bool AbstractMetaClass::hasOperatorOverload() const
+{
+    foreach (const AbstractMetaFunction *f, m_functions) {
+        if (f->ownerClass() == f->implementingClass() && f->isOperatorOverload() && !f->isPrivate())
+            return true;
+    }
+    return false;
+}
+
+bool AbstractMetaClass::hasArithmeticOperatorOverload() const
+{
+    foreach (const AbstractMetaFunction *f, m_functions) {
+        if (f->ownerClass() == f->implementingClass() && f->isArithmeticOperator() && !f->isPrivate())
+            return true;
+    }
+    return false;
+}
+
+bool AbstractMetaClass::hasBitwiseOperatorOverload() const
+{
+    foreach (const AbstractMetaFunction *f, m_functions) {
+        if (f->ownerClass() == f->implementingClass() && f->isBitwiseOperator() && !f->isPrivate())
+            return true;
+    }
+    return false;
+}
+
+bool AbstractMetaClass::hasComparisonOperatorOverload() const
+{
+    foreach (const AbstractMetaFunction *f, m_functions) {
+        if (f->ownerClass() == f->implementingClass() && f->isComparisonOperator() && !f->isPrivate())
+            return true;
+    }
+    return false;
+}
+
+bool AbstractMetaClass::hasLogicalOperatorOverload() const
+{
+    foreach (const AbstractMetaFunction *f, m_functions) {
+        if (f->ownerClass() == f->implementingClass() && f->isLogicalOperator() && !f->isPrivate())
+            return true;
+    }
+    return false;
+}
+
+bool AbstractMetaClass::hasSubscriptOperatorOverload() const
+{
+    foreach (const AbstractMetaFunction *f, m_functions) {
+        if (f->ownerClass() == f->implementingClass() && f->isSubscriptOperator() && !f->isPrivate())
+            return true;
+    }
+    return false;
+}
+
+bool AbstractMetaClass::hasAssignmentOperatorOverload() const
+{
+    foreach (const AbstractMetaFunction *f, m_functions) {
+        if (f->ownerClass() == f->implementingClass() && f->isAssignmentOperator() && !f->isPrivate())
+            return true;
+    }
+    return false;
+}
+
+bool AbstractMetaClass::hasConversionOperatorOverload() const
+{
+    foreach (const AbstractMetaFunction *f, m_functions) {
+        if (f->ownerClass() == f->implementingClass() && f->isConversionOperator() && !f->isPrivate())
+            return true;
+    }
+    return false;
+}
+
+/*******************************************************************************
+ * Returns a list of all functions that should be declared and implemented in
+ * the shell class which is generated as a wrapper on top of the actual C++ class
+ */
+AbstractMetaFunctionList AbstractMetaClass::functionsInShellClass() const
+{
+    // Only functions and only protected and public functions
+    int default_flags = NormalFunctions | Visible | WasVisible | NotRemovedFromShell;
+
+    // All virtual functions
+    AbstractMetaFunctionList returned = queryFunctions(VirtualFunctions | default_flags);
+
+    // All functions explicitly set to be implemented by the shell class
+    // (mainly superclass functions that are hidden by other declarations)
+    returned += queryFunctions(ForcedShellFunctions | default_flags);
+
+    // All functions explicitly set to be virtual slots
+    returned += queryFunctions(VirtualSlots | default_flags);
+
+    return returned;
+}
+
+/*******************************************************************************
+ * Returns a list of all functions that require a public override function to
+ * be generated in the shell class. This includes all functions that were originally
+ * protected in the superclass.
+ */
+AbstractMetaFunctionList AbstractMetaClass::publicOverrideFunctions() const
+{
+    return queryFunctions(NormalFunctions | WasProtected | FinalInCppFunctions | NotRemovedFromTargetLang)
+           + queryFunctions(Signals | WasProtected | FinalInCppFunctions | NotRemovedFromTargetLang);
+}
+
+AbstractMetaFunctionList AbstractMetaClass::virtualOverrideFunctions() const
+{
+    return queryFunctions(NormalFunctions | NonEmptyFunctions | Visible | VirtualInCppFunctions | NotRemovedFromShell) +
+           queryFunctions(Signals | NonEmptyFunctions | Visible | VirtualInCppFunctions | NotRemovedFromShell);
+}
+
+void AbstractMetaClass::sortFunctions()
+{
+    qSort(m_functions.begin(), m_functions.end(), function_sorter);
+}
+
+void AbstractMetaClass::setFunctions(const AbstractMetaFunctionList &functions)
+{
+    m_functions = functions;
+
+    // Functions must be sorted by name before next loop
+    sortFunctions();
+
+    QString currentName;
+    bool hasVirtuals = false;
+    AbstractMetaFunctionList finalFunctions;
+    foreach (AbstractMetaFunction *f, m_functions) {
+        f->setOwnerClass(this);
+
+        m_hasVirtualSlots = m_hasVirtualSlots || f->isVirtualSlot();
+        m_hasVirtuals = m_hasVirtuals || f->isVirtualSlot() || hasVirtualDestructor();
+        m_isPolymorphic = m_isPolymorphic || m_hasVirtuals;
+        m_hasNonpublic = m_hasNonpublic || !f->isPublic();
+
+        // If we have non-virtual overloads of a virtual function, we have to implement
+        // all the overloads in the shell class to override the hiding rule
+        if (currentName == f->name()) {
+            hasVirtuals = hasVirtuals || !f->isFinal();
+            if (f->isFinal())
+                finalFunctions += f;
+        } else {
+            if (hasVirtuals && finalFunctions.size() > 0) {
+                foreach (AbstractMetaFunction *final_function, finalFunctions) {
+                    *final_function += AbstractMetaAttributes::ForceShellImplementation;
+
+                    QString warn = QString("hiding of function '%1' in class '%2'")
+                                   .arg(final_function->name()).arg(name());
+                    ReportHandler::warning(warn);
+                }
+            }
+
+            hasVirtuals = !f->isFinal();
+            finalFunctions.clear();
+            if (f->isFinal())
+                finalFunctions += f;
+            currentName = f->name();
+        }
+    }
+}
+
+bool AbstractMetaClass::hasFieldAccessors() const
+{
+    foreach (const AbstractMetaField *field, fields()) {
+        if (field->getter() || field->setter())
+            return true;
+    }
+
+    return false;
+}
+
+bool AbstractMetaClass::hasDefaultToStringFunction() const
+{
+    foreach (AbstractMetaFunction *f, queryFunctionsByName("toString")) {
+        if (!f->actualMinimumArgumentCount())
+            return true;
+    }
+    return false;
+}
+
+void AbstractMetaClass::addFunction(AbstractMetaFunction *function)
+{
+    Q_ASSERT(!function->signature().startsWith("("));
+    function->setOwnerClass(this);
+
+    if (!function->isDestructor())
+        m_functions << function;
+    else
+        Q_ASSERT(false); //memory leak
+
+    m_hasVirtualSlots |= function->isVirtualSlot();
+    m_hasVirtuals |= !function->isFinal() || function->isVirtualSlot() || hasVirtualDestructor();
+    m_isPolymorphic |= m_hasVirtuals;
+    m_hasNonpublic |= !function->isPublic();
+}
+
+bool AbstractMetaClass::hasSignal(const AbstractMetaFunction *other) const
+{
+    if (!other->isSignal())
+        return false;
+
+    foreach (const AbstractMetaFunction *f, functions()) {
+        if (f->isSignal() && f->compareTo(other) & AbstractMetaFunction::EqualName)
+            return other->modifiedName() == f->modifiedName();
+    }
+
+    return false;
+}
+
+
+QString AbstractMetaClass::name() const
+{
+    return QString(m_typeEntry->targetLangName()).split("::").last();
+}
+
+void AbstractMetaClass::setBaseClass(AbstractMetaClass *baseClass)
+{
+    m_baseClass = baseClass;
+    if (baseClass)
+        m_isPolymorphic |= baseClass->isPolymorphic();
+}
+
+bool AbstractMetaClass::hasFunction(const QString &str) const
+{
+    return findFunction(str);
+}
+
+const AbstractMetaFunction* AbstractMetaClass::findFunction(const QString& functionName) const
+{
+    foreach (const AbstractMetaFunction *f, functions()) {
+        if (f->name() == functionName)
+            return f;
+    }
+    return 0;
+}
+
+bool AbstractMetaClass::hasProtectedFunctions() const
+{
+    foreach (AbstractMetaFunction *func, m_functions) {
+        if (func->isProtected())
+            return true;
+    }
+    return false;
+}
+
+bool AbstractMetaClass::hasProtectedFields() const
+{
+    foreach (const AbstractMetaField *field, fields()) {
+        if (field->isProtected())
+            return true;
+    }
+    return false;
+}
+
+bool AbstractMetaClass::hasProtectedMembers() const
+{
+    return hasProtectedFields() || hasProtectedFunctions();
+}
+
+bool AbstractMetaClass::generateShellClass() const
+{
+    return m_forceShellClass ||
+           (!isFinal()
+            && (hasVirtualFunctions()
+                || hasProtectedFunctions()
+                || hasFieldAccessors()));
+}
+
+QPropertySpec *AbstractMetaClass::propertySpecForRead(const QString &name) const
+{
+    for (int i = 0; i < m_propertySpecs.size(); ++i)
+        if (name == m_propertySpecs.at(i)->read())
+            return m_propertySpecs.at(i);
+    return 0;
+}
+
+QPropertySpec *AbstractMetaClass::propertySpecForWrite(const QString &name) const
+{
+    for (int i = 0; i < m_propertySpecs.size(); ++i)
+        if (name == m_propertySpecs.at(i)->write())
+            return m_propertySpecs.at(i);
+    return 0;
+}
+
+QPropertySpec *AbstractMetaClass::propertySpecForReset(const QString &name) const
+{
+    for (int i = 0; i < m_propertySpecs.size(); ++i) {
+        if (name == m_propertySpecs.at(i)->reset())
+            return m_propertySpecs.at(i);
+    }
+    return 0;
+}
+
+typedef QHash<const AbstractMetaClass*, AbstractMetaTypeList> AbstractMetaClassBaseTemplateInstantiationsMap;
+Q_GLOBAL_STATIC(AbstractMetaClassBaseTemplateInstantiationsMap, metaClassBaseTemplateInstantiations);
+
+bool AbstractMetaClass::hasTemplateBaseClassInstantiations() const
+{
+    if (!templateBaseClass())
+        return false;
+    return metaClassBaseTemplateInstantiations()->contains(this);
+}
+
+AbstractMetaTypeList AbstractMetaClass::templateBaseClassInstantiations() const
+{
+    if (!templateBaseClass())
+        return AbstractMetaTypeList();
+    return metaClassBaseTemplateInstantiations()->value(this);
+}
+
+void AbstractMetaClass::setTemplateBaseClassInstantiations(AbstractMetaTypeList& instantiations)
+{
+    if (!templateBaseClass())
+        return;
+    metaClassBaseTemplateInstantiations()->insert(this, instantiations);
+}
+
+static bool functions_contains(const AbstractMetaFunctionList &l, const AbstractMetaFunction *func)
+{
+    foreach (const AbstractMetaFunction *f, l) {
+        if ((f->compareTo(func) & AbstractMetaFunction::PrettySimilar) == AbstractMetaFunction::PrettySimilar)
+            return true;
+    }
+    return false;
+}
+
+AbstractMetaField::AbstractMetaField() : m_getter(0), m_setter(0), m_class(0)
+{
+}
+
+AbstractMetaField::~AbstractMetaField()
+{
+    delete m_setter;
+    delete m_getter;
+}
+
+AbstractMetaField *AbstractMetaField::copy() const
+{
+    AbstractMetaField *returned = new AbstractMetaField;
+    returned->setEnclosingClass(0);
+    returned->setAttributes(attributes());
+    returned->setName(name());
+    returned->setType(type()->copy());
+    returned->setOriginalAttributes(originalAttributes());
+
+    return returned;
+}
+
+/*******************************************************************************
+ * Indicates that this field has a modification that removes it
+ */
+bool AbstractMetaField::isModifiedRemoved(int types) const
+{
+    FieldModificationList mods = modifications();
+    foreach (FieldModification mod, mods) {
+        if (!mod.isRemoveModifier())
+            continue;
+
+        if ((mod.removal & types) == types)
+            return true;
+    }
+
+    return false;
+}
+
+static QString upCaseFirst(const QString &str)
+{
+    Q_ASSERT(!str.isEmpty());
+    QString s = str;
+    s[0] = s.at(0).toUpper();
+    return s;
+}
+
+static AbstractMetaFunction *createXetter(const AbstractMetaField *g, const QString &name, uint type)
+{
+    AbstractMetaFunction *f = new AbstractMetaFunction;
+
+    f->setName(name);
+    f->setOriginalName(name);
+    f->setOwnerClass(g->enclosingClass());
+    f->setImplementingClass(g->enclosingClass());
+    f->setDeclaringClass(g->enclosingClass());
+
+    uint attr = AbstractMetaAttributes::Native
+                | AbstractMetaAttributes::Final
+                | type;
+    if (g->isStatic())
+        attr |= AbstractMetaAttributes::Static;
+    if (g->isPublic())
+        attr |= AbstractMetaAttributes::Public;
+    else if (g->isProtected())
+        attr |= AbstractMetaAttributes::Protected;
+    else
+        attr |= AbstractMetaAttributes::Private;
+    f->setAttributes(attr);
+    f->setOriginalAttributes(attr);
+
+    FieldModificationList mods = g->modifications();
+    foreach (FieldModification mod, mods) {
+        if (mod.isRenameModifier())
+            f->setName(mod.renamedTo());
+        if (mod.isAccessModifier()) {
+            if (mod.isPrivate())
+                f->setVisibility(AbstractMetaAttributes::Private);
+            else if (mod.isProtected())
+                f->setVisibility(AbstractMetaAttributes::Protected);
+            else if (mod.isPublic())
+                f->setVisibility(AbstractMetaAttributes::Public);
+            else if (mod.isFriendly())
+                f->setVisibility(AbstractMetaAttributes::Friendly);
+        }
+    }
+    return f;
+}
+
+FieldModificationList AbstractMetaField::modifications() const
+{
+    FieldModificationList mods = enclosingClass()->typeEntry()->fieldModifications();
+    FieldModificationList returned;
+
+    foreach (FieldModification mod, mods) {
+        if (mod.name == name())
+            returned += mod;
+    }
+
+    return returned;
+}
+
+const AbstractMetaFunction *AbstractMetaField::setter() const
+{
+    if (!m_setter) {
+        m_setter = createXetter(this,
+                                "set" + upCaseFirst(name()),
+                                AbstractMetaAttributes::SetterFunction);
+        AbstractMetaArgumentList arguments;
+        AbstractMetaArgument *argument = new AbstractMetaArgument;
+        argument->setType(type()->copy());
+        argument->setName(name());
+        arguments.append(argument);
+        m_setter->setArguments(arguments);
+    }
+    return m_setter;
+}
+
+const AbstractMetaFunction *AbstractMetaField::getter() const
+{
+    if (!m_getter) {
+        m_getter = createXetter(this,
+                                name(),
+                                AbstractMetaAttributes::GetterFunction);
+        m_getter->setType(type());
+    }
+
+    return m_getter;
+}
+
+
+bool AbstractMetaClass::hasConstructors() const
+{
+    return queryFunctions(Constructors).size();
+}
+
+bool AbstractMetaClass::hasCopyConstructor() const
+{
+    foreach (const AbstractMetaFunction* ctor, queryFunctions(Constructors)) {
+        if (ctor->isCopyConstructor())
+            return true;
+    }
+    return false;
+}
+
+bool AbstractMetaClass::hasPrivateCopyConstructor() const
+{
+    foreach (const AbstractMetaFunction* ctor, queryFunctions(Constructors)) {
+        if (ctor->isCopyConstructor() && ctor->isPrivate())
+            return true;
+    }
+    return false;
+}
+
+void AbstractMetaClass::addDefaultConstructor()
+{
+    AbstractMetaFunction *f = new AbstractMetaFunction;
+    f->setOriginalName(name());
+    f->setName(name());
+    f->setOwnerClass(this);
+    f->setFunctionType(AbstractMetaFunction::ConstructorFunction);
+    f->setArguments(AbstractMetaArgumentList());
+    f->setDeclaringClass(this);
+
+    uint attr = AbstractMetaAttributes::Native;
+    attr |= AbstractMetaAttributes::Public;
+    attr |= AbstractMetaAttributes::Final;
+    f->setAttributes(attr);
+    f->setImplementingClass(this);
+    f->setOriginalAttributes(f->attributes());
+
+    addFunction(f);
+    this->setHasNonPrivateConstructor(true);
+}
+
+void AbstractMetaClass::addDefaultCopyConstructor(bool isPrivate)
+{
+    AbstractMetaFunction* f = new AbstractMetaFunction;
+    f->setOriginalName(name());
+    f->setName(name());
+    f->setOwnerClass(this);
+    f->setFunctionType(AbstractMetaFunction::ConstructorFunction);
+    f->setDeclaringClass(this);
+
+    AbstractMetaType* argType = new AbstractMetaType;
+    argType->setTypeEntry(typeEntry());
+    argType->setReference(true);
+    argType->setConstant(true);
+    argType->setTypeUsagePattern(AbstractMetaType::ValuePattern);
+
+    AbstractMetaArgument* arg = new AbstractMetaArgument;
+    arg->setType(argType);
+    arg->setName(name());
+    f->addArgument(arg);
+
+    uint attr = AbstractMetaAttributes::Native;
+    attr |= AbstractMetaAttributes::Final;
+    if (isPrivate)
+        attr |= AbstractMetaAttributes::Private;
+    else
+        attr |= AbstractMetaAttributes::Public;
+    f->setAttributes(attr);
+    f->setImplementingClass(this);
+    f->setOriginalAttributes(f->attributes());
+
+    addFunction(f);
+}
+
+bool AbstractMetaClass::hasFunction(const AbstractMetaFunction *f) const
+{
+    return functions_contains(m_functions, f);
+}
+
+/* Goes through the list of functions and returns a list of all
+   functions matching all of the criteria in \a query.
+ */
+
+AbstractMetaFunctionList AbstractMetaClass::queryFunctions(uint query) const
+{
+    AbstractMetaFunctionList functions;
+
+    foreach (AbstractMetaFunction *f, m_functions) {
+
+        if ((query & VirtualSlots) && !f->isVirtualSlot())
+            continue;
+
+        if ((query & NotRemovedFromTargetLang) && f->isRemovedFrom(f->implementingClass(), TypeSystem::TargetLangCode))
+            continue;
+
+        if ((query & NotRemovedFromTargetLang) && !f->isFinal() && f->isRemovedFrom(f->declaringClass(), TypeSystem::TargetLangCode))
+            continue;
+
+        if ((query & NotRemovedFromShell) && f->isRemovedFrom(f->implementingClass(), TypeSystem::ShellCode))
+            continue;
+
+        if ((query & NotRemovedFromShell) && !f->isFinal() && f->isRemovedFrom(f->declaringClass(), TypeSystem::ShellCode))
+            continue;
+
+        if ((query & Visible) && f->isPrivate())
+            continue;
+
+        if ((query & VirtualInTargetLangFunctions) && f->isFinalInTargetLang())
+            continue;
+
+        if ((query & Invisible) && !f->isPrivate())
+            continue;
+
+        if ((query & Empty) && !f->isEmptyFunction())
+            continue;
+
+        if ((query & WasPublic) && !f->wasPublic())
+            continue;
+
+        if ((query & WasVisible) && f->wasPrivate())
+            continue;
+
+        if ((query & WasProtected) && !f->wasProtected())
+            continue;
+
+        if ((query & ClassImplements) && f->ownerClass() != f->implementingClass())
+            continue;
+
+        if ((query & Inconsistent) && (f->isFinalInTargetLang() || !f->isFinalInCpp() || f->isStatic()))
+            continue;
+
+        if ((query & FinalInTargetLangFunctions) && !f->isFinalInTargetLang())
+            continue;
+
+        if ((query & FinalInCppFunctions) && !f->isFinalInCpp())
+            continue;
+
+        if ((query & VirtualInCppFunctions) && f->isFinalInCpp())
+            continue;
+
+        if ((query & Signals) && (!f->isSignal()))
+            continue;
+
+        if ((query & ForcedShellFunctions) &&
+            (!f->isForcedShellImplementation() || !f->isFinal())) {
+            continue;
+        }
+
+        if ((query & Constructors) && (!f->isConstructor() || f->ownerClass() != f->implementingClass()))
+            continue;
+
+        if (!(query & Constructors) && f->isConstructor())
+            continue;
+
+        // Destructors are never included in the functions of a class currently
+        /*
+           if ((query & Destructors) && (!f->isDestructor()
+                                       || f->ownerClass() != f->implementingClass())
+            || f->isDestructor() && (query & Destructors) == 0) {
+            continue;
+        }*/
+
+        if ((query & VirtualFunctions) && (f->isFinal() || f->isSignal() || f->isStatic()))
+            continue;
+
+        if ((query & StaticFunctions) && (!f->isStatic() || f->isSignal()))
+            continue;
+
+        if ((query & NonStaticFunctions) && (f->isStatic()))
+            continue;
+
+        if ((query & NonEmptyFunctions) && (f->isEmptyFunction()))
+            continue;
+
+        if ((query & NormalFunctions) && (f->isSignal()))
+            continue;
+
+        if ((query & AbstractFunctions) && !f->isAbstract())
+            continue;
+
+        if ((query & OperatorOverloads) && !f->isOperatorOverload())
+            continue;
+
+        functions << f;
+    }
+
+    return functions;
+}
+
+
+bool AbstractMetaClass::hasInconsistentFunctions() const
+{
+    return cppInconsistentFunctions().size() > 0;
+}
+
+bool AbstractMetaClass::hasSignals() const
+{
+    return cppSignalFunctions().size() > 0;
+}
+
+
+/**
+ * Adds the specified interface to this class by adding all the
+ * functions in the interface to this class.
+ */
+void AbstractMetaClass::addInterface(AbstractMetaClass *interface)
+{
+    Q_ASSERT(!m_interfaces.contains(interface));
+    m_interfaces << interface;
+
+    m_isPolymorphic |= interface->isPolymorphic();
+
+    if (m_extractedInterface && m_extractedInterface != interface)
+        m_extractedInterface->addInterface(interface);
+
+#if 0
+    foreach (AbstractMetaFunction *function, interface->functions())
+    if (!hasFunction(function) && !function->isConstructor()) {
+        AbstractMetaFunction *cpy = function->copy();
+        cpy->setImplementingClass(this);
+
+        // Setup that this function is an interface class.
+        cpy->setInterfaceClass(interface);
+        *cpy += AbstractMetaAttributes::InterfaceFunction;
+
+        // Copy the modifications in interface into the implementing classes.
+        FunctionModificationList mods = function->modifications(interface);
+        foreach (const FunctionModification &mod, mods)
+            m_typeEntry->addFunctionModification(mod);
+
+        // It should be mostly safe to assume that when we implement an interface
+        // we don't "pass on" pure virtual functions to our sublcasses...
+//             *cpy -= AbstractMetaAttributes::Abstract;
+
+        addFunction(cpy);
+    }
+#endif
+
+}
+
+
+void AbstractMetaClass::setInterfaces(const AbstractMetaClassList &interfaces)
+{
+    m_interfaces = interfaces;
+    foreach (const AbstractMetaClass* interface, interfaces) {
+        if (interface)
+            m_isPolymorphic |= interface->isPolymorphic();
+    }
+}
+
+
+AbstractMetaEnum *AbstractMetaClass::findEnum(const QString &enumName)
+{
+    foreach (AbstractMetaEnum *e, m_enums) {
+        if (e->name() == enumName)
+            return e;
+    }
+
+    if (typeEntry()->designatedInterface())
+        return extractInterface()->findEnum(enumName);
+
+    return 0;
+}
+
+
+
+
+/*!  Recursivly searches for the enum value named \a enumValueName in
+  this class and its superclasses and interfaces. Values belonging to
+  \a meta_enum are excluded from the search.
+*/
+AbstractMetaEnumValue *AbstractMetaClass::findEnumValue(const QString &enumValueName, AbstractMetaEnum *meta_enum)
+{
+    foreach (AbstractMetaEnum *e, m_enums) {
+        if (e != meta_enum)
+            continue;
+        foreach (AbstractMetaEnumValue *v, e->values()) {
+            if (v->name() == enumValueName)
+                return v;
+        }
+    }
+
+    if (typeEntry()->designatedInterface())
+        return extractInterface()->findEnumValue(enumValueName, meta_enum);
+
+    if (baseClass())
+        return baseClass()->findEnumValue(enumValueName, meta_enum);
+
+    return 0;
+}
+
+
+/*!
+ * Searches through all of this class' enums for a value matching the
+ * name \a enumValueName. The name is excluding the class/namespace
+ * prefix. The function recursivly searches interfaces and baseclasses
+ * of this class.
+ */
+AbstractMetaEnum *AbstractMetaClass::findEnumForValue(const QString &enumValueName)
+{
+    foreach (AbstractMetaEnum *e, m_enums) {
+        foreach (AbstractMetaEnumValue *v, e->values()) {
+            if (v->name() == enumValueName)
+                return e;
+        }
+    }
+
+    if (typeEntry()->designatedInterface())
+        return extractInterface()->findEnumForValue(enumValueName);
+
+    if (baseClass())
+        return baseClass()->findEnumForValue(enumValueName);
+
+    return 0;
+}
+
+
+static void addExtraIncludeForType(AbstractMetaClass *metaClass, const AbstractMetaType *type)
+{
+    if (!type)
+        return;
+
+    Q_ASSERT(metaClass);
+    const TypeEntry *entry = (type ? type->typeEntry() : 0);
+    if (entry && entry->isComplex()) {
+        const ComplexTypeEntry *centry = static_cast<const ComplexTypeEntry *>(entry);
+        ComplexTypeEntry *class_entry = metaClass->typeEntry();
+        if (class_entry && centry->include().isValid())
+            class_entry->addExtraInclude(centry->include());
+    }
+
+    if (type->hasInstantiations()) {
+        AbstractMetaTypeList instantiations = type->instantiations();
+        foreach (const AbstractMetaType *instantiation, instantiations)
+            addExtraIncludeForType(metaClass, instantiation);
+    }
+}
+
+static void addExtraIncludesForFunction(AbstractMetaClass *metaClass, const AbstractMetaFunction *meta_function)
+{
+    Q_ASSERT(metaClass);
+    Q_ASSERT(meta_function);
+    addExtraIncludeForType(metaClass, meta_function->type());
+
+    AbstractMetaArgumentList arguments = meta_function->arguments();
+    foreach (AbstractMetaArgument *argument, arguments)
+    addExtraIncludeForType(metaClass, argument->type());
+}
+
+void AbstractMetaClass::fixFunctions()
+{
+    if (m_functionsFixed)
+        return;
+    else
+        m_functionsFixed = true;
+
+    AbstractMetaClass *superClass = baseClass();
+    AbstractMetaFunctionList funcs = functions();
+
+    if (superClass)
+        superClass->fixFunctions();
+    int iface_idx = 0;
+    while (superClass || iface_idx < interfaces().size()) {
+        // Since we always traverse the complete hierarchy we are only
+        // interrested in what each super class implements, not what
+        // we may have propagated from their base classes again.
+        AbstractMetaFunctionList superFuncs;
+        if (superClass) {
+            // Super classes can never be final
+            if (superClass->isFinalInTargetLang()) {
+                ReportHandler::warning("Final class '" + superClass->name() + "' set to non-final, as it is extended by other classes");
+                *superClass -= AbstractMetaAttributes::FinalInTargetLang;
+            }
+            superFuncs = superClass->queryFunctions(AbstractMetaClass::ClassImplements);
+            AbstractMetaFunctionList virtuals = superClass->queryFunctions(AbstractMetaClass::VirtualInCppFunctions);
+            superFuncs += virtuals;
+        } else {
+            superFuncs = interfaces().at(iface_idx)->queryFunctions(AbstractMetaClass::NormalFunctions);
+            AbstractMetaFunctionList virtuals = interfaces().at(iface_idx)->queryFunctions(AbstractMetaClass::VirtualInCppFunctions);
+            superFuncs += virtuals;
+        }
+
+        QSet<AbstractMetaFunction *> funcsToAdd;
+        for (int sfi = 0; sfi < superFuncs.size(); ++sfi) {
+            AbstractMetaFunction *sf = superFuncs.at(sfi);
+
+            if (sf->isRemovedFromAllLanguages(sf->implementingClass()))
+                continue;
+
+            // skip functions added in base classes
+            if (sf->isUserAdded() && sf->declaringClass() != this)
+                continue;
+
+            // we generally don't care about private functions, but we have to get the ones that are
+            // virtual in case they override abstract functions.
+            bool add = (sf->isNormal() || sf->isSignal() || sf->isEmptyFunction());
+            for (int fi = 0; fi < funcs.size(); ++fi) {
+                AbstractMetaFunction *f = funcs.at(fi);
+                if (f->isRemovedFromAllLanguages(f->implementingClass()))
+                    continue;
+
+
+                uint cmp = f->compareTo(sf);
+
+                if (cmp & AbstractMetaFunction::EqualModifiedName) {
+                    add = false;
+                    if (cmp & AbstractMetaFunction::EqualArguments) {
+                        // Same function, propegate virtual...
+                        if (!(cmp & AbstractMetaFunction::EqualAttributes)) {
+                            if (!f->isEmptyFunction()) {
+                                if (!sf->isFinalInCpp() && f->isFinalInCpp()) {
+                                    *f -= AbstractMetaAttributes::FinalInCpp;
+                                }
+                                if (!sf->isFinalInTargetLang() && f->isFinalInTargetLang()) {
+                                    *f -= AbstractMetaAttributes::FinalInTargetLang;
+                                }
+#if 0
+                                if (!f->isFinalInTargetLang() && f->isPrivate()) {
+                                    f->setFunctionType(AbstractMetaFunction::EmptyFunction);
+                                    f->setVisibility(AbstractMetaAttributes::Protected);
+                                    *f += AbstractMetaAttributes::FinalInTargetLang;
+                                    ReportHandler::warning(QString("private virtual function '%1' in '%2'")
+                                                           .arg(f->signature())
+                                                           .arg(f->implementingClass()->name()));
+                                }
+#endif
+                            }
+                        }
+
+                        if (f->visibility() != sf->visibility()) {
+                            QString warn = QString("visibility of function '%1' modified in class '%2'")
+                                           .arg(f->name()).arg(name());
+                            ReportHandler::warning(warn);
+#if 0
+                            // If new visibility is private, we can't
+                            // do anything. If it isn't, then we
+                            // prefer the parent class's visibility
+                            // setting for the function.
+                            if (!f->isPrivate() && !sf->isPrivate())
+                                f->setVisibility(sf->visibility());
+#endif
+                            // Private overrides of abstract functions have to go into the class or
+                            // the subclasses will not compile as non-abstract classes.
+                            // But they don't need to be implemented, since they can never be called.
+                            if (f->isPrivate()) {
+                                f->setFunctionType(AbstractMetaFunction::EmptyFunction);
+                                *f += AbstractMetaAttributes::FinalInTargetLang;
+                                *f += AbstractMetaAttributes::FinalInCpp;
+                            }
+                        }
+
+                        // Set the class which first declares this function, afawk
+                        f->setDeclaringClass(sf->declaringClass());
+
+                        if (sf->isFinalInTargetLang() && !sf->isPrivate() && !f->isPrivate() && !sf->isStatic() && !f->isStatic()) {
+                            // Shadowed funcion, need to make base class
+                            // function non-virtual
+                            if (f->implementingClass() != sf->implementingClass() && f->implementingClass()->inheritsFrom(sf->implementingClass())) {
+
+                                // Check whether the superclass method has been redefined to non-final
+
+                                bool hasNonFinalModifier = false;
+                                bool isBaseImplPrivate = false;
+                                FunctionModificationList mods = sf->modifications(sf->implementingClass());
+                                foreach (FunctionModification mod, mods) {
+                                    if (mod.isNonFinal()) {
+                                        hasNonFinalModifier = true;
+                                        break;
+                                    } else if (mod.isPrivate()) {
+                                        isBaseImplPrivate = true;
+                                        break;
+                                    }
+                                }
+
+                                if (!hasNonFinalModifier && !isBaseImplPrivate) {
+                                    ReportHandler::warning(QString::fromLatin1("Shadowing: %1::%2 and %3::%4")
+                                                           .arg(sf->implementingClass()->name())
+                                                           .arg(sf->signature())
+                                                           .arg(f->implementingClass()->name())
+                                                           .arg(f->signature()));
+                                }
+                            }
+                        }
+
+                    }
+
+                    if (cmp & AbstractMetaFunction::EqualDefaultValueOverload) {
+                        AbstractMetaArgumentList arguments;
+                        if (f->arguments().size() < sf->arguments().size())
+                            arguments = sf->arguments();
+                        else
+                            arguments = f->arguments();
+                        //TODO: fix this
+                        //for (int i=0; i<arguments.size(); ++i)
+                        //    arguments[i]->setDefaultValueExpression("<#>" + QString());
+                    }
+
+
+                    // Otherwise we have function shadowing and we can
+                    // skip the thing...
+                } else if (cmp & AbstractMetaFunction::EqualName && !sf->isSignal()) {
+                    // In the case of function shadowing where the function name has been altered to
+                    // avoid conflict, we don't copy in the original.
+                    add = false;
+                }
+            }
+
+            if (add)
+                funcsToAdd << sf;
+        }
+
+        foreach (AbstractMetaFunction *f, funcsToAdd)
+            funcs << f->copy();
+
+        if (superClass)
+            superClass = superClass->baseClass();
+        else
+            iface_idx++;
+    }
+
+    bool hasPrivateConstructors = false;
+    bool hasPublicConstructors = false;
+    foreach (AbstractMetaFunction *func, funcs) {
+        FunctionModificationList mods = func->modifications(this);
+        foreach (const FunctionModification &mod, mods) {
+            if (mod.isRenameModifier()) {
+                func->setName(mod.renamedTo());
+            }
+        }
+
+        // Make sure class is abstract if one of the functions is
+        if (func->isAbstract()) {
+            (*this) += AbstractMetaAttributes::Abstract;
+            (*this) -= AbstractMetaAttributes::Final;
+        }
+
+        if (func->isConstructor()) {
+            if (func->isPrivate())
+                hasPrivateConstructors = true;
+            else
+                hasPublicConstructors = true;
+        }
+
+
+
+        // Make sure that we include files for all classes that are in use
+
+        if (!func->isRemovedFrom(this, TypeSystem::ShellCode))
+            addExtraIncludesForFunction(this, func);
+    }
+
+    if (hasPrivateConstructors && !hasPublicConstructors) {
+        (*this) += AbstractMetaAttributes::Abstract;
+        (*this) -= AbstractMetaAttributes::Final;
+    }
+
+    foreach (AbstractMetaFunction *f1, funcs) {
+        foreach (AbstractMetaFunction *f2, funcs) {
+            if (f1 != f2) {
+                uint cmp = f1->compareTo(f2);
+                if ((cmp & AbstractMetaFunction::EqualName)
+                    && !f1->isFinalInCpp()
+                    && f2->isFinalInCpp()) {
+                    *f2 += AbstractMetaAttributes::FinalOverload;
+                }
+            }
+        }
+    }
+
+    setFunctions(funcs);
+}
+
+
+QString AbstractMetaType::minimalSignature() const
+{
+    QString minimalSignature;
+    if (isConstant())
+        minimalSignature += "const ";
+    minimalSignature += typeEntry()->qualifiedCppName();
+    if (hasInstantiations()) {
+        AbstractMetaTypeList instantiations = this->instantiations();
+        minimalSignature += "< ";
+        for (int i = 0; i < instantiations.size(); ++i) {
+            if (i > 0)
+                minimalSignature += ",";
+            minimalSignature += instantiations[i]->minimalSignature();
+        }
+        minimalSignature += " >";
+    }
+
+    for (int j = 0; j < indirections(); ++j)
+        minimalSignature += "*";
+    if (isReference())
+        minimalSignature += "&";
+
+    return minimalSignature;
+}
+
+bool AbstractMetaType::hasNativeId() const
+{
+    return (isQObject() || isValue() || isObject()) && typeEntry()->isNativeIdBased();
+}
+
+
+/*******************************************************************************
+ * Other stuff...
+ */
+
+
+AbstractMetaEnum *AbstractMetaClassList::findEnum(const EnumTypeEntry *entry) const
+{
+    Q_ASSERT(entry->isEnum());
+
+    QString qualifiedName = entry->qualifiedCppName();
+    int pos = qualifiedName.lastIndexOf("::");
+
+    QString enumName;
+    QString className;
+
+    if (pos > 0) {
+        enumName = qualifiedName.mid(pos + 2);
+        className = qualifiedName.mid(0, pos);
+    } else {
+        enumName = qualifiedName;
+        className = TypeDatabase::globalNamespaceClassName(entry);
+    }
+
+    AbstractMetaClass *metaClass = findClass(className);
+    if (!metaClass) {
+        ReportHandler::warning(QString("AbstractMeta::findEnum(), unknown class '%1' in '%2'")
+                               .arg(className).arg(entry->qualifiedCppName()));
+        return 0;
+    }
+
+    return metaClass->findEnum(enumName);
+}
+
+AbstractMetaEnumValue *AbstractMetaEnumValueList::find(const QString &name) const
+{
+    for (int i = 0; i < size(); ++i) {
+        if (name == at(i)->name())
+            return at(i);
+    }
+    return 0;
+}
+
+AbstractMetaEnumValue *AbstractMetaClassList::findEnumValue(const QString &name) const
+{
+    QStringList lst = name.split(QLatin1String("::"));
+
+    if (lst.size() > 1) {
+        QString prefixName = lst.at(0);
+        QString enumName = lst.at(1);
+
+        AbstractMetaClass* cl = findClass(prefixName);
+        if (cl)
+            return cl->findEnumValue(enumName, 0);
+    }
+
+    foreach(AbstractMetaClass* metaClass, *this) {
+        foreach(AbstractMetaEnum* metaEnum, metaClass->enums()) {
+            AbstractMetaEnumValue* enumValue = metaClass->findEnumValue(name, metaEnum);
+            if (enumValue)
+                return enumValue;
+        }
+    }
+
+    ReportHandler::warning(QString("no matching enum '%1'").arg(name));
+    return 0;
+}
+
+/*!
+ * Searches the list after a class that mathces \a name; either as
+ * C++, Target language base name or complete Target language package.class name.
+ */
+
+AbstractMetaClass *AbstractMetaClassList::findClass(const QString &name) const
+{
+    if (name.isEmpty())
+        return 0;
+
+    foreach (AbstractMetaClass *c, *this) {
+        if (c->qualifiedCppName() == name)
+            return c;
+    }
+
+    foreach (AbstractMetaClass *c, *this) {
+        if (c->fullName() == name)
+            return c;
+    }
+
+    foreach (AbstractMetaClass *c, *this) {
+        if (c->name() == name)
+            return c;
+    }
+
+    return 0;
+}
+
+AbstractMetaClass *AbstractMetaClassList::findClass(const TypeEntry* typeEntry) const
+{
+    foreach (AbstractMetaClass* c, *this) {
+        if (c->typeEntry() == typeEntry)
+            return c;
+    }
+    return 0;
+}
diff --git a/ApiExtractor/abstractmetalang.h b/ApiExtractor/abstractmetalang.h
new file mode 100644
index 000000000..2851d1c70
--- /dev/null
+++ b/ApiExtractor/abstractmetalang.h
@@ -0,0 +1,2071 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef ABSTRACTMETALANG_H
+#define ABSTRACTMETALANG_H
+
+#include "typesystem.h"
+
+#include <QtCore/QSet>
+#include <QtCore/QStringList>
+#include <QtCore/QTextStream>
+#include <QSharedPointer>
+
+
+class AbstractMeta;
+class AbstractMetaClass;
+class AbstractMetaField;
+class AbstractMetaFunction;
+class AbstractMetaType;
+class AbstractMetaVariable;
+class AbstractMetaArgument;
+class AbstractMetaEnumValue;
+class AbstractMetaEnum;
+class QPropertySpec;
+
+class APIEXTRACTOR_API Documentation
+{
+public:
+    enum Format {
+        Native,
+        Target
+    };
+
+    Documentation()
+            : m_format(Documentation::Native)  {}
+
+    Documentation(const QString& value, Format fmt = Documentation::Native)
+            : m_data(value), m_format(fmt) {}
+
+    QString value() const
+    {
+        return m_data;
+    }
+
+    void setValue(const QString& value, Format fmt = Documentation::Native)
+    {
+        m_data = value; m_format = fmt;
+    }
+
+    Documentation::Format format() const
+    {
+        return m_format;
+    }
+
+private:
+    QString m_data;
+    Format m_format;
+
+};
+
+typedef QList<AbstractMetaField *> AbstractMetaFieldList;
+typedef QList<AbstractMetaArgument *> AbstractMetaArgumentList;
+typedef QList<AbstractMetaFunction *> AbstractMetaFunctionList;
+class APIEXTRACTOR_API AbstractMetaClassList : public  QList<AbstractMetaClass *>
+{
+public:
+    AbstractMetaClass *findClass(const QString &name) const;
+    AbstractMetaClass *findClass(const TypeEntry* typeEntry) const;
+    AbstractMetaEnumValue *findEnumValue(const QString &string) const;
+    AbstractMetaEnum *findEnum(const EnumTypeEntry *entry) const;
+
+};
+
+class APIEXTRACTOR_API AbstractMetaAttributes
+{
+public:
+    AbstractMetaAttributes() : m_attributes(0), m_originalAttributes(0) {};
+
+    enum Attribute {
+        None                        = 0x00000000,
+
+        Private                     = 0x00000001,
+        Protected                   = 0x00000002,
+        Public                      = 0x00000004,
+        Friendly                    = 0x00000008,
+        Visibility                  = 0x0000000f,
+
+        Native                      = 0x00000010,
+        Abstract                    = 0x00000020,
+        Static                      = 0x00000040,
+
+        FinalInTargetLang           = 0x00000080,
+        FinalInCpp                  = 0x00000100,
+        ForceShellImplementation    = 0x00000200,
+
+        GetterFunction              = 0x00000400,
+        SetterFunction              = 0x00000800,
+
+        FinalOverload               = 0x00001000,
+        InterfaceFunction           = 0x00002000,
+
+        PropertyReader              = 0x00004000,
+        PropertyWriter              = 0x00008000,
+        PropertyResetter            = 0x00010000,
+
+        Fake                        = 0x00020000,
+
+        Invokable                   = 0x00040000,
+
+        Final                       = FinalInTargetLang | FinalInCpp
+    };
+
+    uint attributes() const
+    {
+        return m_attributes;
+    }
+
+    void setAttributes(uint attributes)
+    {
+        m_attributes = attributes;
+    }
+
+    uint originalAttributes() const
+    {
+        return m_originalAttributes;
+    }
+
+    void setOriginalAttributes(uint attributes)
+    {
+        m_originalAttributes = attributes;
+    }
+
+    uint visibility() const
+    {
+        return m_attributes & Visibility;
+    }
+
+    void setVisibility(uint visi)
+    {
+        m_attributes = (m_attributes & ~Visibility) | visi;
+    }
+
+    void operator+=(Attribute attribute)
+    {
+        m_attributes |= attribute;
+    }
+
+    void operator-=(Attribute attribute)
+    {
+        m_attributes &= ~attribute;
+    }
+
+    bool isNative() const
+    {
+        return m_attributes & Native;
+    }
+
+    bool isFinal() const
+    {
+        return (m_attributes & Final) == Final;
+    }
+
+    bool isFinalInTargetLang() const
+    {
+        return m_attributes & FinalInTargetLang;
+    }
+
+    bool isFinalInCpp() const
+    {
+        return m_attributes & FinalInCpp;
+    }
+
+    bool isAbstract() const
+    {
+        return m_attributes & Abstract;
+    }
+
+    bool isStatic() const
+    {
+        return m_attributes & Static;
+    }
+
+    bool isForcedShellImplementation() const
+    {
+        return m_attributes & ForceShellImplementation;
+    }
+
+    bool isInterfaceFunction() const
+    {
+        return m_attributes & InterfaceFunction;
+    }
+
+    bool isFinalOverload() const
+    {
+        return m_attributes & FinalOverload;
+    }
+
+    bool isInvokable() const
+    {
+        return m_attributes & Invokable;
+    }
+
+    bool isPropertyReader() const
+    {
+        return m_attributes & PropertyReader;
+    }
+
+    bool isPropertyWriter() const
+    {
+        return m_attributes & PropertyWriter;
+    }
+
+    bool isPropertyResetter() const
+    {
+        return m_attributes & PropertyResetter;
+    }
+
+    bool isPrivate() const
+    {
+        return m_attributes & Private;
+    }
+
+    bool isProtected() const
+    {
+        return m_attributes & Protected;
+    }
+
+    bool isPublic() const
+    {
+        return m_attributes & Public;
+    }
+
+    bool isFriendly() const
+    {
+        return m_attributes & Friendly;
+    }
+
+    bool wasPrivate() const
+    {
+        return m_originalAttributes & Private;
+    }
+
+    bool wasProtected() const
+    {
+        return m_originalAttributes & Protected;
+    }
+
+    bool wasPublic() const
+    {
+        return m_originalAttributes & Public;
+    }
+
+    bool wasFriendly() const
+    {
+        return m_originalAttributes & Friendly;
+    }
+
+    void setDocumentation(const Documentation& doc)
+    {
+        m_doc = doc;
+    }
+
+    Documentation documentation() const
+    {
+        return m_doc;
+    }
+
+private:
+    uint m_attributes;
+    uint m_originalAttributes;
+    Documentation m_doc;
+};
+
+typedef QList<AbstractMetaType*> AbstractMetaTypeList;
+class APIEXTRACTOR_API AbstractMetaType
+{
+public:
+
+    enum TypeUsagePattern {
+        InvalidPattern,
+        PrimitivePattern,
+        FlagsPattern,
+        EnumPattern,
+        ValuePattern,
+        StringPattern,
+        CharPattern,
+        ObjectPattern,
+        QObjectPattern,
+        ValuePointerPattern,
+        NativePointerPattern,
+        ContainerPattern,
+        VariantPattern,
+        VarargsPattern,
+        JObjectWrapperPattern,
+        ArrayPattern,
+        ThreadPattern
+    };
+
+    AbstractMetaType();
+    ~AbstractMetaType();
+
+    QString package() const
+    {
+        return m_typeEntry->targetLangPackage();
+    }
+    QString name() const
+    {
+        if (m_name.isNull())
+            m_name = m_typeEntry->targetLangName().split("::").last();
+        return m_name;
+    }
+    QString fullName() const
+    {
+        return m_typeEntry->qualifiedTargetLangName();
+    }
+
+    void setTypeUsagePattern(TypeUsagePattern pattern)
+    {
+        m_pattern = pattern;
+    }
+    TypeUsagePattern typeUsagePattern() const
+    {
+        return m_pattern;
+    }
+
+    // true when use pattern is container
+    bool hasInstantiations() const
+    {
+        return !m_instantiations.isEmpty();
+    }
+
+    void addInstantiation(AbstractMetaType* inst, bool owner = false)
+    {
+        if (owner)
+            m_children << inst;
+        m_instantiations << inst;
+    }
+
+    void setInstantiations(const AbstractMetaTypeList  &insts, bool owner = false)
+    {
+        m_instantiations = insts;
+        if (owner) {
+            m_children.clear();
+            m_children = insts;
+        }
+    }
+
+    AbstractMetaTypeList instantiations() const
+    {
+        return m_instantiations;
+    }
+
+    void setInstantiationInCpp(bool incpp)
+    {
+        m_cppInstantiation = incpp;
+    }
+    bool hasInstantiationInCpp() const
+    {
+        return hasInstantiations() && m_cppInstantiation;
+    }
+
+    QString minimalSignature() const;
+
+    // true when the type is a QtJambiObject subclass
+    bool hasNativeId() const;
+
+    // returns true if the typs is used as a non complex primitive, no & or *'s
+    bool isPrimitive() const
+    {
+        return m_pattern == PrimitivePattern;
+    }
+
+    // returns true if the type is used as an enum
+    bool isEnum() const
+    {
+        return m_pattern == EnumPattern;
+    }
+
+    // returns true if the type is used as a QObject *
+    bool isQObject() const
+    {
+        return m_pattern == QObjectPattern;
+    }
+
+    // returns true if the type is used as an object, e.g. Xxx *
+    bool isObject() const
+    {
+        return m_pattern == ObjectPattern;
+    }
+
+    // returns true if the type is used as an array, e.g. Xxx[42]
+    bool isArray() const
+    {
+        return m_pattern == ArrayPattern;
+    }
+
+    // returns true if the type is used as a value type (X or const X &)
+    bool isValue() const
+    {
+        return m_pattern == ValuePattern;
+    }
+
+    bool isValuePointer() const
+    {
+        return m_pattern == ValuePointerPattern;
+    }
+
+    // returns true for more complex types...
+    bool isNativePointer() const
+    {
+        return m_pattern == NativePointerPattern;
+    }
+
+    // returns true if the type was originally a QString or const QString & or equivalent for QLatin1String
+    bool isTargetLangString() const
+    {
+        return m_pattern == StringPattern;
+    }
+
+    // returns true if the type was originally a QChar or const QChar &
+    bool isTargetLangChar() const
+    {
+        return m_pattern == CharPattern;
+    }
+
+    // return true if the type was originally a QVariant or const QVariant &
+    bool isVariant() const
+    {
+        return m_pattern == VariantPattern;
+    }
+
+    // return true if the type was originally a varargs
+    bool isVarargs() const
+    {
+        return m_pattern == VarargsPattern;
+    }
+
+    // return true if the type was originally a JObjectWrapper or const JObjectWrapper &
+    bool isJObjectWrapper() const
+    {
+        return m_pattern == JObjectWrapperPattern;
+    }
+
+    // returns true if the type was used as a container
+    bool isContainer() const
+    {
+        return m_pattern == ContainerPattern;
+    }
+
+    // returns true if the type was used as a flag
+    bool isFlags() const
+    {
+        return m_pattern == FlagsPattern;
+    }
+
+    // returns true if the type was used as a thread
+    bool isThread() const
+    {
+        return m_pattern == ThreadPattern;
+    }
+
+    bool isConstant() const
+    {
+        return m_constant;
+    }
+    void setConstant(bool constant)
+    {
+        m_constant = constant;
+    }
+
+    bool isReference() const
+    {
+        return m_reference;
+    }
+    void setReference(bool ref)
+    {
+        m_reference = ref;
+    }
+
+    /**
+     *   Says if the type is to be implemented using target language
+     *   equivalent of C++ enums, i.e. not plain ints.
+     *   /return true if the type is to be implemented using target
+     *   language enums
+     */
+    bool isTargetLangEnum() const
+    {
+        return isEnum() && !((EnumTypeEntry *) typeEntry())->forceInteger();
+    }
+    bool isIntegerEnum() const
+    {
+        return isEnum() && !isTargetLangEnum();
+    }
+
+    /**
+     *   Says if the type is to be implemented using target language
+     *   equivalent of Qt's QFlags, i.e. not plain ints.
+     *   /return true if the type is to be implemented using target
+     *   language QFlags
+     */
+    bool isTargetLangFlags() const
+    {
+        return isFlags() && !((FlagsTypeEntry *) typeEntry())->forceInteger();
+    }
+    bool isIntegerFlags() const
+    {
+        return isFlags() && !isTargetLangFlags();
+    }
+
+    int actualIndirections() const
+    {
+        return m_indirections + (isReference() ? 1 : 0);
+    }
+    int indirections() const
+    {
+        return m_indirections;
+    }
+    void setIndirections(int indirections)
+    {
+        m_indirections = indirections;
+    }
+
+    void setArrayElementCount(int n)
+    {
+        m_arrayElementCount = n;
+    }
+    int arrayElementCount() const
+    {
+        return m_arrayElementCount;
+    }
+
+    const AbstractMetaType *arrayElementType() const
+    {
+        return m_arrayElementType;
+    }
+    void setArrayElementType(const AbstractMetaType *t)
+    {
+        m_arrayElementType = t;
+    }
+
+    QString cppSignature() const;
+
+    AbstractMetaType *copy() const;
+
+    const TypeEntry *typeEntry() const
+    {
+        return m_typeEntry;
+    }
+    void setTypeEntry(const TypeEntry *type)
+    {
+        m_typeEntry = type;
+    }
+
+    void setOriginalTypeDescription(const QString &otd)
+    {
+        m_originalTypeDescription = otd;
+    }
+    QString originalTypeDescription() const
+    {
+        return m_originalTypeDescription;
+    }
+
+    void setOriginalTemplateType(const AbstractMetaType *type)
+    {
+        m_originalTemplateType = type;
+    }
+    const AbstractMetaType *originalTemplateType() const
+    {
+        return m_originalTemplateType;
+    }
+
+    /// Decides and sets the proper usage patter for the current meta type.
+    void decideUsagePattern();
+
+private:
+    const TypeEntry *m_typeEntry;
+    AbstractMetaTypeList m_instantiations;
+    QString m_package;
+    mutable QString m_name;
+    mutable QString m_cachedCppSignature;
+    QString m_originalTypeDescription;
+
+    int m_arrayElementCount;
+    const AbstractMetaType *m_arrayElementType;
+    const AbstractMetaType *m_originalTemplateType;
+
+    TypeUsagePattern m_pattern;
+    uint m_constant : 1;
+    uint m_reference : 1;
+    uint m_cppInstantiation : 1;
+    int m_indirections : 4;
+    uint m_reserved : 25; // unused
+    AbstractMetaTypeList m_children;
+
+    Q_DISABLE_COPY(AbstractMetaType);
+};
+
+class APIEXTRACTOR_API AbstractMetaVariable
+{
+public:
+    AbstractMetaVariable() : m_type(0), m_hasName(false) {}
+    AbstractMetaVariable(const AbstractMetaVariable &other);
+
+    virtual ~AbstractMetaVariable()
+    {
+        delete m_type;
+    }
+
+    AbstractMetaType *type() const
+    {
+        return m_type;
+    }
+    void setType(AbstractMetaType *type)
+    {
+        Q_ASSERT(m_type == 0);
+        m_type = type;
+    }
+    void replaceType(AbstractMetaType *type)
+    {
+        if (m_type)
+            delete m_type;
+        m_type = type;
+    }
+
+    QString name() const
+    {
+        return m_name;
+    }
+    void setName(const QString &name, bool realName = true)
+    {
+        m_name = name;
+        m_hasName = realName;
+    }
+    bool hasName() const
+    {
+        return m_hasName;
+    }
+    QString originalName() const
+    {
+        return m_originalName;
+    }
+    void setOriginalName(const QString& name)
+    {
+        m_originalName = name;
+    }
+    void setDocumentation(const Documentation& doc)
+    {
+        m_doc = doc;
+    }
+    Documentation documentation() const
+    {
+        return m_doc;
+    }
+
+private:
+    QString m_originalName;
+    QString m_name;
+    AbstractMetaType *m_type;
+    bool m_hasName;
+
+    Documentation m_doc;
+};
+
+
+
+class APIEXTRACTOR_API AbstractMetaArgument : public AbstractMetaVariable
+{
+public:
+    AbstractMetaArgument() : m_argumentIndex(0) {};
+
+    QString defaultValueExpression() const
+    {
+        return m_expression;
+    }
+    void setDefaultValueExpression(const QString &expr)
+    {
+        m_expression = expr;
+    }
+
+    QString originalDefaultValueExpression() const
+    {
+        return m_originalExpression;
+    }
+    void setOriginalDefaultValueExpression(const QString &expr)
+    {
+        m_originalExpression = expr;
+    }
+
+    QString toString() const
+    {
+        return type()->name() + " " + AbstractMetaVariable::name() +
+               (m_expression.isEmpty() ? "" :  " = " + m_expression);
+    }
+
+    int argumentIndex() const
+    {
+        return m_argumentIndex;
+    }
+    void setArgumentIndex(int argIndex)
+    {
+        m_argumentIndex = argIndex;
+    }
+
+    AbstractMetaArgument *copy() const;
+private:
+    QString m_expression;
+    QString m_originalExpression;
+    int m_argumentIndex;
+
+    friend class AbstractMetaClass;
+};
+
+
+class APIEXTRACTOR_API AbstractMetaField : public AbstractMetaVariable, public AbstractMetaAttributes
+{
+public:
+    AbstractMetaField();
+    ~AbstractMetaField();
+
+    const AbstractMetaClass *enclosingClass() const
+    {
+        return m_class;
+    }
+    void setEnclosingClass(const AbstractMetaClass *cls)
+    {
+        m_class = cls;
+    }
+
+    const AbstractMetaFunction *getter() const;
+    const AbstractMetaFunction *setter() const;
+
+    FieldModificationList modifications() const;
+
+    bool isModifiedRemoved(int types = TypeSystem::All) const;
+
+    using AbstractMetaVariable::setDocumentation;
+    using AbstractMetaVariable::documentation;
+
+    AbstractMetaField *copy() const;
+
+private:
+    mutable AbstractMetaFunction *m_getter;
+    mutable AbstractMetaFunction *m_setter;
+    const AbstractMetaClass *m_class;
+};
+
+class APIEXTRACTOR_API AbstractMetaFunction : public AbstractMetaAttributes
+{
+public:
+    enum FunctionType {
+        ConstructorFunction,
+        DestructorFunction,
+        NormalFunction,
+        SignalFunction,
+        EmptyFunction,
+        SlotFunction,
+        GlobalScopeFunction
+    };
+
+    enum CompareResult {
+        EqualName                   = 0x00000001,
+        EqualArguments              = 0x00000002,
+        EqualAttributes             = 0x00000004,
+        EqualImplementor            = 0x00000008,
+        EqualReturnType             = 0x00000010,
+        EqualDefaultValueOverload   = 0x00000020,
+        EqualModifiedName           = 0x00000040,
+
+        NameLessThan                = 0x00001000,
+
+        PrettySimilar               = EqualName | EqualArguments,
+        Equal                       = 0x0000001f,
+        NotEqual                    = 0x00001000
+    };
+
+    AbstractMetaFunction()
+            : m_typeEntry(0),
+            m_functionType(NormalFunction),
+            m_type(0),
+            m_class(0),
+            m_implementingClass(0),
+            m_declaringClass(0),
+            m_interfaceClass(0),
+            m_propertySpec(0),
+            m_constant(false),
+            m_invalid(false),
+            m_reverse(false),
+            m_userAdded(false),
+            m_explicit(false),
+            m_pointerOperator(false),
+            m_isCallOperator(false)
+    {
+    }
+
+    ~AbstractMetaFunction();
+
+    QString name() const
+    {
+        return m_name;
+    }
+
+    void setName(const QString &name)
+    {
+        m_name = name;
+    }
+
+    QString originalName() const
+    {
+        return m_originalName.isEmpty() ? name() : m_originalName;
+    }
+
+    void setOriginalName(const QString &name)
+    {
+        m_originalName = name;
+    }
+
+    void setReverseOperator(bool reverse)
+    {
+        m_reverse = reverse;
+    }
+
+    bool isReverseOperator() const
+    {
+        return m_reverse;
+    }
+
+    /**
+     *  Returns true if this is a operator and the "self" operand is a pointer.
+     *  e.g. class Foo {}; operator+(SomeEnum, Foo*);
+     */
+    bool isPointerOperator() const
+    {
+        return m_pointerOperator;
+    }
+
+    void setPointerOperator(bool value)
+    {
+        m_pointerOperator = value;
+    }
+
+    void setExplicit(bool isExplicit)
+    {
+        m_explicit = isExplicit;
+    }
+    /**
+    *   Says if the function (a constructor) was declared as explicit in C++.
+    *   \return true if the function was declared as explicit in C++
+    */
+    bool isExplicit() const
+    {
+        return m_explicit;
+    }
+
+    static bool isConversionOperator(QString funcName);
+    bool isConversionOperator() const
+    {
+        return isConversionOperator(originalName());
+    }
+
+    static bool isOperatorOverload(QString funcName);
+    bool isOperatorOverload() const
+    {
+        return isOperatorOverload(originalName());
+    }
+    bool isCastOperator() const;
+
+    bool isArithmeticOperator() const;
+    bool isBitwiseOperator() const;
+    bool isComparisonOperator() const;
+    bool isLogicalOperator() const;
+    bool isSubscriptOperator() const;
+    bool isAssignmentOperator() const;
+    bool isOtherOperator() const;
+
+    /**
+     * Informs the arity of the operator or -1 if the function is not
+     * an operator overload.
+     * /return the arity of the operator or -1
+     */
+    int arityOfOperator() const;
+    bool isUnaryOperator() const { return arityOfOperator() == 1; }
+    bool isBinaryOperator() const { return arityOfOperator() == 2; }
+    bool isInplaceOperator() const;
+
+    // TODO: ths function *should* know if it is virtual
+    // instead of asking to your implementing class.
+    bool isVirtual() const;
+    bool isCopyConstructor() const;
+    bool isThread() const;
+    bool allowThread() const;
+    QString modifiedName() const;
+
+    QString minimalSignature() const;
+    QStringList possibleIntrospectionCompatibleSignatures() const;
+
+    QString marshalledName() const;
+
+    // true if one or more of the arguments are of QtJambiObject subclasses
+    bool argumentsHaveNativeId() const
+    {
+        foreach (const AbstractMetaArgument *arg, m_arguments) {
+            if (arg->type()->hasNativeId())
+                return true;
+        }
+
+        return false;
+    }
+
+    bool isModifiedRemoved(int types = TypeSystem::All) const;
+
+    AbstractMetaType *type() const
+    {
+        return m_type;
+    }
+    void setType(AbstractMetaType *type)
+    {
+        Q_ASSERT(m_type == 0);
+        m_type = type;
+    }
+
+    void replaceType(AbstractMetaType *type)
+    {
+        if (m_type)
+            delete m_type;
+        m_type = type;
+    }
+
+    // The class that has this function as a member.
+    const AbstractMetaClass *ownerClass() const
+    {
+        return m_class;
+    }
+    void setOwnerClass(const AbstractMetaClass *cls)
+    {
+        m_class = cls;
+    }
+
+    // The first class in a hierarchy that declares the function
+    const AbstractMetaClass *declaringClass() const
+    {
+        return m_declaringClass;
+    }
+    void setDeclaringClass(const AbstractMetaClass *cls)
+    {
+        m_declaringClass = cls;
+    }
+
+    // The class that actually implements this function
+    const AbstractMetaClass *implementingClass() const
+    {
+        return m_implementingClass;
+    }
+    void setImplementingClass(const AbstractMetaClass *cls)
+    {
+        m_implementingClass = cls;
+    }
+
+    bool needsCallThrough() const;
+
+    AbstractMetaArgumentList arguments() const
+    {
+        return m_arguments;
+    }
+    void setArguments(const AbstractMetaArgumentList &arguments)
+    {
+        m_arguments = arguments;
+    }
+    void addArgument(AbstractMetaArgument *argument)
+    {
+        m_arguments << argument;
+    }
+    int actualMinimumArgumentCount() const;
+
+    void setInvalid(bool on)
+    {
+        m_invalid = on;
+    }
+    bool isInvalid() const
+    {
+        return m_invalid;
+    }
+    bool isDeprecated() const;
+    bool isDestructor() const
+    {
+        return functionType() == DestructorFunction;
+    }
+    bool isConstructor() const
+    {
+        return functionType() == ConstructorFunction;
+    }
+    bool isNormal() const
+    {
+        return functionType() == NormalFunction || isSlot() || isInGlobalScope();
+    }
+    bool isInGlobalScope() const
+    {
+        return functionType() == GlobalScopeFunction;
+    }
+    bool isSignal() const
+    {
+        return functionType() == SignalFunction;
+    }
+    bool isSlot() const
+    {
+        return functionType() == SlotFunction;
+    }
+    bool isEmptyFunction() const
+    {
+        return functionType() == EmptyFunction;
+    }
+    FunctionType functionType() const
+    {
+        return m_functionType;
+    }
+    void setFunctionType(FunctionType type)
+    {
+        m_functionType = type;
+    }
+
+    QStringList introspectionCompatibleSignatures(const QStringList &resolvedArguments = QStringList()) const;
+    QString signature() const;
+    QString targetLangSignature(bool minimal = false) const;
+    bool shouldReturnThisObject() const
+    {
+        return QLatin1String("this") == argumentReplaced(0);
+    }
+    bool shouldIgnoreReturnValue() const
+    {
+        return QLatin1String("void") == argumentReplaced(0);
+    }
+
+    bool isConstant() const
+    {
+        return m_constant;
+    }
+    void setConstant(bool constant)
+    {
+        m_constant = constant;
+    }
+
+    /// Returns true if the AbstractMetaFunction was added by the user via the type system description.
+    bool isUserAdded() const
+    {
+        return m_userAdded;
+    }
+    void setUserAdded(bool userAdded)
+    {
+        m_userAdded = userAdded;
+    }
+
+    QString toString() const
+    {
+        return m_name;
+    }
+
+    uint compareTo(const AbstractMetaFunction *other) const;
+
+    bool operator <(const AbstractMetaFunction &a) const;
+
+    AbstractMetaFunction *copy() const;
+
+    QString replacedDefaultExpression(const AbstractMetaClass *cls, int idx) const;
+    bool removedDefaultExpression(const AbstractMetaClass *cls, int idx) const;
+    QString conversionRule(TypeSystem::Language language, int idx) const;
+    QList<ReferenceCount> referenceCounts(const AbstractMetaClass *cls, int idx = -2) const;
+    ArgumentOwner argumentOwner(const AbstractMetaClass *cls, int idx) const;
+
+    bool nullPointersDisabled(const AbstractMetaClass *cls = 0, int argument_idx = 0) const;
+    QString nullPointerDefaultValue(const AbstractMetaClass *cls = 0, int argument_idx = 0) const;
+
+    bool resetObjectAfterUse(int argument_idx) const;
+
+    // Returns whether garbage collection is disabled for the argument in any context
+    bool disabledGarbageCollection(const AbstractMetaClass *cls, int key) const;
+
+    // Returns the ownership rules for the given argument in the given context
+    TypeSystem::Ownership ownership(const AbstractMetaClass *cls, TypeSystem::Language language, int idx) const;
+
+    bool isVirtualSlot() const;
+
+    QString typeReplaced(int argument_index) const;
+    bool isRemovedFromAllLanguages(const AbstractMetaClass *) const;
+    bool isRemovedFrom(const AbstractMetaClass *, TypeSystem::Language language) const;
+    bool argumentRemoved(int) const;
+
+    QString argumentReplaced(int key) const;
+    bool needsSuppressUncheckedWarning() const;
+
+    bool hasModifications(const AbstractMetaClass *implementor) const;
+    /**
+    *   Verifies if any modification to the function is an inject code.
+    *   \return true if there is inject code modifications to the function.
+    */
+    bool hasInjectedCode() const;
+    /**
+    *   Returns a list of code snips for this function.
+    *   The code snips can be filtered by position and language.
+    *   \return list of code snips
+    */
+    CodeSnipList injectedCodeSnips(CodeSnip::Position position = CodeSnip::Any,
+                                   TypeSystem::Language language = TypeSystem::All) const;
+
+    /**
+    *   Verifies if any modification to the function alters/removes its
+    *   arguments types or default values.
+    *   \return true if there is some modification to function signature
+    */
+    bool hasSignatureModifications() const;
+    FunctionModificationList modifications(const AbstractMetaClass* implementor = 0) const;
+
+    /**
+     * Return the argument name if there is a modification the renamed value will be returned
+     */
+    QString argumentName(int index, bool create = true, const AbstractMetaClass *cl = 0) const;
+
+    // If this function stems from an interface, this returns the
+    // interface that declares it.
+    const AbstractMetaClass *interfaceClass() const
+    {
+        return m_interfaceClass;
+    }
+
+    void setInterfaceClass(const AbstractMetaClass *cl)
+    {
+        m_interfaceClass = cl;
+    }
+
+    void setPropertySpec(QPropertySpec *spec)
+    {
+        m_propertySpec = spec;
+    }
+
+    QPropertySpec *propertySpec() const
+    {
+        return m_propertySpec;
+    }
+
+    FunctionTypeEntry* typeEntry() const
+    {
+        return m_typeEntry;
+    }
+
+    void setTypeEntry(FunctionTypeEntry* typeEntry)
+    {
+        m_typeEntry = typeEntry;
+    }
+
+    bool isCallOperator() const;
+private:
+    QString m_name;
+    QString m_originalName;
+    mutable QString m_cachedMinimalSignature;
+    mutable QString m_cachedSignature;
+    mutable QString m_cachedModifiedName;
+
+    FunctionTypeEntry* m_typeEntry;
+    FunctionType m_functionType;
+    AbstractMetaType *m_type;
+    const AbstractMetaClass *m_class;
+    const AbstractMetaClass *m_implementingClass;
+    const AbstractMetaClass *m_declaringClass;
+    const AbstractMetaClass *m_interfaceClass;
+    QPropertySpec *m_propertySpec;
+    AbstractMetaArgumentList m_arguments;
+    uint m_constant                 : 1;
+    uint m_invalid                  : 1;
+    uint m_reverse                  : 1;
+    uint m_userAdded                : 1;
+    uint m_explicit                 : 1;
+    uint m_pointerOperator          : 1;
+    uint m_isCallOperator           : 1;
+};
+
+
+class AbstractMetaEnumValue
+{
+public:
+    AbstractMetaEnumValue()
+            : m_valueSet(false), m_value(0)
+    {
+    }
+
+    int value() const
+    {
+        return m_value;
+    }
+
+    void setValue(int value)
+    {
+        m_valueSet = true;
+        m_value = value;
+    }
+
+    QString stringValue() const
+    {
+        return m_stringValue;
+    }
+
+    void setStringValue(const QString &v)
+    {
+        m_stringValue = v;
+    }
+
+    QString name() const
+    {
+        return m_name;
+    }
+
+    void setName(const QString &name)
+    {
+        m_name = name;
+    }
+
+    bool isValueSet() const
+    {
+        return m_valueSet;
+    }
+
+    void setDocumentation(const Documentation& doc)
+    {
+        m_doc = doc;
+    }
+
+    Documentation documentation() const
+    {
+        return m_doc;
+    }
+
+private:
+    QString m_name;
+    QString m_stringValue;
+
+    bool m_valueSet;
+    int m_value;
+
+    Documentation m_doc;
+};
+
+
+class AbstractMetaEnumValueList : public QList<AbstractMetaEnumValue *>
+{
+public:
+    AbstractMetaEnumValue *find(const QString &name) const;
+};
+
+class AbstractMetaEnum : public AbstractMetaAttributes
+{
+public:
+    AbstractMetaEnum() : m_typeEntry(0), m_class(0), m_hasQenumsDeclaration(false) {}
+    ~AbstractMetaEnum()
+    {
+        qDeleteAll(m_enumValues);
+    }
+
+    AbstractMetaEnumValueList values() const
+    {
+        return m_enumValues;
+    }
+
+    void addEnumValue(AbstractMetaEnumValue *enumValue)
+    {
+        m_enumValues << enumValue;
+    }
+
+    QString name() const
+    {
+        return m_typeEntry->targetLangName();
+    }
+
+    QString qualifier() const
+    {
+        return m_typeEntry->targetLangQualifier();
+    }
+
+    QString package() const
+    {
+        return m_typeEntry->targetLangPackage();
+    }
+
+    QString fullName() const
+    {
+        return package() + "." + qualifier()  + "." + name();
+    }
+
+    // Has the enum been declared inside a Q_ENUMS() macro in its enclosing class?
+    void setHasQEnumsDeclaration(bool on)
+    {
+        m_hasQenumsDeclaration = on;
+    }
+
+    bool hasQEnumsDeclaration() const
+    {
+        return m_hasQenumsDeclaration;
+    }
+
+    EnumTypeEntry *typeEntry() const
+    {
+        return m_typeEntry;
+    }
+
+    void setTypeEntry(EnumTypeEntry *entry)
+    {
+        m_typeEntry = entry;
+    }
+
+    AbstractMetaClass *enclosingClass() const
+    {
+        return m_class;
+    }
+
+    void setEnclosingClass(AbstractMetaClass *c)
+    {
+        m_class = c;
+    }
+
+    bool isAnonymous() const
+    {
+        return m_typeEntry->isAnonymous();
+    }
+
+private:
+    AbstractMetaEnumValueList m_enumValues;
+    EnumTypeEntry *m_typeEntry;
+    AbstractMetaClass *m_class;
+
+    uint m_hasQenumsDeclaration : 1;
+    uint m_reserved : 31;
+};
+
+typedef QList<AbstractMetaEnum *> AbstractMetaEnumList;
+
+class APIEXTRACTOR_API AbstractMetaClass : public AbstractMetaAttributes
+{
+public:
+    enum FunctionQueryOption {
+        Constructors                 = 0x0000001, // Only constructors
+        //Destructors                  = 0x0000002, // Only destructors. Not included in class.
+        VirtualFunctions             = 0x0000004, // Only virtual functions (virtual in both TargetLang and C++)
+        FinalInTargetLangFunctions   = 0x0000008, // Only functions that are non-virtual in TargetLang
+        FinalInCppFunctions          = 0x0000010, // Only functions that are non-virtual in C++
+        ClassImplements              = 0x0000020, // Only functions implemented by the current class
+        Inconsistent                 = 0x0000040, // Only inconsistent functions (inconsistent virtualness in TargetLang/C++)
+        StaticFunctions              = 0x0000080, // Only static functions
+        Signals                      = 0x0000100, // Only signals
+        NormalFunctions              = 0x0000200, // Only functions that aren't signals
+        Visible                      = 0x0000400, // Only public and protected functions
+        ForcedShellFunctions         = 0x0000800, // Only functions that are overridden to be implemented in the shell class
+        WasPublic                    = 0x0001000, // Only functions that were originally public
+        WasProtected                 = 0x0002000, // Only functions that were originally protected
+        NonStaticFunctions           = 0x0004000, // No static functions
+        Empty                        = 0x0008000, // Empty overrides of abstract functions
+        Invisible                    = 0x0010000, // Only private functions
+        VirtualInCppFunctions        = 0x0020000, // Only functions that are virtual in C++
+        NonEmptyFunctions            = 0x0040000, // Only functions with target language API implementations
+        VirtualInTargetLangFunctions = 0x0080000, // Only functions which are virtual in TargetLang
+        AbstractFunctions            = 0x0100000, // Only abstract functions
+        WasVisible                   = 0x0200000, // Only functions that were public or protected in the original code
+        NotRemovedFromTargetLang     = 0x0400000, // Only functions that have not been removed from TargetLang
+        NotRemovedFromShell          = 0x0800000, // Only functions that have not been removed from the shell class
+        VirtualSlots                 = 0x1000000, // Only functions that are set as virtual slots in the type system
+        OperatorOverloads            = 0x2000000  // Only functions that are operator overloads
+    };
+
+    enum OperatorQueryOption {
+        ArithmeticOp   = 0x01, // Arithmetic: +, -, *, /, %, +=, -=, *=, /=, %=, ++, --, unary+, unary-
+        BitwiseOp      = 0x02, // Bitwise: <<, <<=, >>, >>=, ~, &, &=, |, |=, ^, ^=
+        ComparisonOp   = 0x04, // Comparison: <, <=, >, >=, !=, ==
+        LogicalOp      = 0x08, // Logical: !, &&, ||
+        ConversionOp   = 0x10, // Conversion: operator [const] TYPE()
+        SubscriptionOp = 0x20, // Subscription: []
+        AssignmentOp   = 0x40, // Assignment: =
+        OtherOp        = 0x80, // The remaining operators: call(), etc
+        AllOperators   = ArithmeticOp | BitwiseOp | ComparisonOp
+                        | LogicalOp | ConversionOp | SubscriptionOp
+                        | AssignmentOp | OtherOp
+    };
+
+    AbstractMetaClass()
+            : m_namespace(false),
+              m_qobject(false),
+              m_hasVirtuals(false),
+              m_isPolymorphic(false),
+              m_hasNonpublic(false),
+              m_hasVirtualSlots(false),
+              m_hasNonPrivateConstructor(false),
+              m_functionsFixed(false),
+              m_hasPrivateDestructor(false),
+              m_hasProtectedDestructor(false),
+              m_hasVirtualDestructor(false),
+              m_forceShellClass(false),
+              m_hasHashFunction(false),
+              m_hasEqualsOperator(false),
+              m_hasCloneOperator(false),
+              m_isTypeAlias(false),
+              m_hasToStringCapability(false),
+              m_enclosingClass(0),
+              m_baseClass(0),
+              m_templateBaseClass(0),
+              m_extractedInterface(0),
+              m_primaryInterfaceImplementor(0),
+              m_typeEntry(0),
+              m_stream(false)
+    {
+    }
+
+    virtual ~AbstractMetaClass();
+
+    AbstractMetaClass *extractInterface();
+    void fixFunctions();
+
+    AbstractMetaFunctionList functions() const
+    {
+        return m_functions;
+    }
+
+    void setFunctions(const AbstractMetaFunctionList &functions);
+    void addFunction(AbstractMetaFunction *function);
+    bool hasFunction(const AbstractMetaFunction *f) const;
+    bool hasFunction(const QString &str) const;
+    const AbstractMetaFunction* findFunction(const QString& functionName) const;
+    bool hasSignal(const AbstractMetaFunction *f) const;
+
+    bool hasConstructors() const;
+    bool hasCopyConstructor() const;
+    bool hasPrivateCopyConstructor() const;
+
+    void addDefaultConstructor();
+    void addDefaultCopyConstructor(bool isPrivate = false);
+
+    bool hasNonPrivateConstructor() const
+    {
+        return m_hasNonPrivateConstructor;
+    }
+
+    void setHasNonPrivateConstructor(bool value)
+    {
+        m_hasNonPrivateConstructor = value;
+    }
+
+    bool hasPrivateDestructor() const
+    {
+        return m_hasPrivateDestructor;
+    }
+
+    void setHasPrivateDestructor(bool value)
+    {
+        m_hasPrivateDestructor = value;
+    }
+
+    bool hasProtectedDestructor() const
+    {
+        return m_hasProtectedDestructor;
+    }
+
+    void setHasProtectedDestructor(bool value)
+    {
+        m_hasProtectedDestructor = value;
+    }
+
+    bool hasVirtualDestructor() const
+    {
+        return m_hasVirtualDestructor;
+    }
+
+    void setHasVirtualDestructor(bool value)
+    {
+        m_hasVirtualDestructor = value;
+    }
+
+    AbstractMetaFunctionList queryFunctionsByName(const QString &name) const;
+    AbstractMetaFunctionList queryFunctions(uint query) const;
+    inline AbstractMetaFunctionList allVirtualFunctions() const;
+    inline AbstractMetaFunctionList allFinalFunctions() const;
+    AbstractMetaFunctionList functionsInTargetLang() const;
+    AbstractMetaFunctionList functionsInShellClass() const;
+    inline AbstractMetaFunctionList cppInconsistentFunctions() const;
+    inline AbstractMetaFunctionList cppSignalFunctions() const;
+    AbstractMetaFunctionList publicOverrideFunctions() const;
+    AbstractMetaFunctionList virtualOverrideFunctions() const;
+    AbstractMetaFunctionList virtualFunctions() const;
+    AbstractMetaFunctionList nonVirtualShellFunctions() const;
+    AbstractMetaFunctionList implicitConversions() const;
+
+    /**
+     *   Retrieves all class' operator overloads that meet
+     *   query criteria defined with the OperatorQueryOption
+     *   enum.
+     *   /param query composition of OperatorQueryOption enum values
+     *   /return list of operator overload methods that meet the
+     *   query criteria
+     */
+    AbstractMetaFunctionList operatorOverloads(uint query = AllOperators) const;
+
+    bool hasOperatorOverload() const;
+    bool hasArithmeticOperatorOverload() const;
+    bool hasBitwiseOperatorOverload() const;
+    bool hasComparisonOperatorOverload() const;
+    bool hasLogicalOperatorOverload() const;
+    bool hasSubscriptOperatorOverload() const;
+    bool hasAssignmentOperatorOverload() const;
+    bool hasConversionOperatorOverload() const;
+
+    AbstractMetaFieldList fields() const
+    {
+        return m_fields;
+    }
+
+    void setFields(const AbstractMetaFieldList &fields)
+    {
+        m_fields = fields;
+    }
+
+    void addField(AbstractMetaField *field)
+    {
+        m_fields << field;
+    }
+
+    AbstractMetaEnumList enums() const
+    {
+        return m_enums;
+    }
+    void setEnums(const AbstractMetaEnumList &enums)
+    {
+        m_enums = enums;
+    }
+
+    void addEnum(AbstractMetaEnum *e)
+    {
+        m_enums << e;
+    }
+
+    AbstractMetaEnum *findEnum(const QString &enumName);
+    AbstractMetaEnum *findEnumForValue(const QString &enumName);
+    AbstractMetaEnumValue *findEnumValue(const QString &enumName, AbstractMetaEnum *meta_enum);
+
+    AbstractMetaClassList interfaces() const
+    {
+        return m_interfaces;
+    }
+    void addInterface(AbstractMetaClass *interface);
+    void setInterfaces(const AbstractMetaClassList &interface);
+
+    QString fullName() const
+    {
+        return package() + "." + name();
+    }
+
+    /**
+     *   Retrieves the class name without any namespace/scope information.
+     *   /return the class name without scope information
+     */
+    QString name() const;
+
+    QString baseClassName() const
+    {
+        return m_baseClass ? m_baseClass->name() : QString();
+    }
+
+    AbstractMetaClass *baseClass() const
+    {
+        return m_baseClass;
+    }
+
+    void setBaseClass(AbstractMetaClass *base_class);
+
+    const AbstractMetaClass *enclosingClass() const
+    {
+        return m_enclosingClass;
+    }
+
+    void setEnclosingClass(AbstractMetaClass *cl)
+    {
+        m_enclosingClass = cl;
+    }
+
+    const AbstractMetaClassList& innerClasses() const
+    {
+        return m_innerClasses;
+    }
+
+    void addInnerClass(AbstractMetaClass* cl)
+    {
+        m_innerClasses << cl;
+    }
+
+    void setInnerClasses(AbstractMetaClassList innerClasses)
+    {
+        m_innerClasses = innerClasses;
+    }
+
+    QString package() const
+    {
+        return m_typeEntry->targetLangPackage();
+    }
+
+    bool isInterface() const
+    {
+        return m_typeEntry->isInterface();
+    }
+
+    bool isNamespace() const
+    {
+        return m_typeEntry->isNamespace();
+    }
+
+    bool isQObject() const
+    {
+        return m_typeEntry->isQObject();
+    }
+
+    bool isQtNamespace() const
+    {
+        return isNamespace() && name() == "Qt";
+    }
+
+    QString qualifiedCppName() const
+    {
+        return m_typeEntry->qualifiedCppName();
+    }
+
+    bool hasInconsistentFunctions() const;
+    bool hasSignals() const;
+    bool inheritsFrom(const AbstractMetaClass *other) const;
+
+    void setForceShellClass(bool on)
+    {
+        m_forceShellClass = on;
+    }
+
+    bool generateShellClass() const;
+
+    bool hasVirtualSlots() const
+    {
+        return m_hasVirtualSlots;
+    }
+
+    /**
+    *   Says if a class has any virtual functions of its own.
+    *   \return true if the class implements any virtual methods
+    */
+    bool hasVirtualFunctions() const
+    {
+        return !isFinal() && m_hasVirtuals;
+    }
+    /**
+    *   Says if the class that declares or inherits a virtual function.
+    *   \return true if the class implements or inherits any virtual methods
+    */
+    bool isPolymorphic() const
+    {
+        return m_isPolymorphic;
+    }
+
+    /**
+     * Tells if this class has one or more functions that are protected.
+     * \return true if the class has protected functions.
+     */
+    bool hasProtectedFunctions() const;
+
+    /**
+     * Tells if this class has one or more fields (member variables) that are protected.
+     * \return true if the class has protected fields.
+     */
+    bool hasProtectedFields() const;
+
+    /**
+     * Tells if this class has one or more members (functions or fields) that are protected.
+     * \return true if the class has protected members.
+     */
+    bool hasProtectedMembers() const;
+
+
+    QList<TypeEntry *> templateArguments() const
+    {
+        return m_templateArgs;
+    }
+
+    void setTemplateArguments(const QList<TypeEntry *> &args)
+    {
+        m_templateArgs = args;
+    }
+
+    bool hasFieldAccessors() const;
+
+    // only valid during metabuilder's run
+    QStringList baseClassNames() const
+    {
+        return m_baseClassNames;
+    }
+
+    void setBaseClassNames(const QStringList &names)
+    {
+        m_baseClassNames = names;
+    }
+
+    AbstractMetaClass *primaryInterfaceImplementor() const
+    {
+        return m_primaryInterfaceImplementor;
+    }
+
+    void setPrimaryInterfaceImplementor(AbstractMetaClass *cl)
+    {
+        m_primaryInterfaceImplementor = cl;
+    }
+
+    const ComplexTypeEntry *typeEntry() const
+    {
+        return m_typeEntry;
+    }
+
+    ComplexTypeEntry *typeEntry()
+    {
+        return m_typeEntry;
+    }
+
+    void setTypeEntry(ComplexTypeEntry *type)
+    {
+        m_typeEntry = type;
+    }
+
+    void setHasHashFunction(bool on)
+    {
+        m_hasHashFunction = on;
+    }
+
+    bool hasHashFunction() const
+    {
+        return m_hasHashFunction;
+    }
+    virtual bool hasDefaultToStringFunction() const;
+
+    void setHasEqualsOperator(bool on)
+    {
+        m_hasEqualsOperator = on;
+    }
+
+    bool hasEqualsOperator() const
+    {
+        return m_hasEqualsOperator;
+    }
+
+    void setHasCloneOperator(bool on)
+    {
+        m_hasCloneOperator = on;
+    }
+
+    bool hasCloneOperator() const
+    {
+        return m_hasCloneOperator;
+    }
+
+    void addPropertySpec(QPropertySpec *spec)
+    {
+        m_propertySpecs << spec;
+    }
+
+    QList<QPropertySpec *> propertySpecs() const
+    {
+        return m_propertySpecs;
+    }
+
+    QPropertySpec *propertySpecForRead(const QString &name) const;
+    QPropertySpec *propertySpecForWrite(const QString &name) const;
+    QPropertySpec *propertySpecForReset(const QString &name) const;
+
+    QList<ReferenceCount> referenceCounts() const;
+
+    void setEqualsFunctions(const AbstractMetaFunctionList &lst)
+    {
+        m_equalsFunctions = lst;
+    }
+
+    AbstractMetaFunctionList equalsFunctions() const
+    {
+        return m_equalsFunctions;
+    }
+
+    void setNotEqualsFunctions(const AbstractMetaFunctionList &lst)
+    {
+        m_nequalsFunctions = lst;
+    }
+
+    AbstractMetaFunctionList notEqualsFunctions() const
+    {
+        return m_nequalsFunctions;
+    }
+
+    void setLessThanFunctions(const AbstractMetaFunctionList &lst)
+    {
+        m_lessThanFunctions = lst;
+    }
+
+    AbstractMetaFunctionList lessThanFunctions() const
+    {
+        return m_lessThanFunctions;
+    }
+
+    void setGreaterThanFunctions(const AbstractMetaFunctionList &lst)
+    {
+        m_greaterThanFunctions = lst;
+    }
+
+    AbstractMetaFunctionList greaterThanFunctions() const
+    {
+        return m_greaterThanFunctions;
+    }
+
+    void setLessThanEqFunctions(const AbstractMetaFunctionList &lst)
+    {
+        m_lessThanEqFunctions = lst;
+    }
+
+    AbstractMetaFunctionList lessThanEqFunctions() const
+    {
+        return m_lessThanEqFunctions;
+    }
+
+    void setGreaterThanEqFunctions(const AbstractMetaFunctionList &lst)
+    {
+        m_greaterThanEqFunctions = lst;
+    }
+
+    AbstractMetaFunctionList greaterThanEqFunctions() const
+    {
+        return m_greaterThanEqFunctions;
+    }
+
+    /// Returns a list of conversion operators for this class. The conversion operators are defined in other classes of the same module.
+    AbstractMetaFunctionList externalConversionOperators() const
+    {
+        return m_externalConversionOperators;
+    }
+    /// Adds a converter operator for this class.
+    void addExternalConversionOperator(AbstractMetaFunction* conversionOp)
+    {
+        if (!m_externalConversionOperators.contains(conversionOp))
+            m_externalConversionOperators.append(conversionOp);
+    }
+    /// Returns true if this class has any converter operators defined elsewhere.
+    bool hasExternalConversionOperators() const
+    {
+        return !m_externalConversionOperators.isEmpty();
+    }
+
+    void sortFunctions();
+
+    const AbstractMetaClass *templateBaseClass() const
+    {
+        return m_templateBaseClass;
+    }
+
+    void setTemplateBaseClass(const AbstractMetaClass *cls)
+    {
+        m_templateBaseClass = cls;
+    }
+
+    bool hasTemplateBaseClassInstantiations() const;
+    AbstractMetaTypeList templateBaseClassInstantiations() const;
+    void setTemplateBaseClassInstantiations(AbstractMetaTypeList& instantiations);
+
+    void setTypeAlias(bool typeAlias)
+    {
+        m_isTypeAlias = typeAlias;
+    }
+
+    bool isTypeAlias() const
+    {
+        return m_isTypeAlias;
+    }
+
+    void setStream(bool stream)
+    {
+        m_stream = stream;
+    }
+
+    bool isStream() const
+    {
+        return m_stream;
+    }
+
+    void setToStringCapability(bool value)
+    {
+        m_hasToStringCapability = value;
+    }
+
+    bool hasToStringCapability() const
+    {
+        return m_hasToStringCapability;
+    }
+private:
+    uint m_namespace : 1;
+    uint m_qobject : 1;
+    uint m_hasVirtuals : 1;
+    uint m_isPolymorphic : 1;
+    uint m_hasNonpublic : 1;
+    uint m_hasVirtualSlots : 1;
+    uint m_hasNonPrivateConstructor : 1;
+    uint m_functionsFixed : 1;
+    uint m_hasPrivateDestructor : 1;
+    uint m_hasProtectedDestructor : 1;
+    uint m_hasVirtualDestructor : 1;
+    uint m_forceShellClass : 1;
+    uint m_hasHashFunction : 1;
+    uint m_hasEqualsOperator : 1;
+    uint m_hasCloneOperator : 1;
+    uint m_isTypeAlias : 1;
+    uint m_hasToStringCapability : 1;
+    uint m_reserved : 17;
+
+    const AbstractMetaClass *m_enclosingClass;
+    AbstractMetaClass *m_baseClass;
+    const AbstractMetaClass *m_templateBaseClass;
+    AbstractMetaFunctionList m_functions;
+    AbstractMetaFieldList m_fields;
+    AbstractMetaEnumList m_enums;
+    AbstractMetaClassList m_interfaces;
+    AbstractMetaClassList m_orphanInterfaces;
+    AbstractMetaClass *m_extractedInterface;
+    AbstractMetaClass *m_primaryInterfaceImplementor;
+    QList<QPropertySpec *> m_propertySpecs;
+    AbstractMetaFunctionList m_equalsFunctions;
+    AbstractMetaFunctionList m_nequalsFunctions;
+    AbstractMetaClassList m_innerClasses;
+
+    AbstractMetaFunctionList m_lessThanFunctions;
+    AbstractMetaFunctionList m_greaterThanFunctions;
+    AbstractMetaFunctionList m_lessThanEqFunctions;
+    AbstractMetaFunctionList m_greaterThanEqFunctions;
+
+    AbstractMetaFunctionList m_externalConversionOperators;
+
+    QStringList m_baseClassNames;
+    QList<TypeEntry *> m_templateArgs;
+    ComplexTypeEntry *m_typeEntry;
+//     FunctionModelItem m_qDebugStreamFunction;
+
+    bool m_stream;
+    static int m_count;
+};
+
+class QPropertySpec
+{
+public:
+    QPropertySpec(const TypeEntry *type)
+            : m_type(type),
+            m_index(-1)
+    {}
+
+    const TypeEntry *type() const
+    {
+        return m_type;
+    }
+
+    QString name() const
+    {
+        return m_name;
+    }
+
+    void setName(const QString &name)
+    {
+        m_name = name;
+    }
+
+    QString read() const
+    {
+        return m_read;
+    }
+
+    void setRead(const QString &read)
+    {
+        m_read = read;
+    }
+
+    QString write() const
+    {
+        return m_write;
+    }
+
+    void setWrite(const QString &write)
+    {
+        m_write = write;
+    }
+
+    QString designable() const
+    {
+        return m_designable;
+    }
+
+    void setDesignable(const QString &designable)
+    {
+        m_designable = designable;
+    }
+
+    QString reset() const
+    {
+        return m_reset;
+    }
+
+    void setReset(const QString &reset)
+    {
+        m_reset = reset;
+    }
+
+    int index() const
+    {
+        return m_index;
+    }
+
+    void setIndex(int index)
+    {
+        m_index = index;
+    }
+
+private:
+    QString m_name;
+    QString m_read;
+    QString m_write;
+    QString m_designable;
+    QString m_reset;
+    const TypeEntry *m_type;
+    int m_index;
+};
+
+inline AbstractMetaFunctionList AbstractMetaClass::allVirtualFunctions() const
+{
+    return queryFunctions(VirtualFunctions | NotRemovedFromTargetLang);
+}
+
+inline AbstractMetaFunctionList AbstractMetaClass::allFinalFunctions() const
+{
+    return queryFunctions(FinalInTargetLangFunctions
+                          | FinalInCppFunctions
+                          | NotRemovedFromTargetLang);
+}
+
+inline AbstractMetaFunctionList AbstractMetaClass::cppInconsistentFunctions() const
+{
+    return queryFunctions(Inconsistent
+                          | NormalFunctions
+                          | Visible
+                          | NotRemovedFromTargetLang);
+}
+
+inline AbstractMetaFunctionList AbstractMetaClass::cppSignalFunctions() const
+{
+    return queryFunctions(Signals
+                          | Visible
+                          | NotRemovedFromTargetLang);
+}
+
+#endif // ABSTRACTMETALANG_H
diff --git a/ApiExtractor/apiextractor.cpp b/ApiExtractor/apiextractor.cpp
new file mode 100644
index 000000000..c26e6f690
--- /dev/null
+++ b/ApiExtractor/apiextractor.cpp
@@ -0,0 +1,303 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "apiextractor.h"
+#include <QDir>
+#include <QDebug>
+#include <QTemporaryFile>
+#include <iostream>
+
+#include "reporthandler.h"
+#include "typesystem.h"
+#include "fileout.h"
+#include "parser/rpp/pp.h"
+#include "abstractmetabuilder.h"
+#include "apiextractorversion.h"
+#include "typedatabase.h"
+
+static bool preprocess(const QString& sourceFile,
+                       QFile& targetFile,
+                       const QStringList& includes);
+
+ApiExtractor::ApiExtractor() : m_builder(0)
+{
+    // Environment TYPESYSTEMPATH
+    QString envTypesystemPaths = getenv("TYPESYSTEMPATH");
+    if (!envTypesystemPaths.isEmpty())
+        TypeDatabase::instance()->addTypesystemPath(envTypesystemPaths);
+    ReportHandler::setContext("ApiExtractor");
+}
+
+ApiExtractor::~ApiExtractor()
+{
+    delete m_builder;
+}
+
+void ApiExtractor::addTypesystemSearchPath (const QString& path)
+{
+    TypeDatabase::instance()->addTypesystemPath(path);
+}
+
+void ApiExtractor::addTypesystemSearchPath(const QStringList& paths)
+{
+    foreach (QString path, paths)
+        addTypesystemSearchPath(path);
+}
+
+void ApiExtractor::addIncludePath(const QString& path)
+{
+    m_includePaths << path;
+}
+
+void ApiExtractor::addIncludePath(const QStringList& paths)
+{
+    m_includePaths << paths;
+}
+
+void ApiExtractor::setLogDirectory(const QString& logDir)
+{
+    m_logDirectory = logDir;
+}
+
+void ApiExtractor::setCppFileName(const QString& cppFileName)
+{
+    m_cppFileName = cppFileName;
+}
+
+void ApiExtractor::setTypeSystem(const QString& typeSystemFileName)
+{
+    m_typeSystemFileName = typeSystemFileName;
+}
+
+void ApiExtractor::setDebugLevel(ReportHandler::DebugLevel debugLevel)
+{
+    ReportHandler::setDebugLevel(debugLevel);
+}
+
+void ApiExtractor::setSuppressWarnings ( bool value )
+{
+    TypeDatabase::instance()->setSuppressWarnings(value);
+}
+
+void ApiExtractor::setSilent ( bool value )
+{
+    ReportHandler::setSilent(value);
+}
+
+void ApiExtractor::setApiVersion(double version)
+{
+    TypeDatabase::instance()->setApiVersion("*", QByteArray::number(version));
+}
+
+void ApiExtractor::setApiVersion(const QString& package, const QByteArray& version)
+{
+    TypeDatabase::instance()->setApiVersion(package, version);
+}
+
+void ApiExtractor::setDropTypeEntries(QString dropEntries)
+{
+    dropEntries.remove(' ');
+    QStringList entries = dropEntries.split(';');
+    TypeDatabase::instance()->setDropTypeEntries(entries);
+}
+
+AbstractMetaEnumList ApiExtractor::globalEnums() const
+{
+    Q_ASSERT(m_builder);
+    return m_builder->globalEnums();
+}
+
+AbstractMetaFunctionList ApiExtractor::globalFunctions() const
+{
+    Q_ASSERT(m_builder);
+    return m_builder->globalFunctions();
+}
+
+AbstractMetaClassList ApiExtractor::classes() const
+{
+    Q_ASSERT(m_builder);
+    return m_builder->classes();
+}
+
+PrimitiveTypeEntryList ApiExtractor::primitiveTypes() const
+{
+    return TypeDatabase::instance()->primitiveTypes();
+}
+
+ContainerTypeEntryList ApiExtractor::containerTypes() const
+{
+    return TypeDatabase::instance()->containerTypes();
+}
+
+QSet<QString> ApiExtractor::qtMetaTypeDeclaredTypeNames() const
+{
+    Q_ASSERT(m_builder);
+    return m_builder->qtMetaTypeDeclaredTypeNames();
+}
+
+static const AbstractMetaEnum* findEnumOnClasses(AbstractMetaClassList metaClasses, const EnumTypeEntry* typeEntry)
+{
+    const AbstractMetaEnum* result = 0;
+    foreach (const AbstractMetaClass* metaClass, metaClasses) {
+        foreach (const AbstractMetaEnum* metaEnum, metaClass->enums()) {
+            if (metaEnum->typeEntry() == typeEntry) {
+                result = metaEnum;
+                break;
+            }
+        }
+        if (result)
+            break;
+        result = findEnumOnClasses(metaClass->innerClasses(), typeEntry);
+    }
+    return result;
+}
+
+const AbstractMetaEnum* ApiExtractor::findAbstractMetaEnum(const EnumTypeEntry* typeEntry) const
+{
+    if (!typeEntry)
+        return 0;
+    foreach (AbstractMetaEnum* metaEnum, m_builder->globalEnums()) {
+        if (metaEnum->typeEntry() == typeEntry)
+            return metaEnum;
+    }
+    return findEnumOnClasses(m_builder->classes(), typeEntry);
+}
+
+const AbstractMetaEnum* ApiExtractor::findAbstractMetaEnum(const TypeEntry* typeEntry) const
+{
+    if (!typeEntry)
+        return 0;
+    if (typeEntry->isFlags())
+        return findAbstractMetaEnum(reinterpret_cast<const FlagsTypeEntry*>(typeEntry));
+    if (typeEntry->isEnum())
+        return findAbstractMetaEnum(reinterpret_cast<const EnumTypeEntry*>(typeEntry));
+    return 0;
+}
+
+const AbstractMetaEnum* ApiExtractor::findAbstractMetaEnum(const FlagsTypeEntry* typeEntry) const
+{
+    if (!typeEntry)
+        return 0;
+    return findAbstractMetaEnum(typeEntry->originator());
+}
+
+const AbstractMetaEnum* ApiExtractor::findAbstractMetaEnum(const AbstractMetaType* metaType) const
+{
+    if (!metaType)
+        return 0;
+    return findAbstractMetaEnum(metaType->typeEntry());
+}
+
+int ApiExtractor::classCount() const
+{
+    Q_ASSERT(m_builder);
+    return m_builder->classes().count();
+}
+
+bool ApiExtractor::run()
+{
+    if (m_builder)
+        return false;
+
+    if (m_typeSystemFileName.isEmpty()) {
+        std::cerr << "You must specify a Type System file." << std::endl;
+        return false;
+    } else if (!TypeDatabase::instance()->parseFile(m_typeSystemFileName)) {
+        std::cerr << "Cannot parse file: " << qPrintable(m_typeSystemFileName);
+        return false;
+    }
+
+    QTemporaryFile ppFile;
+#ifndef NDEBUG
+    ppFile.setAutoRemove(false);
+#endif
+    // run rpp pre-processor
+    if (!preprocess(m_cppFileName, ppFile, m_includePaths)) {
+        std::cerr << "Preprocessor failed on file: " << qPrintable(m_cppFileName);
+        return false;
+    }
+    ppFile.seek(0);
+    m_builder = new AbstractMetaBuilder;
+    m_builder->setLogDirectory(m_logDirectory);
+    m_builder->setGlobalHeader(m_cppFileName);
+    m_builder->build(&ppFile);
+
+    return true;
+}
+
+static bool preprocess(const QString& sourceFile,
+                       QFile& targetFile,
+                       const QStringList& includes)
+{
+    rpp::pp_environment env;
+    rpp::pp preprocess(env);
+
+    rpp::pp_null_output_iterator null_out;
+
+    const char *ppconfig = ":/trolltech/generator/pp-qt-configuration";
+
+    QFile file(ppconfig);
+    if (!file.open(QFile::ReadOnly)) {
+        std::cerr << "Preprocessor configuration file not found " << ppconfig << std::endl;
+        return false;
+    }
+
+    QByteArray ba = file.readAll();
+    file.close();
+    preprocess.operator()(ba.constData(), ba.constData() + ba.size(), null_out);
+
+    preprocess.push_include_path(".");
+    foreach (QString include, includes)
+        preprocess.push_include_path(QDir::convertSeparators(include).toStdString());
+    preprocess.push_include_path("/usr/include");
+
+    QString currentDir = QDir::current().absolutePath();
+    QFileInfo sourceInfo(sourceFile);
+    if (!sourceInfo.exists()) {
+        std::cerr << "File not found " << qPrintable(sourceFile) << std::endl;
+        return false;
+    }
+    QDir::setCurrent(sourceInfo.absolutePath());
+
+    std::string result;
+    result.reserve(20 * 1024);  // 20K
+
+    result += "# 1 \"builtins\"\n";
+    result += "# 1 \"";
+    result += sourceFile.toStdString();
+    result += "\"\n";
+
+    preprocess.file(sourceInfo.fileName().toStdString(),
+                    rpp::pp_output_iterator<std::string> (result));
+
+    QDir::setCurrent(currentDir);
+
+    if (!targetFile.open(QIODevice::ReadWrite | QIODevice::Text)) {
+        std::cerr << "Failed to write preprocessed file: " << qPrintable(targetFile.fileName()) << std::endl;
+        return false;
+    }
+
+    targetFile.write(result.c_str(), result.length());
+    return true;
+}
+
diff --git a/ApiExtractor/apiextractor.h b/ApiExtractor/apiextractor.h
new file mode 100644
index 000000000..0a71f1a22
--- /dev/null
+++ b/ApiExtractor/apiextractor.h
@@ -0,0 +1,82 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef APIEXTRACTOR_H
+#define APIEXTRACTOR_H
+
+#include "reporthandler.h"
+#include "abstractmetalang.h"
+#include "apiextractormacros.h"
+#include <QStringList>
+
+class AbstractMetaBuilder;
+class QIODevice;
+
+class APIEXTRACTOR_API ApiExtractor
+{
+public:
+    ApiExtractor();
+    ~ApiExtractor();
+
+    void setTypeSystem(const QString& typeSystemFileName);
+    void setCppFileName(const QString& cppFileName);
+    void setDebugLevel(ReportHandler::DebugLevel debugLevel);
+    void setSuppressWarnings(bool value);
+    void setSilent(bool value);
+    void addTypesystemSearchPath(const QString& path);
+    void addTypesystemSearchPath(const QStringList& paths);
+    void addIncludePath(const QString& path);
+    void addIncludePath(const QStringList& paths);
+    void setLogDirectory(const QString& logDir);
+    APIEXTRACTOR_DEPRECATED(void setApiVersion(double version));
+    void setApiVersion(const QString& package, const QByteArray& version);
+    void setDropTypeEntries(QString dropEntries);
+
+    AbstractMetaEnumList globalEnums() const;
+    AbstractMetaFunctionList globalFunctions() const;
+    AbstractMetaClassList classes() const;
+    PrimitiveTypeEntryList primitiveTypes() const;
+    ContainerTypeEntryList containerTypes() const;
+    QSet<QString> qtMetaTypeDeclaredTypeNames() const;
+
+    const AbstractMetaEnum* findAbstractMetaEnum(const EnumTypeEntry* typeEntry) const;
+    const AbstractMetaEnum* findAbstractMetaEnum(const TypeEntry* typeEntry) const;
+    const AbstractMetaEnum* findAbstractMetaEnum(const FlagsTypeEntry* typeEntry) const;
+    const AbstractMetaEnum* findAbstractMetaEnum(const AbstractMetaType* metaType) const;
+
+    int classCount() const;
+
+    bool run();
+private:
+    QString m_typeSystemFileName;
+    QString m_cppFileName;
+    QStringList m_includePaths;
+    AbstractMetaBuilder* m_builder;
+    QString m_logDirectory;
+
+    // disable copy
+    ApiExtractor(const ApiExtractor&);
+    ApiExtractor& operator=(const ApiExtractor&);
+};
+
+#endif // APIEXTRACTOR_H
diff --git a/ApiExtractor/apiextractormacros.h b/ApiExtractor/apiextractormacros.h
new file mode 100644
index 000000000..3364acf14
--- /dev/null
+++ b/ApiExtractor/apiextractormacros.h
@@ -0,0 +1,23 @@
+#ifndef APIEXTRACTORMACROS_H
+#define APIEXTRACTORMACROS_H
+
+
+// APIEXTRACTOR_API is used for the public API symbols.
+#if defined _WIN32
+    #if APIEXTRACTOR_EXPORTS
+        #define APIEXTRACTOR_API __declspec(dllexport)
+    #else
+        #define APIEXTRACTOR_API
+    #endif
+    #define APIEXTRACTOR_DEPRECATED(func) __declspec(deprecated) func
+#elif __GNUC__ >= 4
+    #define APIEXTRACTOR_API __attribute__ ((visibility("default")))
+    #define APIEXTRACTOR_DEPRECATED(func) func __attribute__ ((deprecated))
+#endif
+
+#ifndef APIEXTRACTOR_API
+    #define APIEXTRACTOR_API
+    #define APIEXTRACTOR_DEPRECATED(func) func
+#endif
+
+#endif
diff --git a/ApiExtractor/apiextractorversion.h.in b/ApiExtractor/apiextractorversion.h.in
new file mode 100644
index 000000000..45ce51e83
--- /dev/null
+++ b/ApiExtractor/apiextractorversion.h.in
@@ -0,0 +1,4 @@
+#ifndef APIEXTRACTORVERSION_H
+#define APIEXTRACTORVERSION_H
+#define APIEXTRACTOR_VERSION "@apiextractor_VERSION@"
+#endif
diff --git a/ApiExtractor/asttoxml.cpp b/ApiExtractor/asttoxml.cpp
new file mode 100644
index 000000000..e884835c0
--- /dev/null
+++ b/ApiExtractor/asttoxml.cpp
@@ -0,0 +1,151 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "asttoxml.h"
+#include "parser/control.h"
+#include "parser/parser.h"
+#include "parser/binder.h"
+
+
+#include <QtCore/QXmlStreamWriter>
+#include <QtCore/QTextStream>
+#include <QtCore/QTextCodec>
+#include <QtCore/QFile>
+
+void astToXML(QString name)
+{
+    QFile file(name);
+
+    if (!file.open(QFile::ReadOnly))
+        return;
+
+    QTextStream stream(&file);
+    stream.setCodec(QTextCodec::codecForName("UTF-8"));
+    QByteArray contents = stream.readAll().toUtf8();
+    file.close();
+
+    Control control;
+    Parser p(&control);
+    pool __pool;
+
+    TranslationUnitAST *ast = p.parse(contents, contents.size(), &__pool);
+
+    CodeModel model;
+    Binder binder(&model, p.location());
+    FileModelItem dom = binder.run(ast);
+
+    QFile outputFile;
+    if (!outputFile.open(stdout, QIODevice::WriteOnly))
+        return;
+
+    QXmlStreamWriter s(&outputFile);
+    s.setAutoFormatting(true);
+
+    s.writeStartElement("code");
+
+    QHash<QString, NamespaceModelItem> namespaceMap = dom->namespaceMap();
+    foreach (NamespaceModelItem item, namespaceMap.values())
+        writeOutNamespace(s, item);
+
+    QHash<QString, ClassModelItem> typeMap = dom->classMap();
+    foreach (ClassModelItem item, typeMap.values())
+        writeOutClass(s, item);
+
+    s.writeEndElement();
+}
+
+
+void writeOutNamespace(QXmlStreamWriter &s, NamespaceModelItem &item)
+{
+    s.writeStartElement("namespace");
+    s.writeAttribute("name", item->name());
+
+    QHash<QString, NamespaceModelItem> namespaceMap = item->namespaceMap();
+    foreach (NamespaceModelItem item, namespaceMap.values())
+        writeOutNamespace(s, item);
+
+    QHash<QString, ClassModelItem> typeMap = item->classMap();
+    foreach (ClassModelItem item, typeMap.values())
+        writeOutClass(s, item);
+
+    QHash<QString, EnumModelItem> enumMap = item->enumMap();
+    foreach (EnumModelItem item, enumMap.values())
+        writeOutEnum(s, item);
+
+    s.writeEndElement();
+}
+
+void writeOutEnum(QXmlStreamWriter &s, EnumModelItem &item)
+{
+    QString qualifiedName = item->qualifiedName().join("::");
+    s.writeStartElement("enum");
+    s.writeAttribute("name", qualifiedName);
+
+    EnumeratorList enumList = item->enumerators();
+    for (int i = 0; i < enumList.size() ; i++) {
+        s.writeStartElement("enumerator");
+        if (!enumList[i]->value().isEmpty())
+            s.writeAttribute("value", enumList[i]->value());
+        s.writeCharacters(enumList[i]->name());
+
+        s.writeEndElement();
+    }
+    s.writeEndElement();
+}
+
+void writeOutFunction(QXmlStreamWriter &s, FunctionModelItem &item)
+{
+    QString qualifiedName = item->qualifiedName().join("::");
+    s.writeStartElement("function");
+    s.writeAttribute("name", qualifiedName);
+
+    ArgumentList arguments = item->arguments();
+    for (int i = 0; i < arguments.size() ; i++) {
+        s.writeStartElement("argument");
+        s.writeAttribute("type",  arguments[i]->type().qualifiedName().join("::"));
+        s.writeEndElement();
+    }
+    s.writeEndElement();
+}
+
+void writeOutClass(QXmlStreamWriter &s, ClassModelItem &item)
+{
+    QString qualifiedName = item->qualifiedName().join("::");
+    s.writeStartElement("class");
+    s.writeAttribute("name", qualifiedName);
+
+    QHash<QString, EnumModelItem> enumMap = item->enumMap();
+    foreach (EnumModelItem item, enumMap.values())
+        writeOutEnum(s, item);
+
+    QHash<QString, FunctionModelItem> functionMap = item->functionMap();
+    foreach (FunctionModelItem item, functionMap.values())
+        writeOutFunction(s, item);
+
+    QHash<QString, ClassModelItem> typeMap = item->classMap();
+    foreach (ClassModelItem item, typeMap.values())
+        writeOutClass(s, item);
+
+    s.writeEndElement();
+}
+
diff --git a/ApiExtractor/asttoxml.h b/ApiExtractor/asttoxml.h
new file mode 100644
index 000000000..43c7cc238
--- /dev/null
+++ b/ApiExtractor/asttoxml.h
@@ -0,0 +1,40 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef ASTTOXML
+#define ASTTOXML
+
+#include "parser/codemodel.h"
+
+#include <QtCore/QString>
+#include <QtCore/QXmlStreamWriter>
+
+void astToXML(const QString name);
+void writeOutNamespace(QXmlStreamWriter &s, NamespaceModelItem &item);
+void writeOutEnum(QXmlStreamWriter &s, EnumModelItem &item);
+void writeOutFunction(QXmlStreamWriter &s, FunctionModelItem &item);
+void writeOutClass(QXmlStreamWriter &s, ClassModelItem &item);
+
+
+#endif // ASTTOXML
diff --git a/ApiExtractor/cmake_uninstall.cmake b/ApiExtractor/cmake_uninstall.cmake
new file mode 100644
index 000000000..df95fb9d8
--- /dev/null
+++ b/ApiExtractor/cmake_uninstall.cmake
@@ -0,0 +1,21 @@
+IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+  MESSAGE(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"")
+ENDIF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+
+FILE(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
+STRING(REGEX REPLACE "\n" ";" files "${files}")
+FOREACH(file ${files})
+  MESSAGE(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"")
+  IF(EXISTS "$ENV{DESTDIR}${file}")
+    EXEC_PROGRAM(
+      "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
+      OUTPUT_VARIABLE rm_out
+      RETURN_VALUE rm_retval
+      )
+    IF(NOT "${rm_retval}" STREQUAL 0)
+      MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")
+    ENDIF(NOT "${rm_retval}" STREQUAL 0)
+  ELSE(EXISTS "$ENV{DESTDIR}${file}")
+    MESSAGE(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.")
+  ENDIF(EXISTS "$ENV{DESTDIR}${file}")
+ENDFOREACH(file)
diff --git a/ApiExtractor/data/ApiExtractorConfig.cmake.in b/ApiExtractor/data/ApiExtractorConfig.cmake.in
new file mode 100644
index 000000000..6e6f41967
--- /dev/null
+++ b/ApiExtractor/data/ApiExtractorConfig.cmake.in
@@ -0,0 +1,16 @@
+# - try to find APIEXTRACTOR
+#  APIEXTRACTOR_INCLUDE_DIR   - Directories to include to use APIEXTRACTOR
+#  APIEXTRACTOR_LIBRARIES     - Files to link against to use APIEXTRACTOR
+
+SET(APIEXTRACTOR_INCLUDE_DIR "@CMAKE_INSTALL_PREFIX@/include/apiextractor@apiextractor_SUFFIX@")
+if(MSVC)
+    SET(APIEXTRACTOR_LIBRARY "@LIB_INSTALL_DIR@/@CMAKE_SHARED_LIBRARY_PREFIX@apiextractor@apiextractor_SUFFIX@@LIBRARY_OUTPUT_SUFFIX@.lib")
+elseif(CYGWIN)
+    SET(APIEXTRACTOR_LIBRARY "@LIB_INSTALL_DIR@/@CMAKE_IMPORT_LIBRARY_PREFIX@apiextractor@apiextractor_SUFFIX@@LIBRARY_OUTPUT_SUFFIX@@CMAKE_IMPORT_LIBRARY_SUFFIX@")
+elseif(WIN32)
+    SET(APIEXTRACTOR_LIBRARY "@CMAKE_INSTALL_PREFIX@/bin/@CMAKE_SHARED_LIBRARY_PREFIX@apiextractor@apiextractor_SUFFIX@@LIBRARY_OUTPUT_SUFFIX@@CMAKE_SHARED_LIBRARY_SUFFIX@")
+else()
+    SET(APIEXTRACTOR_LIBRARY "@LIB_INSTALL_DIR@/@CMAKE_SHARED_LIBRARY_PREFIX@apiextractor@apiextractor_SUFFIX@@LIBRARY_OUTPUT_SUFFIX@@CMAKE_SHARED_LIBRARY_SUFFIX@")
+endif()
+
+SET(APIEXTRACTOR_DOCSTRINGS_DISABLED @DISABLE_DOCSTRINGS@)
diff --git a/ApiExtractor/data/ApiExtractorConfigVersion.cmake.in b/ApiExtractor/data/ApiExtractorConfigVersion.cmake.in
new file mode 100644
index 000000000..2c8c3fa87
--- /dev/null
+++ b/ApiExtractor/data/ApiExtractorConfigVersion.cmake.in
@@ -0,0 +1,10 @@
+set(PACKAGE_VERSION @apiextractor_VERSION@)
+
+if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}" )
+   set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}" )
+   set(PACKAGE_VERSION_COMPATIBLE TRUE)
+   if( "${PACKAGE_FIND_VERSION}" STREQUAL "${PACKAGE_VERSION}")
+      set(PACKAGE_VERSION_EXACT TRUE)
+   endif( "${PACKAGE_FIND_VERSION}" STREQUAL "${PACKAGE_VERSION}")
+endif("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}" )
diff --git a/ApiExtractor/data/CMakeLists.txt b/ApiExtractor/data/CMakeLists.txt
new file mode 100644
index 000000000..b824e58a8
--- /dev/null
+++ b/ApiExtractor/data/CMakeLists.txt
@@ -0,0 +1,18 @@
+if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+    set(LIBRARY_OUTPUT_SUFFIX ${CMAKE_DEBUG_POSTFIX})
+else()
+    set(LIBRARY_OUTPUT_SUFFIX ${CMAKE_RELEASE_POSTFIX})
+endif()
+
+
+# create pkg-config file
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/apiextractor.pc.in"
+               "${CMAKE_CURRENT_BINARY_DIR}/apiextractor${apiextractor_SUFFIX}.pc" @ONLY)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/ApiExtractorConfig.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/ApiExtractorConfig.cmake" @ONLY)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/ApiExtractorConfigVersion.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/ApiExtractorConfigVersion.cmake" @ONLY)
+
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/apiextractor${apiextractor_SUFFIX}.pc" DESTINATION "${LIB_INSTALL_DIR}/pkgconfig")
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/ApiExtractorConfig.cmake"
+        DESTINATION "${LIB_INSTALL_DIR}/cmake/ApiExtractor-${apiextractor_VERSION}")
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/ApiExtractorConfigVersion.cmake"
+        DESTINATION "${LIB_INSTALL_DIR}/cmake/ApiExtractor-${apiextractor_VERSION}")
diff --git a/ApiExtractor/data/apiextractor.pc.in b/ApiExtractor/data/apiextractor.pc.in
new file mode 100644
index 000000000..7559b9c77
--- /dev/null
+++ b/ApiExtractor/data/apiextractor.pc.in
@@ -0,0 +1,11 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@/bin
+libdir=@CMAKE_INSTALL_PREFIX@/lib
+includedir=@CMAKE_INSTALL_PREFIX@/include
+
+Name: apiextractor
+Description: Qt4 Binding Generator library
+Requires: QtCore
+Version: @apiextractor_VERSION@
+Libs: -L${libdir} -lapiextractor@apiextractor_SUFFIX@@LIBRARY_OUTPUT_SUFFIX@
+Cflags: -I${includedir}/apiextractor@apiextractor_SUFFIX@
diff --git a/ApiExtractor/doc/CMakeLists.txt b/ApiExtractor/doc/CMakeLists.txt
new file mode 100644
index 000000000..d78844dc8
--- /dev/null
+++ b/ApiExtractor/doc/CMakeLists.txt
@@ -0,0 +1,10 @@
+
+find_program(SPHINX sphinx-build DOC "Path to sphinx-build binary.")
+
+if (SPHINX)
+    message("-- sphinx-build - found")
+    configure_file(conf.py.in conf.py @ONLY)
+    add_custom_target(doc ${SPHINX} -b html -c . ${CMAKE_CURRENT_SOURCE_DIR} html )
+else()
+    message("-- sphinx-build - not found! doc target disabled")
+endif()
\ No newline at end of file
diff --git a/ApiExtractor/doc/_templates/index.html b/ApiExtractor/doc/_templates/index.html
new file mode 100644
index 000000000..4aa14ede5
--- /dev/null
+++ b/ApiExtractor/doc/_templates/index.html
@@ -0,0 +1,27 @@
+{% extends "layout.html" %}
+{% set title = 'Overview' %}
+{% block body %}
+<div class="section">
+  <h1>API Extractor {{ version }}</h1>
+
+    <p>API Extractor is a tool that eases the development of bindings of Qt-based libraries for high
+    level languages by automating most of the process.
+
+    <p>API Extractor is based on the
+    <a href="http://labs.trolltech.com/page/Projects/QtScript/Generator">QtScriptGenerator</a> project.</p>
+
+  <h2>Documentation</h2>
+  <table class="contentstable"><tr>
+    <td width="50%">
+      <p class="biglink"><a href="{{ pathto("overview") }}">Overview</a><br/>
+         <span class="linkdescr">how API Extractor works</span></p>
+      <p class="biglink"><a href="{{ pathto("typesystem") }}">Typesystem reference</a><br/>
+         <span class="linkdescr">reference for all typesystem tags</span></p>
+    </td>
+    <td width="50%">
+      <p class="biglink"><a href="{{ pathto("contents") }}">Contents</a><br/>
+         <span class="linkdescr">for a complete overview</span></p>
+    </td></tr>
+  </table>
+</div>
+{% endblock %}
diff --git a/ApiExtractor/doc/_templates/layout.html b/ApiExtractor/doc/_templates/layout.html
new file mode 100644
index 000000000..9dc53722d
--- /dev/null
+++ b/ApiExtractor/doc/_templates/layout.html
@@ -0,0 +1,41 @@
+{% extends "!layout.html" %}
+
+# Invert sidebars
+{%- block sidebar1 %}{{ sidebar() }}{%- endblock %}
+{%- block sidebar2 %}{%- endblock %}
+
+{%- block header %}
+<div id="container">
+<div class="header">
+    <div class="header_container">
+        <div class="logo"><a href="http://www.pyside.org"><img alt="PySide" src="{{ pathto('_static/pysidelogo.png', 1) }}" width="199" height="102" /></a></div>
+        <div class="related">
+            <ul>
+                {%- block rootrellink %}
+                <li><a href="{{ pathto( 'index' ) }}">{{ shorttitle|e }}</a></li>
+                {%- endblock %}
+                {%- for parent in parents %}
+                <li>{{ reldelim1 }} <a href="{{ parent.link|e }}" {% if loop.last %}{{ accesskey("U") }}{% endif %}>{{ parent.title }}</a></li>
+                {%- endfor %}
+                {%- block relbaritems %} {% endblock %}
+            </ul>
+        </div>
+    </div>
+</div>
+{%- endblock -%}
+
+{%- block footer %}
+    <div class="footer">
+    <a href="http://www.indt.org.br"><img src="{{ pathto('_static/logo_indt.jpg', 1) }}" alt="Indt" border="0" /></a>
+    <a href="http://www.openbossa.org"><img src="{{ pathto('_static/logo_openbossa.png', 1) }}" alt="Openbossa" border="0" /></a>
+    <a href="http://qt.nokia.com/"><img src="{{ pathto('_static/logo_qt.png', 1) }}" alt="Qt" border="0" /></a>
+    <a href="http://www.python.org"><img src="{{ pathto('_static/logo_python.jpg', 1) }}" alt="Python" border="0" /></a>
+    </div>
+</div>
+{%- endblock %}
+
+# No top relbar.
+{%- block relbar1 %}{%- endblock %}
+
+# No bottom relbar.
+{%- block relbar2 %}{%- endblock %}
diff --git a/ApiExtractor/doc/_themes/pysidedocs/searchbox.html b/ApiExtractor/doc/_themes/pysidedocs/searchbox.html
new file mode 100644
index 000000000..55a972156
--- /dev/null
+++ b/ApiExtractor/doc/_themes/pysidedocs/searchbox.html
@@ -0,0 +1,12 @@
+{%- if pagename != "search" %}
+<div id="searchbox" style="display: none">
+  <h3>{{ _('Quick search') }}</h3>
+    <form class="search" action="{{ pathto('search') }}" method="get">
+      <input type="text" name="q" id="q" size="18" />
+      <input type="submit" value="{{ _('Go') }}" id="search_button" />
+      <input type="hidden" name="check_keywords" value="yes" />
+      <input type="hidden" name="area" value="default" />
+    </form>
+</div>
+<script type="text/javascript">$('#searchbox').show(0);</script>
+{%- endif %}
diff --git a/ApiExtractor/doc/_themes/pysidedocs/static/bg_header.png b/ApiExtractor/doc/_themes/pysidedocs/static/bg_header.png
new file mode 100644
index 000000000..843e7e2c5
--- /dev/null
+++ b/ApiExtractor/doc/_themes/pysidedocs/static/bg_header.png
diff --git a/ApiExtractor/doc/_themes/pysidedocs/static/bg_topo.jpg b/ApiExtractor/doc/_themes/pysidedocs/static/bg_topo.jpg
new file mode 100644
index 000000000..4229ae8db
--- /dev/null
+++ b/ApiExtractor/doc/_themes/pysidedocs/static/bg_topo.jpg
diff --git a/ApiExtractor/doc/_themes/pysidedocs/static/fakebar.png b/ApiExtractor/doc/_themes/pysidedocs/static/fakebar.png
new file mode 100644
index 000000000..b45830e00
--- /dev/null
+++ b/ApiExtractor/doc/_themes/pysidedocs/static/fakebar.png
diff --git a/ApiExtractor/doc/_themes/pysidedocs/static/logo_indt.jpg b/ApiExtractor/doc/_themes/pysidedocs/static/logo_indt.jpg
new file mode 100644
index 000000000..2a1fbe7a1
--- /dev/null
+++ b/ApiExtractor/doc/_themes/pysidedocs/static/logo_indt.jpg
diff --git a/ApiExtractor/doc/_themes/pysidedocs/static/logo_openbossa.png b/ApiExtractor/doc/_themes/pysidedocs/static/logo_openbossa.png
new file mode 100644
index 000000000..51e868d6e
--- /dev/null
+++ b/ApiExtractor/doc/_themes/pysidedocs/static/logo_openbossa.png
diff --git a/ApiExtractor/doc/_themes/pysidedocs/static/logo_python.jpg b/ApiExtractor/doc/_themes/pysidedocs/static/logo_python.jpg
new file mode 100644
index 000000000..cd474efba
--- /dev/null
+++ b/ApiExtractor/doc/_themes/pysidedocs/static/logo_python.jpg
diff --git a/ApiExtractor/doc/_themes/pysidedocs/static/logo_qt.png b/ApiExtractor/doc/_themes/pysidedocs/static/logo_qt.png
new file mode 100644
index 000000000..37800f454
--- /dev/null
+++ b/ApiExtractor/doc/_themes/pysidedocs/static/logo_qt.png
diff --git a/ApiExtractor/doc/_themes/pysidedocs/static/pysidedocs.css b/ApiExtractor/doc/_themes/pysidedocs/static/pysidedocs.css
new file mode 100644
index 000000000..fd81f4379
--- /dev/null
+++ b/ApiExtractor/doc/_themes/pysidedocs/static/pysidedocs.css
@@ -0,0 +1,409 @@
+* {
+    font: 100% Verdana, Arial, Helvetica, sans-serif;
+    font-size:12px;
+}
+
+html {
+    height: 100%;
+}
+
+body {
+    margin: 0;
+    padding: 0;
+    text-align: center;
+    background-color: #EBEBEB;
+    height: 100%;
+    color: #333;
+}
+
+strong {
+    font-weight:bold;
+}
+
+.document {
+    padding-bottom: 90px;
+}
+
+#container {
+    position: relative;
+    min-height: 100%;
+    background-image: url(fakebar.png);
+    background-repeat: repeat-y;
+    background-color: white;
+}
+
+.footer {
+    position: absolute;
+    bottom: 0px;
+    margin-top: 50px;
+    text-align:center;
+    background-color: white;
+    border-top: 2px solid #e0e0e0;
+    white-space: nowrap;
+    height: 90px;
+    width: 100%;
+}
+
+.footer img {
+    margin-left: 8px;
+    margin-right: 8px;
+}
+
+.sphinxsidebar {
+    float: left;
+    width: 250px;
+    padding: 0px 10px 0px 10px;
+    text-align: left;
+}
+
+.sphinxsidebar ul {
+    padding: 0px;
+    margin: 0px;
+    list-style-position: inside;
+}
+
+.sphinxsidebar > ul {
+    padding: 0px;
+    margin: 0px;
+}
+
+.sphinxsidebar ul li {
+    margin-left: 10px;
+    padding: 0px;
+}
+
+.sphinxsidebar h3, .sphinxsidebar h3 a {
+    font-weight: bold;
+    color: #333;
+}
+
+.documentwrapper {
+    margin-left: 270px;
+    text-align: left;
+    background-color: #ffffff;
+    border-left: 1px solid #989898;
+    font-size:18px;
+    padding: 10px 50px 15px 50px;
+    height: 100%;
+}
+
+h1 {
+    font-size:18px;
+    padding-left: 50px;
+    padding-bottom: 15px;
+    padding-top: 15px;
+    border-bottom: 1px solid #c2c2c2;
+    text-transform:uppercase;
+    margin-right: -100px;
+    position: relative;
+    left: -50px;
+    top: -10px;
+}
+
+h2 {
+    font-size:12px;
+    font-weight:bold;
+    border-left-width: 1px;
+    border-right-width: 1px;
+    border-top-width: 1px;
+    border-bottom-width: 2px;
+    border-style: solid;
+    border-left-color: #b1b1b1;
+    border-right-color: #b1b1b1;
+    border-top-color: #b1b1b1;
+    border-bottom-color: #009491;
+    background-color: #e0e0e0;
+    padding:5px;
+    margin-top: 20px;
+    -moz-border-radius:5px;
+    -webkit-border-radius:5px;
+    -khtml-border-radius:5px;
+}
+
+h3, h4 {
+    font-weight: bolder;
+}
+
+pre {
+    border-top: 1px solid #e0e0e0;
+    border-bottom: 1px solid #e0e0e0;
+    background-color: #fafafa;
+    padding: 5px;
+    font: 100% monospace;
+    overflow: auto;
+}
+
+pre * {
+    font: 100% monospace;
+}
+
+.headerlink {
+    font-size: 100%;
+    color: inherit;
+    float: right;
+    visibility: Hidden;
+}
+
+h1 .headerlink {
+    padding-right: 50px;
+}
+
+h1:hover .headerlink, h2:hover .headerlink, h3:hover .headerlink {
+    visibility: Visible;
+}
+
+a, a:visited {
+    color: #009491;
+    text-decoration: none;
+}
+
+a:hover {
+    text-decoration: underline;
+}
+
+/* -- admonitions ----------------------------------------------------------- */
+
+div.admonition {
+    margin-top: 10px;
+    margin-bottom: 10px;
+    padding: 7px;
+}
+
+div.admonition dt {
+    font-weight: bold;
+}
+
+div.admonition dl {
+    margin-bottom: 0;
+}
+
+p.admonition-title {
+    margin: 0px 10px 5px 0px;
+    font-weight: bold;
+}
+
+div.body p.centered {
+    text-align: center;
+    margin-top: 25px;
+}
+
+div.warning {
+    background-color: #ffe4e4;
+    border: 1px solid #f66;
+}
+
+div.note {
+    border: 1px solid #e3e3e3;
+}
+
+table.docutils {
+    margin-left: auto;
+    margin-right: auto;
+    margin-bottom: 10px;
+    border: none;
+}
+
+table.docutils td {
+    border: none;
+}
+
+table.docutils th {
+    border: none;
+    font-weight: bold;
+    vertical-align: top;
+}
+
+h2 em {
+    float: right;
+    font-size: 10px;
+    position: relative;
+    top: -20px;
+}
+
+/* Table of pymaemo components */
+
+#development table.docutils td {
+    border-bottom: 1px solid #EBEBEB;
+}
+
+#development th {
+    background-color: #EBEBEB;
+    color: #FC7E00;
+    padding: 5px;
+}
+
+#development th:first-child {
+    -moz-border-radius: 20px 0px 0px 0px;
+    -webkit-border-radius: 20px 0px 0px 0px;
+    -khtml-border-radius: 20px 0px 0px 0px;
+    padding-left: 10px;
+}
+#development th:last-child {
+    -moz-border-radius: 0px 20px 0px 0px;
+    -webkit-border-radius: 0px 20px 0px 0px;
+    -khtml-border-radius: 0px 20px 0px 0px;
+    padding-right: 10px;
+    width: 100px;
+}
+
+hr {
+    border: none;
+    border-bottom: 1px dashed #EBEBEB;
+    width: 70%
+}
+
+.oldnews {
+    text-align: right;
+}
+
+/******************* TOPO *****************************/
+.header {
+    background-image: url(bg_topo.jpg);
+    background-repeat: repeat-x;
+    height: 147px;
+}
+
+.header_container {
+    background-image: url(bg_header.png);
+    background-repeat: no-repeat;
+    background-position: 100px 0px;
+}
+
+.logo {
+    text-align: left;
+    margin-bottom: 10px;
+}
+
+#searchbox {
+    border-top: 1px solid #989898;
+    padding-top: 10px;
+    margin-left: -10px;
+    margin-right: -10px;
+    padding-left: 10px;
+    padding-right: 10px;
+}
+
+#search_button {
+    border: 1px solid #3A393A;
+    background-color: #3A393A;
+    color: white;
+    cursor: pointer;
+    -moz-border-radius: 5px;
+    -webkit-border-radius: 5px;
+    -khtml-border-radius: 5px;
+
+}
+
+form {
+    margin: 0px;
+    padding: 0px;
+}
+
+/* search field */
+form #q {
+    width: 136px;
+/*     height: 22px; */
+    border: none;
+    margin: 0px;
+    -moz-border-radius: 5px;
+    -webkit-border-radius: 5px;
+    -khtml-border-radius: 5px;
+    margin-top: 2px;
+    padding: 4px;
+    line-height: 22px
+}
+
+#search-results h2 {
+    display: none;
+}
+
+#search-results h2 {
+    display: none;
+}
+
+#search-results ul.search {
+    margin: 0px;
+    padding: 0px;
+}
+
+ul.search div.context {
+    padding-left: 40px;
+}
+
+#installation td {
+    text-align: center;
+    font-weight: bold;
+}
+
+em {
+    color: inherit;
+    font-style:italic;
+}
+
+/********   REL bar     *********/
+
+.related {
+    display: inline;
+}
+
+.related ul {
+    padding: 0px 0px 0px 10px;
+    margin: 0px;
+    text-align: left;
+    background-image: url(relbar_bg.png);
+}
+
+.related li {
+    display: inline;
+    color: white;
+    font-weight: bold;
+}
+
+.related li a {
+    color: inherit;
+    line-height: 35px;
+    font-weight: bold;
+    vertical-align: middle;
+}
+
+.related li.right {
+    float: right;
+    margin-right: 5px;
+}
+
+.related h3 {
+    display: none;
+}
+
+.align-center {
+    text-align: center;
+}
+
+.contentstable {
+    width: 100%;
+}
+
+.contentstable td {
+    padding-left: 30px;
+    vertical-align: top;
+}
+
+p.biglink a {
+    font-size: 20px;
+}
+
+dt:target, .highlight {
+    background-color: #fbe54e;
+}
+
+img {
+    border: 0px;
+}
+
+.figure .caption {
+    font-style:italic;
+}
+
+table.footnote {
+    margin: 0px;
+}
diff --git a/ApiExtractor/doc/_themes/pysidedocs/static/pysidelogo.png b/ApiExtractor/doc/_themes/pysidedocs/static/pysidelogo.png
new file mode 100644
index 000000000..076c1057c
--- /dev/null
+++ b/ApiExtractor/doc/_themes/pysidedocs/static/pysidelogo.png
diff --git a/ApiExtractor/doc/_themes/pysidedocs/static/relbar_bg.png b/ApiExtractor/doc/_themes/pysidedocs/static/relbar_bg.png
new file mode 100644
index 000000000..4036733a7
--- /dev/null
+++ b/ApiExtractor/doc/_themes/pysidedocs/static/relbar_bg.png
diff --git a/ApiExtractor/doc/_themes/pysidedocs/theme.conf b/ApiExtractor/doc/_themes/pysidedocs/theme.conf
new file mode 100644
index 000000000..e0a652a5d
--- /dev/null
+++ b/ApiExtractor/doc/_themes/pysidedocs/theme.conf
@@ -0,0 +1,7 @@
+[theme]
+inherit = default
+stylesheet = pysidedocs.css
+pygments_style = none
+
+[options]
+nosidebar = false
diff --git a/ApiExtractor/doc/conf.py.in b/ApiExtractor/doc/conf.py.in
new file mode 100644
index 000000000..70750c899
--- /dev/null
+++ b/ApiExtractor/doc/conf.py.in
@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+#
+# ApiExtractor documentation build configuration file, created by
+# sphinx-quickstart on Wed Apr 22 15:04:20 2009.
+#
+# This file is execfile()d with the current directory set to its containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import sys, os
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#sys.path.append(os.path.abspath('.'))
+
+# -- General configuration -----------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be extensions
+# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
+extensions = ['sphinx.ext.autodoc', 'sphinx.ext.doctest', 'sphinx.ext.ifconfig', 'sphinx.ext.refcounting', 'sphinx.ext.coverage']
+
+rst_epilog = """
+.. |project| replace:: API Extractor
+"""
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['@CMAKE_CURRENT_SOURCE_DIR@/_templates']
+
+# The suffix of source filenames.
+source_suffix = '.rst'
+
+# The encoding of source files.
+source_encoding = 'utf-8'
+
+# The master toctree document.
+#master_doc = 'contents'
+
+# General information about the project.
+project = u'API Extractor'
+copyright = u'2009-2010, Nokia Corporation'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = '@apiextractor_MAJOR_VERSION@.@apiextractor_MINOR_VERSION@'
+# The full version, including alpha/beta/rc tags.
+release = '@apiextractor_VERSION@'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#today = ''
+# Else, today_fmt is used as the format for a strftime call.
+#today_fmt = '%B %d, %Y'
+
+# List of documents that shouldn't be included in the build.
+#unused_docs = []
+
+# List of directories, relative to source directory, that shouldn't be searched
+# for source files.
+exclude_trees = ['_build']
+
+# The reST default role (used for this markup: `text`) to use for all documents.
+#default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# A list of ignored prefixes for module index sorting.
+#modindex_common_prefix = []
+
+
+# -- Options for HTML output ---------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  Major themes that come with
+# Sphinx are currently 'default' and 'sphinxdoc'.
+html_theme = 'pysidedocs'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#html_theme_options = {
+#}
+
+# Add any paths that contain custom themes here, relative to this directory.
+html_theme_path = ['@CMAKE_CURRENT_SOURCE_DIR@/_themes']
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+#html_title = None
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+#html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+#html_logo = None
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+#html_static_path = ['@CMAKE_CURRENT_SOURCE_DIR@/_static']
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+#html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+#html_sidebars = { '' : ''}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+html_additional_pages = { 'index' : 'index.html'}
+
+# If false, no index is generated.
+html_use_index = False
+
+# If true, the index is split into individual pages for each letter.
+html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+html_show_sourcelink = False
+
+html_add_permalinks = True;
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+#html_use_opensearch = ''
+
+# If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml").
+#html_file_suffix = ''
+
diff --git a/ApiExtractor/doc/contents.rst b/ApiExtractor/doc/contents.rst
new file mode 100644
index 000000000..83a4889fe
--- /dev/null
+++ b/ApiExtractor/doc/contents.rst
@@ -0,0 +1,9 @@
+Table of contents
+*****************
+.. toctree::
+    :numbered:
+    :maxdepth: 3
+
+    overview.rst
+    ownership.rst
+    typesystem.rst
diff --git a/ApiExtractor/doc/dependency-apiextractor.svg b/ApiExtractor/doc/dependency-apiextractor.svg
new file mode 100644
index 000000000..6bec8b5a8
--- /dev/null
+++ b/ApiExtractor/doc/dependency-apiextractor.svg
@@ -0,0 +1,360 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="750"
+   height="230"
+   id="svg2"
+   sodipodi:version="0.32"
+   inkscape:version="0.46"
+   version="1.0"
+   sodipodi:docname="dependency-apiextractor.svg"
+   inkscape:output_extension="org.inkscape.output.svg.inkscape"
+   inkscape:export-filename="/tmp/dependency-pyside.png"
+   inkscape:export-xdpi="90"
+   inkscape:export-ydpi="90">
+  <defs
+     id="defs4">
+    <marker
+       inkscape:stockid="Arrow1Lstart"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="Arrow1Lstart"
+       style="overflow:visible">
+      <path
+         id="path3270"
+         d="M 0,0 L 5,-5 L -12.5,0 L 5,5 L 0,0 z"
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
+         transform="matrix(0.8,0,0,0.8,10,0)" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow1Lend"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="Arrow1Lend"
+       style="overflow:visible">
+      <path
+         id="path3679"
+         d="M 0,0 L 5,-5 L -12.5,0 L 5,5 L 0,0 z"
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
+         transform="matrix(-0.8,0,0,-0.8,-10,0)" />
+    </marker>
+    <inkscape:perspective
+       sodipodi:type="inkscape:persp3d"
+       inkscape:vp_x="0 : 526.18109 : 1"
+       inkscape:vp_y="0 : 1000 : 0"
+       inkscape:vp_z="744.09448 : 526.18109 : 1"
+       inkscape:persp3d-origin="372.04724 : 350.78739 : 1"
+       id="perspective10" />
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     gridtolerance="10000"
+     guidetolerance="10"
+     objecttolerance="10"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="1.6315754"
+     inkscape:cx="375"
+     inkscape:cy="115"
+     inkscape:document-units="px"
+     inkscape:current-layer="svg2"
+     showgrid="false"
+     showguides="true"
+     inkscape:guide-bbox="true"
+     inkscape:window-width="1278"
+     inkscape:window-height="949"
+     inkscape:window-x="1330"
+     inkscape:window-y="25">
+    <sodipodi:guide
+       orientation="1,0"
+       position="384.28571,590"
+       id="guide2601" />
+    <sodipodi:guide
+       orientation="1,0"
+       position="678.57143,491.42857"
+       id="guide2603" />
+    <sodipodi:guide
+       orientation="1,0"
+       position="78.571429,257.14286"
+       id="guide2605" />
+    <sodipodi:guide
+       orientation="1,0"
+       position="93.571429,280.71429"
+       id="guide7565" />
+    <sodipodi:guide
+       orientation="1,0"
+       position="148.57143,216.42857"
+       id="guide7567" />
+  </sodipodi:namedview>
+  <metadata
+     id="metadata7">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(-250.44576,-308.53365)" />
+  <g
+     id="g2664"
+     transform="translate(-162.03535,-115.53321)">
+    <path
+       inkscape:connector-type="polyline"
+       id="path2869"
+       d="M 439.27375,270.21407 L 594.99083,193.03351"
+       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;marker-start:url(#Arrow1Lstart);marker-end:none;stroke-opacity:1" />
+    <g
+       transform="translate(166.24286,-190.07976)"
+       id="g2606">
+      <rect
+         style="fill:#e3e2db;stroke:#000000;stroke-opacity:1"
+         id="rect7541"
+         width="211.42857"
+         height="124.28571"
+         x="6.6142678"
+         y="308.16089"
+         ry="17.142857" />
+      <text
+         xml:space="preserve"
+         style="font-size:20.61732101px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
+         x="76.614265"
+         y="339.74512"
+         id="text7543"><tspan
+           sodipodi:role="line"
+           id="tspan7545"
+           x="76.614265"
+           y="339.74512">Boost</tspan></text>
+      <text
+         xml:space="preserve"
+         style="font-size:20.61732101px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
+         x="76.614265"
+         y="372.67505"
+         id="text7547"><tspan
+           sodipodi:role="line"
+           id="tspan7549"
+           x="76.614265"
+           y="372.67505">Qt Software</tspan></text>
+      <text
+         xml:space="preserve"
+         style="font-size:20.61732101px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
+         x="76.614265"
+         y="408.38055"
+         id="text7551"><tspan
+           sodipodi:role="line"
+           id="tspan7553"
+           x="76.614265"
+           y="408.38055">INdT/Nokia</tspan></text>
+      <rect
+         style="fill:#aaeeff;fill-opacity:1;stroke:#000000;stroke-width:0.64285713;stroke-opacity:1"
+         id="rect7555"
+         width="43.163269"
+         height="22.5"
+         x="21.614267"
+         y="321.55374"
+         ry="6.4285707" />
+      <rect
+         style="fill:#b3ff80;fill-opacity:1;stroke:#000000;stroke-width:0.64285713;stroke-opacity:1"
+         id="rect7561"
+         width="43.163269"
+         height="22.5"
+         x="21.614267"
+         y="355.4823"
+         ry="6.4285707" />
+      <rect
+         style="fill:#e9ddaf;fill-opacity:1;stroke:#000000;stroke-width:0.64285713;stroke-opacity:1"
+         id="rect7563"
+         width="43.163269"
+         height="22.5"
+         x="21.614267"
+         y="390.4823"
+         ry="6.4285707" />
+    </g>
+    <path
+       inkscape:connector-type="polyline"
+       id="path2604"
+       d="M 782.79015,270.0418 L 627.07307,192.86124"
+       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;marker-start:url(#Arrow1Lstart);marker-end:none;stroke-opacity:1" />
+    <g
+       transform="translate(234.84929,-73.143707)"
+       id="g5193">
+      <rect
+         ry="9.2689295"
+         style="fill:#b3ff80;fill-rule:evenodd;stroke:#2a7800;stroke-width:0.96558368px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         id="rect2417"
+         width="274.18781"
+         height="73.282379"
+         x="78.571426"
+         y="342.86383"
+         rx="8.3239012" />
+      <text
+         xml:space="preserve"
+         style="font-size:16.27989578px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
+         x="88.822823"
+         y="359.67014"
+         id="text2419"><tspan
+           sodipodi:role="line"
+           id="tspan2421"
+           x="88.822823"
+           y="359.67014">Qt 4.5</tspan></text>
+      <text
+         xml:space="preserve"
+         style="font-size:8.40044498px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
+         x="88.822823"
+         y="375.33484"
+         id="text2423"><tspan
+           sodipodi:role="line"
+           id="tspan2425"
+           x="88.822823"
+           y="375.33484">4.5</tspan></text>
+      <text
+         xml:space="preserve"
+         style="font-size:9.33067703px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
+         x="88.822823"
+         y="390.87479"
+         id="text2427"><tspan
+           sodipodi:role="line"
+           id="tspan2429"
+           x="88.822823"
+           y="390.87479">headers and libraries - compile-time and run-time</tspan></text>
+      <text
+         xml:space="preserve"
+         style="font-size:8.26250458px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
+         x="88.822823"
+         y="400.84058"
+         id="text2431"><tspan
+           sodipodi:role="line"
+           id="tspan2433"
+           x="88.822823"
+           y="400.84058">GNU General Public License v3 /</tspan><tspan
+           id="tspan2472"
+           sodipodi:role="line"
+           x="88.822823"
+           y="411.1687">GNU Lesser General Public Licence v2.1</tspan></text>
+    </g>
+    <g
+       transform="translate(101.41581,-378.37135)"
+       id="g5120">
+      <rect
+         rx="10.404889"
+         ry="13.104635"
+         style="fill:#e9ddaf;fill-rule:evenodd;stroke:#5f5019;stroke-width:0.96620417px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         id="rect2441"
+         width="274.54263"
+         height="73.281754"
+         x="384.28571"
+         y="496.43558" />
+      <text
+         xml:space="preserve"
+         style="font-size:16.27989578px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
+         x="389.17969"
+         y="513.59869"
+         id="text2443"><tspan
+           sodipodi:role="line"
+           id="tspan2445"
+           x="389.17969"
+           y="513.59869">libapiextractor</tspan></text>
+      <text
+         xml:space="preserve"
+         style="font-size:8.40044498px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
+         x="389.17969"
+         y="529.26337"
+         id="text2447"><tspan
+           sodipodi:role="line"
+           id="tspan2449"
+           x="389.17969"
+           y="529.26337">0.2</tspan></text>
+      <text
+         xml:space="preserve"
+         style="font-size:9.33067703px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
+         x="389.17969"
+         y="544.80334"
+         id="text2451"><tspan
+           sodipodi:role="line"
+           x="389.17969"
+           y="544.80334"
+           id="tspan2453">headers and libraries - compile-time and run-time</tspan></text>
+      <text
+         xml:space="preserve"
+         style="font-size:8.26250458px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
+         x="389.17969"
+         y="560.12628"
+         id="text2455"><tspan
+           sodipodi:role="line"
+           id="tspan2457"
+           x="389.17969"
+           y="560.12628">LGPL version 2.1</tspan></text>
+    </g>
+    <g
+       transform="translate(242.40213,-378.858)"
+       id="g5182">
+      <rect
+         ry="11.287985"
+         style="fill:#aaeeff;fill-rule:evenodd;stroke:#006078;stroke-width:0.96620417px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         id="rect2563"
+         width="274.54263"
+         height="73.281754"
+         x="384.28571"
+         y="648.57843"
+         rx="10.404877" />
+      <text
+         xml:space="preserve"
+         style="font-size:16.27989578px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
+         x="389.17969"
+         y="665.74158"
+         id="text2565"><tspan
+           sodipodi:role="line"
+           id="tspan2567"
+           x="389.17969"
+           y="665.74158">boost::graph</tspan></text>
+      <text
+         xml:space="preserve"
+         style="font-size:8.40044498px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
+         x="389.17969"
+         y="681.40625"
+         id="text2569"><tspan
+           sodipodi:role="line"
+           id="tspan2571"
+           x="389.17969"
+           y="681.40625">1.38.0</tspan></text>
+      <text
+         xml:space="preserve"
+         style="font-size:9.33067703px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
+         x="389.17969"
+         y="696.94623"
+         id="text2573"><tspan
+           sodipodi:role="line"
+           x="389.17969"
+           y="696.94623"
+           id="tspan2575">headers and libraries - compile-time and run-time</tspan></text>
+      <text
+         xml:space="preserve"
+         style="font-size:8.26250458px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans"
+         x="389.17969"
+         y="712.26917"
+         id="text2577"><tspan
+           sodipodi:role="line"
+           id="tspan2579"
+           x="389.17969"
+           y="712.26917">Boost Software License 1.0</tspan></text>
+    </g>
+  </g>
+</svg>
diff --git a/ApiExtractor/doc/overview.rst b/ApiExtractor/doc/overview.rst
new file mode 100644
index 000000000..471e2439b
--- /dev/null
+++ b/ApiExtractor/doc/overview.rst
@@ -0,0 +1,15 @@
+.. _gen-overview:
+
+**********************
+API Extractor Overview
+**********************
+
+The **API Extractor** library is used by the binding generator to parse headers
+of a given library and merge this data with information provided by
+typesystem (XML) files, resulting in a representation of how the API should be
+exported to the chosen target language. The generation of source code for the
+bindings is performed by specific generators using the API Extractor library.
+
+The API Extractor is based on QtScriptGenerator_ codebase.
+
+.. _QtScriptGenerator: http://labs.trolltech.com/page/Projects/QtScript/Generator
diff --git a/ApiExtractor/doc/ownership.rst b/ApiExtractor/doc/ownership.rst
new file mode 100644
index 000000000..760967da6
--- /dev/null
+++ b/ApiExtractor/doc/ownership.rst
@@ -0,0 +1,85 @@
+Ownership Management
+********************
+
+Among the various types of instances interactions, sometimes an object
+may be *owned* by another object, so that the owner is responsible for
+destroying the owned object, like in Qt's object system [#]_.
+This kind of relationship has a big role on interfacing with the target language, like
+with Python's reference counting.
+
+
+Ownership transfers
+-------------------
+
+From C++ to target
+^^^^^^^^^^^^^^^^^^
+
+    When an object that is currently owned by C++ has its ownership transfered
+    back to the target language, the binding can know for sure when the object will be deleted and
+    tie the C++ instance existence to the wrapper, calling the C++ destructor normally when the
+    wrapper is deleted.
+
+    .. code-block:: xml
+
+        <modify-argument index="1">
+            <define-ownership class="target" owner="target" />
+        </modify-argument>
+
+
+From target to C++
+^^^^^^^^^^^^^^^^^^
+
+    In the opposite direction,when an object ownership is transfered from the target language
+    to C++, the native code takes full control of the object life and you don't
+    know when that object will be deleted, rendering the wrapper object invalid,
+    unless you're wrapping an object with a virtual destructor,
+    so you can override it and be notified of its destruction.
+
+    By default it's safer to just render the wrapper
+    object invalid and raise some error if the user tries to access
+    one of this objects members or pass it as argument to some function, to avoid unpleasant segfaults.
+    Also you should avoid calling the C++ destructor when deleting the wrapper.
+
+    .. code-block:: xml
+
+        <modify-argument index="1">
+            <define-ownership class="target" owner="c++" />
+        </modify-argument>
+
+
+Parent-child relationship
+-------------------------
+
+One special type of relationship is the parent-child. When an object is called
+the parent of another object (the child), the former is in charge of deleting its
+child when deleted and the target language can trust that the child will be alive
+as long as the parent is, unless some other method can take the C++ ownership away from the parent.
+
+One of the main uses of this scheme is Qt's object system, with ownership among QObject-derived
+classes, creating "trees" of instances.
+
+    .. code-block:: xml
+
+        <modify-argument index="this">
+            <parent index="1" action="add">
+        </modify-argument>
+
+In this example, the instance with the method that is being invoked (indicated by 'index="this"' on
+modify-argument) will be marked as a child
+of the first argument using the `parent` tag. To remove ownership, just use "remove" in the action attribute. **Removing
+parentship also transfers the ownership back to python.**
+
+Invalidation after use
+----------------------
+
+Sometimes an object is created as a virtual method call argument and destroyed after the
+call returned. In this case, you should use the ``invalidate-after-use`` attribute in the
+``modify-argument`` tag to mark the wrapper as invalid right after the virtual method returns.
+
+    .. code-block:: xml
+
+        <modify-argument index="2" invalidate-after-use="yes"/>
+
+In this example the second argument will be invalidated after this method call.
+
+.. [#] See *Object Trees and Object Ownership* http://doc.trolltech.com/4.5/objecttrees.html
diff --git a/ApiExtractor/doc/typesystem.rst b/ApiExtractor/doc/typesystem.rst
new file mode 100644
index 000000000..69dda43a0
--- /dev/null
+++ b/ApiExtractor/doc/typesystem.rst
@@ -0,0 +1,29 @@
+The API Extractor Type System
+*****************************
+
+The typesystem is used by a binding generator or any other software using the APIExtractor library
+to map a C++ library API onto a higher level language.
+
+The typesystem specification is a handwritten XML document listing the types
+that will be available in the generated target language API; types that are not
+declared in the specification will be ignored along with everything depending on
+them. In addition, it is possible to manipulate and modify types and functions.
+It is even possible to use the typesystem specification to inject arbitrary
+code into the source files, such as an extra member function.
+
+Below there is a complete reference guide to the various nodes (XML tags) of the typesystem.
+For usage examples, take a look at the typesystem files used to generate PySide. These files
+can be found in the PySide/<QT_MODULE_NAME> directory of the PySide package.
+
+.. toctree::
+
+    typesystem_specifying_types
+    typesystem_manipulating_objects
+    typesystem_modify_function
+    typesystem_arguments
+    typesystem_solving_compilation
+    typesystem_templates
+    typesystem_conversionrule
+    typesystem_documentation
+
+
diff --git a/ApiExtractor/doc/typesystem_arguments.rst b/ApiExtractor/doc/typesystem_arguments.rst
new file mode 100644
index 000000000..16e0678d3
--- /dev/null
+++ b/ApiExtractor/doc/typesystem_arguments.rst
@@ -0,0 +1,192 @@
+.. _modifying-arguments:
+
+Modifying Arguments
+-------------------
+
+.. _conversion-rule:
+
+conversion-rule
+^^^^^^^^^^^^^^^
+
+    The conversion-rule node allows you to write customized code to convert
+    the given argument between the target language and C++, and it is a child of the modify-argument node.
+
+    .. code-block:: xml
+
+        <modify-argument ...>
+        <conversion-rule class="target | native">
+            // the code
+        </conversion-rule>
+        </modify-argument>
+
+    This node is typically used in combination with the replace-type and
+    remove-argument nodes. The given code is used instead of the generator's
+    conversion code.
+
+    Writing %N in the code (where N is a number), will insert the name of the
+    nth argument. Alternatively, %in and %out which will be replaced with the
+    name of the conversion's input and output variable, respectively. Note the
+    output variable must be declared explicitly, for example:
+
+    .. code-block:: xml
+
+        <conversion-rule class="native">
+        bool %out = (bool) %in;
+        </conversion-rule>
+
+    .. note:: You can also use the conversion-rule node to specify :ref:`a conversion code which will be used instead of the generator's conversion code everywhere for a given type <conversion-rule-on-types>`.
+
+remove-argument
+^^^^^^^^^^^^^^^
+
+    The remove-argument node removes the given argument from the function's
+    signature, and it is a child of the modify-argument node.
+
+    .. code-block:: xml
+
+     <modify-argument>
+         <remove-argument />
+     </modify-argument>
+
+rename to
+^^^^^^^^^
+
+    The 'rename to' node is used to rename a argument and use this new name in the generated code.
+
+    .. code-block:: xml
+
+     <modify-argument>
+         <rename to='...' />
+     </modify-argument>
+
+
+remove-default-expression
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    The remove-default-expression node disables the use of the default expression
+    for the given argument, and it is a child of the modify-argument node.
+
+    .. code-block:: xml
+
+         <modify-argument...>
+             <remove-default-expression />
+         </modify-argument>
+
+replace-default-expression
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    The replace-default-expression node replaces the specified argument with the
+    expression specified by the ``with`` attribute, and it is a child of the
+    modify-argument node.
+
+    .. code-block:: xml
+
+         <modify-argument>
+             <replace-default-expression with="..." />
+         </modify-argument>
+
+
+replace-type
+^^^^^^^^^^^^
+
+    The replace-type node replaces the type of the given argument to the one
+    specified by the ``modified-type`` attribute, and it is a child of the
+    modify-argument node.
+
+    .. code-block:: xml
+
+         <modify-argument>
+             <replace-type modified-type="..." />
+         </modify-argument>
+
+    If the new type is a class, the ``modified-type`` attribute must be set to
+    the fully qualified name (including name of the package as well as the class
+    name).
+
+define-ownership
+^^^^^^^^^^^^^^^^
+
+    The define-ownership tag indicates that the function changes the ownership
+    rules of the argument object. The ``class`` attribute specifies the class of
+    function where to inject the ownership altering code. The ``owner`` attribute
+    specifies the new ownership of the object. It accepts the following values:
+
+        * target: the target language will assume full ownership of the object.
+                  The native resources will be deleted when the target language
+                  object is finalized.
+        * c++: The native code assumes full ownership of the object. The target
+               language object will not be garbage collected.
+        * default: The object will get default ownership, depending on how it
+                   was created.
+
+    .. code-block:: xml
+
+        <modify-argument>
+              <define-ownership class="target | native"
+                                owner="target | c++ | default" />
+        </modify-argument>
+
+
+reference-count
+^^^^^^^^^^^^^^^
+
+    The reference-count tag dictates how an argument should be handled by the
+    target language reference counting system (if there is any), it also indicates
+    the kind of relationship the class owning the function being modified has with
+    the argument. For instance, in a model/view relation a view receiving a model
+    as argument for a **setModel** method should increment the model's reference
+    counting, since the model should be kept alive as much as the view lives.
+    Remember that out hypothetical view could not become parent of the model,
+    since the said model could be used by other views as well.
+    The ``action`` attribute specifies what should be done to the argument
+    reference counting when the modified method is called. It accepts the
+    following values:
+
+        * add: increments the argument reference counter.
+        * add-all: increments the reference counter for each item in a collection.
+        * remove: decrements the argument reference counter.
+        * set: will assign the argument to the variable containing the reference.
+        * ignore: does nothing with the argument reference counter
+                  (sounds worthless, but could be used in situations
+                   where the reference counter increase is mandatory
+                   by default).
+
+    .. code-block:: xml
+
+        <modify-argument>
+              <reference-count action="add|add-all|remove|set|ignore" variable-name="..." />
+        </modify-argument>
+
+
+    The variable-name attribute specifies the name used for the variable that
+    holds the reference(s).
+
+
+replace-value
+^^^^^^^^^^^^^
+
+    The ``replace-value`` attribute lets you replace the return statement of a
+    function with a fixed string. This attribute can only be used for the
+    argument at ``index`` 0, which is always the function's return value.
+
+    .. code-block:: xml
+
+         <modify-argument index="0" replace-value="this"/>
+
+
+parent
+^^^^^^
+
+    The parent node lets you define the argument parent which will
+    take ownership of argument and will destroy the C++ child object when the
+    parent is destroyed.
+
+    .. code-block:: xml
+
+        <modify-argument index="1">
+              <parent index="this" action="add | remove" />
+        </modify-argument>
+
+    In the ``index`` argument you must specify the parent argument. The action
+    *add* creates a parent link between objects, while *remove* will undo the
+    parentage relationship.
diff --git a/ApiExtractor/doc/typesystem_conversionrule.rst b/ApiExtractor/doc/typesystem_conversionrule.rst
new file mode 100644
index 000000000..c62d5bbf6
--- /dev/null
+++ b/ApiExtractor/doc/typesystem_conversionrule.rst
@@ -0,0 +1,113 @@
+.. _conversion-rule-tag:
+
+Conversion Rule Tag
+-------------------
+
+.. _conversion-rule:
+
+conversion-rule
+^^^^^^^^^^^^^^^
+
+    The **conversion-rule** tag specifies how a **primitive-type**, a **container-type**,
+    or a **value-type** may be converted to and from the native C++ language types to the
+    target language types.
+
+    .. code-block:: xml
+
+        <value-type>
+            <conversion-rule>
+                <native-to-target>
+                // Code to convert a native value to a target language object.
+                </native-to-target>
+                <target-to-native>
+                    <add-conversion type='TARGETTYPEA' check='TARGETTYPEA_CHECK(%in)'>
+                    // Code to convert target language type object of type TARGETTYPEA
+                    // to the C++ native type represented by the value/primitive/container-type.
+                    </add-conversion>
+                    <add-conversion type='TARGETTYPEB' check='TARGETTYPEB_CHECK(%in)'>
+                    // Code to convert target language type object of type TARGETTYPEB
+                    // to the C++ native type represented by the value/primitive/container-type.
+                    </add-conversion>
+                </target-to-native>
+            </conversion-rule>
+        </value-type>
+
+    The example above show the structure of a complete conversion rule. Each of the
+    child tags comprising the conversion rule are described in their own sections
+    below.
+
+
+.. _native-to-target:
+
+native-to-target
+^^^^^^^^^^^^^^^^
+
+    The **native-to-target** tag tells how to convert a native C++ value to its
+    target language equivalent. The text inside the tag is a C++ code the takes
+    an input value an does what's needed to convert it to the output value.
+    ``insert-template`` tags may be used to insert commonly repeating code.
+
+    .. code-block:: xml
+
+        <conversion-rule>
+            <native-to-target>
+            // Code to convert a native value to a target language object.
+            </native-to-target>
+        </conversion-rule>
+
+    Use the replace node to modify the template code.
+    Notice that the generator must provide type system variables for the input
+    and output values and types, namely **%in**, **%out**, **%INTYPE** and
+    **%OUTTYPE**. In the case of container types, **%INTYPE** refers to the
+    full container type (e.g. **"list<int>"**) and **%INTYPE_0**, **%INTYPE_1**,
+    **%INTYPE_#**, should be replaced by the types used in the container template
+    (e.g. **%INTYPE_0** correspondes to **"int"** for **"list<int>"**).
+
+
+.. _target-to-native:
+
+target-to-native
+^^^^^^^^^^^^^^^^
+
+    The **target-to-native** tag encloses at least one, but usually many, conversions
+    from target language values to C++ native values. The *optional* attribute
+    ``replace`` tells if the target language to C++ conversions will be added to, or if
+    they will replace the implicit conversions collected by *ApiExtractor*. The default
+    value for it is *yes*.
+
+
+    .. code-block:: xml
+
+        <conversion-rule>
+            <target-to-native replace='yes|no'>\
+            // List of target to native conversions meant to replace or expand
+            // the already existing implicit conversions.
+            </target-to-native>
+        </conversion-rule>
+
+
+.. _add-conversion:
+
+add-conversion
+^^^^^^^^^^^^^^
+
+    Each **add-conversion** tag adds a rule for conversion of a target language type,
+    indicated by the ``type`` attribute, to the C++ native type represented by the
+    **primitive-type**, a **container-type**, or **value-type**, to which the parent
+    **conversion-rule** belongs.
+
+    .. code-block:: xml
+
+        <target-to-native>
+            <add-conversion type='TARGETTYPE' check='TARGETTYPECHECK(%in)'>
+            // Code to convert target language type object of type TARGETTYPE_A
+            // to the C++ native type represented by the value/primitive/container-type.
+            </add-conversion>
+        <target-to-native>
+
+   The ``check`` attribute tells how a target value should be checked to see if it belongs to
+   the type expected. This attribute is *optional*, for it can be derived from the ``type``
+   attribute, but it isn't unusual that some special check is needed. The variables
+   **%in**, **%out**, **%INTYPE**, **%INTYPE_#**, and **%OUTTYPE**, must be provided by
+   the generator as in the ``native-to-target`` tag.
+
diff --git a/ApiExtractor/doc/typesystem_documentation.rst b/ApiExtractor/doc/typesystem_documentation.rst
new file mode 100644
index 000000000..43f72a1ba
--- /dev/null
+++ b/ApiExtractor/doc/typesystem_documentation.rst
@@ -0,0 +1,43 @@
+Manipulating Documentation
+--------------------------
+
+inject-documentation
+^^^^^^^^^^^^^^^^^^^^
+
+    The inject-documentation node inserts the documentation into the generated
+    documentation. This node is a child of the object-type, value-type and
+    modify-function nodes.
+
+    .. code-block:: xml
+
+         <value-type>
+             <inject-documentation mode="append | prepend | replace" format="native | target" >
+                 // the documentation
+             </inject-code>
+         </value-type>
+
+    The **mode** attribute default value is *replace*.
+
+    The **format** attribute specifies when the documentation injection will
+    occur and it accepts the following values:
+
+        * native: Before XML<->Backend transformation occur, so the injected code *must* be a valid XML.
+        * target: After XML<->Backend transformation occur, so the injected code *must* be a valid backend format.
+
+    At the moment the only supported backend is Sphinx.
+
+modify-documentation
+^^^^^^^^^^^^^^^^^^^^
+
+    The modify-documentation node allows you to change the auto-generated
+    documentation. API Extractor transforms XML's from qdoc3 (the Qt documentation
+    tool) into .rst files to be processed later using Sphinx. So you can modify
+    the XML before the transformation occur.
+
+    .. code-block:: xml
+
+        <modify-documentation xpath="...">
+            <!-- new documentation -->
+        </modify-documentation>
+
+    The **xpath** attribute is the XPath to the node that you want to modify.
diff --git a/ApiExtractor/doc/typesystem_manipulating_objects.rst b/ApiExtractor/doc/typesystem_manipulating_objects.rst
new file mode 100644
index 000000000..2838c95e1
--- /dev/null
+++ b/ApiExtractor/doc/typesystem_manipulating_objects.rst
@@ -0,0 +1,132 @@
+.. _manipulating-object-and-value-types:
+
+Manipulating Object and Value Types
+-----------------------------------
+
+.. _inject-code:
+
+inject-code
+^^^^^^^^^^^
+    The inject-code node inserts the given code into the generated code for the
+    given type or function, and it is a child of the :ref:`object-type`, :ref:`value-type`,
+    :ref:`modify-function` and :ref:`add-function` nodes.
+
+    .. code-block:: xml
+
+         <value-type>
+             <inject-code class="native | target | target-declaration"
+                 position="beginning | end" since="...">
+                 // the code
+             </inject-code>
+         </value-type>
+
+    The ``class`` attribute specifies which module of the generated code that
+    will be affected by the code injection. The ``class`` attribute accepts the
+    following values:
+
+        * native: The c++ code
+        * target: The binding code
+        * target-declaration: The code will be injected into the generated header
+          file containing the c++ wrapper class definition.
+
+    If the ``position`` attribute is set to *beginning* (the default), the code
+    is inserted at the beginning of the function. If it is set to *end*, the code
+    is inserted at the end of the function.
+
+    The ``since`` attribute specify the API version where this code was injected.
+
+modify-field
+^^^^^^^^^^^^
+
+    The modify-field node allows you to alter the access privileges for a given
+    C++ field when mapping it onto the target language, and it is a child of an
+    :ref:`object-type` or a :ref:`value-type` node.
+
+    .. code-block:: xml
+
+         <object-type>
+             <modify-field name="..."
+                 write="true | false"
+                 read="true | false" />
+         </object-type>
+
+    The ``name`` attribute is the name of the field, the *optional* ``write``
+    and ``read`` attributes specify the field's access privileges in the target
+    language API (both are set to true by default).
+    The ``remove`` attribute is an *optional* attribute, which can mark the field
+    to be discarded on generation; it has the same purpose of the deprecated tag
+    :ref:`remove`.
+
+.. _modify-function:
+
+modify-function
+^^^^^^^^^^^^^^^
+
+    The modify-function node allows you to modify a given C++ function when mapping
+    it onto the target language, and it is a child of an :ref:`object-type` or a :ref:`value-type`
+    node. Use the :ref:`modify-argument` node to specify which argument the modification
+    affects.
+
+    .. code-block:: xml
+
+         <object-type>
+             <modify-function signature="..."
+                              since="..."
+                              remove="all | c++"
+                              access="public | private | protected"
+                              rename="..." />
+         </object-type>
+
+    The ``signature`` attribute is a normalized C++ signature, excluding return
+    values but including potential const declarations.
+
+    The ``since`` attribute specify the API version when this function was modified.
+
+    The ``remove``, ``access`` and ``rename`` attributes are *optional* attributes
+    for added convenience; they serve the same purpose as the deprecated tags :ref:`remove`, :ref:`access` and :ref:`rename`.
+
+.. _add-function:
+
+add-function
+^^^^^^^^^^^^
+
+    The add-function node allows you to add a given function onto the target language,
+    and it is a child of an :ref:`object-type` or :ref:`value-type` nodes if the
+    function is suposed to be a method, or :ref:`namespace` and :ref:`typesystem` if
+    the function is suposed to be a function inside a namespace or a global function.
+
+    Typically when adding a function some code must be injected to provide the function
+    logic. This can be done using the :ref:`inject-code` node.
+
+    .. code-block:: xml
+
+         <object-type>
+             <add-function signature="..." return-type="..." access="public | protected" static="yes | no" since="..."/>
+         </object-type>
+
+    The ``return-type`` attribute defaults to *void*, the ``access`` to *public* and the ``static`` one to *no*.
+
+    The ``since`` attribute specify the API version when this function was added.
+
+.. _conversion-rule-on-types:
+
+conversion-rule
+^^^^^^^^^^^^^^^
+
+    The conversion-rule node allows you to write customized code to convert the given argument between the target
+    language and C++, and is a child of the :ref:`value-type`, :ref:`object-type`, :ref:`primitive-type` and
+    :ref:`container-type` nodes.
+
+    The code pointed by the file attribute is very tied to the generator using APIExtractor, so it don't follow any
+    rules, but the generator rules..
+
+    .. code-block:: xml
+
+        <value-type name="Foo">
+            <convertion-rule file="my_converter_implementation.h" since="..."/>
+        </value-type>
+
+    The ``since`` attribute specify the API version when this conversion rule became valid.
+
+    .. note:: You can also use the conversion-rule node to specify :ref:`how the conversion of a single function argument should be done in a function <conversion-rule>`.
+
diff --git a/ApiExtractor/doc/typesystem_modify_function.rst b/ApiExtractor/doc/typesystem_modify_function.rst
new file mode 100644
index 000000000..071cea4f5
--- /dev/null
+++ b/ApiExtractor/doc/typesystem_modify_function.rst
@@ -0,0 +1,78 @@
+.. _modifying-functions:
+
+Modifying Functions
+-------------------
+
+.. _modify-argument:
+
+modify-argument
+^^^^^^^^^^^^^^^
+
+    The modify-argument node specifies which of the given function's arguments the
+    modification affects, and is a child of the modify-function node. Use the
+    remove-argument, replace-default-expression, remove-default-expression,
+    replace-type, reference-count and define-ownership nodes to specify the details
+    of the modification.
+
+    .. code-block:: xml
+
+         <modify-function>
+             <modify-argument index="return | this | 1 ..." >
+                 // modifications
+             </modify-argument>
+         </modify-function>
+
+    Set the ``index`` attribute to "1" for the first argument, "2" for the second
+    one and so on. Alternatively, set it to "return" or "this" if you want to
+    modify the function's return value or the object the function is called upon,
+    respectively.
+
+.. _remove:
+
+remove
+^^^^^^
+
+    The remove node removes the given method from the generated target language
+    API, and it is a child of the modify-function node.
+
+    .. code-block:: xml
+
+         <modify-function>
+             <remove class="all" />
+         </modify-function>
+
+    .. warning:: This tag is deprecated, use the ``remove`` attribute from :ref:`modify-function` tag instead.
+
+.. _access:
+
+access
+^^^^^^
+
+    The access node changes the access privileges of the given function in the
+    generated target language API, and it is a child of the modify-function node.
+
+    .. code-block:: xml
+
+        <modify-function>
+            <access modifier="public | protected | private"/>
+        </modify-function>
+
+    .. warning:: This tag is deprecated, use the ``access`` attribute from :ref:`modify-function` tag instead.
+
+.. _rename:
+
+rename
+^^^^^^
+
+    The rename node changes the name of the given function in the generated target
+    language API, and it is a child of the modify-function node.
+
+    .. code-block:: xml
+
+        <modify-function>
+            <rename to="..." />
+        </modify-function>
+
+    The ``to`` attribute is the new name of the function.
+
+    .. warning:: This tag is deprecated, use the ``rename`` attribute from :ref:`modify-function` tag instead.
diff --git a/ApiExtractor/doc/typesystem_solving_compilation.rst b/ApiExtractor/doc/typesystem_solving_compilation.rst
new file mode 100644
index 000000000..81d14a187
--- /dev/null
+++ b/ApiExtractor/doc/typesystem_solving_compilation.rst
@@ -0,0 +1,70 @@
+Solving compilation problems
+----------------------------
+
+suppress-warning
+^^^^^^^^^^^^^^^^
+
+    The generator will generate several warnings which may be irrelevant to the
+    user. The suppress-warning node suppresses the specified warning, and it is
+    a child of the typesystem node.
+
+    .. code-block:: xml
+
+        <typesystem>
+            <suppress-warning text="..." />
+        </typesystem>
+
+    The **text** attribute is the warning text to suppress, and may contain the *
+    wildcard (use "" to escape regular expression matching if the warning contain
+    a regular "*").
+
+extra-includes
+^^^^^^^^^^^^^^
+
+    The extra-includes node contains declarations of additional include files,
+    and it can be a child of the interface-type, namespace-type, value-type and
+    object-type nodes.
+
+    The generator automatically tries to read the global header for each type but
+    sometimes it is required to include extra files in the generated C++ code to
+    make sure that the code compiles. These files must be listed using include
+    nodes witin the extra-include node:
+
+    .. code-block:: xml
+
+         <value-type>
+             <extra-includes>
+                 <include file-name="..." location="global | local"/>
+             </extra-includes>
+         </value-type>
+
+    The **file-name** attribute is the file to include, such as "QStringList".
+    The **location** attribute is where the file is located: *global* means that
+    the file is located in $INCLUDEPATH and will be included using #include <...>,
+    *local* means that the file is in a local directory and will be included
+    using #include "...".
+
+
+include
+^^^^^^^
+
+    The include node specifies the name and location of a file that must be
+    included, and it is a child of the interface-type, namespace-type, value-type,
+    object-type or extra-includes nodes
+
+    The generator automatically tries to read the global header for each type. Use
+    the include node to override this behavior, providing an alternative file. The
+    include node can also be used to specify extra include files.
+
+    .. code-block:: xml
+
+         <value-type>
+             <include file-name="..."
+                 location="global | local"/>
+         </value-type>
+
+    The **file-name** attribute is the file to include, such as "QStringList".
+    The **location** attribute is where the file is located: *global* means that
+    the file is located in $INCLUDEPATH and will be included using #include <...>,
+    *local* means that the file is in a local directory and will be included
+    using #include "...".
diff --git a/ApiExtractor/doc/typesystem_specifying_types.rst b/ApiExtractor/doc/typesystem_specifying_types.rst
new file mode 100644
index 000000000..0d24a6d52
--- /dev/null
+++ b/ApiExtractor/doc/typesystem_specifying_types.rst
@@ -0,0 +1,371 @@
+Specifying Types
+----------------
+
+.. _typesystem:
+
+typesystem
+^^^^^^^^^^
+
+    This is the root node containing all the type system information. It can
+    have a number of attributes, described below.
+
+    .. code-block:: xml
+
+        <typesystem package="..." default-superclass="...">
+        </typesystem>
+
+    The **package** attribute is a string describing the package to be used,
+    e.g. "QtCore".
+    The *optional* **default-superclass** attribute is the canonical C++ base class
+    name of all objects, e.g., "object".
+
+load-typesystem
+^^^^^^^^^^^^^^^
+
+    The load-typesystem node specifies which type systems to load when mapping
+    multiple libraries to another language or basing one library on another, and
+    it is a child of the typesystem node.
+
+    .. code-block:: xml
+
+        <typesystem>
+            <load-typesystem name="..." generate="yes | no" />
+        </typesystem>
+
+    The **name** attribute is the filename of the typesystem to load, the
+    **generate** attribute specifies whether code should be generated or not. The
+    later must be specified when basing one library on another, making the generator
+    able to understand inheritance hierarchies, primitive mapping, parameter types
+    in functions, etc.
+
+    Most libraries will be based on both the QtCore and QtGui modules, in which
+    case code generation for these libraries will be disabled.
+
+
+rejection
+^^^^^^^^^
+
+    The rejection node rejects the given class, or the specified function or
+    field, and it is a child of the typesystem node.
+
+    .. code-block:: xml
+
+        <typesystem>
+            <rejection class="..."
+                function-name="..."
+                field-name="..." />
+        </typesystem>
+
+    The **class** attribute is the C++ class name of the class to reject. Use the
+    *optional* **function-name** or **field-name** attributes to reject a particular
+    function or field. Note that the **field-name** and **function-name** cannot
+    be specified at the same time. To remove all occurrences of a given field or
+    function, set the class attribute to \*.
+
+.. _primitive-type:
+
+primitive-type
+^^^^^^^^^^^^^^
+
+    The primitive-type node describes how a primitive type is mapped from C++ to
+    the target language, and is a child of the typesystem node. Note that most
+    primitives are already specified in the QtCore typesystem.
+
+    .. code-block:: xml
+
+        <typesystem>
+            <primitive-type name="..."
+                since="..."
+                target-name="..."
+                default-constructor="..."
+                preferred-conversion="yes | no" />
+        </typesystem>
+
+    The **name** attribute is the name of the primitive in C++, the optional,
+    **target-name** attribute is the name of the primitive type in the target
+    language. If the later two attributes are not specified their default value
+    will be the same as the **name** attribute.
+
+    The *optional*  **since** value is used to specify the API version of this type.
+
+    If the *optional* **preferred-conversion** attribute is set to *no*, it
+    indicates that this version of the primitive type is not the preferred C++
+    equivalent of the target language type. For example, in Python both "qint64"
+    and "long long" become "long" but we should prefer the "qint64" version. For
+    this reason we mark "long long" with preferred-conversion="no".
+
+    The *optional* **default-constructor** specifies the minimal constructor
+    call to build one value of the primitive-type. This is not needed when the
+    primitive-type may be built with a default constructor (the one without
+    arguments).
+
+    The *optional* **preferred-conversion** attribute tells how to build a default
+    instance of the primitive type. It should be a constructor call capable of
+    creating a instance of the primitive type. Example: a class "Foo" could have
+    a **preferred-conversion** value set to "Foo()". Usually this attribute is
+    used only for classes declared as primitive types and not for primitive C++
+    types, but that depends on the application using *ApiExtractor*.
+
+
+.. _namespace:
+
+namespace-type
+^^^^^^^^^^^^^^
+
+    The namespace-type node maps the given C++ namespace to the target language,
+    and it is a child of the typesystem node. Note that within namespaces, the
+    generator only supports enums (i.e., no functions or classes).
+
+    .. code-block:: xml
+
+        <typesystem>
+            <namespace-type name="..."
+                generate="yes | no"
+                package="..."
+                since="..."
+                revision="..." />
+        </typesystem>
+
+    The **name** attribute is the name of the namespace, e.g., "Qt".
+
+    The *optional* **generate** attribute is used to inform if you need to prepend
+    the given namespace into each generated class. Its default value is **yes**.
+
+    The **package** attribute can be used to override the package of the type system.
+
+    The *optional*  **since** value is used to specify the API version of this type.
+
+    The **revision** attribute can be used to specify a revision for each type, easing the
+    production of ABI compatible bindings.
+
+enum-type
+^^^^^^^^^
+
+    The enum-type node maps the given enum from C++ to the target language,
+    and it is a child of the typesystem node. Use the reject-enum-value to
+    reject values.
+
+    .. code-block:: xml
+
+        <typesystem>
+            <enum-type name="..."
+                identified-by-value="..."
+                since="..."
+                flags="yes | no"
+                flags-revision="..."
+                lower-bound="..."
+                upper-bound="..."
+                force-integer="yes | no"
+                extensible="yes | no"
+                revision="..." />
+        </typesystem>
+
+    The **name** attribute is the fully qualified C++ name of the enum
+    (e.g.,"Qt::FillRule"). If the *optional* **flags** attribute is set to *yes*
+    (the default is *no*), the generator will expect an existing QFlags<T> for the
+    given enum type. The **lower-bound** and **upper-bound** attributes are used
+    to specify runtime bounds checking for the enum value. The value must be a
+    compilable target language statement, such as "QGradient.Spread.PadSpread"
+    (taking again Python as an example). If the **force-integer** attribute is
+    set to *yes* (the default is *no*), the generated target language code will
+    use the target language integers instead of enums. And finally, the
+    **extensible** attribute specifies whether the given enum can be extended
+    with user values (the default is *no*).
+
+    The *optional*  **since** value is used to specify the API version of this type.
+
+    The attribute **identified-by-value** helps to specify anonymous enums using the
+    name of one of their values, which is unique for the anonymous enum scope.
+    Notice that the **enum-type** tag can either have **name** or **identified-by-value**
+    but not both.
+
+    The **revision** attribute can be used to specify a revision for each type, easing the
+    production of ABI compatible bindings.
+
+    The **flags-revision** attribute has the same purposes of **revision** attribute but
+    is used for the QFlag related to this enum.
+
+
+reject-enum-value
+^^^^^^^^^^^^^^^^^
+
+    The reject-enum-value node rejects the enum value specified by the **name**
+    attribute, and it is a child of the enum-type node.
+
+    .. code-block:: xml
+
+         <enum-type>
+             <reject-enum-value name="..."/>
+         </enum-type>
+
+    This node is used when a C++ enum implementation has several identical numeric
+    values, some of which are typically obsolete.
+
+.. _value-type:
+
+value-type
+^^^^^^^^^^
+
+    The value-type node indicates that the given C++ type is mapped onto the target
+    language as a value type. This means that it is an object passed by value on C++,
+    i.e. it is stored in the function call stack. It is a child of the :ref:`typesystem` node.
+
+    .. code-block:: xml
+
+        <typesystem>
+            <value-type  name="..." since="..."
+             copyable="yes | no"
+             hash-function="..."
+             stream="yes | no"
+             default-constructor="..."
+             revision="..." />
+        </typesystem>
+
+    The **name** attribute is the fully qualified C++ class name, such as
+    "QMatrix" or "QPainterPath::Element". The **copyable** attribute is used to
+    force or not specify if this type is copyable. The *optional* **hash-function**
+    attribute informs the function name of a hash function for the type.
+
+    The *optional* attribute **stream** specifies whether this type will be able to
+    use externally defined operators, like QDataStream << and >>. If equals to **yes**,
+    these operators will be called as normal methods within the current class.
+
+    The *optional*  **since** value is used to specify the API version of this type.
+
+    The *optional* **default-constructor** specifies the minimal constructor
+    call to build one instance of the value-type. This is not needed when the
+    value-type may be built with a default constructor (the one without arguments).
+    Usually a code generator may guess a minimal constructor for a value-type based
+    on its constructor signatures, thus **default-constructor** is used only in
+    very odd cases.
+
+    The **revision** attribute can be used to specify a revision for each type, easing the
+    production of ABI compatible bindings.
+
+.. _object-type:
+
+object-type
+^^^^^^^^^^^
+
+    The object-type node indicates that the given C++ type is mapped onto the target
+    language as an object type. This means that it is an object passed by pointer on
+    C++ and it is stored on the heap. It is a child of the :ref:`typesystem` node.
+
+    .. code-block:: xml
+
+        <typesystem>
+            <object-type name="..."
+             since="..."
+             copyable="yes | no"
+             hash-function="..."
+             stream="yes | no"
+             revision="..." />
+        </typesystem>
+
+    The **name** attribute is the fully qualified C++ class name. If there is no
+    C++ base class, the default-superclass attribute can be used to specify a
+    superclass for the given type, in the generated target language API. The
+    **copyable** and **hash-function** attributes are the same as described for
+    :ref:`value-type`.
+
+    The *optional* attribute **stream** specifies whether this type will be able to
+    use externally defined operators, like QDataStream << and >>. If equals to **yes**,
+    these operators will be called as normal methods within the current class.
+
+    The *optional*  **since** value is used to specify the API version of this type.
+
+    The **revision** attribute can be used to specify a revision for each type, easing the
+    production of ABI compatible bindings.
+
+interface-type
+^^^^^^^^^^^^^^
+
+    The interface-type node indicates that the given class is replaced by an
+    interface pattern when mapping from C++ to the target language. Using the
+    interface-type node implicitly makes the given type an :ref:`object-type`.
+
+    .. code-block:: xml
+
+        <typesystem>
+            <interface-type name="..."
+                since="..."
+                package ="..."
+                default-superclass ="..."
+                revision="..." />
+        </typesystem>
+
+    The **name** attribute is the fully qualified C++ class name. The *optional*
+    **package** attribute can be used to override the package of the type system.
+    If there is no C++ base class, the *optional* **default-superclass** attribute
+    can be used to specify a superclass in the generated target language API, for
+    the given class.
+
+    The *optional*  **since** value is used to specify the API version of this interface.
+
+    The **revision** attribute can be used to specify a revision for each type, easing the
+    production of ABI compatible bindings.
+
+.. _container-type:
+
+container-type
+^^^^^^^^^^^^^^
+
+    The container-type node indicates that the given class is a container and
+    must be handled using one of the conversion helpers provided by attribute **type**.
+
+    .. code-block:: xml
+
+        <typesystem>
+            <container-type name="..."
+                since="..."
+                type ="..." />
+        </typesystem>
+
+    The **name** attribute is the fully qualified C++ class name. The **type**
+    attribute is used to indicate what conversion rule will be applied to the
+    container. It can be: *list*, *string-list*, *linked-list*, *vector*, *stack*,
+    *queue*, *set*, *map*, *multi-map*, *hash*, *multi-hash* or *pair*.
+
+    The *optional*  **since** value is used to specify the API version of this container.
+
+
+.. _custom-type:
+
+custom-type
+^^^^^^^^^^^
+
+    The custom-type node simply makes the parser aware of the existence of a target
+    language type, thus avoiding errors when trying to find a type used in function
+    signatures and other places. The proper handling of the custom type is meant to
+    be done by a generator using the APIExractor.
+
+    .. code-block:: xml
+
+        <typesystem>
+            <custom-type name="..." />
+        </typesystem>
+
+    The **name** attribute is the name of the custom type, e.g., "PyObject".
+
+
+.. _function:
+
+function
+^^^^^^^^
+
+    The function node indicates that the given C++ global function is mapped onto
+    the target language.
+
+    .. code-block:: xml
+
+        <typesystem>
+            <function signature="..." rename="..." since="..."/>
+        </typesystem>
+
+    This tag has some limitations, it doesn't support function modifications, besides you
+    can't add a function overload using :ref:`add-function` tag to an existent function.
+    These limitation will be addressed in future versions of ApiExtractor.
+
+    The function tag has two *optional* attributes: **since**, whose value is used to specify
+    the API version of this function, and **rename**, to modify the function name.
+
diff --git a/ApiExtractor/doc/typesystem_templates.rst b/ApiExtractor/doc/typesystem_templates.rst
new file mode 100644
index 000000000..31b155c5a
--- /dev/null
+++ b/ApiExtractor/doc/typesystem_templates.rst
@@ -0,0 +1,55 @@
+.. _using-code-templates:
+
+Using Code Templates
+--------------------
+
+template
+^^^^^^^^
+
+    The template node registers a template that can be used to avoid duplicate
+    code when extending the generated code, and it is a child of the typesystem
+    node.
+
+    .. code-block:: xml
+
+        <typesystem>
+            <template name="my_template">
+                // the code
+            </template>
+        </typesystem>
+
+    Use the insert-template node to insert the template code (identified by the
+    template's ``name`` attribute) into the generated code base.
+
+
+insert-template
+^^^^^^^^^^^^^^^
+
+    The insert-template node includes the code template identified by the name
+    attribute, and it can be a child of the inject-code, conversion-rule, template,
+    custom-constructor and custom-destructor nodes.
+
+    .. code-block:: xml
+
+         <inject-code class="target" position="beginning">
+             <insert-template name="my_template" />
+         </inject-code>
+
+    Use the replace node to modify the template code.
+
+
+replace
+^^^^^^^
+
+    The replace node allows you to modify template code before inserting it into
+    the generated code, and it can be a child of the insert-template node.
+
+    .. code-block:: xml
+
+        <insert-template name="my_template">
+           <replace from="..." to="..." />
+        </insert-template>
+
+    This node will replace the attribute ``from`` with the value pointed by
+    ``to``.
+
diff --git a/ApiExtractor/docparser.cpp b/ApiExtractor/docparser.cpp
new file mode 100644
index 000000000..d6e8bf468
--- /dev/null
+++ b/ApiExtractor/docparser.cpp
@@ -0,0 +1,164 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+#include "docparser.h"
+#include <QtCore/QDebug>
+#include <QtXmlPatterns/QXmlQuery>
+#include <QBuffer>
+
+#include <cstdlib>
+#include <libxslt/xsltutils.h>
+#include <libxslt/transform.h>
+
+DocParser::DocParser()
+{
+    xmlSubstituteEntitiesDefault(1);
+}
+
+DocParser::~DocParser()
+{
+}
+
+QString DocParser::getDocumentation(QXmlQuery& xquery, const QString& query,
+                                    const DocModificationList& mods) const
+{
+    QString doc = execXQuery(xquery, query);
+    return applyDocModifications(mods, doc);
+}
+
+QString DocParser::execXQuery(QXmlQuery& xquery, const QString& query) const
+{
+    QString escapedQuery(query);
+    // XQuery can't have invalid XML characters
+    escapedQuery.replace("&", "&amp;").replace("<", "&lt;");
+    xquery.setQuery(escapedQuery);
+    if (!xquery.isValid()) {
+        qWarning() << "Bad XQuery: " << escapedQuery;
+        return QString();
+    }
+
+    QString result;
+    xquery.evaluateTo(&result);
+    return result;
+}
+
+namespace
+{
+
+struct XslResources
+{
+    xmlDocPtr xmlDoc;
+    xsltStylesheetPtr xslt;
+    xmlDocPtr xslResult;
+
+    XslResources() : xmlDoc(0), xslt(0), xslResult(0) {}
+
+    ~XslResources()
+    {
+        if (xslt)
+            xsltFreeStylesheet(xslt);
+
+        if (xslResult)
+            xmlFreeDoc(xslResult);
+
+        if (xmlDoc)
+            xmlFreeDoc(xmlDoc);
+
+        xsltCleanupGlobals();
+        xmlCleanupParser();
+    }
+};
+
+} // namespace
+
+QString DocParser::applyDocModifications(const DocModificationList& mods, const QString& xml) const
+{
+    if (mods.isEmpty())
+        return xml;
+
+    bool hasXPathBasedModification = false;
+    foreach (DocModification mod, mods) {
+        if (mod.mode() == DocModification::XPathReplace) {
+            hasXPathBasedModification = true;
+            break;
+        }
+    }
+
+    if (!hasXPathBasedModification)
+        return xml;
+
+    QString xsl = QLatin1String("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"
+                                "<xsl:transform version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\">\n"
+                                "<xsl:template match=\"/\">\n"
+                                "    <xsl:apply-templates />\n"
+                                "</xsl:template>\n"
+                                "<xsl:template match=\"*\">\n"
+                                "<xsl:copy>\n"
+                                "    <xsl:copy-of select=\"@*\"/>\n"
+                                "    <xsl:apply-templates/>\n"
+                                "</xsl:copy>\n"
+                                "</xsl:template>\n"
+                               );
+    foreach (DocModification mod, mods) {
+        if (mod.mode() == DocModification::XPathReplace) {
+            xsl += QLatin1String("<xsl:template match=\"")
+                   + mod.xpath().replace("\"", "&quot;") + QLatin1String("\">")
+                   + mod.code() + QLatin1String("</xsl:template>\n");
+        }
+    }
+    xsl += QLatin1String("</xsl:transform>");
+
+    XslResources res;
+    // Read XML data
+    QByteArray xmlData = xml.toUtf8();
+    res.xmlDoc = xmlParseMemory(xmlData.constData(), xmlData.size());
+    if (!res.xmlDoc)
+        return xml;
+
+    // Read XSL data as a XML file
+    QByteArray xslData = xsl.toUtf8();
+    // xsltFreeStylesheet will delete this pointer
+    xmlDocPtr xslDoc = xmlParseMemory(xslData.constData(), xslData.size());
+    if (!xslDoc)
+        return xml;
+
+    // Parse XSL data
+    res.xslt = xsltParseStylesheetDoc(xslDoc);
+    if (!res.xslt)
+        return xml;
+
+    // Apply XSL
+    res.xslResult = xsltApplyStylesheet(res.xslt, res.xmlDoc, 0);
+    xmlChar* buffer = 0;
+    int bufferSize;
+    QString result;
+    if (!xsltSaveResultToString(&buffer, &bufferSize, res.xslResult, res.xslt)) {
+        result = QString::fromUtf8(reinterpret_cast<char*>(buffer), bufferSize);
+        std::free(buffer);
+    } else {
+        result = xml;
+    }
+
+    Q_ASSERT(result != xml);
+    return result;
+}
+
diff --git a/ApiExtractor/docparser.h b/ApiExtractor/docparser.h
new file mode 100644
index 000000000..6764333be
--- /dev/null
+++ b/ApiExtractor/docparser.h
@@ -0,0 +1,117 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+#ifndef DOCPARSER_H
+#define DOCPARSER_H
+
+#include <QString>
+#include <QDir>
+
+#include "abstractmetalang.h"
+
+class QDomDocument;
+class QDomNode;
+class QXmlQuery;
+
+class APIEXTRACTOR_API DocParser
+{
+public:
+    DocParser();
+    virtual ~DocParser();
+    virtual void fillDocumentation(AbstractMetaClass* metaClass) = 0;
+
+    /**
+     *   Process and retrieves documentation concerning the entire
+     *   module or library.
+     *   \return object containing module/library documentation information
+     */
+    virtual Documentation retrieveModuleDocumentation() = 0;
+
+    void setDocumentationDataDirectory(const QString& dir)
+    {
+        m_docDataDir = dir;
+    }
+
+    /**
+     *   Informs the location of the XML data generated by the tool
+     *   (e.g.: DoxyGen, qdoc) used to extract the library's documentation
+     *   comment.
+     *   \return the path for the directory containing the XML data created
+     *   from the library's documentation beign parsed.
+     */
+    QString documentationDataDirectory() const
+    {
+        return m_docDataDir;
+    }
+
+    void setLibrarySourceDirectory(const QString& dir)
+    {
+        m_libSourceDir = dir;
+    }
+    /**
+     *   Informs the location of the library being parsed. The library
+     *   source code is parsed for the documentation comments.
+     *   \return the path for the directory containing the source code of
+     *   the library beign parsed.
+     */
+    QString librarySourceDirectory() const
+    {
+        return m_libSourceDir;
+    }
+
+    void setPackageName(const QString& packageName)
+    {
+        m_packageName = packageName;
+    }
+    /**
+     *   Retrieves the name of the package (or module or library) being parsed.
+     *   \return the name of the package (module/library) being parsed
+     */
+    QString packageName() const
+    {
+        return m_packageName;
+    }
+
+    /**
+    *   Process and retrieves documentation concerning the entire
+    *   module or library.
+    *   \param name module name
+    *   \return object containing module/library documentation information
+    *   \todo Merge with retrieveModuleDocumentation() on next ABI change.
+    */
+    virtual Documentation retrieveModuleDocumentation(const QString& name) = 0;
+
+protected:
+    QString getDocumentation(QXmlQuery& xquery, const QString& query,
+                             const DocModificationList& mods) const;
+
+private:
+    QString m_packageName;
+    QString m_docDataDir;
+    QString m_libSourceDir;
+
+    QString execXQuery(QXmlQuery& xquery, const QString& query) const;
+    QString applyDocModifications(const DocModificationList& mods, const QString& xml) const;
+};
+
+#endif // DOCPARSER_H
+
diff --git a/ApiExtractor/doxygenparser.cpp b/ApiExtractor/doxygenparser.cpp
new file mode 100644
index 000000000..09cdd3865
--- /dev/null
+++ b/ApiExtractor/doxygenparser.cpp
@@ -0,0 +1,185 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "doxygenparser.h"
+#include "abstractmetalang.h"
+#include "reporthandler.h"
+
+#include <QtXmlPatterns/QXmlQuery>
+
+namespace
+{
+
+QString getSectionKindAttr(const AbstractMetaFunction* func)
+{
+    if (func->isSignal()) {
+        return QLatin1String("signal");
+    } else {
+        QString kind = func->isPublic() ? QLatin1String("public") : QLatin1String("protected");
+        if (func->isStatic())
+            kind += QLatin1String("-static");
+        else if (func->isSlot())
+            kind += QLatin1String("-slot");
+        return kind;
+    }
+}
+
+}
+
+Documentation DoxygenParser::retrieveModuleDocumentation()
+{
+        return retrieveModuleDocumentation(packageName());
+}
+
+void DoxygenParser::fillDocumentation(AbstractMetaClass* metaClass)
+{
+    if (!metaClass)
+        return;
+
+    QString doxyFileSuffix;
+    if (metaClass->enclosingClass()) {
+        doxyFileSuffix += metaClass->enclosingClass()->name();
+        doxyFileSuffix += "_1_1"; // FIXME: Check why _1_1!!
+    }
+    doxyFileSuffix += metaClass->name();
+    doxyFileSuffix += ".xml";
+
+    const char* prefixes[] = { "class", "struct", "namespace" };
+    const int numPrefixes = sizeof(prefixes) / sizeof(const char*);
+    bool isProperty = false;
+
+    QString doxyFilePath;
+    for (int i = 0; i < numPrefixes; ++i) {
+        doxyFilePath = documentationDataDirectory() + "/" + prefixes[i] + doxyFileSuffix;
+        if (QFile::exists(doxyFilePath))
+            break;
+        doxyFilePath.clear();
+    }
+
+    if (doxyFilePath.isEmpty()) {
+        ReportHandler::warning("Can't find doxygen file for class "
+                               + metaClass->name() + ", tried: "
+                               + documentationDataDirectory() + "/{struct|class|namespace}"
+                               + doxyFileSuffix);
+        return;
+    }
+    QXmlQuery xquery;
+    xquery.setFocus(QUrl(doxyFilePath));
+
+    // Get class documentation
+    QString classDoc = getDocumentation(xquery, "/doxygen/compounddef/detaileddescription",
+                                        metaClass->typeEntry()->docModifications());
+    if (classDoc.isEmpty()) {
+        ReportHandler::warning("Can't find documentation for class \""
+                               + metaClass->name() + "\".");
+    }
+    metaClass->setDocumentation(classDoc);
+
+    //Functions Documentation
+    AbstractMetaFunctionList funcs = metaClass->functionsInTargetLang();
+    foreach (AbstractMetaFunction *func, funcs) {
+        if (!func || func->isPrivate())
+            continue;
+
+        QString query = "/doxygen/compounddef/sectiondef";
+        // properties
+        if (func->isPropertyReader() || func->isPropertyWriter()
+            || func->isPropertyResetter()) {
+            query += "[@kind=\"property\"]/memberdef/name[text()=\""
+                     + func->propertySpec()->name() + "\"]";
+            isProperty = true;
+        } else { // normal methods
+            QString kind = getSectionKindAttr(func);
+            query += "[@kind=\"" + kind + "-func\"]/memberdef/name[text()=\""
+                     + func->originalName() + "\"]";
+
+            if (func->arguments().isEmpty()) {
+                QString args = func->isConstant() ? "() const " : "()";
+                query += "/../argsstring[text()=\"" + args + "\"]";
+            } else {
+                int i = 1;
+                foreach (AbstractMetaArgument* arg, func->arguments()) {
+                    QString type;
+                    if (!arg->type()->isPrimitive()) {
+                        query += "/../param[" + QString::number(i) + "]/type/ref[text()=\""
+                                 + arg->type()->name() + "\"]/../..";
+                    } else {
+                        query += "/../param[" + QString::number(i) + "]/type[text()=\""
+                                 + arg->type()->name() + "\"]/..";
+                    }
+                    ++i;
+                }
+            }
+        }
+        if (!isProperty) {
+            query += "/../detaileddescription";
+        } else {
+            query = "(" + query;
+            query += "/../detaileddescription)[1]";
+        }
+        QString doc = getDocumentation(xquery, query, DocModificationList());
+        func->setDocumentation(doc);
+        isProperty = false;
+    }
+
+    //Fields
+    AbstractMetaFieldList fields = metaClass->fields();
+    foreach (AbstractMetaField *field, fields) {
+        if (field->isPrivate())
+            return;
+
+        QString query = "/doxygen/compounddef/sectiondef/memberdef/name[text()=\""
+                        + field->name() + "\"]/../detaileddescription";
+        QString doc = getDocumentation(xquery, query, DocModificationList());
+        field->setDocumentation(doc);
+    }
+
+    //Enums
+    AbstractMetaEnumList enums = metaClass->enums();
+    foreach (AbstractMetaEnum *meta_enum, enums) {
+        QString query = "/doxygen/compounddef/sectiondef/memberdef[@kind=\"enum\"]/name[text()=\"" + meta_enum->name() + "\"]/..";
+        QString doc = getDocumentation(xquery, query, DocModificationList());
+        meta_enum->setDocumentation(doc);
+    }
+
+}
+
+Documentation DoxygenParser::retrieveModuleDocumentation(const QString& name){
+
+    QString sourceFile = documentationDataDirectory() + '/' + "indexpage.xml";
+
+    if (!QFile::exists(sourceFile)) {
+        ReportHandler::warning("Can't find doxygen XML file for module "
+                               + name + ", tried: "
+                                                 + sourceFile);
+        return Documentation();
+    }
+
+    QXmlQuery xquery;
+    xquery.setFocus(QUrl(sourceFile));
+
+    // Module documentation
+    QString query = "/doxygen/compounddef/detaileddescription";
+    return Documentation(getDocumentation(xquery, query, DocModificationList()));
+}
+
diff --git a/ApiExtractor/doxygenparser.h b/ApiExtractor/doxygenparser.h
new file mode 100644
index 000000000..1150f7ff7
--- /dev/null
+++ b/ApiExtractor/doxygenparser.h
@@ -0,0 +1,38 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef DOXYGENPARSER_H
+#define DOXYGENPARSER_H
+
+#include "docparser.h"
+
+class APIEXTRACTOR_API DoxygenParser : public DocParser
+{
+public:
+    DoxygenParser()  {}
+    virtual void fillDocumentation(AbstractMetaClass *metaClass);
+    virtual Documentation retrieveModuleDocumentation();
+    virtual Documentation retrieveModuleDocumentation(const QString& name);
+};
+
+#endif // DOXYGENPARSER_H
diff --git a/ApiExtractor/fileout.cpp b/ApiExtractor/fileout.cpp
new file mode 100644
index 000000000..7beb74dcf
--- /dev/null
+++ b/ApiExtractor/fileout.cpp
@@ -0,0 +1,221 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "fileout.h"
+#include "reporthandler.h"
+
+#include <QtCore/QTextCodec>
+#include <QtCore/QFileInfo>
+#include <QtCore/QDir>
+
+#include <cstdio>
+
+bool FileOut::dummy = false;
+bool FileOut::diff = false;
+
+#ifdef Q_OS_LINUX
+const char* colorDelete = "\033[31m";
+const char* colorAdd = "\033[32m";
+const char* colorInfo = "\033[36m";
+const char* colorReset = "\033[0m";
+#else
+const char* colorDelete = "";
+const char* colorAdd = "";
+const char* colorInfo = "";
+const char* colorReset = "";
+#endif
+
+FileOut::FileOut(QString n):
+        name(n),
+        stream(&tmp),
+        isDone(false)
+{}
+
+static int* lcsLength(QList<QByteArray> a, QList<QByteArray> b)
+{
+    const int height = a.size() + 1;
+    const int width = b.size() + 1;
+
+    int *res = new int[width * height];
+
+    for (int row = 0; row < height; row++)
+        res[width * row] = 0;
+
+    for (int col = 0; col < width; col++)
+        res[col] = 0;
+
+    for (int row = 1; row < height; row++) {
+        for (int col = 1; col < width; col++) {
+            if (a[row-1] == b[col-1])
+                res[width * row + col] = res[width * (row-1) + col-1] + 1;
+            else
+                res[width * row + col] = qMax(res[width * row     + col-1],
+                                              res[width * (row-1) + col]);
+        }
+    }
+    return res;
+}
+
+enum Type {
+    Add,
+    Delete,
+    Unchanged
+};
+
+struct Unit
+{
+    Unit(Type type, int pos) :
+            type(type),
+            start(pos),
+            end(pos) {}
+
+    Type type;
+    int start;
+    int end;
+
+    void print(QList<QByteArray> a, QList<QByteArray> b)
+    {
+            if (type == Unchanged) {
+                if ((end - start) > 9) {
+                    for (int i = start; i <= start + 2; i++)
+                        std::printf("  %s\n", a[i].data());
+                    std::printf("%s=\n= %d more lines\n=%s\n", colorInfo, end - start - 6, colorReset);
+                    for (int i = end - 2; i <= end; i++)
+                        std::printf("  %s\n", a[i].data());
+                } else {
+                    for (int i = start; i <= end; i++)
+                        std::printf("  %s\n", a[i].data());
+                }
+            } else if (type == Add) {
+                std::printf("%s", colorAdd);
+                for (int i = start; i <= end; i++)
+                    std::printf("+ %s\n", b[i].data());
+                std::printf("%s", colorReset);
+            } else if (type == Delete) {
+                std::printf("%s", colorDelete);
+                for (int i = start; i <= end; i++)
+                    std::printf("- %s\n", a[i].data());
+                std::printf("%s", colorReset);
+            }
+    }
+};
+
+static QList<Unit*> *unitAppend(QList<Unit*> *res, Type type, int pos)
+{
+    if (!res) {
+        res = new QList<Unit*>;
+        res->append(new Unit(type, pos));
+        return res;
+    }
+
+    Unit *last = res->last();
+    if (last->type == type)
+        last->end = pos;
+    else
+        res->append(new Unit(type, pos));
+
+    return res;
+}
+
+static QList<Unit*> *diffHelper(int *lcs, QList<QByteArray> a, QList<QByteArray> b, int row, int col)
+{
+    if (row > 0 && col > 0 && (a[row-1] == b[col-1])) {
+        return unitAppend(diffHelper(lcs, a, b, row - 1, col - 1), Unchanged, row - 1);
+    } else {
+        int width = b.size() + 1;
+        if ((col > 0)
+            && (row == 0 || lcs[width * row + col-1] >= lcs[width *(row-1) + col])) {
+            return unitAppend(diffHelper(lcs, a, b, row, col - 1), Add, col - 1);
+        } else if ((row > 0)
+            && (col == 0 || lcs[width * row + col-1] < lcs[width *(row-1) + col])) {
+            return unitAppend(diffHelper(lcs, a, b, row - 1, col), Delete, row - 1);
+        }
+    }
+    delete lcs;
+    return 0;
+}
+
+static void diff(QList<QByteArray> a, QList<QByteArray> b)
+{
+    QList<Unit*> *res = diffHelper(lcsLength(a, b), a, b, a.size(), b.size());
+    for (int i = 0; i < res->size(); i++) {
+        Unit *unit = res->at(i);
+        unit->print(a, b);
+        delete(unit);
+    }
+    delete(res);
+}
+
+
+bool FileOut::done()
+{
+    Q_ASSERT(!isDone);
+    if (name.isEmpty())
+        return false;
+
+    isDone = true;
+    bool fileEqual = false;
+    QFile fileRead(name);
+    QFileInfo info(fileRead);
+    stream.flush();
+    QByteArray original;
+    if (info.exists() && (diff || (info.size() == tmp.size()))) {
+        if (!fileRead.open(QIODevice::ReadOnly)) {
+            ReportHandler::warning(QString("failed to open file '%1' for reading")
+                                   .arg(fileRead.fileName()));
+            return false;
+        }
+
+        original = fileRead.readAll();
+        fileRead.close();
+        fileEqual = (original == tmp);
+    }
+
+    if (!fileEqual) {
+        if (!FileOut::dummy) {
+            QDir dir(info.absolutePath());
+            if (!dir.mkpath(dir.absolutePath())) {
+                ReportHandler::warning(QString("unable to create directory '%1'")
+                                       .arg(dir.absolutePath()));
+                return false;
+            }
+
+            QFile fileWrite(name);
+            if (!fileWrite.open(QIODevice::WriteOnly)) {
+                ReportHandler::warning(QString("failed to open file '%1' for writing")
+                                       .arg(fileWrite.fileName()));
+                return false;
+            }
+            QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
+            stream.setDevice(&fileWrite);
+            stream << tmp;
+        }
+        if (diff) {
+            std::printf("%sFile: %s%s\n", colorInfo, qPrintable(name), colorReset);
+            ::diff(original.split('\n'), tmp.split('\n'));
+            std::printf("\n");
+        }
+        return true;
+    }
+    return false;
+}
diff --git a/ApiExtractor/fileout.h b/ApiExtractor/fileout.h
new file mode 100644
index 000000000..1429b3365
--- /dev/null
+++ b/ApiExtractor/fileout.h
@@ -0,0 +1,57 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef FILEOUT_H
+#define FILEOUT_H
+
+#include <QtCore/QObject>
+#include <QtCore/QFile>
+#include <QtCore/QTextStream>
+#include "apiextractormacros.h"
+
+class APIEXTRACTOR_API FileOut : public QObject
+{
+private:
+    QByteArray tmp;
+    QString name;
+
+public:
+    FileOut(QString name);
+    ~FileOut()
+    {
+        if (!isDone)
+            done();
+    }
+
+    bool done();
+
+    QTextStream stream;
+
+    static bool dummy;
+    static bool diff;
+
+private:
+    bool isDone;
+};
+
+#endif // FILEOUT_H
diff --git a/ApiExtractor/generator.qrc b/ApiExtractor/generator.qrc
new file mode 100644
index 000000000..2d82b37cb
--- /dev/null
+++ b/ApiExtractor/generator.qrc
@@ -0,0 +1,5 @@
+<!DOCTYPE RCC><RCC version="1.0">
+<qresource prefix="/trolltech/generator/">
+<file alias="pp-qt-configuration">parser/rpp/pp-qt-configuration</file>
+</qresource>
+</RCC>
diff --git a/ApiExtractor/graph.cpp b/ApiExtractor/graph.cpp
new file mode 100644
index 000000000..c985449c1
--- /dev/null
+++ b/ApiExtractor/graph.cpp
@@ -0,0 +1,130 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "graph.h"
+#include <QVector>
+#include <QDebug>
+#include <QLinkedList>
+#include <QSet>
+#include <iterator>
+#include <algorithm>
+#include <iostream>
+#include <QFile>
+
+struct Graph::GraphPrivate
+{
+    enum Color { WHITE, GRAY, BLACK };
+    typedef QVector<QSet<int> > Edges;
+    typedef QSet<int>::const_iterator EdgeIterator;
+
+    Edges edges;
+
+    GraphPrivate(int numNodes) : edges(numNodes)
+    {
+    }
+
+    void dfsVisit(int node, QLinkedList<int>& result, QVector<Color>& colors) const
+    {
+        colors[node] = GRAY;
+        EdgeIterator it = edges[node].begin();
+        for (; it != edges[node].end(); ++it) {
+            if (colors[*it] == WHITE)
+                dfsVisit(*it, result, colors);
+            else if (colors[*it] == GRAY) // This is not a DAG!
+                return;
+        }
+        colors[node] = BLACK;
+        result.push_front(node);
+    }
+};
+
+Graph::Graph(int numNodes) : m_d(new GraphPrivate(numNodes))
+{
+}
+
+Graph::~Graph()
+{
+    delete m_d;
+}
+
+int Graph::nodeCount() const
+{
+    return m_d->edges.size();
+}
+
+QLinkedList<int> Graph::topologicalSort() const
+{
+    int nodeCount = Graph::nodeCount();
+    QLinkedList<int> result;
+    QVector<GraphPrivate::Color> colors(nodeCount, GraphPrivate::WHITE);
+
+    for (int i = 0; i < nodeCount; ++i) {
+        if (colors[i] == GraphPrivate::WHITE)
+            m_d->dfsVisit(i, result, colors);
+    }
+
+    // Not a DAG!
+    if (result.size() != nodeCount)
+        return QLinkedList<int>();
+    return result;
+}
+
+bool Graph::containsEdge(int from, int to)
+{
+    return m_d->edges[from].contains(to);
+}
+
+void Graph::addEdge(int from, int to)
+{
+    Q_ASSERT(to < (int)m_d->edges.size());
+    m_d->edges[from].insert(to);
+}
+
+void Graph::removeEdge(int from, int to)
+{
+    m_d->edges[from].remove(to);
+}
+
+void Graph::dump() const
+{
+    for (int i = 0; i < m_d->edges.size(); ++i) {
+        std::cout << i << " -> ";
+        std::copy(m_d->edges[i].begin(), m_d->edges[i].end(), std::ostream_iterator<int>(std::cout, " "));
+        std::cout << std::endl;
+    }
+}
+
+void Graph::dumpDot(const QHash< int, QString >& nodeNames, const QString& fileName) const
+{
+    QFile output(fileName);
+    if (!output.open(QIODevice::WriteOnly))
+        return;
+    QTextStream s(&output);
+    s << "digraph D {\n";
+    for (int i = 0; i < m_d->edges.size(); ++i) {
+        GraphPrivate::EdgeIterator it = m_d->edges[i].begin();
+        for (;it != m_d->edges[i].end(); ++it)
+            s << '"' << nodeNames[i] << "\" -> \"" << nodeNames[*it] << "\"\n";
+    }
+    s << "}\n";
+}
diff --git a/ApiExtractor/graph.h b/ApiExtractor/graph.h
new file mode 100644
index 000000000..d3a754e98
--- /dev/null
+++ b/ApiExtractor/graph.h
@@ -0,0 +1,68 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef GRAPH_H
+#define GRAPH_H
+
+#include <QLinkedList>
+#include <QHash>
+#include <QString>
+#include "apiextractormacros.h"
+
+/// A graph that can have their nodes topologically sorted.
+class APIEXTRACTOR_API Graph
+{
+public:
+    /// Create a new graph with \p numNodes nodes.
+    Graph(int numNodes);
+    ~Graph();
+
+    /// Returns the numbed of nodes in this graph.
+    int nodeCount() const;
+    /// Returns true if the graph contains the edge from -> to
+    bool containsEdge(int from, int to);
+    /// Adds an edge to this graph.
+    void addEdge(int from, int to);
+    /// Removes an edge out of this graph.
+    void removeEdge(int from, int to);
+    /// Print this graph to stdout.
+    void dump() const;
+    /**
+    *   Dumps a dot graph to a file named \p filename.
+    *   \param nodeNames map used to translate node ids to human readable text.
+    *   \param fileName file name where the output should be written.
+    */
+    void dumpDot(const QHash<int, QString>& nodeNames, const QString& fileName) const;
+
+    /**
+    *   Topologically sort this graph.
+    *   \return A collection with all nodes topologically sorted or an empty collection if a ciclic dependency was found.
+    */
+    QLinkedList<int> topologicalSort() const;
+private:
+
+    struct GraphPrivate;
+    GraphPrivate* m_d;
+};
+
+#endif
diff --git a/ApiExtractor/icecc.cmake b/ApiExtractor/icecc.cmake
new file mode 100644
index 000000000..b2bf071aa
--- /dev/null
+++ b/ApiExtractor/icecc.cmake
@@ -0,0 +1,11 @@
+include (CMakeForceCompiler)
+option(ENABLE_ICECC "Enable icecc checking, for distributed compilation")
+if (ENABLE_ICECC)
+    find_program(ICECC icecc)
+    if (ICECC)
+        message(STATUS "icecc found! Distributed compilation for all!! huhuhu.")
+        cmake_force_cxx_compiler(${ICECC} icecc)
+    else(ICECC)
+        message(FATAL_ERROR "icecc NOT found! re-run cmake without -DENABLE_ICECC")
+    endif(ICECC)
+endif(ENABLE_ICECC)
diff --git a/ApiExtractor/include.cpp b/ApiExtractor/include.cpp
new file mode 100644
index 000000000..4d4787d03
--- /dev/null
+++ b/ApiExtractor/include.cpp
@@ -0,0 +1,49 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "include.h"
+#include <QTextStream>
+#include <QHash>
+
+QString Include::toString() const
+{
+    if (m_type == IncludePath)
+        return "#include <" + m_name + '>';
+    else if (m_type == LocalPath)
+        return "#include \"" + m_name + "\"";
+    else
+        return "import " + m_name + ";";
+}
+
+uint qHash(const Include& inc)
+{
+    return qHash(inc.m_name);
+}
+
+QTextStream& operator<<(QTextStream& out, const Include& include)
+{
+    if (include.isValid())
+        out << include.toString() << endl;
+    return out;
+}
+
diff --git a/ApiExtractor/include.h b/ApiExtractor/include.h
new file mode 100644
index 000000000..d5ba47999
--- /dev/null
+++ b/ApiExtractor/include.h
@@ -0,0 +1,83 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef INCLUDE_H
+#define INCLUDE_H
+
+#include "apiextractormacros.h"
+#include <QString>
+#include <QList>
+
+class QTextStream;
+
+class APIEXTRACTOR_API Include
+{
+public:
+    enum IncludeType {
+        IncludePath,
+        LocalPath,
+        TargetLangImport
+    };
+
+    Include() : m_type(IncludePath) {}
+    Include(IncludeType t, const QString &nam) : m_type(t), m_name(nam) {};
+
+    bool isValid() const
+    {
+        return !m_name.isEmpty();
+    }
+
+    IncludeType type() const
+    {
+        return m_type;
+    }
+
+    QString name() const
+    {
+        return m_name;
+    }
+
+    QString toString() const;
+
+    bool operator<(const Include& other) const
+    {
+        return m_name < other.m_name;
+    }
+
+    bool operator==(const Include& other) const
+    {
+        return m_type == other.m_type && m_name == other.m_name;
+    }
+
+    friend APIEXTRACTOR_API uint qHash(const Include&);
+    private:
+        IncludeType m_type;
+        QString m_name;
+};
+
+APIEXTRACTOR_API uint qHash(const Include& inc);
+APIEXTRACTOR_API QTextStream& operator<<(QTextStream& out, const Include& include);
+
+typedef QList<Include> IncludeList;
+
+#endif
diff --git a/ApiExtractor/merge.xsl b/ApiExtractor/merge.xsl
new file mode 100644
index 000000000..d0b7eafa5
--- /dev/null
+++ b/ApiExtractor/merge.xsl
@@ -0,0 +1,82 @@
+<?xml version="1.0"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+                version="1.0">
+  <xsl:output method="xml" indent="yes"/>
+  <xsl:param name="lang" />   
+  <xsl:param name="source" />   
+
+  <xsl:template match="processing-instruction()" />
+  
+  <xsl:template match="/typesystem">
+    <xsl:copy>
+      <xsl:for-each select="@*">
+        <xsl:copy>
+          <xsl:value-of select="." />
+        </xsl:copy>
+      </xsl:for-each>
+
+      <xsl:for-each select="document($source)/typesystem/@*">
+        <xsl:copy>
+          <xsl:value-of select="." />
+        </xsl:copy>
+      </xsl:for-each>
+  
+      <xsl:variable name="other" select="document($source)/typesystem/*[not(self::object-type | self::value-type | self::interface-type | self::namespace-type)]" />  
+      <xsl:if test="$other">
+          <xsl:choose>
+          <xsl:when test="$lang != ''">
+            <xsl:element name="language">
+              <xsl:attribute name="name" ><xsl:value-of select="$lang" /></xsl:attribute>
+              <xsl:copy-of select="$other" />
+            </xsl:element>
+          </xsl:when>
+          <xsl:otherwise>
+             <xsl:copy-of select="$other" />
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:if>
+
+      <xsl:apply-templates select="node()" />
+      
+    </xsl:copy>
+  </xsl:template>
+
+
+
+  <xsl:template match="/typesystem/*[self::object-type | self::value-type | self::interface-type | self::namespace-type]">
+    <xsl:variable name="name" select="name()" />
+    <xsl:copy>
+      <xsl:for-each select="@*">
+        <xsl:copy>
+          <xsl:value-of select="." />
+        </xsl:copy>
+      </xsl:for-each>
+
+      <xsl:apply-templates select="node()" />
+      
+      <xsl:variable name="other" select="document($source)/typesystem/*[name() = $name][@name = current()/@name]" />
+      <xsl:if test="$other">
+        <xsl:choose>
+          <xsl:when test="$lang != ''">
+          <xsl:element name="language">
+            <xsl:attribute name="name" ><xsl:value-of select="$lang" /></xsl:attribute>
+            <xsl:copy-of select="$other/node()" />  
+          </xsl:element>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:copy-of select="$other/node()" />
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:if>
+    </xsl:copy>
+  </xsl:template>
+
+  <!-- Plain identity transform. -->
+  <xsl:template match="@*|node()">
+    <xsl:copy>
+      <xsl:apply-templates select="@*"/>
+      <xsl:apply-templates select="node()"/>
+    </xsl:copy>
+  </xsl:template>
+
+</xsl:stylesheet>
diff --git a/ApiExtractor/parser/ast.cpp b/ApiExtractor/parser/ast.cpp
new file mode 100644
index 000000000..ff5b7dfc8
--- /dev/null
+++ b/ApiExtractor/parser/ast.cpp
@@ -0,0 +1,33 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "ast.h"
+#include "lexer.h"
+
+QString AST::toString(TokenStream *stream) const
+{
+    const Token &tk = stream->token((int) start_token);
+    const Token &end_tk = stream->token((int) end_token);
+    return QString::fromLatin1(tk.text + tk.position, end_tk.position - tk.position);
+}
diff --git a/ApiExtractor/parser/ast.h b/ApiExtractor/parser/ast.h
new file mode 100644
index 000000000..d98497649
--- /dev/null
+++ b/ApiExtractor/parser/ast.h
@@ -0,0 +1,879 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef AST_H
+#define AST_H
+
+#include "smallobject.h"
+#include "list.h"
+
+class QString;
+
+#define DECLARE_AST_NODE(k) \
+    enum { __node_kind = Kind_##k };
+
+class TokenStream;
+
+struct AccessSpecifierAST;
+struct AsmDefinitionAST;
+struct BaseClauseAST;
+struct BaseSpecifierAST;
+struct BinaryExpressionAST;
+struct CastExpressionAST;
+struct ClassMemberAccessAST;
+struct ClassSpecifierAST;
+struct CompoundStatementAST;
+struct ConditionAST;
+struct ConditionalExpressionAST;
+struct CppCastExpressionAST;
+struct CtorInitializerAST;
+struct DeclarationAST;
+struct DeclarationStatementAST;
+struct DeclaratorAST;
+struct DeleteExpressionAST;
+struct DoStatementAST;
+struct ElaboratedTypeSpecifierAST;
+struct EnumSpecifierAST;
+struct EnumeratorAST;
+struct ExceptionSpecificationAST;
+struct ExpressionAST;
+struct ExpressionOrDeclarationStatementAST;
+struct ExpressionStatementAST;
+struct ForStatementAST;
+struct FunctionCallAST;
+struct FunctionDefinitionAST;
+struct IfStatementAST;
+struct IncrDecrExpressionAST;
+struct InitDeclaratorAST;
+struct InitializerAST;
+struct InitializerClauseAST;
+struct LabeledStatementAST;
+struct LinkageBodyAST;
+struct LinkageSpecificationAST;
+struct MemInitializerAST;
+struct NameAST;
+struct NamespaceAST;
+struct NamespaceAliasDefinitionAST;
+struct NewDeclaratorAST;
+struct NewExpressionAST;
+struct NewInitializerAST;
+struct NewTypeIdAST;
+struct OperatorAST;
+struct OperatorFunctionIdAST;
+struct ParameterDeclarationAST;
+struct ParameterDeclarationClauseAST;
+struct PostfixExpressionAST;
+struct PrimaryExpressionAST;
+struct PtrOperatorAST;
+struct PtrToMemberAST;
+struct ReturnStatementAST;
+struct SimpleDeclarationAST;
+struct SimpleTypeSpecifierAST;
+struct SizeofExpressionAST;
+struct StatementAST;
+struct StringLiteralAST;
+struct SubscriptExpressionAST;
+struct SwitchStatementAST;
+struct TemplateArgumentAST;
+struct TemplateDeclarationAST;
+struct TemplateParameterAST;
+struct ThrowExpressionAST;
+struct TranslationUnitAST;
+struct TryBlockStatementAST;
+struct TypeIdAST;
+struct TypeIdentificationAST;
+struct TypeParameterAST;
+struct TypeSpecifierAST;
+struct TypedefAST;
+struct UnaryExpressionAST;
+struct UnqualifiedNameAST;
+struct UsingAST;
+struct UsingDirectiveAST;
+struct WhileStatementAST;
+struct WinDeclSpecAST;
+struct QPropertyAST;
+struct QEnumsAST;
+
+struct AST
+{
+    enum NODE_KIND {
+        Kind_UNKNOWN = 0,
+
+        Kind_AccessSpecifier,
+        Kind_AsmDefinition,
+        Kind_BaseClause,
+        Kind_BaseSpecifier,
+        Kind_BinaryExpression,
+        Kind_CastExpression,
+        Kind_ClassMemberAccess,
+        Kind_ClassSpecifier,
+        Kind_CompoundStatement,
+        Kind_Condition,
+        Kind_ConditionalExpression,
+        Kind_CppCastExpression,
+        Kind_CtorInitializer,
+        Kind_DeclarationStatement,
+        Kind_Declarator,
+        Kind_DeleteExpression,
+        Kind_DoStatement,
+        Kind_ElaboratedTypeSpecifier,
+        Kind_EnumSpecifier,
+        Kind_Enumerator,
+        Kind_ExceptionSpecification,
+        Kind_ExpressionOrDeclarationStatement,
+        Kind_ExpressionStatement,
+        Kind_ForStatement,
+        Kind_FunctionCall,
+        Kind_FunctionDefinition,
+        Kind_IfStatement,
+        Kind_IncrDecrExpression,
+        Kind_InitDeclarator,
+        Kind_Initializer,
+        Kind_InitializerClause,
+        Kind_LabeledStatement,
+        Kind_LinkageBody,
+        Kind_LinkageSpecification,
+        Kind_MemInitializer,
+        Kind_Name,
+        Kind_Namespace,
+        Kind_NamespaceAliasDefinition,
+        Kind_NewDeclarator,
+        Kind_NewExpression,
+        Kind_NewInitializer,
+        Kind_NewTypeId,
+        Kind_Operator,
+        Kind_OperatorFunctionId,
+        Kind_ParameterDeclaration,
+        Kind_ParameterDeclarationClause,
+        Kind_PostfixExpression,
+        Kind_PrimaryExpression,
+        Kind_PtrOperator,
+        Kind_PtrToMember,
+        Kind_ReturnStatement,
+        Kind_SimpleDeclaration,
+        Kind_SimpleTypeSpecifier,
+        Kind_SizeofExpression,
+        Kind_StringLiteral,
+        Kind_SubscriptExpression,
+        Kind_SwitchStatement,
+        Kind_TemplateArgument,
+        Kind_TemplateDeclaration,
+        Kind_TemplateParameter,
+        Kind_ThrowExpression,
+        Kind_TranslationUnit,
+        Kind_TryBlockStatement,
+        Kind_TypeId,
+        Kind_TypeIdentification,
+        Kind_TypeParameter,
+        Kind_Typedef,
+        Kind_UnaryExpression,
+        Kind_UnqualifiedName,
+        Kind_Using,
+        Kind_UsingDirective,
+        Kind_WhileStatement,
+        Kind_WinDeclSpec,
+        Kind_QPropertyAST,
+        Kind_ForwardDeclarationSpecifier,
+        Kind_QEnumsAST,
+
+        NODE_KIND_COUNT
+    };
+
+    QString toString(TokenStream *stream) const;
+
+    int kind;
+
+    std::size_t start_token;
+    std::size_t end_token;
+};
+
+struct TypeSpecifierAST: public AST
+{
+    const ListNode<std::size_t> *cv;
+};
+
+struct StatementAST: public AST
+{
+};
+
+struct ExpressionAST: public AST
+{
+};
+
+struct DeclarationAST: public AST
+{
+};
+
+struct AccessSpecifierAST: public DeclarationAST
+{
+    DECLARE_AST_NODE(AccessSpecifier)
+
+    const ListNode<std::size_t> *specs;
+};
+
+struct AsmDefinitionAST: public DeclarationAST
+{
+    DECLARE_AST_NODE(AsmDefinition)
+
+    const ListNode<std::size_t> *cv;
+};
+
+struct BaseClauseAST: public AST
+{ // ### kill me
+    DECLARE_AST_NODE(BaseClause)
+
+    const ListNode<BaseSpecifierAST*> *base_specifiers;
+};
+
+struct BaseSpecifierAST: public AST
+{
+    DECLARE_AST_NODE(BaseSpecifier)
+
+    std::size_t virt;
+    std::size_t access_specifier;
+    NameAST *name;
+};
+
+struct BinaryExpressionAST: public ExpressionAST
+{
+    DECLARE_AST_NODE(BinaryExpression)
+
+    std::size_t op;
+    ExpressionAST *left_expression;
+    ExpressionAST *right_expression;
+};
+
+struct CastExpressionAST: public ExpressionAST
+{
+    DECLARE_AST_NODE(CastExpression)
+
+    TypeIdAST *type_id;
+    ExpressionAST *expression;
+};
+
+struct ClassMemberAccessAST: public ExpressionAST
+{
+    DECLARE_AST_NODE(ClassMemberAccess)
+
+    std::size_t op;
+    NameAST *name;
+};
+
+struct ClassSpecifierAST: public TypeSpecifierAST
+{
+    DECLARE_AST_NODE(ClassSpecifier)
+
+    WinDeclSpecAST *win_decl_specifiers;
+    std::size_t class_key;
+    NameAST *name;
+    BaseClauseAST *base_clause;
+    const ListNode<DeclarationAST*> *member_specs;
+};
+
+struct ForwardDeclarationSpecifierAST: public TypeSpecifierAST
+{
+    DECLARE_AST_NODE(ForwardDeclarationSpecifier)
+
+    std::size_t class_key;
+    NameAST *name;
+    BaseClauseAST *base_clause;
+};
+
+struct CompoundStatementAST: public StatementAST
+{
+    DECLARE_AST_NODE(CompoundStatement)
+
+    const ListNode<StatementAST*> *statements;
+};
+
+struct ConditionAST: public AST
+{
+    DECLARE_AST_NODE(Condition)
+
+    TypeSpecifierAST *type_specifier;
+    DeclaratorAST *declarator;
+    ExpressionAST *expression;
+};
+
+struct ConditionalExpressionAST: public ExpressionAST
+{
+    DECLARE_AST_NODE(ConditionalExpression)
+
+    ExpressionAST *condition;
+    ExpressionAST *left_expression;
+    ExpressionAST *right_expression;
+};
+
+struct CppCastExpressionAST: public ExpressionAST
+{
+    DECLARE_AST_NODE(CppCastExpression)
+
+    std::size_t op;
+    TypeIdAST *type_id;
+    ExpressionAST *expression;
+    const ListNode<ExpressionAST*> *sub_expressions;
+};
+
+struct CtorInitializerAST: public AST
+{
+    DECLARE_AST_NODE(CtorInitializer)
+
+    std::size_t colon;
+    const ListNode<MemInitializerAST*> *member_initializers;
+};
+
+struct DeclarationStatementAST: public StatementAST
+{
+    DECLARE_AST_NODE(DeclarationStatement)
+
+    DeclarationAST *declaration;
+};
+
+struct DeclaratorAST: public AST
+{
+    DECLARE_AST_NODE(Declarator)
+
+    const ListNode<PtrOperatorAST*> *ptr_ops;
+    DeclaratorAST *sub_declarator;
+    NameAST *id;
+    ExpressionAST *bit_expression;
+    const ListNode<ExpressionAST*> *array_dimensions;
+    ParameterDeclarationClauseAST *parameter_declaration_clause;
+    const ListNode<std::size_t> *fun_cv;
+    ExceptionSpecificationAST *exception_spec;
+};
+
+struct DeleteExpressionAST: public ExpressionAST
+{
+    DECLARE_AST_NODE(DeleteExpression)
+
+    std::size_t scope_token;
+    std::size_t delete_token;
+    std::size_t lbracket_token;
+    std::size_t rbracket_token;
+    ExpressionAST *expression;
+};
+
+struct DoStatementAST: public StatementAST
+{
+    DECLARE_AST_NODE(DoStatement)
+
+    StatementAST *statement;
+    ExpressionAST *expression;
+};
+
+struct ElaboratedTypeSpecifierAST: public TypeSpecifierAST
+{
+    DECLARE_AST_NODE(ElaboratedTypeSpecifier)
+
+    std::size_t type;
+    NameAST *name;
+};
+
+struct EnumSpecifierAST: public TypeSpecifierAST
+{
+    DECLARE_AST_NODE(EnumSpecifier)
+
+    NameAST *name;
+    const ListNode<EnumeratorAST*> *enumerators;
+};
+
+struct EnumeratorAST: public AST
+{
+    DECLARE_AST_NODE(Enumerator)
+
+    std::size_t id;
+    ExpressionAST *expression;
+};
+
+struct ExceptionSpecificationAST: public AST
+{
+    DECLARE_AST_NODE(ExceptionSpecification)
+
+    std::size_t ellipsis;
+    const ListNode<TypeIdAST*> *type_ids;
+};
+
+struct ExpressionOrDeclarationStatementAST: public StatementAST
+{
+    DECLARE_AST_NODE(ExpressionOrDeclarationStatement)
+
+    StatementAST *expression;
+    StatementAST *declaration;
+};
+
+struct ExpressionStatementAST: public StatementAST
+{
+    DECLARE_AST_NODE(ExpressionStatement)
+
+    ExpressionAST *expression;
+};
+
+struct FunctionCallAST: public ExpressionAST
+{
+    DECLARE_AST_NODE(FunctionCall)
+
+    ExpressionAST *arguments;
+};
+
+struct FunctionDefinitionAST: public DeclarationAST
+{
+    DECLARE_AST_NODE(FunctionDefinition)
+
+    const ListNode<std::size_t> *storage_specifiers;
+    const ListNode<std::size_t> *function_specifiers;
+    TypeSpecifierAST *type_specifier;
+    InitDeclaratorAST *init_declarator;
+    StatementAST *function_body;
+    WinDeclSpecAST *win_decl_specifiers;
+};
+
+struct ForStatementAST: public StatementAST
+{
+    DECLARE_AST_NODE(ForStatement)
+
+    StatementAST *init_statement;
+    ConditionAST *condition;
+    ExpressionAST *expression;
+    StatementAST *statement;
+};
+
+struct IfStatementAST: public StatementAST
+{
+    DECLARE_AST_NODE(IfStatement)
+
+    ConditionAST *condition;
+    StatementAST *statement;
+    StatementAST *else_statement;
+};
+
+struct IncrDecrExpressionAST: public ExpressionAST
+{
+    DECLARE_AST_NODE(IncrDecrExpression)
+
+    std::size_t op;
+};
+
+struct InitDeclaratorAST: public AST
+{
+    DECLARE_AST_NODE(InitDeclarator)
+
+    DeclaratorAST *declarator;
+    InitializerAST *initializer;
+};
+
+struct InitializerAST: public AST
+{
+    DECLARE_AST_NODE(Initializer)
+
+    InitializerClauseAST *initializer_clause;
+    ExpressionAST *expression;
+};
+
+struct InitializerClauseAST: public AST
+{
+    DECLARE_AST_NODE(InitializerClause)
+
+    ExpressionAST *expression;
+};
+
+struct LabeledStatementAST: public StatementAST
+{
+    DECLARE_AST_NODE(LabeledStatement)
+};
+
+struct LinkageBodyAST: public AST
+{
+    DECLARE_AST_NODE(LinkageBody)
+
+    const ListNode<DeclarationAST*> *declarations;
+};
+
+struct LinkageSpecificationAST: public DeclarationAST
+{
+    DECLARE_AST_NODE(LinkageSpecification)
+
+    std::size_t extern_type;
+    LinkageBodyAST *linkage_body;
+    DeclarationAST *declaration;
+};
+
+struct MemInitializerAST: public AST
+{
+    DECLARE_AST_NODE(MemInitializer)
+
+    NameAST *initializer_id;
+    ExpressionAST *expression;
+};
+
+struct NameAST: public AST
+{
+    DECLARE_AST_NODE(Name)
+
+    bool global;
+    const ListNode<UnqualifiedNameAST*> *qualified_names;
+    UnqualifiedNameAST *unqualified_name;
+};
+
+struct NamespaceAST: public DeclarationAST
+{
+    DECLARE_AST_NODE(Namespace)
+
+    std::size_t namespace_name;
+    LinkageBodyAST *linkage_body;
+};
+
+struct NamespaceAliasDefinitionAST: public DeclarationAST
+{
+    DECLARE_AST_NODE(NamespaceAliasDefinition)
+
+    std::size_t namespace_name;
+    NameAST *alias_name;
+};
+
+struct NewDeclaratorAST: public AST
+{
+    DECLARE_AST_NODE(NewDeclarator)
+
+    PtrOperatorAST *ptr_op;
+    NewDeclaratorAST *sub_declarator;
+    const ListNode<ExpressionAST*> *expressions;
+};
+
+struct NewExpressionAST: public ExpressionAST
+{
+    DECLARE_AST_NODE(NewExpression)
+
+    std::size_t scope_token;
+    std::size_t new_token;
+    ExpressionAST *expression;
+    TypeIdAST *type_id;
+    NewTypeIdAST *new_type_id;
+    NewInitializerAST *new_initializer;
+};
+
+struct NewInitializerAST: public AST
+{
+    DECLARE_AST_NODE(NewInitializer)
+
+    ExpressionAST *expression;
+};
+
+struct NewTypeIdAST: public AST
+{
+    DECLARE_AST_NODE(NewTypeId)
+
+    TypeSpecifierAST *type_specifier;
+    NewInitializerAST *new_initializer;
+    NewDeclaratorAST *new_declarator;
+};
+
+struct OperatorAST: public AST
+{
+    DECLARE_AST_NODE(Operator)
+
+    std::size_t op;
+    std::size_t open;
+    std::size_t close;
+};
+
+struct OperatorFunctionIdAST: public AST
+{
+    DECLARE_AST_NODE(OperatorFunctionId)
+
+    OperatorAST *op;
+    TypeSpecifierAST *type_specifier;
+    const ListNode<PtrOperatorAST*> *ptr_ops;
+};
+
+struct ParameterDeclarationAST: public AST
+{
+    DECLARE_AST_NODE(ParameterDeclaration)
+
+    TypeSpecifierAST *type_specifier;
+    DeclaratorAST *declarator;
+    ExpressionAST *expression;
+};
+
+struct ParameterDeclarationClauseAST: public AST
+{
+    DECLARE_AST_NODE(ParameterDeclarationClause)
+
+    const ListNode<ParameterDeclarationAST*> *parameter_declarations;
+    std::size_t ellipsis;
+};
+
+struct PostfixExpressionAST: public ExpressionAST
+{
+    DECLARE_AST_NODE(PostfixExpression)
+
+    TypeSpecifierAST *type_specifier;
+    ExpressionAST *expression;
+    const ListNode<ExpressionAST*> *sub_expressions;
+};
+
+struct PrimaryExpressionAST: public ExpressionAST
+{
+    DECLARE_AST_NODE(PrimaryExpression)
+
+    StringLiteralAST *literal;
+    std::size_t token;
+    StatementAST *expression_statement;
+    ExpressionAST *sub_expression;
+    NameAST *name;
+};
+
+struct PtrOperatorAST: public AST
+{
+    DECLARE_AST_NODE(PtrOperator)
+
+    const ListNode<std::size_t> *cv;
+    std::size_t op;
+    PtrToMemberAST *mem_ptr;
+};
+
+struct PtrToMemberAST: public AST
+{
+    DECLARE_AST_NODE(PtrToMember)
+};
+
+struct ReturnStatementAST: public StatementAST
+{
+    DECLARE_AST_NODE(ReturnStatement)
+
+    ExpressionAST *expression;
+};
+
+struct SimpleDeclarationAST: public DeclarationAST
+{
+    DECLARE_AST_NODE(SimpleDeclaration)
+
+    const ListNode<std::size_t> *storage_specifiers;
+    const ListNode<std::size_t> *function_specifiers;
+    TypeSpecifierAST *type_specifier;
+    const ListNode<InitDeclaratorAST*> *init_declarators;
+    WinDeclSpecAST *win_decl_specifiers;
+};
+
+struct SimpleTypeSpecifierAST: public TypeSpecifierAST
+{
+    DECLARE_AST_NODE(SimpleTypeSpecifier)
+
+    const ListNode<std::size_t> *integrals;
+    std::size_t type_of;
+    TypeIdAST *type_id;
+    ExpressionAST *expression;
+    NameAST *name;
+};
+
+struct SizeofExpressionAST: public ExpressionAST
+{
+    DECLARE_AST_NODE(SizeofExpression)
+
+    std::size_t sizeof_token;
+    TypeIdAST *type_id;
+    ExpressionAST *expression;
+};
+
+struct StringLiteralAST: public AST
+{
+    DECLARE_AST_NODE(StringLiteral)
+
+    const ListNode<std::size_t> *literals;
+};
+
+struct SubscriptExpressionAST: public ExpressionAST
+{
+    DECLARE_AST_NODE(SubscriptExpression)
+
+    ExpressionAST *subscript;
+};
+
+struct SwitchStatementAST: public StatementAST
+{
+    DECLARE_AST_NODE(SwitchStatement)
+
+    ConditionAST *condition;
+    StatementAST *statement;
+};
+
+struct TemplateArgumentAST: public AST
+{
+    DECLARE_AST_NODE(TemplateArgument)
+
+    TypeIdAST *type_id;
+    ExpressionAST *expression;
+};
+
+struct TemplateDeclarationAST: public DeclarationAST
+{
+    DECLARE_AST_NODE(TemplateDeclaration)
+
+    std::size_t exported;
+    const ListNode<TemplateParameterAST*> *template_parameters;
+    DeclarationAST* declaration;
+};
+
+struct TemplateParameterAST: public AST
+{
+    DECLARE_AST_NODE(TemplateParameter)
+
+    TypeParameterAST *type_parameter;
+    ParameterDeclarationAST *parameter_declaration;
+};
+
+struct ThrowExpressionAST: public ExpressionAST
+{
+    DECLARE_AST_NODE(ThrowExpression)
+
+    std::size_t throw_token;
+    ExpressionAST *expression;
+};
+
+struct TranslationUnitAST: public AST
+{
+    DECLARE_AST_NODE(TranslationUnit)
+
+    const ListNode<DeclarationAST*> *declarations;
+};
+
+struct TryBlockStatementAST: public StatementAST
+{
+    DECLARE_AST_NODE(TryBlockStatement)
+};
+
+struct TypeIdAST: public AST
+{
+    DECLARE_AST_NODE(TypeId)
+
+    TypeSpecifierAST *type_specifier;
+    DeclaratorAST *declarator;
+};
+
+struct TypeIdentificationAST: public ExpressionAST
+{
+    DECLARE_AST_NODE(TypeIdentification)
+
+    std::size_t typename_token;
+    NameAST *name;
+    ExpressionAST *expression;
+};
+
+struct TypeParameterAST: public AST
+{
+    DECLARE_AST_NODE(TypeParameter)
+
+    std::size_t type;
+    NameAST *name;
+    TypeIdAST *type_id;
+    const ListNode<TemplateParameterAST*> *template_parameters;
+    NameAST *template_name;
+};
+
+struct TypedefAST: public DeclarationAST
+{
+    DECLARE_AST_NODE(Typedef)
+
+    TypeSpecifierAST *type_specifier;
+    const ListNode<InitDeclaratorAST*> *init_declarators;
+};
+
+struct UnaryExpressionAST: public ExpressionAST
+{
+    DECLARE_AST_NODE(UnaryExpression)
+
+    std::size_t op;
+    ExpressionAST *expression;
+};
+
+struct UnqualifiedNameAST: public AST
+{
+    DECLARE_AST_NODE(UnqualifiedName)
+
+    std::size_t tilde;
+    std::size_t id;
+    OperatorFunctionIdAST *operator_id;
+    const ListNode<TemplateArgumentAST*> *template_arguments;
+};
+
+struct UsingAST: public DeclarationAST
+{
+    DECLARE_AST_NODE(Using)
+
+    std::size_t type_name;
+    NameAST *name;
+};
+
+struct UsingDirectiveAST: public DeclarationAST
+{
+    DECLARE_AST_NODE(UsingDirective)
+
+    NameAST *name;
+};
+
+struct WhileStatementAST: public StatementAST
+{
+    DECLARE_AST_NODE(WhileStatement)
+
+    ConditionAST *condition;
+    StatementAST *statement;
+};
+
+struct WinDeclSpecAST: public AST
+{
+    DECLARE_AST_NODE(WinDeclSpec)
+
+    std::size_t specifier;
+    std::size_t modifier;
+};
+
+struct QPropertyAST : public DeclarationAST
+{
+    DECLARE_AST_NODE(QPropertyAST)
+};
+
+struct QEnumsAST : public DeclarationAST
+{
+    DECLARE_AST_NODE(QEnumsAST)
+};
+
+template <class _Tp>
+_Tp *CreateNode(pool *memory_pool)
+{
+    _Tp *node = reinterpret_cast<_Tp*>(memory_pool->allocate(sizeof(_Tp), strideof(_Tp)));
+    node->kind = _Tp::__node_kind;
+    return node;
+}
+
+template <class _Tp>
+_Tp ast_cast(AST *item)
+{
+    if (item && static_cast<_Tp>(0)->__node_kind == item->kind)
+        return static_cast<_Tp>(item);
+
+    return 0;
+}
+
+#endif // AST_H
diff --git a/ApiExtractor/parser/binder.cpp b/ApiExtractor/parser/binder.cpp
new file mode 100644
index 000000000..faace02ca
--- /dev/null
+++ b/ApiExtractor/parser/binder.cpp
@@ -0,0 +1,854 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "binder.h"
+#include "lexer.h"
+#include "control.h"
+#include "symbol.h"
+#include "codemodel_finder.h"
+#include "class_compiler.h"
+#include "compiler_utils.h"
+#include "tokens.h"
+#include "dumptree.h"
+
+#include <iostream>
+#include <QDebug>
+
+Binder::Binder(CodeModel *__model, LocationManager &__location, Control *__control)
+        : _M_model(__model),
+        _M_location(__location),
+        _M_token_stream(&_M_location.token_stream),
+        _M_control(__control),
+        _M_current_function_type(CodeModel::Normal),
+        type_cc(this),
+        name_cc(this),
+        decl_cc(this)
+{
+    _M_qualified_types["char"] = QString();
+    _M_qualified_types["double"] = QString();
+    _M_qualified_types["float"] = QString();
+    _M_qualified_types["int"] = QString();
+    _M_qualified_types["long"] = QString();
+    _M_qualified_types["short"] = QString();
+    _M_qualified_types["void"] = QString();
+}
+
+Binder::~Binder()
+{
+}
+
+FileModelItem Binder::run(AST *node)
+{
+    FileModelItem old = _M_current_file;
+    _M_current_access = CodeModel::Public;
+
+    _M_current_file = model()->create<FileModelItem>();
+    updateItemPosition(_M_current_file->toItem(), node);
+    visit(node);
+    FileModelItem result = _M_current_file;
+
+    _M_current_file = old; // restore
+
+    return result;
+}
+
+ScopeModelItem Binder::currentScope()
+{
+    if (_M_current_class)
+        return model_static_cast<ScopeModelItem>(_M_current_class);
+    else if (_M_current_namespace)
+        return model_static_cast<ScopeModelItem>(_M_current_namespace);
+
+    return model_static_cast<ScopeModelItem>(_M_current_file);
+}
+
+TemplateParameterList Binder::changeTemplateParameters(TemplateParameterList templateParameters)
+{
+    TemplateParameterList old = _M_current_template_parameters;
+    _M_current_template_parameters = templateParameters;
+    return old;
+}
+
+CodeModel::FunctionType Binder::changeCurrentFunctionType(CodeModel::FunctionType functionType)
+{
+    CodeModel::FunctionType old = _M_current_function_type;
+    _M_current_function_type = functionType;
+    return old;
+}
+
+CodeModel::AccessPolicy Binder::changeCurrentAccess(CodeModel::AccessPolicy accessPolicy)
+{
+    CodeModel::AccessPolicy old = _M_current_access;
+    _M_current_access = accessPolicy;
+    return old;
+}
+
+NamespaceModelItem Binder::changeCurrentNamespace(NamespaceModelItem item)
+{
+    NamespaceModelItem old = _M_current_namespace;
+    _M_current_namespace = item;
+    return old;
+}
+
+ClassModelItem Binder::changeCurrentClass(ClassModelItem item)
+{
+    ClassModelItem old = _M_current_class;
+    _M_current_class = item;
+    return old;
+}
+
+FunctionDefinitionModelItem Binder::changeCurrentFunction(FunctionDefinitionModelItem item)
+{
+    FunctionDefinitionModelItem old = _M_current_function;
+    _M_current_function = item;
+    return old;
+}
+
+int Binder::decode_token(std::size_t index) const
+{
+    return _M_token_stream->kind(index);
+}
+
+CodeModel::AccessPolicy Binder::decode_access_policy(std::size_t index) const
+{
+    switch (decode_token(index)) {
+    case Token_class:
+        return CodeModel::Private;
+
+    case Token_struct:
+    case Token_union:
+        return CodeModel::Public;
+
+    default:
+        return CodeModel::Public;
+    }
+}
+
+CodeModel::ClassType Binder::decode_class_type(std::size_t index) const
+{
+    switch (decode_token(index)) {
+    case Token_class:
+        return CodeModel::Class;
+    case Token_struct:
+        return CodeModel::Struct;
+    case Token_union:
+        return CodeModel::Union;
+    default:
+        std::cerr << "** WARNING unrecognized class type" << std::endl;
+    }
+    return CodeModel::Class;
+}
+
+const NameSymbol *Binder::decode_symbol(std::size_t index) const
+{
+    return _M_token_stream->symbol(index);
+}
+
+void Binder::visitAccessSpecifier(AccessSpecifierAST *node)
+{
+    const ListNode<std::size_t> *it =  node->specs;
+    if (!it)
+        return;
+
+    it = it->toFront();
+    const ListNode<std::size_t> *end = it;
+
+    do {
+        switch (decode_token(it->element)) {
+        default:
+            break;
+
+        case Token_public:
+            changeCurrentAccess(CodeModel::Public);
+            changeCurrentFunctionType(CodeModel::Normal);
+            break;
+        case Token_protected:
+            changeCurrentAccess(CodeModel::Protected);
+            changeCurrentFunctionType(CodeModel::Normal);
+            break;
+        case Token_private:
+            changeCurrentAccess(CodeModel::Private);
+            changeCurrentFunctionType(CodeModel::Normal);
+            break;
+        case Token_signals:
+            changeCurrentAccess(CodeModel::Protected);
+            changeCurrentFunctionType(CodeModel::Signal);
+            break;
+        case Token_slots:
+            changeCurrentFunctionType(CodeModel::Slot);
+            break;
+        }
+        it = it->next;
+    } while (it != end);
+}
+
+void Binder::visitSimpleDeclaration(SimpleDeclarationAST *node)
+{
+    visit(node->type_specifier);
+
+    if (const ListNode<InitDeclaratorAST*> *it = node->init_declarators) {
+        it = it->toFront();
+        const ListNode<InitDeclaratorAST*> *end = it;
+        do {
+            InitDeclaratorAST *init_declarator = it->element;
+            declare_symbol(node, init_declarator);
+            it = it->next;
+        } while (it != end);
+    }
+}
+
+void Binder::declare_symbol(SimpleDeclarationAST *node, InitDeclaratorAST *init_declarator)
+{
+    DeclaratorAST *declarator = init_declarator->declarator;
+
+    while (declarator && declarator->sub_declarator)
+        declarator = declarator->sub_declarator;
+
+    NameAST *id = declarator->id;
+    if (!declarator->id) {
+        std::cerr << "** WARNING expected a declarator id" << std::endl;
+        return;
+    }
+
+    CodeModelFinder finder(model(), this);
+    ScopeModelItem symbolScope = finder.resolveScope(id, currentScope());
+    if (!symbolScope) {
+        name_cc.run(id);
+        std::cerr << "** WARNING scope not found for symbol:"
+                  << qPrintable(name_cc.name()) << std::endl;
+        return;
+    }
+
+    decl_cc.run(declarator);
+
+    if (decl_cc.isFunction()) {
+        name_cc.run(id->unqualified_name);
+
+        FunctionModelItem fun = model()->create<FunctionModelItem>();
+        updateItemPosition(fun->toItem(), node);
+        fun->setAccessPolicy(_M_current_access);
+        fun->setFunctionType(_M_current_function_type);
+        fun->setName(name_cc.name());
+        fun->setAbstract(init_declarator->initializer != 0);
+        fun->setConstant(declarator->fun_cv != 0);
+        fun->setTemplateParameters(_M_current_template_parameters);
+        applyStorageSpecifiers(node->storage_specifiers, model_static_cast<MemberModelItem>(fun));
+        applyFunctionSpecifiers(node->function_specifiers, fun);
+
+        // build the type
+        TypeInfo typeInfo = CompilerUtils::typeDescription(node->type_specifier,
+                                                           declarator,
+                                                           this);
+
+        fun->setType(qualifyType(typeInfo, symbolScope->qualifiedName()));
+
+
+        fun->setVariadics(decl_cc.isVariadics());
+
+        // ... and the signature
+        foreach (DeclaratorCompiler::Parameter p, decl_cc.parameters()) {
+            ArgumentModelItem arg = model()->create<ArgumentModelItem>();
+            arg->setType(qualifyType(p.type, _M_context));
+            arg->setName(p.name);
+            arg->setDefaultValue(p.defaultValue);
+            if (p.defaultValue)
+                arg->setDefaultValueExpression(p.defaultValueExpression);
+            fun->addArgument(arg);
+        }
+
+        fun->setScope(symbolScope->qualifiedName());
+        symbolScope->addFunction(fun);
+    } else {
+        VariableModelItem var = model()->create<VariableModelItem>();
+        updateItemPosition(var->toItem(), node);
+        var->setTemplateParameters(_M_current_template_parameters);
+        var->setAccessPolicy(_M_current_access);
+        name_cc.run(id->unqualified_name);
+        var->setName(name_cc.name());
+        TypeInfo typeInfo = CompilerUtils::typeDescription(node->type_specifier,
+                                                           declarator,
+                                                           this);
+        if (declarator != init_declarator->declarator
+            && init_declarator->declarator->parameter_declaration_clause) {
+            typeInfo.setFunctionPointer(true);
+            decl_cc.run(init_declarator->declarator);
+            foreach (DeclaratorCompiler::Parameter p, decl_cc.parameters())
+            typeInfo.addArgument(p.type);
+        }
+
+        var->setType(qualifyType(typeInfo, _M_context));
+        applyStorageSpecifiers(node->storage_specifiers, model_static_cast<MemberModelItem>(var));
+
+        var->setScope(symbolScope->qualifiedName());
+        symbolScope->addVariable(var);
+    }
+}
+
+void Binder::visitFunctionDefinition(FunctionDefinitionAST *node)
+{
+    Q_ASSERT(node->init_declarator);
+
+    ScopeModelItem scope = currentScope();
+
+    InitDeclaratorAST *init_declarator = node->init_declarator;
+    DeclaratorAST *declarator = init_declarator->declarator;
+
+    // in the case of "void (func)()" or "void ((func))()" we need to
+    // skip to the inner most.  This is in line with how the declarator
+    // node is generated in 'parser.cpp'
+    while (declarator && declarator->sub_declarator)
+        declarator = declarator->sub_declarator;
+    Q_ASSERT(declarator->id);
+
+    CodeModelFinder finder(model(), this);
+
+    ScopeModelItem functionScope = finder.resolveScope(declarator->id, scope);
+    if (!functionScope) {
+        name_cc.run(declarator->id);
+        std::cerr << "** WARNING scope not found for function definition:"
+                  << qPrintable(name_cc.name()) << std::endl
+                  << "\tdefinition *ignored*"
+                  << std::endl;
+        return;
+    }
+
+    decl_cc.run(declarator);
+
+    Q_ASSERT(!decl_cc.id().isEmpty());
+
+    FunctionDefinitionModelItem
+    old = changeCurrentFunction(_M_model->create<FunctionDefinitionModelItem>());
+    _M_current_function->setScope(functionScope->qualifiedName());
+    updateItemPosition(_M_current_function->toItem(), node);
+
+    Q_ASSERT(declarator->id->unqualified_name);
+    name_cc.run(declarator->id->unqualified_name);
+    QString unqualified_name = name_cc.name();
+
+    _M_current_function->setName(unqualified_name);
+    TypeInfo tmp_type = CompilerUtils::typeDescription(node->type_specifier,
+                                                       declarator, this);
+
+    _M_current_function->setType(qualifyType(tmp_type, _M_context));
+    _M_current_function->setAccessPolicy(_M_current_access);
+    _M_current_function->setFunctionType(_M_current_function_type);
+    _M_current_function->setConstant(declarator->fun_cv);
+    _M_current_function->setTemplateParameters(_M_current_template_parameters);
+
+    applyStorageSpecifiers(node->storage_specifiers,
+                           model_static_cast<MemberModelItem>(_M_current_function));
+    applyFunctionSpecifiers(node->function_specifiers,
+                            model_static_cast<FunctionModelItem>(_M_current_function));
+
+    _M_current_function->setVariadics(decl_cc.isVariadics());
+
+    foreach (DeclaratorCompiler::Parameter p, decl_cc.parameters()) {
+        ArgumentModelItem arg = model()->create<ArgumentModelItem>();
+        arg->setType(qualifyType(p.type, functionScope->qualifiedName()));
+        arg->setName(p.name);
+        arg->setDefaultValue(p.defaultValue);
+        if (p.defaultValue)
+            arg->setDefaultValueExpression(p.defaultValueExpression);
+        _M_current_function->addArgument(arg);
+    }
+
+    functionScope->addFunctionDefinition(_M_current_function);
+
+    FunctionModelItem prototype = model_static_cast<FunctionModelItem>(_M_current_function);
+    FunctionModelItem declared = functionScope->declaredFunction(prototype);
+
+    // try to find a function declaration for this definition..
+    if (!declared) {
+        functionScope->addFunction(prototype);
+    } else {
+        applyFunctionSpecifiers(node->function_specifiers, declared);
+
+        // fix the function type and the access policy
+        _M_current_function->setAccessPolicy(declared->accessPolicy());
+        _M_current_function->setFunctionType(declared->functionType());
+    }
+
+    changeCurrentFunction(old);
+}
+
+void Binder::visitTemplateDeclaration(TemplateDeclarationAST *node)
+{
+    const ListNode<TemplateParameterAST*> *it = node->template_parameters;
+    if (!it) {
+        // QtScript: we want to visit the declaration still, so that
+        // e.g. QMetaTypeId<Foo> is added to the code model
+        visit(node->declaration);
+        return;
+    }
+
+    TemplateParameterList savedTemplateParameters = changeTemplateParameters(TemplateParameterList());
+
+    it = it->toFront();
+    const ListNode<TemplateParameterAST*> *end = it;
+
+    TemplateParameterList templateParameters;
+    do {
+        TemplateParameterAST *parameter = it->element;
+        TypeParameterAST *type_parameter = parameter->type_parameter;
+
+        NameAST *name;
+        if (!type_parameter) {
+            // A hacky hack to work around missing support for parameter declarations in
+            // templates. We just need the to get the name of the variable, since we
+            // aren't actually compiling these anyway. We are still not supporting much
+            // more, but we are refusing to fail for a few more declarations
+            if (!parameter->parameter_declaration ||
+                !parameter->parameter_declaration->declarator ||
+                !parameter->parameter_declaration->declarator->id) {
+
+                /*std::cerr << "** WARNING template declaration not supported ``";
+                Token const &tk = _M_token_stream->token ((int) node->start_token);
+                Token const &end_tk = _M_token_stream->token ((int) node->declaration->start_token);
+
+                std::cerr << std::string (&tk.text[tk.position], (end_tk.position) - tk.position) << "''"
+                    << std::endl << std::endl;*/
+
+                changeTemplateParameters(savedTemplateParameters);
+                return;
+
+            }
+
+            name = parameter->parameter_declaration->declarator->id;
+        } else {
+            int tk = decode_token(type_parameter->type);
+            if (tk != Token_typename && tk != Token_class) {
+                /*std::cerr << "** WARNING template declaration not supported ``";
+                Token const &tk = _M_token_stream->token ((int) node->start_token);
+                Token const &end_tk = _M_token_stream->token ((int) node->declaration->start_token);
+
+                std::cerr << std::string (&tk.text[tk.position], (end_tk.position) - tk.position) << "''"
+                << std::endl << std::endl;*/
+
+                changeTemplateParameters(savedTemplateParameters);
+                return;
+            }
+            assert(tk == Token_typename || tk == Token_class);
+
+            name = type_parameter->name;
+        }
+
+        TemplateParameterModelItem p = model()->create<TemplateParameterModelItem>();
+        name_cc.run(name);
+        p->setName(name_cc.name());
+
+        _M_current_template_parameters.append(p);
+        it = it->next;
+    } while (it != end);
+
+    visit(node->declaration);
+
+    changeTemplateParameters(savedTemplateParameters);
+}
+
+void Binder::visitTypedef(TypedefAST *node)
+{
+    const ListNode<InitDeclaratorAST*> *it = node->init_declarators;
+    if (!it)
+        return;
+
+    it = it->toFront();
+    const ListNode<InitDeclaratorAST*> *end = it;
+
+    do {
+        InitDeclaratorAST *init_declarator = it->element;
+        it = it->next;
+
+        Q_ASSERT(init_declarator->declarator);
+
+        // the name
+        decl_cc.run(init_declarator->declarator);
+        QString alias_name = decl_cc.id();
+
+        if (alias_name.isEmpty()) {
+            std::cerr << "** WARNING anonymous typedef not supported! ``";
+            Token const &tk = _M_token_stream->token((int) node->start_token);
+            Token const &end_tk = _M_token_stream->token((int) node->end_token);
+
+            std::cerr << std::string(&tk.text[tk.position], end_tk.position - tk.position) << "''"
+                      << std::endl << std::endl;
+            continue;
+        }
+
+        // build the type
+        TypeInfo typeInfo = CompilerUtils::typeDescription(node->type_specifier,
+                                                           init_declarator->declarator,
+                                                           this);
+        DeclaratorAST *decl = init_declarator->declarator;
+        while (decl && decl->sub_declarator)
+            decl = decl->sub_declarator;
+
+        if (decl != init_declarator->declarator
+            && init_declarator->declarator->parameter_declaration_clause) {
+            typeInfo.setFunctionPointer(true);
+            decl_cc.run(init_declarator->declarator);
+            foreach (DeclaratorCompiler::Parameter p, decl_cc.parameters())
+                typeInfo.addArgument(p.type);
+        }
+
+        ScopeModelItem scope = currentScope();
+        DeclaratorAST *declarator = init_declarator->declarator;
+        CodeModelFinder finder(model(), this);
+        ScopeModelItem typedefScope = finder.resolveScope(declarator->id, scope);
+
+        TypeAliasModelItem typeAlias = model()->create<TypeAliasModelItem> ();
+        updateItemPosition(typeAlias->toItem(), node);
+        typeAlias->setName(alias_name);
+        typeAlias->setType(qualifyType(typeInfo, currentScope()->qualifiedName()));
+        typeAlias->setScope(typedefScope->qualifiedName());
+        _M_qualified_types[typeAlias->qualifiedName().join(".")] = QString();
+        currentScope()->addTypeAlias(typeAlias);
+    } while (it != end);
+}
+
+void Binder::visitNamespace(NamespaceAST *node)
+{
+    bool anonymous = (node->namespace_name == 0);
+
+    ScopeModelItem scope = currentScope();
+
+    NamespaceModelItem old;
+    if (!anonymous) {
+        QString name = decode_symbol(node->namespace_name)->as_string();
+
+        QStringList qualified_name = scope->qualifiedName();
+        qualified_name += name;
+        NamespaceModelItem ns =
+            model_safe_cast<NamespaceModelItem>(_M_model->findItem(qualified_name,
+                                                                   _M_current_file->toItem()));
+        if (!ns) {
+            ns = _M_model->create<NamespaceModelItem>();
+            updateItemPosition(ns->toItem(), node);
+            ns->setName(name);
+            ns->setScope(scope->qualifiedName());
+        }
+        old = changeCurrentNamespace(ns);
+
+        _M_context.append(name);
+    }
+
+    DefaultVisitor::visitNamespace(node);
+
+    if (!anonymous) {
+        Q_ASSERT(scope->kind() == _CodeModelItem::Kind_Namespace
+                 || scope->kind() == _CodeModelItem::Kind_File);
+
+        _M_context.removeLast();
+
+        if (NamespaceModelItem ns = model_static_cast<NamespaceModelItem>(scope))
+            ns->addNamespace(_M_current_namespace);
+
+        changeCurrentNamespace(old);
+    }
+}
+
+void Binder::visitForwardDeclarationSpecifier(ForwardDeclarationSpecifierAST *node)
+{
+    name_cc.run(node->name);
+    if (name_cc.name().isEmpty())
+        return;
+
+    ScopeModelItem scope = currentScope();
+    _M_qualified_types[(scope->qualifiedName() + name_cc.qualifiedName()).join(".")] = QString();
+}
+
+void Binder::visitClassSpecifier(ClassSpecifierAST *node)
+{
+    ClassCompiler class_cc(this);
+    class_cc.run(node);
+
+    if (class_cc.name().isEmpty()) {
+        // anonymous not supported
+        return;
+    }
+
+    Q_ASSERT(node->name && node->name->unqualified_name);
+
+    ScopeModelItem scope = currentScope();
+
+    ClassModelItem old = changeCurrentClass(_M_model->create<ClassModelItem>());
+    updateItemPosition(_M_current_class->toItem(), node);
+    _M_current_class->setName(class_cc.name());
+
+    QStringList baseClasses = class_cc.baseClasses();
+    TypeInfo info;
+    for (int i = 0; i < baseClasses.size(); ++i) {
+        info.setQualifiedName(baseClasses.at(i).split("::"));
+        baseClasses[i] = qualifyType(info, scope->qualifiedName()).qualifiedName().join("::");
+    }
+
+    _M_current_class->setBaseClasses(baseClasses);
+    _M_current_class->setClassType(decode_class_type(node->class_key));
+    _M_current_class->setTemplateParameters(_M_current_template_parameters);
+
+    if (!_M_current_template_parameters.isEmpty()) {
+        QString name = _M_current_class->name();
+        name += "<";
+        for (int i = 0; i < _M_current_template_parameters.size(); ++i) {
+            if (i > 0)
+                name += ",";
+
+            name += _M_current_template_parameters.at(i)->name();
+        }
+
+        name += ">";
+        _M_current_class->setName(name);
+    }
+
+    CodeModel::AccessPolicy oldAccessPolicy = changeCurrentAccess(decode_access_policy(node->class_key));
+    CodeModel::FunctionType oldFunctionType = changeCurrentFunctionType(CodeModel::Normal);
+
+    _M_current_class->setScope(scope->qualifiedName());
+    _M_qualified_types[_M_current_class->qualifiedName().join(".")] = QString();
+
+    scope->addClass(_M_current_class);
+
+    name_cc.run(node->name->unqualified_name);
+    _M_context.append(name_cc.name());
+    visitNodes(this, node->member_specs);
+    _M_context.removeLast();
+
+    changeCurrentClass(old);
+    changeCurrentAccess(oldAccessPolicy);
+    changeCurrentFunctionType(oldFunctionType);
+}
+
+void Binder::visitLinkageSpecification(LinkageSpecificationAST *node)
+{
+    DefaultVisitor::visitLinkageSpecification(node);
+}
+
+void Binder::visitUsing(UsingAST *node)
+{
+    DefaultVisitor::visitUsing(node);
+}
+
+void Binder::visitEnumSpecifier(EnumSpecifierAST *node)
+{
+    CodeModelFinder finder(model(), this);
+    ScopeModelItem scope = currentScope();
+    ScopeModelItem enumScope = finder.resolveScope(node->name, scope);
+
+    name_cc.run(node->name);
+    QString name = name_cc.name();
+
+    bool isAnonymous = name.isEmpty();
+    if (isAnonymous) {
+        // anonymous enum
+        QString key = _M_context.join("::");
+        int current = ++_M_anonymous_enums[key];
+        name += QLatin1String("enum_");
+        name += QString::number(current);
+    }
+
+    _M_current_enum = model()->create<EnumModelItem>();
+    _M_current_enum->setAccessPolicy(_M_current_access);
+    updateItemPosition(_M_current_enum->toItem(), node);
+    _M_current_enum->setName(name);
+    _M_current_enum->setAnonymous(isAnonymous);
+    _M_current_enum->setScope(enumScope->qualifiedName());
+
+    _M_qualified_types[_M_current_enum->qualifiedName().join(".")] = QString();
+
+    enumScope->addEnum(_M_current_enum);
+
+    DefaultVisitor::visitEnumSpecifier(node);
+
+    _M_current_enum = 0;
+}
+
+static QString strip_preprocessor_lines(const QString &name)
+{
+    QStringList lst = name.split("\n");
+    QString s;
+    for (int i = 0; i < lst.size(); ++i) {
+        if (!lst.at(i).startsWith('#'))
+            s += lst.at(i);
+    }
+    return s.trimmed();
+}
+
+void Binder::visitEnumerator(EnumeratorAST *node)
+{
+    Q_ASSERT(_M_current_enum);
+    EnumeratorModelItem e = model()->create<EnumeratorModelItem>();
+    updateItemPosition(e->toItem(), node);
+    e->setName(decode_symbol(node->id)->as_string());
+
+    if (ExpressionAST *expr = node->expression) {
+        const Token &start_token = _M_token_stream->token((int) expr->start_token);
+        const Token &end_token = _M_token_stream->token((int) expr->end_token);
+
+        e->setValue(strip_preprocessor_lines(QString::fromUtf8(&start_token.text[start_token.position],
+                                                               (int)(end_token.position - start_token.position)).trimmed()).remove(' '));
+    }
+
+    _M_current_enum->addEnumerator(e);
+}
+
+void Binder::visitUsingDirective(UsingDirectiveAST *node)
+{
+    DefaultVisitor::visitUsingDirective(node);
+}
+
+void Binder::visitQEnums(QEnumsAST *node)
+{
+    const Token &start = _M_token_stream->token((int) node->start_token);
+    const Token &end = _M_token_stream->token((int) node->end_token);
+    QStringList enum_list = QString::fromLatin1(start.text + start.position,
+                                                end.position - start.position).split(' ');
+
+    ScopeModelItem scope = currentScope();
+    for (int i = 0; i < enum_list.size(); ++i)
+        scope->addEnumsDeclaration(enum_list.at(i));
+}
+
+void Binder::visitQProperty(QPropertyAST *node)
+{
+    const Token &start = _M_token_stream->token((int) node->start_token);
+    const Token &end = _M_token_stream->token((int) node->end_token);
+    QString property = QString::fromLatin1(start.text + start.position,
+                                           end.position - start.position);
+    _M_current_class->addPropertyDeclaration(property);
+}
+
+void Binder::applyStorageSpecifiers(const ListNode<std::size_t> *it, MemberModelItem item)
+{
+    if (!it)
+        return;
+
+    it = it->toFront();
+    const ListNode<std::size_t> *end = it;
+
+    do {
+        switch (decode_token(it->element)) {
+        default:
+            break;
+
+        case Token_friend:
+            item->setFriend(true);
+            break;
+        case Token_auto:
+            item->setAuto(true);
+            break;
+        case Token_register:
+            item->setRegister(true);
+            break;
+        case Token_static:
+            item->setStatic(true);
+            break;
+        case Token_extern:
+            item->setExtern(true);
+            break;
+        case Token_mutable:
+            item->setMutable(true);
+            break;
+        }
+        it = it->next;
+    } while (it != end);
+}
+
+void Binder::applyFunctionSpecifiers(const ListNode<std::size_t> *it, FunctionModelItem item)
+{
+    if (!it)
+        return;
+
+    it = it->toFront();
+    const ListNode<std::size_t> *end = it;
+
+    do {
+        switch (decode_token(it->element)) {
+        default:
+            break;
+
+        case Token_inline:
+            item->setInline(true);
+            break;
+
+        case Token_virtual:
+            item->setVirtual(true);
+            break;
+
+        case Token_explicit:
+            item->setExplicit(true);
+            break;
+
+        case Token_Q_INVOKABLE:
+            item->setInvokable(true);
+            break;
+        }
+        it = it->next;
+    } while (it != end);
+}
+
+TypeInfo Binder::qualifyType(const TypeInfo &type, const QStringList &context) const
+{
+    // ### Potentially improve to use string list in the name table to
+    if (!context.size()) {
+        // ### We can assume that this means global namespace for now...
+        return type;
+    } else if (_M_qualified_types.contains(type.qualifiedName().join("."))) {
+        return type;
+    } else {
+        QStringList expanded = context;
+        expanded << type.qualifiedName();
+        if (_M_qualified_types.contains(expanded.join("."))) {
+            TypeInfo modified_type = type;
+            modified_type.setQualifiedName(expanded);
+            return modified_type;
+        } else {
+            CodeModelItem scope = model()->findItem(context, _M_current_file->toItem());
+
+            if (ClassModelItem klass = model_dynamic_cast<ClassModelItem> (scope)) {
+                foreach (QString base, klass->baseClasses()) {
+                    QStringList ctx = context;
+                    ctx.removeLast();
+                    ctx.append(base);
+
+                    TypeInfo qualified = qualifyType(type, ctx);
+                    if (qualified != type)
+                        return qualified;
+                }
+            }
+
+            QStringList copy = context;
+            copy.removeLast();
+            return qualifyType(type, copy);
+        }
+    }
+}
+
+void Binder::updateItemPosition(CodeModelItem item, AST *node)
+{
+    QString filename;
+    int line, column;
+
+    assert(node);
+    _M_location.positionAt(_M_token_stream->position(node->start_token), &line, &column, &filename);
+    item->setFileName(filename);
+}
diff --git a/ApiExtractor/parser/binder.h b/ApiExtractor/parser/binder.h
new file mode 100644
index 000000000..b4d4da667
--- /dev/null
+++ b/ApiExtractor/parser/binder.h
@@ -0,0 +1,125 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef BINDER_H
+#define BINDER_H
+
+#include "default_visitor.h"
+#include "codemodel.h"
+#include "type_compiler.h"
+#include "name_compiler.h"
+#include "declarator_compiler.h"
+
+class TokenStream;
+class LocationManager;
+class Control;
+struct NameSymbol;
+
+class Binder: protected DefaultVisitor
+{
+public:
+    Binder(CodeModel *__model, LocationManager &__location, Control *__control = 0);
+    virtual ~Binder();
+
+    inline TokenStream *tokenStream() const
+    {
+        return _M_token_stream;
+    }
+
+    inline CodeModel *model() const
+    {
+        return _M_model;
+    }
+
+    ScopeModelItem currentScope();
+
+    FileModelItem run(AST *node);
+
+// utils
+    TypeInfo qualifyType(const TypeInfo &type, const QStringList &context) const;
+
+protected:
+    virtual void visitAccessSpecifier(AccessSpecifierAST *);
+    virtual void visitClassSpecifier(ClassSpecifierAST *);
+    virtual void visitEnumSpecifier(EnumSpecifierAST *);
+    virtual void visitEnumerator(EnumeratorAST *);
+    virtual void visitFunctionDefinition(FunctionDefinitionAST *);
+    virtual void visitLinkageSpecification(LinkageSpecificationAST *);
+    virtual void visitNamespace(NamespaceAST *);
+    virtual void visitSimpleDeclaration(SimpleDeclarationAST *);
+    virtual void visitTemplateDeclaration(TemplateDeclarationAST *);
+    virtual void visitTypedef(TypedefAST *);
+    virtual void visitUsing(UsingAST *);
+    virtual void visitUsingDirective(UsingDirectiveAST *);
+    virtual void visitQProperty(QPropertyAST *);
+    virtual void visitForwardDeclarationSpecifier(ForwardDeclarationSpecifierAST *);
+    virtual void visitQEnums(QEnumsAST *);
+
+private:
+
+    int decode_token(std::size_t index) const;
+    const NameSymbol *decode_symbol(std::size_t index) const;
+    CodeModel::AccessPolicy decode_access_policy(std::size_t index) const;
+    CodeModel::ClassType decode_class_type(std::size_t index) const;
+
+    CodeModel::FunctionType changeCurrentFunctionType(CodeModel::FunctionType functionType);
+    CodeModel::AccessPolicy changeCurrentAccess(CodeModel::AccessPolicy accessPolicy);
+    NamespaceModelItem changeCurrentNamespace(NamespaceModelItem item);
+    ClassModelItem changeCurrentClass(ClassModelItem item);
+    FunctionDefinitionModelItem changeCurrentFunction(FunctionDefinitionModelItem item);
+    TemplateParameterList changeTemplateParameters(TemplateParameterList templateParameters);
+
+    void declare_symbol(SimpleDeclarationAST *node, InitDeclaratorAST *init_declarator);
+
+    void applyStorageSpecifiers(const ListNode<std::size_t> *storage_specifiers, MemberModelItem item);
+    void applyFunctionSpecifiers(const ListNode<std::size_t> *it, FunctionModelItem item);
+
+    void updateItemPosition(CodeModelItem item, AST *node);
+
+private:
+    CodeModel *_M_model;
+    LocationManager &_M_location;
+    TokenStream *_M_token_stream;
+    Control *_M_control;
+
+    CodeModel::FunctionType _M_current_function_type;
+    CodeModel::AccessPolicy _M_current_access;
+    FileModelItem _M_current_file;
+    NamespaceModelItem _M_current_namespace;
+    ClassModelItem _M_current_class;
+    FunctionDefinitionModelItem _M_current_function;
+    EnumModelItem _M_current_enum;
+    QStringList _M_context;
+    TemplateParameterList _M_current_template_parameters; // ### check me
+    QHash<QString, QString> _M_qualified_types;
+    QHash<QString, int> _M_anonymous_enums;
+
+protected:
+    TypeCompiler type_cc;
+    NameCompiler name_cc;
+    DeclaratorCompiler decl_cc;
+};
+
+#endif // BINDER_H
diff --git a/ApiExtractor/parser/class_compiler.cpp b/ApiExtractor/parser/class_compiler.cpp
new file mode 100644
index 000000000..e04ffe109
--- /dev/null
+++ b/ApiExtractor/parser/class_compiler.cpp
@@ -0,0 +1,66 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#include "class_compiler.h"
+#include "lexer.h"
+#include "binder.h"
+
+ClassCompiler::ClassCompiler(Binder *binder)
+        : _M_binder(binder),
+        _M_token_stream(binder->tokenStream()),
+        name_cc(_M_binder),
+        type_cc(_M_binder)
+{
+}
+
+ClassCompiler::~ClassCompiler()
+{
+}
+
+void ClassCompiler::run(ClassSpecifierAST *node)
+{
+    name_cc.run(node->name);
+    _M_name = name_cc.name();
+    _M_base_classes.clear();
+
+    visit(node);
+}
+
+void ClassCompiler::visitClassSpecifier(ClassSpecifierAST *node)
+{
+    visit(node->base_clause);
+}
+
+void ClassCompiler::visitBaseSpecifier(BaseSpecifierAST *node)
+{
+    name_cc.run(node->name);
+    QString name = name_cc.name();
+
+    if (!name.isEmpty())
+        _M_base_classes.append(name);
+}
+
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/class_compiler.h b/ApiExtractor/parser/class_compiler.h
new file mode 100644
index 000000000..69fccf757
--- /dev/null
+++ b/ApiExtractor/parser/class_compiler.h
@@ -0,0 +1,72 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef CLASS_COMPILER_H
+#define CLASS_COMPILER_H
+
+#include <QtCore/qglobal.h>
+#include <QtCore/QStringList>
+
+#include <default_visitor.h>
+#include <name_compiler.h>
+#include <type_compiler.h>
+
+class TokenStream;
+class Binder;
+
+class ClassCompiler: protected DefaultVisitor
+{
+public:
+    ClassCompiler(Binder *binder);
+    virtual ~ClassCompiler();
+
+    inline QString name() const
+    {
+        return _M_name;
+    }
+
+    inline QStringList baseClasses() const
+    {
+        return _M_base_classes;
+    }
+
+    void run(ClassSpecifierAST *node);
+
+protected:
+    virtual void visitClassSpecifier(ClassSpecifierAST *node);
+    virtual void visitBaseSpecifier(BaseSpecifierAST *node);
+
+private:
+    Binder *_M_binder;
+    TokenStream *_M_token_stream;
+    QString _M_name;
+    QStringList _M_base_classes;
+    NameCompiler name_cc;
+    TypeCompiler type_cc;
+};
+
+#endif // CLASS_COMPILER_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/codemodel.cpp b/ApiExtractor/parser/codemodel.cpp
new file mode 100644
index 000000000..0cc14fcce
--- /dev/null
+++ b/ApiExtractor/parser/codemodel.cpp
@@ -0,0 +1,947 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#include "codemodel.h"
+#include <algorithm>
+
+// ---------------------------------------------------------------------------
+CodeModel::CodeModel()
+        : _M_creation_id(0)
+{
+    _M_globalNamespace = create<NamespaceModelItem>();
+}
+
+CodeModel::~CodeModel()
+{
+}
+
+void CodeModel::wipeout()
+{
+    _M_globalNamespace = create<NamespaceModelItem>();
+    _M_files.clear();
+}
+
+FileList CodeModel::files() const
+{
+    return _M_files.values();
+}
+
+NamespaceModelItem CodeModel::globalNamespace() const
+{
+    return _M_globalNamespace;
+}
+
+void CodeModel::addFile(FileModelItem item)
+{
+    _M_creation_id = 0; // reset the creation id
+    _M_files.insert(item->name(), item);
+}
+
+void CodeModel::removeFile(FileModelItem item)
+{
+    QHash<QString, FileModelItem>::Iterator it = _M_files.find(item->name());
+
+    if (it != _M_files.end() && it.value() == item)
+        _M_files.erase(it);
+}
+
+FileModelItem CodeModel::findFile(const QString &name) const
+{
+    return _M_files.value(name);
+}
+
+QHash<QString, FileModelItem> CodeModel::fileMap() const
+{
+    return _M_files;
+}
+
+CodeModelItem CodeModel::findItem(const QStringList &qualifiedName, CodeModelItem scope) const
+{
+    for (int i = 0; i < qualifiedName.size(); ++i) {
+        // ### Extend to look for members etc too.
+        const QString &name = qualifiedName.at(i);
+
+        if (NamespaceModelItem ns = model_dynamic_cast<NamespaceModelItem>(scope)) {
+            if (NamespaceModelItem tmp_ns = ns->findNamespace(name)) {
+                scope = tmp_ns;
+                continue;
+            }
+        }
+
+        if (ScopeModelItem ss = model_dynamic_cast<ScopeModelItem>(scope)) {
+            if (ClassModelItem cs = ss->findClass(name)) {
+                scope = cs;
+            } else if (EnumModelItem es = ss->findEnum(name)) {
+                if (i == qualifiedName.size() - 1)
+                    return es->toItem();
+            } else if (TypeAliasModelItem tp = ss->findTypeAlias(name)) {
+                if (i == qualifiedName.size() - 1)
+                    return tp->toItem();
+            } else {
+                // If we don't find the name in the scope chain we
+                // need to return an empty item to indicate failure...
+                return CodeModelItem();
+            }
+        }
+    }
+
+    return scope;
+}
+
+
+// ---------------------------------------------------------------------------
+TypeInfo TypeInfo::combine(const TypeInfo &__lhs, const TypeInfo &__rhs)
+{
+    TypeInfo __result = __lhs;
+
+    __result.setConstant(__result.isConstant() || __rhs.isConstant());
+    __result.setVolatile(__result.isVolatile() || __rhs.isVolatile());
+    __result.setReference(__result.isReference() || __rhs.isReference());
+    __result.setIndirections(__result.indirections() + __rhs.indirections());
+    __result.setArrayElements(__result.arrayElements() + __rhs.arrayElements());
+
+    return __result;
+}
+
+TypeInfo TypeInfo::resolveType(TypeInfo const &__type, CodeModelItem __scope)
+{
+    CodeModel *__model = __scope->model();
+    Q_ASSERT(__model != 0);
+
+    CodeModelItem __item = __model->findItem(__type.qualifiedName(), __scope);
+
+    // Copy the type and replace with the proper qualified name. This
+    // only makes sence to do if we're actually getting a resolved
+    // type with a namespace. We only get this if the returned type
+    // has more than 2 entries in the qualified name... This test
+    // could be improved by returning if the type was found or not.
+    TypeInfo otherType(__type);
+    if (__item && __item->qualifiedName().size() > 1) {
+        otherType.setQualifiedName(__item->qualifiedName());
+    }
+
+    if (TypeAliasModelItem __alias = model_dynamic_cast<TypeAliasModelItem> (__item))
+        return resolveType(TypeInfo::combine(__alias->type(), otherType), __scope);
+
+    return otherType;
+}
+
+QString TypeInfo::toString() const
+{
+    QString tmp;
+
+    tmp += m_qualifiedName.join("::");
+    if (isConstant())
+        tmp += QLatin1String(" const");
+
+    if (isVolatile())
+        tmp += QLatin1String(" volatile");
+
+    if (indirections())
+        tmp += QString(indirections(), QLatin1Char('*'));
+
+    if (isReference())
+        tmp += QLatin1Char('&');
+
+    if (isFunctionPointer()) {
+        tmp += QLatin1String(" (*)(");
+        for (int i = 0; i < m_arguments.count(); ++i) {
+            if (i != 0)
+                tmp += QLatin1String(", ");
+
+            tmp += m_arguments.at(i).toString();
+        }
+        tmp += QLatin1String(")");
+    }
+
+    foreach(QString elt, arrayElements()) {
+        tmp += QLatin1String("[");
+        tmp += elt;
+        tmp += QLatin1String("]");
+    }
+
+    return tmp;
+}
+
+bool TypeInfo::operator==(const TypeInfo &other)
+{
+    if (arrayElements().count() != other.arrayElements().count())
+        return false;
+
+#if defined (RXX_CHECK_ARRAY_ELEMENTS) // ### it'll break
+    for (int i = 0; i < arrayElements().count(); ++i) {
+        QString elt1 = arrayElements().at(i).trimmed();
+        QString elt2 = other.arrayElements().at(i).trimmed();
+
+        if (elt1 != elt2)
+            return false;
+    }
+#endif
+
+    return flags == other.flags
+           && m_qualifiedName == other.m_qualifiedName
+           && (!m_functionPointer || m_arguments == other.m_arguments);
+}
+
+// ---------------------------------------------------------------------------
+_CodeModelItem::_CodeModelItem(CodeModel *model, int kind)
+        : _M_model(model),
+        _M_kind(kind),
+        _M_startLine(0),
+        _M_startColumn(0),
+        _M_endLine(0),
+        _M_endColumn(0),
+        _M_creation_id(0)
+{
+}
+
+_CodeModelItem::~_CodeModelItem()
+{
+}
+
+CodeModelItem _CodeModelItem::toItem() const
+{
+    return CodeModelItem(const_cast<_CodeModelItem*>(this));
+}
+
+int _CodeModelItem::kind() const
+{
+    return _M_kind;
+}
+
+void _CodeModelItem::setKind(int kind)
+{
+    _M_kind = kind;
+}
+
+QStringList _CodeModelItem::qualifiedName() const
+{
+    QStringList q = scope();
+
+    if (!name().isEmpty())
+        q += name();
+
+    return q;
+}
+
+QString _CodeModelItem::name() const
+{
+    return _M_name;
+}
+
+void _CodeModelItem::setName(const QString &name)
+{
+    _M_name = name;
+}
+
+QStringList _CodeModelItem::scope() const
+{
+    return _M_scope;
+}
+
+void _CodeModelItem::setScope(const QStringList &scope)
+{
+    _M_scope = scope;
+}
+
+QString _CodeModelItem::fileName() const
+{
+    return _M_fileName;
+}
+
+void _CodeModelItem::setFileName(const QString &fileName)
+{
+    _M_fileName = fileName;
+}
+
+FileModelItem _CodeModelItem::file() const
+{
+    return model()->findFile(fileName());
+}
+
+void _CodeModelItem::getStartPosition(int *line, int *column)
+{
+    *line = _M_startLine;
+    *column = _M_startColumn;
+}
+
+void _CodeModelItem::setStartPosition(int line, int column)
+{
+    _M_startLine = line;
+    _M_startColumn = column;
+}
+
+void _CodeModelItem::getEndPosition(int *line, int *column)
+{
+    *line = _M_endLine;
+    *column = _M_endColumn;
+}
+
+void _CodeModelItem::setEndPosition(int line, int column)
+{
+    _M_endLine = line;
+    _M_endColumn = column;
+}
+
+// ---------------------------------------------------------------------------
+QStringList _ClassModelItem::baseClasses() const
+{
+    return _M_baseClasses;
+}
+
+void _ClassModelItem::setBaseClasses(const QStringList &baseClasses)
+{
+    _M_baseClasses = baseClasses;
+}
+
+TemplateParameterList _ClassModelItem::templateParameters() const
+{
+    return _M_templateParameters;
+}
+
+void _ClassModelItem::setTemplateParameters(const TemplateParameterList &templateParameters)
+{
+    _M_templateParameters = templateParameters;
+}
+
+void _ClassModelItem::addBaseClass(const QString &baseClass)
+{
+    _M_baseClasses.append(baseClass);
+}
+
+void _ClassModelItem::removeBaseClass(const QString &baseClass)
+{
+    _M_baseClasses.removeAt(_M_baseClasses.indexOf(baseClass));
+}
+
+bool _ClassModelItem::extendsClass(const QString &name) const
+{
+    return _M_baseClasses.contains(name);
+}
+
+void _ClassModelItem::setClassType(CodeModel::ClassType type)
+{
+    _M_classType = type;
+}
+
+CodeModel::ClassType _ClassModelItem::classType() const
+{
+    return _M_classType;
+}
+
+void _ClassModelItem::addPropertyDeclaration(const QString &propertyDeclaration)
+{
+    _M_propertyDeclarations << propertyDeclaration;
+}
+
+
+// ---------------------------------------------------------------------------
+FunctionModelItem _ScopeModelItem::declaredFunction(FunctionModelItem item)
+{
+    FunctionList function_list = findFunctions(item->name());
+
+    foreach(FunctionModelItem fun, function_list) {
+        if (fun->isSimilar(item))
+            return fun;
+    }
+
+    return FunctionModelItem();
+}
+
+ClassList _ScopeModelItem::classes() const
+{
+    ClassList result = _M_classes.values();
+    qSort(result);
+    ClassList::iterator it = std::unique(result.begin(), result.end());
+    result.erase(it, result.end());
+    return result;
+}
+
+TypeAliasList _ScopeModelItem::typeAliases() const
+{
+    return _M_typeAliases.values();
+}
+
+VariableList _ScopeModelItem::variables() const
+{
+    return _M_variables.values();
+}
+
+FunctionList _ScopeModelItem::functions() const
+{
+    return _M_functions.values();
+}
+
+void _ScopeModelItem::addEnumsDeclaration(const QString &enumsDeclaration)
+{
+    _M_enumsDeclarations << enumsDeclaration;
+}
+
+FunctionDefinitionList _ScopeModelItem::functionDefinitions() const
+{
+    return _M_functionDefinitions.values();
+}
+
+EnumList _ScopeModelItem::enums() const
+{
+    return _M_enums.values();
+}
+
+void _ScopeModelItem::addClass(ClassModelItem item)
+{
+    QString name = item->name();
+    int idx = name.indexOf("<");
+    if (idx > 0)
+        _M_classes.insert(name.left(idx), item);
+    _M_classes.insert(name, item);
+}
+
+void _ScopeModelItem::addFunction(FunctionModelItem item)
+{
+    _M_functions.insert(item->name(), item);
+}
+
+void _ScopeModelItem::addFunctionDefinition(FunctionDefinitionModelItem item)
+{
+    _M_functionDefinitions.insert(item->name(), item);
+}
+
+void _ScopeModelItem::addVariable(VariableModelItem item)
+{
+    _M_variables.insert(item->name(), item);
+}
+
+void _ScopeModelItem::addTypeAlias(TypeAliasModelItem item)
+{
+    _M_typeAliases.insert(item->name(), item);
+}
+
+void _ScopeModelItem::addEnum(EnumModelItem item)
+{
+    _M_enums.insert(item->name(), item);
+}
+
+void _ScopeModelItem::removeClass(ClassModelItem item)
+{
+    QHash<QString, ClassModelItem>::Iterator it = _M_classes.find(item->name());
+
+    if (it != _M_classes.end() && it.value() == item)
+        _M_classes.erase(it);
+}
+
+void _ScopeModelItem::removeFunction(FunctionModelItem item)
+{
+    QMultiHash<QString, FunctionModelItem>::Iterator it = _M_functions.find(item->name());
+
+    while (it != _M_functions.end() && it.key() == item->name()
+           && it.value() != item) {
+        ++it;
+    }
+
+    if (it != _M_functions.end() && it.value() == item) {
+        _M_functions.erase(it);
+    }
+}
+
+void _ScopeModelItem::removeFunctionDefinition(FunctionDefinitionModelItem item)
+{
+    QMultiHash<QString, FunctionDefinitionModelItem>::Iterator it = _M_functionDefinitions.find(item->name());
+
+    while (it != _M_functionDefinitions.end() && it.key() == item->name()
+           && it.value() != item) {
+        ++it;
+    }
+
+    if (it != _M_functionDefinitions.end() && it.value() == item) {
+        _M_functionDefinitions.erase(it);
+    }
+}
+
+void _ScopeModelItem::removeVariable(VariableModelItem item)
+{
+    QHash<QString, VariableModelItem>::Iterator it = _M_variables.find(item->name());
+
+    if (it != _M_variables.end() && it.value() == item)
+        _M_variables.erase(it);
+}
+
+void _ScopeModelItem::removeTypeAlias(TypeAliasModelItem item)
+{
+    QHash<QString, TypeAliasModelItem>::Iterator it = _M_typeAliases.find(item->name());
+
+    if (it != _M_typeAliases.end() && it.value() == item)
+        _M_typeAliases.erase(it);
+}
+
+void _ScopeModelItem::removeEnum(EnumModelItem item)
+{
+    QHash<QString, EnumModelItem>::Iterator it = _M_enums.find(item->name());
+
+    if (it != _M_enums.end() && it.value() == item)
+        _M_enums.erase(it);
+}
+
+ClassModelItem _ScopeModelItem::findClass(const QString &name) const
+{
+    return _M_classes.value(name);
+}
+
+VariableModelItem _ScopeModelItem::findVariable(const QString &name) const
+{
+    return _M_variables.value(name);
+}
+
+TypeAliasModelItem _ScopeModelItem::findTypeAlias(const QString &name) const
+{
+    return _M_typeAliases.value(name);
+}
+
+EnumModelItem _ScopeModelItem::findEnum(const QString &name) const
+{
+    return _M_enums.value(name);
+}
+
+FunctionList _ScopeModelItem::findFunctions(const QString &name) const
+{
+    return _M_functions.values(name);
+}
+
+FunctionDefinitionList _ScopeModelItem::findFunctionDefinitions(const QString &name) const
+{
+    return _M_functionDefinitions.values(name);
+}
+
+// ---------------------------------------------------------------------------
+NamespaceList _NamespaceModelItem::namespaces() const
+{
+    return _M_namespaces.values();
+}
+void _NamespaceModelItem::addNamespace(NamespaceModelItem item)
+{
+    _M_namespaces.insert(item->name(), item);
+}
+void _NamespaceModelItem::removeNamespace(NamespaceModelItem item)
+{
+    QHash<QString, NamespaceModelItem>::Iterator it = _M_namespaces.find(item->name());
+
+    if (it != _M_namespaces.end() && it.value() == item)
+        _M_namespaces.erase(it);
+}
+
+NamespaceModelItem _NamespaceModelItem::findNamespace(const QString &name) const
+{
+    return _M_namespaces.value(name);
+}
+
+// ---------------------------------------------------------------------------
+TypeInfo _ArgumentModelItem::type() const
+{
+    return _M_type;
+}
+
+void _ArgumentModelItem::setType(const TypeInfo &type)
+{
+    _M_type = type;
+}
+
+bool _ArgumentModelItem::defaultValue() const
+{
+    return _M_defaultValue;
+}
+
+void _ArgumentModelItem::setDefaultValue(bool defaultValue)
+{
+    _M_defaultValue = defaultValue;
+}
+
+// ---------------------------------------------------------------------------
+bool _FunctionModelItem::isSimilar(FunctionModelItem other) const
+{
+    if (name() != other->name())
+        return false;
+
+    if (isConstant() != other->isConstant())
+        return false;
+
+    if (isVariadics() != other->isVariadics())
+        return false;
+
+    if (arguments().count() != other->arguments().count())
+        return false;
+
+    // ### check the template parameters
+
+    for (int i = 0; i < arguments().count(); ++i) {
+        ArgumentModelItem arg1 = arguments().at(i);
+        ArgumentModelItem arg2 = other->arguments().at(i);
+
+        if (arg1->type() != arg2->type())
+            return false;
+    }
+
+    return true;
+}
+
+ArgumentList _FunctionModelItem::arguments() const
+{
+    return _M_arguments;
+}
+
+void _FunctionModelItem::addArgument(ArgumentModelItem item)
+{
+    _M_arguments.append(item);
+}
+
+void _FunctionModelItem::removeArgument(ArgumentModelItem item)
+{
+    _M_arguments.removeAt(_M_arguments.indexOf(item));
+}
+
+CodeModel::FunctionType _FunctionModelItem::functionType() const
+{
+    return _M_functionType;
+}
+
+void _FunctionModelItem::setFunctionType(CodeModel::FunctionType functionType)
+{
+    _M_functionType = functionType;
+}
+
+bool _FunctionModelItem::isVariadics() const
+{
+    return _M_isVariadics;
+}
+
+void _FunctionModelItem::setVariadics(bool isVariadics)
+{
+    _M_isVariadics = isVariadics;
+}
+
+bool _FunctionModelItem::isVirtual() const
+{
+    return _M_isVirtual;
+}
+
+void _FunctionModelItem::setVirtual(bool isVirtual)
+{
+    _M_isVirtual = isVirtual;
+}
+
+bool _FunctionModelItem::isInline() const
+{
+    return _M_isInline;
+}
+
+void _FunctionModelItem::setInline(bool isInline)
+{
+    _M_isInline = isInline;
+}
+
+bool _FunctionModelItem::isExplicit() const
+{
+    return _M_isExplicit;
+}
+
+void _FunctionModelItem::setExplicit(bool isExplicit)
+{
+    _M_isExplicit = isExplicit;
+}
+
+bool _FunctionModelItem::isAbstract() const
+{
+    return _M_isAbstract;
+}
+
+void _FunctionModelItem::setAbstract(bool isAbstract)
+{
+    _M_isAbstract = isAbstract;
+}
+
+// Qt
+bool _FunctionModelItem::isInvokable() const
+{
+    return _M_isInvokable;
+}
+
+void _FunctionModelItem::setInvokable(bool isInvokable)
+{
+    _M_isInvokable = isInvokable;
+}
+
+// ---------------------------------------------------------------------------
+TypeInfo _TypeAliasModelItem::type() const
+{
+    return _M_type;
+}
+
+void _TypeAliasModelItem::setType(const TypeInfo &type)
+{
+    _M_type = type;
+}
+
+// ---------------------------------------------------------------------------
+CodeModel::AccessPolicy _EnumModelItem::accessPolicy() const
+{
+    return _M_accessPolicy;
+}
+
+void _EnumModelItem::setAccessPolicy(CodeModel::AccessPolicy accessPolicy)
+{
+    _M_accessPolicy = accessPolicy;
+}
+
+EnumeratorList _EnumModelItem::enumerators() const
+{
+    return _M_enumerators;
+}
+
+void _EnumModelItem::addEnumerator(EnumeratorModelItem item)
+{
+    _M_enumerators.append(item);
+}
+
+void _EnumModelItem::removeEnumerator(EnumeratorModelItem item)
+{
+    _M_enumerators.removeAt(_M_enumerators.indexOf(item));
+}
+
+bool _EnumModelItem::isAnonymous() const
+{
+    return _M_anonymous;
+}
+
+void _EnumModelItem::setAnonymous(bool anonymous)
+{
+    _M_anonymous = anonymous;
+}
+
+// ---------------------------------------------------------------------------
+QString _EnumeratorModelItem::value() const
+{
+    return _M_value;
+}
+
+void _EnumeratorModelItem::setValue(const QString &value)
+{
+    _M_value = value;
+}
+
+// ---------------------------------------------------------------------------
+TypeInfo _TemplateParameterModelItem::type() const
+{
+    return _M_type;
+}
+
+void _TemplateParameterModelItem::setType(const TypeInfo &type)
+{
+    _M_type = type;
+}
+
+bool _TemplateParameterModelItem::defaultValue() const
+{
+    return _M_defaultValue;
+}
+
+void _TemplateParameterModelItem::setDefaultValue(bool defaultValue)
+{
+    _M_defaultValue = defaultValue;
+}
+
+// ---------------------------------------------------------------------------
+ScopeModelItem _ScopeModelItem::create(CodeModel *model)
+{
+    ScopeModelItem item(new _ScopeModelItem(model));
+    return item;
+}
+
+ClassModelItem _ClassModelItem::create(CodeModel *model)
+{
+    ClassModelItem item(new _ClassModelItem(model));
+    return item;
+}
+
+NamespaceModelItem _NamespaceModelItem::create(CodeModel *model)
+{
+    NamespaceModelItem item(new _NamespaceModelItem(model));
+    return item;
+}
+
+FileModelItem _FileModelItem::create(CodeModel *model)
+{
+    FileModelItem item(new _FileModelItem(model));
+    return item;
+}
+
+ArgumentModelItem _ArgumentModelItem::create(CodeModel *model)
+{
+    ArgumentModelItem item(new _ArgumentModelItem(model));
+    return item;
+}
+
+FunctionModelItem _FunctionModelItem::create(CodeModel *model)
+{
+    FunctionModelItem item(new _FunctionModelItem(model));
+    return item;
+}
+
+FunctionDefinitionModelItem _FunctionDefinitionModelItem::create(CodeModel *model)
+{
+    FunctionDefinitionModelItem item(new _FunctionDefinitionModelItem(model));
+    return item;
+}
+
+VariableModelItem _VariableModelItem::create(CodeModel *model)
+{
+    VariableModelItem item(new _VariableModelItem(model));
+    return item;
+}
+
+TypeAliasModelItem _TypeAliasModelItem::create(CodeModel *model)
+{
+    TypeAliasModelItem item(new _TypeAliasModelItem(model));
+    return item;
+}
+
+EnumModelItem _EnumModelItem::create(CodeModel *model)
+{
+    EnumModelItem item(new _EnumModelItem(model));
+    return item;
+}
+
+EnumeratorModelItem _EnumeratorModelItem::create(CodeModel *model)
+{
+    EnumeratorModelItem item(new _EnumeratorModelItem(model));
+    return item;
+}
+
+TemplateParameterModelItem _TemplateParameterModelItem::create(CodeModel *model)
+{
+    TemplateParameterModelItem item(new _TemplateParameterModelItem(model));
+    return item;
+}
+
+// ---------------------------------------------------------------------------
+TypeInfo _MemberModelItem::type() const
+{
+    return _M_type;
+}
+
+void _MemberModelItem::setType(const TypeInfo &type)
+{
+    _M_type = type;
+}
+
+CodeModel::AccessPolicy _MemberModelItem::accessPolicy() const
+{
+    return _M_accessPolicy;
+}
+
+void _MemberModelItem::setAccessPolicy(CodeModel::AccessPolicy accessPolicy)
+{
+    _M_accessPolicy = accessPolicy;
+}
+
+bool _MemberModelItem::isStatic() const
+{
+    return _M_isStatic;
+}
+
+void _MemberModelItem::setStatic(bool isStatic)
+{
+    _M_isStatic = isStatic;
+}
+
+bool _MemberModelItem::isConstant() const
+{
+    return _M_isConstant;
+}
+
+void _MemberModelItem::setConstant(bool isConstant)
+{
+    _M_isConstant = isConstant;
+}
+
+bool _MemberModelItem::isVolatile() const
+{
+    return _M_isVolatile;
+}
+
+void _MemberModelItem::setVolatile(bool isVolatile)
+{
+    _M_isVolatile = isVolatile;
+}
+
+bool _MemberModelItem::isAuto() const
+{
+    return _M_isAuto;
+}
+
+void _MemberModelItem::setAuto(bool isAuto)
+{
+    _M_isAuto = isAuto;
+}
+
+bool _MemberModelItem::isFriend() const
+{
+    return _M_isFriend;
+}
+
+void _MemberModelItem::setFriend(bool isFriend)
+{
+    _M_isFriend = isFriend;
+}
+
+bool _MemberModelItem::isRegister() const
+{
+    return _M_isRegister;
+}
+
+void _MemberModelItem::setRegister(bool isRegister)
+{
+    _M_isRegister = isRegister;
+}
+
+bool _MemberModelItem::isExtern() const
+{
+    return _M_isExtern;
+}
+
+void _MemberModelItem::setExtern(bool isExtern)
+{
+    _M_isExtern = isExtern;
+}
+
+bool _MemberModelItem::isMutable() const
+{
+    return _M_isMutable;
+}
+
+void _MemberModelItem::setMutable(bool isMutable)
+{
+    _M_isMutable = isMutable;
+}
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
+
diff --git a/ApiExtractor/parser/codemodel.h b/ApiExtractor/parser/codemodel.h
new file mode 100644
index 000000000..f87f57a35
--- /dev/null
+++ b/ApiExtractor/parser/codemodel.h
@@ -0,0 +1,841 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef CODEMODEL_H
+#define CODEMODEL_H
+
+#include "codemodel_fwd.h"
+#include "codemodel_pointer.h"
+
+#include <QtCore/QHash>
+#include <QtCore/QList>
+#include <QtCore/QString>
+#include <QtCore/QStringList>
+#include <QtCore/QVector>
+
+#define DECLARE_MODEL_NODE(k) \
+    enum { __node_kind = Kind_##k }; \
+    typedef CodeModelPointer<k##ModelItem> Pointer;
+
+template <class _Target, class _Source>
+_Target model_static_cast(_Source item)
+{
+    typedef typename _Target::Type * _Target_pointer;
+
+    _Target ptr(static_cast<_Target_pointer>(item.data()));
+    return ptr;
+}
+
+class CodeModel
+{
+public:
+    enum AccessPolicy {
+        Public,
+        Protected,
+        Private
+    };
+
+    enum FunctionType {
+        Normal,
+        Signal,
+        Slot
+    };
+
+    enum ClassType {
+        Class,
+        Struct,
+        Union
+    };
+
+public:
+    CodeModel();
+    virtual ~CodeModel();
+
+    template <class _Target> _Target create()
+    {
+        typedef typename _Target::Type _Target_type;
+
+        _Target result = _Target_type::create(this);
+        result->setCreationId(_M_creation_id++);
+        return result;
+    }
+
+    FileList files() const;
+    NamespaceModelItem globalNamespace() const;
+
+    void addFile(FileModelItem item);
+    void removeFile(FileModelItem item);
+    FileModelItem findFile(const QString &name) const;
+    QHash<QString, FileModelItem> fileMap() const;
+
+    CodeModelItem findItem(const QStringList &qualifiedName, CodeModelItem scope) const;
+
+    void wipeout();
+
+private:
+    QHash<QString, FileModelItem> _M_files;
+    NamespaceModelItem _M_globalNamespace;
+    std::size_t _M_creation_id;
+
+private:
+    CodeModel(const CodeModel &other);
+    void operator = (const CodeModel &other);
+};
+
+class TypeInfo
+{
+public:
+    TypeInfo(const TypeInfo &other)
+            : flags(other.flags),
+            m_qualifiedName(other.m_qualifiedName),
+            m_arrayElements(other.m_arrayElements),
+            m_arguments(other.m_arguments)
+    {}
+
+    TypeInfo():
+            flags(0) {}
+
+    QStringList qualifiedName() const
+    {
+        return m_qualifiedName;
+    }
+
+    void setQualifiedName(const QStringList &qualified_name)
+    {
+        m_qualifiedName = qualified_name;
+    }
+
+    bool isConstant() const
+    {
+        return m_constant;
+    }
+
+    void setConstant(bool is)
+    {
+        m_constant = is;
+    }
+
+    bool isVolatile() const
+    {
+        return m_volatile;
+    }
+
+    void setVolatile(bool is)
+    {
+        m_volatile = is;
+    }
+
+    bool isReference() const
+    {
+        return m_reference;
+    }
+
+    void setReference(bool is)
+    {
+        m_reference = is;
+    }
+
+    int indirections() const
+    {
+        return m_indirections;
+    }
+
+    void setIndirections(int indirections)
+    {
+        m_indirections = indirections;
+    }
+
+    bool isFunctionPointer() const
+    {
+        return m_functionPointer;
+    }
+    void setFunctionPointer(bool is)
+    {
+        m_functionPointer = is;
+    }
+
+    QStringList arrayElements() const
+    {
+        return m_arrayElements;
+    }
+    void setArrayElements(const QStringList &arrayElements)
+    {
+        m_arrayElements = arrayElements;
+    }
+
+    QList<TypeInfo> arguments() const
+    {
+        return m_arguments;
+    }
+
+    void setArguments(const QList<TypeInfo> &arguments);
+
+    void addArgument(const TypeInfo &arg)
+    {
+        m_arguments.append(arg);
+    }
+
+    bool operator==(const TypeInfo &other);
+
+    bool operator!=(const TypeInfo &other)
+    {
+        return !(*this == other);
+    }
+
+    // ### arrays and templates??
+
+    QString toString() const;
+
+    static TypeInfo combine(const TypeInfo &__lhs, const TypeInfo &__rhs);
+    static TypeInfo resolveType(TypeInfo const &__type, CodeModelItem __scope);
+
+private:
+    union {
+        uint flags;
+
+        struct {
+            uint m_constant: 1;
+            uint m_volatile: 1;
+            uint m_reference: 1;
+            uint m_functionPointer: 1;
+            uint m_indirections: 6;
+            uint m_padding: 22;
+        };
+    };
+
+    QStringList m_qualifiedName;
+    QStringList m_arrayElements;
+    QList<TypeInfo> m_arguments;
+};
+
+class _CodeModelItem: public QSharedData
+{
+public:
+    enum Kind {
+        /* These are bit-flags resembling inheritance */
+        Kind_Scope = 0x1,
+        Kind_Namespace = 0x2 | Kind_Scope,
+        Kind_Member = 0x4,
+        Kind_Function = 0x8 | Kind_Member,
+        KindMask = 0xf,
+
+        /* These are for classes that are not inherited from */
+        FirstKind = 0x8,
+        Kind_Argument = 1 << FirstKind,
+        Kind_Class = 2 << FirstKind | Kind_Scope,
+        Kind_Enum = 3 << FirstKind,
+        Kind_Enumerator = 4 << FirstKind,
+        Kind_File = 5 << FirstKind | Kind_Namespace,
+        Kind_FunctionDefinition = 6 << FirstKind | Kind_Function,
+        Kind_TemplateParameter = 7 << FirstKind,
+        Kind_TypeAlias = 8 << FirstKind,
+        Kind_Variable = 9 << FirstKind | Kind_Member
+    };
+
+public:
+    virtual ~_CodeModelItem();
+
+    int kind() const;
+
+    QStringList qualifiedName() const;
+
+    QString name() const;
+    void setName(const QString &name);
+
+    QStringList scope() const;
+    void setScope(const QStringList &scope);
+
+    QString fileName() const;
+    void setFileName(const QString &fileName);
+
+    FileModelItem file() const;
+
+    void getStartPosition(int *line, int *column);
+    void setStartPosition(int line, int column);
+
+    void getEndPosition(int *line, int *column);
+    void setEndPosition(int line, int column);
+
+    inline std::size_t creationId() const
+    {
+        return _M_creation_id;
+    }
+
+    inline void setCreationId(std::size_t creation_id)
+    {
+        _M_creation_id = creation_id;
+    }
+
+    inline CodeModel *model() const
+    {
+        return _M_model;
+    }
+
+    CodeModelItem toItem() const;
+
+protected:
+    _CodeModelItem(CodeModel *model, int kind);
+    void setKind(int kind);
+
+private:
+    CodeModel *_M_model;
+    int _M_kind;
+    int _M_startLine;
+    int _M_startColumn;
+    int _M_endLine;
+    int _M_endColumn;
+    std::size_t _M_creation_id;
+    QString _M_name;
+    QString _M_fileName;
+    QStringList _M_scope;
+
+private:
+    _CodeModelItem(const _CodeModelItem &other);
+    void operator = (const _CodeModelItem &other);
+};
+
+class _ScopeModelItem: public _CodeModelItem
+{
+public:
+    DECLARE_MODEL_NODE(Scope)
+
+    static ScopeModelItem create(CodeModel *model);
+
+public:
+    ClassList classes() const;
+    EnumList enums() const;
+    FunctionDefinitionList functionDefinitions() const;
+    FunctionList functions() const;
+    TypeAliasList typeAliases() const;
+    VariableList variables() const;
+
+    void addClass(ClassModelItem item);
+    void addEnum(EnumModelItem item);
+    void addFunction(FunctionModelItem item);
+    void addFunctionDefinition(FunctionDefinitionModelItem item);
+    void addTypeAlias(TypeAliasModelItem item);
+    void addVariable(VariableModelItem item);
+
+    void removeClass(ClassModelItem item);
+    void removeEnum(EnumModelItem item);
+    void removeFunction(FunctionModelItem item);
+    void removeFunctionDefinition(FunctionDefinitionModelItem item);
+    void removeTypeAlias(TypeAliasModelItem item);
+    void removeVariable(VariableModelItem item);
+
+    ClassModelItem findClass(const QString &name) const;
+    EnumModelItem findEnum(const QString &name) const;
+    FunctionDefinitionList findFunctionDefinitions(const QString &name) const;
+    FunctionList findFunctions(const QString &name) const;
+    TypeAliasModelItem findTypeAlias(const QString &name) const;
+    VariableModelItem findVariable(const QString &name) const;
+
+    void addEnumsDeclaration(const QString &enumsDeclaration);
+    QStringList enumsDeclarations() const
+    {
+        return _M_enumsDeclarations;
+    }
+
+    inline QHash<QString, ClassModelItem> classMap() const
+    {
+        return _M_classes;
+    }
+    inline QHash<QString, EnumModelItem> enumMap() const
+    {
+        return _M_enums;
+    }
+    inline QHash<QString, TypeAliasModelItem> typeAliasMap() const
+    {
+        return _M_typeAliases;
+    }
+    inline QHash<QString, VariableModelItem> variableMap() const
+    {
+        return _M_variables;
+    }
+    inline QMultiHash<QString, FunctionDefinitionModelItem> functionDefinitionMap() const
+    {
+        return _M_functionDefinitions;
+    }
+    inline QMultiHash<QString, FunctionModelItem> functionMap() const
+    {
+        return _M_functions;
+    }
+
+    FunctionModelItem declaredFunction(FunctionModelItem item);
+
+protected:
+    _ScopeModelItem(CodeModel *model, int kind = __node_kind)
+            : _CodeModelItem(model, kind) {}
+
+private:
+    QHash<QString, ClassModelItem> _M_classes;
+    QHash<QString, EnumModelItem> _M_enums;
+    QHash<QString, TypeAliasModelItem> _M_typeAliases;
+    QHash<QString, VariableModelItem> _M_variables;
+    QMultiHash<QString, FunctionDefinitionModelItem> _M_functionDefinitions;
+    QMultiHash<QString, FunctionModelItem> _M_functions;
+
+private:
+    _ScopeModelItem(const _ScopeModelItem &other);
+    void operator = (const _ScopeModelItem &other);
+
+    QStringList _M_enumsDeclarations;
+};
+
+class _ClassModelItem: public _ScopeModelItem
+{
+public:
+    DECLARE_MODEL_NODE(Class)
+
+    static ClassModelItem create(CodeModel *model);
+
+public:
+    QStringList baseClasses() const;
+
+    void setBaseClasses(const QStringList &baseClasses);
+    void addBaseClass(const QString &baseClass);
+    void removeBaseClass(const QString &baseClass);
+
+    TemplateParameterList templateParameters() const;
+    void setTemplateParameters(const TemplateParameterList &templateParameters);
+
+    bool extendsClass(const QString &name) const;
+
+    void setClassType(CodeModel::ClassType type);
+    CodeModel::ClassType classType() const;
+
+    void addPropertyDeclaration(const QString &propertyDeclaration);
+    QStringList propertyDeclarations() const
+    {
+        return _M_propertyDeclarations;
+    }
+
+protected:
+    _ClassModelItem(CodeModel *model, int kind = __node_kind)
+            : _ScopeModelItem(model, kind), _M_classType(CodeModel::Class) {}
+
+private:
+    QStringList _M_baseClasses;
+    TemplateParameterList _M_templateParameters;
+    CodeModel::ClassType _M_classType;
+
+    QStringList _M_propertyDeclarations;
+
+private:
+    _ClassModelItem(const _ClassModelItem &other);
+    void operator = (const _ClassModelItem &other);
+};
+
+class _NamespaceModelItem: public _ScopeModelItem
+{
+public:
+    DECLARE_MODEL_NODE(Namespace)
+
+    static NamespaceModelItem create(CodeModel *model);
+
+public:
+    NamespaceList namespaces() const;
+
+    void addNamespace(NamespaceModelItem item);
+    void removeNamespace(NamespaceModelItem item);
+
+    NamespaceModelItem findNamespace(const QString &name) const;
+
+    inline QHash<QString, NamespaceModelItem> namespaceMap() const
+    {
+        return _M_namespaces;
+    };
+
+protected:
+    _NamespaceModelItem(CodeModel *model, int kind = __node_kind)
+            : _ScopeModelItem(model, kind) {}
+
+private:
+    QHash<QString, NamespaceModelItem> _M_namespaces;
+
+private:
+    _NamespaceModelItem(const _NamespaceModelItem &other);
+    void operator = (const _NamespaceModelItem &other);
+};
+
+class _FileModelItem: public _NamespaceModelItem
+{
+public:
+    DECLARE_MODEL_NODE(File)
+
+    static FileModelItem create(CodeModel *model);
+
+protected:
+    _FileModelItem(CodeModel *model, int kind = __node_kind)
+            : _NamespaceModelItem(model, kind) {}
+
+private:
+    _FileModelItem(const _FileModelItem &other);
+    void operator = (const _FileModelItem &other);
+};
+
+class _ArgumentModelItem: public _CodeModelItem
+{
+public:
+    DECLARE_MODEL_NODE(Argument)
+
+    static ArgumentModelItem create(CodeModel *model);
+
+public:
+    TypeInfo type() const;
+    void setType(const TypeInfo &type);
+
+    bool defaultValue() const;
+    void setDefaultValue(bool defaultValue);
+
+    QString defaultValueExpression() const
+    {
+        return _M_defaultValueExpression;
+    }
+
+    void setDefaultValueExpression(const QString &expr)
+    {
+        _M_defaultValueExpression = expr;
+    }
+
+protected:
+    _ArgumentModelItem(CodeModel *model, int kind = __node_kind)
+            : _CodeModelItem(model, kind), _M_defaultValue(false) {}
+
+private:
+    TypeInfo _M_type;
+    QString _M_defaultValueExpression;
+    bool _M_defaultValue;
+
+private:
+    _ArgumentModelItem(const _ArgumentModelItem &other);
+    void operator = (const _ArgumentModelItem &other);
+};
+
+class _MemberModelItem: public _CodeModelItem
+{
+public:
+    DECLARE_MODEL_NODE(Member)
+
+    bool isConstant() const;
+    void setConstant(bool isConstant);
+
+    bool isVolatile() const;
+    void setVolatile(bool isVolatile);
+
+    bool isStatic() const;
+    void setStatic(bool isStatic);
+
+    bool isAuto() const;
+    void setAuto(bool isAuto);
+
+    bool isFriend() const;
+    void setFriend(bool isFriend);
+
+    bool isRegister() const;
+    void setRegister(bool isRegister);
+
+    bool isExtern() const;
+    void setExtern(bool isExtern);
+
+    bool isMutable() const;
+    void setMutable(bool isMutable);
+
+    CodeModel::AccessPolicy accessPolicy() const;
+    void setAccessPolicy(CodeModel::AccessPolicy accessPolicy);
+
+    TemplateParameterList templateParameters() const
+    {
+        return _M_templateParameters;
+    }
+
+    void setTemplateParameters(const TemplateParameterList &templateParameters)
+    {
+        _M_templateParameters = templateParameters;
+    }
+
+    TypeInfo type() const;
+    void setType(const TypeInfo &type);
+
+protected:
+    _MemberModelItem(CodeModel *model, int kind)
+            : _CodeModelItem(model, kind),
+            _M_accessPolicy(CodeModel::Public),
+            _M_flags(0) {}
+
+private:
+    TemplateParameterList _M_templateParameters;
+    TypeInfo _M_type;
+    CodeModel::AccessPolicy _M_accessPolicy;
+    union {
+        struct {
+            uint _M_isConstant: 1;
+            uint _M_isVolatile: 1;
+            uint _M_isStatic: 1;
+            uint _M_isAuto: 1;
+            uint _M_isFriend: 1;
+            uint _M_isRegister: 1;
+            uint _M_isExtern: 1;
+            uint _M_isMutable: 1;
+        };
+        uint _M_flags;
+    };
+
+};
+
+class _FunctionModelItem: public _MemberModelItem
+{
+public:
+    DECLARE_MODEL_NODE(Function)
+
+    static FunctionModelItem create(CodeModel *model);
+
+public:
+    ArgumentList arguments() const;
+
+    void addArgument(ArgumentModelItem item);
+    void removeArgument(ArgumentModelItem item);
+
+    CodeModel::FunctionType functionType() const;
+    void setFunctionType(CodeModel::FunctionType functionType);
+
+    bool isVirtual() const;
+    void setVirtual(bool isVirtual);
+
+    bool isInline() const;
+    void setInline(bool isInline);
+
+    bool isExplicit() const;
+    void setExplicit(bool isExplicit);
+
+    bool isInvokable() const; // Qt
+    void setInvokable(bool isInvokable); // Qt
+
+    bool isAbstract() const;
+    void setAbstract(bool isAbstract);
+
+    bool isVariadics() const;
+    void setVariadics(bool isVariadics);
+
+    bool isSimilar(FunctionModelItem other) const;
+
+protected:
+    _FunctionModelItem(CodeModel *model, int kind = __node_kind)
+            : _MemberModelItem(model, kind),
+            _M_functionType(CodeModel::Normal),
+            _M_flags(0) {}
+
+private:
+    ArgumentList _M_arguments;
+    CodeModel::FunctionType _M_functionType;
+    union {
+        struct {
+            uint _M_isVirtual: 1;
+            uint _M_isInline: 1;
+            uint _M_isAbstract: 1;
+            uint _M_isExplicit: 1;
+            uint _M_isVariadics: 1;
+            uint _M_isInvokable : 1; // Qt
+        };
+        uint _M_flags;
+    };
+
+private:
+    _FunctionModelItem(const _FunctionModelItem &other);
+    void operator = (const _FunctionModelItem &other);
+};
+
+class _FunctionDefinitionModelItem: public _FunctionModelItem
+{
+public:
+    DECLARE_MODEL_NODE(FunctionDefinition)
+
+    static FunctionDefinitionModelItem create(CodeModel *model);
+
+protected:
+    _FunctionDefinitionModelItem(CodeModel *model, int kind = __node_kind)
+            : _FunctionModelItem(model, kind) {}
+
+private:
+    _FunctionDefinitionModelItem(const _FunctionDefinitionModelItem &other);
+    void operator = (const _FunctionDefinitionModelItem &other);
+};
+
+class _VariableModelItem: public _MemberModelItem
+{
+public:
+    DECLARE_MODEL_NODE(Variable)
+
+    static VariableModelItem create(CodeModel *model);
+
+protected:
+    _VariableModelItem(CodeModel *model, int kind = __node_kind)
+            : _MemberModelItem(model, kind) {}
+
+private:
+    _VariableModelItem(const _VariableModelItem &other);
+    void operator = (const _VariableModelItem &other);
+};
+
+class _TypeAliasModelItem: public _CodeModelItem
+{
+public:
+    DECLARE_MODEL_NODE(TypeAlias)
+
+    static TypeAliasModelItem create(CodeModel *model);
+
+public:
+    TypeInfo type() const;
+    void setType(const TypeInfo &type);
+
+protected:
+    _TypeAliasModelItem(CodeModel *model, int kind = __node_kind)
+            : _CodeModelItem(model, kind) {}
+
+private:
+    TypeInfo _M_type;
+
+private:
+    _TypeAliasModelItem(const _TypeAliasModelItem &other);
+    void operator = (const _TypeAliasModelItem &other);
+};
+
+class _EnumModelItem: public _CodeModelItem
+{
+public:
+    DECLARE_MODEL_NODE(Enum)
+
+    static EnumModelItem create(CodeModel *model);
+
+public:
+    CodeModel::AccessPolicy accessPolicy() const;
+    void setAccessPolicy(CodeModel::AccessPolicy accessPolicy);
+
+    EnumeratorList enumerators() const;
+    void addEnumerator(EnumeratorModelItem item);
+    void removeEnumerator(EnumeratorModelItem item);
+    bool isAnonymous() const;
+    void setAnonymous(bool anonymous);
+
+protected:
+    _EnumModelItem(CodeModel *model, int kind = __node_kind)
+            : _CodeModelItem(model, kind),
+            _M_accessPolicy(CodeModel::Public) {}
+
+private:
+    CodeModel::AccessPolicy _M_accessPolicy;
+    EnumeratorList _M_enumerators;
+    bool _M_anonymous;
+
+private:
+    _EnumModelItem(const _EnumModelItem &other);
+    void operator = (const _EnumModelItem &other);
+};
+
+class _EnumeratorModelItem: public _CodeModelItem
+{
+public:
+    DECLARE_MODEL_NODE(Enumerator)
+
+    static EnumeratorModelItem create(CodeModel *model);
+
+public:
+    QString value() const;
+    void setValue(const QString &value);
+
+protected:
+    _EnumeratorModelItem(CodeModel *model, int kind = __node_kind)
+            : _CodeModelItem(model, kind) {}
+
+private:
+    QString _M_value;
+
+private:
+    _EnumeratorModelItem(const _EnumeratorModelItem &other);
+    void operator = (const _EnumeratorModelItem &other);
+};
+
+class _TemplateParameterModelItem: public _CodeModelItem
+{
+public:
+    DECLARE_MODEL_NODE(TemplateParameter)
+
+    static TemplateParameterModelItem create(CodeModel *model);
+
+public:
+    TypeInfo type() const;
+    void setType(const TypeInfo &type);
+
+    bool defaultValue() const;
+    void setDefaultValue(bool defaultValue);
+
+protected:
+    _TemplateParameterModelItem(CodeModel *model, int kind = __node_kind)
+            : _CodeModelItem(model, kind), _M_defaultValue(false) {}
+
+private:
+    TypeInfo _M_type;
+    bool _M_defaultValue;
+
+private:
+    _TemplateParameterModelItem(const _TemplateParameterModelItem &other);
+    void operator = (const _TemplateParameterModelItem &other);
+};
+
+template <class _Target, class _Source>
+_Target model_safe_cast(_Source item)
+{
+    typedef typename _Target::Type * _Target_pointer;
+    typedef typename _Source::Type * _Source_pointer;
+
+    _Source_pointer source = item.data();
+    if (source && source->kind() == _Target_pointer(0)->__node_kind) {
+        _Target ptr(static_cast<_Target_pointer>(source));
+        return ptr;
+    }
+
+    return _Target();
+}
+
+template <typename _Target, typename _Source>
+_Target model_dynamic_cast(_Source item)
+{
+    typedef typename _Target::Type * _Target_pointer;
+    typedef typename _Source::Type * _Source_pointer;
+
+    _Source_pointer source = item.data();
+    if (source && (source->kind() == _Target_pointer(0)->__node_kind
+                   || (int(_Target_pointer(0)->__node_kind) <= int(_CodeModelItem::KindMask)
+                       && ((source->kind() & _Target_pointer(0)->__node_kind)
+                           == _Target_pointer(0)->__node_kind)))) {
+        _Target ptr(static_cast<_Target_pointer>(source));
+        return ptr;
+    }
+
+    return _Target();
+}
+#endif // CODEMODEL_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/codemodel_finder.cpp b/ApiExtractor/parser/codemodel_finder.cpp
new file mode 100644
index 000000000..866ea1cbd
--- /dev/null
+++ b/ApiExtractor/parser/codemodel_finder.cpp
@@ -0,0 +1,98 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "codemodel_finder.h"
+#include "codemodel.h"
+#include "binder.h"
+
+CodeModelFinder::CodeModelFinder(CodeModel *model, Binder *binder)
+        : _M_model(model),
+        _M_binder(binder),
+        _M_token_stream(binder->tokenStream()),
+        name_cc(_M_binder),
+        _M_resolve_policy(ResolveItem)
+{
+}
+
+CodeModelFinder::~CodeModelFinder()
+{
+}
+
+ScopeModelItem CodeModelFinder::resolveScope(NameAST *name, ScopeModelItem scope)
+{
+    Q_ASSERT(scope);
+
+    ResolvePolicy saved_resolve_policy = _M_resolve_policy;
+    _M_resolve_policy = ResolveScope;
+
+    ScopeModelItem old = changeCurrentScope(scope);
+
+    visit(name);
+    ScopeModelItem result = _M_current_scope;
+
+    changeCurrentScope(old); // restore
+
+    _M_resolve_policy = saved_resolve_policy;
+
+    return result;
+}
+
+ScopeModelItem CodeModelFinder::changeCurrentScope(ScopeModelItem scope)
+{
+    ScopeModelItem old = _M_current_scope;
+    _M_current_scope = scope;
+    return old;
+}
+
+void CodeModelFinder::visitName(NameAST *node)
+{
+    visitNodes(this, node->qualified_names);
+
+    if (_M_resolve_policy == ResolveItem)
+        visit(node->unqualified_name);
+}
+
+void CodeModelFinder::visitUnqualifiedName(UnqualifiedNameAST *node)
+{
+    if (!_M_current_scope) {
+        // nothing to do
+        return;
+    }
+
+    name_cc.run(node);
+    QString id = name_cc.name();
+
+    if (ClassModelItem klass = _M_current_scope->findClass(id)) {
+        _M_current_scope = klass;
+    } else if (NamespaceModelItem parentNamespace = model_safe_cast<NamespaceModelItem>(_M_current_scope)) {
+        NamespaceModelItem ns = parentNamespace->findNamespace(id);
+        _M_current_scope = model_static_cast<ScopeModelItem>(ns);
+    } else if (FileModelItem file = model_safe_cast<FileModelItem>(_M_current_scope)) {
+        NamespaceModelItem ns = file->findNamespace(id);
+        _M_current_scope = model_static_cast<ScopeModelItem>(ns);
+    }
+}
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
+
diff --git a/ApiExtractor/parser/codemodel_finder.h b/ApiExtractor/parser/codemodel_finder.h
new file mode 100644
index 000000000..ac1b5b0eb
--- /dev/null
+++ b/ApiExtractor/parser/codemodel_finder.h
@@ -0,0 +1,70 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef CODEMODEL_FINDER_H
+#define CODEMODEL_FINDER_H
+
+#include <default_visitor.h>
+#include <codemodel_fwd.h>
+#include <name_compiler.h>
+
+class TokenStream;
+class Binder;
+
+class CodeModelFinder: protected DefaultVisitor
+{
+    enum ResolvePolicy {
+        ResolveScope,
+        ResolveItem
+    };
+
+public:
+    CodeModelFinder(CodeModel *model, Binder *binder);
+    virtual ~CodeModelFinder();
+
+    ScopeModelItem resolveScope(NameAST *name, ScopeModelItem scope);
+
+    inline CodeModel *model() const
+    {
+        return _M_model;
+    }
+
+protected:
+    virtual void visitName(NameAST *node);
+    virtual void visitUnqualifiedName(UnqualifiedNameAST *node);
+
+    ScopeModelItem changeCurrentScope(ScopeModelItem scope);
+
+private:
+    CodeModel *_M_model;
+    Binder *_M_binder;
+    TokenStream *_M_token_stream;
+    NameCompiler name_cc;
+
+    ScopeModelItem _M_current_scope;
+    ResolvePolicy _M_resolve_policy;
+};
+
+#endif // CODEMODEL_FINDER_H
diff --git a/ApiExtractor/parser/codemodel_fwd.h b/ApiExtractor/parser/codemodel_fwd.h
new file mode 100644
index 000000000..96405909c
--- /dev/null
+++ b/ApiExtractor/parser/codemodel_fwd.h
@@ -0,0 +1,80 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef CODEMODEL_FWD_H
+#define CODEMODEL_FWD_H
+
+#include "codemodel_pointer.h"
+#include <QtCore/QList>
+
+// forward declarations
+class CodeModel;
+class _ArgumentModelItem;
+class _ClassModelItem;
+class _CodeModelItem;
+class _EnumModelItem;
+class _EnumeratorModelItem;
+class _FileModelItem;
+class _FunctionDefinitionModelItem;
+class _FunctionModelItem;
+class _NamespaceModelItem;
+class _ScopeModelItem;
+class _TemplateParameterModelItem;
+class _TypeAliasModelItem;
+class _VariableModelItem;
+class _MemberModelItem;
+class TypeInfo;
+
+typedef CodeModelPointer<_ArgumentModelItem> ArgumentModelItem;
+typedef CodeModelPointer<_ClassModelItem> ClassModelItem;
+typedef CodeModelPointer<_CodeModelItem> CodeModelItem;
+typedef CodeModelPointer<_EnumModelItem> EnumModelItem;
+typedef CodeModelPointer<_EnumeratorModelItem> EnumeratorModelItem;
+typedef CodeModelPointer<_FileModelItem> FileModelItem;
+typedef CodeModelPointer<_FunctionDefinitionModelItem> FunctionDefinitionModelItem;
+typedef CodeModelPointer<_FunctionModelItem> FunctionModelItem;
+typedef CodeModelPointer<_NamespaceModelItem> NamespaceModelItem;
+typedef CodeModelPointer<_ScopeModelItem> ScopeModelItem;
+typedef CodeModelPointer<_TemplateParameterModelItem> TemplateParameterModelItem;
+typedef CodeModelPointer<_TypeAliasModelItem> TypeAliasModelItem;
+typedef CodeModelPointer<_VariableModelItem> VariableModelItem;
+typedef CodeModelPointer<_MemberModelItem> MemberModelItem;
+
+typedef QList<ArgumentModelItem> ArgumentList;
+typedef QList<ClassModelItem> ClassList;
+typedef QList<CodeModelItem> ItemList;
+typedef QList<EnumModelItem> EnumList;
+typedef QList<EnumeratorModelItem> EnumeratorList;
+typedef QList<FileModelItem> FileList;
+typedef QList<FunctionDefinitionModelItem> FunctionDefinitionList;
+typedef QList<FunctionModelItem> FunctionList;
+typedef QList<NamespaceModelItem> NamespaceList;
+typedef QList<ScopeModelItem> ScopeList;
+typedef QList<TemplateParameterModelItem> TemplateParameterList;
+typedef QList<TypeAliasModelItem> TypeAliasList;
+typedef QList<VariableModelItem> VariableList;
+typedef QList<MemberModelItem> MemberList;
+
+#endif // CODEMODEL_FWD_H
diff --git a/ApiExtractor/parser/codemodel_pointer.h b/ApiExtractor/parser/codemodel_pointer.h
new file mode 100644
index 000000000..2c728f3c5
--- /dev/null
+++ b/ApiExtractor/parser/codemodel_pointer.h
@@ -0,0 +1,60 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2006 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef CODEMODEL_POINTER_H
+#define CODEMODEL_POINTER_H
+
+#include <QtCore/QSharedData>
+#include <QAtomicPointer>
+
+template <class T> class CodeModelPointer : public QAtomicPointer<T>
+{
+public:
+    typedef T Type;
+
+    inline CodeModelPointer(T *value = 0) : QAtomicPointer<T>(value) {}
+
+    inline CodeModelPointer &operator=(T *o)
+    {
+        QAtomicPointer<T>::operator=(o);
+        return *this;
+    }
+
+    inline T *data()
+    {
+        return (T *) *this;
+    }
+
+    inline const T *data() const
+    {
+        return (const T *) *this;
+    }
+
+    inline const T *constData() const
+    {
+        return (const T *) *this;
+    }
+};
+
+#endif // CODEMODEL_POINTER_H
diff --git a/ApiExtractor/parser/compiler_utils.cpp b/ApiExtractor/parser/compiler_utils.cpp
new file mode 100644
index 000000000..49624149a
--- /dev/null
+++ b/ApiExtractor/parser/compiler_utils.cpp
@@ -0,0 +1,50 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#include "compiler_utils.h"
+#include "type_compiler.h"
+#include "name_compiler.h"
+#include "declarator_compiler.h"
+#include "ast.h"
+#include "binder.h"
+
+TypeInfo CompilerUtils::typeDescription(TypeSpecifierAST *type_specifier, DeclaratorAST *declarator, Binder *binder)
+{
+    TypeCompiler type_cc(binder);
+    DeclaratorCompiler decl_cc(binder);
+
+    type_cc.run(type_specifier);
+    decl_cc.run(declarator);
+
+    TypeInfo typeInfo;
+    typeInfo.setQualifiedName(type_cc.qualifiedName());
+    typeInfo.setConstant(type_cc.isConstant());
+    typeInfo.setVolatile(type_cc.isVolatile());
+    typeInfo.setReference(decl_cc.isReference());
+    typeInfo.setIndirections(decl_cc.indirection());
+    typeInfo.setArrayElements(decl_cc.arrayElements());
+
+    return typeInfo;
+}
diff --git a/ApiExtractor/parser/compiler_utils.h b/ApiExtractor/parser/compiler_utils.h
new file mode 100644
index 000000000..fdd96f15b
--- /dev/null
+++ b/ApiExtractor/parser/compiler_utils.h
@@ -0,0 +1,47 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef COMPILER_UTILS_H
+#define COMPILER_UTILS_H
+
+#include <utility>
+
+#include "codemodel.h"
+
+class QString;
+class QStringList;
+struct TypeSpecifierAST;
+struct DeclaratorAST;
+class TokenStream;
+class Binder;
+
+namespace CompilerUtils
+{
+
+TypeInfo typeDescription(TypeSpecifierAST *type_specifier, DeclaratorAST *declarator, Binder *binder);
+
+} // namespace CompilerUtils
+
+#endif // COMPILER_UTILS_H
diff --git a/ApiExtractor/parser/control.cpp b/ApiExtractor/parser/control.cpp
new file mode 100644
index 000000000..9615debba
--- /dev/null
+++ b/ApiExtractor/parser/control.cpp
@@ -0,0 +1,130 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#include "control.h"
+#include "lexer.h"
+
+Control::Control()
+        : current_context(0),
+        _M_skipFunctionBody(false),
+        _M_lexer(0),
+        _M_parser(0)
+{
+    pushContext();
+
+    declareTypedef(findOrInsertName("__builtin_va_list",
+                                    strlen("__builtin_va_list")), 0);
+}
+
+Control::~Control()
+{
+    popContext();
+
+    Q_ASSERT(current_context == 0);
+}
+
+Lexer *Control::changeLexer(Lexer *lexer)
+{
+    Lexer *old = _M_lexer;
+    _M_lexer = lexer;
+    return old;
+}
+
+Parser *Control::changeParser(Parser *parser)
+{
+    Parser *old = _M_parser;
+    _M_parser = parser;
+    return old;
+}
+
+Type *Control::lookupType(const NameSymbol *name) const
+{
+    Q_ASSERT(current_context != 0);
+
+    return current_context->resolve(name);
+}
+
+void Control::declare(const NameSymbol *name, Type *type)
+{
+    //printf("*** Declare:");
+    //printSymbol(name);
+    //putchar('\n');
+    Q_ASSERT(current_context != 0);
+
+    current_context->bind(name, type);
+}
+
+void Control::pushContext()
+{
+    // printf("+Context\n");
+    Context *new_context = new Context;
+    new_context->parent = current_context;
+    current_context = new_context;
+}
+
+void Control::popContext()
+{
+    // printf("-Context\n");
+    Q_ASSERT(current_context != 0);
+
+    Context *old_context = current_context;
+    current_context = current_context->parent;
+
+    delete old_context;
+}
+
+void Control::declareTypedef(const NameSymbol *name, Declarator *d)
+{
+    //  printf("declared typedef:");
+    //  printSymbol(name);
+    //  printf("\n");
+    stl_typedef_table.insert(name, d);
+}
+
+bool Control::isTypedef(const NameSymbol *name) const
+{
+    //  printf("is typedef:");
+    //  printSymbol(name);
+    // printf("= %d\n", (stl_typedef_table.find(name) != stl_typedef_table.end()));
+
+    return stl_typedef_table.contains(name);
+}
+
+QList<Control::ErrorMessage> Control::errorMessages() const
+{
+    return _M_error_messages;
+}
+
+void Control::clearErrorMessages()
+{
+    _M_error_messages.clear();
+}
+
+void Control::reportError(const ErrorMessage &errmsg)
+{
+    _M_error_messages.append(errmsg);
+}
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/control.h b/ApiExtractor/parser/control.h
new file mode 100644
index 000000000..533db912c
--- /dev/null
+++ b/ApiExtractor/parser/control.h
@@ -0,0 +1,160 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef CONTROL_H
+#define CONTROL_H
+
+#include "symbol.h"
+#include "smallobject.h"
+
+#include <QtCore/QHash>
+
+struct Declarator;
+struct Type;
+class Lexer;
+class Parser;
+
+struct Context {
+    Context *parent;
+
+    inline void bind(const NameSymbol *name, Type *type) {
+        symbol_table.insert(name, type);
+    }
+
+    inline Type *resolve(const NameSymbol *name) const {
+        if (Type *type = symbol_table.value(name))
+            return type;
+        else if (parent)
+            return parent->resolve(name);
+
+        return 0;
+    }
+
+    typedef QHash<const NameSymbol*, Type*> symbol_table_t;
+
+    symbol_table_t symbol_table;
+};
+
+class Control
+{
+public:
+    class ErrorMessage
+    {
+    public:
+        ErrorMessage():
+                _M_line(0),
+                _M_column(0) {}
+
+        inline int line() const {
+            return _M_line;
+        }
+        inline void setLine(int line) {
+            _M_line = line;
+        }
+
+        inline int column() const {
+            return _M_column;
+        }
+        inline void setColumn(int column) {
+            _M_column = column;
+        }
+
+        inline QString fileName() const {
+            return _M_fileName;
+        }
+        inline void setFileName(const QString &fileName) {
+            _M_fileName = fileName;
+        }
+
+        inline QString message() const {
+            return _M_message;
+        }
+        inline void setMessage(const QString &message) {
+            _M_message = message;
+        }
+
+    private:
+        int _M_line;
+        int _M_column;
+        QString _M_fileName;
+        QString _M_message;
+    };
+
+    Control();
+    ~Control();
+
+    inline bool skipFunctionBody() const {
+        return _M_skipFunctionBody;
+    }
+    inline void setSkipFunctionBody(bool skip) {
+        _M_skipFunctionBody = skip;
+    }
+
+    Lexer *changeLexer(Lexer *lexer);
+    Parser *changeParser(Parser *parser);
+
+    Lexer *currentLexer() const {
+        return _M_lexer;
+    }
+    Parser *currentParser() const {
+        return _M_parser;
+    }
+
+    Context *current_context;
+
+    inline Context *currentContext() const {
+        return current_context;
+    }
+
+    void pushContext();
+    void popContext();
+
+    Type *lookupType(const NameSymbol *name) const;
+    void declare(const NameSymbol *name, Type *type);
+
+    inline const NameSymbol *findOrInsertName(const char *data, size_t count) {
+        return name_table.findOrInsert(data, count);
+    }
+
+    void declareTypedef(const NameSymbol *name, Declarator *d);
+    bool isTypedef(const NameSymbol *name) const;
+
+    void reportError(const ErrorMessage &errmsg);
+    QList<ErrorMessage> errorMessages() const;
+    void clearErrorMessages();
+
+private:
+    NameTable name_table;
+    QHash<const NameSymbol*, Declarator*> stl_typedef_table;
+    bool _M_skipFunctionBody;
+    Lexer *_M_lexer;
+    Parser *_M_parser;
+
+    QList<ErrorMessage> _M_error_messages;
+};
+
+#endif // CONTROL_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/declarator_compiler.cpp b/ApiExtractor/parser/declarator_compiler.cpp
new file mode 100644
index 000000000..255bfcddb
--- /dev/null
+++ b/ApiExtractor/parser/declarator_compiler.cpp
@@ -0,0 +1,147 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#include "declarator_compiler.h"
+#include "name_compiler.h"
+#include "type_compiler.h"
+#include "compiler_utils.h"
+#include "lexer.h"
+#include "binder.h"
+#include "tokens.h"
+
+#include <qdebug.h>
+
+DeclaratorCompiler::DeclaratorCompiler(Binder *binder)
+        : _M_binder(binder), _M_token_stream(binder->tokenStream())
+{
+}
+
+void DeclaratorCompiler::run(DeclaratorAST *node)
+{
+    _M_id.clear();
+    _M_parameters.clear();
+    _M_array.clear();
+    _M_function = false;
+    _M_reference = false;
+    _M_variadics = false;
+    _M_indirection = 0;
+
+    if (node) {
+        NameCompiler name_cc(_M_binder);
+
+        DeclaratorAST *decl = node;
+        while (decl && decl->sub_declarator)
+            decl = decl->sub_declarator;
+
+        Q_ASSERT(decl != 0);
+
+        name_cc.run(decl->id);
+        _M_id = name_cc.name();
+        _M_function = (node->parameter_declaration_clause != 0);
+        if (node->parameter_declaration_clause && node->parameter_declaration_clause->ellipsis)
+            _M_variadics = true;
+
+        visitNodes(this, node->ptr_ops);
+        visit(node->parameter_declaration_clause);
+
+        if (const ListNode<ExpressionAST*> *it = node->array_dimensions) {
+            it->toFront();
+            const ListNode<ExpressionAST*> *end = it;
+
+            do {
+                QString elt;
+                if (ExpressionAST *expr = it->element) {
+                    const Token &start_token = _M_token_stream->token((int) expr->start_token);
+                    const Token &end_token = _M_token_stream->token((int) expr->end_token);
+
+                    elt += QString::fromUtf8(&start_token.text[start_token.position],
+                                             (int)(end_token.position - start_token.position)).trimmed();
+                }
+
+                _M_array.append(elt);
+
+                it = it->next;
+            } while (it != end);
+        }
+    }
+}
+
+void DeclaratorCompiler::visitPtrOperator(PtrOperatorAST *node)
+{
+    std::size_t op =  _M_token_stream->kind(node->op);
+
+    switch (op) {
+    case '&':
+        _M_reference = true;
+        break;
+    case '*':
+        ++_M_indirection;
+        break;
+
+    default:
+        break;
+    }
+
+    if (node->mem_ptr) {
+#if defined(__GNUC__)
+#warning "ptr to mem -- not implemented"
+#endif
+    }
+}
+
+void DeclaratorCompiler::visitParameterDeclaration(ParameterDeclarationAST *node)
+{
+    Parameter p;
+
+    TypeCompiler type_cc(_M_binder);
+    DeclaratorCompiler decl_cc(_M_binder);
+
+    decl_cc.run(node->declarator);
+
+    p.name = decl_cc.id();
+    p.type = CompilerUtils::typeDescription(node->type_specifier, node->declarator, _M_binder);
+    if (node->expression != 0) {
+        const Token &start = _M_token_stream->token((int) node->expression->start_token);
+        const Token &end = _M_token_stream->token((int) node->expression->end_token);
+        int length = (int)(end.position - start.position);
+
+        p.defaultValueExpression = QString();
+        QString source = QString::fromUtf8(&start.text[start.position], length).trimmed();
+        QStringList list = source.split("\n");
+
+
+        for (int i = 0; i < list.size(); ++i) {
+            if (!list.at(i).startsWith("#"))
+                p.defaultValueExpression += list.at(i).trimmed();
+        }
+
+        p.defaultValue = p.defaultValueExpression.size() > 0;
+
+    }
+
+    _M_parameters.append(p);
+}
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/declarator_compiler.h b/ApiExtractor/parser/declarator_compiler.h
new file mode 100644
index 000000000..70a65b058
--- /dev/null
+++ b/ApiExtractor/parser/declarator_compiler.h
@@ -0,0 +1,96 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef DECLARATOR_COMPILER_H
+#define DECLARATOR_COMPILER_H
+
+#include "default_visitor.h"
+#include "codemodel.h"
+
+#include <QtCore/QString>
+#include <QtCore/QList>
+
+class TokenStream;
+class Binder;
+
+class DeclaratorCompiler: protected DefaultVisitor
+{
+public:
+    struct Parameter {
+        TypeInfo type;
+        QString name;
+        QString defaultValueExpression;
+        bool defaultValue;
+
+        Parameter(): defaultValue(false) {}
+    };
+
+public:
+    DeclaratorCompiler(Binder *binder);
+
+    void run(DeclaratorAST *node);
+
+    inline QString id() const {
+        return _M_id;
+    }
+    inline QStringList arrayElements() const {
+        return _M_array;
+    }
+    inline bool isFunction() const {
+        return _M_function;
+    }
+    inline bool isVariadics() const {
+        return _M_variadics;
+    }
+    inline bool isReference() const {
+        return _M_reference;
+    }
+    inline int indirection() const {
+        return _M_indirection;
+    }
+    inline QList<Parameter> parameters() const {
+        return _M_parameters;
+    }
+
+protected:
+    virtual void visitPtrOperator(PtrOperatorAST *node);
+    virtual void visitParameterDeclaration(ParameterDeclarationAST *node);
+
+private:
+    Binder *_M_binder;
+    TokenStream *_M_token_stream;
+
+    bool _M_function;
+    bool _M_reference;
+    bool _M_variadics;
+    int _M_indirection;
+    QString _M_id;
+    QStringList _M_array;
+    QList<Parameter> _M_parameters;
+};
+
+#endif // DECLARATOR_COMPILER_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/default_visitor.cpp b/ApiExtractor/parser/default_visitor.cpp
new file mode 100644
index 000000000..07ab968cc
--- /dev/null
+++ b/ApiExtractor/parser/default_visitor.cpp
@@ -0,0 +1,459 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#include "default_visitor.h"
+
+void DefaultVisitor::visitAccessSpecifier(AccessSpecifierAST *)
+{
+    // nothing to do
+}
+
+void DefaultVisitor::visitAsmDefinition(AsmDefinitionAST *)
+{
+    // nothing to do
+}
+
+void DefaultVisitor::visitBaseClause(BaseClauseAST *node)
+{
+    visitNodes(this, node->base_specifiers);
+}
+
+void DefaultVisitor::visitBaseSpecifier(BaseSpecifierAST *node)
+{
+    visit(node->name);
+}
+
+void DefaultVisitor::visitBinaryExpression(BinaryExpressionAST *node)
+{
+    visit(node->left_expression);
+    visit(node->right_expression);
+}
+
+void DefaultVisitor::visitCastExpression(CastExpressionAST *node)
+{
+    visit(node->type_id);
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitClassMemberAccess(ClassMemberAccessAST *node)
+{
+    visit(node->name);
+}
+
+void DefaultVisitor::visitClassSpecifier(ClassSpecifierAST *node)
+{
+    visit(node->win_decl_specifiers);
+    visit(node->name);
+    visit(node->base_clause);
+    visitNodes(this, node->member_specs);
+}
+
+void DefaultVisitor::visitCompoundStatement(CompoundStatementAST *node)
+{
+    visitNodes(this, node->statements);
+}
+
+void DefaultVisitor::visitCondition(ConditionAST *node)
+{
+    visit(node->type_specifier);
+    visit(node->declarator);
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitConditionalExpression(ConditionalExpressionAST *node)
+{
+    visit(node->condition);
+    visit(node->left_expression);
+    visit(node->right_expression);
+}
+
+void DefaultVisitor::visitCppCastExpression(CppCastExpressionAST *node)
+{
+    visit(node->type_id);
+    visit(node->expression);
+    visitNodes(this, node->sub_expressions);
+}
+
+void DefaultVisitor::visitCtorInitializer(CtorInitializerAST *node)
+{
+    visitNodes(this, node->member_initializers);
+}
+
+void DefaultVisitor::visitDeclarationStatement(DeclarationStatementAST *node)
+{
+    visit(node->declaration);
+}
+
+void DefaultVisitor::visitDeclarator(DeclaratorAST *node)
+{
+    visit(node->sub_declarator);
+    visitNodes(this, node->ptr_ops);
+    visit(node->id);
+    visit(node->bit_expression);
+    visitNodes(this, node->array_dimensions);
+    visit(node->parameter_declaration_clause);
+    visit(node->exception_spec);
+}
+
+void DefaultVisitor::visitDeleteExpression(DeleteExpressionAST *node)
+{
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitDoStatement(DoStatementAST *node)
+{
+    visit(node->statement);
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST *node)
+{
+    visit(node->name);
+}
+
+void DefaultVisitor::visitEnumSpecifier(EnumSpecifierAST *node)
+{
+    visit(node->name);
+    visitNodes(this, node->enumerators);
+}
+
+void DefaultVisitor::visitEnumerator(EnumeratorAST *node)
+{
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitExceptionSpecification(ExceptionSpecificationAST *node)
+{
+    visitNodes(this, node->type_ids);
+}
+
+void DefaultVisitor::visitExpressionOrDeclarationStatement(ExpressionOrDeclarationStatementAST *node)
+{
+    visit(node->expression);
+    visit(node->declaration);
+}
+
+void DefaultVisitor::visitExpressionStatement(ExpressionStatementAST *node)
+{
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitForStatement(ForStatementAST *node)
+{
+    visit(node->init_statement);
+    visit(node->condition);
+    visit(node->expression);
+    visit(node->statement);
+}
+
+void DefaultVisitor::visitFunctionCall(FunctionCallAST *node)
+{
+    visit(node->arguments);
+}
+
+void DefaultVisitor::visitFunctionDefinition(FunctionDefinitionAST *node)
+{
+    visit(node->type_specifier);
+    visit(node->init_declarator);
+    visit(node->function_body);
+    visit(node->win_decl_specifiers);
+}
+
+void DefaultVisitor::visitIfStatement(IfStatementAST *node)
+{
+    visit(node->condition);
+    visit(node->statement);
+    visit(node->else_statement);
+}
+
+void DefaultVisitor::visitIncrDecrExpression(IncrDecrExpressionAST *)
+{
+    // nothing to do
+}
+
+void DefaultVisitor::visitInitDeclarator(InitDeclaratorAST *node)
+{
+    visit(node->declarator);
+    visit(node->initializer);
+}
+
+void DefaultVisitor::visitInitializer(InitializerAST *node)
+{
+    visit(node->initializer_clause);
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitInitializerClause(InitializerClauseAST *node)
+{
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitLabeledStatement(LabeledStatementAST *)
+{
+    // nothing to do
+}
+
+void DefaultVisitor::visitLinkageBody(LinkageBodyAST *node)
+{
+    visitNodes(this, node->declarations);
+}
+
+void DefaultVisitor::visitLinkageSpecification(LinkageSpecificationAST *node)
+{
+    visit(node->linkage_body);
+    visit(node->declaration);
+}
+
+void DefaultVisitor::visitMemInitializer(MemInitializerAST *node)
+{
+    visit(node->initializer_id);
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitName(NameAST *node)
+{
+    visitNodes(this, node->qualified_names);
+    visit(node->unqualified_name);
+}
+
+void DefaultVisitor::visitNamespace(NamespaceAST *node)
+{
+    visit(node->linkage_body);
+}
+
+void DefaultVisitor::visitNamespaceAliasDefinition(NamespaceAliasDefinitionAST *node)
+{
+    visit(node->alias_name);
+}
+
+void DefaultVisitor::visitNewDeclarator(NewDeclaratorAST *node)
+{
+    visit(node->ptr_op);
+    visit(node->sub_declarator);
+    visitNodes(this, node->expressions);
+}
+
+void DefaultVisitor::visitNewExpression(NewExpressionAST *node)
+{
+    visit(node->expression);
+    visit(node->type_id);
+    visit(node->new_type_id);
+    visit(node->new_initializer);
+}
+
+void DefaultVisitor::visitNewInitializer(NewInitializerAST *node)
+{
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitNewTypeId(NewTypeIdAST *node)
+{
+    visit(node->type_specifier);
+    visit(node->new_initializer);
+    visit(node->new_declarator);
+}
+
+void DefaultVisitor::visitOperator(OperatorAST *)
+{
+    // nothing to do
+}
+
+void DefaultVisitor::visitOperatorFunctionId(OperatorFunctionIdAST *node)
+{
+    visit(node->op);
+    visit(node->type_specifier);
+    visitNodes(this, node->ptr_ops);
+}
+
+void DefaultVisitor::visitParameterDeclaration(ParameterDeclarationAST *node)
+{
+    visit(node->type_specifier);
+    visit(node->declarator);
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitParameterDeclarationClause(ParameterDeclarationClauseAST *node)
+{
+    visitNodes(this, node->parameter_declarations);
+}
+
+void DefaultVisitor::visitPostfixExpression(PostfixExpressionAST *node)
+{
+    visit(node->type_specifier);
+    visit(node->expression);
+    visitNodes(this, node->sub_expressions);
+}
+
+void DefaultVisitor::visitPrimaryExpression(PrimaryExpressionAST *node)
+{
+    visit(node->literal);
+    visit(node->expression_statement);
+    visit(node->sub_expression);
+    visit(node->name);
+}
+
+void DefaultVisitor::visitPtrOperator(PtrOperatorAST *node)
+{
+    visit(node->mem_ptr);
+}
+
+void DefaultVisitor::visitPtrToMember(PtrToMemberAST *)
+{
+    // nothing to do
+}
+
+void DefaultVisitor::visitReturnStatement(ReturnStatementAST *node)
+{
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitSimpleDeclaration(SimpleDeclarationAST *node)
+{
+    visit(node->type_specifier);
+    visitNodes(this, node->init_declarators);
+    visit(node->win_decl_specifiers);
+}
+
+void DefaultVisitor::visitSimpleTypeSpecifier(SimpleTypeSpecifierAST *node)
+{
+    visit(node->name);
+    visit(node->type_id);
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitSizeofExpression(SizeofExpressionAST *node)
+{
+    visit(node->type_id);
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitStringLiteral(StringLiteralAST *)
+{
+    // nothing to do
+}
+
+void DefaultVisitor::visitSubscriptExpression(SubscriptExpressionAST *node)
+{
+    visit(node->subscript);
+}
+
+void DefaultVisitor::visitSwitchStatement(SwitchStatementAST *node)
+{
+    visit(node->condition);
+    visit(node->statement);
+}
+
+void DefaultVisitor::visitTemplateArgument(TemplateArgumentAST *node)
+{
+    visit(node->type_id);
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitTemplateDeclaration(TemplateDeclarationAST *node)
+{
+    visitNodes(this, node->template_parameters);
+    visit(node->declaration);
+}
+
+void DefaultVisitor::visitTemplateParameter(TemplateParameterAST *node)
+{
+    visit(node->type_parameter);
+    visit(node->parameter_declaration);
+}
+
+void DefaultVisitor::visitThrowExpression(ThrowExpressionAST *node)
+{
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitTranslationUnit(TranslationUnitAST *node)
+{
+    visitNodes(this, node->declarations);
+}
+
+void DefaultVisitor::visitTryBlockStatement(TryBlockStatementAST *)
+{
+    // nothing to do
+}
+
+void DefaultVisitor::visitTypeId(TypeIdAST *node)
+{
+    visit(node->type_specifier);
+    visit(node->declarator);
+}
+
+void DefaultVisitor::visitTypeIdentification(TypeIdentificationAST *node)
+{
+    visit(node->name);
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitTypeParameter(TypeParameterAST *node)
+{
+    visit(node->name);
+    visit(node->type_id);
+    visitNodes(this, node->template_parameters);
+    visit(node->template_name);
+}
+
+void DefaultVisitor::visitTypedef(TypedefAST *node)
+{
+    visit(node->type_specifier);
+    visitNodes(this, node->init_declarators);
+}
+
+void DefaultVisitor::visitUnaryExpression(UnaryExpressionAST *node)
+{
+    visit(node->expression);
+}
+
+void DefaultVisitor::visitUnqualifiedName(UnqualifiedNameAST *node)
+{
+    visit(node->operator_id);
+    visitNodes(this, node->template_arguments);
+}
+
+void DefaultVisitor::visitUsing(UsingAST *node)
+{
+    visit(node->name);
+}
+
+void DefaultVisitor::visitUsingDirective(UsingDirectiveAST *node)
+{
+    visit(node->name);
+}
+
+void DefaultVisitor::visitWhileStatement(WhileStatementAST *node)
+{
+    visit(node->condition);
+    visit(node->statement);
+}
+
+void DefaultVisitor::visitWinDeclSpec(WinDeclSpecAST *)
+{
+    // nothing to do
+}
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/default_visitor.h b/ApiExtractor/parser/default_visitor.h
new file mode 100644
index 000000000..ec1caf3bc
--- /dev/null
+++ b/ApiExtractor/parser/default_visitor.h
@@ -0,0 +1,118 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef DEFAULT_VISITOR_H
+#define DEFAULT_VISITOR_H
+
+#include "visitor.h"
+
+class DefaultVisitor: public Visitor
+{
+public:
+    DefaultVisitor() {}
+
+protected:
+    virtual void visitAccessSpecifier(AccessSpecifierAST *);
+    virtual void visitAsmDefinition(AsmDefinitionAST *);
+    virtual void visitBaseClause(BaseClauseAST *);
+    virtual void visitBaseSpecifier(BaseSpecifierAST *);
+    virtual void visitBinaryExpression(BinaryExpressionAST *);
+    virtual void visitCastExpression(CastExpressionAST *);
+    virtual void visitClassMemberAccess(ClassMemberAccessAST *);
+    virtual void visitClassSpecifier(ClassSpecifierAST *);
+    virtual void visitCompoundStatement(CompoundStatementAST *);
+    virtual void visitCondition(ConditionAST *);
+    virtual void visitConditionalExpression(ConditionalExpressionAST *);
+    virtual void visitCppCastExpression(CppCastExpressionAST *);
+    virtual void visitCtorInitializer(CtorInitializerAST *);
+    virtual void visitDeclarationStatement(DeclarationStatementAST *);
+    virtual void visitDeclarator(DeclaratorAST *);
+    virtual void visitDeleteExpression(DeleteExpressionAST *);
+    virtual void visitDoStatement(DoStatementAST *);
+    virtual void visitElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST *);
+    virtual void visitEnumSpecifier(EnumSpecifierAST *);
+    virtual void visitEnumerator(EnumeratorAST *);
+    virtual void visitExceptionSpecification(ExceptionSpecificationAST *);
+    virtual void visitExpressionOrDeclarationStatement(ExpressionOrDeclarationStatementAST *);
+    virtual void visitExpressionStatement(ExpressionStatementAST *);
+    virtual void visitForStatement(ForStatementAST *);
+    virtual void visitFunctionCall(FunctionCallAST *);
+    virtual void visitFunctionDefinition(FunctionDefinitionAST *);
+    virtual void visitIfStatement(IfStatementAST *);
+    virtual void visitIncrDecrExpression(IncrDecrExpressionAST *);
+    virtual void visitInitDeclarator(InitDeclaratorAST *);
+    virtual void visitInitializer(InitializerAST *);
+    virtual void visitInitializerClause(InitializerClauseAST *);
+    virtual void visitLabeledStatement(LabeledStatementAST *);
+    virtual void visitLinkageBody(LinkageBodyAST *);
+    virtual void visitLinkageSpecification(LinkageSpecificationAST *);
+    virtual void visitMemInitializer(MemInitializerAST *);
+    virtual void visitName(NameAST *);
+    virtual void visitNamespace(NamespaceAST *);
+    virtual void visitNamespaceAliasDefinition(NamespaceAliasDefinitionAST *);
+    virtual void visitNewDeclarator(NewDeclaratorAST *);
+    virtual void visitNewExpression(NewExpressionAST *);
+    virtual void visitNewInitializer(NewInitializerAST *);
+    virtual void visitNewTypeId(NewTypeIdAST *);
+    virtual void visitOperator(OperatorAST *);
+    virtual void visitOperatorFunctionId(OperatorFunctionIdAST *);
+    virtual void visitParameterDeclaration(ParameterDeclarationAST *);
+    virtual void visitParameterDeclarationClause(ParameterDeclarationClauseAST *);
+    virtual void visitPostfixExpression(PostfixExpressionAST *);
+    virtual void visitPrimaryExpression(PrimaryExpressionAST *);
+    virtual void visitPtrOperator(PtrOperatorAST *);
+    virtual void visitPtrToMember(PtrToMemberAST *);
+    virtual void visitReturnStatement(ReturnStatementAST *);
+    virtual void visitSimpleDeclaration(SimpleDeclarationAST *);
+    virtual void visitSimpleTypeSpecifier(SimpleTypeSpecifierAST *);
+    virtual void visitSizeofExpression(SizeofExpressionAST *);
+    virtual void visitStringLiteral(StringLiteralAST *);
+    virtual void visitSubscriptExpression(SubscriptExpressionAST *);
+    virtual void visitSwitchStatement(SwitchStatementAST *);
+    virtual void visitTemplateArgument(TemplateArgumentAST *);
+    virtual void visitTemplateDeclaration(TemplateDeclarationAST *);
+    virtual void visitTemplateParameter(TemplateParameterAST *);
+    virtual void visitThrowExpression(ThrowExpressionAST *);
+    virtual void visitTranslationUnit(TranslationUnitAST *);
+    virtual void visitTryBlockStatement(TryBlockStatementAST *);
+    virtual void visitTypeId(TypeIdAST *);
+    virtual void visitTypeIdentification(TypeIdentificationAST *);
+    virtual void visitTypeParameter(TypeParameterAST *);
+    virtual void visitTypedef(TypedefAST *);
+    virtual void visitUnaryExpression(UnaryExpressionAST *);
+    virtual void visitUnqualifiedName(UnqualifiedNameAST *);
+    virtual void visitUsing(UsingAST *);
+    virtual void visitUsingDirective(UsingDirectiveAST *);
+    virtual void visitWhileStatement(WhileStatementAST *);
+    virtual void visitWinDeclSpec(WinDeclSpecAST *);
+
+private:
+    typedef void (Visitor::*visitor_fun_ptr)(AST *);
+    static visitor_fun_ptr _S_table[];
+};
+
+#endif // VISITOR_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/dumptree.cpp b/ApiExtractor/parser/dumptree.cpp
new file mode 100644
index 000000000..1514b0f64
--- /dev/null
+++ b/ApiExtractor/parser/dumptree.cpp
@@ -0,0 +1,125 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#include "dumptree.h"
+
+#include <QtCore/QString>
+#include <QtCore/qdebug.h>
+
+static char const * const names[] = {
+    0,
+    "AccessSpecifier",
+    "AsmDefinition",
+    "BaseClause",
+    "BaseSpecifier",
+    "BinaryExpression",
+    "CastExpression",
+    "ClassMemberAccess",
+    "ClassSpecifier",
+    "CompoundStatement",
+    "Condition",
+    "ConditionalExpression",
+    "CppCastExpression",
+    "CtorInitializer",
+    "DeclarationStatement",
+    "Declarator",
+    "DeleteExpression",
+    "DoStatement",
+    "ElaboratedTypeSpecifier",
+    "EnumSpecifier",
+    "Enumerator",
+    "ExceptionSpecification",
+    "ExpressionOrDeclarationStatement",
+    "ExpressionStatement",
+    "ForStatement",
+    "FunctionCall",
+    "FunctionDefinition",
+    "IfStatement",
+    "IncrDecrExpression",
+    "InitDeclarator",
+    "Initializer",
+    "InitializerClause",
+    "LabeledStatement",
+    "LinkageBody",
+    "LinkageSpecification",
+    "MemInitializer",
+    "Name",
+    "Namespace",
+    "NamespaceAliasDefinition",
+    "NewDeclarator",
+    "NewExpression",
+    "NewInitializer",
+    "NewTypeId",
+    "Operator",
+    "OperatorFunctionId",
+    "ParameterDeclaration",
+    "ParameterDeclarationClause",
+    "PostfixExpression",
+    "PrimaryExpression",
+    "PtrOperator",
+    "PtrToMember",
+    "ReturnStatement",
+    "SimpleDeclaration",
+    "SimpleTypeSpecifier",
+    "SizeofExpression",
+    "StringLiteral",
+    "SubscriptExpression",
+    "SwitchStatement",
+    "TemplateArgument",
+    "TemplateDeclaration",
+    "TemplateParameter",
+    "ThrowExpression",
+    "TranslationUnit",
+    "TryBlockStatement",
+    "TypeId",
+    "TypeIdentification",
+    "TypeParameter",
+    "Typedef",
+    "UnaryExpression",
+    "UnqualifiedName",
+    "Using",
+    "UsingDirective",
+    "WhileStatement",
+    "WinDeclSpec"
+};
+
+DumpTree::DumpTree()
+{
+}
+
+void DumpTree::visit(AST *node)
+{
+    static int indent = 0;
+
+    if (node)
+        qDebug() << QString(indent * 2, ' ').toLatin1().constData() << names[node->kind]
+        << '[' << node->start_token << ", " << node->end_token << ']';
+
+    ++indent;
+    DefaultVisitor::visit(node);
+    --indent;
+}
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/dumptree.h b/ApiExtractor/parser/dumptree.h
new file mode 100644
index 000000000..cfc55e2e6
--- /dev/null
+++ b/ApiExtractor/parser/dumptree.h
@@ -0,0 +1,46 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef DUMPTREE_H
+#define DUMPTREE_H
+
+#include "default_visitor.h"
+
+class DumpTree: protected DefaultVisitor
+{
+public:
+    DumpTree();
+
+    void dump(AST *node) {
+        visit(node);
+    }
+
+protected:
+    virtual void visit(AST *node);
+};
+
+#endif // DUMPTREE_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/lexer.cpp b/ApiExtractor/parser/lexer.cpp
new file mode 100644
index 000000000..2abb540d0
--- /dev/null
+++ b/ApiExtractor/parser/lexer.cpp
@@ -0,0 +1,1695 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#include "lexer.h"
+#include "tokens.h"
+#include "control.h"
+
+#include <cctype>
+#include <iostream>
+
+scan_fun_ptr Lexer::s_scan_keyword_table[] = {
+    &Lexer::scanKeyword0, &Lexer::scanKeyword0,
+    &Lexer::scanKeyword2, &Lexer::scanKeyword3,
+    &Lexer::scanKeyword4, &Lexer::scanKeyword5,
+    &Lexer::scanKeyword6, &Lexer::scanKeyword7,
+    &Lexer::scanKeyword8, &Lexer::scanKeyword9,
+    &Lexer::scanKeyword10, &Lexer::scanKeyword11,
+    &Lexer::scanKeyword12, &Lexer::scanKeyword13,
+    &Lexer::scanKeyword14, &Lexer::scanKeyword0,
+    &Lexer::scanKeyword16
+};
+
+void LocationManager::extract_line(int offset, int *line, QString *filename) const
+{
+    *line = 0;
+    if (token_stream.size() < 1)
+        return;
+
+    const unsigned char *begin_buffer = reinterpret_cast<const unsigned char *>(token_stream[0].text);
+    const unsigned char *cursor = begin_buffer + offset;
+
+    ++cursor; // skip '#'
+    if (std::isspace(*cursor) && std::isdigit(*(cursor + 1))) {
+        ++cursor;
+        char buffer[1024], *cp = buffer;
+        do {
+            *cp++ = *cursor++;
+        } while (std::isdigit(*cursor));
+        *cp = '\0';
+        int l = strtol(buffer, 0, 0);
+
+        Q_ASSERT(std::isspace(*cursor));
+        ++cursor;
+
+        Q_ASSERT(*cursor == '"');
+        ++cursor;
+
+        cp = buffer;
+        while (*cursor && *cursor != '"') {
+            *cp++ = *cursor++;
+        }
+        *cp = '\0';
+        Q_ASSERT(*cursor == '"');
+        ++cursor;
+
+        *filename = buffer;
+        *line = l;
+        // printf("filename: %s line: %d\n", buffer, line);
+    }
+}
+
+void LocationManager::positionAt(std::size_t offset, int *line, int *column,
+                                 QString *filename) const
+{
+    int ppline, ppcolumn;
+    line_table.positionAt(offset, &ppline, &ppcolumn);
+
+    int base_line;
+    extract_line((int) line_table[ppline-1], &base_line, filename);
+
+    int line2, column2;
+    location_table.positionAt((int) line_table[ppline-1], &line2, &column2);
+
+    location_table.positionAt(offset, line, column);
+    *line = base_line + *line - line2  - 1;
+}
+
+scan_fun_ptr Lexer::s_scan_table[256];
+bool Lexer::s_initialized = false;
+
+void Lexer::tokenize(const char *contents, std::size_t size)
+{
+    if (!s_initialized)
+        initialize_scan_table();
+
+    token_stream.resize(1024);
+    token_stream[0].kind = Token_EOF;
+    token_stream[0].text = contents;
+
+    index = 1;
+
+    cursor = (const unsigned char *) contents;
+    begin_buffer = (const unsigned char *) contents;
+    end_buffer = cursor + size;
+
+    location_table.resize(1024);
+    location_table[0] = 0;
+    location_table.current_line = 1;
+
+    line_table.resize(1024);
+    line_table[0] = 0;
+    line_table.current_line = 1;
+
+    do {
+        if (index == token_stream.size())
+            token_stream.resize(token_stream.size() * 2);
+
+        Token *current_token = &token_stream[(int) index];
+        current_token->text = reinterpret_cast<const char*>(begin_buffer);
+        current_token->position = cursor - begin_buffer;
+        (this->*s_scan_table[*cursor])();
+        current_token->size = cursor - begin_buffer - current_token->position;
+    } while (cursor < end_buffer);
+
+    if (index == token_stream.size())
+        token_stream.resize(token_stream.size() * 2);
+
+    Q_ASSERT(index < token_stream.size());
+    token_stream[(int) index].position = cursor - begin_buffer;
+    token_stream[(int) index].kind = Token_EOF;
+}
+
+void Lexer::reportError(const QString& msg)
+{
+    int line, column;
+    QString fileName;
+
+    std::size_t tok = token_stream.cursor();
+    _M_location.positionAt(token_stream.position(tok),
+                           &line, &column, &fileName);
+
+    Control::ErrorMessage errmsg;
+    errmsg.setLine(line + 1);
+    errmsg.setColumn(column);
+    errmsg.setFileName(fileName);
+    errmsg.setMessage(QLatin1String("** LEXER ERROR ") + msg);
+    control->reportError(errmsg);
+}
+
+void Lexer::initialize_scan_table()
+{
+    s_initialized = true;
+
+    for (int i = 0; i < 256; ++i) {
+        if (isspace(i))
+            s_scan_table[i] = &Lexer::scan_white_spaces;
+        else if (isalpha(i) || i == '_')
+            s_scan_table[i] = &Lexer::scan_identifier_or_keyword;
+        else if (isdigit(i))
+            s_scan_table[i] = &Lexer::scan_int_constant;
+        else
+            s_scan_table[i] = &Lexer::scan_invalid_input;
+    }
+
+    s_scan_table[int('L')] = &Lexer::scan_identifier_or_literal;
+    s_scan_table[int('\n')] = &Lexer::scan_newline;
+    s_scan_table[int('#')] = &Lexer::scan_preprocessor;
+
+    s_scan_table[int('\'')] = &Lexer::scan_char_constant;
+    s_scan_table[int('"')]  = &Lexer::scan_string_constant;
+
+    s_scan_table[int('.')] = &Lexer::scan_int_constant;
+
+    s_scan_table[int('!')] = &Lexer::scan_not;
+    s_scan_table[int('%')] = &Lexer::scan_remainder;
+    s_scan_table[int('&')] = &Lexer::scan_and;
+    s_scan_table[int('(')] = &Lexer::scan_left_paren;
+    s_scan_table[int(')')] = &Lexer::scan_right_paren;
+    s_scan_table[int('*')] = &Lexer::scan_star;
+    s_scan_table[int('+')] = &Lexer::scan_plus;
+    s_scan_table[int(',')] = &Lexer::scan_comma;
+    s_scan_table[int('-')] = &Lexer::scan_minus;
+    s_scan_table[int('/')] = &Lexer::scan_divide;
+    s_scan_table[int(':')] = &Lexer::scan_colon;
+    s_scan_table[int(';')] = &Lexer::scan_semicolon;
+    s_scan_table[int('<')] = &Lexer::scan_less;
+    s_scan_table[int('=')] = &Lexer::scan_equal;
+    s_scan_table[int('>')] = &Lexer::scan_greater;
+    s_scan_table[int('?')] = &Lexer::scan_question;
+    s_scan_table[int('[')] = &Lexer::scan_left_bracket;
+    s_scan_table[int(']')] = &Lexer::scan_right_bracket;
+    s_scan_table[int('^')] = &Lexer::scan_xor;
+    s_scan_table[int('{')] = &Lexer::scan_left_brace;
+    s_scan_table[int('|')] = &Lexer::scan_or;
+    s_scan_table[int('}')] = &Lexer::scan_right_brace;
+    s_scan_table[int('~')] = &Lexer::scan_tilde;
+
+    s_scan_table[0] = &Lexer::scan_EOF;
+}
+
+void Lexer::scan_preprocessor()
+{
+    if (line_table.current_line == line_table.size())
+        line_table.resize(line_table.current_line * 2);
+
+    line_table[(int) line_table.current_line++] = (cursor - begin_buffer);
+
+    while (*cursor && *cursor != '\n')
+        ++cursor;
+
+    if (*cursor != '\n')
+        reportError("expected newline");
+}
+
+void Lexer::scan_char_constant()
+{
+    const unsigned char *begin = cursor;
+
+    ++cursor;
+    while (*cursor && *cursor != '\'') {
+        if (*cursor == '\n')
+            reportError("did not expect newline");
+
+        if (*cursor == '\\')
+            ++cursor;
+        ++cursor;
+    }
+
+    if (*cursor != '\'')
+        reportError("expected \'");
+
+    ++cursor;
+
+    token_stream[(int) index].extra.symbol =
+        control->findOrInsertName((const char*) begin, cursor - begin);
+
+    token_stream[(int) index++].kind = Token_char_literal;
+}
+
+void Lexer::scan_string_constant()
+{
+    const unsigned char *begin = cursor;
+
+    ++cursor;
+    while (*cursor && *cursor != '"') {
+        if (*cursor == '\n')
+            reportError("did not expect newline");
+
+        if (*cursor == '\\')
+            ++cursor;
+        ++cursor;
+    }
+
+    if (*cursor != '"')
+        reportError("expected \"");
+
+    ++cursor;
+
+    token_stream[(int) index].extra.symbol =
+        control->findOrInsertName((const char*) begin, cursor - begin);
+
+    token_stream[(int) index++].kind = Token_string_literal;
+}
+
+void Lexer::scan_newline()
+{
+    if (location_table.current_line == location_table.size())
+        location_table.resize(location_table.current_line * 2);
+
+    location_table[(int) location_table.current_line++] = (cursor - begin_buffer);
+    ++cursor;
+}
+
+void Lexer::scan_white_spaces()
+{
+    while (isspace(*cursor)) {
+        if (*cursor == '\n')
+            scan_newline();
+        else
+            ++cursor;
+    }
+}
+
+void Lexer::scan_identifier_or_literal()
+{
+    switch (*(cursor + 1)) {
+    case '\'':
+        ++cursor;
+        scan_char_constant();
+        break;
+
+    case '\"':
+        ++cursor;
+        scan_string_constant();
+        break;
+
+    default:
+        scan_identifier_or_keyword();
+        break;
+    }
+}
+
+void Lexer::scan_identifier_or_keyword()
+{
+    const unsigned char *skip = cursor;
+    while (isalnum(*skip) || *skip == '_')
+        ++skip;
+
+    int n = skip - cursor;
+    Token *current_token = &token_stream[(int) index];
+    (this->*s_scan_keyword_table[n < 17 ? n : 0])();
+
+    if (current_token->kind == Token_identifier) {
+        current_token->extra.symbol =
+            control->findOrInsertName((const char*) cursor, n);
+    }
+
+    cursor = skip;
+}
+
+void Lexer::scan_int_constant()
+{
+    if (*cursor == '.' && !std::isdigit(*(cursor + 1))) {
+        scan_dot();
+        return;
+    }
+
+    const unsigned char *begin = cursor;
+
+    while (isalnum(*cursor) || *cursor == '.')
+        ++cursor;
+
+    token_stream[(int) index].extra.symbol =
+        control->findOrInsertName((const char*) begin, cursor - begin);
+
+    token_stream[(int) index++].kind = Token_number_literal;
+}
+
+void Lexer::scan_not()
+{
+    /*
+      '!'     ::= not
+      '!='        ::= not_equal
+    */
+
+    ++cursor;
+
+    if (*cursor == '=') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_not_eq;
+    } else {
+        token_stream[(int) index++].kind = '!';
+    }
+}
+
+void Lexer::scan_remainder()
+{
+    /*
+      '%'     ::= remainder
+      '%='        ::= remainder_equal
+    */
+
+    ++cursor;
+
+    if (*cursor == '=') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_assign;
+    } else {
+        token_stream[(int) index++].kind = '%';
+    }
+}
+
+void Lexer::scan_and()
+{
+    /*
+      '&&'        ::= and_and
+      '&'     ::= and
+      '&='        ::= and_equal
+    */
+
+    ++cursor;
+    if (*cursor == '=') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_assign;
+    } else if (*cursor == '&') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_and;
+    } else {
+        token_stream[(int) index++].kind = '&';
+    }
+}
+
+void Lexer::scan_left_paren()
+{
+    ++cursor;
+    token_stream[(int) index++].kind = '(';
+}
+
+void Lexer::scan_right_paren()
+{
+    ++cursor;
+    token_stream[(int) index++].kind = ')';
+}
+
+void Lexer::scan_star()
+{
+    /*
+      '*'     ::= star
+      '*='        ::= star_equal
+    */
+
+    ++cursor;
+
+    if (*cursor == '=') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_assign;
+    } else {
+        token_stream[(int) index++].kind = '*';
+    }
+}
+
+void Lexer::scan_plus()
+{
+    /*
+      '+'     ::= plus
+      '++'        ::= incr
+      '+='        ::= plus_equal
+    */
+
+    ++cursor;
+    if (*cursor == '=') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_assign;
+    } else if (*cursor == '+') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_incr;
+    } else {
+        token_stream[(int) index++].kind = '+';
+    }
+}
+
+void Lexer::scan_comma()
+{
+    ++cursor;
+    token_stream[(int) index++].kind = ',';
+}
+
+void Lexer::scan_minus()
+{
+    /*
+      '-'     ::= minus
+      '--'        ::= decr
+      '-='        ::= minus_equal
+      '->'        ::= left_arrow
+    */
+
+    ++cursor;
+    if (*cursor == '=') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_assign;
+    } else if (*cursor == '-') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_decr;
+    } else if (*cursor == '>') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_arrow;
+        if (*cursor == '*') {
+            ++cursor;
+            token_stream[(int) index++].kind = Token_ptrmem;
+        }
+    } else {
+        token_stream[(int) index++].kind = '-';
+    }
+}
+
+void Lexer::scan_dot()
+{
+    /*
+      '.'     ::= dot
+      '...'       ::= ellipsis
+    */
+
+    ++cursor;
+    if (*cursor == '.' && *(cursor + 1) == '.') {
+        cursor += 2;
+        token_stream[(int) index++].kind = Token_ellipsis;
+    } else if (*cursor == '.' && *(cursor + 1) == '*') {
+        cursor += 2;
+        token_stream[(int) index++].kind = Token_ptrmem;
+    } else
+        token_stream[(int) index++].kind = '.';
+}
+
+void Lexer::scan_divide()
+{
+    /*
+      '/'     ::= divide
+      '/='    ::= divide_equal
+    */
+
+    ++cursor;
+
+    if (*cursor == '=') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_assign;
+    } else {
+        token_stream[(int) index++].kind = '/';
+    }
+}
+
+void Lexer::scan_colon()
+{
+    ++cursor;
+    if (*cursor == ':') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_scope;
+    } else {
+        token_stream[(int) index++].kind = ':';
+    }
+}
+
+void Lexer::scan_semicolon()
+{
+    ++cursor;
+    token_stream[(int) index++].kind = ';';
+}
+
+void Lexer::scan_less()
+{
+    /*
+      '<'         ::= less
+      '<<'        ::= left_shift
+      '<<='       ::= left_shift_equal
+      '<='        ::= less_equal
+    */
+
+    ++cursor;
+    if (*cursor == '=') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_leq;
+    } else if (*cursor == '<') {
+        ++cursor;
+        if (*cursor == '=') {
+            ++cursor;
+            token_stream[(int) index++].kind = Token_assign;
+        } else {
+            token_stream[(int) index++].kind = Token_shift;
+        }
+    } else {
+        token_stream[(int) index++].kind = '<';
+    }
+}
+
+void Lexer::scan_equal()
+{
+    /*
+      '='         ::= equal
+      '=='        ::= equal_equal
+    */
+    ++cursor;
+
+    if (*cursor == '=') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_eq;
+    } else {
+        token_stream[(int) index++].kind = '=';
+    }
+}
+
+void Lexer::scan_greater()
+{
+    /*
+      '>'         ::= greater
+      '>='        ::= greater_equal
+      '>>'        ::= right_shift
+      '>>='       ::= right_shift_equal
+    */
+
+    ++cursor;
+    if (*cursor == '=') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_geq;
+    } else if (*cursor == '>') {
+        ++cursor;
+        if (*cursor == '=') {
+            ++cursor;
+            token_stream[(int) index++].kind = Token_assign;
+        } else {
+            token_stream[(int) index++].kind = Token_shift;
+        }
+    } else {
+        token_stream[(int) index++].kind = '>';
+    }
+}
+
+void Lexer::scan_question()
+{
+    ++cursor;
+    token_stream[(int) index++].kind = '?';
+}
+
+void Lexer::scan_left_bracket()
+{
+    ++cursor;
+    token_stream[(int) index++].kind = '[';
+}
+
+void Lexer::scan_right_bracket()
+{
+    ++cursor;
+    token_stream[(int) index++].kind = ']';
+}
+
+void Lexer::scan_xor()
+{
+    /*
+      '^'         ::= xor
+      '^='        ::= xor_equal
+    */
+    ++cursor;
+
+    if (*cursor == '=') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_assign;
+    } else {
+        token_stream[(int) index++].kind = '^';
+    }
+}
+
+void Lexer::scan_left_brace()
+{
+    ++cursor;
+    token_stream[(int) index++].kind = '{';
+}
+
+void Lexer::scan_or()
+{
+    /*
+      '|'         ::= or
+      '|='        ::= or_equal
+      '||'        ::= or_or
+    */
+    ++cursor;
+    if (*cursor == '=') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_assign;
+    } else if (*cursor == '|') {
+        ++cursor;
+        token_stream[(int) index++].kind = Token_or;
+    } else {
+        token_stream[(int) index++].kind = '|';
+    }
+}
+
+void Lexer::scan_right_brace()
+{
+    ++cursor;
+    token_stream[(int) index++].kind = '}';
+}
+
+void Lexer::scan_tilde()
+{
+    ++cursor;
+    token_stream[(int) index++].kind = '~';
+}
+
+void Lexer::scan_EOF()
+{
+    ++cursor;
+    token_stream[(int) index++].kind = Token_EOF;
+}
+
+void Lexer::scan_invalid_input()
+{
+    QString errmsg("invalid input: %1");
+    errmsg.arg(int(*cursor));
+    reportError(errmsg);
+    ++cursor;
+}
+
+void LocationTable::positionAt(std::size_t offset, int max_line,
+                               int *line, int *column) const
+{
+    if (!(line && column && max_line != 0))
+        return;
+
+    int first = 0;
+    int len = max_line;
+    int half;
+    int middle;
+
+    while (len > 0) {
+        half = len >> 1;
+        middle = first;
+
+        middle += half;
+
+        if (lines[middle] < offset) {
+            first = middle;
+            ++first;
+            len = len - half - 1;
+        } else
+            len = half;
+    }
+
+    *line = std::max(first, 1);
+    *column = (int)(offset - lines[*line - 1] - 1);
+
+    if (*column < 0) {
+        *column = 0;
+    }
+}
+
+void Lexer::scanKeyword0()
+{
+    token_stream[(int) index++].kind = Token_identifier;
+}
+
+void Lexer::scanKeyword2()
+{
+    switch (*cursor) {
+    case 'i':
+        if (*(cursor + 1) == 'f') {
+            token_stream[(int) index++].kind = Token_if;
+            return;
+        }
+        break;
+
+    case 'd':
+        if (*(cursor + 1) == 'o') {
+            token_stream[(int) index++].kind = Token_do;
+            return;
+        }
+        break;
+
+    case 'o':
+        if (*(cursor + 1) == 'r') {
+            token_stream[(int) index++].kind = Token_or;
+            return;
+        }
+        break;
+
+    }
+    token_stream[(int) index++].kind = Token_identifier;
+}
+
+void Lexer::scanKeyword3()
+{
+    switch (*cursor) {
+    case 'a':
+        if (*(cursor + 1) == 'n' &&
+            *(cursor + 2) == 'd') {
+            token_stream[(int) index++].kind = Token_and;
+            return;
+        }
+        if (*(cursor + 1) == 's' &&
+            *(cursor + 2) == 'm') {
+            token_stream[(int) index++].kind = Token_asm;
+            return;
+        }
+        break;
+
+    case 'f':
+        if (*(cursor + 1) == 'o' &&
+            *(cursor + 2) == 'r') {
+            token_stream[(int) index++].kind = Token_for;
+            return;
+        }
+        break;
+
+    case 'i':
+        if (*(cursor + 1) == 'n' &&
+            *(cursor + 2) == 't') {
+            token_stream[(int) index++].kind = Token_int;
+            return;
+        }
+        break;
+
+    case 'n':
+        if (*(cursor + 1) == 'e' &&
+            *(cursor + 2) == 'w') {
+            token_stream[(int) index++].kind = Token_new;
+            return;
+        }
+        if (*(cursor + 1) == 'o' &&
+            *(cursor + 2) == 't') {
+            token_stream[(int) index++].kind = Token_not;
+            return;
+        }
+        break;
+
+    case 't':
+        if (*(cursor + 1) == 'r' &&
+            *(cursor + 2) == 'y') {
+            token_stream[(int) index++].kind = Token_try;
+            return;
+        }
+        break;
+
+    case 'x':
+        if (*(cursor + 1) == 'o' &&
+            *(cursor + 2) == 'r') {
+            token_stream[(int) index++].kind = Token_xor;
+            return;
+        }
+        break;
+
+    }
+    token_stream[(int) index++].kind = Token_identifier;
+}
+
+void Lexer::scanKeyword4()
+{
+    switch (*cursor) {
+    case 'a':
+        if (*(cursor + 1) == 'u' &&
+            *(cursor + 2) == 't' &&
+            *(cursor + 3) == 'o') {
+            token_stream[(int) index++].kind = Token_auto;
+            return;
+        }
+        break;
+
+    case 'c':
+        if (*(cursor + 1) == 'a' &&
+            *(cursor + 2) == 's' &&
+            *(cursor + 3) == 'e') {
+            token_stream[(int) index++].kind = Token_case;
+            return;
+        }
+        if (*(cursor + 1) == 'h' &&
+            *(cursor + 2) == 'a' &&
+            *(cursor + 3) == 'r') {
+            token_stream[(int) index++].kind = Token_char;
+            return;
+        }
+        break;
+
+    case 'b':
+        if (*(cursor + 1) == 'o' &&
+            *(cursor + 2) == 'o' &&
+            *(cursor + 3) == 'l') {
+            token_stream[(int) index++].kind = Token_bool;
+            return;
+        }
+        break;
+
+    case 'e':
+        if (*(cursor + 1) == 'l' &&
+            *(cursor + 2) == 's' &&
+            *(cursor + 3) == 'e') {
+            token_stream[(int) index++].kind = Token_else;
+            return;
+        }
+        if (*(cursor + 1) == 'm' &&
+            *(cursor + 2) == 'i' &&
+            *(cursor + 3) == 't') {
+            token_stream[(int) index++].kind = Token_emit;
+            return;
+        }
+        if (*(cursor + 1) == 'n' &&
+            *(cursor + 2) == 'u' &&
+            *(cursor + 3) == 'm') {
+            token_stream[(int) index++].kind = Token_enum;
+            return;
+        }
+        break;
+
+    case 'g':
+        if (*(cursor + 1) == 'o' &&
+            *(cursor + 2) == 't' &&
+            *(cursor + 3) == 'o') {
+            token_stream[(int) index++].kind = Token_goto;
+            return;
+        }
+        break;
+
+    case 'l':
+        if (*(cursor + 1) == 'o' &&
+            *(cursor + 2) == 'n' &&
+            *(cursor + 3) == 'g') {
+            token_stream[(int) index++].kind = Token_long;
+            return;
+        }
+        break;
+
+    case 't':
+        if (*(cursor + 1) == 'h' &&
+            *(cursor + 2) == 'i' &&
+            *(cursor + 3) == 's') {
+            token_stream[(int) index++].kind = Token_this;
+            return;
+        }
+        break;
+
+    case 'v':
+        if (*(cursor + 1) == 'o' &&
+            *(cursor + 2) == 'i' &&
+            *(cursor + 3) == 'd') {
+            token_stream[(int) index++].kind = Token_void;
+            return;
+        }
+        break;
+
+    }
+    token_stream[(int) index++].kind = Token_identifier;
+}
+
+void Lexer::scanKeyword5()
+{
+    switch (*cursor) {
+    case 'c':
+        if (*(cursor + 1) == 'a' &&
+            *(cursor + 2) == 't' &&
+            *(cursor + 3) == 'c' &&
+            *(cursor + 4) == 'h') {
+            token_stream[(int) index++].kind = Token_catch;
+            return;
+        }
+        if (*(cursor + 1) == 'l' &&
+            *(cursor + 2) == 'a' &&
+            *(cursor + 3) == 's' &&
+            *(cursor + 4) == 's') {
+            token_stream[(int) index++].kind = Token_class;
+            return;
+        }
+        if (*(cursor + 1) == 'o' &&
+            *(cursor + 2) == 'm' &&
+            *(cursor + 3) == 'p' &&
+            *(cursor + 4) == 'l') {
+            token_stream[(int) index++].kind = Token_compl;
+            return;
+        }
+        if (*(cursor + 1) == 'o' &&
+            *(cursor + 2) == 'n' &&
+            *(cursor + 3) == 's' &&
+            *(cursor + 4) == 't') {
+            token_stream[(int) index++].kind = Token_const;
+            return;
+        }
+        break;
+
+    case 'b':
+        if (*(cursor + 1) == 'i' &&
+            *(cursor + 2) == 't' &&
+            *(cursor + 3) == 'o' &&
+            *(cursor + 4) == 'r') {
+            token_stream[(int) index++].kind = Token_bitor;
+            return;
+        }
+        if (*(cursor + 1) == 'r' &&
+            *(cursor + 2) == 'e' &&
+            *(cursor + 3) == 'a' &&
+            *(cursor + 4) == 'k') {
+            token_stream[(int) index++].kind = Token_break;
+            return;
+        }
+        break;
+
+    case 'f':
+        if (*(cursor + 1) == 'l' &&
+            *(cursor + 2) == 'o' &&
+            *(cursor + 3) == 'a' &&
+            *(cursor + 4) == 't') {
+            token_stream[(int) index++].kind = Token_float;
+            return;
+        }
+        break;
+
+    case 'o':
+        if (*(cursor + 1) == 'r' &&
+            *(cursor + 2) == '_' &&
+            *(cursor + 3) == 'e' &&
+            *(cursor + 4) == 'q') {
+            token_stream[(int) index++].kind = Token_or_eq;
+            return;
+        }
+        break;
+
+    case 's':
+        if (*(cursor + 1) == 'h' &&
+            *(cursor + 2) == 'o' &&
+            *(cursor + 3) == 'r' &&
+            *(cursor + 4) == 't') {
+            token_stream[(int) index++].kind = Token_short;
+            return;
+        }
+        if (*(cursor + 1) == 'l' &&
+            *(cursor + 2) == 'o' &&
+            *(cursor + 3) == 't' &&
+            *(cursor + 4) == 's') {
+            token_stream[(int) index++].kind = Token_slots;
+            return;
+        }
+        break;
+
+    case 'u':
+        if (*(cursor + 1) == 'n' &&
+            *(cursor + 2) == 'i' &&
+            *(cursor + 3) == 'o' &&
+            *(cursor + 4) == 'n') {
+            token_stream[(int) index++].kind = Token_union;
+            return;
+        }
+        if (*(cursor + 1) == 's' &&
+            *(cursor + 2) == 'i' &&
+            *(cursor + 3) == 'n' &&
+            *(cursor + 4) == 'g') {
+            token_stream[(int) index++].kind = Token_using;
+            return;
+        }
+        break;
+
+    case 't':
+        if (*(cursor + 1) == 'h' &&
+            *(cursor + 2) == 'r' &&
+            *(cursor + 3) == 'o' &&
+            *(cursor + 4) == 'w') {
+            token_stream[(int) index++].kind = Token_throw;
+            return;
+        }
+        break;
+
+    case 'w':
+        if (*(cursor + 1) == 'h' &&
+            *(cursor + 2) == 'i' &&
+            *(cursor + 3) == 'l' &&
+            *(cursor + 4) == 'e') {
+            token_stream[(int) index++].kind = Token_while;
+            return;
+        }
+        break;
+
+    }
+    token_stream[(int) index++].kind = Token_identifier;
+}
+
+void Lexer::scanKeyword6()
+{
+    switch (*cursor) {
+    case 'a':
+        if (*(cursor + 1) == 'n' &&
+            *(cursor + 2) == 'd' &&
+            *(cursor + 3) == '_' &&
+            *(cursor + 4) == 'e' &&
+            *(cursor + 5) == 'q') {
+            token_stream[(int) index++].kind = Token_and_eq;
+            return;
+        }
+        break;
+
+    case 'b':
+        if (*(cursor + 1) == 'i' &&
+            *(cursor + 2) == 't' &&
+            *(cursor + 3) == 'a' &&
+            *(cursor + 4) == 'n' &&
+            *(cursor + 5) == 'd') {
+            token_stream[(int) index++].kind = Token_bitand;
+            return;
+        }
+        break;
+
+    case 'e':
+        if (*(cursor + 1) == 'x' &&
+            *(cursor + 2) == 'p' &&
+            *(cursor + 3) == 'o' &&
+            *(cursor + 4) == 'r' &&
+            *(cursor + 5) == 't') {
+            token_stream[(int) index++].kind = Token_export;
+            return;
+        }
+        if (*(cursor + 1) == 'x' &&
+            *(cursor + 2) == 't' &&
+            *(cursor + 3) == 'e' &&
+            *(cursor + 4) == 'r' &&
+            *(cursor + 5) == 'n') {
+            token_stream[(int) index++].kind = Token_extern;
+            return;
+        }
+        break;
+
+    case 'd':
+        if (*(cursor + 1) == 'e' &&
+            *(cursor + 2) == 'l' &&
+            *(cursor + 3) == 'e' &&
+            *(cursor + 4) == 't' &&
+            *(cursor + 5) == 'e') {
+            token_stream[(int) index++].kind = Token_delete;
+            return;
+        }
+        if (*(cursor + 1) == 'o' &&
+            *(cursor + 2) == 'u' &&
+            *(cursor + 3) == 'b' &&
+            *(cursor + 4) == 'l' &&
+            *(cursor + 5) == 'e') {
+            token_stream[(int) index++].kind = Token_double;
+            return;
+        }
+        break;
+
+    case 'f':
+        if (*(cursor + 1) == 'r' &&
+            *(cursor + 2) == 'i' &&
+            *(cursor + 3) == 'e' &&
+            *(cursor + 4) == 'n' &&
+            *(cursor + 5) == 'd') {
+            token_stream[(int) index++].kind = Token_friend;
+            return;
+        }
+        break;
+
+    case 'i':
+        if (*(cursor + 1) == 'n' &&
+            *(cursor + 2) == 'l' &&
+            *(cursor + 3) == 'i' &&
+            *(cursor + 4) == 'n' &&
+            *(cursor + 5) == 'e') {
+            token_stream[(int) index++].kind = Token_inline;
+            return;
+        }
+        break;
+
+    case 'K':
+        if (*(cursor + 1) == '_' &&
+            *(cursor + 2) == 'D' &&
+            *(cursor + 3) == 'C' &&
+            *(cursor + 4) == 'O' &&
+            *(cursor + 5) == 'P') {
+            token_stream[(int) index++].kind = Token_K_DCOP;
+            return;
+        }
+        break;
+
+    case 'n':
+        if (*(cursor + 1) == 'o' &&
+            *(cursor + 2) == 't' &&
+            *(cursor + 3) == '_' &&
+            *(cursor + 4) == 'e' &&
+            *(cursor + 5) == 'q') {
+            token_stream[(int) index++].kind = Token_not_eq;
+            return;
+        }
+        break;
+
+    case 'p':
+        if (*(cursor + 1) == 'u' &&
+            *(cursor + 2) == 'b' &&
+            *(cursor + 3) == 'l' &&
+            *(cursor + 4) == 'i' &&
+            *(cursor + 5) == 'c') {
+            token_stream[(int) index++].kind = Token_public;
+            return;
+        }
+        break;
+
+    case 's':
+        if (*(cursor + 1) == 'i' &&
+            *(cursor + 2) == 'g' &&
+            *(cursor + 3) == 'n' &&
+            *(cursor + 4) == 'e' &&
+            *(cursor + 5) == 'd') {
+            token_stream[(int) index++].kind = Token_signed;
+            return;
+        }
+        if (*(cursor + 1) == 'i' &&
+            *(cursor + 2) == 'z' &&
+            *(cursor + 3) == 'e' &&
+            *(cursor + 4) == 'o' &&
+            *(cursor + 5) == 'f') {
+            token_stream[(int) index++].kind = Token_sizeof;
+            return;
+        }
+        if (*(cursor + 1) == 't' &&
+            *(cursor + 2) == 'a' &&
+            *(cursor + 3) == 't' &&
+            *(cursor + 4) == 'i' &&
+            *(cursor + 5) == 'c') {
+            token_stream[(int) index++].kind = Token_static;
+            return;
+        }
+        if (*(cursor + 1) == 't' &&
+            *(cursor + 2) == 'r' &&
+            *(cursor + 3) == 'u' &&
+            *(cursor + 4) == 'c' &&
+            *(cursor + 5) == 't') {
+            token_stream[(int) index++].kind = Token_struct;
+            return;
+        }
+        if (*(cursor + 1) == 'w' &&
+            *(cursor + 2) == 'i' &&
+            *(cursor + 3) == 't' &&
+            *(cursor + 4) == 'c' &&
+            *(cursor + 5) == 'h') {
+            token_stream[(int) index++].kind = Token_switch;
+            return;
+        }
+        break;
+
+    case 'r':
+        if (*(cursor + 1) == 'e' &&
+            *(cursor + 2) == 't' &&
+            *(cursor + 3) == 'u' &&
+            *(cursor + 4) == 'r' &&
+            *(cursor + 5) == 'n') {
+            token_stream[(int) index++].kind = Token_return;
+            return;
+        }
+        break;
+
+    case 't':
+        if (*(cursor + 1) == 'y' &&
+            *(cursor + 2) == 'p' &&
+            *(cursor + 3) == 'e' &&
+            *(cursor + 4) == 'i' &&
+            *(cursor + 5) == 'd') {
+            token_stream[(int) index++].kind = Token_typeid;
+            return;
+        }
+        break;
+
+    case 'x':
+        if (*(cursor + 1) == 'o' &&
+            *(cursor + 2) == 'r' &&
+            *(cursor + 3) == '_' &&
+            *(cursor + 4) == 'e' &&
+            *(cursor + 5) == 'q') {
+            token_stream[(int) index++].kind = Token_xor_eq;
+            return;
+        }
+        break;
+
+    case 'k':
+        if (*(cursor + 1) == '_' &&
+            *(cursor + 2) == 'd' &&
+            *(cursor + 3) == 'c' &&
+            *(cursor + 4) == 'o' &&
+            *(cursor + 5) == 'p') {
+            token_stream[(int) index++].kind = Token_k_dcop;
+            return;
+        }
+        break;
+
+    }
+    token_stream[(int) index++].kind = Token_identifier;
+}
+
+void Lexer::scanKeyword7()
+{
+    switch (*cursor) {
+    case 'd':
+        if (*(cursor + 1) == 'e' &&
+            *(cursor + 2) == 'f' &&
+            *(cursor + 3) == 'a' &&
+            *(cursor + 4) == 'u' &&
+            *(cursor + 5) == 'l' &&
+            *(cursor + 6) == 't') {
+            token_stream[(int) index++].kind = Token_default;
+            return;
+        }
+        break;
+
+    case 'm':
+        if (*(cursor + 1) == 'u' &&
+            *(cursor + 2) == 't' &&
+            *(cursor + 3) == 'a' &&
+            *(cursor + 4) == 'b' &&
+            *(cursor + 5) == 'l' &&
+            *(cursor + 6) == 'e') {
+            token_stream[(int) index++].kind = Token_mutable;
+            return;
+        }
+        break;
+
+    case 'p':
+        if (*(cursor + 1) == 'r' &&
+            *(cursor + 2) == 'i' &&
+            *(cursor + 3) == 'v' &&
+            *(cursor + 4) == 'a' &&
+            *(cursor + 5) == 't' &&
+            *(cursor + 6) == 'e') {
+            token_stream[(int) index++].kind = Token_private;
+            return;
+        }
+        break;
+    case 's':
+        if (*(cursor + 1) == 'i' &&
+            *(cursor + 2) == 'g' &&
+            *(cursor + 3) == 'n' &&
+            *(cursor + 4) == 'a' &&
+            *(cursor + 5) == 'l' &&
+            *(cursor + 6) == 's') {
+            token_stream[(int) index++].kind = Token_signals;
+            return;
+        }
+        break;
+    case 't':
+        if (*(cursor + 1) == 'y' &&
+            *(cursor + 2) == 'p' &&
+            *(cursor + 3) == 'e' &&
+            *(cursor + 4) == 'd' &&
+            *(cursor + 5) == 'e' &&
+            *(cursor + 6) == 'f') {
+            token_stream[(int) index++].kind = Token_typedef;
+            return;
+        }
+        break;
+
+    case 'v':
+        if (*(cursor + 1) == 'i' &&
+            *(cursor + 2) == 'r' &&
+            *(cursor + 3) == 't' &&
+            *(cursor + 4) == 'u' &&
+            *(cursor + 5) == 'a' &&
+            *(cursor + 6) == 'l') {
+            token_stream[(int) index++].kind = Token_virtual;
+            return;
+        }
+        break;
+
+    case 'Q':
+        if (*(cursor + 1) == '_' &&
+            *(cursor + 2) == 'E' &&
+            *(cursor + 3) == 'N' &&
+            *(cursor + 4) == 'U' &&
+            *(cursor + 5) == 'M' &&
+            *(cursor + 6) == 'S') {
+            token_stream[(int) index++].kind = Token_Q_ENUMS;
+            return;
+        }
+        break;
+
+    }
+    token_stream[(int) index++].kind = Token_identifier;
+}
+
+void Lexer::scanKeyword8()
+{
+    switch (*cursor) {
+    case '_':
+        if (*(cursor + 1) == '_' &&
+            *(cursor + 2) == 't' &&
+            *(cursor + 3) == 'y' &&
+            *(cursor + 4) == 'p' &&
+            *(cursor + 5) == 'e' &&
+            *(cursor + 6) == 'o' &&
+            *(cursor + 7) == 'f') {
+            token_stream[(int) index++].kind = Token___typeof;
+            return;
+        }
+        break;
+
+    case 'c':
+        if (*(cursor + 1) == 'o' &&
+            *(cursor + 2) == 'n' &&
+            *(cursor + 3) == 't' &&
+            *(cursor + 4) == 'i' &&
+            *(cursor + 5) == 'n' &&
+            *(cursor + 6) == 'u' &&
+            *(cursor + 7) == 'e') {
+            token_stream[(int) index++].kind = Token_continue;
+            return;
+        }
+        break;
+
+    case 'e':
+        if (*(cursor + 1) == 'x' &&
+            *(cursor + 2) == 'p' &&
+            *(cursor + 3) == 'l' &&
+            *(cursor + 4) == 'i' &&
+            *(cursor + 5) == 'c' &&
+            *(cursor + 6) == 'i' &&
+            *(cursor + 7) == 't') {
+            token_stream[(int) index++].kind = Token_explicit;
+            return;
+        }
+        break;
+
+    case 'o':
+        if (*(cursor + 1) == 'p' &&
+            *(cursor + 2) == 'e' &&
+            *(cursor + 3) == 'r' &&
+            *(cursor + 4) == 'a' &&
+            *(cursor + 5) == 't' &&
+            *(cursor + 6) == 'o' &&
+            *(cursor + 7) == 'r') {
+            token_stream[(int) index++].kind = Token_operator;
+            return;
+        }
+        break;
+
+    case 'Q':
+        if (*(cursor + 1) == '_' &&
+            *(cursor + 2) == 'O' &&
+            *(cursor + 3) == 'B' &&
+            *(cursor + 4) == 'J' &&
+            *(cursor + 5) == 'E' &&
+            *(cursor + 6) == 'C' &&
+            *(cursor + 7) == 'T') {
+            token_stream[(int) index++].kind = Token_Q_OBJECT;
+            return;
+        }
+        break;
+
+    case 'r':
+        if (*(cursor + 1) == 'e' &&
+            *(cursor + 2) == 'g' &&
+            *(cursor + 3) == 'i' &&
+            *(cursor + 4) == 's' &&
+            *(cursor + 5) == 't' &&
+            *(cursor + 6) == 'e' &&
+            *(cursor + 7) == 'r') {
+            token_stream[(int) index++].kind = Token_register;
+            return;
+        }
+        break;
+
+    case 'u':
+        if (*(cursor + 1) == 'n' &&
+            *(cursor + 2) == 's' &&
+            *(cursor + 3) == 'i' &&
+            *(cursor + 4) == 'g' &&
+            *(cursor + 5) == 'n' &&
+            *(cursor + 6) == 'e' &&
+            *(cursor + 7) == 'd') {
+            token_stream[(int) index++].kind = Token_unsigned;
+            return;
+        }
+        break;
+
+    case 't':
+        if (*(cursor + 1) == 'e' &&
+            *(cursor + 2) == 'm' &&
+            *(cursor + 3) == 'p' &&
+            *(cursor + 4) == 'l' &&
+            *(cursor + 5) == 'a' &&
+            *(cursor + 6) == 't' &&
+            *(cursor + 7) == 'e') {
+            token_stream[(int) index++].kind = Token_template;
+            return;
+        }
+        if (*(cursor + 1) == 'y' &&
+            *(cursor + 2) == 'p' &&
+            *(cursor + 3) == 'e' &&
+            *(cursor + 4) == 'n' &&
+            *(cursor + 5) == 'a' &&
+            *(cursor + 6) == 'm' &&
+            *(cursor + 7) == 'e') {
+            token_stream[(int) index++].kind = Token_typename;
+            return;
+        }
+        break;
+
+    case 'v':
+        if (*(cursor + 1) == 'o' &&
+            *(cursor + 2) == 'l' &&
+            *(cursor + 3) == 'a' &&
+            *(cursor + 4) == 't' &&
+            *(cursor + 5) == 'i' &&
+            *(cursor + 6) == 'l' &&
+            *(cursor + 7) == 'e') {
+            token_stream[(int) index++].kind = Token_volatile;
+            return;
+        }
+        break;
+
+    }
+    token_stream[(int) index++].kind = Token_identifier;
+}
+
+void Lexer::scanKeyword9()
+{
+    switch (*cursor) {
+    case 'p':
+        if (*(cursor + 1) == 'r' &&
+            *(cursor + 2) == 'o' &&
+            *(cursor + 3) == 't' &&
+            *(cursor + 4) == 'e' &&
+            *(cursor + 5) == 'c' &&
+            *(cursor + 6) == 't' &&
+            *(cursor + 7) == 'e' &&
+            *(cursor + 8) == 'd') {
+            token_stream[(int) index++].kind = Token_protected;
+            return;
+        }
+        break;
+
+    case 'n':
+        if (*(cursor + 1) == 'a' &&
+            *(cursor + 2) == 'm' &&
+            *(cursor + 3) == 'e' &&
+            *(cursor + 4) == 's' &&
+            *(cursor + 5) == 'p' &&
+            *(cursor + 6) == 'a' &&
+            *(cursor + 7) == 'c' &&
+            *(cursor + 8) == 'e') {
+            token_stream[(int) index++].kind = Token_namespace;
+            return;
+        }
+        break;
+
+    }
+    token_stream[(int) index++].kind = Token_identifier;
+}
+
+void Lexer::scanKeyword10()
+{
+    switch (*cursor) {
+    case 'c':
+        if (*(cursor + 1) == 'o' &&
+            *(cursor + 2) == 'n' &&
+            *(cursor + 3) == 's' &&
+            *(cursor + 4) == 't' &&
+            *(cursor + 5) == '_' &&
+            *(cursor + 6) == 'c' &&
+            *(cursor + 7) == 'a' &&
+            *(cursor + 8) == 's' &&
+            *(cursor + 9) == 't') {
+            token_stream[(int) index++].kind = Token_const_cast;
+            return;
+        }
+        break;
+
+    case 'Q':
+        if (*(cursor + 1) == '_' &&
+            *(cursor + 2) == 'P' &&
+            *(cursor + 3) == 'R' &&
+            *(cursor + 4) == 'O' &&
+            *(cursor + 5) == 'P' &&
+            *(cursor + 6) == 'E' &&
+            *(cursor + 7) == 'R' &&
+            *(cursor + 8) == 'T' &&
+            *(cursor + 9) == 'Y') {
+            token_stream[(int) index++].kind = Token_Q_PROPERTY;
+            return;
+        }
+
+        break;
+    }
+
+    token_stream[(int) index++].kind = Token_identifier;
+}
+
+void Lexer::scanKeyword11()
+{
+    switch (*cursor) {
+    case 'Q':
+        if (*(cursor + 1) == '_' &&
+            *(cursor + 2) == 'I' &&
+            *(cursor + 3) == 'N' &&
+            *(cursor + 4) == 'V' &&
+            *(cursor + 5) == 'O' &&
+            *(cursor + 6) == 'K' &&
+            *(cursor + 7) == 'A' &&
+            *(cursor + 8) == 'B' &&
+            *(cursor + 9) == 'L' &&
+            *(cursor + 10) == 'E') {
+            token_stream[(int) index++].kind = Token_Q_INVOKABLE;
+            return;
+        }
+        break;
+
+    case 's':
+        if (*(cursor + 1) == 't' &&
+            *(cursor + 2) == 'a' &&
+            *(cursor + 3) == 't' &&
+            *(cursor + 4) == 'i' &&
+            *(cursor + 5) == 'c' &&
+            *(cursor + 6) == '_' &&
+            *(cursor + 7) == 'c' &&
+            *(cursor + 8) == 'a' &&
+            *(cursor + 9) == 's' &&
+            *(cursor + 10) == 't') {
+            token_stream[(int) index++].kind = Token_static_cast;
+            return;
+        }
+        break;
+
+    }
+    token_stream[(int) index++].kind = Token_identifier;
+}
+
+void Lexer::scanKeyword12()
+{
+    switch (*cursor) {
+    case 'd':
+        if (*(cursor + 1) == 'y' &&
+            *(cursor + 2) == 'n' &&
+            *(cursor + 3) == 'a' &&
+            *(cursor + 4) == 'm' &&
+            *(cursor + 5) == 'i' &&
+            *(cursor + 6) == 'c' &&
+            *(cursor + 7) == '_' &&
+            *(cursor + 8) == 'c' &&
+            *(cursor + 9) == 'a' &&
+            *(cursor + 10) == 's' &&
+            *(cursor + 11) == 't') {
+            token_stream[(int) index++].kind = Token_dynamic_cast;
+            return;
+        }
+        break;
+
+    }
+    token_stream[(int) index++].kind = Token_identifier;
+}
+
+void Lexer::scanKeyword13()
+{
+    switch (*cursor) {
+    case '_':
+        if (*(cursor + 1) == '_' &&
+            *(cursor + 2) == 'a' &&
+            *(cursor + 3) == 't' &&
+            *(cursor + 4) == 't' &&
+            *(cursor + 5) == 'r' &&
+            *(cursor + 6) == 'i' &&
+            *(cursor + 7) == 'b' &&
+            *(cursor + 8) == 'u' &&
+            *(cursor + 9) == 't' &&
+            *(cursor + 10) == 'e' &&
+            *(cursor + 11) == '_' &&
+            *(cursor + 12) == '_') {
+            token_stream[(int) index++].kind = Token___attribute__;
+            return;
+        }
+        break;
+    }
+    token_stream[(int) index++].kind = Token_identifier;
+}
+
+void Lexer::scanKeyword14()
+{
+    switch (*cursor) {
+    case 'k':
+        if (*(cursor + 1) == '_' &&
+            *(cursor + 2) == 'd' &&
+            *(cursor + 3) == 'c' &&
+            *(cursor + 4) == 'o' &&
+            *(cursor + 5) == 'p' &&
+            *(cursor + 6) == '_' &&
+            *(cursor + 7) == 's' &&
+            *(cursor + 8) == 'i' &&
+            *(cursor + 9) == 'g' &&
+            *(cursor + 10) == 'n' &&
+            *(cursor + 11) == 'a' &&
+            *(cursor + 12) == 'l' &&
+            *(cursor + 13) == 's') {
+            token_stream[(int) index++].kind = Token_k_dcop_signals;
+            return;
+        }
+        break;
+    }
+    token_stream[(int) index++].kind = Token_identifier;
+}
+
+void Lexer::scanKeyword16()
+{
+    switch (*cursor) {
+    case 'r':
+        if (*(cursor + 1) == 'e' &&
+            *(cursor + 2) == 'i' &&
+            *(cursor + 3) == 'n' &&
+            *(cursor + 4) == 't' &&
+            *(cursor + 5) == 'e' &&
+            *(cursor + 6) == 'r' &&
+            *(cursor + 7) == 'p' &&
+            *(cursor + 8) == 'r' &&
+            *(cursor + 9) == 'e' &&
+            *(cursor + 10) == 't' &&
+            *(cursor + 11) == '_' &&
+            *(cursor + 12) == 'c' &&
+            *(cursor + 13) == 'a' &&
+            *(cursor + 14) == 's' &&
+            *(cursor + 15) == 't') {
+            token_stream[(int) index++].kind = Token_reinterpret_cast;
+            return;
+        }
+        break;
+    }
+
+    token_stream[(int) index++].kind = Token_identifier;
+}
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/lexer.h b/ApiExtractor/parser/lexer.h
new file mode 100644
index 000000000..874805325
--- /dev/null
+++ b/ApiExtractor/parser/lexer.h
@@ -0,0 +1,290 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef LEXER_H
+#define LEXER_H
+
+#include "symbol.h"
+
+#include <QtCore/QString>
+#include <cstdlib>
+#include <cassert>
+
+struct NameSymbol;
+class Lexer;
+class Control;
+
+typedef void (Lexer::*scan_fun_ptr)();
+
+class Token
+{
+public:
+    int kind;
+    std::size_t position;
+    std::size_t size;
+    char const *text;
+
+    union {
+        const NameSymbol *symbol;
+        std::size_t right_brace;
+    } extra;
+};
+
+class LocationTable
+{
+private:
+    LocationTable(const LocationTable &source);
+    void operator = (const LocationTable &source);
+
+public:
+    inline LocationTable(std::size_t size = 1024)
+            : lines(0),
+            line_count(0),
+            current_line(0) {
+        resize(size);
+    }
+
+    inline ~LocationTable() {
+        free(lines);
+    }
+
+    inline std::size_t size() const {
+        return line_count;
+    }
+
+    void resize(std::size_t size) {
+        Q_ASSERT(size > 0);
+        lines = (std::size_t*) ::realloc(lines, sizeof(std::size_t) * size);
+        line_count = size;
+    }
+
+    void positionAt(std::size_t offset, int *line, int *column) const {
+        positionAt(offset, (int) current_line, line, column);
+    }
+
+    void positionAt(std::size_t offset, int max_line, int *line, int *column) const;
+
+    inline std::size_t &operator[](int index) {
+        return lines[index];
+    }
+
+private:
+    std::size_t *lines;
+    std::size_t line_count;
+    std::size_t current_line;
+
+    friend class Lexer;
+};
+
+class TokenStream
+{
+private:
+    TokenStream(const TokenStream &);
+    void operator = (const TokenStream &);
+
+public:
+    inline TokenStream(std::size_t size = 1024)
+            : tokens(0),
+            index(0),
+            token_count(0) {
+        resize(size);
+    }
+
+    inline ~TokenStream() {
+        ::free(tokens);
+    }
+
+    inline std::size_t size() const {
+        return token_count;
+    }
+
+    inline std::size_t cursor() const {
+        return index;
+    }
+
+    inline void rewind(int i) {
+        index = i;
+    }
+
+    void resize(std::size_t size) {
+        Q_ASSERT(size > 0);
+        tokens = (Token*) ::realloc(tokens, sizeof(Token) * size);
+        token_count = size;
+    }
+
+    inline std::size_t nextToken() {
+        return index++;
+    }
+
+    inline int lookAhead(std::size_t i = 0) const {
+        return tokens[index + i].kind;
+    }
+
+    inline int kind(std::size_t i) const {
+        return tokens[i].kind;
+    }
+
+    inline std::size_t position(std::size_t i) const {
+        return tokens[i].position;
+    }
+
+    inline const NameSymbol *symbol(std::size_t i) const {
+        return tokens[i].extra.symbol;
+    }
+
+    inline std::size_t matchingBrace(std::size_t i) const {
+        return tokens[i].extra.right_brace;
+    }
+
+    inline Token &operator[](int index) {
+        return tokens[index];
+    }
+
+    inline const Token &token(int index) const {
+        return tokens[index];
+    }
+
+private:
+    Token *tokens;
+    std::size_t index;
+    std::size_t token_count;
+
+private:
+    friend class Lexer;
+};
+
+class LocationManager
+{
+    LocationManager(LocationManager const &__other);
+    void operator = (LocationManager const &__other);
+
+public:
+    LocationManager(TokenStream &__token_stream,
+                    LocationTable &__location_table,
+                    LocationTable &__line_table):
+            token_stream(__token_stream),
+            location_table(__location_table),
+            line_table(__line_table) {}
+
+    void positionAt(std::size_t offset, int *line, int *column,
+                    QString *filename) const;
+
+    void extract_line(int offset, int *line, QString *filename) const;
+
+    TokenStream &token_stream;
+    LocationTable &location_table;
+    LocationTable &line_table;
+};
+
+class Lexer
+{
+public:
+    Lexer(LocationManager &__location, Control *__control):
+            _M_location(__location),
+            token_stream(_M_location.token_stream),
+            location_table(_M_location.location_table),
+            line_table(_M_location.line_table),
+            control(__control) {}
+
+    void tokenize(const char *contents, std::size_t size);
+
+    LocationManager &_M_location;
+    TokenStream &token_stream;
+    LocationTable &location_table;
+    LocationTable &line_table;
+
+private:
+    void reportError(const QString& msg);
+
+    void initialize_scan_table();
+    void scan_newline();
+    void scan_white_spaces();
+    void scan_identifier_or_keyword();
+    void scan_identifier_or_literal();
+    void scan_int_constant();
+    void scan_char_constant();
+    void scan_string_constant();
+    void scan_invalid_input();
+    void scan_preprocessor();
+
+    // keywords
+    void scanKeyword0();
+    void scanKeyword2();
+    void scanKeyword3();
+    void scanKeyword4();
+    void scanKeyword5();
+    void scanKeyword6();
+    void scanKeyword7();
+    void scanKeyword8();
+    void scanKeyword9();
+    void scanKeyword10();
+    void scanKeyword11();
+    void scanKeyword12();
+    void scanKeyword13();
+    void scanKeyword14();
+    void scanKeyword16();
+
+    // operators
+    void scan_not();
+    void scan_remainder();
+    void scan_and();
+    void scan_left_paren();
+    void scan_right_paren();
+    void scan_star();
+    void scan_plus();
+    void scan_comma();
+    void scan_minus();
+    void scan_dot();
+    void scan_divide();
+    void scan_colon();
+    void scan_semicolon();
+    void scan_less();
+    void scan_equal();
+    void scan_greater();
+    void scan_question();
+    void scan_left_bracket();
+    void scan_right_bracket();
+    void scan_xor();
+    void scan_left_brace();
+    void scan_or();
+    void scan_right_brace();
+    void scan_tilde();
+    void scan_EOF();
+
+private:
+    Control *control;
+    const unsigned char *cursor;
+    const unsigned char *begin_buffer;
+    const unsigned char *end_buffer;
+    std::size_t index;
+
+    static scan_fun_ptr s_scan_table[];
+    static scan_fun_ptr s_scan_keyword_table[];
+    static bool s_initialized;
+};
+
+#endif // LEXER_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/list.cpp b/ApiExtractor/parser/list.cpp
new file mode 100644
index 000000000..7482b7392
--- /dev/null
+++ b/ApiExtractor/parser/list.cpp
@@ -0,0 +1,28 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#include "list.h"
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/list.h b/ApiExtractor/parser/list.h
new file mode 100644
index 000000000..fe0e6276a
--- /dev/null
+++ b/ApiExtractor/parser/list.h
@@ -0,0 +1,100 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef FASTLIST_H
+#define FASTLIST_H
+
+#include "smallobject.h"
+
+template <typename Tp>
+struct ListNode {
+    Tp element;
+    int index;
+    mutable const ListNode<Tp> *next;
+
+    static ListNode *create(const Tp &element, pool *p) {
+        ListNode<Tp> *node = new(p->allocate(sizeof(ListNode), strideof(ListNode))) ListNode();
+        node->element = element;
+        node->index = 0;
+        node->next = node;
+
+        return node;
+    }
+
+    static ListNode *create(const ListNode *n1, const Tp &element, pool *p) {
+        ListNode<Tp> *n2 = ListNode::create(element, p);
+
+        n2->index = n1->index + 1;
+        n2->next = n1->next;
+        n1->next = n2;
+
+        return n2;
+    }
+
+    inline ListNode<Tp>() { }
+
+    inline const ListNode<Tp> *at(int index) const {
+        const ListNode<Tp> *node = this;
+        while (index != node->index)
+            node = node->next;
+
+        return node;
+    }
+
+    inline bool hasNext() const {
+        return index < next->index;
+    }
+
+    inline int count() const {
+        return 1 + toBack()->index;
+    }
+
+    inline const ListNode<Tp> *toFront() const {
+        return toBack()->next;
+    }
+
+    inline const ListNode<Tp> *toBack() const {
+        const ListNode<Tp> *node = this;
+        while (node->hasNext())
+            node = node->next;
+
+        return node;
+    }
+};
+
+template <class Tp>
+inline const ListNode<Tp> *snoc(const ListNode<Tp> *list,
+                                const Tp &element, pool *p)
+{
+    if (!list)
+        return ListNode<Tp>::create(element, p);
+
+    return ListNode<Tp>::create(list->toBack(), element, p);
+}
+
+#endif // FASTLIST_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
+
diff --git a/ApiExtractor/parser/name_compiler.cpp b/ApiExtractor/parser/name_compiler.cpp
new file mode 100644
index 000000000..4dbd516d6
--- /dev/null
+++ b/ApiExtractor/parser/name_compiler.cpp
@@ -0,0 +1,134 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#include "name_compiler.h"
+#include "type_compiler.h"
+#include "declarator_compiler.h"
+#include "lexer.h"
+#include "symbol.h"
+#include "binder.h"
+
+#include <QtCore/qdebug.h>
+
+NameCompiler::NameCompiler(Binder *binder)
+        : _M_binder(binder), _M_token_stream(binder->tokenStream())
+{
+}
+
+QString NameCompiler::decode_operator(std::size_t index) const
+{
+    const Token &tk = _M_token_stream->token((int) index);
+    return QString::fromUtf8(&tk.text[tk.position], (int) tk.size);
+}
+
+QString NameCompiler::internal_run(AST *node)
+{
+    _M_name.clear();
+    visit(node);
+    return name();
+}
+
+void NameCompiler::visitUnqualifiedName(UnqualifiedNameAST *node)
+{
+    QString tmp_name;
+
+    if (node->tilde)
+        tmp_name += QLatin1String("~");
+
+    if (node->id)
+        tmp_name += _M_token_stream->symbol(node->id)->as_string();
+
+    if (OperatorFunctionIdAST *op_id = node->operator_id) {
+#if defined(__GNUC__)
+#warning "NameCompiler::visitUnqualifiedName() -- implement me"
+#endif
+
+        if (op_id->op && op_id->op->op) {
+            tmp_name += QLatin1String("operator");
+            tmp_name += decode_operator(op_id->op->op);
+            if (op_id->op->close)
+                tmp_name += decode_operator(op_id->op->close);
+        } else if (op_id->type_specifier) {
+#if defined(__GNUC__)
+#warning "don't use an hardcoded string as cast' name"
+#endif
+            Token const &tk = _M_token_stream->token((int) op_id->start_token);
+            Token const &end_tk = _M_token_stream->token((int) op_id->end_token);
+            tmp_name += QString::fromLatin1(&tk.text[tk.position],
+                                            (int)(end_tk.position - tk.position)).trimmed();
+        }
+    }
+
+    _M_name += tmp_name;
+    if (node->template_arguments) {
+        // ### cleanup
+        _M_name.last() += QLatin1String("<");
+        visitNodes(this, node->template_arguments);
+        _M_name.last().truncate(_M_name.last().count() - 1); // remove the last ','
+        _M_name.last() += QLatin1String(">");
+    }
+
+}
+
+void NameCompiler::visitTemplateArgument(TemplateArgumentAST *node)
+{
+    if (node->type_id && node->type_id->type_specifier) {
+        TypeCompiler type_cc(_M_binder);
+        type_cc.run(node->type_id->type_specifier);
+
+        DeclaratorCompiler decl_cc(_M_binder);
+        decl_cc.run(node->type_id->declarator);
+
+        if (type_cc.isConstant())
+            _M_name.last() += "const ";
+
+        QStringList q = type_cc.qualifiedName();
+
+        if (q.count() == 1) {
+#if defined (RXX_RESOLVE_TYPEDEF) // ### it'll break :(
+            TypeInfo tp;
+            tp.setQualifiedName(q);
+            tp = TypeInfo::resolveType(tp, _M_binder->currentScope()->toItem());
+            q = tp.qualifiedName();
+#endif
+
+            if (CodeModelItem item = _M_binder->model()->findItem(q, _M_binder->currentScope()->toItem())) {
+                if (item->name() == q.last())
+                    q = item->qualifiedName();
+            }
+        }
+
+        _M_name.last() += q.join("::");
+
+        if (decl_cc.isReference())
+            _M_name.last() += "&";
+        if (decl_cc.indirection())
+            _M_name.last() += QString(decl_cc.indirection(), '*');
+
+        _M_name.last() += QLatin1String(",");
+    }
+}
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/name_compiler.h b/ApiExtractor/parser/name_compiler.h
new file mode 100644
index 000000000..66cabaccf
--- /dev/null
+++ b/ApiExtractor/parser/name_compiler.h
@@ -0,0 +1,69 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef NAME_COMPILER_H
+#define NAME_COMPILER_H
+
+#include "default_visitor.h"
+#include <QtCore/QStringList>
+
+class TokenStream;
+class Binder;
+
+class NameCompiler: protected DefaultVisitor
+{
+public:
+    NameCompiler(Binder *binder);
+
+    void run(NameAST *node) {
+        internal_run(node);
+    }
+    void run(UnqualifiedNameAST *node) {
+        internal_run(node);
+    }
+
+    QString name() const {
+        return _M_name.join("::");
+    }
+    QStringList qualifiedName() const {
+        return _M_name;
+    }
+
+protected:
+    virtual void visitUnqualifiedName(UnqualifiedNameAST *node);
+    virtual void visitTemplateArgument(TemplateArgumentAST *node);
+
+    QString internal_run(AST *node);
+    QString decode_operator(std::size_t index) const;
+
+private:
+    Binder *_M_binder;
+    TokenStream *_M_token_stream;
+    QStringList _M_name;
+};
+
+#endif // NAME_COMPILER_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/parser.cpp b/ApiExtractor/parser/parser.cpp
new file mode 100644
index 000000000..e7d663ffd
--- /dev/null
+++ b/ApiExtractor/parser/parser.cpp
@@ -0,0 +1,4054 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+
+
+// c++ support
+#include "parser.h"
+#include "tokens.h"
+#include "lexer.h"
+#include "control.h"
+
+#include <cstdlib>
+
+#define ADVANCE(tk, descr) \
+    { \
+        if (token_stream.lookAhead() != tk) { \
+            tokenRequiredError(tk); \
+            return false; \
+        } \
+        token_stream.nextToken(); \
+    }
+
+#define ADVANCE_NR(tk, descr) \
+    do { \
+        if (token_stream.lookAhead() != tk) { \
+            tokenRequiredError(tk); \
+        } \
+        else \
+            token_stream.nextToken(); \
+    } while (0)
+
+#define CHECK(tk) \
+    do { \
+        if (token_stream.lookAhead() != tk) { \
+            return false; \
+        } \
+        token_stream.nextToken(); \
+    } while (0)
+
+#define UPDATE_POS(_node, start, end) \
+    do { \
+        (_node)->start_token = start; \
+        (_node)->end_token = end; \
+    } while (0)
+
+Parser::Parser(Control *c)
+        : _M_location(token_stream, location_table, line_table),
+        control(c),
+        lexer(_M_location, control)
+{
+    _M_block_errors = false;
+}
+
+Parser::~Parser()
+{
+}
+
+void Parser::advance()
+{
+    token_stream.nextToken();
+}
+
+TranslationUnitAST *Parser::parse(const char *contents,
+                                  std::size_t size, pool *p)
+{
+    _M_block_errors = false;
+    _M_pool = p;
+    lexer.tokenize(contents, size);
+    token_stream.nextToken(); // skip the first token
+
+    Lexer *oldLexer = control->changeLexer(&lexer);
+    Parser *oldParser = control->changeParser(this);
+
+    TranslationUnitAST *ast = 0;
+    parseTranslationUnit(ast);
+
+    control->changeLexer(oldLexer);
+    control->changeParser(oldParser);
+
+    return ast;
+}
+
+bool Parser::parseWinDeclSpec(WinDeclSpecAST *&node)
+{
+    if (token_stream.lookAhead() != Token_identifier)
+        return false;
+
+    std::size_t start = token_stream.cursor();
+
+    const NameSymbol *name_symbol = token_stream.symbol(token_stream.cursor());
+    QString name = name_symbol->as_string();
+    if (name != QLatin1String("__declspec"))
+        return false;
+    std::size_t specifier = token_stream.cursor();
+
+    token_stream.nextToken();
+    if (token_stream.lookAhead() != '(')
+        return false;
+
+    token_stream.nextToken();
+    if (token_stream.lookAhead() != Token_identifier)
+        return false;
+    std::size_t modifier = token_stream.cursor();
+
+    token_stream.nextToken();
+    if (token_stream.lookAhead() != ')')
+        return false;
+
+    token_stream.nextToken();
+
+    node = CreateNode<WinDeclSpecAST>(_M_pool);
+    node->specifier = specifier;
+    node->modifier = modifier;
+
+    UPDATE_POS(node, start, token_stream.cursor());
+
+    return true;
+}
+
+void Parser::tokenRequiredError(int token)
+{
+    QString err;
+
+    err += "expected token ";
+    err += "``";
+    err += token_name(token);
+    err += "'' found ``";
+    err += token_name(token_stream.lookAhead());
+    err += "''";
+
+    reportError(err);
+}
+
+void Parser::syntaxError()
+{
+    QString err;
+
+    err += "unexpected token ";
+    err += "``";
+    err += token_name(token_stream.lookAhead());
+    err += "''";
+
+    reportError(err);
+}
+
+void Parser::reportError(const QString& msg)
+{
+    if (!_M_block_errors) {
+        int line, column;
+        QString fileName;
+
+        std::size_t tok = token_stream.cursor();
+        location().positionAt(token_stream.position(tok),
+                              &line, &column, &fileName);
+
+        Control::ErrorMessage errmsg;
+        errmsg.setLine(line + 1);
+        errmsg.setColumn(column);
+        errmsg.setFileName(fileName);
+        errmsg.setMessage(QLatin1String("** PARSER ERROR ") + msg);
+        control->reportError(errmsg);
+    }
+}
+
+bool Parser::skipUntil(int token)
+{
+    while (token_stream.lookAhead()) {
+        if (token_stream.lookAhead() == token)
+            return true;
+
+        token_stream.nextToken();
+    }
+
+    return false;
+}
+
+bool Parser::skipUntilDeclaration()
+{
+    while (token_stream.lookAhead()) {
+
+        switch (token_stream.lookAhead()) {
+        case ';':
+        case '~':
+        case Token_scope:
+        case Token_identifier:
+        case Token_operator:
+        case Token_char:
+        case Token_wchar_t:
+        case Token_bool:
+        case Token_short:
+        case Token_int:
+        case Token_long:
+        case Token_signed:
+        case Token_unsigned:
+        case Token_float:
+        case Token_double:
+        case Token_void:
+        case Token_extern:
+        case Token_namespace:
+        case Token_using:
+        case Token_typedef:
+        case Token_asm:
+        case Token_template:
+        case Token_export:
+
+        case Token_const:       // cv
+        case Token_volatile:    // cv
+
+        case Token_public:
+        case Token_protected:
+        case Token_private:
+        case Token_signals:      // Qt
+        case Token_slots:        // Qt
+            return true;
+
+        default:
+            token_stream.nextToken();
+        }
+    }
+
+    return false;
+}
+
+bool Parser::skipUntilStatement()
+{
+    while (token_stream.lookAhead()) {
+        switch (token_stream.lookAhead()) {
+        case ';':
+        case '{':
+        case '}':
+        case Token_const:
+        case Token_volatile:
+        case Token_identifier:
+        case Token_case:
+        case Token_default:
+        case Token_if:
+        case Token_switch:
+        case Token_while:
+        case Token_do:
+        case Token_for:
+        case Token_break:
+        case Token_continue:
+        case Token_return:
+        case Token_goto:
+        case Token_try:
+        case Token_catch:
+        case Token_throw:
+        case Token_char:
+        case Token_wchar_t:
+        case Token_bool:
+        case Token_short:
+        case Token_int:
+        case Token_long:
+        case Token_signed:
+        case Token_unsigned:
+        case Token_float:
+        case Token_double:
+        case Token_void:
+        case Token_class:
+        case Token_struct:
+        case Token_union:
+        case Token_enum:
+        case Token_scope:
+        case Token_template:
+        case Token_using:
+            return true;
+
+        default:
+            token_stream.nextToken();
+        }
+    }
+
+    return false;
+}
+
+bool Parser::skip(int l, int r)
+{
+    int count = 0;
+    while (token_stream.lookAhead()) {
+        int tk = token_stream.lookAhead();
+
+        if (tk == l)
+            ++count;
+        else if (tk == r)
+            --count;
+        else if (l != '{' && (tk == '{' || tk == '}' || tk == ';'))
+            return false;
+
+        if (!count)
+            return true;
+
+        token_stream.nextToken();
+    }
+
+    return false;
+}
+
+bool Parser::parseName(NameAST *&node, bool acceptTemplateId)
+{
+    std::size_t start = token_stream.cursor();
+
+    WinDeclSpecAST *winDeclSpec = 0;
+    parseWinDeclSpec(winDeclSpec);
+
+    NameAST *ast = CreateNode<NameAST>(_M_pool);
+
+    if (token_stream.lookAhead() == Token_scope) {
+        ast->global = true;
+        token_stream.nextToken();
+    }
+
+    std::size_t idx = token_stream.cursor();
+
+    while (true) {
+        UnqualifiedNameAST *n = 0;
+        if (!parseUnqualifiedName(n))
+            return false;
+
+        if (token_stream.lookAhead() == Token_scope) {
+            token_stream.nextToken();
+
+            ast->qualified_names
+            = snoc(ast->qualified_names, n, _M_pool);
+
+            if (token_stream.lookAhead() == Token_template) {
+                /// skip optional template     #### @todo CHECK
+                token_stream.nextToken();
+            }
+        } else {
+            Q_ASSERT(n);
+            if (!acceptTemplateId) {
+                token_stream.rewind((int) n->start_token);
+                parseUnqualifiedName(n, false);
+            }
+
+            ast->unqualified_name = n;
+            break;
+        }
+    }
+
+    if (idx == token_stream.cursor())
+        return false;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseTranslationUnit(TranslationUnitAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+    TranslationUnitAST *ast = CreateNode<TranslationUnitAST>(_M_pool);
+
+    while (token_stream.lookAhead()) {
+        std::size_t startDecl = token_stream.cursor();
+
+        DeclarationAST *declaration = 0;
+        if (parseDeclaration(declaration)) {
+            ast->declarations =
+                snoc(ast->declarations, declaration, _M_pool);
+        } else {
+            // error recovery
+            if (startDecl == token_stream.cursor()) {
+                // skip at least one token
+                token_stream.nextToken();
+            }
+
+            skipUntilDeclaration();
+        }
+    }
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseDeclaration(DeclarationAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    switch (token_stream.lookAhead()) {
+    case ';':
+        token_stream.nextToken();
+        return true;
+
+    case Token_extern:
+        return parseLinkageSpecification(node);
+
+    case Token_namespace:
+        return parseNamespace(node);
+
+    case Token_using:
+        return parseUsing(node);
+
+    case Token_typedef:
+        return parseTypedef(node);
+
+    case Token_asm:
+        return parseAsmDefinition(node);
+
+    case Token_Q_ENUMS:
+        return parseQ_ENUMS(node);
+
+    case Token_template:
+    case Token_export:
+        return parseTemplateDeclaration(node);
+
+    default: {
+        const ListNode<std::size_t> *cv = 0;
+        parseCvQualify(cv);
+
+        const ListNode<std::size_t> *storageSpec = 0;
+        parseStorageClassSpecifier(storageSpec);
+
+        parseCvQualify(cv);
+
+        TypeSpecifierAST *spec = 0;
+        if (parseEnumSpecifier(spec)
+            || parseClassSpecifier(spec)
+            || parseForwardDeclarationSpecifier(spec)) {
+            parseCvQualify(cv);
+
+            spec->cv = cv;
+
+            const ListNode<InitDeclaratorAST*> *declarators = 0;
+            parseInitDeclaratorList(declarators);
+            ADVANCE(';', ";");
+
+            SimpleDeclarationAST *ast =
+                CreateNode<SimpleDeclarationAST>(_M_pool);
+
+            ast->storage_specifiers = storageSpec;
+            ast->type_specifier = spec;
+            ast->init_declarators = declarators;
+            UPDATE_POS(ast, start, token_stream.cursor());
+            node = ast;
+
+            return true;
+        }
+    }
+    } // end switch
+
+    token_stream.rewind((int) start);
+    return parseDeclarationInternal(node);
+}
+
+bool Parser::parseLinkageSpecification(DeclarationAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    CHECK(Token_extern);
+
+    LinkageSpecificationAST *ast = CreateNode<LinkageSpecificationAST>(_M_pool);
+
+    if (token_stream.lookAhead() == Token_string_literal) {
+        ast->extern_type = token_stream.cursor();
+        token_stream.nextToken();
+    }
+
+    if (token_stream.lookAhead() == '{')
+        parseLinkageBody(ast->linkage_body);
+    else if (!parseDeclaration(ast->declaration))
+        reportError(("Declaration syntax error"));
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseLinkageBody(LinkageBodyAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    CHECK('{');
+
+    LinkageBodyAST *ast = CreateNode<LinkageBodyAST>(_M_pool);
+
+    while (token_stream.lookAhead()) {
+        int tk = token_stream.lookAhead();
+
+        if (tk == '}')
+            break;
+
+        std::size_t startDecl = token_stream.cursor();
+
+        DeclarationAST *declaration = 0;
+        if (parseDeclaration(declaration)) {
+            ast->declarations = snoc(ast->declarations, declaration, _M_pool);
+        } else {
+            // error recovery
+            if (startDecl == token_stream.cursor()) {
+                // skip at least one token
+                token_stream.nextToken();
+            }
+
+            skipUntilDeclaration();
+        }
+    }
+
+    if (token_stream.lookAhead() != '}')
+        reportError(("} expected"));
+    else
+        token_stream.nextToken();
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseNamespace(DeclarationAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    CHECK(Token_namespace);
+
+    std::size_t namespace_name = 0;
+    if (token_stream.lookAhead() == Token_identifier) {
+        namespace_name = token_stream.cursor();
+        token_stream.nextToken();
+    }
+
+    if (token_stream.lookAhead() == '=') {
+        // namespace alias
+        token_stream.nextToken();
+
+        NameAST *name = 0;
+        if (parseName(name)) {
+            ADVANCE(';', ";");
+
+            NamespaceAliasDefinitionAST *ast
+            = CreateNode<NamespaceAliasDefinitionAST>(_M_pool);
+            ast->namespace_name = namespace_name;
+            ast->alias_name = name;
+            UPDATE_POS(ast, start, token_stream.cursor());
+            node = ast;
+            return true;
+        } else {
+            reportError(("namespace expected"));
+            return false;
+        }
+    } else if (token_stream.lookAhead() != '{') {
+        reportError(("{ expected"));
+        return false;
+    }
+
+    NamespaceAST *ast = CreateNode<NamespaceAST>(_M_pool);
+    ast->namespace_name = namespace_name;
+    parseLinkageBody(ast->linkage_body);
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseUsing(DeclarationAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    CHECK(Token_using);
+
+    if (token_stream.lookAhead() == Token_namespace)
+        return parseUsingDirective(node);
+
+    UsingAST *ast = CreateNode<UsingAST>(_M_pool);
+
+    if (token_stream.lookAhead() == Token_typename) {
+        ast->type_name = token_stream.cursor();
+        token_stream.nextToken();
+    }
+
+    if (!parseName(ast->name))
+        return false;
+
+    ADVANCE(';', ";");
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseUsingDirective(DeclarationAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    CHECK(Token_namespace);
+
+    NameAST *name = 0;
+    if (!parseName(name)) {
+        reportError(("Namespace name expected"));
+        return false;
+    }
+
+    ADVANCE(';', ";");
+
+    UsingDirectiveAST *ast = CreateNode<UsingDirectiveAST>(_M_pool);
+    ast->name = name;
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+
+bool Parser::parseOperatorFunctionId(OperatorFunctionIdAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    CHECK(Token_operator);
+
+    OperatorFunctionIdAST *ast = CreateNode<OperatorFunctionIdAST>(_M_pool);
+
+    if (!parseOperator(ast->op)) {
+        ast->op = 0;
+
+        // parse cast operator
+        const ListNode<std::size_t> *cv = 0;
+        parseCvQualify(cv);
+
+        if (!parseSimpleTypeSpecifier(ast->type_specifier)) {
+            syntaxError();
+            return false;
+        }
+
+        parseCvQualify(cv);
+        ast->type_specifier->cv = cv;
+
+        PtrOperatorAST *ptr_op = 0;
+        while (parsePtrOperator(ptr_op))
+            ast->ptr_ops = snoc(ast->ptr_ops, ptr_op, _M_pool);
+    }
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+    return true;
+}
+
+bool Parser::parseTemplateArgumentList(const ListNode<TemplateArgumentAST*> *&node,
+                                       bool reportError)
+{
+    TemplateArgumentAST *templArg = 0;
+    if (!parseTemplateArgument(templArg))
+        return false;
+
+    node = snoc(node, templArg, _M_pool);
+
+    while (token_stream.lookAhead() == ',') {
+        token_stream.nextToken();
+
+        if (!parseTemplateArgument(templArg)) {
+            if (reportError) {
+                syntaxError();
+                break;
+            }
+
+            node = 0;
+            return false;
+        }
+
+        node = snoc(node, templArg, _M_pool);
+    }
+
+    return true;
+}
+
+bool Parser::parseTypedef(DeclarationAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    CHECK(Token_typedef);
+
+    TypeSpecifierAST *spec = 0;
+    if (!parseTypeSpecifierOrClassSpec(spec)) {
+        reportError(("Need a type specifier to declare"));
+        return false;
+    }
+
+    const ListNode<InitDeclaratorAST*> *declarators = 0;
+    if (!parseInitDeclaratorList(declarators)) {
+        //reportError(("Need an identifier to declare"));
+        //return false;
+    }
+
+    ADVANCE(';', ";");
+
+    TypedefAST *ast = CreateNode<TypedefAST>(_M_pool);
+    ast->type_specifier = spec;
+    ast->init_declarators = declarators;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseAsmDefinition(DeclarationAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    ADVANCE(Token_asm, "asm");
+
+    const ListNode<std::size_t> *cv = 0;
+    parseCvQualify(cv);
+
+#if defined(__GNUC__)
+#warning "implement me"
+#endif
+    skip('(', ')');
+    token_stream.nextToken();
+    ADVANCE(';', ";");
+
+    AsmDefinitionAST *ast = CreateNode<AsmDefinitionAST>(_M_pool);
+    ast->cv = cv;
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseTemplateDeclaration(DeclarationAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    std::size_t exported = 0;
+    if (token_stream.lookAhead() == Token_export) {
+        exported = token_stream.cursor();
+        token_stream.nextToken();
+    }
+
+    CHECK(Token_template);
+
+    const ListNode<TemplateParameterAST*> *params = 0;
+    if (token_stream.lookAhead() == '<') {
+        token_stream.nextToken();
+        parseTemplateParameterList(params);
+
+        ADVANCE('>', ">");
+    }
+
+    DeclarationAST *declaration = 0;
+    if (!parseDeclaration(declaration))
+        reportError(("expected a declaration"));
+
+    TemplateDeclarationAST *ast = CreateNode<TemplateDeclarationAST>(_M_pool);
+    ast->exported = exported;
+    ast->template_parameters = params;
+    ast->declaration = declaration;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseOperator(OperatorAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    OperatorAST *ast = CreateNode<OperatorAST>(_M_pool);
+
+    switch (token_stream.lookAhead()) {
+    case Token_new:
+    case Token_delete: {
+        ast->op = token_stream.cursor();
+        token_stream.nextToken();
+
+        if (token_stream.lookAhead() == '['
+            && token_stream.lookAhead(1) == ']') {
+            ast->open = token_stream.cursor();
+            token_stream.nextToken();
+
+            ast->close = token_stream.cursor();
+            token_stream.nextToken();
+        }
+    }
+    break;
+
+    case '+':
+    case '-':
+    case '*':
+    case '/':
+    case '%':
+    case '^':
+    case '&':
+    case '|':
+    case '~':
+    case '!':
+    case '=':
+    case '<':
+    case '>':
+    case ',':
+    case Token_assign:
+    case Token_shift:
+    case Token_eq:
+    case Token_not_eq:
+    case Token_leq:
+    case Token_geq:
+    case Token_and:
+    case Token_or:
+    case Token_incr:
+    case Token_decr:
+    case Token_ptrmem:
+    case Token_arrow:
+        ast->op = token_stream.cursor();
+        token_stream.nextToken();
+        break;
+
+    default:
+        if (token_stream.lookAhead() == '('
+            && token_stream.lookAhead(1) == ')') {
+            ast->op = ast->open = token_stream.cursor();
+            token_stream.nextToken();
+            ast->close = token_stream.cursor();
+            token_stream.nextToken();
+        } else if (token_stream.lookAhead() == '['
+                   && token_stream.lookAhead(1) == ']') {
+            ast->op = ast->open = token_stream.cursor();
+            token_stream.nextToken();
+            ast->close = token_stream.cursor();
+            token_stream.nextToken();
+        } else {
+            return false;
+        }
+    }
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseCvQualify(const ListNode<std::size_t> *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    int tk;
+    while (0 != (tk = token_stream.lookAhead())
+           && (tk == Token_const || tk == Token_volatile)) {
+        node = snoc(node, token_stream.cursor(), _M_pool);
+        token_stream.nextToken();
+    }
+
+    return start != token_stream.cursor();
+}
+
+bool Parser::parseSimpleTypeSpecifier(TypeSpecifierAST *&node,
+                                      bool onlyIntegral)
+{
+    std::size_t start = token_stream.cursor();
+    bool isIntegral = false;
+    bool done = false;
+
+    const ListNode<std::size_t> *integrals = 0;
+
+    while (!done) {
+        switch (token_stream.lookAhead()) {
+        case Token_char:
+        case Token_wchar_t:
+        case Token_bool:
+        case Token_short:
+        case Token_int:
+        case Token_long:
+        case Token_signed:
+        case Token_unsigned:
+        case Token_float:
+        case Token_double:
+        case Token_void:
+            integrals = snoc(integrals, token_stream.cursor(), _M_pool);
+            isIntegral = true;
+            token_stream.nextToken();
+            break;
+
+        default:
+            done = true;
+        }
+    }
+
+    SimpleTypeSpecifierAST *ast = CreateNode<SimpleTypeSpecifierAST>(_M_pool);
+    if (isIntegral) {
+        ast->integrals = integrals;
+    } else if (token_stream.lookAhead() == Token___typeof) {
+        ast->type_of = token_stream.cursor();
+        token_stream.nextToken();
+
+        if (token_stream.lookAhead() == '(') {
+            token_stream.nextToken();
+
+            std::size_t saved = token_stream.cursor();
+            parseTypeId(ast->type_id);
+            if (token_stream.lookAhead() != ')') {
+                ast->type_id = 0;
+                token_stream.rewind((int) saved);
+                parseUnaryExpression(ast->expression);
+            }
+            ADVANCE(')', ")");
+        } else {
+            parseUnaryExpression(ast->expression);
+        }
+    } else if (onlyIntegral) {
+        token_stream.rewind((int) start);
+        return false;
+    } else {
+        if (!parseName(ast->name, true)) {
+            ast->name = 0;
+            token_stream.rewind((int) start);
+            return false;
+        }
+    }
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parsePtrOperator(PtrOperatorAST *&node)
+{
+    int tk = token_stream.lookAhead();
+
+    if (tk != '&' && tk != '*'
+        && tk != Token_scope && tk != Token_identifier) {
+        return false;
+    }
+
+    std::size_t start = token_stream.cursor();
+
+    PtrOperatorAST *ast = CreateNode<PtrOperatorAST>(_M_pool);
+
+    switch (token_stream.lookAhead()) {
+    case '&':
+    case '*':
+        ast->op = token_stream.cursor();
+        token_stream.nextToken();
+        break;
+
+    case Token_scope:
+    case Token_identifier: {
+        if (!parsePtrToMember(ast->mem_ptr)) {
+            token_stream.rewind((int) start);
+            return false;
+        }
+    }
+    break;
+
+    default:
+        Q_ASSERT(0);
+        break;
+    }
+
+    parseCvQualify(ast->cv);
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseTemplateArgument(TemplateArgumentAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    TypeIdAST *typeId = 0;
+    ExpressionAST *expr = 0;
+
+    if (!parseTypeId(typeId) || (token_stream.lookAhead() != ','
+                                 && token_stream.lookAhead() != '>')) {
+        token_stream.rewind((int) start);
+
+        if (!parseLogicalOrExpression(expr, true))
+            return false;
+    }
+
+    TemplateArgumentAST *ast = CreateNode<TemplateArgumentAST>(_M_pool);
+    ast->type_id = typeId;
+    ast->expression = expr;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseTypeSpecifier(TypeSpecifierAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    const ListNode<std::size_t> *cv = 0;
+    parseCvQualify(cv);
+
+    TypeSpecifierAST *ast = 0;
+    if (!parseElaboratedTypeSpecifier(ast) && !parseSimpleTypeSpecifier(ast)) {
+        token_stream.rewind((int) start);
+        return false;
+    }
+
+    parseCvQualify(cv);
+    ast->cv = cv;
+
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseDeclarator(DeclaratorAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    DeclaratorAST *ast = CreateNode<DeclaratorAST>(_M_pool);
+
+    //fprintf(stderr, "[%s-%s] ast->ptr_ops: %p\n", __FILE__, __FUNCTION__, ast->ptr_ops);
+
+    DeclaratorAST *decl = 0;
+    NameAST *declId = 0;
+
+    PtrOperatorAST *ptrOp = 0;
+    while (parsePtrOperator(ptrOp))
+        ast->ptr_ops = snoc(ast->ptr_ops, ptrOp, _M_pool);
+
+    if (token_stream.lookAhead() == '(') {
+        token_stream.nextToken();
+
+        if (!parseDeclarator(decl))
+            return false;
+
+        ast->sub_declarator = decl;
+
+        CHECK(')');
+    } else {
+        if (token_stream.lookAhead() == ':') {
+            // unnamed bitfield
+        } else if (parseName(declId, true)) {
+            ast->id = declId;
+        } else {
+            token_stream.rewind((int) start);
+            return false;
+        }
+
+        if (token_stream.lookAhead() == ':') {
+            token_stream.nextToken();
+
+            if (!parseConstantExpression(ast->bit_expression))
+                reportError(("Constant expression expected"));
+
+            goto update_pos;
+        }
+    }
+
+    {
+        bool isVector = true;
+
+        while (token_stream.lookAhead() == '[') {
+            token_stream.nextToken();
+
+            ExpressionAST *expr = 0;
+            parseCommaExpression(expr);
+
+            ADVANCE(']', "]");
+
+            ast->array_dimensions = snoc(ast->array_dimensions, expr, _M_pool);
+            isVector = true;
+        }
+
+        bool skipParen = false;
+        if (token_stream.lookAhead() == Token_identifier
+            && token_stream.lookAhead(1) == '('
+            && token_stream.lookAhead(2) == '(') {
+            token_stream.nextToken();
+            token_stream.nextToken();
+            skipParen = true;
+        }
+
+        int tok = token_stream.lookAhead();
+        if (ast->sub_declarator
+            && !(isVector || tok == '(' || tok == ','
+                 || tok == ';' || tok == '=')) {
+            token_stream.rewind((int) start);
+            return false;
+        }
+
+        std::size_t index = token_stream.cursor();
+        if (token_stream.lookAhead() == '(') {
+            token_stream.nextToken();
+
+            ParameterDeclarationClauseAST *params = 0;
+            if (!parseParameterDeclarationClause(params)) {
+                token_stream.rewind((int) index);
+                goto update_pos;
+            }
+
+            ast->parameter_declaration_clause = params;
+
+            if (token_stream.lookAhead() != ')') {
+                token_stream.rewind((int) index);
+                goto update_pos;
+            }
+
+            token_stream.nextToken();  // skip ')'
+
+            parseCvQualify(ast->fun_cv);
+            parseExceptionSpecification(ast->exception_spec);
+
+            if (token_stream.lookAhead() == Token___attribute__)
+                parse_Attribute__();
+        }
+
+        if (skipParen) {
+            if (token_stream.lookAhead() != ')')
+                reportError(("')' expected"));
+            else
+                token_stream.nextToken();
+        }
+    }
+
+update_pos:
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseAbstractDeclarator(DeclaratorAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    DeclaratorAST *ast = CreateNode<DeclaratorAST>(_M_pool);
+    DeclaratorAST *decl = 0;
+
+    PtrOperatorAST *ptrOp = 0;
+    while (parsePtrOperator(ptrOp))
+        ast->ptr_ops = snoc(ast->ptr_ops, ptrOp, _M_pool);
+
+    int index = (int) token_stream.cursor();
+    if (token_stream.lookAhead() == '(') {
+        token_stream.nextToken();
+
+        if (!parseAbstractDeclarator(decl)) {
+            token_stream.rewind((int) index);
+            goto label1;
+        }
+
+        ast->sub_declarator = decl;
+
+        if (token_stream.lookAhead() != ')') {
+            token_stream.rewind((int) start);
+            return false;
+        }
+        token_stream.nextToken();
+    } else if (token_stream.lookAhead() == ':') {
+        token_stream.nextToken();
+        if (!parseConstantExpression(ast->bit_expression)) {
+            ast->bit_expression = 0;
+            reportError(("Constant expression expected"));
+        }
+        goto update_pos;
+    }
+
+label1: {
+        bool isVector = true;
+
+        while (token_stream.lookAhead() == '[') {
+            token_stream.nextToken();
+
+            ExpressionAST *expr = 0;
+            parseCommaExpression(expr);
+
+            ADVANCE(']', "]");
+
+            ast->array_dimensions = snoc(ast->array_dimensions, expr, _M_pool);
+            isVector = true;
+        }
+
+        int tok = token_stream.lookAhead();
+        if (ast->sub_declarator
+            && !(isVector || tok == '(' || tok == ','
+                 || tok == ';' || tok == '=')) {
+            token_stream.rewind((int) start);
+            return false;
+        }
+
+        int index = (int) token_stream.cursor();
+        if (token_stream.lookAhead() == '(') {
+            token_stream.nextToken();
+
+            ParameterDeclarationClauseAST *params = 0;
+            if (!parseParameterDeclarationClause(params)) {
+                token_stream.rewind((int) index);
+                goto update_pos;
+            }
+
+            ast->parameter_declaration_clause = params;
+
+            if (token_stream.lookAhead() != ')') {
+                token_stream.rewind((int) index);
+                goto update_pos;
+            }
+
+            token_stream.nextToken();  // skip ')'
+
+            parseCvQualify(ast->fun_cv);
+            parseExceptionSpecification(ast->exception_spec);
+        }
+    }
+
+update_pos:
+    if (token_stream.cursor() == start)
+        return false;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseEnumSpecifier(TypeSpecifierAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    CHECK(Token_enum);
+
+    NameAST *name = 0;
+    parseName(name);
+
+    if (token_stream.lookAhead() != '{') {
+        token_stream.rewind((int) start);
+        return false;
+    }
+    token_stream.nextToken();
+
+    EnumSpecifierAST *ast = CreateNode<EnumSpecifierAST>(_M_pool);
+    ast->name = name;
+
+    EnumeratorAST *enumerator = 0;
+    if (parseEnumerator(enumerator)) {
+        ast->enumerators = snoc(ast->enumerators, enumerator, _M_pool);
+
+        while (token_stream.lookAhead() == ',') {
+            token_stream.nextToken();
+
+            if (!parseEnumerator(enumerator)) {
+                //reportError(("Enumerator expected"));
+                break;
+            }
+
+            ast->enumerators = snoc(ast->enumerators, enumerator, _M_pool);
+        }
+    }
+
+    ADVANCE_NR('}', "}");
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseTemplateParameterList(const ListNode<TemplateParameterAST*> *&node)
+{
+    TemplateParameterAST *param = 0;
+    if (!parseTemplateParameter(param))
+        return false;
+
+    node = snoc(node, param, _M_pool);
+
+    while (token_stream.lookAhead() == ',') {
+        token_stream.nextToken();
+
+        if (!parseTemplateParameter(param)) {
+            syntaxError();
+            break;
+        } else {
+            node = snoc(node, param, _M_pool);
+        }
+    }
+
+    return true;
+}
+
+bool Parser::parseTemplateParameter(TemplateParameterAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+    TemplateParameterAST *ast = CreateNode<TemplateParameterAST>(_M_pool);
+
+    int tk = token_stream.lookAhead();
+
+    if ((tk == Token_class || tk == Token_typename || tk == Token_template)
+        && parseTypeParameter(ast->type_parameter)) {
+        // nothing to do
+    } else if (!parseParameterDeclaration(ast->parameter_declaration))
+        return false;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseTypeParameter(TypeParameterAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    TypeParameterAST *ast = CreateNode<TypeParameterAST>(_M_pool);
+    ast->type = start;
+
+    switch (token_stream.lookAhead()) {
+    case Token_class:
+    case Token_typename: {
+        token_stream.nextToken(); // skip class
+
+        // parse optional name
+        if (parseName(ast->name, true)) {
+            if (token_stream.lookAhead() == '=') {
+                token_stream.nextToken();
+
+                if (!parseTypeId(ast->type_id)) {
+                    //syntaxError();
+                    token_stream.rewind((int) start);
+                    return false;
+                }
+            } else if (token_stream.lookAhead() != ','
+                       && token_stream.lookAhead() != '>') {
+                token_stream.rewind((int) start);
+                return false;
+            }
+        }
+    }
+    break;
+
+    case Token_template: {
+        token_stream.nextToken(); // skip template
+        ADVANCE('<', "<");
+
+        if (!parseTemplateParameterList(ast->template_parameters))
+            return false;
+
+        ADVANCE('>', ">");
+
+        if (token_stream.lookAhead() == Token_class)
+            token_stream.nextToken();
+
+        // parse optional name
+        if (parseName(ast->name, true)) {
+            if (token_stream.lookAhead() == '=') {
+                token_stream.nextToken();
+
+                if (!parseTypeId(ast->type_id)) {
+                    syntaxError();
+                    return false;
+                }
+            }
+        }
+
+        if (token_stream.lookAhead() == '=') {
+            token_stream.nextToken();
+
+            parseName(ast->template_name, true);
+        }
+    }
+    break;
+
+    default:
+        return false;
+
+    } // end switch
+
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+    return true;
+}
+
+bool Parser::parseStorageClassSpecifier(const ListNode<std::size_t> *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    int tk;
+    while (0 != (tk = token_stream.lookAhead())
+           && (tk == Token_friend || tk == Token_auto
+               || tk == Token_register || tk == Token_static
+               || tk == Token_extern || tk == Token_mutable)) {
+        node = snoc(node, token_stream.cursor(), _M_pool);
+        token_stream.nextToken();
+    }
+
+    return start != token_stream.cursor();
+}
+
+bool Parser::parseFunctionSpecifier(const ListNode<std::size_t> *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    int tk;
+    while (0 != (tk = token_stream.lookAhead())
+           && (tk == Token_inline || tk == Token_virtual
+               || tk == Token_explicit || tk == Token_Q_INVOKABLE)) {
+        node = snoc(node, token_stream.cursor(), _M_pool);
+        token_stream.nextToken();
+    }
+
+    return start != token_stream.cursor();
+}
+
+bool Parser::parseTypeId(TypeIdAST *&node)
+{
+    /// @todo implement the AST for typeId
+    std::size_t start = token_stream.cursor();
+
+    TypeSpecifierAST *spec = 0;
+    if (!parseTypeSpecifier(spec)) {
+        token_stream.rewind((int) start);
+        return false;
+    }
+
+    DeclaratorAST *decl = 0;
+    parseAbstractDeclarator(decl);
+
+    TypeIdAST *ast = CreateNode<TypeIdAST>(_M_pool);
+    ast->type_specifier = spec;
+    ast->declarator = decl;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseInitDeclaratorList(const ListNode<InitDeclaratorAST*> *&node)
+{
+    InitDeclaratorAST *decl = 0;
+    if (!parseInitDeclarator(decl))
+        return false;
+
+    node = snoc(node, decl, _M_pool);
+
+    while (token_stream.lookAhead() == ',') {
+        token_stream.nextToken();
+
+        if (!parseInitDeclarator(decl)) {
+            syntaxError();
+            break;
+        }
+        node = snoc(node, decl, _M_pool);
+    }
+
+    return true;
+}
+
+bool Parser::parseParameterDeclarationClause(ParameterDeclarationClauseAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    ParameterDeclarationClauseAST *ast
+    = CreateNode<ParameterDeclarationClauseAST>(_M_pool);
+
+    if (!parseParameterDeclarationList(ast->parameter_declarations)) {
+        if (token_stream.lookAhead() == ')')
+            goto good;
+
+        if (token_stream.lookAhead() == Token_ellipsis
+            && token_stream.lookAhead(1) == ')') {
+            ast->ellipsis = token_stream.cursor();
+            goto good;
+        }
+
+        return false;
+    }
+
+good:
+
+    if (token_stream.lookAhead() == Token_ellipsis) {
+        ast->ellipsis = token_stream.cursor();
+        token_stream.nextToken();
+    }
+
+    /// @todo add ellipsis
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseParameterDeclarationList(const ListNode<ParameterDeclarationAST*> *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    ParameterDeclarationAST *param = 0;
+    if (!parseParameterDeclaration(param)) {
+        token_stream.rewind((int) start);
+        return false;
+    }
+
+    node = snoc(node, param, _M_pool);
+
+    while (token_stream.lookAhead() == ',') {
+        token_stream.nextToken();
+
+        if (token_stream.lookAhead() == Token_ellipsis)
+            break;
+
+        if (!parseParameterDeclaration(param)) {
+            token_stream.rewind((int) start);
+            return false;
+        }
+        node = snoc(node, param, _M_pool);
+    }
+
+    return true;
+}
+
+bool Parser::parseParameterDeclaration(ParameterDeclarationAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    const ListNode<std::size_t> *storage = 0;
+    parseStorageClassSpecifier(storage);
+
+    // parse decl spec
+    TypeSpecifierAST *spec = 0;
+    if (!parseTypeSpecifier(spec)) {
+        token_stream.rewind((int) start);
+        return false;
+    }
+
+    int index = (int) token_stream.cursor();
+
+    DeclaratorAST *decl = 0;
+    if (!parseDeclarator(decl)) {
+        token_stream.rewind((int) index);
+
+        // try with abstract declarator
+        parseAbstractDeclarator(decl);
+    }
+
+    ExpressionAST *expr = 0;
+    if (token_stream.lookAhead() == '=') {
+        token_stream.nextToken();
+        if (!parseLogicalOrExpression(expr, true))
+            reportError(("Expression expected"));
+    }
+
+    ParameterDeclarationAST *ast = CreateNode<ParameterDeclarationAST>(_M_pool);
+    ast->type_specifier = spec;
+    ast->declarator = decl;
+    ast->expression = expr;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parse_Attribute__()
+{
+    token_stream.nextToken();
+
+    ADVANCE('(', "(");
+
+    ExpressionAST *expr = 0;
+    parseExpression(expr);
+
+    if (token_stream.lookAhead() != ')') {
+        reportError(("')' expected"));
+        return false;
+    } else {
+        token_stream.nextToken();
+    }
+    return true;
+}
+
+QString Parser::tokenText(AST *ast) const
+{
+    if (!ast)
+        return QString();
+
+    int start_token = ast->start_token;
+    int end_token = ast->end_token;
+
+    Token const &tk = token_stream.token(start_token);
+    Token const &end_tk = token_stream.token(end_token);
+
+    return QString::fromLatin1(&tk.text[tk.position],
+                               (int)(end_tk.position - tk.position)).trimmed();
+}
+
+bool Parser::parseForwardDeclarationSpecifier(TypeSpecifierAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    int kind = token_stream.lookAhead();
+    if (kind != Token_class && kind != Token_struct && kind != Token_union)
+        return false;
+
+    std::size_t class_key = token_stream.cursor();
+    token_stream.nextToken();
+
+    NameAST *name = 0;
+    if (!parseName(name, false)) {
+        token_stream.rewind((int) start);
+        return false;
+    }
+
+    BaseClauseAST *bases = 0;
+    if (token_stream.lookAhead() == ':') {
+        if (!parseBaseClause(bases)) {
+            token_stream.rewind((int) start);
+            return false;
+        }
+    }
+
+    if (token_stream.lookAhead() != ';') {
+        token_stream.rewind((int) start);
+        return false;
+    }
+
+    ForwardDeclarationSpecifierAST *ast = CreateNode<ForwardDeclarationSpecifierAST>(_M_pool);
+    ast->class_key = class_key;
+    ast->name = name;
+    ast->base_clause = bases;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseClassSpecifier(TypeSpecifierAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    int kind = token_stream.lookAhead();
+    if (kind != Token_class && kind != Token_struct && kind != Token_union)
+        return false;
+
+    std::size_t class_key = token_stream.cursor();
+    token_stream.nextToken();
+
+    WinDeclSpecAST *winDeclSpec = 0;
+    parseWinDeclSpec(winDeclSpec);
+
+    if (token_stream.lookAhead() == Token___attribute__)
+        parse_Attribute__();
+
+    while (token_stream.lookAhead() == Token_identifier
+           && token_stream.lookAhead(1) == Token_identifier)
+        token_stream.nextToken();
+
+    NameAST *name = 0;
+    parseName(name, true);
+
+    BaseClauseAST *bases = 0;
+
+    if (token_stream.lookAhead() == ':') {
+        if (!parseBaseClause(bases))
+            skipUntil('{');
+    }
+
+    if (token_stream.lookAhead() != '{') {
+
+        token_stream.rewind((int) start);
+        return false;
+    }
+
+    ADVANCE('{', "{");
+
+    ClassSpecifierAST *ast = CreateNode<ClassSpecifierAST>(_M_pool);
+    ast->win_decl_specifiers = winDeclSpec;
+    ast->class_key = class_key;
+    ast->name = name;
+    ast->base_clause = bases;
+
+    while (token_stream.lookAhead()) {
+        if (token_stream.lookAhead() == '}')
+            break;
+
+        std::size_t startDecl = token_stream.cursor();
+
+        DeclarationAST *memSpec = 0;
+        if (!parseMemberSpecification(memSpec)) {
+            if (startDecl == token_stream.cursor())
+                token_stream.nextToken(); // skip at least one token
+            skipUntilDeclaration();
+        } else
+            ast->member_specs = snoc(ast->member_specs, memSpec, _M_pool);
+    }
+
+    ADVANCE_NR('}', "}");
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseAccessSpecifier(DeclarationAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    const ListNode<std::size_t> *specs = 0;
+
+    bool done = false;
+    while (!done) {
+        switch (token_stream.lookAhead()) {
+        case Token_signals:
+        case Token_slots:
+        case Token_k_dcop:
+        case Token_k_dcop_signals:
+        case Token_public:
+        case Token_protected:
+        case Token_private:
+            specs = snoc(specs, token_stream.cursor(), _M_pool);
+            token_stream.nextToken();
+            break;
+
+        default:
+            done = true;
+            break;
+        }
+    }
+
+    if (!specs)
+        return false;
+
+    ADVANCE(':', ":");
+
+    AccessSpecifierAST *ast = CreateNode<AccessSpecifierAST>(_M_pool);
+    ast->specs = specs;
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseMemberSpecification(DeclarationAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (token_stream.lookAhead() == ';') {
+        token_stream.nextToken();
+        return true;
+    } else if (token_stream.lookAhead() == Token_Q_OBJECT
+               || token_stream.lookAhead() == Token_K_DCOP) {
+        token_stream.nextToken();
+        return true;
+    } else if (parseTypedef(node)) {
+        return true;
+    } else if (parseUsing(node)) {
+        return true;
+    } else if (parseTemplateDeclaration(node)) {
+        return true;
+    } else if (parseAccessSpecifier(node)) {
+        return true;
+    } else if (parseQ_PROPERTY(node)) {
+        return true;
+    } else if (parseQ_ENUMS(node)) {
+        return true;
+    }
+
+    token_stream.rewind((int) start);
+
+    const ListNode<std::size_t> *cv = 0;
+    parseCvQualify(cv);
+
+    const ListNode<std::size_t> *storageSpec = 0;
+    parseStorageClassSpecifier(storageSpec);
+
+    parseCvQualify(cv);
+
+    TypeSpecifierAST *spec = 0;
+    if (parseEnumSpecifier(spec) || parseClassSpecifier(spec)) {
+        parseCvQualify(cv);
+        spec->cv = cv;
+
+        const ListNode<InitDeclaratorAST*> *declarators = 0;
+        parseInitDeclaratorList(declarators);
+        ADVANCE(';', ";");
+
+        SimpleDeclarationAST *ast = CreateNode<SimpleDeclarationAST>(_M_pool);
+        ast->type_specifier = spec;
+        ast->init_declarators = declarators;
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+
+        return true;
+    }
+
+    token_stream.rewind((int) start);
+    return parseDeclarationInternal(node);
+}
+
+bool Parser::parseCtorInitializer(CtorInitializerAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    CHECK(':');
+
+    CtorInitializerAST *ast = CreateNode<CtorInitializerAST>(_M_pool);
+    ast->colon = start;
+
+    if (!parseMemInitializerList(ast->member_initializers))
+        reportError(("Member initializers expected"));
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseElaboratedTypeSpecifier(TypeSpecifierAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    int tk = token_stream.lookAhead();
+    if (tk == Token_class
+        || tk == Token_struct
+        || tk == Token_union
+        || tk == Token_enum
+        || tk == Token_typename) {
+        std::size_t type = token_stream.cursor();
+        token_stream.nextToken();
+
+        NameAST *name = 0;
+        if (parseName(name, true)) {
+            ElaboratedTypeSpecifierAST *ast
+            = CreateNode<ElaboratedTypeSpecifierAST>(_M_pool);
+
+            ast->type = type;
+            ast->name = name;
+
+            UPDATE_POS(ast, start, token_stream.cursor());
+            node = ast;
+
+            return true;
+        }
+    }
+
+    token_stream.rewind((int) start);
+    return false;
+}
+
+bool Parser::parseExceptionSpecification(ExceptionSpecificationAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    CHECK(Token_throw);
+    ADVANCE('(', "(");
+
+    ExceptionSpecificationAST *ast = CreateNode<ExceptionSpecificationAST>(_M_pool);
+
+    if (token_stream.lookAhead() == Token_ellipsis) {
+        ast->ellipsis = token_stream.cursor();
+        token_stream.nextToken();
+    } else {
+        parseTypeIdList(ast->type_ids);
+    }
+
+    ADVANCE(')', ")");
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseEnumerator(EnumeratorAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    CHECK(Token_identifier);
+    std::size_t id = token_stream.cursor() - 1;
+
+    EnumeratorAST *ast = CreateNode<EnumeratorAST>(_M_pool);
+    ast->id = id;
+
+    if (token_stream.lookAhead() == '=') {
+        token_stream.nextToken();
+
+        if (!parseConstantExpression(ast->expression))
+            reportError(("Constant expression expected"));
+    }
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseInitDeclarator(InitDeclaratorAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    DeclaratorAST *decl = 0;
+    if (!parseDeclarator(decl))
+        return false;
+
+    if (token_stream.lookAhead(0) == Token_asm) {
+        token_stream.nextToken();
+        skip('(', ')');
+        token_stream.nextToken();
+    }
+
+    InitializerAST *init = 0;
+    parseInitializer(init);
+
+    InitDeclaratorAST *ast = CreateNode<InitDeclaratorAST>(_M_pool);
+    ast->declarator = decl;
+    ast->initializer = init;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseBaseClause(BaseClauseAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    CHECK(':');
+
+    BaseSpecifierAST *baseSpec = 0;
+    if (!parseBaseSpecifier(baseSpec))
+        return false;
+
+    BaseClauseAST *ast = CreateNode<BaseClauseAST>(_M_pool);
+    ast->base_specifiers = snoc(ast->base_specifiers, baseSpec, _M_pool);
+
+    while (token_stream.lookAhead() == ',') {
+        token_stream.nextToken();
+
+        if (!parseBaseSpecifier(baseSpec)) {
+            reportError(("Base class specifier expected"));
+            break;
+        }
+        ast->base_specifiers = snoc(ast->base_specifiers, baseSpec, _M_pool);
+    }
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseInitializer(InitializerAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    int tk = token_stream.lookAhead();
+    if (tk != '=' && tk != '(')
+        return false;
+
+    InitializerAST *ast = CreateNode<InitializerAST>(_M_pool);
+
+    if (tk == '=') {
+        token_stream.nextToken();
+
+        if (!parseInitializerClause(ast->initializer_clause))
+            reportError(("Initializer clause expected"));
+
+    } else if (tk == '(') {
+        token_stream.nextToken();
+        parseCommaExpression(ast->expression);
+        CHECK(')');
+    }
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseMemInitializerList(const ListNode<MemInitializerAST*> *&node)
+{
+    MemInitializerAST *init = 0;
+
+    if (!parseMemInitializer(init))
+        return false;
+
+    node = snoc(node, init, _M_pool);
+
+    while (token_stream.lookAhead() == ',') {
+        token_stream.nextToken();
+
+        if (!parseMemInitializer(init))
+            break;
+
+        node = snoc(node, init, _M_pool);
+    }
+
+    return true;
+}
+
+bool Parser::parseMemInitializer(MemInitializerAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    NameAST *initId = 0;
+    if (!parseName(initId, true)) {
+        reportError(("Identifier expected"));
+        return false;
+    }
+
+    ADVANCE('(', "(");
+    ExpressionAST *expr = 0;
+    parseCommaExpression(expr);
+    ADVANCE(')', ")");
+
+    MemInitializerAST *ast = CreateNode<MemInitializerAST>(_M_pool);
+    ast->initializer_id = initId;
+    ast->expression = expr;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseTypeIdList(const ListNode<TypeIdAST*> *&node)
+{
+    TypeIdAST *typeId = 0;
+    if (!parseTypeId(typeId))
+        return false;
+
+    node = snoc(node, typeId, _M_pool);
+
+    while (token_stream.lookAhead() == ',') {
+        token_stream.nextToken();
+        if (parseTypeId(typeId)) {
+            node = snoc(node, typeId, _M_pool);
+        } else {
+            reportError(("Type id expected"));
+            break;
+        }
+    }
+
+    return true;
+}
+
+bool Parser::parseBaseSpecifier(BaseSpecifierAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    BaseSpecifierAST *ast = CreateNode<BaseSpecifierAST>(_M_pool);
+
+    if (token_stream.lookAhead() == Token_virtual) {
+        ast->virt = token_stream.cursor();
+        token_stream.nextToken();
+
+        int tk = token_stream.lookAhead();
+        if (tk == Token_public || tk == Token_protected
+            || tk == Token_private) {
+            ast->access_specifier = token_stream.cursor();
+            token_stream.nextToken();
+        }
+    } else {
+        int tk = token_stream.lookAhead();
+        if (tk == Token_public || tk == Token_protected
+            || tk == Token_private) {
+            ast->access_specifier = token_stream.cursor();
+            token_stream.nextToken();
+        }
+
+        if (token_stream.lookAhead() == Token_virtual) {
+            ast->virt = token_stream.cursor();
+            token_stream.nextToken();
+        }
+    }
+
+    if (!parseName(ast->name, true))
+        reportError(("Class name expected"));
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseInitializerClause(InitializerClauseAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    InitializerClauseAST *ast = CreateNode<InitializerClauseAST>(_M_pool);
+
+    if (token_stream.lookAhead() == '{') {
+#if defined(__GNUC__)
+#warning "implement me"
+#endif
+        if (skip('{', '}'))
+            token_stream.nextToken();
+        else
+            reportError(("} missing"));
+    } else {
+        if (!parseAssignmentExpression(ast->expression))
+            reportError(("Expression expected"));
+    }
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parsePtrToMember(PtrToMemberAST *&node)
+{
+#if defined(__GNUC__)
+#warning "implemente me (AST)"
+#endif
+
+    std::size_t start = token_stream.cursor();
+
+    if (token_stream.lookAhead() == Token_scope) {
+        token_stream.nextToken();
+    }
+
+    UnqualifiedNameAST *name = 0;
+    while (token_stream.lookAhead() == Token_identifier) {
+        if (!parseUnqualifiedName(name))
+            break;
+
+        if (token_stream.lookAhead() == Token_scope
+            && token_stream.lookAhead(1) == '*') {
+            token_stream.nextToken();
+            token_stream.nextToken();
+
+            PtrToMemberAST *ast = CreateNode<PtrToMemberAST>(_M_pool);
+            UPDATE_POS(ast, start, token_stream.cursor());
+            node = ast;
+
+            return true;
+        }
+
+        if (token_stream.lookAhead() == Token_scope)
+            token_stream.nextToken();
+    }
+
+    token_stream.rewind((int) start);
+    return false;
+}
+
+bool Parser::parseUnqualifiedName(UnqualifiedNameAST *&node,
+                                  bool parseTemplateId)
+{
+    std::size_t start = token_stream.cursor();
+
+    std::size_t tilde = 0;
+    std::size_t id = 0;
+    OperatorFunctionIdAST *operator_id = 0;
+
+    if (token_stream.lookAhead() == Token_identifier) {
+        id = token_stream.cursor();
+        token_stream.nextToken();
+    } else if (token_stream.lookAhead() == '~'
+               && token_stream.lookAhead(1) == Token_identifier) {
+        tilde = token_stream.cursor();
+        token_stream.nextToken(); // skip ~
+
+        id = token_stream.cursor();
+        token_stream.nextToken(); // skip classname
+    } else if (token_stream.lookAhead() == Token_operator) {
+        if (!parseOperatorFunctionId(operator_id))
+            return false;
+    } else {
+        return false;
+    }
+
+    UnqualifiedNameAST *ast = CreateNode<UnqualifiedNameAST>(_M_pool);
+    ast->tilde = tilde;
+    ast->id = id;
+    ast->operator_id = operator_id;
+
+    if (parseTemplateId && !tilde) {
+        std::size_t index = token_stream.cursor();
+
+        if (token_stream.lookAhead() == '<') {
+            token_stream.nextToken();
+
+            // optional template arguments
+            parseTemplateArgumentList(ast->template_arguments);
+
+            if (token_stream.lookAhead() == '>') {
+                token_stream.nextToken();
+            } else {
+                ast->template_arguments = 0;
+                token_stream.rewind((int) index);
+            }
+        }
+    }
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseStringLiteral(StringLiteralAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (token_stream.lookAhead() != Token_string_literal)
+        return false;
+
+    StringLiteralAST *ast = CreateNode<StringLiteralAST>(_M_pool);
+
+    while (token_stream.lookAhead() == Token_string_literal) {
+        ast->literals = snoc(ast->literals, token_stream.cursor(), _M_pool);
+        token_stream.nextToken();
+    }
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseExpressionStatement(StatementAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    ExpressionAST *expr = 0;
+    parseCommaExpression(expr);
+
+    ADVANCE(';', ";");
+
+    ExpressionStatementAST *ast = CreateNode<ExpressionStatementAST>(_M_pool);
+    ast->expression = expr;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseStatement(StatementAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    switch (token_stream.lookAhead()) {
+    case Token_while:
+        return parseWhileStatement(node);
+
+    case Token_do:
+        return parseDoStatement(node);
+
+    case Token_for:
+        return parseForStatement(node);
+
+    case Token_if:
+        return parseIfStatement(node);
+
+    case Token_switch:
+        return parseSwitchStatement(node);
+
+    case Token_try:
+        return parseTryBlockStatement(node);
+
+    case Token_case:
+    case Token_default:
+        return parseLabeledStatement(node);
+
+    case Token_break:
+    case Token_continue:
+#if defined(__GNUC__)
+#warning "implement me"
+#endif
+        token_stream.nextToken();
+        ADVANCE(';', ";");
+        return true;
+
+    case Token_goto:
+#if defined(__GNUC__)
+#warning "implement me"
+#endif
+        token_stream.nextToken();
+        ADVANCE(Token_identifier, "identifier");
+        ADVANCE(';', ";");
+        return true;
+
+    case Token_return: {
+        token_stream.nextToken();
+        ExpressionAST *expr = 0;
+        parseCommaExpression(expr);
+
+        ADVANCE(';', ";");
+
+        ReturnStatementAST *ast = CreateNode<ReturnStatementAST>(_M_pool);
+        ast->expression = expr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+    return true;
+
+    case '{':
+        return parseCompoundStatement(node);
+
+    case Token_identifier:
+        if (parseLabeledStatement(node))
+            return true;
+        break;
+    }
+
+    return parseExpressionOrDeclarationStatement(node);
+}
+
+bool Parser::parseExpressionOrDeclarationStatement(StatementAST *&node)
+{
+    bool blocked = block_errors(true);
+
+    std::size_t start = token_stream.cursor();
+
+    StatementAST *decl_ast = 0;
+    bool maybe_amb = parseDeclarationStatement(decl_ast);
+    maybe_amb &= token_stream.kind(token_stream.cursor() - 1) == ';';
+
+    std::size_t end = token_stream.cursor();
+
+    token_stream.rewind((int) start);
+    StatementAST *expr_ast = 0;
+    maybe_amb &= parseExpressionStatement(expr_ast);
+    maybe_amb &= token_stream.kind(token_stream.cursor() - 1) == ';';
+
+    if (maybe_amb) {
+        Q_ASSERT(decl_ast && expr_ast);
+        ExpressionOrDeclarationStatementAST *ast =
+            CreateNode<ExpressionOrDeclarationStatementAST>(_M_pool);
+        ast->declaration = decl_ast;
+        ast->expression = expr_ast;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    } else {
+        token_stream.rewind((int) std::max(end, token_stream.cursor()));
+
+        node = decl_ast;
+        if (!node)
+            node = expr_ast;
+    }
+
+    block_errors(blocked);
+
+    if (!node)
+        syntaxError();
+
+    return node != 0;
+}
+
+bool Parser::parseCondition(ConditionAST *&node, bool initRequired)
+{
+    std::size_t start = token_stream.cursor();
+
+    ConditionAST *ast = CreateNode<ConditionAST>(_M_pool);
+    TypeSpecifierAST *spec = 0;
+
+    if (parseTypeSpecifier(spec)) {
+        ast->type_specifier = spec;
+
+        std::size_t declarator_start = token_stream.cursor();
+
+        DeclaratorAST *decl = 0;
+        if (!parseDeclarator(decl)) {
+            token_stream.rewind((int) declarator_start);
+            if (!initRequired && !parseAbstractDeclarator(decl))
+                decl = 0;
+        }
+
+        if (decl && (!initRequired || token_stream.lookAhead() == '=')) {
+            ast->declarator = decl;
+
+            if (token_stream.lookAhead() == '=') {
+                token_stream.nextToken();
+
+                parseExpression(ast->expression);
+            }
+
+            UPDATE_POS(ast, start, token_stream.cursor());
+            node = ast;
+
+            return true;
+        }
+    }
+
+    token_stream.rewind((int) start);
+
+    if (!parseCommaExpression(ast->expression))
+        return false;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+
+bool Parser::parseWhileStatement(StatementAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    ADVANCE(Token_while, "while");
+    ADVANCE('(' , "(");
+
+    ConditionAST *cond = 0;
+    if (!parseCondition(cond)) {
+        reportError(("condition expected"));
+        return false;
+    }
+    ADVANCE(')', ")");
+
+    StatementAST *body = 0;
+    if (!parseStatement(body)) {
+        reportError(("statement expected"));
+        return false;
+    }
+
+    WhileStatementAST *ast = CreateNode<WhileStatementAST>(_M_pool);
+    ast->condition = cond;
+    ast->statement = body;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseDoStatement(StatementAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    ADVANCE(Token_do, "do");
+
+    StatementAST *body = 0;
+    if (!parseStatement(body)) {
+        reportError(("statement expected"));
+        //return false;
+    }
+
+    ADVANCE_NR(Token_while, "while");
+    ADVANCE_NR('(' , "(");
+
+    ExpressionAST *expr = 0;
+    if (!parseCommaExpression(expr)) {
+        reportError(("expression expected"));
+        //return false;
+    }
+
+    ADVANCE_NR(')', ")");
+    ADVANCE_NR(';', ";");
+
+    DoStatementAST *ast = CreateNode<DoStatementAST>(_M_pool);
+    ast->statement = body;
+    ast->expression = expr;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseForStatement(StatementAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    ADVANCE(Token_for, "for");
+    ADVANCE('(', "(");
+
+    StatementAST *init = 0;
+    if (!parseForInitStatement(init)) {
+        reportError(("for initialization expected"));
+        return false;
+    }
+
+    ConditionAST *cond = 0;
+    parseCondition(cond);
+    ADVANCE(';', ";");
+
+    ExpressionAST *expr = 0;
+    parseCommaExpression(expr);
+    ADVANCE(')', ")");
+
+    StatementAST *body = 0;
+    if (!parseStatement(body))
+        return false;
+
+    ForStatementAST *ast = CreateNode<ForStatementAST>(_M_pool);
+    ast->init_statement = init;
+    ast->condition = cond;
+    ast->expression = expr;
+    ast->statement = body;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseForInitStatement(StatementAST *&node)
+{
+    if (parseDeclarationStatement(node))
+        return true;
+
+    return parseExpressionStatement(node);
+}
+
+bool Parser::parseCompoundStatement(StatementAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    CHECK('{');
+
+    CompoundStatementAST *ast = CreateNode<CompoundStatementAST>(_M_pool);
+
+    while (token_stream.lookAhead()) {
+        if (token_stream.lookAhead() == '}')
+            break;
+
+        std::size_t startStmt = token_stream.cursor();
+
+        StatementAST *stmt = 0;
+        if (!parseStatement(stmt)) {
+            if (startStmt == token_stream.cursor())
+                token_stream.nextToken();
+
+            skipUntilStatement();
+        } else {
+            ast->statements = snoc(ast->statements, stmt, _M_pool);
+        }
+    }
+
+    ADVANCE_NR('}', "}");
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseIfStatement(StatementAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    ADVANCE(Token_if, "if");
+
+    ADVANCE('(' , "(");
+
+    IfStatementAST *ast = CreateNode<IfStatementAST>(_M_pool);
+
+    ConditionAST *cond = 0;
+    if (!parseCondition(cond)) {
+        reportError(("condition expected"));
+        return false;
+    }
+    ADVANCE(')', ")");
+
+    StatementAST *stmt = 0;
+    if (!parseStatement(stmt)) {
+        reportError(("statement expected"));
+        return false;
+    }
+
+    ast->condition = cond;
+    ast->statement = stmt;
+
+    if (token_stream.lookAhead() == Token_else) {
+        token_stream.nextToken();
+
+        if (!parseStatement(ast->else_statement)) {
+            reportError(("statement expected"));
+            return false;
+        }
+    }
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseSwitchStatement(StatementAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+    ADVANCE(Token_switch, "switch");
+
+    ADVANCE('(' , "(");
+
+    ConditionAST *cond = 0;
+    if (!parseCondition(cond)) {
+        reportError(("condition expected"));
+        return false;
+    }
+    ADVANCE(')', ")");
+
+    StatementAST *stmt = 0;
+    if (!parseCompoundStatement(stmt)) {
+        syntaxError();
+        return false;
+    }
+
+    SwitchStatementAST *ast = CreateNode<SwitchStatementAST>(_M_pool);
+    ast->condition = cond;
+    ast->statement = stmt;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseLabeledStatement(StatementAST *&node)
+{
+    switch (token_stream.lookAhead()) {
+    case Token_identifier:
+    case Token_default:
+        if (token_stream.lookAhead(1) == ':') {
+            token_stream.nextToken();
+            token_stream.nextToken();
+
+            StatementAST *stmt = 0;
+            if (parseStatement(stmt)) {
+                node = stmt;
+                return true;
+            }
+        }
+        break;
+
+    case Token_case: {
+        token_stream.nextToken();
+        ExpressionAST *expr = 0;
+        if (!parseConstantExpression(expr)) {
+            reportError(("expression expected"));
+        } else if (token_stream.lookAhead() == Token_ellipsis) {
+            token_stream.nextToken();
+
+            ExpressionAST *expr2 = 0;
+            if (!parseConstantExpression(expr2))
+                reportError(("expression expected"));
+        }
+        ADVANCE(':', ":");
+
+        StatementAST *stmt = 0;
+        if (parseStatement(stmt)) {
+            node = stmt;
+            return true;
+        }
+    }
+    break;
+
+    }
+
+    return false;
+}
+
+bool Parser::parseBlockDeclaration(DeclarationAST *&node)
+{
+    switch (token_stream.lookAhead()) {
+    case Token_typedef:
+        return parseTypedef(node);
+    case Token_using:
+        return parseUsing(node);
+    case Token_asm:
+        return parseAsmDefinition(node);
+    case Token_namespace:
+        return parseNamespaceAliasDefinition(node);
+    }
+
+    std::size_t start = token_stream.cursor();
+
+    const ListNode<std::size_t> *cv = 0;
+    parseCvQualify(cv);
+
+    const ListNode<std::size_t> *storageSpec = 0;
+    parseStorageClassSpecifier(storageSpec);
+
+    parseCvQualify(cv);
+
+    TypeSpecifierAST *spec = 0;
+    if (!parseTypeSpecifierOrClassSpec(spec)) { // replace with simpleTypeSpecifier?!?!
+        token_stream.rewind((int) start);
+        return false;
+    }
+
+    parseCvQualify(cv);
+    spec->cv = cv;
+
+    const ListNode<InitDeclaratorAST*> *declarators = 0;
+    parseInitDeclaratorList(declarators);
+
+    if (token_stream.lookAhead() != ';') {
+        token_stream.rewind((int) start);
+        return false;
+    }
+    token_stream.nextToken();
+
+    SimpleDeclarationAST *ast = CreateNode<SimpleDeclarationAST>(_M_pool);
+    ast->type_specifier = spec;
+    ast->init_declarators = declarators;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseNamespaceAliasDefinition(DeclarationAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    CHECK(Token_namespace);
+
+    NamespaceAliasDefinitionAST *ast
+    = CreateNode<NamespaceAliasDefinitionAST>(_M_pool);
+
+    ADVANCE(Token_identifier,  "identifier");
+    ast->namespace_name = token_stream.cursor() - 1;
+
+    ADVANCE('=', "=");
+
+    if (!parseName(ast->alias_name))
+        reportError(("Namespace name expected"));
+
+    ADVANCE(';', ";");
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseDeclarationStatement(StatementAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    DeclarationAST *decl = 0;
+    if (!parseBlockDeclaration(decl))
+        return false;
+
+    DeclarationStatementAST *ast = CreateNode<DeclarationStatementAST>(_M_pool);
+    ast->declaration = decl;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseDeclarationInternal(DeclarationAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    // that is for the case '__declspec(dllexport) int ...' or
+    // '__declspec(dllexport) inline int ...', etc.
+    WinDeclSpecAST *winDeclSpec = 0;
+    parseWinDeclSpec(winDeclSpec);
+
+    const ListNode<std::size_t> *funSpec = 0;
+    bool hasFunSpec = parseFunctionSpecifier(funSpec);
+
+    const ListNode<std::size_t> *cv = 0;
+    parseCvQualify(cv);
+
+    const ListNode<std::size_t> *storageSpec = 0;
+    bool hasStorageSpec = parseStorageClassSpecifier(storageSpec);
+
+    if (hasStorageSpec && !hasFunSpec)
+        hasFunSpec = parseFunctionSpecifier(funSpec);
+
+    // that is for the case 'friend __declspec(dllexport) ....'
+    parseWinDeclSpec(winDeclSpec);
+
+    if (!cv)
+        parseCvQualify(cv);
+
+    int index = (int) token_stream.cursor();
+    NameAST *name = 0;
+    if (parseName(name, true) && token_stream.lookAhead() == '(') {
+        // no type specifier, maybe a constructor or a cast operator??
+
+        token_stream.rewind((int) index);
+
+        InitDeclaratorAST *declarator = 0;
+        if (parseInitDeclarator(declarator)) {
+            switch (token_stream.lookAhead()) {
+            case ';': {
+                token_stream.nextToken();
+
+                SimpleDeclarationAST *ast
+                = CreateNode<SimpleDeclarationAST>(_M_pool);
+
+                ast->storage_specifiers = storageSpec;
+                ast->function_specifiers = funSpec;
+                ast->init_declarators = snoc(ast->init_declarators,
+                                             declarator, _M_pool);
+
+                UPDATE_POS(ast, start, token_stream.cursor());
+                node = ast;
+            }
+            return true;
+
+            case ':': {
+                CtorInitializerAST *ctorInit = 0;
+                StatementAST *funBody = 0;
+
+                if (parseCtorInitializer(ctorInit)
+                    && parseFunctionBody(funBody)) {
+                    FunctionDefinitionAST *ast
+                    = CreateNode<FunctionDefinitionAST>(_M_pool);
+
+                    ast->storage_specifiers = storageSpec;
+                    ast->function_specifiers = funSpec;
+                    ast->init_declarator = declarator;
+                    ast->function_body = funBody;
+
+                    UPDATE_POS(ast, start, token_stream.cursor());
+                    node = ast;
+
+                    return true;
+                }
+            }
+            break;
+
+            case '{': {
+                StatementAST *funBody = 0;
+                if (parseFunctionBody(funBody)) {
+                    FunctionDefinitionAST *ast
+                    = CreateNode<FunctionDefinitionAST>(_M_pool);
+
+                    ast->storage_specifiers = storageSpec;
+                    ast->function_specifiers = funSpec;
+                    ast->init_declarator = declarator;
+                    ast->function_body = funBody;
+
+                    UPDATE_POS(ast, start, token_stream.cursor());
+                    node = ast;
+
+                    return true;
+                }
+            }
+            break;
+
+            case '(':
+            case '[':
+                // ops!! it seems a declarator
+                goto start_decl;
+                break;
+            }
+
+        }
+    }
+
+start_decl:
+    token_stream.rewind((int) index);
+
+    if (token_stream.lookAhead() == Token_const
+        && token_stream.lookAhead(1) == Token_identifier
+        && token_stream.lookAhead(2) == '=') {
+        // constant definition
+        token_stream.nextToken(); // skip const
+
+        const ListNode<InitDeclaratorAST*> *declarators = 0;
+        if (!parseInitDeclaratorList(declarators)) {
+            syntaxError();
+            return false;
+        }
+
+        ADVANCE(';', ";");
+
+#if defined(__GNUC__)
+#warning "mark the ast as constant"
+#endif
+        SimpleDeclarationAST *ast = CreateNode<SimpleDeclarationAST>(_M_pool);
+        ast->init_declarators = declarators;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+
+        return true;
+    }
+
+    TypeSpecifierAST *spec = 0;
+    if (parseTypeSpecifier(spec)) {
+        Q_ASSERT(spec);
+
+        if (!hasFunSpec)
+            parseFunctionSpecifier(funSpec);         // e.g. "void inline"
+
+        spec->cv = cv;
+
+        const ListNode<InitDeclaratorAST*> *declarators = 0;
+        InitDeclaratorAST *decl = 0;
+        int startDeclarator = (int) token_stream.cursor();
+        bool maybeFunctionDefinition = false;
+
+        if (token_stream.lookAhead() != ';') {
+            if (parseInitDeclarator(decl) && token_stream.lookAhead() == '{') {
+                // function definition
+                maybeFunctionDefinition = true;
+            } else {
+                token_stream.rewind((int) startDeclarator);
+                if (!parseInitDeclaratorList(declarators)) {
+                    syntaxError();
+                    return false;
+                }
+            }
+        }
+
+        switch (token_stream.lookAhead()) {
+        case ';': {
+            token_stream.nextToken();
+            SimpleDeclarationAST *ast
+            = CreateNode<SimpleDeclarationAST>(_M_pool);
+
+            ast->storage_specifiers = storageSpec;
+            ast->function_specifiers = funSpec;
+            ast->type_specifier = spec;
+            ast->win_decl_specifiers = winDeclSpec;
+            ast->init_declarators = declarators;
+
+            UPDATE_POS(ast, start, token_stream.cursor());
+            node = ast;
+        }
+        return true;
+
+        case '{': {
+            if (!maybeFunctionDefinition) {
+                syntaxError();
+                return false;
+            }
+
+            StatementAST *funBody = 0;
+            if (parseFunctionBody(funBody)) {
+                FunctionDefinitionAST *ast
+                = CreateNode<FunctionDefinitionAST>(_M_pool);
+
+                ast->win_decl_specifiers = winDeclSpec;
+                ast->storage_specifiers = storageSpec;
+                ast->function_specifiers = funSpec;
+                ast->type_specifier = spec;
+                ast->init_declarator = decl;
+                ast->function_body = funBody;
+
+                UPDATE_POS(ast, start, token_stream.cursor());
+                node = ast;
+
+                return true;
+            }
+        }
+        break;
+        } // end switch
+    }
+
+    syntaxError();
+    return false;
+}
+
+bool Parser::skipFunctionBody(StatementAST *&)
+{
+#if defined(__GNUC__)
+#warning "Parser::skipFunctionBody() -- implement me"
+#endif
+    Q_ASSERT(0); // ### not implemented
+    return 0;
+}
+
+bool Parser::parseFunctionBody(StatementAST *&node)
+{
+    if (control->skipFunctionBody())
+        return skipFunctionBody(node);
+
+    return parseCompoundStatement(node);
+}
+
+bool Parser::parseTypeSpecifierOrClassSpec(TypeSpecifierAST *&node)
+{
+    if (parseClassSpecifier(node))
+        return true;
+    else if (parseEnumSpecifier(node))
+        return true;
+    else if (parseTypeSpecifier(node))
+        return true;
+
+    return false;
+}
+
+bool Parser::parseTryBlockStatement(StatementAST *&node)
+{
+#if defined(__GNUC__)
+#warning "implement me"
+#endif
+    CHECK(Token_try);
+
+    StatementAST *stmt = 0;
+    if (!parseCompoundStatement(stmt)) {
+        syntaxError();
+        return false;
+    }
+
+    if (token_stream.lookAhead() != Token_catch) {
+        reportError(("catch expected"));
+        return false;
+    }
+
+    while (token_stream.lookAhead() == Token_catch) {
+        token_stream.nextToken();
+        ADVANCE('(', "(");
+        ConditionAST *cond = 0;
+        if (token_stream.lookAhead() == Token_ellipsis) {
+            token_stream.nextToken();
+        } else if (!parseCondition(cond, false)) {
+            reportError(("condition expected"));
+            return false;
+        }
+        ADVANCE(')', ")");
+
+        StatementAST *body = 0;
+        if (!parseCompoundStatement(body)) {
+            syntaxError();
+            return false;
+        }
+    }
+
+    node = stmt;
+    return true;
+}
+
+bool Parser::parsePrimaryExpression(ExpressionAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    PrimaryExpressionAST *ast = CreateNode<PrimaryExpressionAST>(_M_pool);
+
+    switch (token_stream.lookAhead()) {
+    case Token_string_literal:
+        parseStringLiteral(ast->literal);
+        break;
+
+    case Token_number_literal:
+    case Token_char_literal:
+    case Token_true:
+    case Token_false:
+    case Token_this:
+        ast->token = token_stream.cursor();
+        token_stream.nextToken();
+        break;
+
+    case '(':
+        token_stream.nextToken();
+
+        if (token_stream.lookAhead() == '{') {
+            if (!parseCompoundStatement(ast->expression_statement))
+                return false;
+        } else {
+            if (!parseExpression(ast->sub_expression))
+                return false;
+        }
+
+        CHECK(')');
+        break;
+
+    default:
+        if (!parseName(ast->name))
+            return false;
+
+        break;
+    }
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+
+/*
+  postfix-expression-internal:
+  [ expression ]
+  ( expression-list [opt] )
+  (.|->) template [opt] id-expression
+  (.|->) pseudo-destructor-name
+  ++
+  --
+*/
+bool Parser::parsePostfixExpressionInternal(ExpressionAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    switch (token_stream.lookAhead()) {
+    case '[': {
+        token_stream.nextToken();
+        ExpressionAST *expr = 0;
+        parseExpression(expr);
+        CHECK(']');
+
+        SubscriptExpressionAST *ast
+        = CreateNode<SubscriptExpressionAST>(_M_pool);
+
+        ast->subscript = expr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+    return true;
+
+    case '(': {
+        token_stream.nextToken();
+        ExpressionAST *expr = 0;
+        parseExpression(expr);
+        CHECK(')');
+
+        FunctionCallAST *ast = CreateNode<FunctionCallAST>(_M_pool);
+        ast->arguments = expr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+    return true;
+
+    case '.':
+    case Token_arrow: {
+        std::size_t op = token_stream.cursor();
+        token_stream.nextToken();
+
+        std::size_t templ = 0;
+        if (token_stream.lookAhead() == Token_template) {
+            templ = token_stream.cursor();
+            token_stream.nextToken();
+        }
+
+        int saved = int(token_stream.cursor());
+        NameAST *name = 0;
+
+        if (parseName(name, true) && name->unqualified_name
+            && name->unqualified_name->template_arguments
+            && token_stream.lookAhead() == '(') {
+            // a template method call
+            // ### reverse the logic
+        } else {
+            token_stream.rewind(saved);
+            name = 0;
+
+            if (!parseName(name, templ != 0))
+                return false;
+        }
+
+        ClassMemberAccessAST *ast = CreateNode<ClassMemberAccessAST>(_M_pool);
+        ast->op = op;
+        ast->name = name;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+    return true;
+
+    case Token_incr:
+    case Token_decr: {
+        std::size_t op = token_stream.cursor();
+        token_stream.nextToken();
+
+        IncrDecrExpressionAST *ast = CreateNode<IncrDecrExpressionAST>(_M_pool);
+        ast->op = op;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+    return true;
+
+    default:
+        return false;
+    }
+}
+
+/*
+  postfix-expression:
+  simple-type-specifier ( expression-list [opt] )
+  primary-expression postfix-expression-internal*
+*/
+bool Parser::parsePostfixExpression(ExpressionAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    switch (token_stream.lookAhead()) {
+    case Token_dynamic_cast:
+    case Token_static_cast:
+    case Token_reinterpret_cast:
+    case Token_const_cast: {
+        std::size_t castOp = token_stream.cursor();
+        token_stream.nextToken();
+
+        CHECK('<');
+        TypeIdAST *typeId = 0;
+        parseTypeId(typeId);
+        CHECK('>');
+
+        CHECK('(');
+        ExpressionAST *expr = 0;
+        parseCommaExpression(expr);
+        CHECK(')');
+
+        CppCastExpressionAST *ast = CreateNode<CppCastExpressionAST>(_M_pool);
+        ast->op = castOp;
+        ast->type_id = typeId;
+        ast->expression = expr;
+
+        ExpressionAST *e = 0;
+        while (parsePostfixExpressionInternal(e))
+            ast->sub_expressions = snoc(ast->sub_expressions, e, _M_pool);
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+    return true;
+
+    case Token_typename: {
+        std::size_t token = token_stream.cursor();
+        token_stream.nextToken();
+
+        NameAST* name = 0;
+        if (!parseName(name, true))
+            return false;
+
+        CHECK('(');
+        ExpressionAST *expr = 0;
+        parseCommaExpression(expr);
+        CHECK(')');
+
+        TypeIdentificationAST *ast = CreateNode<TypeIdentificationAST>(_M_pool);
+        ast->typename_token = token;
+        ast->name = name;
+        ast->expression = expr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+    return true;
+
+    case Token_typeid: {
+        token_stream.nextToken();
+
+        CHECK('(');
+        TypeIdAST *typeId = 0;
+        parseTypeId(typeId);
+        CHECK(')');
+
+        TypeIdentificationAST *ast = CreateNode<TypeIdentificationAST>(_M_pool);
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+    return true;
+
+    default:
+        break;
+    }
+
+    std::size_t saved_pos = token_stream.cursor();
+
+    TypeSpecifierAST *typeSpec = 0;
+    ExpressionAST *expr = 0;
+
+    // let's try to parse a type
+    NameAST *name = 0;
+    if (parseName(name, true)) {
+        Q_ASSERT(name->unqualified_name);
+
+        bool has_template_args = name->unqualified_name->template_arguments != 0;
+
+        if (has_template_args && token_stream.lookAhead() == '(') {
+            ExpressionAST *cast_expr = 0;
+            if (parseCastExpression(cast_expr)
+                && cast_expr->kind == AST::Kind_CastExpression) {
+                token_stream.rewind((int) saved_pos);
+                parsePrimaryExpression(expr);
+                goto L_no_rewind;
+            }
+        }
+    }
+
+    token_stream.rewind((int) saved_pos);
+
+L_no_rewind:
+    if (!expr && parseSimpleTypeSpecifier(typeSpec)
+        && token_stream.lookAhead() == '(') {
+        token_stream.nextToken(); // skip '('
+        parseCommaExpression(expr);
+        CHECK(')');
+    } else if (expr) {
+        typeSpec = 0;
+    } else {
+        typeSpec = 0;
+        token_stream.rewind((int) start);
+
+        if (!parsePrimaryExpression(expr))
+            return false;
+    }
+
+    const ListNode<ExpressionAST*> *sub_expressions = 0;
+    ExpressionAST *sub_expression = 0;
+
+    while (parsePostfixExpressionInternal(sub_expression))
+        sub_expressions = snoc(sub_expressions, sub_expression, _M_pool);
+
+    if (sub_expressions || !expr || (typeSpec && expr)) {
+        PostfixExpressionAST *ast = CreateNode<PostfixExpressionAST>(_M_pool);
+        ast->type_specifier = typeSpec;
+        ast->expression = expr;
+        ast->sub_expressions = sub_expressions;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    } else
+        node = expr;
+
+    return true;
+}
+
+bool Parser::parseUnaryExpression(ExpressionAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    switch (token_stream.lookAhead()) {
+    case Token_incr:
+    case Token_decr:
+    case '*':
+    case '&':
+    case '+':
+    case '-':
+    case '!':
+    case '~': {
+        std::size_t op = token_stream.cursor();
+        token_stream.nextToken();
+
+        ExpressionAST *expr = 0;
+        if (!parseCastExpression(expr))
+            return false;
+
+        UnaryExpressionAST *ast = CreateNode<UnaryExpressionAST>(_M_pool);
+        ast->op = op;
+        ast->expression = expr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+    return true;
+
+    case Token_sizeof: {
+        std::size_t sizeof_token = token_stream.cursor();
+        token_stream.nextToken();
+
+        SizeofExpressionAST *ast = CreateNode<SizeofExpressionAST>(_M_pool);
+        ast->sizeof_token = sizeof_token;
+
+        std::size_t index = token_stream.cursor();
+        if (token_stream.lookAhead() == '(') {
+            token_stream.nextToken();
+            if (parseTypeId(ast->type_id) && token_stream.lookAhead() == ')') {
+                token_stream.nextToken(); // skip )
+
+                UPDATE_POS(ast, start, token_stream.cursor());
+                node = ast;
+                return true;
+            }
+
+            ast->type_id = 0;
+            token_stream.rewind((int) index);
+        }
+
+        if (!parseUnaryExpression(ast->expression))
+            return false;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+        return true;
+    }
+
+    default:
+        break;
+    }
+
+    int token = token_stream.lookAhead();
+
+    if (token == Token_new
+        || (token == Token_scope && token_stream.lookAhead(1) == Token_new))
+        return parseNewExpression(node);
+
+    if (token == Token_delete
+        || (token == Token_scope && token_stream.lookAhead(1) == Token_delete))
+        return parseDeleteExpression(node);
+
+    return parsePostfixExpression(node);
+}
+
+bool Parser::parseNewExpression(ExpressionAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    NewExpressionAST *ast = CreateNode<NewExpressionAST>(_M_pool);
+
+    if (token_stream.lookAhead() == Token_scope
+        && token_stream.lookAhead(1) == Token_new) {
+        ast->scope_token = token_stream.cursor();
+        token_stream.nextToken();
+    }
+
+    CHECK(Token_new);
+    ast->new_token = token_stream.cursor() - 1;
+
+    if (token_stream.lookAhead() == '(') {
+        token_stream.nextToken();
+        parseCommaExpression(ast->expression);
+        CHECK(')');
+    }
+
+    if (token_stream.lookAhead() == '(') {
+        token_stream.nextToken();
+        parseTypeId(ast->type_id);
+        CHECK(')');
+    } else {
+        parseNewTypeId(ast->new_type_id);
+    }
+
+    parseNewInitializer(ast->new_initializer);
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseNewTypeId(NewTypeIdAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    TypeSpecifierAST *typeSpec = 0;
+    if (!parseTypeSpecifier(typeSpec))
+        return false;
+
+    NewTypeIdAST *ast = CreateNode<NewTypeIdAST>(_M_pool);
+    ast->type_specifier = typeSpec;
+
+    parseNewDeclarator(ast->new_declarator);
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseNewDeclarator(NewDeclaratorAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    NewDeclaratorAST *ast = CreateNode<NewDeclaratorAST>(_M_pool);
+
+    PtrOperatorAST *ptrOp = 0;
+    if (parsePtrOperator(ptrOp)) {
+        ast->ptr_op = ptrOp;
+        parseNewDeclarator(ast->sub_declarator);
+    }
+
+    while (token_stream.lookAhead() == '[') {
+        token_stream.nextToken();
+        ExpressionAST *expr = 0;
+        parseExpression(expr);
+        ast->expressions = snoc(ast->expressions, expr, _M_pool);
+        ADVANCE(']', "]");
+    }
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseNewInitializer(NewInitializerAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    CHECK('(');
+
+    NewInitializerAST *ast = CreateNode<NewInitializerAST>(_M_pool);
+
+    parseCommaExpression(ast->expression);
+
+    CHECK(')');
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseDeleteExpression(ExpressionAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    DeleteExpressionAST *ast = CreateNode<DeleteExpressionAST>(_M_pool);
+
+    if (token_stream.lookAhead() == Token_scope
+        && token_stream.lookAhead(1) == Token_delete) {
+        ast->scope_token = token_stream.cursor();
+        token_stream.nextToken();
+    }
+
+    CHECK(Token_delete);
+    ast->delete_token = token_stream.cursor() - 1;
+
+    if (token_stream.lookAhead() == '[') {
+        ast->lbracket_token = token_stream.cursor();
+        token_stream.nextToken();
+        CHECK(']');
+        ast->rbracket_token = token_stream.cursor() - 1;
+    }
+
+    if (!parseCastExpression(ast->expression))
+        return false;
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseCastExpression(ExpressionAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (token_stream.lookAhead() == '(') {
+        token_stream.nextToken();
+
+        CastExpressionAST *ast = CreateNode<CastExpressionAST>(_M_pool);
+
+        if (parseTypeId(ast->type_id)) {
+            if (token_stream.lookAhead() == ')') {
+                token_stream.nextToken();
+
+                if (parseCastExpression(ast->expression)) {
+                    UPDATE_POS(ast, start, token_stream.cursor());
+                    node = ast;
+
+                    return true;
+                }
+            }
+        }
+    }
+
+    token_stream.rewind((int) start);
+    return parseUnaryExpression(node);
+}
+
+bool Parser::parsePmExpression(ExpressionAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (!parseCastExpression(node) || !node) // ### fixme
+        return false;
+
+    while (token_stream.lookAhead() == Token_ptrmem) {
+        std::size_t op = token_stream.cursor();
+        token_stream.nextToken();
+
+        ExpressionAST *rightExpr = 0;
+        if (!parseCastExpression(rightExpr))
+            return false;
+
+        BinaryExpressionAST *ast = CreateNode<BinaryExpressionAST>(_M_pool);
+        ast->op = op;
+        ast->left_expression = node;
+        ast->right_expression = rightExpr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+
+    return true;
+}
+
+bool Parser::parseMultiplicativeExpression(ExpressionAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (!parsePmExpression(node))
+        return false;
+
+    while (token_stream.lookAhead() == '*'
+           || token_stream.lookAhead() == '/'
+           || token_stream.lookAhead() == '%') {
+        std::size_t op = token_stream.cursor();
+        token_stream.nextToken();
+
+        ExpressionAST *rightExpr = 0;
+        if (!parsePmExpression(rightExpr))
+            return false;
+
+        BinaryExpressionAST *ast = CreateNode<BinaryExpressionAST>(_M_pool);
+        ast->op = op;
+        ast->left_expression = node;
+        ast->right_expression = rightExpr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+
+    return true;
+}
+
+
+bool Parser::parseAdditiveExpression(ExpressionAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (!parseMultiplicativeExpression(node))
+        return false;
+
+    while (token_stream.lookAhead() == '+' || token_stream.lookAhead() == '-') {
+        std::size_t op = token_stream.cursor();
+        token_stream.nextToken();
+
+        ExpressionAST *rightExpr = 0;
+        if (!parseMultiplicativeExpression(rightExpr))
+            return false;
+
+        BinaryExpressionAST *ast = CreateNode<BinaryExpressionAST>(_M_pool);
+        ast->op = op;
+        ast->left_expression = node;
+        ast->right_expression = rightExpr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+
+    return true;
+}
+
+bool Parser::parseShiftExpression(ExpressionAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (!parseAdditiveExpression(node))
+        return false;
+
+    while (token_stream.lookAhead() == Token_shift) {
+        std::size_t op = token_stream.cursor();
+        token_stream.nextToken();
+
+        ExpressionAST *rightExpr = 0;
+        if (!parseAdditiveExpression(rightExpr))
+            return false;
+
+        BinaryExpressionAST *ast = CreateNode<BinaryExpressionAST>(_M_pool);
+        ast->op = op;
+        ast->left_expression = node;
+        ast->right_expression = rightExpr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+
+    return true;
+}
+
+bool Parser::parseRelationalExpression(ExpressionAST *&node, bool templArgs)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (!parseShiftExpression(node))
+        return false;
+
+    while (token_stream.lookAhead() == '<'
+           || (token_stream.lookAhead() == '>' && !templArgs)
+           || token_stream.lookAhead() == Token_leq
+           || token_stream.lookAhead() == Token_geq) {
+        std::size_t op = token_stream.cursor();
+        token_stream.nextToken();
+
+        ExpressionAST *rightExpr = 0;
+        if (!parseShiftExpression(rightExpr))
+            return false;
+
+        BinaryExpressionAST *ast = CreateNode<BinaryExpressionAST>(_M_pool);
+        ast->op = op;
+        ast->left_expression = node;
+        ast->right_expression = rightExpr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+
+    return true;
+}
+
+bool Parser::parseEqualityExpression(ExpressionAST *&node, bool templArgs)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (!parseRelationalExpression(node, templArgs))
+        return false;
+
+    while (token_stream.lookAhead() == Token_eq
+           || token_stream.lookAhead() == Token_not_eq) {
+        std::size_t op = token_stream.cursor();
+        token_stream.nextToken();
+
+        ExpressionAST *rightExpr = 0;
+        if (!parseRelationalExpression(rightExpr, templArgs))
+            return false;
+
+        BinaryExpressionAST *ast = CreateNode<BinaryExpressionAST>(_M_pool);
+        ast->op = op;
+        ast->left_expression = node;
+        ast->right_expression = rightExpr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+
+    return true;
+}
+
+bool Parser::parseAndExpression(ExpressionAST *&node, bool templArgs)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (!parseEqualityExpression(node, templArgs))
+        return false;
+
+    while (token_stream.lookAhead() == '&') {
+        std::size_t op = token_stream.cursor();
+        token_stream.nextToken();
+
+        ExpressionAST *rightExpr = 0;
+        if (!parseEqualityExpression(rightExpr, templArgs))
+            return false;
+
+        BinaryExpressionAST *ast = CreateNode<BinaryExpressionAST>(_M_pool);
+        ast->op = op;
+        ast->left_expression = node;
+        ast->right_expression = rightExpr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+
+    return true;
+}
+
+bool Parser::parseExclusiveOrExpression(ExpressionAST *&node, bool templArgs)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (!parseAndExpression(node, templArgs))
+        return false;
+
+    while (token_stream.lookAhead() == '^') {
+        std::size_t op = token_stream.cursor();
+        token_stream.nextToken();
+
+        ExpressionAST *rightExpr = 0;
+        if (!parseAndExpression(rightExpr, templArgs))
+            return false;
+
+        BinaryExpressionAST *ast = CreateNode<BinaryExpressionAST>(_M_pool);
+        ast->op = op;
+        ast->left_expression = node;
+        ast->right_expression = rightExpr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+
+    return true;
+}
+
+bool Parser::parseInclusiveOrExpression(ExpressionAST *&node, bool templArgs)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (!parseExclusiveOrExpression(node, templArgs))
+        return false;
+
+    while (token_stream.lookAhead() == '|') {
+        std::size_t op = token_stream.cursor();
+        token_stream.nextToken();
+
+        ExpressionAST *rightExpr = 0;
+        if (!parseExclusiveOrExpression(rightExpr, templArgs))
+            return false;
+
+        BinaryExpressionAST *ast = CreateNode<BinaryExpressionAST>(_M_pool);
+        ast->op = op;
+        ast->left_expression = node;
+        ast->right_expression = rightExpr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+
+    return true;
+}
+
+bool Parser::parseLogicalAndExpression(ExpressionAST *&node, bool templArgs)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (!parseInclusiveOrExpression(node, templArgs))
+        return false;
+
+    while (token_stream.lookAhead() == Token_and) {
+        std::size_t op = token_stream.cursor();
+        token_stream.nextToken();
+
+        ExpressionAST *rightExpr = 0;
+        if (!parseInclusiveOrExpression(rightExpr, templArgs))
+            return false;
+
+        BinaryExpressionAST *ast = CreateNode<BinaryExpressionAST>(_M_pool);
+        ast->op = op;
+        ast->left_expression = node;
+        ast->right_expression = rightExpr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+
+    return true;
+}
+
+bool Parser::parseLogicalOrExpression(ExpressionAST *&node, bool templArgs)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (!parseLogicalAndExpression(node, templArgs))
+        return false;
+
+    while (token_stream.lookAhead() == Token_or) {
+        std::size_t op = token_stream.cursor();
+        token_stream.nextToken();
+
+        ExpressionAST *rightExpr = 0;
+        if (!parseLogicalAndExpression(rightExpr, templArgs))
+            return false;
+
+        BinaryExpressionAST *ast = CreateNode<BinaryExpressionAST>(_M_pool);
+        ast->op = op;
+        ast->left_expression = node;
+        ast->right_expression = rightExpr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+
+    return true;
+}
+
+bool Parser::parseConditionalExpression(ExpressionAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (!parseLogicalOrExpression(node))
+        return false;
+
+    if (token_stream.lookAhead() == '?') {
+        token_stream.nextToken();
+
+        ExpressionAST *leftExpr = 0;
+        if (!parseExpression(leftExpr))
+            return false;
+
+        CHECK(':');
+
+        ExpressionAST *rightExpr = 0;
+        if (!parseAssignmentExpression(rightExpr))
+            return false;
+
+        ConditionalExpressionAST *ast
+        = CreateNode<ConditionalExpressionAST>(_M_pool);
+
+        ast->condition = node;
+        ast->left_expression = leftExpr;
+        ast->right_expression = rightExpr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+
+    return true;
+}
+
+bool Parser::parseAssignmentExpression(ExpressionAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (token_stream.lookAhead() == Token_throw && !parseThrowExpression(node))
+        return false;
+    else if (!parseConditionalExpression(node))
+        return false;
+
+    while (token_stream.lookAhead() == Token_assign
+           || token_stream.lookAhead() == '=') {
+        std::size_t op = token_stream.cursor();
+        token_stream.nextToken();
+
+        ExpressionAST *rightExpr = 0;
+        if (!parseConditionalExpression(rightExpr))
+            return false;
+
+        BinaryExpressionAST *ast = CreateNode<BinaryExpressionAST>(_M_pool);
+        ast->op = op;
+        ast->left_expression = node;
+        ast->right_expression = rightExpr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+
+    return true;
+}
+
+bool Parser::parseConstantExpression(ExpressionAST *&node)
+{
+    return parseConditionalExpression(node);
+}
+
+bool Parser::parseExpression(ExpressionAST *&node)
+{
+    return parseCommaExpression(node);
+}
+
+bool Parser::parseCommaExpression(ExpressionAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    if (!parseAssignmentExpression(node))
+        return false;
+
+    while (token_stream.lookAhead() == ',') {
+        std::size_t op = token_stream.cursor();
+        token_stream.nextToken();
+
+        ExpressionAST *rightExpr = 0;
+        if (!parseAssignmentExpression(rightExpr))
+            return false;
+
+        BinaryExpressionAST *ast = CreateNode<BinaryExpressionAST>(_M_pool);
+        ast->op = op;
+        ast->left_expression = node;
+        ast->right_expression = rightExpr;
+
+        UPDATE_POS(ast, start, token_stream.cursor());
+        node = ast;
+    }
+
+    return true;
+}
+
+bool Parser::parseThrowExpression(ExpressionAST *&node)
+{
+    std::size_t start = token_stream.cursor();
+
+    CHECK(Token_throw);
+
+    ThrowExpressionAST *ast = CreateNode<ThrowExpressionAST>(_M_pool);
+    ast->throw_token = token_stream.cursor() - 1;
+
+    parseAssignmentExpression(ast->expression);
+
+    UPDATE_POS(ast, start, token_stream.cursor());
+    node = ast;
+
+    return true;
+}
+
+bool Parser::parseQ_ENUMS(DeclarationAST *&node)
+{
+    if (token_stream.lookAhead() != Token_Q_ENUMS)
+        return false;
+
+    if (token_stream.lookAhead(1) != '(')
+        return false;
+
+    token_stream.nextToken();
+    token_stream.nextToken();
+
+    int firstToken = token_stream.cursor();
+    while (token_stream.lookAhead() != ')')
+        token_stream.nextToken();
+
+    QEnumsAST *ast = CreateNode<QEnumsAST>(_M_pool);
+    UPDATE_POS(ast, firstToken, token_stream.cursor());
+    node = ast;
+
+    token_stream.nextToken();
+
+    return true;
+}
+
+bool Parser::parseQ_PROPERTY(DeclarationAST *&node)
+{
+    if (token_stream.lookAhead() != Token_Q_PROPERTY)
+        return false;
+
+    if (token_stream.lookAhead(1) != '(')
+        return false;
+
+    token_stream.nextToken();
+    token_stream.nextToken();
+
+    int firstToken = token_stream.cursor();
+    while (token_stream.lookAhead() != ')')
+        token_stream.nextToken();
+
+    QPropertyAST *ast = CreateNode<QPropertyAST>(_M_pool);
+    UPDATE_POS(ast, firstToken, token_stream.cursor());
+    node = ast;
+
+//   const Token &t1 = token_stream[firstToken];
+//   const Token &t2 = token_stream[token_stream.cursor()];
+//   printf("property: %s\n",
+//          qPrintable(QString::fromLatin1(t1.text + t1.position, t2.position - t1.position)));
+
+    token_stream.nextToken();
+
+    return true;
+}
+
+bool Parser::block_errors(bool block)
+{
+    bool current = _M_block_errors;
+    _M_block_errors = block;
+    return current;
+}
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
+
diff --git a/ApiExtractor/parser/parser.h b/ApiExtractor/parser/parser.h
new file mode 100644
index 000000000..4b0c76c85
--- /dev/null
+++ b/ApiExtractor/parser/parser.h
@@ -0,0 +1,198 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef PARSER_H
+#define PARSER_H
+
+#include "ast.h"
+#include "lexer.h"
+
+#include <QtCore/QString>
+
+class FileSymbol;
+class Control;
+
+class Parser
+{
+public:
+    Parser(Control *control);
+    ~Parser();
+
+    LocationManager &location() { return _M_location; }
+
+    TranslationUnitAST *parse(const char *contents, std::size_t size, pool *p);
+
+private:
+    void reportError(const QString& msg);
+    void syntaxError();
+    void tokenRequiredError(int expected);
+
+public:
+    bool skipFunctionBody(StatementAST *&node);
+
+public:
+    bool parse_Attribute__();
+    bool parseAbstractDeclarator(DeclaratorAST *&node);
+    bool parseAccessSpecifier(DeclarationAST *&node);
+    bool parseAdditiveExpression(ExpressionAST *&node);
+    bool parseAndExpression(ExpressionAST *&node, bool templArgs = false);
+    bool parseAsmDefinition(DeclarationAST *&node);
+    bool parseAssignmentExpression(ExpressionAST *&node);
+    bool parseBaseClause(BaseClauseAST *&node);
+    bool parseBaseSpecifier(BaseSpecifierAST *&node);
+    bool parseBlockDeclaration(DeclarationAST *&node);
+    bool parseCastExpression(ExpressionAST *&node);
+    bool parseClassSpecifier(TypeSpecifierAST *&node);
+    bool parseForwardDeclarationSpecifier(TypeSpecifierAST *&node);
+    bool parseCommaExpression(ExpressionAST *&node);
+    bool parseCompoundStatement(StatementAST *&node);
+    bool parseCondition(ConditionAST *&node, bool initRequired = true);
+    bool parseConditionalExpression(ExpressionAST *&node);
+    bool parseConstantExpression(ExpressionAST *&node);
+    bool parseCtorInitializer(CtorInitializerAST *&node);
+    bool parseCvQualify(const ListNode<std::size_t> *&node);
+    bool parseDeclaration(DeclarationAST *&node);
+    bool parseDeclarationInternal(DeclarationAST *&node);
+    bool parseDeclarationStatement(StatementAST *&node);
+    bool parseDeclarator(DeclaratorAST *&node);
+    bool parseDeleteExpression(ExpressionAST *&node);
+    bool parseDoStatement(StatementAST *&node);
+    bool parseElaboratedTypeSpecifier(TypeSpecifierAST *&node);
+    bool parseEnumSpecifier(TypeSpecifierAST *&node);
+    bool parseEnumerator(EnumeratorAST *&node);
+    bool parseEqualityExpression(ExpressionAST *&node,
+                                 bool templArgs = false);
+    bool parseExceptionSpecification(ExceptionSpecificationAST *&node);
+    bool parseExclusiveOrExpression(ExpressionAST *&node,
+                                    bool templArgs = false);
+    bool parseExpression(ExpressionAST *&node);
+    bool parseExpressionOrDeclarationStatement(StatementAST *&node);
+    bool parseExpressionStatement(StatementAST *&node);
+    bool parseForInitStatement(StatementAST *&node);
+    bool parseForStatement(StatementAST *&node);
+    bool parseFunctionBody(StatementAST *&node);
+    bool parseFunctionSpecifier(const ListNode<std::size_t> *&node);
+    bool parseIfStatement(StatementAST *&node);
+    bool parseInclusiveOrExpression(ExpressionAST *&node,
+                                    bool templArgs = false);
+    bool parseInitDeclarator(InitDeclaratorAST *&node);
+    bool parseInitDeclaratorList(const ListNode<InitDeclaratorAST*> *&node);
+    bool parseInitializer(InitializerAST *&node);
+    bool parseInitializerClause(InitializerClauseAST *&node);
+    bool parseLabeledStatement(StatementAST *&node);
+    bool parseLinkageBody(LinkageBodyAST *&node);
+    bool parseLinkageSpecification(DeclarationAST *&node);
+    bool parseLogicalAndExpression(ExpressionAST *&node,
+                                   bool templArgs = false);
+    bool parseLogicalOrExpression(ExpressionAST *&node,
+                                  bool templArgs = false);
+    bool parseMemInitializer(MemInitializerAST *&node);
+    bool parseMemInitializerList(const ListNode<MemInitializerAST*> *&node);
+    bool parseMemberSpecification(DeclarationAST *&node);
+    bool parseMultiplicativeExpression(ExpressionAST *&node);
+    bool parseName(NameAST *&node, bool acceptTemplateId = false);
+    bool parseNamespace(DeclarationAST *&node);
+    bool parseNamespaceAliasDefinition(DeclarationAST *&node);
+    bool parseNewDeclarator(NewDeclaratorAST *&node);
+    bool parseNewExpression(ExpressionAST *&node);
+    bool parseNewInitializer(NewInitializerAST *&node);
+    bool parseNewTypeId(NewTypeIdAST *&node);
+    bool parseOperator(OperatorAST *&node);
+    bool parseOperatorFunctionId(OperatorFunctionIdAST *&node);
+    bool parseParameterDeclaration(ParameterDeclarationAST *&node);
+    bool parseParameterDeclarationClause(ParameterDeclarationClauseAST *&node);
+    bool parseParameterDeclarationList(const ListNode<ParameterDeclarationAST*> *&node);
+    bool parsePmExpression(ExpressionAST *&node);
+    bool parsePostfixExpression(ExpressionAST *&node);
+    bool parsePostfixExpressionInternal(ExpressionAST *&node);
+    bool parsePrimaryExpression(ExpressionAST *&node);
+    bool parsePtrOperator(PtrOperatorAST *&node);
+    bool parsePtrToMember(PtrToMemberAST *&node);
+    bool parseRelationalExpression(ExpressionAST *&node,
+                                   bool templArgs = false);
+    bool parseShiftExpression(ExpressionAST *&node);
+    bool parseSimpleTypeSpecifier(TypeSpecifierAST *&node,
+                                  bool onlyIntegral = false);
+    bool parseStatement(StatementAST *&node);
+    bool parseStorageClassSpecifier(const ListNode<std::size_t> *&node);
+    bool parseStringLiteral(StringLiteralAST *&node);
+    bool parseSwitchStatement(StatementAST *&node);
+    bool parseTemplateArgument(TemplateArgumentAST *&node);
+    bool parseTemplateArgumentList(const ListNode<TemplateArgumentAST*> *&node,
+                                   bool reportError = true);
+    bool parseTemplateDeclaration(DeclarationAST *&node);
+    bool parseTemplateParameter(TemplateParameterAST *&node);
+    bool parseTemplateParameterList(const ListNode<TemplateParameterAST*> *&node);
+    bool parseThrowExpression(ExpressionAST *&node);
+    bool parseTranslationUnit(TranslationUnitAST *&node);
+    bool parseTryBlockStatement(StatementAST *&node);
+    bool parseTypeId(TypeIdAST *&node);
+    bool parseTypeIdList(const ListNode<TypeIdAST*> *&node);
+    bool parseTypeParameter(TypeParameterAST *&node);
+    bool parseTypeSpecifier(TypeSpecifierAST *&node);
+    bool parseTypeSpecifierOrClassSpec(TypeSpecifierAST *&node);
+    bool parseTypedef(DeclarationAST *&node);
+    bool parseUnaryExpression(ExpressionAST *&node);
+    bool parseUnqualifiedName(UnqualifiedNameAST *&node,
+                              bool parseTemplateId = true);
+    bool parseUsing(DeclarationAST *&node);
+    bool parseUsingDirective(DeclarationAST *&node);
+    bool parseWhileStatement(StatementAST *&node);
+    bool parseWinDeclSpec(WinDeclSpecAST *&node);
+
+    bool parseQ_PROPERTY(DeclarationAST *&node);
+    bool parseQ_ENUMS(DeclarationAST *&node);
+
+    bool skipUntil(int token);
+    bool skipUntilDeclaration();
+    bool skipUntilStatement();
+    bool skip(int l, int r);
+
+    void advance();
+
+    // private:
+    TokenStream token_stream;
+    LocationTable location_table;
+    LocationTable line_table;
+
+    bool block_errors(bool block);
+
+private:
+    QString tokenText(AST *) const;
+
+    LocationManager _M_location;
+    Control *control;
+    Lexer lexer;
+    pool *_M_pool;
+    bool _M_block_errors;
+
+private:
+    Parser(const Parser& source);
+    void operator = (const Parser& source);
+};
+
+#endif
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/r++.macros b/ApiExtractor/parser/r++.macros
new file mode 100644
index 000000000..455276c84
--- /dev/null
+++ b/ApiExtractor/parser/r++.macros
@@ -0,0 +1,28 @@
+
+#define __attribute__(a...)
+#define __typeof__         __typeof
+
+#define __extension
+#define __extension__
+
+#define __restrict
+#define __restrict__
+
+#define __volatile         volatile
+#define __volatile__       volatile
+
+#define __inline             inline
+#define __inline__           inline
+
+#define __const               const
+#define __const__             const
+
+#define __asm               asm
+#define __asm__             asm
+
+#define __GNUC__                 3
+//#define __GNUC_MINOR__           4
+
+#define __ROBC__                 0
+#define __ROBC_MINOR__           1
+
diff --git a/ApiExtractor/parser/rpp-allocator.h b/ApiExtractor/parser/rpp-allocator.h
new file mode 100644
index 000000000..313895f00
--- /dev/null
+++ b/ApiExtractor/parser/rpp-allocator.h
@@ -0,0 +1,24 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "parser/rxx_allocator.h"
diff --git a/ApiExtractor/parser/rpp/builtin-macros.cpp b/ApiExtractor/parser/rpp/builtin-macros.cpp
new file mode 100644
index 000000000..1b0fc06af
--- /dev/null
+++ b/ApiExtractor/parser/rpp/builtin-macros.cpp
@@ -0,0 +1,23 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
diff --git a/ApiExtractor/parser/rpp/pp-cctype.h b/ApiExtractor/parser/rpp/pp-cctype.h
new file mode 100644
index 000000000..5b0bf477c
--- /dev/null
+++ b/ApiExtractor/parser/rpp/pp-cctype.h
@@ -0,0 +1,57 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef PP_CCTYPE_H
+#define PP_CCTYPE_H
+
+#include <cctype>
+
+namespace rpp
+{
+
+inline bool pp_isalpha(int __ch)
+{
+    return std::isalpha((unsigned char) __ch) != 0;
+}
+
+inline bool pp_isalnum(int __ch)
+{
+    return std::isalnum((unsigned char) __ch) != 0;
+}
+
+inline bool pp_isdigit(int __ch)
+{
+    return std::isdigit((unsigned char) __ch) != 0;
+}
+
+inline bool pp_isspace(int __ch)
+{
+    return std::isspace((unsigned char) __ch) != 0;
+}
+
+} // namespace rpp
+
+#endif // PP_CCTYPE_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/rpp/pp-configuration b/ApiExtractor/parser/rpp/pp-configuration
new file mode 100644
index 000000000..15586dd88
--- /dev/null
+++ b/ApiExtractor/parser/rpp/pp-configuration
@@ -0,0 +1,86 @@
+#define __DBL_MIN_EXP__ (-1021)
+#define __FLT_MIN__ 1.17549435e-38F
+#define __CHAR_BIT__ 8
+#define __WCHAR_MAX__ 2147483647
+#define __DBL_DENORM_MIN__ 4.9406564584124654e-324
+#define __FLT_EVAL_METHOD__ 2
+#define __DBL_MIN_10_EXP__ (-307)
+#define __FINITE_MATH_ONLY__ 0
+#define __GNUC_PATCHLEVEL__ 2
+#define __SHRT_MAX__ 32767
+#define __LDBL_MAX__ 1.18973149535723176502e+4932L
+#define __UINTMAX_TYPE__ long long unsigned int
+#define __linux 1
+#define __unix 1
+#define __LDBL_MAX_EXP__ 16384
+#define __linux__ 1
+#define __SCHAR_MAX__ 127
+#define __USER_LABEL_PREFIX__
+#define __STDC_HOSTED__ 1
+#define __LDBL_HAS_INFINITY__ 1
+#define __DBL_DIG__ 15
+#define __FLT_EPSILON__ 1.19209290e-7F
+#define __GXX_WEAK__ 1
+#define __LDBL_MIN__ 3.36210314311209350626e-4932L
+#define __unix__ 1
+#define __DECIMAL_DIG__ 21
+#define __gnu_linux__ 1
+#define __LDBL_HAS_QUIET_NAN__ 1
+#define __GNUC__ 4
+#define __DBL_MAX__ 1.7976931348623157e+308
+#define __DBL_HAS_INFINITY__ 1
+#define __cplusplus 1
+#define __DEPRECATED 1
+#define __DBL_MAX_EXP__ 1024
+#define __GNUG__ 4
+#define __LONG_LONG_MAX__ 9223372036854775807LL
+#define __GXX_ABI_VERSION 1002
+#define __FLT_MIN_EXP__ (-125)
+#define __DBL_MIN__ 2.2250738585072014e-308
+#define __FLT_MIN_10_EXP__ (-37)
+#define __DBL_HAS_QUIET_NAN__ 1
+#define __REGISTER_PREFIX__
+#define __NO_INLINE__ 1
+#define __i386 1
+#define __FLT_MANT_DIG__ 24
+#define __VERSION__ "4.0.2 20050808 (prerelease) (Ubuntu 4.0.1-4ubuntu9)"
+#define i386 1
+#define __i486__ 1
+#define unix 1
+#define __i386__ 1
+#define __SIZE_TYPE__ unsigned int
+#define __ELF__ 1
+#define __FLT_RADIX__ 2
+#define __LDBL_EPSILON__ 1.08420217248550443401e-19L
+#define __FLT_HAS_QUIET_NAN__ 1
+#define __FLT_MAX_10_EXP__ 38
+#define __LONG_MAX__ 2147483647L
+#define __FLT_HAS_INFINITY__ 1
+#define linux 1
+#define __EXCEPTIONS 1
+#define __LDBL_MANT_DIG__ 64
+#define __WCHAR_TYPE__ int
+#define __FLT_DIG__ 6
+#define __INT_MAX__ 2147483647
+#define __i486 1
+#define __FLT_MAX_EXP__ 128
+#define __DBL_MANT_DIG__ 53
+#define __WINT_TYPE__ unsigned int
+#define __LDBL_MIN_EXP__ (-16381)
+#define __LDBL_MAX_10_EXP__ 4932
+#define __DBL_EPSILON__ 2.2204460492503131e-16
+#define __tune_i486__ 1
+#define __INTMAX_MAX__ 9223372036854775807LL
+#define __FLT_DENORM_MIN__ 1.40129846e-45F
+#define __FLT_MAX__ 3.40282347e+38F
+#define __INTMAX_TYPE__ long long int
+#define __GNUC_MINOR__ 0
+#define __DBL_MAX_10_EXP__ 308
+#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L
+#define __PTRDIFF_TYPE__ int
+#define __LDBL_MIN_10_EXP__ (-4931)
+#define __LDBL_DIG__ 18
+#define _GNU_SOURCE 1
+
+
+#define __STDC__
diff --git a/ApiExtractor/parser/rpp/pp-engine-bits.h b/ApiExtractor/parser/rpp/pp-engine-bits.h
new file mode 100644
index 000000000..a79df43a4
--- /dev/null
+++ b/ApiExtractor/parser/rpp/pp-engine-bits.h
@@ -0,0 +1,1300 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef PP_ENGINE_BITS_H
+#define PP_ENGINE_BITS_H
+
+#include "pp.h"
+#include <sys/stat.h>
+#include <cstdio>
+#include <iostream>
+
+namespace rpp
+{
+
+inline std::string pp::fix_file_path(std::string const &filename) const
+{
+#if defined (PP_OS_WIN)
+    std::string s = filename;
+    for (std::string::iterator it = s.begin(); it != s.end(); ++it) {
+        if (*it == '/')
+            *it = '\\';
+    }
+    return s;
+#else
+    return filename;
+#endif
+}
+
+inline bool pp::is_absolute(std::string const &filename) const
+{
+#if defined(PP_OS_WIN)
+    return filename.length() >= 3
+           && filename.at(1) == ':'
+           && (filename.at(2) == '\\' || filename.at(2) == '/');
+#else
+    return filename.length() >= 1
+           && filename.at(0) == '/';
+#endif
+}
+
+template <typename _OutputIterator>
+void pp::file(std::string const &filename, _OutputIterator __result)
+{
+    FILE *fp = std::fopen(filename.c_str(), "rb");
+    if (fp != 0) {
+        std::string was = env.current_file;
+        env.current_file = filename;
+        file(fp, __result);
+        env.current_file = was;
+    }
+    //else
+    //std::cerr << "** WARNING file ``" << filename << " not found!" << std::endl;
+}
+
+template <typename _OutputIterator>
+void pp::file(FILE *fp, _OutputIterator __result)
+{
+    assert(fp != 0);
+
+#if defined (HAVE_MMAP)
+    struct stat st;
+    fstat(FILENO(fp), &st);
+    std::size_t size = st.st_size;
+    char *buffer = 0;
+    buffer = (char *) ::mmap(0, size, PROT_READ, MAP_SHARED, FILENO(fp), 0);
+    fclose(fp);
+    if (!buffer || buffer == (char*) - 1)
+        return;
+    this->operator()(buffer, buffer + size, __result);
+    ::munmap(buffer, size);
+#else
+    std::string buffer;
+    while (!feof(fp)) {
+        char tmp[1024];
+        int read = (int) fread(tmp, sizeof(char), 1023, fp);
+        tmp[read] = '\0';
+        buffer += tmp;
+    }
+    fclose(fp);
+    this->operator()(buffer.c_str(), buffer.c_str() + buffer.size(), __result);
+#endif
+}
+
+template <typename _InputIterator>
+bool pp::find_header_protection(_InputIterator __first, _InputIterator __last, std::string *__prot)
+{
+    int was = env.current_line;
+
+    while (__first != __last) {
+        if (pp_isspace(*__first)) {
+            if (*__first == '\n')
+                ++env.current_line;
+
+            ++__first;
+        } else if (_PP_internal::comment_p(__first, __last)) {
+            __first = skip_comment_or_divop(__first, __last);
+            env.current_line += skip_comment_or_divop.lines;
+        } else if (*__first == '#') {
+            __first = skip_blanks(++__first, __last);
+            env.current_line += skip_blanks.lines;
+
+            if (__first != __last && *__first == 'i') {
+                _InputIterator __begin = __first;
+                __first = skip_identifier(__begin, __last);
+                env.current_line += skip_identifier.lines;
+
+                std::string __directive(__begin, __first);
+
+                if (__directive == "ifndef") {
+                    __first = skip_blanks(__first, __last);
+                    env.current_line += skip_blanks.lines;
+
+                    __begin = __first;
+                    __first = skip_identifier(__first, __last);
+                    env.current_line += skip_identifier.lines;
+
+                    if (__begin != __first && __first != __last) {
+                        __prot->assign(__begin, __first);
+                        return true;
+                    }
+                }
+            }
+            break;
+        } else
+            break;
+    }
+
+    env.current_line = was;
+    return false;
+}
+
+inline pp::PP_DIRECTIVE_TYPE pp::find_directive(char const *__directive, std::size_t __size) const
+{
+    switch (__size) {
+    case 0:
+        return PP_UNNAMED_DIRECTIVE;
+    case 2:
+        if (__directive[0] == 'i'
+            && __directive[1] == 'f')
+            return PP_IF;
+        break;
+
+    case 4:
+        if (__directive[0] == 'e' && !strcmp(__directive, "elif"))
+            return PP_ELIF;
+        else if (__directive[0] == 'e' && !strcmp(__directive, "else"))
+            return PP_ELSE;
+        break;
+
+    case 5:
+        if (__directive[0] == 'i' && !strcmp(__directive, "ifdef"))
+            return PP_IFDEF;
+        else if (__directive[0] == 'u' && !strcmp(__directive, "undef"))
+            return PP_UNDEF;
+        else if (__directive[0] == 'e') {
+            if (!strcmp(__directive, "endif"))
+                return PP_ENDIF;
+            else if (!strcmp(__directive, "error"))
+                return PP_ERROR;
+        }
+        break;
+
+    case 6:
+        if (__directive[0] == 'i' && !strcmp(__directive, "ifndef"))
+            return PP_IFNDEF;
+        else if (__directive[0] == 'd' && !strcmp(__directive, "define"))
+            return PP_DEFINE;
+        else if (__directive[0] == 'p' && !strcmp(__directive, "pragma"))
+            return PP_PRAGMA;
+        break;
+
+    case 7:
+        if (__directive[0] == 'i' && !strcmp(__directive, "include"))
+            return PP_INCLUDE;
+        else if (!strcmp(__directive, "warning"))
+            return PP_WARNING;
+        break;
+
+    case 12:
+        if (__directive[0] == 'i' && !strcmp(__directive, "include_next"))
+            return PP_INCLUDE_NEXT;
+        break;
+
+    default:
+        break;
+    }
+    std::cerr << "** WARNING unknown directive '#" << __directive << "' at " << env.current_file << ":" << env.current_line << std::endl;
+    return PP_UNKNOWN_DIRECTIVE;
+}
+
+inline bool pp::file_isdir(std::string const &__filename) const
+{
+    struct stat __st;
+#if defined(PP_OS_WIN)
+    if (stat(__filename.c_str(), &__st) == 0)
+        return (__st.st_mode & _S_IFDIR) == _S_IFDIR;
+    else
+        return false;
+#else
+    if (lstat(__filename.c_str(), &__st) == 0)
+        return (__st.st_mode & S_IFDIR) == S_IFDIR;
+    else
+        return false;
+#endif
+}
+
+inline bool pp::file_exists(std::string const &__filename) const
+{
+    struct stat __st;
+#if defined(PP_OS_WIN)
+    return stat(__filename.c_str(), &__st) == 0;
+#else
+    return lstat(__filename.c_str(), &__st) == 0;
+#endif
+}
+
+inline FILE *pp::find_include_file(std::string const &__input_filename, std::string *__filepath,
+                                   INCLUDE_POLICY __include_policy, bool __skip_current_path) const
+{
+    assert(__filepath != 0);
+    assert(! __input_filename.empty());
+
+    __filepath->assign(__input_filename);
+
+    if (is_absolute(*__filepath))
+        return std::fopen(__filepath->c_str(), "r");
+
+    if (! env.current_file.empty())
+        _PP_internal::extract_file_path(env.current_file, __filepath);
+
+    if (__include_policy == INCLUDE_LOCAL && ! __skip_current_path) {
+        std::string __tmp(*__filepath);
+        __tmp += __input_filename;
+
+        if (file_exists(__tmp) && !file_isdir(__tmp)) {
+            __filepath->append(__input_filename);
+            return std::fopen(__filepath->c_str(), "r");
+        }
+    }
+
+    std::vector<std::string>::const_iterator it = include_paths.begin();
+
+    if (__skip_current_path) {
+        it = std::find(include_paths.begin(), include_paths.end(), *__filepath);
+
+        if (it != include_paths.end())
+            ++it;
+
+        else
+            it = include_paths.begin();
+    }
+
+    for (; it != include_paths.end(); ++it) {
+        if (__skip_current_path && it == include_paths.begin())
+            continue;
+
+        __filepath->assign(*it);
+        __filepath->append(__input_filename);
+
+        if (file_exists(*__filepath) && !file_isdir(*__filepath))
+            return std::fopen(__filepath->c_str(), "r");
+
+#ifdef Q_OS_MAC
+        // try in Framework path on Mac, if there is a path in front
+        // ### what about escaped slashes?
+        size_t slashPos = __input_filename.find('/');
+        if (slashPos != std::string::npos) {
+            __filepath->assign(*it);
+            __filepath->append(__input_filename.substr(0, slashPos));
+            __filepath->append(".framework/Headers/");
+            __filepath->append(__input_filename.substr(slashPos + 1, std::string::npos));
+            std::cerr << *__filepath << "\n";
+
+            if (file_exists(*__filepath) && !file_isdir(*__filepath))
+                return fopen(__filepath->c_str(), "r");
+        }
+#endif // Q_OS_MAC
+    }
+
+    return 0;
+}
+
+template <typename _InputIterator, typename _OutputIterator>
+_InputIterator pp::handle_directive(char const *__directive, std::size_t __size,
+                                    _InputIterator __first, _InputIterator __last, _OutputIterator __result)
+{
+    __first = skip_blanks(__first, __last);
+
+    PP_DIRECTIVE_TYPE d = find_directive(__directive, __size);
+    switch (d) {
+    case PP_UNNAMED_DIRECTIVE:
+        /* There are many boost headers that include the character '#'
+         * at the beginning of any line and just do nothing else with
+         * that unnamed directive. Well, as that's not an error so
+         * we'll just ignore this unnamed directive for now.
+         */
+        ++__last;
+        return ++__first;
+    case PP_DEFINE:
+        if (! skipping())
+            return handle_define(__first, __last);
+        break;
+
+    case PP_INCLUDE:
+    case PP_INCLUDE_NEXT:
+        if (! skipping())
+            return handle_include(d == PP_INCLUDE_NEXT, __first, __last, __result);
+        break;
+
+    case PP_UNDEF:
+        if (! skipping())
+            return handle_undef(__first, __last);
+        break;
+
+    case PP_ELIF:
+        return handle_elif(__first, __last);
+
+    case PP_ELSE:
+        return handle_else(__first, __last);
+
+    case PP_ENDIF:
+        return handle_endif(__first, __last);
+
+    case PP_IF:
+        return handle_if(__first, __last);
+
+    case PP_IFDEF:
+        return handle_ifdef(false, __first, __last);
+
+    case PP_IFNDEF:
+        return handle_ifdef(true, __first, __last);
+
+    default:
+        break;
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator, typename _OutputIterator>
+_InputIterator pp::handle_include(bool __skip_current_path, _InputIterator __first, _InputIterator __last,
+                                  _OutputIterator __result)
+{
+    if (pp_isalpha(*__first) || *__first == '_') {
+        pp_macro_expander expand_include(env);
+        std::string name;
+        name.reserve(255);
+        expand_include(__first, __last, std::back_inserter(name));
+        std::string::iterator it = skip_blanks(name.begin(), name.end());
+        if (it != name.end() && (*it != '<' || *it != '"')) {
+            std::cerr << "** WARNING APIExtractor does not support the use "
+                         "of #include directives without passing either "
+                         "\"<path/to/header.h>\" or \"./path/to/header.h\", "
+                         "for example. Invalid use at " << env.current_file
+                      << ":" << env.current_line << "." << std::endl;
+            return __last;
+        }
+
+        handle_include(__skip_current_path, it, name.end(), __result);
+        return __first;
+    }
+
+    assert(*__first == '<' || *__first == '"');
+    int quote = (*__first == '"') ? '"' : '>';
+    ++__first;
+
+    _InputIterator end_name = __first;
+    for (; end_name != __last; ++end_name) {
+        assert(*end_name != '\n');
+
+        if (*end_name == quote)
+            break;
+    }
+
+    std::string filename(__first, end_name);
+
+#ifdef PP_OS_WIN
+    std::replace(filename.begin(), filename.end(), '/', '\\');
+#endif
+
+    std::string filepath;
+    FILE *fp = find_include_file(filename, &filepath, quote == '>' ? INCLUDE_GLOBAL : INCLUDE_LOCAL, __skip_current_path);
+
+#if defined (PP_HOOK_ON_FILE_INCLUDED)
+    PP_HOOK_ON_FILE_INCLUDED(env.current_file, fp ? filepath : filename, fp);
+#endif
+
+    if (fp != 0) {
+        std::string old_file = env.current_file;
+        env.current_file = filepath;
+        int __saved_lines = env.current_line;
+
+        env.current_line = 1;
+        //output_line (env.current_file, 1, __result);
+
+        file(fp, __result);
+
+        // restore the file name and the line position
+        env.current_file = old_file;
+        env.current_line = __saved_lines;
+
+        // sync the buffer
+        _PP_internal::output_line(env.current_file, env.current_line, __result);
+    }
+#ifndef RPP_JAMBI
+//   else
+//     std::cerr << "*** WARNING " << filename << ": No such file or directory" << std::endl;
+#endif
+
+    return __first;
+}
+
+template <typename _InputIterator, typename _OutputIterator>
+void pp::operator()(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
+{
+#ifndef PP_NO_SMART_HEADER_PROTECTION
+    std::string __prot;
+    __prot.reserve(255);
+    pp_fast_string __tmp(__prot.c_str(), __prot.size());
+
+    if (find_header_protection(__first, __last, &__prot)
+        && env.resolve(&__tmp) != 0) {
+        // std::cerr << "** DEBUG found header protection:" << __prot << std::endl;
+        return;
+    }
+#endif
+
+    env.current_line = 1;
+    char __buffer[512];
+
+    while (true) {
+        __first = skip_blanks(__first, __last);
+        env.current_line += skip_blanks.lines;
+
+        if (__first == __last)
+            break;
+        else if (*__first == '#') {
+            assert(*__first == '#');
+            __first = skip_blanks(++__first, __last);
+            env.current_line += skip_blanks.lines;
+
+            _InputIterator end_id = skip_identifier(__first, __last);
+            env.current_line += skip_identifier.lines;
+            std::size_t __size = end_id - __first;
+
+            assert(__size < 512);
+            char *__cp = __buffer;
+            std::copy(__first, end_id, __cp);
+            __cp[__size] = '\0';
+
+            end_id = skip_blanks(end_id, __last);
+            __first = skip(end_id, __last);
+
+            int was = env.current_line;
+            (void) handle_directive(__buffer, __size, end_id, __first, __result);
+
+            if (env.current_line != was) {
+                env.current_line = was;
+                _PP_internal::output_line(env.current_file, env.current_line, __result);
+            }
+        } else if (*__first == '\n') {
+            // ### compress the line
+            *__result++ = *__first++;
+            ++env.current_line;
+        } else if (skipping())
+            __first = skip(__first, __last);
+        else {
+            _PP_internal::output_line(env.current_file, env.current_line, __result);
+            __first = expand(__first, __last, __result);
+            env.current_line += expand.lines;
+
+            if (expand.generated_lines)
+                _PP_internal::output_line(env.current_file, env.current_line, __result);
+        }
+    }
+}
+
+inline pp::pp(pp_environment &__env):
+        env(__env), expand(env)
+{
+    iflevel = 0;
+    _M_skipping[iflevel] = 0;
+    _M_true_test[iflevel] = 0;
+}
+
+inline std::back_insert_iterator<std::vector<std::string> > pp::include_paths_inserter()
+{
+    return std::back_inserter(include_paths);
+}
+
+inline std::vector<std::string>::iterator pp::include_paths_begin()
+{
+    return include_paths.begin();
+}
+
+inline std::vector<std::string>::iterator pp::include_paths_end()
+{
+    return include_paths.end();
+}
+
+inline std::vector<std::string>::const_iterator pp::include_paths_begin() const
+{
+    return include_paths.begin();
+}
+
+inline std::vector<std::string>::const_iterator pp::include_paths_end() const
+{
+    return include_paths.end();
+}
+
+inline void pp::push_include_path(std::string const &__path)
+{
+    if (__path.empty() || __path [__path.size() - 1] != PATH_SEPARATOR) {
+        std::string __tmp(__path);
+        __tmp += PATH_SEPARATOR;
+        include_paths.push_back(__tmp);
+    }
+
+    else
+        include_paths.push_back(__path);
+}
+
+template <typename _InputIterator>
+_InputIterator pp::handle_define(_InputIterator __first, _InputIterator __last)
+{
+    pp_macro macro;
+#if defined (PP_WITH_MACRO_POSITION)
+    macro.file = pp_symbol::get(env.current_file);
+#endif
+    std::string definition;
+
+    __first = skip_blanks(__first, __last);
+    _InputIterator end_macro_name = skip_identifier(__first, __last);
+    pp_fast_string const *macro_name = pp_symbol::get(__first, end_macro_name);
+    __first = end_macro_name;
+
+    if (__first != __last && *__first == '(') {
+        macro.function_like = true;
+        macro.formals.reserve(5);
+
+        __first = skip_blanks(++__first, __last);  // skip '('
+        _InputIterator arg_end = skip_identifier(__first, __last);
+        if (__first != arg_end)
+            macro.formals.push_back(pp_symbol::get(__first, arg_end));
+
+        __first = skip_blanks(arg_end, __last);
+
+        if (*__first == '.') {
+            macro.variadics = true;
+            while (*__first == '.')
+                ++__first;
+        }
+
+        while (__first != __last && *__first == ',') {
+            __first = skip_blanks(++__first, __last);
+
+            arg_end = skip_identifier(__first, __last);
+            if (__first != arg_end)
+                macro.formals.push_back(pp_symbol::get(__first, arg_end));
+
+            __first = skip_blanks(arg_end, __last);
+
+            if (*__first == '.') {
+                macro.variadics = true;
+                while (*__first == '.')
+                    ++__first;
+            }
+        }
+
+        assert(*__first == ')');
+        ++__first;
+    }
+
+    __first = skip_blanks(__first, __last);
+
+    /* Note: Sometimes one can include a path between brackets (for
+     * e.g., when defining a macro or so) so that we cannot simply
+     * ignore that. The in_path variable will handle this situation.
+     */
+    bool in_path = false;
+    while (__first != __last && *__first != '\n') {
+        if ((*__first == '<' || *__first == '"') &&
+            (*(__first + 1) != '*' && *(__first + 1) != '/')) {
+            in_path = true;
+            goto skip_path;
+        }
+
+        if (in_path) {
+            if (*__first == '>' || *__first == '"') {
+                in_path = false;
+                goto skip_path;
+            } else if (*__first == ',' || *__first == ' ' || *__first == '\\') {
+                in_path = false;
+                continue;
+            }
+        }
+
+        if (*__first == '/') {
+            if (*(__first + 1) != '*' && *(__first + 1) != '/') {
+                in_path = true;
+                goto skip_path;
+            } else {
+                __first = skip_comment_or_divop(__first, __last);
+                env.current_line += skip_comment_or_divop.lines;
+            }
+        }
+
+        if (*__first == '\\') {
+            _InputIterator __begin = __first;
+            __begin = skip_blanks(++__begin, __last);
+
+            if (__begin != __last && *__begin == '\n') {
+                ++macro.lines;
+                __first = skip_blanks(++__begin, __last);
+                definition += ' ';
+                continue;
+            }
+        }
+
+skip_path:
+        definition += *__first++;
+    }
+
+    macro.definition = pp_symbol::get(definition);
+    env.bind(macro_name, macro);
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::skip(_InputIterator __first, _InputIterator __last)
+{
+    pp_skip_string_literal skip_string_literal;
+    pp_skip_char_literal skip_char_literal;
+
+    while (__first != __last && *__first != '\n') {
+        if (*__first == '/') {
+            __first = skip_comment_or_divop(__first, __last);
+            env.current_line += skip_comment_or_divop.lines;
+        } else if (*__first == '"') {
+            __first = skip_string_literal(__first, __last);
+            env.current_line += skip_string_literal.lines;
+        } else if (*__first == '\'') {
+            __first = skip_char_literal(__first, __last);
+            env.current_line += skip_char_literal.lines;
+        } else if (*__first == '\\') {
+            __first = skip_blanks(++__first, __last);
+            env.current_line += skip_blanks.lines;
+
+            if (__first != __last && *__first == '\n') {
+                ++__first;
+                ++env.current_line;
+            }
+        } else
+            ++__first;
+    }
+
+    return __first;
+}
+
+inline bool pp::test_if_level()
+{
+    bool result = !_M_skipping[iflevel++];
+    _M_skipping[iflevel] = _M_skipping[iflevel - 1];
+    _M_true_test[iflevel] = false;
+    return result;
+}
+
+inline int pp::skipping() const
+{
+    return _M_skipping[iflevel];
+}
+
+template <typename _InputIterator>
+_InputIterator pp::eval_primary(_InputIterator __first, _InputIterator __last, Value *result)
+{
+    bool expect_paren = false;
+    int token;
+    __first = next_token(__first, __last, &token);
+
+    switch (token) {
+    case TOKEN_NUMBER:
+        result->set_long(token_value);
+        break;
+
+    case TOKEN_UNUMBER:
+        result->set_ulong(token_uvalue);
+        break;
+
+    case TOKEN_DEFINED:
+        __first = next_token(__first, __last, &token);
+
+        if (token == '(') {
+            expect_paren = true;
+            __first = next_token(__first, __last, &token);
+        }
+
+        if (token != TOKEN_IDENTIFIER) {
+            std::cerr << "** WARNING expected ``identifier'' found:" << char(token) << std::endl;
+            result->set_long(0);
+            break;
+        }
+
+        result->set_long(env.resolve(token_text->c_str(), token_text->size()) != 0);
+
+        next_token(__first, __last, &token);  // skip '('
+
+        if (expect_paren) {
+            _InputIterator next = next_token(__first, __last, &token);
+            if (token != ')')
+                std::cerr << "** WARNING expected ``)''" << std::endl;
+            else
+                __first = next;
+        }
+        break;
+
+    case TOKEN_IDENTIFIER:
+        result->set_long(0);
+        break;
+
+    case '-':
+        __first = eval_primary(__first, __last, result);
+        result->set_long(- result->l);
+        return __first;
+
+    case '+':
+        __first = eval_primary(__first, __last, result);
+        return __first;
+
+    case '!':
+        __first = eval_primary(__first, __last, result);
+        result->set_long(result->is_zero());
+        return __first;
+
+    case '(':
+        __first = eval_constant_expression(__first, __last, result);
+        next_token(__first, __last, &token);
+
+        if (token != ')') {
+            std::cerr << "** WARNING expected ``)'' = " << token << " (at "
+                      << env.current_file << ":" << env.current_line
+                      << ")." << std::endl;
+        } else {
+            __first = next_token(__first, __last, &token);
+        }
+        break;
+
+    default:
+        result->set_long(0);
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::eval_multiplicative(_InputIterator __first, _InputIterator __last, Value *result)
+{
+    __first = eval_primary(__first, __last, result);
+
+    int token;
+    _InputIterator next = next_token(__first, __last, &token);
+
+    while (token == '*' || token == '/' || token == '%') {
+        Value value;
+        __first = eval_primary(next, __last, &value);
+
+        if (token == '*')
+            result->op_mult(value);
+        else if (token == '/') {
+            if (value.is_zero()) {
+                std::cerr << "** WARNING division by zero" << std::endl;
+                result->set_long(0);
+            } else
+                result->op_div(value);
+        } else {
+            if (value.is_zero()) {
+                std::cerr << "** WARNING division by zero" << std::endl;
+                result->set_long(0);
+            } else
+                result->op_mod(value);
+        }
+        next = next_token(__first, __last, &token);
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::eval_additive(_InputIterator __first, _InputIterator __last, Value *result)
+{
+    __first = eval_multiplicative(__first, __last, result);
+
+    int token;
+    _InputIterator next = next_token(__first, __last, &token);
+
+    while (token == '+' || token == '-') {
+        Value value;
+        __first = eval_multiplicative(next, __last, &value);
+
+        if (token == '+')
+            result->op_add(value);
+        else
+            result->op_sub(value);
+        next = next_token(__first, __last, &token);
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::eval_shift(_InputIterator __first, _InputIterator __last, Value *result)
+{
+    __first = eval_additive(__first, __last, result);
+
+    int token;
+    _InputIterator next = next_token(__first, __last, &token);
+
+    while (token == TOKEN_LT_LT || token == TOKEN_GT_GT) {
+        Value value;
+        __first = eval_additive(next, __last, &value);
+
+        if (token == TOKEN_LT_LT)
+            result->op_lhs(value);
+        else
+            result->op_rhs(value);
+        next = next_token(__first, __last, &token);
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::eval_relational(_InputIterator __first, _InputIterator __last, Value *result)
+{
+    __first = eval_shift(__first, __last, result);
+
+    int token;
+    _InputIterator next = next_token(__first, __last, &token);
+
+    while (token == '<'
+           || token == '>'
+           || token == TOKEN_LT_EQ
+           || token == TOKEN_GT_EQ) {
+        Value value;
+        __first = eval_shift(next, __last, &value);
+
+        switch (token) {
+        default:
+            assert(0);
+            break;
+
+        case '<':
+            result->op_lt(value);
+            break;
+
+        case '>':
+            result->op_gt(value);
+            break;
+
+        case TOKEN_LT_EQ:
+            result->op_le(value);
+            break;
+
+        case TOKEN_GT_EQ:
+            result->op_ge(value);
+            break;
+        }
+        next = next_token(__first, __last, &token);
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::eval_equality(_InputIterator __first, _InputIterator __last, Value *result)
+{
+    __first = eval_relational(__first, __last, result);
+
+    int token;
+    _InputIterator next = next_token(__first, __last, &token);
+
+    while (token == TOKEN_EQ_EQ || token == TOKEN_NOT_EQ) {
+        Value value;
+        __first = eval_relational(next, __last, &value);
+
+        if (token == TOKEN_EQ_EQ)
+            result->op_eq(value);
+        else
+            result->op_ne(value);
+        next = next_token(__first, __last, &token);
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::eval_and(_InputIterator __first, _InputIterator __last, Value *result)
+{
+    __first = eval_equality(__first, __last, result);
+
+    int token;
+    _InputIterator next = next_token(__first, __last, &token);
+
+    while (token == '&') {
+        Value value;
+        __first = eval_equality(next, __last, &value);
+        result->op_bit_and(value);
+        next = next_token(__first, __last, &token);
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::eval_xor(_InputIterator __first, _InputIterator __last, Value *result)
+{
+    __first = eval_and(__first, __last, result);
+
+    int token;
+    _InputIterator next = next_token(__first, __last, &token);
+
+    while (token == '^') {
+        Value value;
+        __first = eval_and(next, __last, &value);
+        result->op_bit_xor(value);
+        next = next_token(__first, __last, &token);
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::eval_or(_InputIterator __first, _InputIterator __last, Value *result)
+{
+    __first = eval_xor(__first, __last, result);
+
+    int token;
+    _InputIterator next = next_token(__first, __last, &token);
+
+    while (token == '|') {
+        Value value;
+        __first = eval_xor(next, __last, &value);
+        result->op_bit_or(value);
+        next = next_token(__first, __last, &token);
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::eval_logical_and(_InputIterator __first, _InputIterator __last, Value *result)
+{
+    __first = eval_or(__first, __last, result);
+
+    int token;
+    _InputIterator next = next_token(__first, __last, &token);
+
+    while (token == TOKEN_AND_AND) {
+        Value value;
+        __first = eval_or(next, __last, &value);
+        result->op_and(value);
+        next = next_token(__first, __last, &token);
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::eval_logical_or(_InputIterator __first, _InputIterator __last, Value *result)
+{
+    __first = eval_logical_and(__first, __last, result);
+
+    int token;
+    _InputIterator next = next_token(__first, __last, &token);
+
+    while (token == TOKEN_OR_OR) {
+        Value value;
+        __first = eval_logical_and(next, __last, &value);
+        result->op_or(value);
+        next = next_token(__first, __last, &token);
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::eval_constant_expression(_InputIterator __first, _InputIterator __last, Value *result)
+{
+    __first = eval_logical_or(__first, __last, result);
+
+    int token;
+    _InputIterator next = next_token(__first, __last, &token);
+
+    if (token == '?') {
+        Value left_value;
+        __first = eval_constant_expression(next, __last, &left_value);
+        __first = skip_blanks(__first, __last);
+
+        __first = next_token(__first, __last, &token);
+        if (token == ':') {
+            Value right_value;
+            __first = eval_constant_expression(__first, __last, &right_value);
+
+            *result = !result->is_zero() ? left_value : right_value;
+        } else {
+            std::cerr << "** WARNING expected ``:'' = " << int (token) << std::endl;
+            *result = left_value;
+        }
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::eval_expression(_InputIterator __first, _InputIterator __last, Value *result)
+{
+    return __first = eval_constant_expression(skip_blanks(__first, __last), __last, result);
+}
+
+template <typename _InputIterator>
+_InputIterator pp::handle_if(_InputIterator __first, _InputIterator __last)
+{
+    if (test_if_level()) {
+        pp_macro_expander expand_condition(env);
+        std::string condition;
+        condition.reserve(255);
+        expand_condition(skip_blanks(__first, __last), __last, std::back_inserter(condition));
+
+        Value result;
+        result.set_long(0);
+        eval_expression(condition.c_str(), condition.c_str() + condition.size(), &result);
+
+        _M_true_test[iflevel] = !result.is_zero();
+        _M_skipping[iflevel] = result.is_zero();
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::handle_else(_InputIterator __first, _InputIterator /*__last*/)
+{
+    if (iflevel == 0 && !skipping()) {
+        std::cerr << "** WARNING #else without #if" << std::endl;
+    } else if (iflevel > 0 && _M_skipping[iflevel - 1]) {
+        _M_skipping[iflevel] = true;
+    } else {
+        _M_skipping[iflevel] = _M_true_test[iflevel];
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::handle_elif(_InputIterator __first, _InputIterator __last)
+{
+    assert(iflevel > 0);
+
+    if (iflevel == 0 && !skipping()) {
+        std::cerr << "** WARNING #else without #if" << std::endl;
+    } else if (!_M_true_test[iflevel] && !_M_skipping[iflevel - 1]) {
+        Value result;
+        __first = eval_expression(__first, __last, &result);
+        _M_true_test[iflevel] = !result.is_zero();
+        _M_skipping[iflevel] = result.is_zero();
+    } else {
+        _M_skipping[iflevel] = true;
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::handle_endif(_InputIterator __first, _InputIterator /*__last*/)
+{
+    if (iflevel == 0 && !skipping()) {
+        std::cerr << "** WARNING #endif without #if" << std::endl;
+    } else {
+        _M_skipping[iflevel] = 0;
+        _M_true_test[iflevel] = 0;
+
+        --iflevel;
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::handle_ifdef(bool check_undefined, _InputIterator __first, _InputIterator __last)
+{
+    if (test_if_level()) {
+        _InputIterator end_macro_name = skip_identifier(__first, __last);
+
+        std::size_t __size;
+#if defined(__SUNPRO_CC)
+        std::distance(__first, end_macro_name, __size);
+#else
+        __size = std::distance(__first, end_macro_name);
+#endif
+        assert(__size < 256);
+
+        char __buffer [256];
+        std::copy(__first, end_macro_name, __buffer);
+
+        bool value = env.resolve(__buffer, __size) != 0;
+
+        __first = end_macro_name;
+
+        if (check_undefined)
+            value = !value;
+
+        _M_true_test[iflevel] = value;
+        _M_skipping[iflevel] = !value;
+    }
+
+    return __first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::handle_undef(_InputIterator __first, _InputIterator __last)
+{
+    __first = skip_blanks(__first, __last);
+    _InputIterator end_macro_name = skip_identifier(__first, __last);
+    assert(end_macro_name != __first);
+
+    std::size_t __size;
+#if defined(__SUNPRO_CC)
+    std::distance(__first, end_macro_name, __size);
+#else
+    __size = std::distance(__first, end_macro_name);
+#endif
+
+    assert(__size < 256);
+
+    char __buffer [256];
+    std::copy(__first, end_macro_name, __buffer);
+
+    pp_fast_string const __tmp(__buffer, __size);
+    env.unbind(&__tmp);
+
+    __first = end_macro_name;
+
+    return __first;
+}
+
+template <typename _InputIterator>
+char pp::peek_char(_InputIterator __first, _InputIterator __last)
+{
+    if (__first == __last)
+        return 0;
+
+    return *++__first;
+}
+
+template <typename _InputIterator>
+_InputIterator pp::next_token(_InputIterator __first, _InputIterator __last, int *kind)
+{
+    __first = skip_blanks(__first, __last);
+
+    if (__first == __last) {
+        *kind = 0;
+        return __first;
+    }
+
+    char ch = *__first;
+    char ch2 = peek_char(__first, __last);
+
+    switch (ch) {
+    case '/':
+        if (ch2 == '/' || ch2 == '*') {
+            __first = skip_comment_or_divop(__first, __last);
+            return next_token(__first, __last, kind);
+        }
+        ++__first;
+        *kind = '/';
+        break;
+
+    case '<':
+        ++__first;
+        if (ch2 == '<') {
+            ++__first;
+            *kind = TOKEN_LT_LT;
+        } else if (ch2 == '=') {
+            ++__first;
+            *kind = TOKEN_LT_EQ;
+        } else
+            *kind = '<';
+
+        return __first;
+
+    case '>':
+        ++__first;
+        if (ch2 == '>') {
+            ++__first;
+            *kind = TOKEN_GT_GT;
+        } else if (ch2 == '=') {
+            ++__first;
+            *kind = TOKEN_GT_EQ;
+        } else
+            *kind = '>';
+
+        return __first;
+
+    case '!':
+        ++__first;
+        if (ch2 == '=') {
+            ++__first;
+            *kind = TOKEN_NOT_EQ;
+        } else
+            *kind = '!';
+
+        return __first;
+
+    case '=':
+        ++__first;
+        if (ch2 == '=') {
+            ++__first;
+            *kind = TOKEN_EQ_EQ;
+        } else
+            *kind = '=';
+
+        return __first;
+
+    case '|':
+        ++__first;
+        if (ch2 == '|') {
+            ++__first;
+            *kind = TOKEN_OR_OR;
+        } else
+            *kind = '|';
+
+        return __first;
+
+    case '&':
+        ++__first;
+        if (ch2 == '&') {
+            ++__first;
+            *kind = TOKEN_AND_AND;
+        } else
+            *kind = '&';
+
+        return __first;
+
+    default:
+        if (pp_isalpha(ch) || ch == '_') {
+            _InputIterator end = skip_identifier(__first, __last);
+            _M_current_text.assign(__first, end);
+
+            token_text = &_M_current_text;
+            __first = end;
+
+            if (*token_text == "defined")
+                *kind = TOKEN_DEFINED;
+            else
+                *kind = TOKEN_IDENTIFIER;
+        } else if (pp_isdigit(ch)) {
+            _InputIterator end = skip_number(__first, __last);
+            std::string __str(__first, __last);
+            char ch = __str [__str.size() - 1];
+            if (ch == 'u' || ch == 'U') {
+                token_uvalue = strtoul(__str.c_str(), 0, 0);
+                *kind = TOKEN_UNUMBER;
+            } else {
+                token_value = strtol(__str.c_str(), 0, 0);
+                *kind = TOKEN_NUMBER;
+            }
+            __first = end;
+        } else
+            *kind = *__first++;
+    }
+
+    return __first;
+}
+
+} // namespace rpp
+
+#endif // PP_ENGINE_BITS_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/rpp/pp-engine.h b/ApiExtractor/parser/rpp/pp-engine.h
new file mode 100644
index 000000000..bc1d02e2c
--- /dev/null
+++ b/ApiExtractor/parser/rpp/pp-engine.h
@@ -0,0 +1,283 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef PP_ENGINE_H
+#define PP_ENGINE_H
+
+#include <string>
+#include <vector>
+#include "pp-scanner.h"
+#include "pp-macro-expander.h"
+#include "pp-environment.h"
+
+namespace rpp
+{
+
+struct Value {
+    Value() : kind(Kind_Long), l(0) {}
+
+    enum Kind {
+        Kind_Long,
+        Kind_ULong,
+    };
+
+    Kind kind;
+
+    union {
+        long l;
+        unsigned long ul;
+    };
+
+    inline bool is_ulong() const {
+        return kind == Kind_ULong;
+    }
+
+    inline void set_ulong(unsigned long v) {
+        ul = v;
+        kind = Kind_ULong;
+    }
+
+    inline void set_long(long v) {
+        l = v;
+        kind = Kind_Long;
+    }
+
+    inline bool is_zero() const {
+        return l == 0;
+    }
+
+#define PP_DEFINE_BIN_OP(name, op) \
+    inline Value &name (const Value &other) \
+    { \
+        if (is_ulong () || other.is_ulong ()) \
+            set_ulong (ul op other.ul); \
+        else \
+            set_long (l op other.l); \
+        return *this; \
+    }
+
+    PP_DEFINE_BIN_OP(op_add, +)
+    PP_DEFINE_BIN_OP(op_sub, -)
+    PP_DEFINE_BIN_OP(op_mult, *)
+    PP_DEFINE_BIN_OP(op_div, /)
+    PP_DEFINE_BIN_OP(op_mod, %)
+    PP_DEFINE_BIN_OP(op_lhs, <<)
+    PP_DEFINE_BIN_OP(op_rhs, >>)
+    PP_DEFINE_BIN_OP(op_lt, <)
+    PP_DEFINE_BIN_OP(op_gt, >)
+    PP_DEFINE_BIN_OP(op_le, <=)
+    PP_DEFINE_BIN_OP(op_ge, >=)
+    PP_DEFINE_BIN_OP(op_eq, ==)
+    PP_DEFINE_BIN_OP(op_ne, !=)
+    PP_DEFINE_BIN_OP(op_bit_and, &)
+    PP_DEFINE_BIN_OP(op_bit_or, |)
+    PP_DEFINE_BIN_OP(op_bit_xor, ^)
+    PP_DEFINE_BIN_OP(op_and, &&)
+    PP_DEFINE_BIN_OP(op_or, ||)
+
+#undef PP_DEFINE_BIN_OP
+};
+
+class pp
+{
+    pp_environment &env;
+    pp_macro_expander expand;
+    pp_skip_identifier skip_identifier;
+    pp_skip_comment_or_divop skip_comment_or_divop;
+    pp_skip_blanks skip_blanks;
+    pp_skip_number skip_number;
+    std::vector<std::string> include_paths;
+    std::string _M_current_text;
+
+    enum { MAX_LEVEL = 512 };
+    int _M_skipping[MAX_LEVEL];
+    int _M_true_test[MAX_LEVEL];
+    int iflevel;
+
+    union {
+        long token_value;
+        unsigned long token_uvalue;
+        std::string *token_text;
+    };
+
+    enum INCLUDE_POLICY {
+        INCLUDE_GLOBAL,
+        INCLUDE_LOCAL
+    };
+
+    enum TOKEN_TYPE {
+        TOKEN_NUMBER = 1000,
+        TOKEN_UNUMBER,
+        TOKEN_IDENTIFIER,
+        TOKEN_DEFINED,
+        TOKEN_LT_LT,
+        TOKEN_LT_EQ,
+        TOKEN_GT_GT,
+        TOKEN_GT_EQ,
+        TOKEN_EQ_EQ,
+        TOKEN_NOT_EQ,
+        TOKEN_OR_OR,
+        TOKEN_AND_AND,
+    };
+
+    enum PP_DIRECTIVE_TYPE {
+        PP_UNKNOWN_DIRECTIVE,
+        PP_UNNAMED_DIRECTIVE,
+        PP_DEFINE,
+        PP_INCLUDE,
+        PP_INCLUDE_NEXT,
+        PP_ELIF,
+        PP_ELSE,
+        PP_ENDIF,
+        PP_IF,
+        PP_IFDEF,
+        PP_IFNDEF,
+        PP_UNDEF,
+        PP_PRAGMA,
+        PP_ERROR,
+        PP_WARNING
+    };
+
+public:
+    pp(pp_environment &__env);
+
+    inline std::back_insert_iterator<std::vector<std::string> > include_paths_inserter();
+
+    inline void push_include_path(std::string const &__path);
+
+    inline std::vector<std::string>::iterator include_paths_begin();
+    inline std::vector<std::string>::iterator include_paths_end();
+
+    inline std::vector<std::string>::const_iterator include_paths_begin() const;
+    inline std::vector<std::string>::const_iterator include_paths_end() const;
+
+    template <typename _InputIterator>
+    inline _InputIterator eval_expression(_InputIterator __first, _InputIterator __last, Value *result);
+
+    template <typename _OutputIterator>
+    void file(std::string const &filename, _OutputIterator __result);
+
+    template <typename _OutputIterator>
+    void file(FILE *fp, _OutputIterator __result);
+
+    template <typename _InputIterator, typename _OutputIterator>
+    void operator()(_InputIterator __first, _InputIterator __last, _OutputIterator __result);
+
+private:
+    inline bool file_isdir(std::string const &__filename) const;
+    inline bool file_exists(std::string const &__filename) const;
+    FILE *find_include_file(std::string const &__filename, std::string *__filepath,
+                            INCLUDE_POLICY __include_policy, bool __skip_current_path = false) const;
+
+    inline int skipping() const;
+    bool test_if_level();
+
+    inline std::string fix_file_path(std::string const &filename) const;
+    inline bool is_absolute(std::string const &filename) const;
+
+    PP_DIRECTIVE_TYPE find_directive(char const *__directive, std::size_t __size) const;
+
+    template <typename _InputIterator>
+    bool find_header_protection(_InputIterator __first, _InputIterator __last, std::string *__prot);
+
+    template <typename _InputIterator>
+    _InputIterator skip(_InputIterator __first, _InputIterator __last);
+
+    template <typename _InputIterator>
+    _InputIterator eval_primary(_InputIterator __first, _InputIterator __last, Value *result);
+
+    template <typename _InputIterator>
+    _InputIterator eval_multiplicative(_InputIterator __first, _InputIterator __last, Value *result);
+
+    template <typename _InputIterator>
+    _InputIterator eval_additive(_InputIterator __first, _InputIterator __last, Value *result);
+
+    template <typename _InputIterator>
+    _InputIterator eval_shift(_InputIterator __first, _InputIterator __last, Value *result);
+
+    template <typename _InputIterator>
+    _InputIterator eval_relational(_InputIterator __first, _InputIterator __last, Value *result);
+
+    template <typename _InputIterator>
+    _InputIterator eval_equality(_InputIterator __first, _InputIterator __last, Value *result);
+
+    template <typename _InputIterator>
+    _InputIterator eval_and(_InputIterator __first, _InputIterator __last, Value *result);
+
+    template <typename _InputIterator>
+    _InputIterator eval_xor(_InputIterator __first, _InputIterator __last, Value *result);
+
+    template <typename _InputIterator>
+    _InputIterator eval_or(_InputIterator __first, _InputIterator __last, Value *result);
+
+    template <typename _InputIterator>
+    _InputIterator eval_logical_and(_InputIterator __first, _InputIterator __last, Value *result);
+
+    template <typename _InputIterator>
+    _InputIterator eval_logical_or(_InputIterator __first, _InputIterator __last, Value *result);
+
+    template <typename _InputIterator>
+    _InputIterator eval_constant_expression(_InputIterator __first, _InputIterator __last, Value *result);
+
+    template <typename _InputIterator, typename _OutputIterator>
+    _InputIterator handle_directive(char const *__directive, std::size_t __size,
+                                    _InputIterator __first, _InputIterator __last, _OutputIterator __result);
+
+    template <typename _InputIterator, typename _OutputIterator>
+    _InputIterator handle_include(bool skip_current_path, _InputIterator __first, _InputIterator __last,
+                                  _OutputIterator __result);
+
+    template <typename _InputIterator>
+    _InputIterator handle_define(_InputIterator __first, _InputIterator __last);
+
+    template <typename _InputIterator>
+    _InputIterator handle_if(_InputIterator __first, _InputIterator __last);
+
+    template <typename _InputIterator>
+    _InputIterator handle_else(_InputIterator __first, _InputIterator __last);
+
+    template <typename _InputIterator>
+    _InputIterator handle_elif(_InputIterator __first, _InputIterator __last);
+
+    template <typename _InputIterator>
+    _InputIterator handle_endif(_InputIterator __first, _InputIterator __last);
+
+    template <typename _InputIterator>
+    _InputIterator handle_ifdef(bool check_undefined, _InputIterator __first, _InputIterator __last);
+
+    template <typename _InputIterator>
+    _InputIterator handle_undef(_InputIterator __first, _InputIterator __last);
+
+    template <typename _InputIterator>
+    inline char peek_char(_InputIterator __first, _InputIterator __last);
+
+    template <typename _InputIterator>
+    _InputIterator next_token(_InputIterator __first, _InputIterator __last, int *kind);
+};
+
+} // namespace rpp
+
+#endif // PP_ENGINE_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/rpp/pp-environment.h b/ApiExtractor/parser/rpp/pp-environment.h
new file mode 100644
index 000000000..be3ef3837
--- /dev/null
+++ b/ApiExtractor/parser/rpp/pp-environment.h
@@ -0,0 +1,139 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef PP_ENVIRONMENT_H
+#define PP_ENVIRONMENT_H
+
+#include <vector>
+#include <string>
+#include <cstring>
+#include "pp-macro.h"
+
+namespace rpp
+{
+
+class pp_environment
+{
+public:
+    typedef std::vector<pp_macro*>::const_iterator const_iterator;
+
+public:
+    pp_environment():
+            current_line(0),
+            _M_hash_size(4093) {
+        _M_base = (pp_macro **) memset(new pp_macro* [_M_hash_size], 0, _M_hash_size * sizeof(pp_macro*));
+    }
+
+    ~pp_environment() {
+        for (std::size_t i = 0; i < _M_macros.size(); ++i)
+            delete _M_macros [i];
+
+        delete [] _M_base;
+    }
+
+    const_iterator first_macro() const {
+        return _M_macros.begin();
+    }
+    const_iterator last_macro() const {
+        return _M_macros.end();
+    }
+
+    inline void bind(pp_fast_string const *__name, pp_macro const &__macro) {
+        std::size_t h = hash_code(*__name) % _M_hash_size;
+        pp_macro *m = new pp_macro(__macro);
+        m->name = __name;
+        m->next = _M_base [h];
+        m->hash_code = h;
+        _M_base [h] = m;
+
+        _M_macros.push_back(m);
+
+        if (_M_macros.size() == _M_hash_size)
+            rehash();
+    }
+
+    inline void unbind(pp_fast_string const *__name) {
+        if (pp_macro *m = resolve(__name))
+            m->hidden = true;
+    }
+
+    inline void unbind(char const *__s, std::size_t __size) {
+        pp_fast_string __tmp(__s, __size);
+        unbind(&__tmp);
+    }
+
+    inline pp_macro *resolve(pp_fast_string const *__name) const {
+        std::size_t h = hash_code(*__name) % _M_hash_size;
+        pp_macro *it = _M_base [h];
+
+        while (it && it->name && it->hash_code == h && (*it->name != *__name || it->hidden))
+            it = it->next;
+
+        return it;
+    }
+
+    inline pp_macro *resolve(char const *__data, std::size_t __size) const {
+        pp_fast_string const __tmp(__data, __size);
+        return resolve(&__tmp);
+    }
+
+    std::string current_file;
+    int current_line;
+
+private:
+    inline std::size_t hash_code(pp_fast_string const &s) const {
+        std::size_t hash_value = 0;
+
+        for (std::size_t i = 0; i < s.size(); ++i)
+            hash_value = (hash_value << 5) - hash_value + s.at(i);
+
+        return hash_value;
+    }
+
+    void rehash() {
+        delete[] _M_base;
+
+        _M_hash_size <<= 1;
+
+        _M_base = (pp_macro **) memset(new pp_macro* [_M_hash_size], 0, _M_hash_size * sizeof(pp_macro*));
+        for (std::size_t index = 0; index < _M_macros.size(); ++index) {
+            pp_macro *elt = _M_macros [index];
+            std::size_t h = hash_code(*elt->name) % _M_hash_size;
+            elt->next = _M_base [h];
+            elt->hash_code = h;
+            _M_base [h] = elt;
+        }
+    }
+
+private:
+    std::vector<pp_macro*> _M_macros;
+    pp_macro **_M_base;
+    std::size_t _M_hash_size;
+};
+
+} // namespace rpp
+
+#endif // PP_ENVIRONMENT_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/rpp/pp-fwd.h b/ApiExtractor/parser/rpp/pp-fwd.h
new file mode 100644
index 000000000..5b1c792f8
--- /dev/null
+++ b/ApiExtractor/parser/rpp/pp-fwd.h
@@ -0,0 +1,39 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef PP_FWD_H
+#define PP_FWD_H
+
+namespace rpp
+{
+
+template <typename _CharT> class pp_string;
+
+typedef pp_string<char> pp_fast_string;
+
+} // namespace rpp
+
+#endif // PP_FWD_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/rpp/pp-internal.h b/ApiExtractor/parser/rpp/pp-internal.h
new file mode 100644
index 000000000..7e708101d
--- /dev/null
+++ b/ApiExtractor/parser/rpp/pp-internal.h
@@ -0,0 +1,117 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef PP_INTERNAL_H
+#define PP_INTERNAL_H
+
+#include <algorithm>
+#include <string>
+#include "pp.h"
+
+namespace rpp
+{
+
+namespace _PP_internal
+{
+
+inline void extract_file_path(const std::string &__filename, std::string *__filepath)
+{
+    std::size_t __index = __filename.rfind(PATH_SEPARATOR);
+
+    if (__index == std::string::npos)
+        *__filepath = "/";
+
+    else
+        __filepath->assign(__filename, 0, __index + 1);
+}
+
+template <typename _OutputIterator>
+void output_line(const std::string &__filename, int __line, _OutputIterator __result)
+{
+    std::string __msg;
+
+    __msg += "# ";
+
+    char __line_descr[16];
+    pp_snprintf(__line_descr, 16, "%d", __line);
+    __msg += __line_descr;
+
+    __msg += " \"";
+
+    if (__filename.empty())
+        __msg += "<internal>";
+    else
+        __msg += __filename;
+
+    __msg += "\"\n";
+    std::copy(__msg.begin(), __msg.end(), __result);
+}
+
+template <typename _InputIterator>
+inline bool comment_p(_InputIterator __first, _InputIterator __last)  /*const*/
+{
+    if (__first == __last)
+        return false;
+
+    if (*__first != '/')
+        return false;
+
+    if (++__first == __last)
+        return false;
+
+    return (*__first == '/' || *__first == '*');
+}
+
+struct _Compare_string: public std::binary_function<bool, pp_fast_string const *, pp_fast_string const *> {
+    inline bool operator()(pp_fast_string const *__lhs, pp_fast_string const *__rhs) const {
+        return *__lhs < *__rhs;
+    }
+};
+
+struct _Equal_to_string: public std::binary_function<bool, pp_fast_string const *, pp_fast_string const *> {
+    inline bool operator()(pp_fast_string const *__lhs, pp_fast_string const *__rhs) const {
+        return *__lhs == *__rhs;
+    }
+};
+
+struct _Hash_string: public std::unary_function<std::size_t, pp_fast_string const *> {
+    inline std::size_t operator()(pp_fast_string const *__s) const {
+        char const *__ptr = __s->begin();
+        std::size_t __size = __s->size();
+        std::size_t __h = 0;
+
+        for (std::size_t i = 0; i < __size; ++i)
+            __h = (__h << 5) - __h + __ptr [i];
+
+        return __h;
+    }
+};
+
+} // _PP_internal
+
+} // namespace rpp
+
+#endif // PP_INTERNAL_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/rpp/pp-iterator.h b/ApiExtractor/parser/rpp/pp-iterator.h
new file mode 100644
index 000000000..3e87d1cfc
--- /dev/null
+++ b/ApiExtractor/parser/rpp/pp-iterator.h
@@ -0,0 +1,94 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef PP_ITERATOR_H
+#define PP_ITERATOR_H
+
+#include <iterator>
+
+namespace rpp
+{
+
+class pp_null_output_iterator
+        : public std::iterator<std::output_iterator_tag, void, void, void, void>
+{
+public:
+    pp_null_output_iterator() {}
+
+    template <typename _Tp>
+    pp_null_output_iterator &operator=(_Tp const &) {
+        return *this;
+    }
+
+    inline pp_null_output_iterator &operator *() {
+        return *this;
+    }
+    inline pp_null_output_iterator &operator ++ () {
+        return *this;
+    }
+    inline pp_null_output_iterator operator ++ (int) {
+        return *this;
+    }
+};
+
+template <typename _Container>
+class pp_output_iterator
+        : public std::iterator<std::output_iterator_tag, void, void, void, void>
+{
+    std::string &_M_result;
+
+public:
+    explicit pp_output_iterator(std::string &__result):
+            _M_result(__result) {}
+
+    inline pp_output_iterator<_Container>& operator=(const pp_output_iterator<_Container>& other)
+    {
+        _M_result = other._M_result;
+        return *this;
+    }
+
+    inline pp_output_iterator &operator=(typename _Container::const_reference __v) {
+        if (_M_result.capacity() == _M_result.size())
+            _M_result.reserve(_M_result.capacity() << 2);
+
+        _M_result.push_back(__v);
+        return *this;
+    }
+
+    inline pp_output_iterator &operator *() {
+        return *this;
+    }
+    inline pp_output_iterator &operator ++ () {
+        return *this;
+    }
+    inline pp_output_iterator operator ++ (int) {
+        return *this;
+    }
+};
+
+} // namespace rpp
+
+#endif // PP_ITERATOR_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/rpp/pp-macro-expander.h b/ApiExtractor/parser/rpp/pp-macro-expander.h
new file mode 100644
index 000000000..fd875d980
--- /dev/null
+++ b/ApiExtractor/parser/rpp/pp-macro-expander.h
@@ -0,0 +1,351 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef PP_MACRO_EXPANDER_H
+#define PP_MACRO_EXPANDER_H
+
+namespace rpp
+{
+
+struct pp_frame {
+    pp_macro *expanding_macro;
+    std::vector<std::string> *actuals;
+
+    pp_frame(pp_macro *__expanding_macro, std::vector<std::string> *__actuals):
+            expanding_macro(__expanding_macro), actuals(__actuals) {}
+};
+
+class pp_macro_expander
+{
+    pp_environment &env;
+    pp_frame *frame;
+
+    pp_skip_number skip_number;
+    pp_skip_identifier skip_identifier;
+    pp_skip_string_literal skip_string_literal;
+    pp_skip_char_literal skip_char_literal;
+    pp_skip_argument skip_argument;
+    pp_skip_comment_or_divop skip_comment_or_divop;
+    pp_skip_blanks skip_blanks;
+    pp_skip_whitespaces skip_whitespaces;
+
+    std::string const *resolve_formal(pp_fast_string const *__name) {
+        assert(__name != 0);
+
+        if (! frame)
+            return 0;
+
+        assert(frame->expanding_macro != 0);
+
+        std::vector<pp_fast_string const *> const formals = frame->expanding_macro->formals;
+        for (std::size_t index = 0; index < formals.size(); ++index) {
+            pp_fast_string const *formal = formals[index];
+
+            if (*formal != *__name)
+                continue;
+
+            else if (frame->actuals && index < frame->actuals->size())
+                return &(*frame->actuals)[index];
+
+            else
+                assert(0);  // internal error?
+        }
+
+        return 0;
+    }
+
+public: // attributes
+    int lines;
+    int generated_lines;
+
+public:
+    pp_macro_expander(pp_environment &__env, pp_frame *__frame = 0):
+            env(__env), frame(__frame), lines(0), generated_lines(0) {}
+
+    template <typename _InputIterator, typename _OutputIterator>
+    _InputIterator operator()(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
+        generated_lines = 0;
+        __first = skip_blanks(__first, __last);
+        lines = skip_blanks.lines;
+
+        while (__first != __last) {
+            if (*__first == '\n') {
+                *__result++ = *__first;
+                ++lines;
+
+                __first = skip_blanks(++__first, __last);
+                lines += skip_blanks.lines;
+
+                if (__first != __last && *__first == '#')
+                    break;
+            } else if (*__first == '#') {
+                __first = skip_blanks(++__first, __last);
+                lines += skip_blanks.lines;
+
+                _InputIterator end_id = skip_identifier(__first, __last);
+
+                // ### rewrite: not safe
+                char name_buffer[512], *cp = name_buffer;
+                std::copy(__first, end_id, cp);
+                std::size_t name_size = end_id - __first;
+                name_buffer[name_size] = '\0';
+
+                pp_fast_string fast_name(name_buffer, name_size);
+
+                if (std::string const *actual = resolve_formal(&fast_name)) {
+                    *__result++ = '\"';
+
+                    for (std::string::const_iterator it = skip_whitespaces(actual->begin(), actual->end());
+                         it != actual->end(); ++it) {
+                        if (*it == '"') {
+                            *__result++ = '\\';
+                            *__result++ = *it;
+                        }
+
+                        else if (*it == '\n') {
+                            *__result++ = '"';
+                            *__result++ = '\n';
+                            *__result++ = '"';
+                        }
+
+                        else
+                            *__result++ = *it;
+                    }
+
+                    *__result++ = '\"';
+                    __first = end_id;
+                } else
+                    *__result++ = '#'; // ### warning message?
+            } else if (*__first == '\"') {
+                _InputIterator next_pos = skip_string_literal(__first, __last);
+                lines += skip_string_literal.lines;
+                std::copy(__first, next_pos, __result);
+                __first = next_pos;
+            } else if (*__first == '\'') {
+                _InputIterator next_pos = skip_char_literal(__first, __last);
+                lines += skip_char_literal.lines;
+                std::copy(__first, next_pos, __result);
+                __first = next_pos;
+            } else if (_PP_internal::comment_p(__first, __last)) {
+                __first = skip_comment_or_divop(__first, __last);
+                int n = skip_comment_or_divop.lines;
+                lines += n;
+
+                while (n-- > 0)
+                    *__result++ = '\n';
+            } else if (pp_isspace(*__first)) {
+                for (; __first != __last; ++__first) {
+                    if (*__first == '\n' || !pp_isspace(*__first))
+                        break;
+                }
+
+                *__result = ' ';
+            } else if (pp_isdigit(*__first)) {
+                _InputIterator next_pos = skip_number(__first, __last);
+                lines += skip_number.lines;
+                std::copy(__first, next_pos, __result);
+                __first = next_pos;
+            } else if (pp_isalpha(*__first) || *__first == '_') {
+                _InputIterator name_begin = __first;
+                _InputIterator name_end = skip_identifier(__first, __last);
+                __first = name_end; // advance
+
+                // search for the paste token
+                _InputIterator next = skip_blanks(__first, __last);
+                if (next != __last && *next == '#') {
+                    ++next;
+                    if (next != __last && *next == '#')
+                        __first = skip_blanks(++next, __last);
+                }
+
+                // ### rewrite: not safe
+
+                std::ptrdiff_t name_size;
+#if defined(__SUNPRO_CC)
+                std::distance(name_begin, name_end, name_size);
+#else
+                name_size = std::distance(name_begin, name_end);
+#endif
+                assert(name_size >= 0 && name_size < 512);
+
+                char name_buffer[512], *cp = name_buffer;
+                std::size_t __size = name_end - name_begin;
+                std::copy(name_begin, name_end, cp);
+                name_buffer[__size] = '\0';
+
+                pp_fast_string fast_name(name_buffer, name_size);
+
+                if (std::string const *actual = resolve_formal(&fast_name)) {
+                    std::copy(actual->begin(), actual->end(), __result);
+                    continue;
+                }
+
+                static bool hide_next = false; // ### remove me
+
+                pp_macro *macro = env.resolve(name_buffer, name_size);
+                if (! macro || macro->hidden || hide_next) {
+                    hide_next = ! strcmp(name_buffer, "defined");
+
+                    if (__size == 8 && name_buffer [0] == '_' && name_buffer [1] == '_') {
+                        if (! strcmp(name_buffer, "__LINE__")) {
+                            char buf [16];
+                            char *end = buf + pp_snprintf(buf, 16, "%d", env.current_line + lines);
+
+                            std::copy(&buf [0], end, __result);
+                            continue;
+                        }
+
+                        else if (! strcmp(name_buffer, "__FILE__")) {
+                            __result++ = '"';
+                            std::copy(env.current_file.begin(), env.current_file.end(), __result);    // ### quote
+                            __result++ = '"';
+                            continue;
+                        }
+                    }
+
+                    std::copy(name_begin, name_end, __result);
+                    continue;
+                }
+
+                if (! macro->function_like) {
+                    pp_macro *m = 0;
+
+                    if (macro->definition) {
+                        macro->hidden = true;
+
+                        std::string __tmp;
+                        __tmp.reserve(256);
+
+                        pp_macro_expander expand_macro(env);
+                        expand_macro(macro->definition->begin(), macro->definition->end(), std::back_inserter(__tmp));
+                        generated_lines += expand_macro.lines;
+
+                        if (! __tmp.empty()) {
+                            std::string::iterator __begin_id = skip_whitespaces(__tmp.begin(), __tmp.end());
+                            std::string::iterator __end_id = skip_identifier(__begin_id, __tmp.end());
+
+                            if (__end_id == __tmp.end()) {
+                                std::string __id;
+                                __id.assign(__begin_id, __end_id);
+
+                                std::size_t x;
+#if defined(__SUNPRO_CC)
+                                std::distance(__begin_id, __end_id, x);
+#else
+                                x = std::distance(__begin_id, __end_id);
+#endif
+                                m = env.resolve(__id.c_str(), x);
+                            }
+
+                            if (! m)
+                                std::copy(__tmp.begin(), __tmp.end(), __result);
+                        }
+
+                        macro->hidden = false;
+                    }
+
+                    if (! m)
+                        continue;
+
+                    macro = m;
+                }
+
+                // function like macro
+                _InputIterator arg_it = skip_whitespaces(__first, __last);
+
+                if (arg_it == __last || *arg_it != '(') {
+                    std::copy(name_begin, name_end, __result);
+                    lines += skip_whitespaces.lines;
+                    __first = arg_it;
+                    continue;
+                }
+
+                std::vector<std::string> actuals;
+                actuals.reserve(5);
+                ++arg_it; // skip '('
+
+                pp_macro_expander expand_actual(env, frame);
+
+                _InputIterator arg_end = skip_argument_variadics(actuals, macro, arg_it, __last);
+                if (arg_it != arg_end) {
+                    std::string actual(arg_it, arg_end);
+                    actuals.resize(actuals.size() + 1);
+                    actuals.back().reserve(255);
+                    expand_actual(actual.begin(), actual.end(), std::back_inserter(actuals.back()));
+                    arg_it = arg_end;
+                }
+
+                while (arg_it != __last && *arg_end == ',') {
+                    ++arg_it; // skip ','
+
+                    arg_end = skip_argument_variadics(actuals, macro, arg_it, __last);
+                    std::string actual(arg_it, arg_end);
+                    actuals.resize(actuals.size() + 1);
+                    actuals.back().reserve(255);
+                    expand_actual(actual.begin(), actual.end(), std::back_inserter(actuals.back()));
+                    arg_it = arg_end;
+                }
+
+                assert(arg_it != __last && *arg_it == ')');
+
+                ++arg_it; // skip ')'
+                __first = arg_it;
+
+#if 0 // ### enable me
+                assert((macro->variadics && macro->formals.size() >= actuals.size())
+                       || macro->formals.size() == actuals.size());
+#endif
+
+                pp_frame frame(macro, &actuals);
+                pp_macro_expander expand_macro(env, &frame);
+                macro->hidden = true;
+                expand_macro(macro->definition->begin(), macro->definition->end(), __result);
+                macro->hidden = false;
+                generated_lines += expand_macro.lines;
+            } else
+                *__result++ = *__first++;
+        }
+
+        return __first;
+    }
+
+    template <typename _InputIterator>
+    _InputIterator skip_argument_variadics(std::vector<std::string> const &__actuals, pp_macro *__macro,
+                                           _InputIterator __first, _InputIterator __last) {
+        _InputIterator arg_end = skip_argument(__first, __last);
+
+        while (__macro->variadics && __first != arg_end && arg_end != __last && *arg_end == ','
+               && (__actuals.size() + 1) == __macro->formals.size()) {
+            arg_end = skip_argument(++arg_end, __last);
+        }
+
+        return arg_end;
+    }
+};
+
+} // namespace rpp
+
+#endif // PP_MACRO_EXPANDER_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/rpp/pp-macro.h b/ApiExtractor/parser/rpp/pp-macro.h
new file mode 100644
index 000000000..e633834b1
--- /dev/null
+++ b/ApiExtractor/parser/rpp/pp-macro.h
@@ -0,0 +1,72 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef PP_MACRO_H
+#define PP_MACRO_H
+
+#include <vector>
+#include "pp-fwd.h"
+
+namespace rpp
+{
+
+struct pp_macro {
+#if defined (PP_WITH_MACRO_POSITION)
+    pp_fast_string const *file;
+#endif
+    pp_fast_string const *name;
+    pp_fast_string const *definition;
+    std::vector<pp_fast_string const *> formals;
+
+    union {
+        int unsigned state;
+
+        struct {
+            int unsigned hidden: 1;
+            int unsigned function_like: 1;
+            int unsigned variadics: 1;
+        };
+    };
+
+    int lines;
+    pp_macro *next;
+    std::size_t hash_code;
+
+    inline pp_macro():
+#if defined (PP_WITH_MACRO_POSITION)
+            file(0),
+#endif
+            name(0),
+            definition(0),
+            state(0),
+            lines(0),
+            next(0),
+            hash_code(0) {}
+};
+
+} // namespace rpp
+
+#endif // PP_MACRO_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/rpp/pp-qt-configuration b/ApiExtractor/parser/rpp/pp-qt-configuration
new file mode 100644
index 000000000..206c3d643
--- /dev/null
+++ b/ApiExtractor/parser/rpp/pp-qt-configuration
@@ -0,0 +1,24 @@
+#define __cplusplus 1
+
+#define __STDC__
+
+// Qt
+#define QOBJECTDEFS_H
+
+// not yet supported
+#define Q_SLOTS slots
+#define Q_SIGNALS signals
+#define Q_FLAGS(a)
+#define Q_PRIVATE_SLOT(a, b)
+#define Q_DECLARE_INTERFACE(a,b)
+#define Q_INTERFACES(a)
+#define Q_GADGET
+#define Q_OVERRIDE(a)
+#define Q_OS_OS2
+#define Q_NO_USING_KEYWORD
+#define QT_NO_QOBJECT_CHECK
+#define QT_NO_MEMBER_TEMPLATES
+// There are symbols in Qt that exist in Debug but
+// not in release
+#define QT_NO_DEBUG
+
diff --git a/ApiExtractor/parser/rpp/pp-scanner.h b/ApiExtractor/parser/rpp/pp-scanner.h
new file mode 100644
index 000000000..e97b15843
--- /dev/null
+++ b/ApiExtractor/parser/rpp/pp-scanner.h
@@ -0,0 +1,313 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef PP_SCANNER_H
+#define PP_SCANNER_H
+
+#include "pp-cctype.h"
+#include <cassert>
+
+namespace rpp
+{
+
+struct pp_skip_blanks {
+    int lines;
+
+    template <typename _InputIterator>
+    _InputIterator operator()(_InputIterator __first, _InputIterator __last) {
+        lines = 0;
+
+        for (; __first != __last; lines += (*__first != '\n' ? 0 : 1), ++__first) {
+            if (*__first == '\\') {
+                _InputIterator __begin = __first;
+                ++__begin;
+
+                if (__begin != __last && *__begin == '\n')
+                    ++__first;
+                else
+                    break;
+            } else if (*__first == '\n' || !pp_isspace(*__first))
+                break;
+        }
+
+        return __first;
+    }
+};
+
+struct pp_skip_whitespaces {
+    int lines;
+
+    template <typename _InputIterator>
+    _InputIterator operator()(_InputIterator __first, _InputIterator __last) {
+        lines = 0;
+
+        for (; __first != __last; lines += (*__first != '\n' ? 0 : 1), ++__first) {
+            if (! pp_isspace(*__first))
+                break;
+        }
+
+        return __first;
+    }
+};
+
+struct pp_skip_comment_or_divop {
+    int lines;
+
+    template <typename _InputIterator>
+    _InputIterator operator()(_InputIterator __first, _InputIterator __last) {
+        enum {
+            MAYBE_BEGIN,
+            BEGIN,
+            MAYBE_END,
+            END,
+            IN_COMMENT,
+            IN_CXX_COMMENT
+        } state(MAYBE_BEGIN);
+
+        lines = 0;
+
+        for (; __first != __last; lines += (*__first != '\n' ? 0 : 1), ++__first) {
+            switch (state) {
+            default:
+                assert(0);
+                break;
+
+            case MAYBE_BEGIN:
+                if (*__first != '/')
+                    return __first;
+
+                state = BEGIN;
+                break;
+
+            case BEGIN:
+                if (*__first == '*')
+                    state = IN_COMMENT;
+                else if (*__first == '/')
+                    state = IN_CXX_COMMENT;
+                else
+                    return __first;
+                break;
+
+            case IN_COMMENT:
+                if (*__first == '*')
+                    state = MAYBE_END;
+                break;
+
+            case IN_CXX_COMMENT:
+                if (*__first == '\n')
+                    return __first;
+                break;
+
+            case MAYBE_END:
+                if (*__first == '/')
+                    state = END;
+                else if (*__first != '*')
+                    state = IN_COMMENT;
+                break;
+
+            case END:
+                return __first;
+            }
+        }
+
+        return __first;
+    }
+};
+
+struct pp_skip_identifier {
+    int lines;
+
+    template <typename _InputIterator>
+    _InputIterator operator()(_InputIterator __first, _InputIterator __last) {
+        lines = 0;
+
+        for (; __first != __last; lines += (*__first != '\n' ? 0 : 1), ++__first) {
+            if (! pp_isalnum(*__first) && *__first != '_')
+                break;
+        }
+
+        return __first;
+    }
+};
+
+struct pp_skip_number {
+    int lines;
+
+    template <typename _InputIterator>
+    _InputIterator operator()(_InputIterator __first, _InputIterator __last) {
+        lines = 0;
+
+        for (; __first != __last; lines += (*__first != '\n' ? 0 : 1), ++__first) {
+            if (! pp_isalnum(*__first) && *__first != '.')
+                break;
+        }
+
+        return __first;
+    }
+};
+
+struct pp_skip_string_literal {
+    int lines;
+
+    template <typename _InputIterator>
+    _InputIterator operator()(_InputIterator __first, _InputIterator __last) {
+        enum {
+            BEGIN,
+            IN_STRING,
+            QUOTE,
+            END
+        } state(BEGIN);
+
+        lines = 0;
+
+        for (; __first != __last; lines += (*__first != '\n' ? 0 : 1), ++__first) {
+            switch (state) {
+            default:
+                assert(0);
+                break;
+
+            case BEGIN:
+                if (*__first != '\"')
+                    return __first;
+                state = IN_STRING;
+                break;
+
+            case IN_STRING:
+                assert(*__first != '\n');
+
+                if (*__first == '\"')
+                    state = END;
+                else if (*__first == '\\')
+                    state = QUOTE;
+                break;
+
+            case QUOTE:
+                state = IN_STRING;
+                break;
+
+            case END:
+                return __first;
+            }
+        }
+
+        return __first;
+    }
+};
+
+struct pp_skip_char_literal {
+    int lines;
+
+    template <typename _InputIterator>
+    _InputIterator operator()(_InputIterator __first, _InputIterator __last) {
+        enum {
+            BEGIN,
+            IN_STRING,
+            QUOTE,
+            END
+        } state(BEGIN);
+
+        lines = 0;
+
+        for (; state != END && __first != __last; lines += (*__first != '\n' ? 0 : 1), ++__first) {
+            switch (state) {
+            default:
+                assert(0);
+                break;
+
+            case BEGIN:
+                if (*__first != '\'')
+                    return __first;
+                state = IN_STRING;
+                break;
+
+            case IN_STRING:
+                assert(*__first != '\n');
+
+                if (*__first == '\'')
+                    state = END;
+                else if (*__first == '\\')
+                    state = QUOTE;
+                break;
+
+            case QUOTE:
+                state = IN_STRING;
+                break;
+            }
+        }
+
+        return __first;
+    }
+};
+
+struct pp_skip_argument {
+    pp_skip_identifier skip_number;
+    pp_skip_identifier skip_identifier;
+    pp_skip_string_literal skip_string_literal;
+    pp_skip_char_literal skip_char_literal;
+    pp_skip_comment_or_divop skip_comment_or_divop;
+    int lines;
+
+    template <typename _InputIterator>
+    _InputIterator operator()(_InputIterator __first, _InputIterator __last) {
+        int depth = 0;
+        lines = 0;
+
+        while (__first != __last) {
+            if (!depth && (*__first == ')' || *__first == ','))
+                break;
+            else if (*__first == '(')
+                ++depth, ++__first;
+            else if (*__first == ')')
+                --depth, ++__first;
+            else if (*__first == '\"') {
+                __first = skip_string_literal(__first, __last);
+                lines += skip_string_literal.lines;
+            } else if (*__first == '\'') {
+                __first = skip_char_literal(__first, __last);
+                lines += skip_char_literal.lines;
+            } else if (*__first == '/') {
+                __first = skip_comment_or_divop(__first, __last);
+                lines += skip_comment_or_divop.lines;
+            } else if (pp_isalpha(*__first) || *__first == '_') {
+                __first = skip_identifier(__first, __last);
+                lines += skip_identifier.lines;
+            } else if (pp_isdigit(*__first)) {
+                __first = skip_number(__first, __last);
+                lines += skip_number.lines;
+            } else if (*__first == '\n') {
+                ++__first;
+                ++lines;
+            } else
+                ++__first;
+        }
+
+        return __first;
+    }
+};
+
+} // namespace rpp
+
+#endif // PP_SCANNER_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/rpp/pp-string.h b/ApiExtractor/parser/rpp/pp-string.h
new file mode 100644
index 000000000..31bca4f7b
--- /dev/null
+++ b/ApiExtractor/parser/rpp/pp-string.h
@@ -0,0 +1,107 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef PP_STRING_H
+#define PP_STRING_H
+
+namespace rpp
+{
+
+template <typename _CharT>
+class pp_string
+{
+    typedef std::char_traits<_CharT> traits_type;
+    typedef std::size_t size_type;
+
+    _CharT const *_M_begin;
+    std::size_t _M_size;
+
+public:
+    inline pp_string():
+            _M_begin(0), _M_size(0) {}
+
+    explicit pp_string(std::string const &__s):
+            _M_begin(__s.c_str()), _M_size(__s.size()) {}
+
+    inline pp_string(_CharT const *__begin, std::size_t __size):
+            _M_begin(__begin), _M_size(__size) {}
+
+    inline _CharT const *begin() const {
+        return _M_begin;
+    }
+    inline _CharT const *end() const {
+        return _M_begin + _M_size;
+    }
+
+    inline _CharT at(std::size_t index) const {
+        return _M_begin [index];
+    }
+
+    inline std::size_t size() const {
+        return _M_size;
+    }
+
+    inline int compare(pp_string const &__other) const {
+        size_type const __size = this->size();
+        size_type const __osize = __other.size();
+        size_type const __len = std::min(__size,  __osize);
+
+        int __r = traits_type::compare(_M_begin, __other._M_begin, __len);
+        if (!__r)
+            __r = (int)(__size - __osize);
+
+        return __r;
+    }
+
+    inline bool operator == (pp_string const &__other) const {
+        return compare(__other) == 0;
+    }
+
+    inline bool operator != (pp_string const &__other) const {
+        return compare(__other) != 0;
+    }
+
+    inline bool operator < (pp_string const &__other) const {
+        return compare(__other) < 0;
+    }
+
+    inline bool operator == (char const *s) const {
+        std::size_t n = strlen(s);
+
+        if (n != _M_size)
+            return false;
+
+        return ! strncmp(_M_begin, s, n);
+    }
+
+    inline bool operator != (char const *s) const {
+        return ! operator == (s);
+    }
+};
+
+} // namespace rpp
+
+#endif // PP_STRING_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/rpp/pp-symbol.h b/ApiExtractor/parser/rpp/pp-symbol.h
new file mode 100644
index 000000000..8078aba8c
--- /dev/null
+++ b/ApiExtractor/parser/rpp/pp-symbol.h
@@ -0,0 +1,92 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef PP_SYMBOL_H
+#define PP_SYMBOL_H
+
+#include <cassert>
+#include <iterator>
+#include "pp-fwd.h"
+#include "parser/rxx_allocator.h"
+
+namespace rpp
+{
+
+class pp_symbol
+{
+    static rxx_allocator<char> &allocator_instance() {
+        static rxx_allocator<char>__allocator;
+        return __allocator;
+    }
+    static rxx_allocator<pp_fast_string> &ppfs_allocator_instance ()
+    {
+        static rxx_allocator<pp_fast_string>__ppfs_allocator;
+        return __ppfs_allocator;
+    }
+
+public:
+    static int &N() {
+        static int __N;
+        return __N;
+    }
+
+    static pp_fast_string const *get(char const *__data, std::size_t __size) {
+        ++N();
+        char *data = allocator_instance().allocate(__size + 1);
+        memcpy(data, __data, __size);
+        data[__size] = '\0';
+
+        pp_fast_string *where = ppfs_allocator_instance ().allocate (sizeof (pp_fast_string));
+        return new(where) pp_fast_string(data, __size);
+    }
+
+    template <typename _InputIterator>
+    static pp_fast_string const *get(_InputIterator __first, _InputIterator __last) {
+        ++N();
+        std::ptrdiff_t __size;
+#if defined(__SUNPRO_CC)
+        std::distance(__first, __last, __size);
+#else
+        __size = std::distance(__first, __last);
+#endif
+        assert(__size >= 0 && __size < 512);
+
+        char *data = allocator_instance().allocate(__size + 1);
+        std::copy(__first, __last, data);
+        data[__size] = '\0';
+
+        pp_fast_string *where = ppfs_allocator_instance ().allocate (sizeof (pp_fast_string));
+        return new(where) pp_fast_string(data, __size);
+    }
+
+    static pp_fast_string const *get(std::string const &__s) {
+        return get(__s.c_str(), __s.size());
+    }
+};
+
+} // namespace rpp
+
+#endif // PP_SYMBOL_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/rpp/pp.h b/ApiExtractor/parser/rpp/pp.h
new file mode 100644
index 000000000..3ff38c0d1
--- /dev/null
+++ b/ApiExtractor/parser/rpp/pp.h
@@ -0,0 +1,91 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef PP_H
+#define PP_H
+
+#if defined(_WIN64) || defined(WIN64) || defined(__WIN64__) \
+    || defined(_WIN32) || defined(WIN32) || defined(__WIN32__)
+#  define PP_OS_WIN
+#endif
+
+#include <set>
+#include <map>
+#include <vector>
+#include <string>
+#include <iterator>
+#include <iostream>
+#include <cassert>
+#include <cctype>
+#include <cstdio>
+
+#include <fcntl.h>
+
+#ifdef HAVE_MMAP
+#  include <sys/mman.h>
+#endif
+
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#if (_MSC_VER >= 1400)
+#  define FILENO _fileno
+#else
+#  define FILENO fileno
+#endif
+
+#if defined (PP_OS_WIN)
+#  define PATH_SEPARATOR '\\'
+#else
+#  define PATH_SEPARATOR '/'
+#endif
+
+#if defined (RPP_JAMBI)
+#  include "parser/rxx_allocator.h"
+#else
+#  include "parser/rpp-allocator.h"
+#endif
+
+#if defined (_MSC_VER)
+#  define pp_snprintf _snprintf
+#else
+#  define pp_snprintf snprintf
+#endif
+
+#include "pp-fwd.h"
+#include "pp-cctype.h"
+#include "pp-string.h"
+#include "pp-symbol.h"
+#include "pp-internal.h"
+#include "pp-iterator.h"
+#include "pp-macro.h"
+#include "pp-environment.h"
+#include "pp-scanner.h"
+#include "pp-macro-expander.h"
+#include "pp-engine.h"
+#include "pp-engine-bits.h"
+
+#endif // PP_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/rpp/preprocessor.cpp b/ApiExtractor/parser/rpp/preprocessor.cpp
new file mode 100644
index 000000000..9a4f8b04a
--- /dev/null
+++ b/ApiExtractor/parser/rpp/preprocessor.cpp
@@ -0,0 +1,159 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright 2005 Harald Fernengel <harry@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "preprocessor.h"
+
+#include <string>
+#include <cstdio>
+
+// register callback for include hooks
+static void includeFileHook(const std::string &, const std::string &, FILE *);
+
+#define PP_HOOK_ON_FILE_INCLUDED(A, B, C) includeFileHook(A, B, C)
+#include "pp.h"
+
+using namespace rpp;
+
+#include <QtCore/QtCore>
+
+class PreprocessorPrivate
+{
+public:
+    QByteArray result;
+    pp_environment env;
+    QStringList includePaths;
+
+    void initPP(pp &proc) {
+        foreach(QString path, includePaths)
+        proc.push_include_path(path.toStdString());
+    }
+};
+
+QHash<QString, QStringList> includedFiles;
+
+void includeFileHook(const std::string &fileName, const std::string &filePath, FILE *)
+{
+    includedFiles[QString::fromStdString(fileName)].append(QString::fromStdString(filePath));
+}
+
+Preprocessor::Preprocessor()
+{
+    d = new PreprocessorPrivate;
+    includedFiles.clear();
+}
+
+Preprocessor::~Preprocessor()
+{
+    delete d;
+}
+
+void Preprocessor::processFile(const QString &fileName)
+{
+    pp proc(d->env);
+    d->initPP(proc);
+
+    d->result.reserve(d->result.size() + 20 * 1024);
+
+    d->result += "# 1 \"" + fileName.toLatin1() + "\"\n"; // ### REMOVE ME
+    proc.file(fileName.toLocal8Bit().constData(), std::back_inserter(d->result));
+}
+
+void Preprocessor::processString(const QByteArray &str)
+{
+    pp proc(d->env);
+    d->initPP(proc);
+
+    proc(str.begin(), str.end(), std::back_inserter(d->result));
+}
+
+QByteArray Preprocessor::result() const
+{
+    return d->result;
+}
+
+void Preprocessor::addIncludePaths(const QStringList &includePaths)
+{
+    d->includePaths += includePaths;
+}
+
+QStringList Preprocessor::macroNames() const
+{
+    QStringList macros;
+
+    pp_environment::const_iterator it = d->env.first_macro();
+    while (it != d->env.last_macro()) {
+        const pp_macro *m = *it;
+        macros += QString::fromLatin1(m->name->begin(), m->name->size());
+        ++it;
+    }
+
+    return macros;
+}
+
+QList<Preprocessor::MacroItem> Preprocessor::macros() const
+{
+    QList<MacroItem> items;
+
+    pp_environment::const_iterator it = d->env.first_macro();
+    while (it != d->env.last_macro()) {
+        const pp_macro *m = *it;
+        MacroItem item;
+        item.name = QString::fromLatin1(m->name->begin(), m->name->size());
+        item.definition = QString::fromLatin1(m->definition->begin(),
+                                              m->definition->size());
+        for (size_t i = 0; i < m->formals.size(); ++i) {
+            item.parameters += QString::fromLatin1(m->formals[i]->begin(),
+                                                   m->formals[i]->size());
+        }
+        item.isFunctionLike = m->function_like;
+
+#ifdef PP_WITH_MACRO_POSITION
+        item.fileName = QString::fromLatin1(m->file->begin(), m->file->size());
+#endif
+        items += item;
+
+        ++it;
+    }
+
+    return items;
+}
+
+/*
+int main()
+{
+    Preprocessor pp;
+
+    QStringList paths;
+    paths << "/usr/include";
+    pp.addIncludePaths(paths);
+
+    pp.processFile("pp-configuration");
+    pp.processFile("/usr/include/stdio.h");
+
+    qDebug() << pp.result();
+
+    return 0;
+}
+*/
+
diff --git a/ApiExtractor/parser/rpp/preprocessor.h b/ApiExtractor/parser/rpp/preprocessor.h
new file mode 100644
index 000000000..c363ea7c8
--- /dev/null
+++ b/ApiExtractor/parser/rpp/preprocessor.h
@@ -0,0 +1,66 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright 2005 Harald Fernengel <harry@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef PREPROCESSOR_H
+#define PREPROCESSOR_H
+
+#include <QtCore/qglobal.h>
+#include <QtCore/qstring.h>
+#include <QtCore/qstringlist.h>
+
+class QByteArray;
+class PreprocessorPrivate;
+
+class Preprocessor
+{
+public:
+    Preprocessor();
+    ~Preprocessor();
+
+    void processFile(const QString &fileName);
+    void processString(const QByteArray &str);
+
+    void addIncludePaths(const QStringList &includePaths);
+
+    QByteArray result() const;
+
+    QStringList macroNames() const;
+
+    struct MacroItem {
+        QString name;
+        QStringList parameters;
+        QString definition;
+        bool isFunctionLike;
+#ifdef PP_WITH_MACRO_POSITION
+        QString fileName;
+#endif
+    };
+    QList<MacroItem> macros() const;
+
+private:
+    Q_DISABLE_COPY(Preprocessor)
+    PreprocessorPrivate *d;
+};
+
+#endif
diff --git a/ApiExtractor/parser/rxx_allocator.h b/ApiExtractor/parser/rxx_allocator.h
new file mode 100644
index 000000000..8325edbdf
--- /dev/null
+++ b/ApiExtractor/parser/rxx_allocator.h
@@ -0,0 +1,146 @@
+/* This file is part of KDevelop
+    Copyright 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License version 2 as published by the Free Software Foundation.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+
+#ifndef RXX_ALLOCATOR_H
+#define RXX_ALLOCATOR_H
+
+#include <cstddef>
+#include <cstdlib>
+#include <string.h>
+#include <memory>
+
+// Stride calculation
+template <typename T>
+struct Tchar {
+  T t;
+  char c;
+};
+
+#define strideof(T)                            \
+  ((sizeof(Tchar<T>) > sizeof(T)) ?            \
+  sizeof(Tchar<T>)-sizeof(T) : sizeof(T))
+
+
+/**The allocator which uses fixed size blocks for allocation of its elements.
+Block size is currently 64k, allocated space is not reclaimed,
+if the size of the element being allocated extends the amount of free
+memory in the block then a new block is allocated.
+
+The allocator supports standard c++ library interface but does not
+make use of allocation hints.
+*/
+template <class _Tp> class rxx_allocator {
+public:
+  typedef _Tp value_type;
+  typedef _Tp* pointer;
+  typedef const _Tp* const_pointer;
+  typedef _Tp& reference;
+  typedef const _Tp& const_reference;
+  typedef std::size_t size_type;
+  typedef std::ptrdiff_t difference_type;
+
+  static const size_type max_block_count = size_type(-1);
+  static const size_type _S_block_size = 1 << 16; // 64K
+
+  rxx_allocator() {
+    init();
+  }
+
+  rxx_allocator(const rxx_allocator &/*__o*/) {
+    init();
+  }
+
+  ~rxx_allocator() {
+    for (size_type index = 0; index < _M_block_index + 1; ++index)
+      delete[] _M_storage[index];
+
+    ::free(_M_storage);
+  }
+
+  pointer address(reference __val) { return &__val; }
+  const_pointer address(const_reference __val) const { return &__val; }
+
+  /**Allocates @p __n elements continuosly in the pool. Warning! no
+  check is done to check if the size of those @p __n elements
+  fit into the block. You should assure you do not allocate more
+  than the size of a block.*/
+  pointer allocate(size_type __n, const void* = 0) {
+    const size_type bytes = __n * sizeof(_Tp);
+
+    if (_M_current_block == 0
+	|| _S_block_size < _M_current_index + bytes)
+      {
+	++_M_block_index;
+
+	_M_storage = reinterpret_cast<char**>
+	  (::realloc(_M_storage, sizeof(char*) * (1 + _M_block_index)));
+
+	_M_current_block = _M_storage[_M_block_index] = reinterpret_cast<char*>
+	  (new char[_S_block_size]);
+
+	::memset(_M_current_block, 0, _S_block_size);
+	_M_current_index = 0;
+      }
+
+    pointer p = reinterpret_cast<pointer>
+      (_M_current_block + _M_current_index);
+
+    _M_current_index += bytes;
+
+    return p;
+  }
+
+  pointer allocate(size_type __n, size_type stride, const void* = 0) {
+    if (reinterpret_cast<size_type>(_M_current_block + _M_current_index) % stride > 0)
+      _M_current_index += stride - reinterpret_cast<size_type>(_M_current_block + _M_current_index) % stride;
+    return allocate(__n);
+  }
+
+  /**Deallocate does nothing in this implementation.*/
+  void deallocate(pointer /*__p*/, size_type /*__n*/) {}
+
+  size_type max_size() const { return size_type(-1) / sizeof(_Tp); }
+
+  void construct(pointer __p, const_reference __val) { new (__p) _Tp(__val); }
+  void destroy(pointer __p) { __p->~_Tp(); }
+
+  template <class _Tp1> struct rebind {
+    typedef rxx_allocator<_Tp1> other;
+  };
+
+private:
+
+  void init()
+  {
+    _M_block_index = max_block_count;
+    _M_current_index = 0;
+    _M_storage = 0;
+    _M_current_block = 0;
+  }
+
+  template <class _Tp1> rxx_allocator(const rxx_allocator<_Tp1> &__o) {}
+
+private:
+  size_type _M_block_index;
+  size_type _M_current_index;
+  char *_M_current_block;
+  char **_M_storage;
+};
+
+#endif // RXX_ALLOCATOR_H
+
diff --git a/ApiExtractor/parser/smallobject.cpp b/ApiExtractor/parser/smallobject.cpp
new file mode 100644
index 000000000..e96d417c6
--- /dev/null
+++ b/ApiExtractor/parser/smallobject.cpp
@@ -0,0 +1,28 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#include "smallobject.h"
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/smallobject.h b/ApiExtractor/parser/smallobject.h
new file mode 100644
index 000000000..a9eb4990b
--- /dev/null
+++ b/ApiExtractor/parser/smallobject.h
@@ -0,0 +1,53 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef SMALLOBJECT_H
+#define SMALLOBJECT_H
+
+#include "rxx_allocator.h"
+#include <cstring>
+
+class pool
+{
+    rxx_allocator<char> __alloc;
+
+public:
+    inline void *allocate(std::size_t __size);
+    inline void *allocate(std::size_t __size, std::size_t __stride);
+};
+
+inline void *pool::allocate(std::size_t __size)
+{
+    return __alloc.allocate(__size);
+}
+
+inline void *pool::allocate(std::size_t __size, std::size_t __stride)
+{
+  return __alloc.allocate(__size, __stride);
+}
+
+#endif
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/symbol.h b/ApiExtractor/parser/symbol.h
new file mode 100644
index 000000000..8e393cddb
--- /dev/null
+++ b/ApiExtractor/parser/symbol.h
@@ -0,0 +1,122 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef SYMBOL_H
+#define SYMBOL_H
+
+#include <QtCore/QString>
+#include <cstring>
+
+#include <QtCore/QHash>
+#include <QtCore/QPair>
+
+struct NameSymbol
+{
+    const char *data;
+    std::size_t count;
+
+    inline QString as_string() const
+    {
+        return QString::fromUtf8(data, (int) count);
+    }
+
+    inline bool operator == (const NameSymbol &other) const
+    {
+        return count == other.count
+               && !std::strncmp(data, other.data, count);
+    }
+
+protected:
+    inline NameSymbol() {}
+    inline NameSymbol(const char *d, std::size_t c)
+            : data(d), count(c) {}
+
+private:
+    void operator = (const NameSymbol &);
+
+    friend class NameTable;
+};
+
+inline uint qHash(const NameSymbol &r)
+{
+    uint hash_value = 0;
+
+    for (std::size_t i = 0; i < r.count; ++i)
+        hash_value = (hash_value << 5) - hash_value + r.data[i];
+
+    return hash_value;
+}
+
+inline uint qHash(const QPair<const char*, std::size_t> &r)
+{
+    uint hash_value = 0;
+
+    for (std::size_t i = 0; i < r.second; ++i)
+        hash_value = (hash_value << 5) - hash_value + r.first[i];
+
+    return hash_value;
+}
+
+class NameTable
+{
+public:
+    typedef QPair<const char *, std::size_t> KeyType;
+    typedef QHash<KeyType, NameSymbol*> ContainerType;
+
+public:
+    NameTable() {}
+
+    ~NameTable()
+    {
+        qDeleteAll(_M_storage);
+    }
+
+    inline const NameSymbol *findOrInsert(const char *str, std::size_t len)
+    {
+        KeyType key(str, len);
+
+        NameSymbol *name = _M_storage.value(key);
+        if (!name) {
+            name = new NameSymbol(str, len);
+            _M_storage.insert(key, name);
+        }
+
+        return name;
+    }
+
+    inline std::size_t count() const { return _M_storage.size(); }
+
+private:
+    ContainerType _M_storage;
+
+private:
+    NameTable(const NameTable &other);
+    void operator=(const NameTable &other);
+};
+
+#endif // SYMBOL_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
+
diff --git a/ApiExtractor/parser/tokens.cpp b/ApiExtractor/parser/tokens.cpp
new file mode 100644
index 000000000..2e054d894
--- /dev/null
+++ b/ApiExtractor/parser/tokens.cpp
@@ -0,0 +1,249 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#include <QtCore/qglobal.h>
+
+#include "tokens.h"
+
+static char const * const _S_token_names[] = {
+    "K_DCOP",
+    "Q_OBJECT",
+    "Q_PROPERTY",
+    "__attribute__",
+    "__typeof",
+    "and",
+    "and_eq",
+    "arrow",
+    "asm",
+    "assign",
+    "auto",
+    "bitand",
+    "bitor",
+    "bool",
+    "break",
+    "case",
+    "catch",
+    "char",
+    "char_literal",
+    "class",
+    "comment",
+    "compl",
+    "concat",
+    "const",
+    "const_cast",
+    "continue",
+    "decr",
+    "default",
+    "delete",
+    "do",
+    "double",
+    "dynamic_cast",
+    "ellipsis",
+    "else",
+    "emit",
+    "enum",
+    "eq",
+    "explicit",
+    "export",
+    "extern",
+    "false",
+    "float",
+    "for",
+    "friend",
+    "geq",
+    "goto",
+    "identifier",
+    "if",
+    "incr",
+    "inline",
+    "int",
+    "k_dcop",
+    "k_dcop_signals",
+    "leq",
+    "long",
+    "mutable",
+    "namespace",
+    "new",
+    "not",
+    "not_eq",
+    "number_literal",
+    "operator",
+    "or",
+    "or_eq",
+    "preproc",
+    "private",
+    "protected",
+    "ptrmem",
+    "public",
+    "register",
+    "reinterpret_cast",
+    "return",
+    "scope",
+    "shift",
+    "short",
+    "signals",
+    "signed",
+    "sizeof",
+    "slots",
+    "static",
+    "static_cast",
+    "string_literal",
+    "struct",
+    "switch",
+    "template",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typedef",
+    "typeid",
+    "typename",
+    "union",
+    "unsigned",
+    "using",
+    "virtual",
+    "void",
+    "volatile",
+    "wchar_t",
+    "while",
+    "whitespaces",
+    "xor",
+    "xor_eq",
+    "Q_ENUMS"
+};
+
+static char _S_printable[][2] = {
+    { char(32), '\0' },
+    { char(33), '\0' },
+    { char(34), '\0' },
+    { char(35), '\0' },
+    { char(36), '\0' },
+    { char(37), '\0' },
+    { char(38), '\0' },
+    { char(39), '\0' },
+    { char(40), '\0' },
+    { char(41), '\0' },
+    { char(42), '\0' },
+    { char(43), '\0' },
+    { char(44), '\0' },
+    { char(45), '\0' },
+    { char(46), '\0' },
+    { char(47), '\0' },
+    { char(48), '\0' },
+    { char(49), '\0' },
+    { char(50), '\0' },
+    { char(51), '\0' },
+    { char(52), '\0' },
+    { char(53), '\0' },
+    { char(54), '\0' },
+    { char(55), '\0' },
+    { char(56), '\0' },
+    { char(57), '\0' },
+    { char(58), '\0' },
+    { char(59), '\0' },
+    { char(60), '\0' },
+    { char(61), '\0' },
+    { char(62), '\0' },
+    { char(63), '\0' },
+    { char(64), '\0' },
+    { char(65), '\0' },
+    { char(66), '\0' },
+    { char(67), '\0' },
+    { char(68), '\0' },
+    { char(69), '\0' },
+    { char(70), '\0' },
+    { char(71), '\0' },
+    { char(72), '\0' },
+    { char(73), '\0' },
+    { char(74), '\0' },
+    { char(75), '\0' },
+    { char(76), '\0' },
+    { char(77), '\0' },
+    { char(78), '\0' },
+    { char(79), '\0' },
+    { char(80), '\0' },
+    { char(81), '\0' },
+    { char(82), '\0' },
+    { char(83), '\0' },
+    { char(84), '\0' },
+    { char(85), '\0' },
+    { char(86), '\0' },
+    { char(87), '\0' },
+    { char(88), '\0' },
+    { char(89), '\0' },
+    { char(90), '\0' },
+    { char(91), '\0' },
+    { char(92), '\0' },
+    { char(93), '\0' },
+    { char(94), '\0' },
+    { char(95), '\0' },
+    { char(96), '\0' },
+    { char(97), '\0' },
+    { char(98), '\0' },
+    { char(99), '\0' },
+    { char(100), '\0' },
+    { char(101), '\0' },
+    { char(102), '\0' },
+    { char(103), '\0' },
+    { char(104), '\0' },
+    { char(105), '\0' },
+    { char(106), '\0' },
+    { char(107), '\0' },
+    { char(108), '\0' },
+    { char(109), '\0' },
+    { char(110), '\0' },
+    { char(111), '\0' },
+    { char(112), '\0' },
+    { char(113), '\0' },
+    { char(114), '\0' },
+    { char(115), '\0' },
+    { char(116), '\0' },
+    { char(117), '\0' },
+    { char(118), '\0' },
+    { char(119), '\0' },
+    { char(120), '\0' },
+    { char(121), '\0' },
+    { char(122), '\0' },
+    { char(123), '\0' },
+    { char(124), '\0' },
+    { char(125), '\0' },
+    { char(126), '\0' },
+    { char(127), '\0' },
+};
+
+char const *token_name(int token)
+{
+    if (token == 0)
+        return "eof";
+    else if (token >= 32 && token <= 127)
+        return _S_printable[token - 32];
+    else if (token >= 1000)
+        return _S_token_names[token - 1000];
+
+    Q_ASSERT(0);
+    return 0;
+}
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/tokens.h b/ApiExtractor/parser/tokens.h
new file mode 100644
index 000000000..257ff0992
--- /dev/null
+++ b/ApiExtractor/parser/tokens.h
@@ -0,0 +1,145 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef TOKENS_H
+#define TOKENS_H
+
+enum TOKEN_KIND {
+    Token_EOF = 0,
+
+    Token_K_DCOP = 1000,
+    Token_Q_OBJECT,
+    Token_Q_PROPERTY,
+    Token___attribute__,
+    Token___typeof,
+    Token_and,
+    Token_and_eq,
+    Token_arrow,
+    Token_asm,
+    Token_assign,
+    Token_auto,
+    Token_bitand,
+    Token_bitor,
+    Token_bool,
+    Token_break,
+    Token_case,
+    Token_catch,
+    Token_char,
+    Token_char_literal,
+    Token_class,
+    Token_comment,
+    Token_compl,
+    Token_concat,
+    Token_const,
+    Token_const_cast,
+    Token_continue,
+    Token_decr,
+    Token_default,
+    Token_delete,
+    Token_do,
+    Token_double,
+    Token_dynamic_cast,
+    Token_ellipsis,
+    Token_else,
+    Token_emit,
+    Token_enum,
+    Token_eq,
+    Token_explicit,
+    Token_export,
+    Token_extern,
+    Token_false,
+    Token_float,
+    Token_for,
+    Token_friend,
+    Token_geq,
+    Token_goto,
+    Token_identifier,
+    Token_if,
+    Token_incr,
+    Token_inline,
+    Token_int,
+    Token_k_dcop,
+    Token_k_dcop_signals,
+    Token_leq,
+    Token_long,
+    Token_mutable,
+    Token_namespace,
+    Token_new,
+    Token_not,
+    Token_not_eq,
+    Token_number_literal,
+    Token_operator,
+    Token_or,
+    Token_or_eq,
+    Token_preproc,
+    Token_private,
+    Token_protected,
+    Token_ptrmem,
+    Token_public,
+    Token_register,
+    Token_reinterpret_cast,
+    Token_return,
+    Token_scope,
+    Token_shift,
+    Token_short,
+    Token_signals,
+    Token_signed,
+    Token_sizeof,
+    Token_slots,
+    Token_static,
+    Token_static_cast,
+    Token_string_literal,
+    Token_struct,
+    Token_switch,
+    Token_template,
+    Token_this,
+    Token_throw,
+    Token_true,
+    Token_try,
+    Token_typedef,
+    Token_typeid,
+    Token_typename,
+    Token_union,
+    Token_unsigned,
+    Token_using,
+    Token_virtual,
+    Token_void,
+    Token_volatile,
+    Token_wchar_t,
+    Token_while,
+    Token_whitespaces,
+    Token_xor,
+    Token_xor_eq,
+    Token_Q_ENUMS,
+    Token_Q_INVOKABLE,
+
+    TOKEN_KIND_COUNT
+};
+
+char const *token_name(int token);
+
+#endif
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/type_compiler.cpp b/ApiExtractor/parser/type_compiler.cpp
new file mode 100644
index 000000000..4bcdb277a
--- /dev/null
+++ b/ApiExtractor/parser/type_compiler.cpp
@@ -0,0 +1,129 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+
+
+#include "type_compiler.h"
+#include "name_compiler.h"
+#include "lexer.h"
+#include "symbol.h"
+#include "tokens.h"
+#include "binder.h"
+
+#include <QtCore/QString>
+
+TypeCompiler::TypeCompiler(Binder *binder)
+        : _M_binder(binder), _M_token_stream(binder->tokenStream())
+{
+}
+
+void TypeCompiler::run(TypeSpecifierAST *node)
+{
+    _M_type.clear();
+    _M_cv.clear();
+
+    visit(node);
+
+    if (node && node->cv) {
+        const ListNode<std::size_t> *it = node->cv->toFront();
+        const ListNode<std::size_t> *end = it;
+        do {
+            int kind = _M_token_stream->kind(it->element);
+            if (!_M_cv.contains(kind))
+                _M_cv.append(kind);
+
+            it = it->next;
+        } while (it != end);
+    }
+}
+
+void TypeCompiler::visitClassSpecifier(ClassSpecifierAST *node)
+{
+    visit(node->name);
+}
+
+void TypeCompiler::visitEnumSpecifier(EnumSpecifierAST *node)
+{
+    visit(node->name);
+}
+
+void TypeCompiler::visitElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST *node)
+{
+    visit(node->name);
+}
+
+void TypeCompiler::visitSimpleTypeSpecifier(SimpleTypeSpecifierAST *node)
+{
+    if (const ListNode<std::size_t> *it = node->integrals) {
+        it = it->toFront();
+        const ListNode<std::size_t> *end = it;
+        QString current_item;
+        do {
+            std::size_t token = it->element;
+            current_item += token_name(_M_token_stream->kind(token));
+            current_item += " ";
+            it = it->next;
+        } while (it != end);
+        _M_type += current_item.trimmed();
+    } else if (node->type_of) {
+        // ### implement me
+        _M_type += QLatin1String("typeof<...>");
+    }
+
+    visit(node->name);
+}
+
+void TypeCompiler::visitName(NameAST *node)
+{
+    NameCompiler name_cc(_M_binder);
+    name_cc.run(node);
+    _M_type = name_cc.qualifiedName();
+}
+
+QStringList TypeCompiler::cvString() const
+{
+    QStringList lst;
+
+    foreach (int q, cv()) {
+        if (q == Token_const)
+            lst.append(QLatin1String("const"));
+        else if (q == Token_volatile)
+            lst.append(QLatin1String("volatile"));
+    }
+
+    return lst;
+}
+
+bool TypeCompiler::isConstant() const
+{
+    return _M_cv.contains(Token_const);
+}
+
+bool TypeCompiler::isVolatile() const
+{
+    return _M_cv.contains(Token_volatile);
+}
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/type_compiler.h b/ApiExtractor/parser/type_compiler.h
new file mode 100644
index 000000000..985cc8e2e
--- /dev/null
+++ b/ApiExtractor/parser/type_compiler.h
@@ -0,0 +1,71 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef TYPE_COMPILER_H
+#define TYPE_COMPILER_H
+
+#include "default_visitor.h"
+
+#include <QtCore/QString>
+#include <QtCore/QStringList>
+#include <QtCore/QList>
+
+class TokenStream;
+class Binder;
+
+class TypeCompiler: protected DefaultVisitor
+{
+public:
+    TypeCompiler(Binder *binder);
+
+    inline QStringList qualifiedName() const { return _M_type; }
+    inline QList<int> cv() const { return _M_cv; }
+
+    bool isConstant() const;
+    bool isVolatile() const;
+
+    QStringList cvString() const;
+
+    void run(TypeSpecifierAST *node);
+
+protected:
+    virtual void visitClassSpecifier(ClassSpecifierAST *node);
+    virtual void visitEnumSpecifier(EnumSpecifierAST *node);
+    virtual void visitElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST *node);
+    virtual void visitSimpleTypeSpecifier(SimpleTypeSpecifierAST *node);
+
+    virtual void visitName(NameAST *node);
+
+private:
+    Binder *_M_binder;
+    TokenStream *_M_token_stream;
+    QStringList _M_type;
+    QList<int> _M_cv;
+};
+
+#endif // TYPE_COMPILER_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
+
diff --git a/ApiExtractor/parser/visitor.cpp b/ApiExtractor/parser/visitor.cpp
new file mode 100644
index 000000000..742981414
--- /dev/null
+++ b/ApiExtractor/parser/visitor.cpp
@@ -0,0 +1,122 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#include "visitor.h"
+
+Visitor::visitor_fun_ptr Visitor::_S_table[AST::NODE_KIND_COUNT] = {
+    0,
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitAccessSpecifier),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitAsmDefinition),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitBaseClause),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitBaseSpecifier),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitBinaryExpression),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitCastExpression),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitClassMemberAccess),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitClassSpecifier),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitCompoundStatement),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitCondition),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitConditionalExpression),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitCppCastExpression),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitCtorInitializer),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitDeclarationStatement),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitDeclarator),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitDeleteExpression),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitDoStatement),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitElaboratedTypeSpecifier),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitEnumSpecifier),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitEnumerator),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitExceptionSpecification),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitExpressionOrDeclarationStatement),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitExpressionStatement),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitForStatement),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitFunctionCall),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitFunctionDefinition),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitIfStatement),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitIncrDecrExpression),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitInitDeclarator),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitInitializer),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitInitializerClause),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitLabeledStatement),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitLinkageBody),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitLinkageSpecification),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitMemInitializer),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitName),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitNamespace),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitNamespaceAliasDefinition),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitNewDeclarator),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitNewExpression),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitNewInitializer),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitNewTypeId),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitOperator),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitOperatorFunctionId),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitParameterDeclaration),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitParameterDeclarationClause),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitPostfixExpression),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitPrimaryExpression),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitPtrOperator),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitPtrToMember),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitReturnStatement),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitSimpleDeclaration),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitSimpleTypeSpecifier),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitSizeofExpression),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitStringLiteral),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitSubscriptExpression),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitSwitchStatement),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTemplateArgument),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTemplateDeclaration),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTemplateParameter),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitThrowExpression),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTranslationUnit),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTryBlockStatement),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTypeId),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTypeIdentification),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTypeParameter),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTypedef),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitUnaryExpression),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitUnqualifiedName),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitUsing),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitUsingDirective),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitWhileStatement),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitWinDeclSpec),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitQProperty),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitForwardDeclarationSpecifier),
+    reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitQEnums)
+};
+
+Visitor::Visitor()
+{
+}
+
+Visitor::~Visitor()
+{
+}
+
+void Visitor::visit(AST *node)
+{
+    if (node)
+        (this->*_S_table[node->kind])(node);
+}
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/parser/visitor.h b/ApiExtractor/parser/visitor.h
new file mode 100644
index 000000000..74edcca83
--- /dev/null
+++ b/ApiExtractor/parser/visitor.h
@@ -0,0 +1,140 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+#ifndef VISITOR_H
+#define VISITOR_H
+
+#include "ast.h"
+
+class Visitor
+{
+public:
+    Visitor();
+    virtual ~Visitor();
+
+    virtual void visit(AST *node);
+
+protected:
+    virtual void visitAccessSpecifier(AccessSpecifierAST *) {}
+    virtual void visitAsmDefinition(AsmDefinitionAST *) {}
+    virtual void visitBaseClause(BaseClauseAST *) {}
+    virtual void visitBaseSpecifier(BaseSpecifierAST *) {}
+    virtual void visitBinaryExpression(BinaryExpressionAST *) {}
+    virtual void visitCastExpression(CastExpressionAST *) {}
+    virtual void visitClassMemberAccess(ClassMemberAccessAST *) {}
+    virtual void visitClassSpecifier(ClassSpecifierAST *) {}
+    virtual void visitCompoundStatement(CompoundStatementAST *) {}
+    virtual void visitCondition(ConditionAST *) {}
+    virtual void visitConditionalExpression(ConditionalExpressionAST *) {}
+    virtual void visitCppCastExpression(CppCastExpressionAST *) {}
+    virtual void visitCtorInitializer(CtorInitializerAST *) {}
+    virtual void visitDeclarationStatement(DeclarationStatementAST *) {}
+    virtual void visitDeclarator(DeclaratorAST *) {}
+    virtual void visitDeleteExpression(DeleteExpressionAST *) {}
+    virtual void visitDoStatement(DoStatementAST *) {}
+    virtual void visitElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST *) {}
+    virtual void visitEnumSpecifier(EnumSpecifierAST *) {}
+    virtual void visitEnumerator(EnumeratorAST *) {}
+    virtual void visitExceptionSpecification(ExceptionSpecificationAST *) {}
+    virtual void visitExpressionOrDeclarationStatement(ExpressionOrDeclarationStatementAST *) {}
+    virtual void visitExpressionStatement(ExpressionStatementAST *) {}
+    virtual void visitForStatement(ForStatementAST *) {}
+    virtual void visitFunctionCall(FunctionCallAST *) {}
+    virtual void visitFunctionDefinition(FunctionDefinitionAST *) {}
+    virtual void visitIfStatement(IfStatementAST *) {}
+    virtual void visitIncrDecrExpression(IncrDecrExpressionAST *) {}
+    virtual void visitInitDeclarator(InitDeclaratorAST *) {}
+    virtual void visitInitializer(InitializerAST *) {}
+    virtual void visitInitializerClause(InitializerClauseAST *) {}
+    virtual void visitLabeledStatement(LabeledStatementAST *) {}
+    virtual void visitLinkageBody(LinkageBodyAST *) {}
+    virtual void visitLinkageSpecification(LinkageSpecificationAST *) {}
+    virtual void visitMemInitializer(MemInitializerAST *) {}
+    virtual void visitName(NameAST *) {}
+    virtual void visitNamespace(NamespaceAST *) {}
+    virtual void visitNamespaceAliasDefinition(NamespaceAliasDefinitionAST *) {}
+    virtual void visitNewDeclarator(NewDeclaratorAST *) {}
+    virtual void visitNewExpression(NewExpressionAST *) {}
+    virtual void visitNewInitializer(NewInitializerAST *) {}
+    virtual void visitNewTypeId(NewTypeIdAST *) {}
+    virtual void visitOperator(OperatorAST *) {}
+    virtual void visitOperatorFunctionId(OperatorFunctionIdAST *) {}
+    virtual void visitParameterDeclaration(ParameterDeclarationAST *) {}
+    virtual void visitParameterDeclarationClause(ParameterDeclarationClauseAST *) {}
+    virtual void visitPostfixExpression(PostfixExpressionAST *) {}
+    virtual void visitPrimaryExpression(PrimaryExpressionAST *) {}
+    virtual void visitPtrOperator(PtrOperatorAST *) {}
+    virtual void visitPtrToMember(PtrToMemberAST *) {}
+    virtual void visitReturnStatement(ReturnStatementAST *) {}
+    virtual void visitSimpleDeclaration(SimpleDeclarationAST *) {}
+    virtual void visitSimpleTypeSpecifier(SimpleTypeSpecifierAST *) {}
+    virtual void visitSizeofExpression(SizeofExpressionAST *) {}
+    virtual void visitStringLiteral(StringLiteralAST *) {}
+    virtual void visitSubscriptExpression(SubscriptExpressionAST *) {}
+    virtual void visitSwitchStatement(SwitchStatementAST *) {}
+    virtual void visitTemplateArgument(TemplateArgumentAST *) {}
+    virtual void visitTemplateDeclaration(TemplateDeclarationAST *) {}
+    virtual void visitTemplateParameter(TemplateParameterAST *) {}
+    virtual void visitThrowExpression(ThrowExpressionAST *) {}
+    virtual void visitTranslationUnit(TranslationUnitAST *) {}
+    virtual void visitTryBlockStatement(TryBlockStatementAST *) {}
+    virtual void visitTypeId(TypeIdAST *) {}
+    virtual void visitTypeIdentification(TypeIdentificationAST *) {}
+    virtual void visitTypeParameter(TypeParameterAST *) {}
+    virtual void visitTypedef(TypedefAST *) {}
+    virtual void visitUnaryExpression(UnaryExpressionAST *) {}
+    virtual void visitUnqualifiedName(UnqualifiedNameAST *) {}
+    virtual void visitUsing(UsingAST *) {}
+    virtual void visitUsingDirective(UsingDirectiveAST *) {}
+    virtual void visitWhileStatement(WhileStatementAST *) {}
+    virtual void visitWinDeclSpec(WinDeclSpecAST *) {}
+    virtual void visitQProperty(QPropertyAST *) {}
+    virtual void visitForwardDeclarationSpecifier(ForwardDeclarationSpecifierAST *) {}
+    virtual void visitQEnums(QEnumsAST *) {}
+
+private:
+    typedef void (Visitor::*visitor_fun_ptr)(AST *);
+    static visitor_fun_ptr _S_table[];
+};
+
+template <class _Tp>
+void visitNodes(Visitor *v, const ListNode<_Tp> *nodes)
+{
+    if (!nodes)
+        return;
+
+    const ListNode<_Tp>
+    *it = nodes->toFront(),
+          *end = it;
+
+    do {
+        v->visit(it->element);
+        it = it->next;
+    } while (it != end);
+}
+
+#endif // VISITOR_H
+
+// kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/ApiExtractor/qtdocparser.cpp b/ApiExtractor/qtdocparser.cpp
new file mode 100644
index 000000000..dd5cbbcd5
--- /dev/null
+++ b/ApiExtractor/qtdocparser.cpp
@@ -0,0 +1,167 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "qtdocparser.h"
+#include "reporthandler.h"
+#include <QtXmlPatterns/QXmlQuery>
+#include <QUrl>
+
+Documentation QtDocParser::retrieveModuleDocumentation()
+{
+    return retrieveModuleDocumentation(packageName());
+}
+
+void QtDocParser::fillDocumentation(AbstractMetaClass* metaClass)
+{
+    if (!metaClass)
+        return;
+
+    QString scope = metaClass->name();
+    const AbstractMetaClass* context = metaClass->enclosingClass();
+    while(context) {
+        if (context->enclosingClass() == 0)
+            break;
+        context = context->enclosingClass();
+    }
+
+    QString filename = metaClass->qualifiedCppName().toLower().replace("::", "-");
+    QString sourceFile = documentationDataDirectory() + '/' + filename + ".xml";
+    if (metaClass->enclosingClass())
+        sourceFile.replace("::", "-");
+
+    if (!QFile::exists(sourceFile)) {
+        ReportHandler::warning("Can't find qdoc3 file for class "
+                               + metaClass->name() + ", tried: "
+                               + sourceFile);
+        return;
+    }
+
+    QXmlQuery xquery;
+    xquery.setFocus(QUrl(sourceFile));
+
+    QString className = metaClass->name();
+
+    // Class/Namespace documentation
+    QString type = metaClass->isNamespace() ? QLatin1String("namespace") : QLatin1String("class");
+    QString query = "/WebXML/document/" + type + "[@name=\"" + className + "\"]/description";
+
+    DocModificationList signedModifs, classModifs;
+    foreach (DocModification docModif, metaClass->typeEntry()->docModifications()) {
+        if (docModif.signature().isEmpty())
+            classModifs.append(docModif);
+        else
+            signedModifs.append(docModif);
+    }
+
+    Documentation doc(getDocumentation(xquery, query, classModifs));
+    metaClass->setDocumentation(doc);
+
+
+    //Functions Documentation
+    AbstractMetaFunctionList funcs = metaClass->functionsInTargetLang();
+    foreach (AbstractMetaFunction *func, funcs) {
+        if (!func || func->isPrivate())
+            continue;
+
+        QString query = "/WebXML/document/" + type + "[@" + "name" + "=\"" + className + "\"]";
+        // properties
+        if (func->isPropertyReader() || func->isPropertyWriter() || func->isPropertyResetter()) {
+            query += "/property[@name=\"" + func->propertySpec()->name() + "\"]";
+        } else { // normal methods
+            QString isConst = func->isConstant() ? "true" : "false";
+            query += "/function[@name=\"" + func->originalName()
+                     + "\" and count(parameter)="
+                     + QString::number(func->arguments().count())
+                     + " and @const=\"" + isConst + "\"]";
+
+            int i = 1;
+            foreach (AbstractMetaArgument* arg, func->arguments()) {
+                QString type = arg->type()->name();
+
+                if (arg->type()->isConstant())
+                    type.prepend("const ");
+
+                if (arg->type()->isReference()) {
+                    type += " &";
+                } if (arg->type()->indirections()) {
+                    type += ' ';
+                    for (int j = 0, max = arg->type()->indirections(); j < max; ++j)
+                        type += '*';
+                }
+                query += "/parameter[" + QString::number(i) + "][@left=\"" + type + "\"]/..";
+                ++i;
+            }
+        }
+        query += "/description";
+        DocModificationList funcModifs;
+        foreach (DocModification funcModif, signedModifs) {
+            if (funcModif.signature() == func->minimalSignature())
+                funcModifs.append(funcModif);
+        }
+        doc.setValue(getDocumentation(xquery, query, funcModifs));
+        func->setDocumentation(doc);
+    }
+#if 0
+    // Fields
+    AbstractMetaFieldList fields = metaClass->fields();
+    foreach (AbstractMetaField *field, fields) {
+        if (field->isPrivate())
+            return;
+
+        QString query = "/doxygen/compounddef/sectiondef/memberdef/name[text()=\"" + field->name() + "\"]/..";
+        Documentation doc = getDocumentation(DocModificationList(), xquery, query);
+        field->setDocumentation(doc);
+    }
+#endif
+    // Enums
+    AbstractMetaEnumList enums = metaClass->enums();
+    foreach (AbstractMetaEnum *meta_enum, enums) {
+        QString query = "/WebXML/document/" + type + "[@" + "name" + "=\""
+                        + className + "\"]/enum[@name=\""
+                        + meta_enum->name() + "\"]/description";
+        doc.setValue(getDocumentation(xquery, query, DocModificationList()));
+        meta_enum->setDocumentation(doc);
+    }
+}
+
+Documentation QtDocParser::retrieveModuleDocumentation(const QString& name)
+{
+    // TODO: This method of acquiring the module name supposes that the target language uses
+    // dots as module separators in package names. Improve this.
+    QString moduleName = QString(name).remove(0, name.lastIndexOf('.') + 1);
+    QString sourceFile = documentationDataDirectory() + '/' + moduleName.toLower() + ".xml";
+
+    if (!QFile::exists(sourceFile)) {
+        ReportHandler::warning("Can't find qdoc3 file for module "
+                               + name + ", tried: "
+                                                 + sourceFile);
+        return Documentation();
+    }
+
+    QXmlQuery xquery;
+    xquery.setFocus(QUrl(sourceFile));
+
+    // Module documentation
+    QString query = "/WebXML/document/page[@name=\"" + moduleName + "\"]/description";
+    return Documentation(getDocumentation(xquery, query, DocModificationList()));
+}
diff --git a/ApiExtractor/qtdocparser.h b/ApiExtractor/qtdocparser.h
new file mode 100644
index 000000000..e69d0650a
--- /dev/null
+++ b/ApiExtractor/qtdocparser.h
@@ -0,0 +1,39 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef QTDOCPARSER_H
+#define QTDOCPARSER_H
+
+#include "docparser.h"
+
+class APIEXTRACTOR_API QtDocParser : public DocParser
+{
+public:
+    QtDocParser() {}
+    virtual void fillDocumentation(AbstractMetaClass* metaClass);
+    virtual Documentation retrieveModuleDocumentation();
+    virtual Documentation retrieveModuleDocumentation(const QString& name);
+};
+
+#endif // QTDOCPARSER_H
+
diff --git a/ApiExtractor/reporthandler.cpp b/ApiExtractor/reporthandler.cpp
new file mode 100644
index 000000000..471f008ef
--- /dev/null
+++ b/ApiExtractor/reporthandler.cpp
@@ -0,0 +1,172 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "reporthandler.h"
+#include "typesystem.h"
+#include "typedatabase.h"
+#include <QtCore/QSet>
+#include <cstring>
+#include <cstdarg>
+#include <cstdio>
+
+#if _WINDOWS || NOCOLOR
+    #define COLOR_END ""
+    #define COLOR_WHITE ""
+    #define COLOR_YELLOW ""
+    #define COLOR_GREEN ""
+#else
+    #define COLOR_END "\033[0m"
+    #define COLOR_WHITE "\033[1;37m"
+    #define COLOR_YELLOW "\033[1;33m"
+    #define COLOR_GREEN "\033[0;32m"
+#endif
+
+static bool m_silent = false;
+static int m_warningCount = 0;
+static int m_suppressedCount = 0;
+static QString m_context;
+static ReportHandler::DebugLevel m_debugLevel = ReportHandler::NoDebug;
+static QSet<QString> m_reportedWarnings;
+static QString m_progressBuffer;
+static int m_step_size = 0;
+static int m_step = -1;
+static int m_step_warning = 0;
+
+static void printProgress()
+{
+    std::printf("%s", m_progressBuffer.toAscii().data());
+    std::fflush(stdout);
+    m_progressBuffer.clear();
+}
+
+static void printWarnings()
+{
+    if (m_reportedWarnings.size() > 0) {
+        m_progressBuffer += "\t";
+        foreach(QString msg, m_reportedWarnings)
+            m_progressBuffer += msg + "\n\t";
+        m_progressBuffer += "\n\n";
+        m_reportedWarnings.clear();
+        printProgress();
+    }
+}
+
+ReportHandler::DebugLevel ReportHandler::debugLevel()
+{
+    return m_debugLevel;
+}
+
+void ReportHandler::setDebugLevel(ReportHandler::DebugLevel level)
+{
+    m_debugLevel = level;
+}
+
+void ReportHandler::setContext(const QString& context)
+{
+    m_context = context;
+}
+
+int ReportHandler::suppressedCount()
+{
+    return m_suppressedCount;
+}
+
+int ReportHandler::warningCount()
+{
+    return m_warningCount;
+}
+
+void ReportHandler::setProgressReference(int max)
+{
+    m_step_size = max;
+    m_step = -1;
+}
+
+bool ReportHandler::isSilent()
+{
+    return m_silent;
+}
+
+void ReportHandler::setSilent(bool silent)
+{
+    m_silent = silent;
+}
+
+void ReportHandler::warning(const QString &text)
+{
+    if (m_silent)
+        return;
+
+// Context is useless!
+//     QString warningText = QString("\r" COLOR_YELLOW "WARNING(%1)" COLOR_END " :: %2").arg(m_context).arg(text);
+    TypeDatabase *db = TypeDatabase::instance();
+    if (db && db->isSuppressedWarning(text)) {
+        ++m_suppressedCount;
+    } else if (!m_reportedWarnings.contains(text)) {
+        ++m_warningCount;
+        ++m_step_warning;
+        m_reportedWarnings << text;
+    }
+}
+
+void ReportHandler::progress(const QString& str, ...)
+{
+    if (m_silent)
+        return;
+
+    if (m_step == -1) {
+        QTextStream buf(&m_progressBuffer);
+        buf.setFieldWidth(45);
+        buf.setFieldAlignment(QTextStream::AlignLeft);
+        buf << str;
+        printProgress();
+        m_step = 0;
+    }
+    m_step++;
+    if (m_step >= m_step_size) {
+        if (m_step_warning == 0) {
+            m_progressBuffer = "[" COLOR_GREEN "OK" COLOR_END "]\n";
+        } else {
+            m_progressBuffer = "[" COLOR_YELLOW "WARNING" COLOR_END "]\n";
+        }
+        printProgress();
+        m_step_warning = 0;
+    }
+}
+
+void ReportHandler::flush()
+{
+    if (!m_silent)
+        printWarnings();
+}
+
+void ReportHandler::debug(DebugLevel level, const QString &text)
+{
+    if (m_debugLevel == NoDebug)
+        return;
+
+    if (level <= m_debugLevel) {
+        std::printf("\r" COLOR_GREEN "DEBUG" COLOR_END " :: %-70s\n", qPrintable(text));
+        printProgress();
+    }
+}
diff --git a/ApiExtractor/reporthandler.h b/ApiExtractor/reporthandler.h
new file mode 100644
index 000000000..f1fae50ed
--- /dev/null
+++ b/ApiExtractor/reporthandler.h
@@ -0,0 +1,75 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef REPORTHANDLER_H
+#define REPORTHANDLER_H
+
+class QString;
+#include "apiextractormacros.h"
+
+class APIEXTRACTOR_API ReportHandler
+{
+public:
+    enum DebugLevel { NoDebug, SparseDebug, MediumDebug, FullDebug };
+
+    static void setContext(const QString &context);
+
+    static DebugLevel debugLevel();
+    static void setDebugLevel(DebugLevel level);
+
+    static int warningCount();
+
+    static int suppressedCount();
+
+    static void warning(const QString &str);
+
+    template <typename T>
+    static void setProgressReference(T collection)
+    {
+        setProgressReference(collection.count());
+    }
+
+    static void setProgressReference(int max);
+
+    static void progress(const QString &str, ...);
+
+    static void debugSparse(const QString &str)
+    {
+        debug(SparseDebug, str);
+    }
+    static void debugMedium(const QString &str)
+    {
+        debug(MediumDebug, str);
+    }
+    static void debugFull(const QString &str)
+    {
+        debug(FullDebug, str);
+    }
+    static void debug(DebugLevel level, const QString &str);
+
+    static bool isSilent();
+    static void setSilent(bool silent);
+    static void flush();
+};
+
+#endif // REPORTHANDLER_H
diff --git a/ApiExtractor/symbols.filter b/ApiExtractor/symbols.filter
new file mode 100644
index 000000000..af6c744dd
--- /dev/null
+++ b/ApiExtractor/symbols.filter
@@ -0,0 +1,7 @@
+{
+local:
+_ZSt*;
+_ZNSt*;
+_ZNSs*;
+_ZNKSt*;
+};
diff --git a/ApiExtractor/tests/CMakeLists.txt b/ApiExtractor/tests/CMakeLists.txt
new file mode 100644
index 000000000..dd3a32663
--- /dev/null
+++ b/ApiExtractor/tests/CMakeLists.txt
@@ -0,0 +1,54 @@
+
+macro(declare_test testname)
+    qt4_automoc("${testname}.cpp")
+    add_executable(${testname} "${testname}.cpp")
+    include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR} ${apiextractor_SOURCE_DIR})
+    target_link_libraries(${testname} ${QT_QTTEST_LIBRARY} ${QT_QTCORE_LIBRARY} ${QT_QTGUI_LIBRARY} apiextractor)
+    add_test(${testname} ${testname})
+    if (INSTALL_TESTS)
+        install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${testname} DESTINATION share/apiextractor${apiextractor_SUFFIX}/tests)
+    endif()
+endmacro(declare_test testname)
+
+declare_test(testabstractmetaclass)
+declare_test(testabstractmetatype)
+declare_test(testaddfunction)
+declare_test(testarrayargument)
+declare_test(testcodeinjection)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/utf8code.txt"
+                "${CMAKE_CURRENT_BINARY_DIR}/utf8code.txt" COPYONLY)
+declare_test(testcontainer)
+declare_test(testconversionoperator)
+declare_test(testconversionruletag)
+declare_test(testctorinformation)
+declare_test(testdroptypeentries)
+declare_test(testdtorinformation)
+declare_test(testenum)
+declare_test(testextrainclude)
+declare_test(testfunctiontag)
+declare_test(testimplicitconversions)
+declare_test(testinserttemplate)
+declare_test(testmodifyfunction)
+declare_test(testmultipleinheritance)
+declare_test(testnamespace)
+declare_test(testnestedtypes)
+declare_test(testnumericaltypedef)
+declare_test(testprimitivetypetag)
+declare_test(testrefcounttag)
+declare_test(testreferencetopointer)
+declare_test(testremovefield)
+declare_test(testremoveimplconv)
+declare_test(testremoveoperatormethod)
+declare_test(testresolvetype)
+declare_test(testreverseoperators)
+declare_test(testtemplates)
+declare_test(testtoposort)
+declare_test(testvaluetypedefaultctortag)
+declare_test(testvoidarg)
+declare_test(testtyperevision)
+if (NOT DISABLE_DOCSTRINGS)
+    declare_test(testmodifydocumentation)
+    configure_file("${CMAKE_CURRENT_SOURCE_DIR}/a.xml"
+                   "${CMAKE_CURRENT_BINARY_DIR}/a.xml" COPYONLY)
+endif()
+
diff --git a/ApiExtractor/tests/a.xml b/ApiExtractor/tests/a.xml
new file mode 100644
index 000000000..1c6d62a17
--- /dev/null
+++ b/ApiExtractor/tests/a.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" ?>
+
+<WebXML>
+    <document>
+        <class name="A">
+            <description>oi
+                <para>Paragraph number 1</para>
+                <para>Paragraph number 2</para>
+                <para>Paragraph number 3</para>
+            </description>
+        </class>
+    </document>
+</WebXML>
diff --git a/ApiExtractor/tests/testabstractmetaclass.cpp b/ApiExtractor/tests/testabstractmetaclass.cpp
new file mode 100644
index 000000000..11e17d989
--- /dev/null
+++ b/ApiExtractor/tests/testabstractmetaclass.cpp
@@ -0,0 +1,446 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testabstractmetaclass.h"
+#include "abstractmetabuilder.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestAbstractMetaClass::testClassName()
+{
+    const char* cppCode ="class ClassName {};";
+    const char* xmlCode = "<typesystem package=\"Foo\"><value-type name=\"ClassName\"/></typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 1);
+    QCOMPARE(classes[0]->name(), QString("ClassName"));
+}
+
+void TestAbstractMetaClass::testClassNameUnderNamespace()
+{
+    const char* cppCode ="namespace Namespace { class ClassName {}; }";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <namespace-type name=\"Namespace\"/> \
+        <value-type name=\"Namespace::ClassName\"/> \
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2); // 1 namespace + 1 class
+    if (classes.first()->name() != "ClassName")
+        classes.swap(0, 1);
+
+    QCOMPARE(classes[0]->name(), QString("ClassName"));
+    QCOMPARE(classes[0]->qualifiedCppName(), QString("Namespace::ClassName"));
+    QCOMPARE(classes[1]->name(), QString("Namespace"));
+    QVERIFY(classes[1]->isNamespace());
+
+    // Check ctors info
+    QVERIFY(classes[0]->hasConstructors());
+    QCOMPARE(classes[0]->functions().size(), 2); // default ctor + copy ctor
+
+    AbstractMetaFunctionList ctors = classes[0]->queryFunctions(AbstractMetaClass::Constructors);
+    QCOMPARE(ctors.size(), 2);
+    if (ctors.first()->minimalSignature() != "ClassName()")
+        ctors.swap(0, 1);
+
+    QCOMPARE(ctors[0]->arguments().size(), 0);
+    QCOMPARE(ctors[0]->minimalSignature(), QString("ClassName()"));
+    QCOMPARE(ctors[1]->arguments().size(), 1);
+    QCOMPARE(ctors[1]->minimalSignature(), QString("ClassName(Namespace::ClassName)"));
+
+    QVERIFY(!classes[0]->hasPrivateDestructor());
+    QVERIFY(classes[0]->hasCloneOperator()); // implicit default copy ctor
+    QVERIFY(!classes[0]->hasHashFunction());
+
+    // This method is buggy and nobody wants to fix it or needs it fixed :-/
+    // QVERIFY(classes[0]->hasNonPrivateConstructor());
+}
+
+void TestAbstractMetaClass::testVirtualMethods()
+{
+    const char* cppCode ="\
+    class A {\
+    public:\
+        virtual int pureVirtual() const = 0;\
+    };\
+    class B : public A {};\
+    class C : public B {\
+    public:\
+        int pureVirtual() const { return 0; }\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <primitive-type name='int' />\
+        <object-type name='A'/> \
+        <object-type name='B'/> \
+        <object-type name='C'/> \
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 3);
+    AbstractMetaClass* a = classes.findClass("A");
+    AbstractMetaClass* b = classes.findClass("B");
+    AbstractMetaClass* c = classes.findClass("C");
+
+    AbstractMetaClass* no_class = 0;
+
+    QCOMPARE(a->baseClass(), no_class);
+    QCOMPARE(b->baseClass(), a);
+    QCOMPARE(c->baseClass(), b);
+
+    QCOMPARE(a->functions().size(), 2); // default ctor + the pure virtual method
+    QCOMPARE(b->functions().size(), 2);
+    QCOMPARE(c->functions().size(), 2);
+
+    // implementing class, ownclass, declaringclass
+    AbstractMetaFunction* ctorA = a->queryFunctions(AbstractMetaClass::Constructors).first();
+    AbstractMetaFunction* ctorB = b->queryFunctions(AbstractMetaClass::Constructors).first();
+    AbstractMetaFunction* ctorC = c->queryFunctions(AbstractMetaClass::Constructors).first();
+    QVERIFY(ctorA->isConstructor());
+    QVERIFY(!ctorA->isVirtual());
+    QVERIFY(ctorB->isConstructor());
+    QVERIFY(!ctorB->isVirtual());
+    QVERIFY(ctorC->isConstructor());
+    QVERIFY(!ctorC->isVirtual());
+    QCOMPARE(ctorA->implementingClass(), a);
+    QCOMPARE(ctorA->ownerClass(), a);
+    QCOMPARE(ctorA->declaringClass(), a);
+
+    QCOMPARE(a->virtualFunctions().size(), 1); // Add a pureVirtualMethods method !?
+    QCOMPARE(b->virtualFunctions().size(), 1);
+    QCOMPARE(c->virtualFunctions().size(), 1);
+
+    AbstractMetaFunction* funcA = a->virtualFunctions().first();
+    AbstractMetaFunction* funcB = b->virtualFunctions().first();
+    AbstractMetaFunction* funcC = c->virtualFunctions().first();
+
+    QCOMPARE(funcA->ownerClass(), a);
+    QCOMPARE(funcB->ownerClass(), b);
+    QCOMPARE(funcC->ownerClass(), c);
+
+    QCOMPARE(funcA->declaringClass(), a);
+    QCOMPARE(funcB->declaringClass(), a);
+    QCOMPARE(funcC->declaringClass(), a);
+
+    // The next two tests could return null, because it makes more sense.
+    // But we have too many code written relying on this behaviour where
+    // implementingClass is equals to declaringClass on pure virtual functions
+    QCOMPARE(funcA->implementingClass(), a);
+    QCOMPARE(funcB->implementingClass(), a);
+    QCOMPARE(funcC->implementingClass(), c);
+}
+
+void TestAbstractMetaClass::testDefaultValues()
+{
+    const char* cppCode ="\
+    struct A {\
+        class B {};\
+        void method(B b = B());\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <value-type name='A'/> \
+        <value-type name='A::B'/> \
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    AbstractMetaClass* classA = classes.findClass("A");
+    QCOMPARE(classA->queryFunctionsByName("method").count(), 1);
+    AbstractMetaFunction* method = classA->queryFunctionsByName("method").first();
+    AbstractMetaArgument* arg = method->arguments().first();
+    QCOMPARE(arg->defaultValueExpression(), arg->originalDefaultValueExpression());
+}
+
+void TestAbstractMetaClass::testModifiedDefaultValues()
+{
+    const char* cppCode ="\
+    struct A {\
+        class B {};\
+        void method(B b = B());\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <value-type name='A'> \
+        <modify-function signature='method(A::B)'>\
+            <modify-argument index='1'>\
+                <replace-default-expression with='Hello'/>\
+            </modify-argument>\
+        </modify-function>\
+        </value-type>\
+        <value-type name='A::B'/> \
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    AbstractMetaClass* classA = classes.findClass("A");
+    QCOMPARE(classA->queryFunctionsByName("method").count(), 1);
+    AbstractMetaFunction* method = classA->queryFunctionsByName("method").first();
+    AbstractMetaArgument* arg = method->arguments().first();
+    QCOMPARE(arg->defaultValueExpression(), QString("Hello"));
+    QCOMPARE(arg->originalDefaultValueExpression(), QString("A::B()"));
+}
+
+void TestAbstractMetaClass::testInnerClassOfAPolymorphicOne()
+{
+    const char* cppCode ="\
+    struct A {\
+        class B {};\
+        virtual void method();\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <object-type name='A' /> \
+        <value-type name='A::B' /> \
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QVERIFY(classA->isPolymorphic());
+    AbstractMetaClass* classB = classes.findClass("A::B");
+    QVERIFY(classB);
+    QVERIFY(!classB->isPolymorphic());
+}
+
+void TestAbstractMetaClass::testClassDefaultConstructors()
+{
+    const char* cppCode ="\
+    struct A {};\
+    \
+    struct B {\
+        B();\
+    private: \
+        B(const B&);\
+    };\
+    \
+    struct C {\
+        C(const C&);\
+    };\
+    \
+    struct D {\
+    private: \
+        D(const D&);\
+    };\
+    \
+    struct E {\
+    private: \
+        ~E();\
+    };\
+    \
+    struct F {\
+        F(int, int);\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <primitive-type name='int' />\
+        <value-type name='A' /> \
+        <object-type name='B' /> \
+        <value-type name='C' /> \
+        <object-type name='D' /> \
+        <object-type name='E' /> \
+        <value-type name='F' /> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 6);
+
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QCOMPARE(classA->functions().size(), 2);
+
+    AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
+    QCOMPARE(ctors.size(), 2);
+    if (ctors.first()->minimalSignature() != "A()")
+        ctors.swap(0, 1);
+
+    QCOMPARE(ctors[0]->arguments().size(), 0);
+    QCOMPARE(ctors[0]->minimalSignature(), QString("A()"));
+    QCOMPARE(ctors[1]->arguments().size(), 1);
+    QCOMPARE(ctors[1]->minimalSignature(), QString("A(A)"));
+
+    AbstractMetaClass* classB = classes.findClass("B");
+    QVERIFY(classB);
+    QCOMPARE(classB->functions().size(), 2);
+    QCOMPARE(classB->functions().first()->minimalSignature(), QString("B()"));
+
+    AbstractMetaClass* classC = classes.findClass("C");
+    QVERIFY(classC);
+    QCOMPARE(classC->functions().size(), 1);
+    QCOMPARE(classC->functions().first()->minimalSignature(), QString("C(C)"));
+
+    AbstractMetaClass* classD = classes.findClass("D");
+    QVERIFY(classD);
+    QCOMPARE(classD->functions().size(), 1);
+    QCOMPARE(classD->functions().first()->minimalSignature(), QString("D(D)"));
+    QVERIFY(classD->functions().first()->isPrivate());
+
+    AbstractMetaClass* classE = classes.findClass("E");
+    QVERIFY(classE);
+    QVERIFY(classE->hasPrivateDestructor());
+    QCOMPARE(classE->functions().size(), 0);
+
+    AbstractMetaClass* classF = classes.findClass("F");
+    QVERIFY(classF);
+
+    ctors = classF->queryFunctions(AbstractMetaClass::Constructors);
+    QCOMPARE(ctors.size(), 2);
+    if (ctors.first()->minimalSignature() != "F(int,int)")
+        ctors.swap(0, 1);
+
+    QCOMPARE(ctors[0]->arguments().size(), 2);
+    QCOMPARE(ctors[0]->minimalSignature(), QString("F(int,int)"));
+    QCOMPARE(ctors[1]->arguments().size(), 1);
+    QCOMPARE(ctors[1]->minimalSignature(), QString("F(F)"));
+}
+
+void TestAbstractMetaClass::testClassInheritedDefaultConstructors()
+{
+    const char* cppCode ="\
+    struct A {\
+        A();\
+    private: \
+        A(const A&);\
+    };\
+    struct B : public A {};\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <object-type name='A' /> \
+        <object-type name='B' /> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+
+    AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
+    QCOMPARE(ctors.size(), 2);
+    if (ctors.first()->minimalSignature() != "A()")
+        ctors.swap(0, 1);
+
+    QCOMPARE(ctors[0]->arguments().size(), 0);
+    QCOMPARE(ctors[0]->minimalSignature(), QString("A()"));
+    QCOMPARE(ctors[1]->arguments().size(), 1);
+    QCOMPARE(ctors[1]->minimalSignature(), QString("A(A)"));
+    QVERIFY(ctors[1]->isPrivate());
+
+    AbstractMetaClass* classB = classes.findClass("B");
+    QVERIFY(classB);
+
+    ctors = classB->queryFunctions(AbstractMetaClass::Constructors);
+    QCOMPARE(ctors.size(), 1);
+    QCOMPARE(ctors.first()->arguments().size(), 0);
+    QCOMPARE(ctors.first()->minimalSignature(), QString("B()"));
+}
+
+void TestAbstractMetaClass::testAbstractClassDefaultConstructors()
+{
+    const char* cppCode ="\
+    struct A {\
+        virtual method() = 0;\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <object-type name='A' /> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 1);
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+
+    AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
+    QCOMPARE(ctors.size(), 1);
+    QCOMPARE(ctors.first()->arguments().size(), 0);
+    QCOMPARE(ctors.first()->minimalSignature(), QString("A()"));
+}
+
+void TestAbstractMetaClass::testObjectTypesMustNotHaveCopyConstructors()
+{
+    const char* cppCode ="struct A {};";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <object-type name='A' /> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 1);
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+
+    AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
+    QCOMPARE(ctors.size(), 1);
+    QCOMPARE(ctors.first()->arguments().size(), 0);
+    QCOMPARE(ctors.first()->minimalSignature(), QString("A()"));
+}
+
+void TestAbstractMetaClass::testIsPolymorphic()
+{
+    const char* cppCode = "\
+    class A\
+    {\
+    public:\
+        A();\
+        inline bool abc() const {}\
+    };\
+    \
+    class B : public A\
+    {\
+    public:\
+        B();\
+        inline bool abc() const {}\
+    };";
+    const char* xmlCode = "\
+    <typesystem package='Foo'>\
+        <primitive-type name='bool' />\
+        <value-type name='A' />\
+        <value-type name='B' />\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    AbstractMetaClass* b = classes.findClass("A");
+
+    QVERIFY(!b->isPolymorphic());
+    AbstractMetaClass* a = classes.findClass("B");
+    QVERIFY(!a->isPolymorphic());
+}
+
+QTEST_APPLESS_MAIN(TestAbstractMetaClass)
+
+#include "testabstractmetaclass.moc"
diff --git a/ApiExtractor/tests/testabstractmetaclass.h b/ApiExtractor/tests/testabstractmetaclass.h
new file mode 100644
index 000000000..d725c46ed
--- /dev/null
+++ b/ApiExtractor/tests/testabstractmetaclass.h
@@ -0,0 +1,48 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTABSTRACTMETACLASS_H
+#define TESTABSTRACTMETACLASS_H
+
+#include <QObject>
+
+class AbstractMetaBuilder;
+
+class TestAbstractMetaClass : public QObject
+{
+    Q_OBJECT
+private slots:
+    void testClassName();
+    void testClassNameUnderNamespace();
+    void testVirtualMethods();
+    void testDefaultValues();
+    void testModifiedDefaultValues();
+    void testInnerClassOfAPolymorphicOne();
+    void testClassDefaultConstructors();
+    void testClassInheritedDefaultConstructors();
+    void testAbstractClassDefaultConstructors();
+    void testObjectTypesMustNotHaveCopyConstructors();
+    void testIsPolymorphic();
+};
+
+#endif // TESTABSTRACTMETACLASS_H
diff --git a/ApiExtractor/tests/testabstractmetatype.cpp b/ApiExtractor/tests/testabstractmetatype.cpp
new file mode 100644
index 000000000..1e9ce81eb
--- /dev/null
+++ b/ApiExtractor/tests/testabstractmetatype.cpp
@@ -0,0 +1,206 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testabstractmetatype.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestAbstractMetaType::testConstCharPtrType()
+{
+    const char* cppCode ="const char* justAtest();";
+    const char* xmlCode = "<typesystem package=\"Foo\">\
+        <primitive-type name='char'/>\
+        <function signature='justAtest()' />\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    QCOMPARE(t.builder()->globalFunctions().size(), 1);
+    AbstractMetaFunction* func = t.builder()->globalFunctions().first();
+    AbstractMetaType* rtype = func->type();
+    // Test properties of const char*
+    QVERIFY(rtype);
+    QCOMPARE(rtype->package(), QString("Foo"));
+    QCOMPARE(rtype->name(), QString("char"));
+    QVERIFY(rtype->isConstant());
+    QVERIFY(!rtype->isArray());
+    QVERIFY(!rtype->isContainer());
+    QVERIFY(!rtype->isObject());
+    QVERIFY(!rtype->isPrimitive()); // const char* differs from char, so it's not considered a primitive type by apiextractor
+    QVERIFY(rtype->isNativePointer());
+    QVERIFY(!rtype->isQObject());
+    QVERIFY(!rtype->isReference());
+    QVERIFY(!rtype->isValue());
+    QVERIFY(!rtype->isValuePointer());
+}
+
+void TestAbstractMetaType::testApiVersionSupported()
+{
+    const char* cppCode ="class foo {}; class foo2 {};\
+                          void justAtest(); void justAtest3();";
+    const char* xmlCode = "<typesystem package='Foo'>\
+        <value-type name='foo' since='0.1'/>\
+        <value-type name='foo2' since='1.0'/>\
+        <value-type name='foo3' since='1.1'/>\
+        <function signature='justAtest()' since='0.1'/>\
+        <function signature='justAtest2()' since='1.1'/>\
+        <function signature='justAtest3()'/>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false, "1.0");
+
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.size(), 2);
+
+
+    AbstractMetaFunctionList functions = t.builder()->globalFunctions();
+    QCOMPARE(functions.size(), 2);
+}
+
+
+void TestAbstractMetaType::testApiVersionNotSupported()
+{
+    const char* cppCode ="class object {};";
+    const char* xmlCode = "<typesystem package='Foo'>\
+        <value-type name='object' since='0.1'/>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, true, "0.1");
+
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.size(), 1);
+}
+
+void TestAbstractMetaType::testCharType()
+{
+    const char* cppCode ="char justAtest(); class A {};";
+    const char* xmlCode = "<typesystem package=\"Foo\">\
+    <primitive-type name='char'/>\
+    <value-type name='A' />\
+    <function signature='justAtest()' />\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.size(), 1);
+    QCOMPARE(classes.first()->package(), QString("Foo"));
+
+    AbstractMetaFunctionList functions = t.builder()->globalFunctions();
+    QCOMPARE(functions.size(), 1);
+    AbstractMetaFunction* func = functions.first();
+    AbstractMetaType* rtype = func->type();
+    // Test properties of const char*
+    QVERIFY(rtype);
+    QCOMPARE(rtype->package(), QString("Foo"));
+    QCOMPARE(rtype->name(), QString("char"));
+    QVERIFY(!rtype->isConstant());
+    QVERIFY(!rtype->isArray());
+    QVERIFY(!rtype->isContainer());
+    QVERIFY(!rtype->isObject());
+    QVERIFY(rtype->isPrimitive());
+    QVERIFY(!rtype->isNativePointer());
+    QVERIFY(!rtype->isQObject());
+    QVERIFY(!rtype->isReference());
+    QVERIFY(!rtype->isValue());
+    QVERIFY(!rtype->isValuePointer());
+}
+
+void TestAbstractMetaType::testTypedef()
+{
+    const char* cppCode ="\
+    struct A {\
+        void someMethod();\
+    };\
+    typedef A B;\
+    typedef B C;";
+    const char* xmlCode = "<typesystem package=\"Foo\">\
+    <value-type name='C' />\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.size(), 1);
+    AbstractMetaClass* c = classes.findClass("C");
+    QVERIFY(c);
+    QVERIFY(c->isTypeAlias());
+}
+
+void TestAbstractMetaType::testTypedefWithTemplates()
+{
+    const char* cppCode ="\
+    template<typename T>\
+    class A {};\
+    \
+    class B {};\
+    typedef A<B> C;\
+    \
+    void func(C c);\
+    ";
+    const char* xmlCode = "<typesystem package=\"Foo\">\
+    <container-type name='A' type='list'/>\
+    <value-type name='B' />\
+    <function signature='func(A&lt;B&gt;)' />\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.size(), 1);
+    AbstractMetaFunctionList functions = t.builder()->globalFunctions();
+    QCOMPARE(functions.count(), 1);
+    AbstractMetaFunction* function = functions.first();
+    AbstractMetaArgumentList args = function->arguments();
+    QCOMPARE(args.count(), 1);
+    AbstractMetaArgument* arg = args.first();
+    AbstractMetaType* metaType = arg->type();
+    QCOMPARE(metaType->cppSignature(), QString("A<B >"));
+}
+
+
+void TestAbstractMetaType::testObjectTypeUsedAsValue()
+{
+    const char* cppCode ="\
+    class A {\
+        void method(A);\
+    };\
+    ";
+    const char* xmlCode = "<typesystem package='Foo'>\
+    <object-type name='A' />\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.size(), 1);
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    AbstractMetaFunctionList overloads = classA->queryFunctionsByName("method");
+    QCOMPARE(overloads.count(), 1);
+    AbstractMetaFunction* method = overloads.first();
+    QVERIFY(method);
+    AbstractMetaArgumentList args = method->arguments();
+    QCOMPARE(args.count(), 1);
+    AbstractMetaArgument* arg = args.first();
+    AbstractMetaType* metaType = arg->type();
+    QCOMPARE(metaType->cppSignature(), QString("A"));
+    QVERIFY(metaType->isValue());
+    QVERIFY(metaType->typeEntry()->isObject());
+}
+
+QTEST_APPLESS_MAIN(TestAbstractMetaType)
+
+#include "testabstractmetatype.moc"
diff --git a/ApiExtractor/tests/testabstractmetatype.h b/ApiExtractor/tests/testabstractmetatype.h
new file mode 100644
index 000000000..f543172cc
--- /dev/null
+++ b/ApiExtractor/tests/testabstractmetatype.h
@@ -0,0 +1,42 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTABSTRACTMETATYPE_H
+#define TESTABSTRACTMETATYPE_H
+
+#include <QObject>
+
+class TestAbstractMetaType : public QObject
+{
+    Q_OBJECT
+private slots:
+    void testConstCharPtrType();
+    void testCharType();
+    void testTypedef();
+    void testTypedefWithTemplates();
+    void testApiVersionSupported();
+    void testApiVersionNotSupported();
+    void testObjectTypeUsedAsValue();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testaddfunction.cpp b/ApiExtractor/tests/testaddfunction.cpp
new file mode 100644
index 000000000..c1189c346
--- /dev/null
+++ b/ApiExtractor/tests/testaddfunction.cpp
@@ -0,0 +1,432 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testaddfunction.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+
+void TestAddFunction::testParsingFuncNameAndConstness()
+{
+    // generic test...
+    const char sig1[] = "func(type1, const type2, const type3* const)";
+    AddedFunction f1(sig1, "void", 0);
+    QCOMPARE(f1.name(), QString("func"));
+    QCOMPARE(f1.arguments().count(), 3);
+    AddedFunction::TypeInfo retval = f1.returnType();
+    QCOMPARE(retval.name, QString("void"));
+    QCOMPARE(retval.indirections, 0);
+    QCOMPARE(retval.isConstant, false);
+    QCOMPARE(retval.isReference, false);
+
+    // test with a ugly template as argument and other ugly stuff
+    const char sig2[] = "    _fu__nc_       (  type1, const type2, const Abc<int& , C<char*> *   >  * *, const type3* const    )   const ";
+    AddedFunction f2(sig2, "const Abc<int& , C<char*> *   >  * *", 0);
+    QCOMPARE(f2.name(), QString("_fu__nc_"));
+    QList< AddedFunction::TypeInfo > args = f2.arguments();
+    QCOMPARE(args.count(), 4);
+    retval = f2.returnType();
+    QCOMPARE(retval.name, QString("Abc<int& , C<char*> *   >"));
+    QCOMPARE(retval.indirections, 2);
+    QCOMPARE(retval.isConstant, true);
+    QCOMPARE(retval.isReference, false);
+    retval = args[2];
+    QCOMPARE(retval.name, QString("Abc<int& , C<char*> *   >"));
+    QCOMPARE(retval.indirections, 2);
+    QCOMPARE(retval.isConstant, true);
+    QCOMPARE(retval.isReference, false);
+
+    // function with no args.
+    const char sig3[] = "func()";
+    AddedFunction f3(sig3, "void", 0);
+    QCOMPARE(f3.name(), QString("func"));
+    QCOMPARE(f3.arguments().count(), 0);
+}
+
+void TestAddFunction::testAddFunction()
+{
+    const char cppCode[] = "struct B {}; struct A { void a(int); };";
+    const char xmlCode[] = "\
+    <typesystem package='Foo'>\
+        <primitive-type name='int' />\
+        <primitive-type name='float' />\
+        <value-type name='B' />\
+        <value-type name='A'>\
+            <add-function signature='b(int, float = 4.6, const B&amp;)' return-type='int' access='protected'>\
+            </add-function>\
+        </value-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    TypeDatabase* typeDb = TypeDatabase::instance();
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QCOMPARE(classA->functions().count(), 4); // default ctor, default copy ctor, func a() and the added function
+
+    AbstractMetaFunction* addedFunc = classA->functions().last();
+    QCOMPARE(addedFunc->visibility(), uint(AbstractMetaFunction::Protected));
+    QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::NormalFunction);
+    QVERIFY(addedFunc->isUserAdded());
+    QCOMPARE(addedFunc->ownerClass(), classA);
+    QCOMPARE(addedFunc->implementingClass(), classA);
+    QCOMPARE(addedFunc->declaringClass(), classA);
+    QVERIFY(!addedFunc->isVirtual());
+    QVERIFY(!addedFunc->isSignal());
+    QVERIFY(!addedFunc->isSlot());
+    QVERIFY(!addedFunc->isStatic());
+
+    AbstractMetaType* returnType = addedFunc->type();
+    QCOMPARE(returnType->typeEntry(), typeDb->findPrimitiveType("int"));
+    AbstractMetaArgumentList args = addedFunc->arguments();
+    QCOMPARE(args.count(), 3);
+    QCOMPARE(args[0]->type()->typeEntry(), returnType->typeEntry());
+    QCOMPARE(args[1]->defaultValueExpression(), QString("4.6"));
+    QCOMPARE(args[2]->type()->typeEntry(), typeDb->findType("B"));
+}
+
+void TestAddFunction::testAddFunctionConstructor()
+{
+    const char cppCode[] = "struct A { A() {} };";
+    const char xmlCode[] = "\
+    <typesystem package='Foo'>\
+        <primitive-type name='int' />\
+        <value-type name='A'>\
+            <add-function signature='A(int)' />\
+        </value-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QCOMPARE(classA->functions().count(), 3); // default and added ctors
+    AbstractMetaFunction* addedFunc = classA->functions().last();
+    QCOMPARE(addedFunc->visibility(), uint(AbstractMetaFunction::Public));
+    QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::ConstructorFunction);
+    QCOMPARE(addedFunc->arguments().size(), 1);
+    QVERIFY(addedFunc->isUserAdded());
+    QVERIFY(!addedFunc->type());
+}
+
+void TestAddFunction::testAddFunctionTagDefaultValues()
+{
+    const char cppCode[] = "struct A {};";
+    const char xmlCode[] = "\
+    <typesystem package='Foo'>\
+        <value-type name='A'>\
+            <add-function signature='func()' />\
+        </value-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QCOMPARE(classA->functions().count(), 3); // default ctor, default copy ctor and the added function
+    AbstractMetaFunction* addedFunc = classA->functions().last();
+    QCOMPARE(addedFunc->visibility(), uint(AbstractMetaFunction::Public));
+    QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::NormalFunction);
+    QVERIFY(addedFunc->isUserAdded());
+    QVERIFY(!addedFunc->type());
+}
+
+void TestAddFunction::testAddFunctionCodeSnippets()
+{
+    const char cppCode[] = "struct A {};";
+    const char xmlCode[] = "\
+    <typesystem package='Foo'>\
+        <value-type name='A'>\
+            <add-function signature='func()'>\
+                <inject-code class='target' position='end'>Hi!, I am the code.</inject-code>\
+            </add-function>\
+        </value-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    AbstractMetaFunction* addedFunc = classA->functions().last();
+    QVERIFY(addedFunc->hasInjectedCode());
+}
+
+void TestAddFunction::testAddFunctionWithoutParenteses()
+{
+    const char sig1[] = "func";
+    AddedFunction f1(sig1, "void", 0);
+
+    QCOMPARE(f1.name(), QString("func"));
+    QCOMPARE(f1.arguments().count(), 0);
+    QCOMPARE(f1.isConstant(), false);
+
+    const char cppCode[] = "struct A {};";
+    const char xmlCode[] = "\
+    <typesystem package='Foo'>\
+        <value-type name='A'>\
+            <add-function signature='func'>\
+                <inject-code class='target' position='end'>Hi!, I am the code.</inject-code>\
+            </add-function>\
+        </value-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    const AbstractMetaFunction* addedFunc = classA->findFunction("func");
+    QVERIFY(addedFunc);
+    QVERIFY(addedFunc->hasInjectedCode());
+    QCOMPARE(addedFunc->injectedCodeSnips(CodeSnip::Any, TypeSystem::TargetLangCode).count(), 1);
+}
+
+void TestAddFunction::testAddFunctionWithDefaultArgs()
+{
+    const char sig1[] = "func";
+    AddedFunction f1(sig1, "void", 0);
+
+    QCOMPARE(f1.name(), QString("func"));
+    QCOMPARE(f1.arguments().count(), 0);
+    QCOMPARE(f1.isConstant(), false);
+
+    const char cppCode[] = "struct A { };";
+    const char xmlCode[] = "\
+    <typesystem package='Foo'>\
+        <primitive-type name='int'/> \
+        <value-type name='A'>\
+            <add-function signature='func(int, int)'>\
+              <modify-argument index='2'>\
+                <replace-default-expression with='2'/> \
+              </modify-argument> \
+            </add-function>\
+        </value-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    const AbstractMetaFunction* addedFunc = classA->findFunction("func");
+    QVERIFY(addedFunc);
+    AbstractMetaArgument *arg = addedFunc->arguments()[1];
+    QCOMPARE(arg->defaultValueExpression(), QString("2"));
+}
+
+void TestAddFunction::testAddFunctionAtModuleLevel()
+{
+    const char cppCode[] = "struct A { };";
+    const char xmlCode[] = "\
+    <typesystem package='Foo'>\
+        <primitive-type name='int'/> \
+        <value-type name='A'/>\
+        <add-function signature='func(int, int)'>\
+            <inject-code class='target' position='beginning'>custom_code();</inject-code>\
+        </add-function>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+
+    TypeDatabase* typeDb = TypeDatabase::instance();
+
+    AddedFunctionList addedFuncs = typeDb->findGlobalUserFunctions("func");
+
+    QCOMPARE(addedFuncs.size(), 1);
+
+    FunctionModificationList mods = typeDb->functionModifications("func(int,int)");
+
+    QCOMPARE(mods.size(), 1);
+    QVERIFY(mods.first().isCodeInjection());
+    CodeSnip snip = mods.first().snips.first();
+    QCOMPARE(snip.code(), QString("custom_code();"));
+}
+
+void TestAddFunction::testAddFunctionWithVarargs()
+{
+    const char sig1[] = "func(int,char,...)";
+    AddedFunction f1(sig1, "void", 0);
+
+    QCOMPARE(f1.name(), QString("func"));
+    QCOMPARE(f1.arguments().count(), 3);
+    QVERIFY(!f1.isConstant());
+
+    const char cppCode[] = "struct A {};";
+    const char xmlCode[] = "\
+    <typesystem package='Foo'>\
+        <primitive-type name='int'/> \
+        <primitive-type name='char'/> \
+        <value-type name='A'>\
+            <add-function signature='func(int,char,...)'/>\
+        </value-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    const AbstractMetaFunction* addedFunc = classA->findFunction("func");
+    QVERIFY(addedFunc);
+    const AbstractMetaArgument* arg = addedFunc->arguments().last();
+    QVERIFY(arg->type()->isVarargs());
+    QVERIFY(arg->type()->typeEntry()->isVarargs());
+}
+
+void TestAddFunction::testAddStaticFunction()
+{
+    const char cppCode[] = "struct A { };";
+    const char xmlCode[] = "\
+    <typesystem package='Foo'>\
+        <primitive-type name='int'/> \
+        <value-type name='A'>\
+            <add-function signature='func(int, int)' static='yes'>\
+                <inject-code class='target' position='beginning'>custom_code();</inject-code>\
+            </add-function>\
+        </value-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    const AbstractMetaFunction* addedFunc = classA->findFunction("func");
+    QVERIFY(addedFunc);
+    QVERIFY(addedFunc->isStatic());
+}
+
+void TestAddFunction::testAddGlobalFunction()
+{
+    const char cppCode[] = "struct A { };struct B {};";
+    const char xmlCode[] = "\
+    <typesystem package='Foo'>\
+        <primitive-type name='int'/> \
+        <value-type name='A' />\
+        <add-function signature='globalFunc(int, int)' static='yes'>\
+            <inject-code class='target' position='beginning'>custom_code();</inject-code>\
+        </add-function>\
+        <add-function signature='globalFunc2(int, int)' static='yes'>\
+            <inject-code class='target' position='beginning'>custom_code();</inject-code>\
+        </add-function>\
+        <value-type name='B' />\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaFunctionList globalFuncs = t.builder()->globalFunctions();
+    QCOMPARE(globalFuncs.count(), 2);
+    QVERIFY(!t.builder()->classes().findClass("B")->findFunction("globalFunc"));
+    QVERIFY(!t.builder()->classes().findClass("B")->findFunction("globalFunc2"));
+    QVERIFY(!globalFuncs[0]->injectedCodeSnips().isEmpty());
+    QVERIFY(!globalFuncs[1]->injectedCodeSnips().isEmpty());
+}
+
+void TestAddFunction::testAddFunctionWithApiVersion()
+{
+    const char cppCode[] = "";
+    const char xmlCode[] = "\
+    <typesystem package='Foo'>\
+        <primitive-type name='int'/> \
+        <add-function signature='globalFunc(int, int)' static='yes' since='1.3'>\
+            <inject-code class='target' position='beginning'>custom_code();</inject-code>\
+        </add-function>\
+        <add-function signature='globalFunc2(int, int)' static='yes' since='0.1'>\
+            <inject-code class='target' position='beginning'>custom_code();</inject-code>\
+        </add-function>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, true, "0.1");
+    AbstractMetaFunctionList globalFuncs = t.builder()->globalFunctions();
+    QCOMPARE(globalFuncs.count(), 1);
+}
+
+void TestAddFunction::testModifyAddedFunction()
+{
+    const char cppCode[] = "class Foo { };";
+    const char xmlCode[] = "\
+    <typesystem package='Package'>\
+        <primitive-type name='float'/>\
+        <primitive-type name='int'/>\
+        <value-type name='Foo'>\
+            <add-function signature='method(float, int)'>\
+                <inject-code class='target' position='beginning'>custom_code();</inject-code>\
+                <modify-argument index='2'>\
+                    <replace-default-expression with='0' />\
+                    <rename to='varName' />\
+                </modify-argument>\
+            </add-function>\
+        </value-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* foo = classes.findClass("Foo");
+    const AbstractMetaFunction* method = foo->findFunction("method");
+    QCOMPARE(method->arguments().size(), 2);
+    AbstractMetaArgument* arg = method->arguments().at(1);
+    QCOMPARE(arg->defaultValueExpression(), QString("0"));
+    QCOMPARE(arg->name(), QString("varName"));
+    QCOMPARE(method->argumentName(2), QString("varName"));
+}
+
+void TestAddFunction::testAddFunctionOnTypedef()
+{
+    const char cppCode[] = "template<class T> class Foo { }; typedef Foo<int> FooInt;";
+    const char xmlCode[] = "\
+    <typesystem package='Package'>\
+        <custom-type name='PySequence'/>\
+        <primitive-type name='int'/>\
+        <value-type name='FooInt'>\
+            <add-function signature='FooInt(PySequence)'>\
+                <inject-code class='target' position='beginning'>custom_code();</inject-code>\
+            </add-function>\
+            <add-function signature='method()'>\
+                <inject-code class='target' position='beginning'>custom_code();</inject-code>\
+            </add-function>\
+        </value-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* foo = classes.findClass("FooInt");
+    QVERIFY(foo->hasNonPrivateConstructor());
+    AbstractMetaFunctionList lst = foo->queryFunctions(AbstractMetaClass::Constructors);
+    foreach(AbstractMetaFunction* f, lst)
+        QVERIFY(f->signature().startsWith(f->name()));
+    QCOMPARE(lst.size(), 2);
+    const AbstractMetaFunction* method = foo->findFunction("method");
+    QVERIFY(method);
+}
+
+void TestAddFunction::testAddFunctionWithTemplateArg()
+{
+    const char cppCode[] = "template<class T> class Foo { };";
+    const char xmlCode[] = "\
+    <typesystem package='Package'>\
+        <primitive-type name='int'/>\
+        <container-type name='Foo'  type='list'/>\
+        <add-function signature='func(Foo&lt;int>)' />\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    QCOMPARE(t.builder()->globalFunctions().size(), 1);
+    AbstractMetaFunction* func = t.builder()->globalFunctions().first();
+    AbstractMetaArgument* arg = func->arguments().first();
+    QCOMPARE(arg->type()->instantiations().count(), 1);
+}
+
+QTEST_APPLESS_MAIN(TestAddFunction)
+
+#include "testaddfunction.moc"
+
diff --git a/ApiExtractor/tests/testaddfunction.h b/ApiExtractor/tests/testaddfunction.h
new file mode 100644
index 000000000..ce8c1fe41
--- /dev/null
+++ b/ApiExtractor/tests/testaddfunction.h
@@ -0,0 +1,49 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTADDFUNCTION_H
+#define TESTADDFUNCTION_H
+#include <QObject>
+
+class TestAddFunction : public QObject
+{
+    Q_OBJECT
+private slots:
+    void testParsingFuncNameAndConstness();
+    void testAddFunction();
+    void testAddFunctionConstructor();
+    void testAddFunctionTagDefaultValues();
+    void testAddFunctionCodeSnippets();
+    void testAddFunctionWithoutParenteses();
+    void testAddFunctionWithDefaultArgs();
+    void testAddFunctionAtModuleLevel();
+    void testAddFunctionWithVarargs();
+    void testAddStaticFunction();
+    void testAddGlobalFunction();
+    void testAddFunctionWithApiVersion();
+    void testModifyAddedFunction();
+    void testAddFunctionOnTypedef();
+    void testAddFunctionWithTemplateArg();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testarrayargument.cpp b/ApiExtractor/tests/testarrayargument.cpp
new file mode 100644
index 000000000..7750ded59
--- /dev/null
+++ b/ApiExtractor/tests/testarrayargument.cpp
@@ -0,0 +1,121 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testarrayargument.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestArrayArgument::testArrayArgumentWithSizeDefinedByInteger()
+{
+    const char* cppCode ="\
+    struct A { \
+        enum SomeEnum { Value0, Value1, NValues }; \
+        void method(double[3]); \
+    };";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <primitive-type name='double'/>\
+        <object-type name='A'>\
+            <enum-type name='SomeEnum'/>\
+        </object-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClass* classA = t.builder()->classes().findClass("A");
+    QVERIFY(classA);
+
+    const AbstractMetaArgument* arg = classA->functions().last()->arguments().first();
+    QVERIFY(arg->type()->isArray());
+    QCOMPARE(arg->type()->arrayElementCount(), 3);
+    QCOMPARE(arg->type()->arrayElementType()->name(), QString("double"));
+}
+
+void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValue()
+{
+    const char* cppCode ="\
+    struct A { \
+        enum SomeEnum { Value0, Value1, NValues }; \
+        void method(double[NValues]); \
+    };";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <primitive-type name='double'/>\
+        <object-type name='A'>\
+            <enum-type name='SomeEnum'/>\
+        </object-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClass* classA = t.builder()->classes().findClass("A");
+    QVERIFY(classA);
+
+    AbstractMetaEnum* someEnum = classA->findEnum("SomeEnum");
+    QVERIFY(someEnum);
+    AbstractMetaEnumValue* nvalues = classA->findEnumValue("NValues", someEnum);
+    QVERIFY(nvalues);
+
+    const AbstractMetaArgument* arg = classA->functions().last()->arguments().first();
+    QVERIFY(arg->type()->isArray());
+    QCOMPARE(arg->type()->arrayElementCount(), nvalues->value());
+    QCOMPARE(arg->type()->arrayElementType()->name(), QString("double"));
+};
+
+void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValueFromGlobalEnum()
+{
+    const char* cppCode ="\
+    enum SomeEnum { Value0, Value1, NValues }; \
+    struct A { \
+        void method(double[NValues]); \
+    };";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <primitive-type name='double'/>\
+        <enum-type name='SomeEnum'/>\
+        <object-type name='A'>\
+        </object-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClass* classA = t.builder()->classes().findClass("A");
+    QVERIFY(classA);
+
+    AbstractMetaEnum* someEnum = t.builder()->globalEnums().first();
+    QVERIFY(someEnum);
+    AbstractMetaEnumValue* nvalues = 0;
+    foreach (AbstractMetaEnumValue* enumValue, someEnum->values()) {
+        if (enumValue->name() == "NValues") {
+            nvalues = enumValue;
+            break;
+        }
+    }
+    QVERIFY(nvalues);
+
+    const AbstractMetaArgument* arg = classA->functions().last()->arguments().first();
+    QVERIFY(arg->type()->isArray());
+    QCOMPARE(arg->type()->arrayElementCount(), nvalues->value());
+    QCOMPARE(arg->type()->arrayElementType()->name(), QString("double"));
+};
+
+QTEST_APPLESS_MAIN(TestArrayArgument)
+
+#include "testarrayargument.moc"
diff --git a/ApiExtractor/tests/testarrayargument.h b/ApiExtractor/tests/testarrayargument.h
new file mode 100644
index 000000000..44cb6a6cb
--- /dev/null
+++ b/ApiExtractor/tests/testarrayargument.h
@@ -0,0 +1,37 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTARRAYARGUMENT_H
+#define TESTARRAYARGUMENT_H
+#include <QObject>
+
+class TestArrayArgument : public QObject
+{
+    Q_OBJECT
+private slots:
+    void testArrayArgumentWithSizeDefinedByInteger();
+    void testArrayArgumentWithSizeDefinedByEnumValue();
+    void testArrayArgumentWithSizeDefinedByEnumValueFromGlobalEnum();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testcodeinjection.cpp b/ApiExtractor/tests/testcodeinjection.cpp
new file mode 100644
index 000000000..ed2c379c2
--- /dev/null
+++ b/ApiExtractor/tests/testcodeinjection.cpp
@@ -0,0 +1,98 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testcodeinjection.h"
+#include <QFileInfo>
+#include <QDir>
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestCodeInjections::testReadFileUtf8()
+{
+    const char* cppCode ="struct A {};";
+    int argc = 0;
+    char *argv[] = {NULL};
+    QCoreApplication app(argc, argv);
+    QString filePath = QDir::currentPath();
+    QString xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <value-type name='A'> \
+            <conversion-rule file='"+filePath+"/utf8code.txt'/>\
+            <inject-code class='target' file='"+filePath+"/utf8code.txt' />\
+        </value-type>\
+        <value-type name='A::B'/> \
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode.toLocal8Bit().constData());
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QCOMPARE(classA->typeEntry()->codeSnips().count(), 1);
+    QString code = classA->typeEntry()->codeSnips().first().code();
+    QString utf8Data = QString::fromUtf8("\xC3\xA1\xC3\xA9\xC3\xAD\xC3\xB3\xC3\xBA");
+    QVERIFY(code.indexOf(utf8Data) != -1);
+    code = classA->typeEntry()->conversionRule();
+    QVERIFY(code.indexOf(utf8Data) != -1);
+}
+
+void TestCodeInjections::testInjectWithValidApiVersion()
+{
+    const char* cppCode ="struct A {};";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <value-type name='A'> \
+            <inject-code class='target' since='1.0'>\
+                test Inject code\
+            </inject-code>\
+        </value-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, true, "1.0");
+
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QCOMPARE(classA->typeEntry()->codeSnips().count(), 1);
+}
+
+void TestCodeInjections::testInjectWithInvalidApiVersion()
+{
+    const char* cppCode ="struct A {};";
+    const char* xmlCode  = "\
+    <typesystem package=\"Foo\"> \
+        <value-type name='A'> \
+            <inject-code class='target' since='1.0'>\
+                test Inject code\
+            </inject-code>\
+        </value-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, true, "0.1");
+
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QCOMPARE(classA->typeEntry()->codeSnips().count(), 0);
+}
+
+
+
+QTEST_APPLESS_MAIN(TestCodeInjections)
+
+#include "testcodeinjection.moc"
diff --git a/ApiExtractor/tests/testcodeinjection.h b/ApiExtractor/tests/testcodeinjection.h
new file mode 100644
index 000000000..e12b40d2d
--- /dev/null
+++ b/ApiExtractor/tests/testcodeinjection.h
@@ -0,0 +1,40 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTCODEINJECTIONS_H
+#define TESTCODEINJECTIONS_H
+
+#include <QObject>
+
+class AbstractMetaBuilder;
+
+class TestCodeInjections : public QObject
+{
+    Q_OBJECT
+private slots:
+    void testReadFileUtf8();
+    void testInjectWithValidApiVersion();
+    void testInjectWithInvalidApiVersion();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testcontainer.cpp b/ApiExtractor/tests/testcontainer.cpp
new file mode 100644
index 000000000..3d31f8a61
--- /dev/null
+++ b/ApiExtractor/tests/testcontainer.cpp
@@ -0,0 +1,99 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testcontainer.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestContainer::testContainerType()
+{
+    const char* cppCode ="\
+    namespace std {\
+    template<class T>\
+    class list { \
+        T get(int x) { return 0; }\
+    };\
+    }\
+    class A : public std::list<int> {\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <namespace-type name='std' generate='no' /> \
+        <container-type name='std::list' type='list' /> \
+        <object-type name='A'/> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, true);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    //search for class A
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QVERIFY(classA->typeEntry()->baseContainerType());
+    QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(classA->typeEntry()->baseContainerType())->type(), ContainerTypeEntry::ListContainer);
+}
+
+void TestContainer::testListOfValueType()
+{
+    const char* cppCode ="\
+    namespace std {\
+    template<class T>\
+    class list { \
+        T get(int x) { return 0; }\
+    };\
+    }\
+    class ValueType {};\
+    class A : public std::list<ValueType> {\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <namespace-type name='std' generate='no' /> \
+        <container-type name='std::list' type='list' /> \
+        <value-type name='ValueType'/> \
+        <value-type name='A'/> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, true);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 3);
+
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QCOMPARE(classA->templateBaseClassInstantiations().count(), 1);
+    const AbstractMetaType* templateInstanceType = classA->templateBaseClassInstantiations().first();
+    QVERIFY(templateInstanceType);
+
+    QCOMPARE(templateInstanceType->indirections(), 0);
+    QVERIFY(!templateInstanceType->typeEntry()->isObject());
+    QVERIFY(templateInstanceType->typeEntry()->isValue());
+    QVERIFY(!templateInstanceType->isReference());
+    QVERIFY(!templateInstanceType->isObject());
+    QVERIFY(!templateInstanceType->isValuePointer());
+    QVERIFY(templateInstanceType->isValue());
+}
+
+QTEST_APPLESS_MAIN(TestContainer)
+
+#include "testcontainer.moc"
diff --git a/ApiExtractor/tests/testcontainer.h b/ApiExtractor/tests/testcontainer.h
new file mode 100644
index 000000000..22e47eeba
--- /dev/null
+++ b/ApiExtractor/tests/testcontainer.h
@@ -0,0 +1,36 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTCONTAINER_H
+#define TESTCONTAINER_H
+#include <QObject>
+
+class TestContainer : public QObject
+{
+    Q_OBJECT
+private slots:
+    void testContainerType();
+    void testListOfValueType();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testconversionoperator.cpp b/ApiExtractor/tests/testconversionoperator.cpp
new file mode 100644
index 000000000..e14388e30
--- /dev/null
+++ b/ApiExtractor/tests/testconversionoperator.cpp
@@ -0,0 +1,179 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testconversionoperator.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+
+void TestConversionOperator::testConversionOperator()
+{
+    const char cppCode[] = "\
+    struct A {\
+    };\
+    struct B {\
+        operator A() const;\
+    };\
+    struct C {\
+        operator A() const;\
+    };";
+    const char xmlCode[] = "\
+    <typesystem package=\"Foo\">\
+        <value-type name='A' />\
+        <value-type name='B' />\
+        <value-type name='C' />\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    AbstractMetaClass* classB = classes.findClass("B");
+    AbstractMetaClass* classC = classes.findClass("C");
+    QVERIFY(classA);
+    QVERIFY(classB);
+    QVERIFY(classC);
+    QCOMPARE(classA->functions().count(), 2);
+    QCOMPARE(classB->functions().count(), 3);
+    QCOMPARE(classC->functions().count(), 3);
+    QCOMPARE(classA->externalConversionOperators().count(), 2);
+
+    AbstractMetaFunction* convOp = 0;
+    foreach(AbstractMetaFunction* func, classB->functions()) {
+        if (func->isConversionOperator()) {
+            convOp = func;
+            break;
+        }
+    }
+    QVERIFY(convOp);
+    QVERIFY(classA->externalConversionOperators().contains(convOp));
+}
+
+void TestConversionOperator::testConversionOperatorOfDiscardedClass()
+{
+    const char cppCode[] = "\
+    struct A {\
+    };\
+    struct B {\
+        operator A() const;\
+    };";
+    const char xmlCode[] = "\
+    <typesystem package=\"Foo\">\
+        <value-type name='A' />\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QCOMPARE(classA->externalConversionOperators().count(), 0);
+}
+
+void TestConversionOperator::testRemovedConversionOperator()
+{
+    const char cppCode[] = "\
+    struct A {\
+    };\
+    struct B {\
+        operator A() const;\
+    };";
+    const char xmlCode[] = "\
+    <typesystem package=\"Foo\">\
+        <value-type name='A' />\
+        <value-type name='B'>\
+            <modify-function signature='operator A() const' remove='all' />\
+        </value-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    AbstractMetaClass* classB = classes.findClass("B");
+    QVERIFY(classA);
+    QVERIFY(classB);
+    QCOMPARE(classA->functions().count(), 2);
+    QCOMPARE(classB->functions().count(), 3);
+    QCOMPARE(classA->externalConversionOperators().count(), 0);
+    QCOMPARE(classA->implicitConversions().count(), 0);
+}
+
+void TestConversionOperator::testConversionOperatorReturningReference()
+{
+    const char cppCode[] = "\
+    struct A {};\
+    struct B {\
+        operator A&() const;\
+    };";
+    const char xmlCode[] = "\
+    <typesystem package='Foo'>\
+        <value-type name='A' />\
+        <value-type name='B' />\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    AbstractMetaClass* classB = classes.findClass("B");
+    QVERIFY(classA);
+    QVERIFY(classB);
+    QCOMPARE(classA->functions().count(), 2);
+    QCOMPARE(classB->functions().count(), 3);
+    QCOMPARE(classA->externalConversionOperators().count(), 1);
+    QCOMPARE(classA->externalConversionOperators().first()->type()->cppSignature(), QString("A"));
+    QCOMPARE(classA->externalConversionOperators().first()->ownerClass()->name(), QString("B"));
+    QCOMPARE(classA->implicitConversions().count(), 1);
+    QCOMPARE(classA->implicitConversions().first()->type()->cppSignature(), QString("A"));
+    QCOMPARE(classA->implicitConversions().first()->ownerClass()->name(), QString("B"));
+}
+
+void TestConversionOperator::testConversionOperatorReturningConstReference()
+{
+    const char cppCode[] = "\
+    struct A {};\
+    struct B {\
+        operator const A&() const;\
+    };";
+    const char xmlCode[] = "\
+    <typesystem package='Foo'>\
+        <value-type name='A' />\
+        <value-type name='B' />\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    AbstractMetaClass* classB = classes.findClass("B");
+    QVERIFY(classA);
+    QVERIFY(classB);
+    QCOMPARE(classA->functions().count(), 2);
+    QCOMPARE(classB->functions().count(), 3);
+    QCOMPARE(classA->externalConversionOperators().count(), 1);
+    QCOMPARE(classA->externalConversionOperators().first()->type()->cppSignature(), QString("A"));
+    QCOMPARE(classA->externalConversionOperators().first()->ownerClass()->name(), QString("B"));
+    QCOMPARE(classA->implicitConversions().count(), 1);
+    QCOMPARE(classA->implicitConversions().first()->type()->cppSignature(), QString("A"));
+    QCOMPARE(classA->implicitConversions().first()->ownerClass()->name(), QString("B"));
+}
+
+QTEST_APPLESS_MAIN(TestConversionOperator)
+
+#include "testconversionoperator.moc"
diff --git a/ApiExtractor/tests/testconversionoperator.h b/ApiExtractor/tests/testconversionoperator.h
new file mode 100644
index 000000000..a901f3099
--- /dev/null
+++ b/ApiExtractor/tests/testconversionoperator.h
@@ -0,0 +1,39 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTCONVERSIONOPERATOR_H
+#define TESTCONVERSIONOPERATOR_H
+#include <QObject>
+
+class TestConversionOperator : public QObject
+{
+    Q_OBJECT
+private slots:
+    void testConversionOperator();
+    void testConversionOperatorOfDiscardedClass();
+    void testRemovedConversionOperator();
+    void testConversionOperatorReturningReference();
+    void testConversionOperatorReturningConstReference();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testconversionruletag.cpp b/ApiExtractor/tests/testconversionruletag.cpp
new file mode 100644
index 000000000..6228ef287
--- /dev/null
+++ b/ApiExtractor/tests/testconversionruletag.cpp
@@ -0,0 +1,230 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testconversionruletag.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+#include <QFile>
+#include <QTemporaryFile>
+
+void TestConversionRuleTag::testConversionRuleTagWithFile()
+{
+    // temp file used later
+    const char conversionData[] = "Hi! I'm a conversion rule.";
+    QTemporaryFile file;
+    file.open();
+    QCOMPARE(file.write(conversionData), qint64(sizeof(conversionData)-1));
+    file.close();
+
+    const char cppCode[] = "struct A {};";
+    QString xmlCode = "\
+    <typesystem package='Foo'>\
+        <value-type name='A'>\
+            <conversion-rule file='"+ file.fileName() +"' />\
+        </value-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode.toLocal8Bit().data());
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    const ComplexTypeEntry* typeEntry = classA->typeEntry();
+    QVERIFY(typeEntry->hasConversionRule());
+    QCOMPARE(typeEntry->conversionRule(), QString(conversionData));
+}
+
+void TestConversionRuleTag::testConversionRuleTagReplace()
+{
+    const char cppCode[] = "\
+    struct A {\
+        A();\
+        A(const char*, int);\
+    };\
+    struct B {\
+        A createA();\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'>\
+        <primitive-type name='int'/>\
+        <primitive-type name='char'/>\
+        <primitive-type name='A'>\
+            <conversion-rule>\
+                <native-to-target>\
+                DoThis();\
+                return ConvertFromCppToPython(%IN);\
+                </native-to-target>\
+                <target-to-native>\
+                    <add-conversion type='TargetNone' check='%IN == Target_None'>\
+                    DoThat();\
+                    DoSomething();\
+                    %OUT = A();\
+                    </add-conversion>\
+                    <add-conversion type='B' check='CheckIfInputObjectIsB(%IN)'>\
+                    %OUT = %IN.createA();\
+                    </add-conversion>\
+                    <add-conversion type='String' check='String_Check(%IN)'>\
+                    %OUT = new A(String_AsString(%IN), String_GetSize(%IN));\
+                    </add-conversion>\
+                </target-to-native>\
+            </conversion-rule>\
+        </primitive-type>\
+        <value-type name='B'/>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    TypeDatabase* typeDb = TypeDatabase::instance();
+    PrimitiveTypeEntry* typeA = typeDb->findPrimitiveType("A");
+    QVERIFY(typeA);
+
+    CustomConversion* conversion = typeA->customConversion();
+    QVERIFY(conversion);
+
+    QCOMPARE(typeA, conversion->ownerType());
+    QCOMPARE(conversion->nativeToTargetConversion().trimmed(), QString("DoThis();                return ConvertFromCppToPython(%IN);"));
+
+    QVERIFY(conversion->replaceOriginalTargetToNativeConversions());
+    QVERIFY(conversion->hasTargetToNativeConversions());
+    QCOMPARE(conversion->targetToNativeConversions().size(), 3);
+
+    CustomConversion::TargetToNativeConversion* toNative = conversion->targetToNativeConversions().at(0);
+    QVERIFY(toNative);
+    QCOMPARE(toNative->sourceTypeName(), QString("TargetNone"));
+    QVERIFY(toNative->isCustomType());
+    QCOMPARE(toNative->sourceType(), (const TypeEntry*)0);
+    QCOMPARE(toNative->sourceTypeCheck(), QString("%IN == Target_None"));
+    QCOMPARE(toNative->conversion().trimmed(), QString("DoThat();                    DoSomething();                    %OUT = A();"));
+
+    toNative = conversion->targetToNativeConversions().at(1);
+    QVERIFY(toNative);
+    QCOMPARE(toNative->sourceTypeName(), QString("B"));
+    QVERIFY(!toNative->isCustomType());
+    TypeEntry* typeB = typeDb->findType("B");
+    QVERIFY(typeB);
+    QCOMPARE(toNative->sourceType(), typeB);
+    QCOMPARE(toNative->sourceTypeCheck(), QString("CheckIfInputObjectIsB(%IN)"));
+    QCOMPARE(toNative->conversion().trimmed(), QString("%OUT = %IN.createA();"));
+
+    toNative = conversion->targetToNativeConversions().at(2);
+    QVERIFY(toNative);
+    QCOMPARE(toNative->sourceTypeName(), QString("String"));
+    QVERIFY(toNative->isCustomType());
+    QCOMPARE(toNative->sourceType(), (const TypeEntry*)0);
+    QCOMPARE(toNative->sourceTypeCheck(), QString("String_Check(%IN)"));
+    QCOMPARE(toNative->conversion().trimmed(), QString("%OUT = new A(String_AsString(%IN), String_GetSize(%IN));"));
+}
+
+void TestConversionRuleTag::testConversionRuleTagAdd()
+{
+    const char cppCode[] = "\
+    struct Date {\
+        Date();\
+        Date(int, int, int);\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'>\
+        <primitive-type name='int'/>\
+        <value-type name='Date'>\
+            <conversion-rule>\
+                <target-to-native replace='no'>\
+                    <add-conversion type='TargetDate' check='TargetDate_Check(%IN)'>\
+                    if (!TargetDateTimeAPI) TargetDateTime_IMPORT;\
+                    %OUT = new Date(TargetDate_Day(%IN), TargetDate_Month(%IN), TargetDate_Year(%IN));\
+                    </add-conversion>\
+                </target-to-native>\
+            </conversion-rule>\
+        </value-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClass* classA = t.builder()->classes().findClass("Date");
+    QVERIFY(classA);
+
+    CustomConversion* conversion = classA->typeEntry()->customConversion();
+    QVERIFY(conversion);
+
+    QCOMPARE(conversion->nativeToTargetConversion(), QString());
+
+    QVERIFY(!conversion->replaceOriginalTargetToNativeConversions());
+    QVERIFY(conversion->hasTargetToNativeConversions());
+    QCOMPARE(conversion->targetToNativeConversions().size(), 1);
+
+    CustomConversion::TargetToNativeConversion* toNative = conversion->targetToNativeConversions().first();
+    QVERIFY(toNative);
+    QCOMPARE(toNative->sourceTypeName(), QString("TargetDate"));
+    QVERIFY(toNative->isCustomType());
+    QCOMPARE(toNative->sourceType(), (const TypeEntry*)0);
+    QCOMPARE(toNative->sourceTypeCheck(), QString("TargetDate_Check(%IN)"));
+    QCOMPARE(toNative->conversion().trimmed(), QString("if (!TargetDateTimeAPI) TargetDateTime_IMPORT;                    %OUT = new Date(TargetDate_Day(%IN), TargetDate_Month(%IN), TargetDate_Year(%IN));"));
+}
+
+void TestConversionRuleTag::testConversionRuleTagWithInsertTemplate()
+{
+    const char cppCode[] = "struct A {};";
+    const char* xmlCode = "\
+    <typesystem package='Foo'>\
+        <primitive-type name='int'/>\
+        <template name='native_to_target'>\
+        return ConvertFromCppToPython(%IN);\
+        </template>\
+        <template name='target_to_native'>\
+        %OUT = %IN.createA();\
+        </template>\
+        <primitive-type name='A'>\
+            <conversion-rule>\
+                <native-to-target>\
+                    <insert-template name='native_to_target'/>\
+                </native-to-target>\
+                <target-to-native>\
+                    <add-conversion type='TargetType'>\
+                        <insert-template name='target_to_native'/>\
+                    </add-conversion>\
+                </target-to-native>\
+            </conversion-rule>\
+        </primitive-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    TypeDatabase* typeDb = TypeDatabase::instance();
+    PrimitiveTypeEntry* typeA = typeDb->findPrimitiveType("A");
+    QVERIFY(typeA);
+
+    CustomConversion* conversion = typeA->customConversion();
+    QVERIFY(conversion);
+
+    QCOMPARE(typeA, conversion->ownerType());
+    QCOMPARE(conversion->nativeToTargetConversion().trimmed(),
+             QString("// TEMPLATE - native_to_target - START        return ConvertFromCppToPython(%IN);        // TEMPLATE - native_to_target - END"));
+
+    QVERIFY(conversion->hasTargetToNativeConversions());
+    QCOMPARE(conversion->targetToNativeConversions().size(), 1);
+
+    CustomConversion::TargetToNativeConversion* toNative = conversion->targetToNativeConversions().first();
+    QVERIFY(toNative);
+    QCOMPARE(toNative->conversion().trimmed(),
+             QString("// TEMPLATE - target_to_native - START        %OUT = %IN.createA();        // TEMPLATE - target_to_native - END"));
+}
+
+QTEST_APPLESS_MAIN(TestConversionRuleTag)
+
+#include "testconversionruletag.moc"
diff --git a/ApiExtractor/tests/testconversionruletag.h b/ApiExtractor/tests/testconversionruletag.h
new file mode 100644
index 000000000..8ab1481b1
--- /dev/null
+++ b/ApiExtractor/tests/testconversionruletag.h
@@ -0,0 +1,38 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTCONVERSIONRULE_H
+#define TESTCONVERSIONRULE_H
+#include <QObject>
+
+class TestConversionRuleTag : public QObject
+{
+    Q_OBJECT
+private slots:
+    void testConversionRuleTagWithFile();
+    void testConversionRuleTagReplace();
+    void testConversionRuleTagAdd();
+    void testConversionRuleTagWithInsertTemplate();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testctorinformation.cpp b/ApiExtractor/tests/testctorinformation.cpp
new file mode 100644
index 000000000..09d57eb84
--- /dev/null
+++ b/ApiExtractor/tests/testctorinformation.cpp
@@ -0,0 +1,71 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testctorinformation.h"
+#include "abstractmetabuilder.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestCtorInformation::testCtorIsPrivate()
+{
+    const char* cppCode = "class Control { public: Control() {} };\
+                           class Subject { private: Subject() {} };\
+                           class CtorLess { };";
+    const char* xmlCode = "<typesystem package='Foo'>\
+                                <value-type name='Control'/>\
+                                <object-type name='Subject'/>\
+                                <value-type name='CtorLess'/>\
+                           </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 3);
+    QCOMPARE(classes.findClass("Control")->hasNonPrivateConstructor(), true);
+    QCOMPARE(classes.findClass("Subject")->hasNonPrivateConstructor(), false);
+    QCOMPARE(classes.findClass("CtorLess")->hasNonPrivateConstructor(), true);
+}
+
+void TestCtorInformation::testHasNonPrivateCtor()
+{
+    const char* cppCode = "template<typename T>\
+                           struct Base { Base(double) {} };\
+                           typedef Base<int> Derived;\
+                          ";
+    const char* xmlCode = "<typesystem package='Foo'>\
+                                <primitive-type name='int' />\
+                                <primitive-type name='double' />\
+                                <object-type name='Base' generate='no'/>\
+                                <object-type name='Derived'/>\
+                           </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    AbstractMetaClass* base = classes.findClass("Base");
+    QCOMPARE(base->hasNonPrivateConstructor(), true);
+    AbstractMetaClass* derived = classes.findClass("Derived");
+    QCOMPARE(derived->hasNonPrivateConstructor(), true);
+}
+
+QTEST_APPLESS_MAIN(TestCtorInformation)
+
+#include "testctorinformation.moc"
+
diff --git a/ApiExtractor/tests/testctorinformation.h b/ApiExtractor/tests/testctorinformation.h
new file mode 100644
index 000000000..12d2529af
--- /dev/null
+++ b/ApiExtractor/tests/testctorinformation.h
@@ -0,0 +1,39 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTCTORINFORMATION_H
+#define TESTCTORINFORMATION_H
+
+#include <QObject>
+
+class AbstractMetaBuilder;
+
+class TestCtorInformation: public QObject
+{
+    Q_OBJECT
+private slots:
+    void testCtorIsPrivate();
+    void testHasNonPrivateCtor();
+};
+
+#endif // TESTCTORINFORMATION_H
diff --git a/ApiExtractor/tests/testdroptypeentries.cpp b/ApiExtractor/tests/testdroptypeentries.cpp
new file mode 100644
index 000000000..5e646eac9
--- /dev/null
+++ b/ApiExtractor/tests/testdroptypeentries.cpp
@@ -0,0 +1,138 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testdroptypeentries.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+static const char* cppCode ="\
+    struct ValueA {};\
+    struct ValueB {};\
+    struct ObjectA {};\
+    struct ObjectB {};\
+    namespace NamespaceA {\
+        struct InnerClassA {};\
+        namespace InnerNamespaceA {}\
+    }\
+    namespace NamespaceB {}\
+    enum EnumA { Value0 };\
+    enum EnumB { Value1 };\
+    void funcA();\
+    void funcB();\
+";
+
+static const char* xmlCode = "\
+<typesystem package='Foo'>\
+    <value-type name='ValueA' />\
+    <value-type name='ValueB' />\
+    <object-type name='ObjectA' />\
+    <object-type name='ObjectB' />\
+    <namespace-type name='NamespaceA'>\
+        <value-type name='InnerClassA' />\
+        <namespace-type name='InnerNamespaceA' />\
+    </namespace-type>\
+    <namespace-type name='NamespaceB' />\
+    <enum-type name='EnumA' />\
+    <enum-type name='EnumB' />\
+    <function signature='funcA()' />\
+    <function signature='funcB()' />\
+</typesystem>";
+
+void TestDropTypeEntries::testDropEntries()
+{
+    QStringList droppedEntries("Foo.ValueB");
+    droppedEntries << "Foo.ObjectB" << "Foo.NamespaceA.InnerClassA";
+    droppedEntries << "Foo.NamespaceB" << "Foo.EnumB" << "Foo.funcB()";
+    droppedEntries << "Foo.NamespaceA.InnerNamespaceA";
+    TestUtil t(cppCode, xmlCode, false, 0, droppedEntries);
+
+    AbstractMetaClassList classes = t.builder()->classes();
+    QVERIFY(classes.findClass("ValueA"));
+    QVERIFY(!classes.findClass("ValueB"));
+    QVERIFY(classes.findClass("ObjectA"));
+    QVERIFY(!classes.findClass("ObjectB"));
+    QVERIFY(classes.findClass("NamespaceA"));
+    QVERIFY(!classes.findClass("NamespaceA::InnerClassA"));
+    QVERIFY(!classes.findClass("NamespaceB"));
+
+    AbstractMetaEnumList globalEnums = t.builder()->globalEnums();
+    QCOMPARE(globalEnums.count(), 1);
+    QCOMPARE(globalEnums.first()->name(), QString("EnumA"));
+
+    TypeDatabase* td = TypeDatabase::instance();
+    QVERIFY(td->findType("funcA"));
+    QVERIFY(!td->findType("funcB"));
+}
+
+void TestDropTypeEntries::testDontDropEntries()
+{
+    TestUtil t(cppCode, xmlCode, false);
+
+    AbstractMetaClassList classes = t.builder()->classes();
+    QVERIFY(classes.findClass("ValueA"));
+    QVERIFY(classes.findClass("ValueB"));
+    QVERIFY(classes.findClass("ObjectA"));
+    QVERIFY(classes.findClass("ObjectB"));
+    QVERIFY(classes.findClass("NamespaceA"));
+    QVERIFY(classes.findClass("NamespaceA::InnerClassA"));
+    QVERIFY(classes.findClass("NamespaceB"));
+
+    QCOMPARE(t.builder()->globalEnums().size(), 2);
+
+    TypeDatabase* td = TypeDatabase::instance();
+    QVERIFY(td->findType("funcA"));
+    QVERIFY(td->findType("funcB"));
+}
+
+static const char* cppCode2 ="\
+    struct ValueA {\
+        void func();\
+    };\
+";
+
+static const char* xmlCode2 = "\
+<typesystem package='Foo'>\
+    <value-type name='ValueA'>\
+        <modify-function signature='func()'>\
+            <remove class='all' />\
+        </modify-function>\
+    </value-type>\
+</typesystem>";
+
+void TestDropTypeEntries::testDropEntryWithChildTags()
+{
+    QStringList droppedEntries("Foo.ValueA");
+    TestUtil t(cppCode2, xmlCode2, false, 0, droppedEntries);
+    QVERIFY(!t.builder()->classes().findClass("ValueA"));
+}
+
+void TestDropTypeEntries::testDontDropEntryWithChildTags()
+{
+    TestUtil t(cppCode2, xmlCode2, false);
+    QVERIFY(t.builder()->classes().findClass("ValueA"));
+}
+
+QTEST_APPLESS_MAIN(TestDropTypeEntries)
+
+#include "testdroptypeentries.moc"
+
diff --git a/ApiExtractor/tests/testdroptypeentries.h b/ApiExtractor/tests/testdroptypeentries.h
new file mode 100644
index 000000000..e91292c12
--- /dev/null
+++ b/ApiExtractor/tests/testdroptypeentries.h
@@ -0,0 +1,39 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTDROPTYPEENTRIES_H
+#define TESTDROPTYPEENTRIES_H
+
+#include <QObject>
+
+class TestDropTypeEntries : public QObject
+{
+    Q_OBJECT
+    private slots:
+        void testDropEntries();
+        void testDontDropEntries();
+        void testDropEntryWithChildTags();
+        void testDontDropEntryWithChildTags();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testdtorinformation.cpp b/ApiExtractor/tests/testdtorinformation.cpp
new file mode 100644
index 000000000..1aaeb91dc
--- /dev/null
+++ b/ApiExtractor/tests/testdtorinformation.cpp
@@ -0,0 +1,76 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testdtorinformation.h"
+#include "abstractmetabuilder.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestDtorInformation::testDtorIsPrivate()
+{
+    const char* cppCode ="class Control { public: ~Control() {} }; class Subject { private: ~Subject() {} };";
+    const char* xmlCode = "<typesystem package=\"Foo\"><value-type name=\"Control\"/><value-type name=\"Subject\"/></typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.findClass("Control")->hasPrivateDestructor(), false);
+    QCOMPARE(classes.findClass("Subject")->hasPrivateDestructor(), true);
+}
+
+void TestDtorInformation::testDtorIsProtected()
+{
+    const char* cppCode ="class Control { public: ~Control() {} }; class Subject { protected: ~Subject() {} };";
+    const char* xmlCode = "<typesystem package=\"Foo\"><value-type name=\"Control\"/><value-type name=\"Subject\"/></typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.findClass("Control")->hasProtectedDestructor(), false);
+    QCOMPARE(classes.findClass("Subject")->hasProtectedDestructor(), true);
+}
+
+void TestDtorInformation::testDtorIsVirtual()
+{
+    const char* cppCode ="class Control { public: ~Control() {} }; class Subject { protected: virtual ~Subject() {} };";
+    const char* xmlCode = "<typesystem package=\"Foo\"><value-type name=\"Control\"/><value-type name=\"Subject\"/></typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.findClass("Control")->hasVirtualDestructor(), false);
+    QCOMPARE(classes.findClass("Subject")->hasVirtualDestructor(), true);
+}
+
+void TestDtorInformation::testClassWithVirtualDtorIsPolymorphic()
+{
+    const char* cppCode ="class Control { public: virtual ~Control() {} }; class Subject { protected: virtual ~Subject() {} };";
+    const char* xmlCode = "<typesystem package=\"Foo\"><value-type name=\"Control\"/><value-type name=\"Subject\"/></typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.findClass("Control")->isPolymorphic(), true);
+    QCOMPARE(classes.findClass("Subject")->isPolymorphic(), true);
+}
+
+QTEST_APPLESS_MAIN(TestDtorInformation)
+
+#include "testdtorinformation.moc"
+
diff --git a/ApiExtractor/tests/testdtorinformation.h b/ApiExtractor/tests/testdtorinformation.h
new file mode 100644
index 000000000..2e378001b
--- /dev/null
+++ b/ApiExtractor/tests/testdtorinformation.h
@@ -0,0 +1,41 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTDTORINFORMATION_H
+#define TESTDTORINFORMATION_H
+
+#include <QObject>
+
+class AbstractMetaBuilder;
+
+class TestDtorInformation: public QObject
+{
+    Q_OBJECT
+private slots:
+    void testDtorIsPrivate();
+    void testDtorIsProtected();
+    void testDtorIsVirtual();
+    void testClassWithVirtualDtorIsPolymorphic();
+};
+
+#endif // TESTDTORINFORMATION_H
diff --git a/ApiExtractor/tests/testenum.cpp b/ApiExtractor/tests/testenum.cpp
new file mode 100644
index 000000000..85796a1e9
--- /dev/null
+++ b/ApiExtractor/tests/testenum.cpp
@@ -0,0 +1,378 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testenum.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestEnum::testEnumCppSignature()
+{
+    const char* cppCode ="\
+    enum GlobalEnum { A, B };\
+    \
+    struct A {\
+        enum ClassEnum { A, B };\
+        void method(ClassEnum);\
+    };\
+    void func(A::ClassEnum);\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <enum-type name='GlobalEnum' />\
+        <value-type name='A'> \
+            <enum-type name='ClassEnum' />\
+        </value-type> \
+        <function signature='func(A::ClassEnum)' />\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 1);
+
+    AbstractMetaEnumList globalEnums = t.builder()->globalEnums();
+    QCOMPARE(globalEnums.count(), 1);
+    QCOMPARE(globalEnums.first()->name(), QString("GlobalEnum"));
+
+    // enum as parameter of a function
+    AbstractMetaFunctionList functions = t.builder()->globalFunctions();
+    QCOMPARE(functions.count(), 1);
+    QCOMPARE(functions.first()->arguments().count(), 1);
+    QCOMPARE(functions.first()->arguments().first()->type()->cppSignature(), QString("A::ClassEnum"));
+
+    // enum as parameter of a method
+    AbstractMetaClass* classA = classes.findClass("A");
+    QCOMPARE(classA->enums().count(), 1);
+    AbstractMetaFunctionList funcs = classA->queryFunctionsByName("method");
+    QVERIFY(!funcs.isEmpty());
+    AbstractMetaFunction* method = funcs.first();
+    QVERIFY(method);
+    AbstractMetaArgument* arg = method->arguments().first();
+    QCOMPARE(arg->type()->name(), QString("ClassEnum"));
+    QCOMPARE(arg->type()->cppSignature(), QString("A::ClassEnum"));
+    QCOMPARE(functions.first()->arguments().count(), 1);
+    arg = functions.first()->arguments().first();
+    QCOMPARE(arg->type()->name(), QString("ClassEnum"));
+    QCOMPARE(arg->type()->cppSignature(), QString("A::ClassEnum"));
+
+    AbstractMetaEnumList classEnums = classA->enums();
+    QCOMPARE(classEnums.first()->name(), QString("ClassEnum"));
+}
+
+void TestEnum::testEnumWithApiVersion()
+{
+    const char* cppCode ="\
+    struct A {\
+        enum ClassEnum { EnumA, EnumB };\
+        enum ClassEnum2 { EnumC, EnumD };\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <value-type name='A'> \
+            <enum-type name='ClassEnum' since='0.1'/>\
+            <enum-type name='ClassEnum2' since='0.2'/>\
+        </value-type> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, true, "0.1");
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 1);
+    QCOMPARE(classes[0]->enums().count(), 1);
+}
+
+void TestEnum::testAnonymousEnum()
+{
+    const char* cppCode ="\
+    enum { Global0, Global1 }; \
+    struct A {\
+        enum { A0, A1 };\
+        enum { isThis = true, isThat = false };\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <!-- Uses the first value of the enum to identify it. -->\
+        <enum-type identified-by-value='Global0'/>\
+        <value-type name='A'> \
+            <!-- Uses the second value of the enum to identify it. -->\
+            <enum-type identified-by-value='A1'/>\
+            <enum-type identified-by-value='isThis'/>\
+        </value-type> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+
+    AbstractMetaEnumList globalEnums = t.builder()->globalEnums();
+    QCOMPARE(globalEnums.count(), 1);
+    QCOMPARE(globalEnums.first()->typeEntry()->qualifiedCppName(), QString("Global0"));
+    QVERIFY(globalEnums.first()->isAnonymous());
+
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 1);
+    QCOMPARE(classes[0]->enums().count(), 2);
+
+    AbstractMetaEnum* anonEnumA1 = classes[0]->findEnum("A1");
+    QVERIFY(anonEnumA1);
+    QVERIFY(anonEnumA1->isAnonymous());
+    QCOMPARE(anonEnumA1->typeEntry()->qualifiedCppName(), QString("A::A1"));
+
+    AbstractMetaEnumValue* enumValueA0 = anonEnumA1->values().first();
+    QCOMPARE(enumValueA0->name(), QString("A0"));
+    QCOMPARE(enumValueA0->value(), 0);
+    QCOMPARE(enumValueA0->stringValue(), QString(""));
+
+    AbstractMetaEnumValue* enumValueA1 = anonEnumA1->values().last();
+    QCOMPARE(enumValueA1->name(), QString("A1"));
+    QCOMPARE(enumValueA1->value(), 1);
+    QCOMPARE(enumValueA1->stringValue(), QString(""));
+
+    AbstractMetaEnum* anonEnumIsThis = classes[0]->findEnum("isThis");
+    QVERIFY(anonEnumIsThis);
+    QVERIFY(anonEnumIsThis->isAnonymous());
+    QCOMPARE(anonEnumIsThis->typeEntry()->qualifiedCppName(), QString("A::isThis"));
+
+    AbstractMetaEnumValue* enumValueIsThis = anonEnumIsThis->values().first();
+    QCOMPARE(enumValueIsThis->name(), QString("isThis"));
+    QCOMPARE(enumValueIsThis->value(), static_cast<int>(true));
+    QCOMPARE(enumValueIsThis->stringValue(), QString("true"));
+
+    AbstractMetaEnumValue* enumValueIsThat = anonEnumIsThis->values().last();
+    QCOMPARE(enumValueIsThat->name(), QString("isThat"));
+    QCOMPARE(enumValueIsThat->value(), static_cast<int>(false));
+    QCOMPARE(enumValueIsThat->stringValue(), QString("false"));
+}
+
+void TestEnum::testGlobalEnums()
+{
+    const char* cppCode ="\
+    enum EnumA { A0, A1 }; \
+    enum EnumB { B0 = 2, B1 = 0x4 }; \
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <enum-type name='EnumA'/>\
+        <enum-type name='EnumB'/>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+
+    AbstractMetaEnumList globalEnums = t.builder()->globalEnums();
+    QCOMPARE(globalEnums.count(), 2);
+
+    AbstractMetaEnum* enumA = globalEnums.first();
+    QCOMPARE(enumA->typeEntry()->qualifiedCppName(), QString("EnumA"));
+
+    AbstractMetaEnumValue* enumValueA0 = enumA->values().first();
+    QCOMPARE(enumValueA0->name(), QString("A0"));
+    QCOMPARE(enumValueA0->value(), 0);
+    QCOMPARE(enumValueA0->stringValue(), QString(""));
+
+    AbstractMetaEnumValue* enumValueA1 = enumA->values().last();
+    QCOMPARE(enumValueA1->name(), QString("A1"));
+    QCOMPARE(enumValueA1->value(), 1);
+    QCOMPARE(enumValueA1->stringValue(), QString(""));
+
+    AbstractMetaEnum* enumB = globalEnums.last();
+    QCOMPARE(enumB->typeEntry()->qualifiedCppName(), QString("EnumB"));
+
+    AbstractMetaEnumValue* enumValueB0 = enumB->values().first();
+    QCOMPARE(enumValueB0->name(), QString("B0"));
+    QCOMPARE(enumValueB0->value(), 2);
+    QCOMPARE(enumValueB0->stringValue(), QString("2"));
+
+    AbstractMetaEnumValue* enumValueB1 = enumB->values().last();
+    QCOMPARE(enumValueB1->name(), QString("B1"));
+    QCOMPARE(enumValueB1->value(), 4);
+    QCOMPARE(enumValueB1->stringValue(), QString("0x4"));
+}
+
+void TestEnum::testEnumValueFromNeighbourEnum()
+{
+    const char* cppCode ="\
+    namespace A {\
+        enum EnumA { ValueA0, ValueA1 };\
+        enum EnumB { ValueB0 = A::ValueA1, ValueB1 = ValueA0 };\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <namespace-type name='A'> \
+            <enum-type name='EnumA'/>\
+            <enum-type name='EnumB'/>\
+        </namespace-type> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 1);
+    QCOMPARE(classes[0]->enums().count(), 2);
+
+    AbstractMetaEnum* enumA = classes[0]->findEnum("EnumA");
+    QVERIFY(enumA);
+    QCOMPARE(enumA->typeEntry()->qualifiedCppName(), QString("A::EnumA"));
+
+    AbstractMetaEnumValue* enumValueA0 = enumA->values().first();
+    QCOMPARE(enumValueA0->name(), QString("ValueA0"));
+    QCOMPARE(enumValueA0->value(), 0);
+    QCOMPARE(enumValueA0->stringValue(), QString(""));
+
+    AbstractMetaEnumValue* enumValueA1 = enumA->values().last();
+    QCOMPARE(enumValueA1->name(), QString("ValueA1"));
+    QCOMPARE(enumValueA1->value(), 1);
+    QCOMPARE(enumValueA1->stringValue(), QString(""));
+
+    AbstractMetaEnum* enumB = classes[0]->findEnum("EnumB");
+    QVERIFY(enumB);
+    QCOMPARE(enumB->typeEntry()->qualifiedCppName(), QString("A::EnumB"));
+
+    AbstractMetaEnumValue* enumValueB0 = enumB->values().first();
+    QCOMPARE(enumValueB0->name(), QString("ValueB0"));
+    QCOMPARE(enumValueB0->value(), 1);
+    QCOMPARE(enumValueB0->stringValue(), QString("A::ValueA1"));
+
+    AbstractMetaEnumValue* enumValueB1 = enumB->values().last();
+    QCOMPARE(enumValueB1->name(), QString("ValueB1"));
+    QCOMPARE(enumValueB1->value(), 0);
+    QCOMPARE(enumValueB1->stringValue(), QString("ValueA0"));
+}
+
+void TestEnum::testEnumValueFromExpression()
+{
+    const char* cppCode ="\
+    struct A {\
+        enum EnumA {\
+            ValueA0 = 3u,\
+            ValueA1 = ~3u,\
+            ValueA2 = ~3,\
+            ValueA3 = 0xf0,\
+            ValueA4 = 8 |ValueA3,\
+            ValueA5 = ValueA3|32,\
+            ValueA6 = ValueA3 >> 1,\
+            ValueA7 = ValueA3 << 1\
+        };\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <value-type name='A'> \
+            <enum-type name='EnumA'/>\
+        </value-type> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+
+    AbstractMetaClass* classA = t.builder()->classes().findClass("A");
+    QVERIFY(classA);
+
+    AbstractMetaEnum* enumA = classA->findEnum("EnumA");
+    QVERIFY(enumA);
+    QCOMPARE(enumA->typeEntry()->qualifiedCppName(), QString("A::EnumA"));
+
+    AbstractMetaEnumValue* valueA0 = enumA->values().at(0);
+    QCOMPARE(valueA0->name(), QString("ValueA0"));
+    QCOMPARE(valueA0->stringValue(), QString("3u"));
+    QCOMPARE(valueA0->value(), (int) 3u);
+
+    AbstractMetaEnumValue* valueA1 = enumA->values().at(1);
+    QCOMPARE(valueA1->name(), QString("ValueA1"));
+    QCOMPARE(valueA1->stringValue(), QString("~3u"));
+    QCOMPARE(valueA1->value(), (int) ~3u);
+
+    AbstractMetaEnumValue* valueA2 = enumA->values().at(2);
+    QCOMPARE(valueA2->name(), QString("ValueA2"));
+    QCOMPARE(valueA2->stringValue(), QString("~3"));
+    QCOMPARE(valueA2->value(), ~3);
+
+    AbstractMetaEnumValue* valueA3 = enumA->values().at(3);
+    QCOMPARE(valueA3->name(), QString("ValueA3"));
+    QCOMPARE(valueA3->stringValue(), QString("0xf0"));
+    QCOMPARE(valueA3->value(), 0xf0);
+
+    AbstractMetaEnumValue* valueA4 = enumA->values().at(4);
+    QCOMPARE(valueA4->name(), QString("ValueA4"));
+    QCOMPARE(valueA4->stringValue(), QString("8|ValueA3"));
+    QCOMPARE(valueA4->value(), 8|0xf0);
+
+    AbstractMetaEnumValue* valueA5 = enumA->values().at(5);
+    QCOMPARE(valueA5->name(), QString("ValueA5"));
+    QCOMPARE(valueA5->stringValue(), QString("ValueA3|32"));
+    QCOMPARE(valueA5->value(), 0xf0|32);
+
+    AbstractMetaEnumValue* valueA6 = enumA->values().at(6);
+    QCOMPARE(valueA6->name(), QString("ValueA6"));
+    QCOMPARE(valueA6->stringValue(), QString("ValueA3>>1"));
+    QCOMPARE(valueA6->value(), 0xf0 >> 1);
+
+    AbstractMetaEnumValue* valueA7 = enumA->values().at(7);
+    QCOMPARE(valueA7->name(), QString("ValueA7"));
+    QCOMPARE(valueA7->stringValue(), QString("ValueA3<<1"));
+    QCOMPARE(valueA7->value(), 0xf0 << 1);
+}
+
+void TestEnum::testPrivateEnum()
+{
+    const char* cppCode ="\
+    class A {\
+    private:\
+        enum PrivateEnum { Priv0 = 0x0f, Priv1 = 0xf0 };\
+    public:\
+        enum PublicEnum { Pub0 = Priv0, Pub1 = A::Priv1 };\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <value-type name='A'> \
+            <enum-type name='PublicEnum'/>\
+        </value-type> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+
+    AbstractMetaClass* classA = t.builder()->classes().findClass("A");
+    QVERIFY(classA);
+    QCOMPARE(classA->enums().count(), 2);
+
+    AbstractMetaEnum* privateEnum = classA->findEnum("PrivateEnum");
+    QVERIFY(privateEnum);
+    QVERIFY(privateEnum->isPrivate());
+    QCOMPARE(privateEnum->typeEntry()->qualifiedCppName(), QString("A::PrivateEnum"));
+
+    AbstractMetaEnum* publicEnum = classA->findEnum("PublicEnum");
+    QVERIFY(publicEnum);
+    QCOMPARE(publicEnum->typeEntry()->qualifiedCppName(), QString("A::PublicEnum"));
+
+    AbstractMetaEnumValue* pub0 = publicEnum->values().first();
+    QCOMPARE(pub0->name(), QString("Pub0"));
+    QCOMPARE(pub0->value(), 0x0f);
+    QCOMPARE(pub0->stringValue(), QString("Priv0"));
+
+    AbstractMetaEnumValue* pub1 = publicEnum->values().last();
+    QCOMPARE(pub1->name(), QString("Pub1"));
+    QCOMPARE(pub1->value(), 0xf0);
+    QCOMPARE(pub1->stringValue(), QString("A::Priv1"));
+}
+
+QTEST_APPLESS_MAIN(TestEnum)
+
+#include "testenum.moc"
diff --git a/ApiExtractor/tests/testenum.h b/ApiExtractor/tests/testenum.h
new file mode 100644
index 000000000..7bf3a9eb5
--- /dev/null
+++ b/ApiExtractor/tests/testenum.h
@@ -0,0 +1,41 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTENUM_H
+#define TESTENUM_H
+#include <QObject>
+
+class TestEnum : public QObject
+{
+    Q_OBJECT
+private slots:
+    void testEnumCppSignature();
+    void testEnumWithApiVersion();
+    void testAnonymousEnum();
+    void testGlobalEnums();
+    void testEnumValueFromNeighbourEnum();
+    void testEnumValueFromExpression();
+    void testPrivateEnum();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testextrainclude.cpp b/ApiExtractor/tests/testextrainclude.cpp
new file mode 100644
index 000000000..b9e6ad318
--- /dev/null
+++ b/ApiExtractor/tests/testextrainclude.cpp
@@ -0,0 +1,79 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testextrainclude.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestExtraInclude::testClassExtraInclude()
+{
+    const char* cppCode ="struct A {};";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <value-type name='A'> \
+            <extra-includes>\
+                <include file-name='header.h' location='global' />\
+            </extra-includes>\
+        </value-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    const AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+
+    QList<Include> includes = classA->typeEntry()->extraIncludes();
+    QCOMPARE(includes.count(), 1);
+    QCOMPARE(includes.first().name(), QString("header.h"));
+}
+
+void TestExtraInclude::testGlobalExtraIncludes()
+{
+    const char* cppCode ="struct A {};";
+    const char* xmlCode = "\
+    <typesystem package='Foo'>\
+        <extra-includes>\
+            <include file-name='header1.h' location='global' />\
+            <include file-name='header2.h' location='global' />\
+        </extra-includes>\
+        <value-type name='A' />\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QVERIFY(classes.findClass("A"));
+
+    TypeDatabase* td = TypeDatabase::instance();
+    TypeEntry* module = td->findType("Foo");
+    QVERIFY(module);
+
+    QList<Include> includes = module->extraIncludes();
+    QCOMPARE(includes.count(), 2);
+    QCOMPARE(includes.first().name(), QString("header1.h"));
+    QCOMPARE(includes.last().name(), QString("header2.h"));
+}
+
+QTEST_APPLESS_MAIN(TestExtraInclude)
+
+#include "testextrainclude.moc"
+
diff --git a/ApiExtractor/tests/testextrainclude.h b/ApiExtractor/tests/testextrainclude.h
new file mode 100644
index 000000000..d397f5fcc
--- /dev/null
+++ b/ApiExtractor/tests/testextrainclude.h
@@ -0,0 +1,37 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTEXTRAINCLUDE_H
+#define TESTEXTRAINCLUDE_H
+
+#include <QObject>
+
+class TestExtraInclude : public QObject
+{
+    Q_OBJECT
+    private slots:
+        void testClassExtraInclude();
+        void testGlobalExtraIncludes();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testfunctiontag.cpp b/ApiExtractor/tests/testfunctiontag.cpp
new file mode 100644
index 000000000..378baf479
--- /dev/null
+++ b/ApiExtractor/tests/testfunctiontag.cpp
@@ -0,0 +1,89 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testfunctiontag.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestFunctionTag::testFunctionTagForSpecificSignature()
+{
+    const char cppCode[] = "void globalFunction(int); void globalFunction(float); void dummy()";
+    const char xmlCode[] = "\
+    <typesystem package=\"Foo\">\
+        <primitive-type name='int'/> \
+        <primitive-type name='float'/> \
+        <function signature='globalFunction(int)'/>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+
+    FunctionTypeEntry* func = (FunctionTypeEntry*) TypeDatabase::instance()->findType("globalFunction");
+    QVERIFY(func);
+    QCOMPARE(t.builder()->globalFunctions().size(), 1);
+}
+
+void TestFunctionTag::testFunctionTagForAllSignatures()
+{
+    const char cppCode[] = "void globalFunction(int); void globalFunction(float); void dummy();";
+    const char xmlCode[] = "\
+    <typesystem package=\"Foo\">\
+        <primitive-type name='int'/> \
+        <primitive-type name='float'/> \
+        <function signature='globalFunction(int)'/>\
+        <function signature='globalFunction(float)'/>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+
+    FunctionTypeEntry* func = (FunctionTypeEntry*) TypeDatabase::instance()->findType("globalFunction");
+    QVERIFY(func);
+    QCOMPARE(t.builder()->globalFunctions().size(), 2);
+}
+
+void TestFunctionTag::testRenameGlobalFunction()
+{
+    const char* cppCode ="void global_function_with_ugly_name();";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <function signature='global_function_with_ugly_name()' rename='smooth' />\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+
+    FunctionTypeEntry* func = (FunctionTypeEntry*) TypeDatabase::instance()->findType("global_function_with_ugly_name");
+    QVERIFY(func);
+
+    QCOMPARE(t.builder()->globalFunctions().size(), 1);
+    const AbstractMetaFunction* metaFunc = t.builder()->globalFunctions().first();
+
+    QVERIFY(metaFunc);
+    QCOMPARE(metaFunc->modifications().size(), 1);
+    QVERIFY(metaFunc->modifications().first().isRenameModifier());
+    QCOMPARE(metaFunc->modifications().first().renamedTo(), QString("smooth"));
+
+    QCOMPARE(metaFunc->name(), QString("smooth"));
+    QCOMPARE(metaFunc->originalName(), QString("global_function_with_ugly_name"));
+    QCOMPARE(metaFunc->minimalSignature(), QString("global_function_with_ugly_name()"));
+}
+
+QTEST_APPLESS_MAIN(TestFunctionTag)
+
+#include "testfunctiontag.moc"
+
diff --git a/ApiExtractor/tests/testfunctiontag.h b/ApiExtractor/tests/testfunctiontag.h
new file mode 100644
index 000000000..2edd1c4de
--- /dev/null
+++ b/ApiExtractor/tests/testfunctiontag.h
@@ -0,0 +1,37 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTFUNCTIONTAG_H
+#define TESTFUNCTIONTAG_H
+#include <QObject>
+
+class TestFunctionTag : public QObject
+{
+    Q_OBJECT
+private slots:
+    void testFunctionTagForSpecificSignature();
+    void testFunctionTagForAllSignatures();
+    void testRenameGlobalFunction();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testimplicitconversions.cpp b/ApiExtractor/tests/testimplicitconversions.cpp
new file mode 100644
index 000000000..4bc4d73fc
--- /dev/null
+++ b/ApiExtractor/tests/testimplicitconversions.cpp
@@ -0,0 +1,158 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testimplicitconversions.h"
+#include "testutil.h"
+#include <QtTest/QTest>
+
+void TestImplicitConversions::testWithPrivateCtors()
+{
+    const char* cppCode ="\
+    class B;\
+    class C;\
+    class A {\
+        A(const B&);\
+    public:\
+        A(const C&);\
+    };\
+    class B {};\
+    class C {};\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <value-type name='A'/> \
+        <value-type name='B'/> \
+        <value-type name='C'/> \
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 3);
+
+    AbstractMetaClass* classA = classes.findClass("A");
+    AbstractMetaClass* classC = classes.findClass("C");
+    AbstractMetaFunctionList implicitConvs = classA->implicitConversions();
+    QCOMPARE(implicitConvs.count(), 1);
+    QCOMPARE(implicitConvs.first()->arguments().first()->type()->typeEntry(), classC->typeEntry());
+}
+
+void TestImplicitConversions::testWithModifiedVisibility()
+{
+    const char* cppCode ="\
+    class B;\
+    class A {\
+    public:\
+        A(const B&);\
+    };\
+    class B {};\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'>\
+        <value-type name='A'>\
+            <modify-function signature='A(const B&amp;)'>\
+                <access modifier='private' />\
+            </modify-function>\
+        </value-type>\
+        <value-type name='B'/>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    AbstractMetaClass* classA = classes.findClass("A");
+    AbstractMetaClass* classB = classes.findClass("B");
+    AbstractMetaFunctionList implicitConvs = classA->implicitConversions();
+    QCOMPARE(implicitConvs.count(), 1);
+    QCOMPARE(implicitConvs.first()->arguments().first()->type()->typeEntry(), classB->typeEntry());
+}
+
+
+void TestImplicitConversions::testWithAddedCtor()
+{
+    const char* cppCode ="\
+    class B;\
+    class A {\
+    public:\
+        A(const B&);\
+    };\
+    class B {};\
+    class C {};\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'>\
+        <custom-type name='TARGETLANGTYPE' />\
+        <value-type name='A'>\
+            <add-function signature='A(const C&amp;)' />\
+        </value-type>\
+        <value-type name='B'>\
+            <add-function signature='B(TARGETLANGTYPE*)' />\
+        </value-type>\
+        <value-type name='C'/>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 3);
+
+    AbstractMetaClass* classA = classes.findClass("A");
+    AbstractMetaFunctionList implicitConvs = classA->implicitConversions();
+    QCOMPARE(implicitConvs.count(), 2);
+
+    // Added constructors with custom types should never result in implicit converters.
+    AbstractMetaClass* classB = classes.findClass("B");
+    implicitConvs = classB->implicitConversions();
+    QCOMPARE(implicitConvs.count(), 0);
+}
+
+void TestImplicitConversions::testWithExternalConversionOperator()
+{
+    const char* cppCode ="\
+    class A {};\
+    struct B {\
+        operator A() const;\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'>\
+        <value-type name='A'/>\
+        <value-type name='B'/>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    AbstractMetaClass* classA = classes.findClass("A");
+    AbstractMetaClass* classB = classes.findClass("B");
+    AbstractMetaFunctionList implicitConvs = classA->implicitConversions();
+    QCOMPARE(implicitConvs.count(), 1);
+    AbstractMetaFunctionList externalConvOps = classA->externalConversionOperators();
+    QCOMPARE(externalConvOps.count(), 1);
+
+    const AbstractMetaFunction* convOp = 0;
+    foreach(const AbstractMetaFunction* func, classB->functions()) {
+        if (func->isConversionOperator())
+            convOp = func;
+    }
+    QVERIFY(convOp);
+    QCOMPARE(implicitConvs.first(), convOp);
+}
+
+QTEST_APPLESS_MAIN(TestImplicitConversions)
+
+#include "testimplicitconversions.moc"
diff --git a/ApiExtractor/tests/testimplicitconversions.h b/ApiExtractor/tests/testimplicitconversions.h
new file mode 100644
index 000000000..69bef4952
--- /dev/null
+++ b/ApiExtractor/tests/testimplicitconversions.h
@@ -0,0 +1,41 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTIMPLICITCONVERSIONS_H
+#define TESTIMPLICITCONVERSIONS_H
+
+#include <QObject>
+
+class AbstractMetaBuilder;
+
+class TestImplicitConversions : public QObject
+{
+    Q_OBJECT
+private slots:
+    void testWithPrivateCtors();
+    void testWithModifiedVisibility();
+    void testWithAddedCtor();
+    void testWithExternalConversionOperator();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testinserttemplate.cpp b/ApiExtractor/tests/testinserttemplate.cpp
new file mode 100644
index 000000000..e3aade5a4
--- /dev/null
+++ b/ApiExtractor/tests/testinserttemplate.cpp
@@ -0,0 +1,121 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "testinserttemplate.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestInsertTemplate::testInsertTemplateOnClassInjectCode()
+{
+    const char* cppCode ="struct A{};";
+    const char* xmlCode = "\
+    <typesystem package='Foo'>\
+        <template name='code_template'>\
+        code template content\
+        </template>\
+        <value-type name='A'>\
+            <inject-code class='native'>\
+                <insert-template name='code_template'/>\
+            </inject-code>\
+        </value-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 1);
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QCOMPARE(classA->typeEntry()->codeSnips().count(), 1);
+    QString code = classA->typeEntry()->codeSnips().first().code();
+    QVERIFY(code.contains("code template content"));
+}
+
+void TestInsertTemplate::testInsertTemplateOnModuleInjectCode()
+{
+    const char* cppCode ="";
+    const char* xmlCode = "\
+    <typesystem package='Foo'>\
+        <template name='code_template'>\
+        code template content\
+        </template>\
+        <inject-code class='native'>\
+            <insert-template name='code_template'/>\
+        </inject-code>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QVERIFY(classes.isEmpty());
+
+    TypeEntry* module = TypeDatabase::instance()->findType("Foo");
+    QVERIFY(module);
+    QCOMPARE(module->codeSnips().count(), 1);
+    QString code = module->codeSnips().first().code().trimmed();
+    QVERIFY(code.contains("code template content"));
+}
+
+void TestInsertTemplate::testInvalidTypeSystemTemplate()
+{
+    const char* cppCode ="";
+    const char* xmlCode = "\
+    <typesystem package='Foo'>\
+        <inject-code class='native'>\
+            <insert-template name='this_code_template_does_not_exists'/>\
+        </inject-code>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QVERIFY(classes.isEmpty());
+
+    TypeEntry* module = TypeDatabase::instance()->findType("Foo");
+    QVERIFY(module);
+    QCOMPARE(module->codeSnips().count(), 1);
+    QString code = module->codeSnips().first().code().trimmed();
+    QVERIFY(code.isEmpty());
+}
+
+void TestInsertTemplate::testValidAndInvalidTypeSystemTemplate()
+{
+    const char* cppCode ="";
+    const char* xmlCode = "\
+    <typesystem package='Foo'>\
+        <template name='code_template'>\
+        code template content\
+        </template>\
+        <inject-code class='native'>\
+            <insert-template name='this_code_template_does_not_exists'/>\
+            <insert-template name='code_template'/>\
+        </inject-code>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QVERIFY(classes.isEmpty());
+
+    TypeEntry* module = TypeDatabase::instance()->findType("Foo");
+    QVERIFY(module);
+    QCOMPARE(module->codeSnips().count(), 1);
+    QString code = module->codeSnips().first().code().trimmed();
+    QVERIFY(code.contains("code template content"));
+}
+
+QTEST_APPLESS_MAIN(TestInsertTemplate)
+
+#include "testinserttemplate.moc"
diff --git a/ApiExtractor/tests/testinserttemplate.h b/ApiExtractor/tests/testinserttemplate.h
new file mode 100644
index 000000000..fd3ca1d72
--- /dev/null
+++ b/ApiExtractor/tests/testinserttemplate.h
@@ -0,0 +1,39 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef TESTINSERTTEMPLATE_H
+#define TESTINSERTTEMPLATE_H
+
+#include <QObject>
+
+class TestInsertTemplate : public QObject
+{
+    Q_OBJECT
+    private slots:
+        void testInsertTemplateOnClassInjectCode();
+        void testInsertTemplateOnModuleInjectCode();
+        void testInvalidTypeSystemTemplate();
+        void testValidAndInvalidTypeSystemTemplate();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testmodifydocumentation.cpp b/ApiExtractor/tests/testmodifydocumentation.cpp
new file mode 100644
index 000000000..7cab9daf2
--- /dev/null
+++ b/ApiExtractor/tests/testmodifydocumentation.cpp
@@ -0,0 +1,75 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testmodifydocumentation.h"
+
+#include <QCoreApplication>
+#include <QtTest/QTest>
+#include "testutil.h"
+#include <qtdocparser.h>
+
+void TestModifyDocumentation::testModifyDocumentation()
+{
+    const char* cppCode ="struct B { void b(); }; class A {};";
+    const char* xmlCode = "<typesystem package=\"Foo\">\
+    <value-type name='B'>\
+        <modify-function signature='b()' remove='all' />\
+    </value-type>\
+    <value-type name='A'>\
+    <modify-documentation xpath='description/para[3]'>\
+    &lt;para>Some changed contents here&lt;/para>\
+    </modify-documentation>\
+    </value-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+
+    AbstractMetaClass* classA = t.builder()->classes().findClass("A");
+    QVERIFY(classA);
+    DocModificationList docMods = classA->typeEntry()->docModifications();
+    QCOMPARE(docMods.count(), 1);
+    QCOMPARE(docMods[0].code().trimmed(), QString("<para>Some changed contents here</para>"));
+    QCOMPARE(docMods[0].signature(), QString(""));
+    QtDocParser docParser;
+    docParser.setDocumentationDataDirectory(QDir::currentPath());
+    docParser.fillDocumentation(classA);
+
+    QVERIFY(!classA->documentation().value().trimmed().isEmpty());
+    QCOMPARE(classA->documentation().value(), QString("<?xml version=\"1.0\"?>\n\
+<description>oi\n\
+                <para>Paragraph number 1</para>\n\
+    <para>Paragraph number 2</para>\n\
+    <para>Some changed contents here</para>\n\
+</description>\n"));
+}
+
+// We expand QTEST_MAIN macro but using QCoreApplication instead of QApplication
+// because this test needs an event loop but can't use QApplication to avoid a crash
+// on our ARMEL/FRAMANTLE buildbot
+int main(int argc, char** argv)
+{
+    QCoreApplication app(argc, argv);
+    TestModifyDocumentation tc;
+    return QTest::qExec(&tc, argc, argv);
+}
+
+#include "testmodifydocumentation.moc"
diff --git a/ApiExtractor/tests/testmodifydocumentation.h b/ApiExtractor/tests/testmodifydocumentation.h
new file mode 100644
index 000000000..14bb0c69d
--- /dev/null
+++ b/ApiExtractor/tests/testmodifydocumentation.h
@@ -0,0 +1,36 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTMODIFYDOCUMENTATION_H
+#define TESTMODIFYDOCUMENTATION_H
+
+#include <QObject>
+
+class TestModifyDocumentation : public QObject
+{
+Q_OBJECT
+private slots:
+    void testModifyDocumentation();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testmodifyfunction.cpp b/ApiExtractor/tests/testmodifyfunction.cpp
new file mode 100644
index 000000000..93dae7536
--- /dev/null
+++ b/ApiExtractor/tests/testmodifyfunction.cpp
@@ -0,0 +1,244 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testmodifyfunction.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestModifyFunction::testRenameArgument()
+{
+    const char* cppCode ="\
+    struct A {\
+        void method(int=0);\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <primitive-type name='int'/>\
+        <object-type name='A'> \
+        <modify-function signature='method(int)'>\
+            <modify-argument index='1'>\
+                <rename to='otherArg' />\
+            </modify-argument>\
+        </modify-function>\
+        </object-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    const AbstractMetaFunction* func = classA->findFunction("method");
+    Q_ASSERT(func);
+
+    QCOMPARE(func->argumentName(1), QString("otherArg"));
+}
+
+void TestModifyFunction::testOwnershipTransfer()
+{
+    const char* cppCode ="\
+    struct A {};\
+    struct B {\
+        virtual A* method();\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <object-type name='A' /> \
+        <object-type name='B'> \
+        <modify-function signature='method()'>\
+            <modify-argument index='return'>\
+                <define-ownership owner='c++' /> \
+            </modify-argument>\
+        </modify-function>\
+        </object-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classB = classes.findClass("B");
+    const AbstractMetaFunction* func = classB->findFunction("method");
+
+    QCOMPARE(func->ownership(func->ownerClass(), TypeSystem::TargetLangCode, 0), TypeSystem::CppOwnership);
+}
+
+
+void TestModifyFunction::invalidateAfterUse()
+{
+    const char* cppCode ="\
+    struct A {\
+        virtual void call(int *a);\
+    };\
+    struct B : A {\
+    };\
+    struct C : B {\
+        virtual void call2(int *a);\
+    };\
+    struct D : C {\
+        virtual void call2(int *a);\
+    };\
+    struct E : D {\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <primitive-type name='int'/>\
+        <object-type name='A'> \
+        <modify-function signature='call(int*)'>\
+          <modify-argument index='1' invalidate-after-use='true'/>\
+        </modify-function>\
+        </object-type>\
+        <object-type name='B' /> \
+        <object-type name='C'> \
+        <modify-function signature='call2(int*)'>\
+          <modify-argument index='1' invalidate-after-use='true'/>\
+        </modify-function>\
+        </object-type>\
+        <object-type name='D'> \
+        <modify-function signature='call2(int*)'>\
+          <modify-argument index='1' invalidate-after-use='true'/>\
+        </modify-function>\
+        </object-type>\
+        <object-type name='E' /> \
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false, "0.1");
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classB = classes.findClass("B");
+    const AbstractMetaFunction* func = classB->findFunction("call");
+    QCOMPARE(func->modifications().size(), 1);
+    QCOMPARE(func->modifications().at(0).argument_mods.size(), 1);
+    QVERIFY(func->modifications().at(0).argument_mods.at(0).resetAfterUse);
+
+    AbstractMetaClass* classC = classes.findClass("C");
+    QVERIFY(classC);
+    func = classC->findFunction("call");
+    QCOMPARE(func->modifications().size(), 1);
+    QCOMPARE(func->modifications().at(0).argument_mods.size(), 1);
+    QVERIFY(func->modifications().at(0).argument_mods.at(0).resetAfterUse);
+
+    func = classC->findFunction("call2");
+    QCOMPARE(func->modifications().size(), 1);
+    QCOMPARE(func->modifications().at(0).argument_mods.size(), 1);
+    QVERIFY(func->modifications().at(0).argument_mods.at(0).resetAfterUse);
+
+    AbstractMetaClass* classD =  classes.findClass("D");
+    QVERIFY(classD);
+    func = classD->findFunction("call");
+    QCOMPARE(func->modifications().size(), 1);
+    QCOMPARE(func->modifications().at(0).argument_mods.size(), 1);
+    QVERIFY(func->modifications().at(0).argument_mods.at(0).resetAfterUse);
+
+    func = classD->findFunction("call2");
+    QCOMPARE(func->modifications().size(), 1);
+    QCOMPARE(func->modifications().at(0).argument_mods.size(), 1);
+    QVERIFY(func->modifications().at(0).argument_mods.at(0).resetAfterUse);
+
+    AbstractMetaClass* classE = classes.findClass("E");
+    QVERIFY(classE);
+    func = classE->findFunction("call");
+    QVERIFY(func);
+    QCOMPARE(func->modifications().size(), 1);
+    QCOMPARE(func->modifications().at(0).argument_mods.size(), 1);
+    QVERIFY(func->modifications().at(0).argument_mods.at(0).resetAfterUse);
+
+    func = classE->findFunction("call2");
+    QVERIFY(func);
+    QCOMPARE(func->modifications().size(), 1);
+    QCOMPARE(func->modifications().at(0).argument_mods.size(), 1);
+    QVERIFY(func->modifications().at(0).argument_mods.at(0).resetAfterUse);
+}
+
+void TestModifyFunction::testWithApiVersion()
+{
+    const char* cppCode ="\
+    struct A {};\
+    struct B {\
+        virtual A* method();\
+        virtual B* methodB();\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <object-type name='A' /> \
+        <object-type name='B'> \
+        <modify-function signature='method()' since='0.1'>\
+            <modify-argument index='return'>\
+                <define-ownership owner='c++' /> \
+            </modify-argument>\
+        </modify-function>\
+        <modify-function signature='methodB()' since='0.2'>\
+            <modify-argument index='return'>\
+                <define-ownership owner='c++' /> \
+            </modify-argument>\
+        </modify-function>\
+        </object-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false, "0.1");
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classB = classes.findClass("B");
+    const AbstractMetaFunction* func = classB->findFunction("method");
+
+    QCOMPARE(func->ownership(func->ownerClass(), TypeSystem::TargetLangCode, 0), TypeSystem::CppOwnership);
+
+    func = classB->findFunction("methodB");
+    QVERIFY(func->ownership(func->ownerClass(), TypeSystem::TargetLangCode, 0) != TypeSystem::CppOwnership);
+}
+
+void TestModifyFunction::testGlobalFunctionModification()
+{
+    const char* cppCode ="\
+    struct A {};\
+    void function(A* a = 0);\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <primitive-type name='A'/>\
+        <function signature='function(A*)'>\
+            <modify-function signature='function(A*)'>\
+                <modify-argument index='1'>\
+                    <replace-type modified-type='A'/>\
+                    <replace-default-expression with='A()'/>\
+                </modify-argument>\
+            </modify-function>\
+        </function>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+    QCOMPARE(t.builder()->globalFunctions().size(), 1);
+
+    FunctionModificationList mods = TypeDatabase::instance()->functionModifications("function(A*)");
+    QCOMPARE(mods.count(), 1);
+    QList<ArgumentModification> argMods = mods.first().argument_mods;
+    QCOMPARE(argMods.count(), 1);
+    ArgumentModification argMod = argMods.first();
+    QCOMPARE(argMod.replacedDefaultExpression, QString("A()"));
+
+    const AbstractMetaFunction* func = t.builder()->globalFunctions().first();
+    QVERIFY(func);
+    QCOMPARE(func->arguments().count(), 1);
+    const AbstractMetaArgument* arg = func->arguments().first();
+    QCOMPARE(arg->type()->cppSignature(), QString("A *"));
+    QCOMPARE(arg->originalDefaultValueExpression(), QString("0"));
+    QCOMPARE(arg->defaultValueExpression(), QString("A()"));
+}
+
+QTEST_APPLESS_MAIN(TestModifyFunction)
+
+#include "testmodifyfunction.moc"
diff --git a/ApiExtractor/tests/testmodifyfunction.h b/ApiExtractor/tests/testmodifyfunction.h
new file mode 100644
index 000000000..d72a41ddc
--- /dev/null
+++ b/ApiExtractor/tests/testmodifyfunction.h
@@ -0,0 +1,40 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTABSTRACTMETACLASS_H
+#define TESTABSTRACTMETACLASS_H
+
+#include <QObject>
+
+class TestModifyFunction : public QObject
+{
+    Q_OBJECT
+    private slots:
+        void testOwnershipTransfer();
+        void testWithApiVersion();
+        void testRenameArgument();
+        void invalidateAfterUse();
+        void testGlobalFunctionModification();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testmultipleinheritance.cpp b/ApiExtractor/tests/testmultipleinheritance.cpp
new file mode 100644
index 000000000..5464fc446
--- /dev/null
+++ b/ApiExtractor/tests/testmultipleinheritance.cpp
@@ -0,0 +1,69 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testmultipleinheritance.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestMultipleInheritance::testVirtualClass()
+{
+    const char* cppCode ="\
+    struct A {\
+        virtual ~A();\
+        virtual void theBug();\
+    };\
+    struct B {\
+        virtual ~B();\
+    };\
+    struct C : A, B {\
+    };\
+    struct D : C {\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <object-type name='A' /> \
+        <object-type name='B' /> \
+        <object-type name='C' /> \
+        <object-type name='D' /> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 4);
+
+    AbstractMetaClass* classD = classes.findClass("D");
+    bool functionFound = false;
+    foreach (AbstractMetaFunction* f, classD->functions()) {
+        if (f->name() == "theBug") {
+            functionFound = true;
+            break;
+        }
+    }
+    QVERIFY(functionFound);
+
+}
+
+QTEST_APPLESS_MAIN(TestMultipleInheritance)
+
+#include "testmultipleinheritance.moc"
diff --git a/ApiExtractor/tests/testmultipleinheritance.h b/ApiExtractor/tests/testmultipleinheritance.h
new file mode 100644
index 000000000..3a1bd388d
--- /dev/null
+++ b/ApiExtractor/tests/testmultipleinheritance.h
@@ -0,0 +1,38 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTMULTIPLEINHERITANCE_H
+#define TESTMULTIPLEINHERITANCE_H
+
+#include <QObject>
+
+class AbstractMetaBuilder;
+
+class TestMultipleInheritance : public QObject
+{
+    Q_OBJECT
+    private slots:
+        void testVirtualClass();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testnamespace.cpp b/ApiExtractor/tests/testnamespace.cpp
new file mode 100644
index 000000000..7fc457db0
--- /dev/null
+++ b/ApiExtractor/tests/testnamespace.cpp
@@ -0,0 +1,89 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testnamespace.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestNamespace::testNamespaceMembers()
+{
+    const char* cppCode = "\
+    namespace Namespace\
+    {\
+        enum Option {\
+            OpZero,\
+            OpOne\
+        };\
+        void foo(Option opt);\
+    };";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <namespace-type name='Namespace'>\
+            <enum-type name='Option' /> \
+        </namespace-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* ns = classes.findClass("Namespace");
+    QVERIFY(ns);
+    const AbstractMetaEnum* metaEnum = ns->findEnum("Option");
+    QVERIFY(metaEnum);
+    const AbstractMetaFunction* func = ns->findFunction("foo");
+    QVERIFY(func);
+}
+
+void TestNamespace::testNamespaceInnerClassMembers()
+{
+    const char* cppCode = "\
+    namespace OuterNamespace\
+    {\
+        namespace InnerNamespace {\
+            struct SomeClass {\
+                void method();\
+            };\
+        };\
+    };";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <namespace-type name='OuterNamespace'>\
+            <namespace-type name='InnerNamespace'>\
+                <value-type name='SomeClass' /> \
+            </namespace-type>\
+        </namespace-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* ons = classes.findClass("OuterNamespace");
+    QVERIFY(ons);
+    AbstractMetaClass* ins = classes.findClass("OuterNamespace::InnerNamespace");
+    QVERIFY(ins);
+    AbstractMetaClass* sc = classes.findClass("OuterNamespace::InnerNamespace::SomeClass");
+    QVERIFY(sc);
+    const AbstractMetaFunction* meth = sc->findFunction("method");
+    QVERIFY(meth);
+}
+
+QTEST_APPLESS_MAIN(TestNamespace)
+
+#include "testnamespace.moc"
+
diff --git a/ApiExtractor/tests/testnamespace.h b/ApiExtractor/tests/testnamespace.h
new file mode 100644
index 000000000..77f24eb9b
--- /dev/null
+++ b/ApiExtractor/tests/testnamespace.h
@@ -0,0 +1,37 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTNAMESPACE_H
+#define TESTNAMESPACE_H
+
+#include <QObject>
+
+class TestNamespace : public QObject
+{
+    Q_OBJECT
+    private slots:
+        void testNamespaceMembers();
+        void testNamespaceInnerClassMembers();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testnestedtypes.cpp b/ApiExtractor/tests/testnestedtypes.cpp
new file mode 100644
index 000000000..83512f7db
--- /dev/null
+++ b/ApiExtractor/tests/testnestedtypes.cpp
@@ -0,0 +1,122 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testnestedtypes.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestNestedTypes::testNestedTypesModifications()
+{
+    const char* cppCode ="\
+    namespace OuterNamespace {\
+        namespace InnerNamespace {\
+            struct SomeClass {\
+                void method() {}\
+            };\
+        };\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <namespace-type name='OuterNamespace'>\
+            <namespace-type name='InnerNamespace'>\
+                <inject-code class='native'>custom_code1();</inject-code>\
+                <add-function signature='method()' return-type='OuterNamespace::InnerNamespace::SomeClass'>\
+                    <inject-code class='target'>custom_code2();</inject-code>\
+                </add-function>\
+                <object-type name='SomeClass' target-lang-name='RenamedSomeClass'>\
+                    <modify-function signature='method()' remove='all'/>\
+                </object-type>\
+            </namespace-type>\
+        </namespace-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+
+    AbstractMetaClass* ons = classes.findClass("OuterNamespace");
+    QVERIFY(ons);
+
+    AbstractMetaClass* ins = classes.findClass("OuterNamespace::InnerNamespace");
+    QVERIFY(ins);
+    QCOMPARE(ins->functions().count(), 1);
+    QCOMPARE(ins->typeEntry()->codeSnips().count(), 1);
+    CodeSnip snip = ins->typeEntry()->codeSnips().first();
+    QCOMPARE(snip.code(), QString("custom_code1();"));
+
+    AbstractMetaFunction* addedFunc = ins->functions().first();
+    QVERIFY(addedFunc->isUserAdded());
+    QCOMPARE(addedFunc->visibility(), uint(AbstractMetaFunction::Public));
+    QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::NormalFunction);
+    QCOMPARE(addedFunc->type()->minimalSignature(), QString("OuterNamespace::InnerNamespace::SomeClass"));
+
+    QCOMPARE(addedFunc->modifications().size(), 1);
+    QVERIFY(addedFunc->modifications().first().isCodeInjection());
+    snip = addedFunc->modifications().first().snips.first();
+    QCOMPARE(snip.code(), QString("custom_code2();"));
+
+    AbstractMetaClass* sc = classes.findClass("OuterNamespace::InnerNamespace::SomeClass");
+    QVERIFY(ins);
+    QCOMPARE(sc->functions().count(), 2); // default constructor and removed method
+    AbstractMetaFunction* removedFunc = sc->functions().last();
+    QVERIFY(removedFunc->isModifiedRemoved());
+}
+
+
+void TestNestedTypes::testDuplicationOfNestedTypes()
+{
+    const char* cppCode ="\
+    namespace Namespace {\
+        class SomeClass {};\
+    };";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <namespace-type name='Namespace'>\
+            <value-type name='SomeClass'>\
+                <add-function signature='createSomeClass(Namespace::SomeClass)'/>\
+            </value-type>\
+        </namespace-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    AbstractMetaClass* nspace = classes.findClass("Namespace");
+    QVERIFY(nspace);
+    AbstractMetaClass* cls1 = classes.findClass("SomeClass");
+    QVERIFY(cls1);
+    AbstractMetaClass* cls2 = classes.findClass("Namespace::SomeClass");
+    QVERIFY(cls2);
+    QCOMPARE(cls1, cls2);
+    QCOMPARE(cls1->name(), QString("SomeClass"));
+    QCOMPARE(cls1->qualifiedCppName(), QString("Namespace::SomeClass"));
+
+    TypeEntry* t1 = TypeDatabase::instance()->findType("Namespace::SomeClass");
+    QVERIFY(t1);
+    TypeEntry* t2 = TypeDatabase::instance()->findType("SomeClass");
+    QVERIFY(!t2);
+}
+
+QTEST_APPLESS_MAIN(TestNestedTypes)
+
+#include "testnestedtypes.moc"
diff --git a/ApiExtractor/tests/testnestedtypes.h b/ApiExtractor/tests/testnestedtypes.h
new file mode 100644
index 000000000..d0b828b0c
--- /dev/null
+++ b/ApiExtractor/tests/testnestedtypes.h
@@ -0,0 +1,36 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTNESTEDTYPES_H
+#define TESTNESTEDTYPES_H
+#include <QObject>
+
+class TestNestedTypes : public QObject
+{
+    Q_OBJECT
+private slots:
+    void testNestedTypesModifications();
+    void testDuplicationOfNestedTypes();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testnumericaltypedef.cpp b/ApiExtractor/tests/testnumericaltypedef.cpp
new file mode 100644
index 000000000..e48796726
--- /dev/null
+++ b/ApiExtractor/tests/testnumericaltypedef.cpp
@@ -0,0 +1,113 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testnumericaltypedef.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestNumericalTypedef::testNumericalTypedef()
+{
+    const char* cppCode ="\
+    typedef double real;\
+    void funcDouble(double);\
+    void funcReal(real);\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <primitive-type name='double' /> \
+        <primitive-type name='real' /> \
+        <function signature='funcDouble(double)' />\
+        <function signature='funcReal(real)' />\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+
+    QCOMPARE(t.builder()->globalFunctions().size(), 2);
+    const AbstractMetaFunction* funcDouble = t.builder()->globalFunctions().first();
+    QVERIFY(funcDouble);
+    const AbstractMetaFunction* funcReal = t.builder()->globalFunctions().last();
+    QVERIFY(funcReal);
+
+    if (funcDouble->name() == "funcReal")
+        std::swap(funcDouble, funcReal);
+
+    QCOMPARE(funcDouble->minimalSignature(), QString("funcDouble(double)"));
+    QCOMPARE(funcReal->minimalSignature(), QString("funcReal(real)"));
+
+    const AbstractMetaType* doubleType = funcDouble->arguments().first()->type();
+    QVERIFY(doubleType);
+    QCOMPARE(doubleType->cppSignature(), QString("double"));
+    QVERIFY(doubleType->isPrimitive());
+    QVERIFY(doubleType->typeEntry()->isCppPrimitive());
+
+    const AbstractMetaType* realType = funcReal->arguments().first()->type();
+    QVERIFY(realType);
+    QCOMPARE(realType->cppSignature(), QString("real"));
+    QVERIFY(realType->isPrimitive());
+    QVERIFY(realType->typeEntry()->isCppPrimitive());
+}
+
+void TestNumericalTypedef::testUnsignedNumericalTypedef()
+{
+    const char* cppCode ="\
+    typedef unsigned short ushort;\
+    void funcUnsignedShort(unsigned short);\
+    void funcUShort(ushort);\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <primitive-type name='short' /> \
+        <primitive-type name='unsigned short' /> \
+        <primitive-type name='ushort' /> \
+        <function signature='funcUnsignedShort(unsigned short)' />\
+        <function signature='funcUShort(ushort)' />\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+
+    QCOMPARE(t.builder()->globalFunctions().size(), 2);
+    const AbstractMetaFunction* funcUnsignedShort = t.builder()->globalFunctions().first();
+    QVERIFY(funcUnsignedShort);
+    const AbstractMetaFunction* funcUShort = t.builder()->globalFunctions().last();
+    QVERIFY(funcUShort);
+
+    if (funcUnsignedShort->name() == "funcUShort")
+        std::swap(funcUnsignedShort, funcUShort);
+
+    QCOMPARE(funcUnsignedShort->minimalSignature(), QString("funcUnsignedShort(unsigned short)"));
+    QCOMPARE(funcUShort->minimalSignature(), QString("funcUShort(ushort)"));
+
+    const AbstractMetaType* unsignedShortType = funcUnsignedShort->arguments().first()->type();
+    QVERIFY(unsignedShortType);
+    QCOMPARE(unsignedShortType->cppSignature(), QString("unsigned short"));
+    QVERIFY(unsignedShortType->isPrimitive());
+    QVERIFY(unsignedShortType->typeEntry()->isCppPrimitive());
+
+    const AbstractMetaType* ushortType = funcUShort->arguments().first()->type();
+    QVERIFY(ushortType);
+    QCOMPARE(ushortType->cppSignature(), QString("ushort"));
+    QVERIFY(ushortType->isPrimitive());
+    QVERIFY(ushortType->typeEntry()->isCppPrimitive());
+}
+
+QTEST_APPLESS_MAIN(TestNumericalTypedef)
+
+#include "testnumericaltypedef.moc"
diff --git a/ApiExtractor/tests/testnumericaltypedef.h b/ApiExtractor/tests/testnumericaltypedef.h
new file mode 100644
index 000000000..a1d1bbe59
--- /dev/null
+++ b/ApiExtractor/tests/testnumericaltypedef.h
@@ -0,0 +1,37 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTNUMERICALTYPEDEF_H
+#define TESTNUMERICALTYPEDEF_H
+
+#include <QObject>
+
+class TestNumericalTypedef : public QObject
+{
+    Q_OBJECT
+    private slots:
+        void testNumericalTypedef();
+        void testUnsignedNumericalTypedef();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testprimitivetypetag.cpp b/ApiExtractor/tests/testprimitivetypetag.cpp
new file mode 100644
index 000000000..ebd245bf9
--- /dev/null
+++ b/ApiExtractor/tests/testprimitivetypetag.cpp
@@ -0,0 +1,55 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testprimitivetypetag.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestPrimitiveTypeTag::testPrimitiveTypeDefaultConstructor()
+{
+    const char* cppCode ="\
+    struct A {};\
+    struct B {};\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <primitive-type name='A' default-constructor='A()'/> \
+        <object-type name='B' /> \
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 1);
+    AbstractMetaClass* classB = classes.findClass("B");
+    QVERIFY(classB);
+
+    PrimitiveTypeEntry* typeEntry = TypeDatabase::instance()->findPrimitiveType("A");
+    QVERIFY(typeEntry);
+    QVERIFY(typeEntry->hasDefaultConstructor());
+    QCOMPARE(typeEntry->defaultConstructor(), QString("A()"));
+}
+
+QTEST_APPLESS_MAIN(TestPrimitiveTypeTag)
+
+#include "testprimitivetypetag.moc"
+
diff --git a/ApiExtractor/tests/testprimitivetypetag.h b/ApiExtractor/tests/testprimitivetypetag.h
new file mode 100644
index 000000000..676174ddd
--- /dev/null
+++ b/ApiExtractor/tests/testprimitivetypetag.h
@@ -0,0 +1,36 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTPRIMITIVETYPETAG_H
+#define TESTPRIMITIVETYPETAG_H
+
+#include <QObject>
+
+class TestPrimitiveTypeTag : public QObject
+{
+    Q_OBJECT
+    private slots:
+        void testPrimitiveTypeDefaultConstructor();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testrefcounttag.cpp b/ApiExtractor/tests/testrefcounttag.cpp
new file mode 100644
index 000000000..9e05cee93
--- /dev/null
+++ b/ApiExtractor/tests/testrefcounttag.cpp
@@ -0,0 +1,94 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testrefcounttag.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestRefCountTag::testReferenceCountTag()
+{
+    const char* cppCode ="\
+    struct A {};\
+    struct B {\
+        void keepObject(B* b);\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <object-type name='A' /> \
+        <object-type name='B'> \
+        <modify-function signature='keepObject(B*)'>\
+            <modify-argument index='1'>\
+                <reference-count action='add' /> \
+            </modify-argument>\
+        </modify-function>\
+        </object-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classB = classes.findClass("B");
+    const AbstractMetaFunction* func = classB->findFunction("keepObject");
+    QVERIFY(func);
+    ReferenceCount refCount = func->modifications().first().argument_mods.first().referenceCounts.first();
+    QCOMPARE(refCount.action, ReferenceCount::Add);
+}
+
+void TestRefCountTag::testWithApiVersion()
+{
+    const char* cppCode ="\
+    struct A {};\
+    struct B {\
+        void keepObject(B*, B*);\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <object-type name='A' /> \
+        <object-type name='B'> \
+        <modify-function signature='keepObject(B*, B*)'>\
+            <modify-argument index='1' since='0.1'>\
+                <reference-count action='add' /> \
+            </modify-argument>\
+            <modify-argument index='2' since='0.2'>\
+                <reference-count action='add' /> \
+            </modify-argument>\
+        </modify-function>\
+        </object-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false, "0.1");
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classB = classes.findClass("B");
+    const AbstractMetaFunction* func = classB->findFunction("keepObject");
+    QVERIFY(func);
+    ReferenceCount refCount = func->modifications().first().argument_mods.first().referenceCounts.first();
+    QCOMPARE(refCount.action, ReferenceCount::Add);
+
+    QCOMPARE(func->modifications().size(), 1);
+}
+
+
+QTEST_APPLESS_MAIN(TestRefCountTag)
+
+#include "testrefcounttag.moc"
+
diff --git a/ApiExtractor/tests/testrefcounttag.h b/ApiExtractor/tests/testrefcounttag.h
new file mode 100644
index 000000000..1fcdd3dfb
--- /dev/null
+++ b/ApiExtractor/tests/testrefcounttag.h
@@ -0,0 +1,37 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTREFCOUNTTAG_H
+#define TESTREFCOUNTTAG_H
+
+#include <QObject>
+
+class TestRefCountTag : public QObject
+{
+    Q_OBJECT
+    private slots:
+        void testReferenceCountTag();
+        void testWithApiVersion();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testreferencetopointer.cpp b/ApiExtractor/tests/testreferencetopointer.cpp
new file mode 100644
index 000000000..cd4b63b0a
--- /dev/null
+++ b/ApiExtractor/tests/testreferencetopointer.cpp
@@ -0,0 +1,53 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testreferencetopointer.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestReferenceToPointer::testReferenceToPointerArgument()
+{
+    const char* cppCode ="\
+    struct A {};\
+    struct B {\
+        void dummy(A*&);\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <object-type name='A' /> \
+        <object-type name='B' /> \
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classB = classes.findClass("B");
+    QVERIFY(classB);
+    const AbstractMetaFunction* func = classB->findFunction("dummy");
+    QVERIFY(func);
+    QCOMPARE(func->arguments().first()->type()->minimalSignature(), QString("A*&"));
+}
+
+QTEST_APPLESS_MAIN(TestReferenceToPointer)
+
+#include "testreferencetopointer.moc"
+
diff --git a/ApiExtractor/tests/testreferencetopointer.h b/ApiExtractor/tests/testreferencetopointer.h
new file mode 100644
index 000000000..b682285b5
--- /dev/null
+++ b/ApiExtractor/tests/testreferencetopointer.h
@@ -0,0 +1,36 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTREFERENCETOPOINTER_H
+#define TESTREFERENCETOPOINTER_H
+
+#include <QObject>
+
+class TestReferenceToPointer : public QObject
+{
+    Q_OBJECT
+    private slots:
+        void testReferenceToPointerArgument();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testremovefield.cpp b/ApiExtractor/tests/testremovefield.cpp
new file mode 100644
index 000000000..1b1ae9c6a
--- /dev/null
+++ b/ApiExtractor/tests/testremovefield.cpp
@@ -0,0 +1,56 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testremovefield.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestRemoveField::testRemoveField()
+{
+    const char* cppCode ="\
+    struct A {\
+        int fieldA;\
+        int fieldB;\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <primitive-type name='int' />\
+        <value-type name='A'> \
+            <modify-field name='fieldB' remove='all' />\
+        </value-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QCOMPARE(classA->fields().size(), 1);
+    const AbstractMetaField* fieldA = classA->fields().first();
+    QVERIFY(fieldA);
+    QCOMPARE(fieldA->name(), QString("fieldA"));
+}
+
+QTEST_APPLESS_MAIN(TestRemoveField)
+
+#include "testremovefield.moc"
+
diff --git a/ApiExtractor/tests/testremovefield.h b/ApiExtractor/tests/testremovefield.h
new file mode 100644
index 000000000..301150c6f
--- /dev/null
+++ b/ApiExtractor/tests/testremovefield.h
@@ -0,0 +1,36 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTREMOVEFIELD_H
+#define TESTREMOVEFIELD_H
+
+#include <QObject>
+
+class TestRemoveField : public QObject
+{
+    Q_OBJECT
+    private slots:
+        void testRemoveField();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testremoveimplconv.cpp b/ApiExtractor/tests/testremoveimplconv.cpp
new file mode 100644
index 000000000..48c7640d2
--- /dev/null
+++ b/ApiExtractor/tests/testremoveimplconv.cpp
@@ -0,0 +1,64 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testremoveimplconv.h"
+#include "testutil.h"
+#include <QtTest/QTest>
+
+// When a constructor able to trigger implicity conversions is removed
+// it should not appear in the implicity conversion list.
+void TestRemoveImplConv::testRemoveImplConv()
+{
+    const char* cppCode ="\
+    struct A {};\
+    struct B {};\
+    struct C {\
+        C(const A&);\
+        C(const B&);\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\"> \
+        <value-type name='A' /> \
+        <value-type name='B' /> \
+        <value-type name='C'> \
+            <modify-function signature='C(const A&amp;)' remove='all' />\
+        </value-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 3);
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    AbstractMetaClass* classB = classes.findClass("B");
+    QVERIFY(classB);
+    AbstractMetaClass* classC = classes.findClass("C");
+    QVERIFY(classC);
+    AbstractMetaFunctionList implConv = classC->implicitConversions();
+    QCOMPARE(implConv.count(), 1);
+    QCOMPARE(implConv.first()->arguments().first()->type()->typeEntry(), classB->typeEntry());
+}
+
+QTEST_APPLESS_MAIN(TestRemoveImplConv)
+
+#include "testremoveimplconv.moc"
diff --git a/ApiExtractor/tests/testremoveimplconv.h b/ApiExtractor/tests/testremoveimplconv.h
new file mode 100644
index 000000000..bacc2a250
--- /dev/null
+++ b/ApiExtractor/tests/testremoveimplconv.h
@@ -0,0 +1,36 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTREMOVEIMPLCONV_H
+#define TESTREMOVEIMPLCONV_H
+
+#include <QObject>
+
+class TestRemoveImplConv : public QObject
+{
+Q_OBJECT
+private slots:
+    void testRemoveImplConv();
+};
+
+#endif // TESTREMOVEIMPLCONV_H
diff --git a/ApiExtractor/tests/testremoveoperatormethod.cpp b/ApiExtractor/tests/testremoveoperatormethod.cpp
new file mode 100644
index 000000000..35caea788
--- /dev/null
+++ b/ApiExtractor/tests/testremoveoperatormethod.cpp
@@ -0,0 +1,115 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testremoveoperatormethod.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestRemoveOperatorMethod::testRemoveOperatorMethod()
+{
+    const char* cppCode ="\
+    struct A {\
+        A& operator>>(char&);\
+        A& operator>>(char*);\
+        A& operator>>(signed short&);\
+        A& operator>>(unsigned short&);\
+        A& operator>>(signed int&);\
+        A& operator>>(unsigned int&);\
+        A& operator>>(signed long&);\
+        A& operator>>(unsigned long&);\
+        A& operator>>(__int64&);\
+        A& operator>>(unsigned __int64&);\
+        A& operator>>(float&);\
+        A& operator>>(double&);\
+        A& operator>>(Char&);\
+        A& operator>>(ByteArray&);\
+        A& operator>>(String&);\
+    };\
+    struct Char {};\
+    struct ByteArray {};\
+    struct String {};\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'>\
+        <primitive-type name='char' />\
+        <primitive-type name='signed short' />\
+        <primitive-type name='unsigned short' />\
+        <primitive-type name='signed int' />\
+        <primitive-type name='unsigned int' />\
+        <primitive-type name='signed long' />\
+        <primitive-type name='unsigned long' />\
+        <primitive-type name='__int64' />\
+        <primitive-type name='unsigned __int64' />\
+        <primitive-type name='float' />\
+        <primitive-type name='double' />\
+        <primitive-type name='Char' />\
+        <primitive-type name='String' />\
+        <value-type name='ByteArray' />\
+        <object-type name='A'>\
+            <modify-function signature='operator&gt;&gt;(char&amp;)' remove='all'/>\
+            <modify-function signature='operator&gt;&gt;(char*)' remove='all'/>\
+            <modify-function signature='operator&gt;&gt;(signed short&amp;)' remove='all'/>\
+            <modify-function signature='operator&gt;&gt;(unsigned short&amp;)' remove='all'/>\
+            <modify-function signature='operator&gt;&gt;(signed int&amp;)' remove='all'/>\
+            <modify-function signature='operator&gt;&gt;(unsigned int&amp;)' remove='all'/>\
+            <modify-function signature='operator&gt;&gt;(signed long&amp;)' remove='all'/>\
+            <modify-function signature='operator&gt;&gt;(unsigned long&amp;)' remove='all'/>\
+            <modify-function signature='operator&gt;&gt;(__int64&amp;)' remove='all'/>\
+            <modify-function signature='operator&gt;&gt;(unsigned __int64&amp;)' remove='all'/>\
+            <modify-function signature='operator&gt;&gt;(float&amp;)' remove='all'/>\
+            <modify-function signature='operator&gt;&gt;(double&amp;)' remove='all'/>\
+            <modify-function signature='operator&gt;&gt;(Char&amp;)' remove='all'/>\
+            <modify-function signature='operator&gt;&gt;(String&amp;)' remove='all'/>\
+        </object-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QCOMPARE(classA->functions().size(), 15);
+    QStringList removedSignatures;
+    removedSignatures.append("operator>>(char&)");
+    removedSignatures.append("operator>>(char*)");
+    removedSignatures.append("operator>>(signed short&)");
+    removedSignatures.append("operator>>(unsigned short&)");
+    removedSignatures.append("operator>>(signed int&)");
+    removedSignatures.append("operator>>(unsigned int&)");
+    removedSignatures.append("operator>>(signed long&)");
+    removedSignatures.append("operator>>(unsigned long&)");
+    removedSignatures.append("operator>>(__int64&)");
+    removedSignatures.append("operator>>(unsigned __int64&)");
+    removedSignatures.append("operator>>(float&)");
+    removedSignatures.append("operator>>(double&)");
+    removedSignatures.append("operator>>(Char&)");
+    removedSignatures.append("operator>>(String&)");
+    int notRemoved = classA->functions().size();
+    foreach (const AbstractMetaFunction* f, classA->functions()) {
+        QCOMPARE(f->isModifiedRemoved(), bool(removedSignatures.contains(f->minimalSignature())));
+        notRemoved -= int(f->isModifiedRemoved());
+    }
+    QCOMPARE(notRemoved, 2);
+}
+
+QTEST_APPLESS_MAIN(TestRemoveOperatorMethod)
+
+#include "testremoveoperatormethod.moc"
diff --git a/ApiExtractor/tests/testremoveoperatormethod.h b/ApiExtractor/tests/testremoveoperatormethod.h
new file mode 100644
index 000000000..1833ff11c
--- /dev/null
+++ b/ApiExtractor/tests/testremoveoperatormethod.h
@@ -0,0 +1,36 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTREMOVEOPERATORMETHOD_H
+#define TESTREMOVEOPERATORMETHOD_H
+
+#include <QObject>
+
+class TestRemoveOperatorMethod : public QObject
+{
+    Q_OBJECT
+    private slots:
+        void testRemoveOperatorMethod();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testresolvetype.cpp b/ApiExtractor/tests/testresolvetype.cpp
new file mode 100644
index 000000000..11880e1b1
--- /dev/null
+++ b/ApiExtractor/tests/testresolvetype.cpp
@@ -0,0 +1,58 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testresolvetype.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestResolveType::testResolveReturnTypeFromParentScope()
+{
+    const char* cppCode = "\
+    namespace A {\
+        struct B {\
+            struct C {};\
+        };\
+        struct D : public B::C {\
+            C* foo = 0;\
+            C* method();\
+        };\
+    };";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <namespace-type name='A' />\
+        <value-type name='A::B' /> \
+        <value-type name='A::B::C' /> \
+        <value-type name='A::D' /> \
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classD = classes.findClass("A::D");
+    QVERIFY(classD);
+    const AbstractMetaFunction* meth = classD->findFunction("method");
+    QVERIFY(meth);
+}
+
+QTEST_APPLESS_MAIN(TestResolveType)
+
+#include "testresolvetype.moc"
+
diff --git a/ApiExtractor/tests/testresolvetype.h b/ApiExtractor/tests/testresolvetype.h
new file mode 100644
index 000000000..8dc1c0a01
--- /dev/null
+++ b/ApiExtractor/tests/testresolvetype.h
@@ -0,0 +1,36 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTRESOLVETYPE_H
+#define TESTRESOLVETYPE_H
+
+#include <QObject>
+
+class TestResolveType : public QObject
+{
+    Q_OBJECT
+    private slots:
+        void testResolveReturnTypeFromParentScope();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testreverseoperators.cpp b/ApiExtractor/tests/testreverseoperators.cpp
new file mode 100644
index 000000000..ab9cee0ff
--- /dev/null
+++ b/ApiExtractor/tests/testreverseoperators.cpp
@@ -0,0 +1,130 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testreverseoperators.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestReverseOperators::testReverseSum()
+{
+    const char cppCode[] = "struct A {\
+            A& operator+(int);\
+        };\
+        A& operator+(int, const A&);";
+    const char xmlCode[] = "\
+    <typesystem package=\"Foo\">\
+        <primitive-type name='int' />\
+        <value-type name='A' />\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QCOMPARE(classA->functions().count(), 4);
+
+    const AbstractMetaFunction* reverseOp = 0;
+    const AbstractMetaFunction* normalOp = 0;
+    foreach(const AbstractMetaFunction* func, classA->functions()) {
+        if (func->name() == "operator+") {
+            if (func->isReverseOperator())
+                reverseOp = func;
+            else
+                normalOp = func;
+        }
+    }
+
+    QVERIFY(normalOp);
+    QVERIFY(!normalOp->isReverseOperator());
+    QCOMPARE(normalOp->arguments().count(), 1);
+    QVERIFY(reverseOp);
+    QVERIFY(reverseOp->isReverseOperator());
+    QCOMPARE(reverseOp->arguments().count(), 1);
+}
+
+void TestReverseOperators::testReverseSumWithAmbiguity()
+{
+    const char cppCode[] = "\
+    struct A { A operator+(int); };\
+    A operator+(int, const A&);\
+    struct B {};\
+    B operator+(const A&, const B&);\
+    B operator+(const B&, const A&);\
+    int operator-(int, const A*);\
+    int operator/(const A*, int);\
+    ";
+    const char xmlCode[] = "\
+    <typesystem package=\"Foo\">\
+        <primitive-type name='int' />\
+        <value-type name='A' />\
+        <value-type name='B' />\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QCOMPARE(classA->functions().count(), 6);
+
+    AbstractMetaClass* classB = classes.findClass("B");
+    QVERIFY(classB);
+    QCOMPARE(classB->functions().count(), 4);
+
+    const AbstractMetaFunction* reverseOp = 0;
+    const AbstractMetaFunction* normalOp = 0;
+    foreach(const AbstractMetaFunction* func, classB->functions()) {
+        if (func->name() == "operator+") {
+            if (func->isReverseOperator())
+                reverseOp = func;
+            else
+                normalOp = func;
+        }
+    }
+    QVERIFY(normalOp);
+    QVERIFY(!normalOp->isReverseOperator());
+    QCOMPARE(normalOp->arguments().count(), 1);
+    QCOMPARE(normalOp->minimalSignature(), QString("operator+(B,A)"));
+    QVERIFY(reverseOp);
+    QVERIFY(reverseOp->isReverseOperator());
+    QCOMPARE(reverseOp->arguments().count(), 1);
+    QCOMPARE(reverseOp->minimalSignature(), QString("operator+(A,B)"));
+
+    reverseOp = classA->findFunction("operator-");
+    QVERIFY(reverseOp);
+    QCOMPARE(reverseOp->arguments().count(), 1);
+    QVERIFY(reverseOp->isPointerOperator());
+    QVERIFY(reverseOp->isReverseOperator());
+
+    normalOp = classA->findFunction("operator/");
+    QVERIFY(normalOp);
+    QCOMPARE(normalOp->arguments().count(), 1);
+    QVERIFY(normalOp->isPointerOperator());
+    QVERIFY(!normalOp->isReverseOperator());
+
+}
+
+
+
+QTEST_APPLESS_MAIN(TestReverseOperators)
+
+#include "testreverseoperators.moc"
diff --git a/ApiExtractor/tests/testreverseoperators.h b/ApiExtractor/tests/testreverseoperators.h
new file mode 100644
index 000000000..d5bdd9a1c
--- /dev/null
+++ b/ApiExtractor/tests/testreverseoperators.h
@@ -0,0 +1,36 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTREVERSEOPERATORS_H
+#define TESTREVERSEOPERATORS_H
+#include <QObject>
+
+class TestReverseOperators : public QObject
+{
+    Q_OBJECT
+private slots:
+    void testReverseSum();
+    void testReverseSumWithAmbiguity();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testtemplates.cpp b/ApiExtractor/tests/testtemplates.cpp
new file mode 100644
index 000000000..c6a65d888
--- /dev/null
+++ b/ApiExtractor/tests/testtemplates.cpp
@@ -0,0 +1,383 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testtemplates.h"
+#include <QtTest/QTest>
+#include <QTemporaryFile>
+#include "testutil.h"
+
+void TestTemplates::testTemplateWithNamespace()
+{
+    const char cppCode[] = "\
+    struct Url {\
+      void name();\
+    };\
+    namespace Internet {\
+        struct Url{};\
+        struct Bookmarks {\
+            QList<Url> list();\
+        };\
+    }";
+    const char xmlCode0[] = "\
+    <typesystem package='Pakcage.Network'>\
+        <value-type name='Url' />\
+    </typesystem>";
+
+    QTemporaryFile file;
+    QVERIFY(file.open());
+    file.write(xmlCode0);
+    file.close();
+
+    QString xmlCode1 = QString("\
+    <typesystem package='Package.Internet'>\
+        <load-typesystem name='%1' generate='no'/>\
+        <container-type name='QList' type='list'/> \
+        <namespace-type name='Internet' generate='no' />\
+        <value-type name='Internet::Url'/>\
+        <value-type name='Internet::Bookmarks'/>\
+    </typesystem>").arg(file.fileName());
+
+    TestUtil t(cppCode, qPrintable(xmlCode1), false);
+    AbstractMetaClassList classes = t.builder()->classes();
+
+    AbstractMetaClass* classB = classes.findClass("Bookmarks");
+    QVERIFY(classB);
+    const AbstractMetaFunction* func = classB->findFunction("list");
+    AbstractMetaType* funcType = func->type();
+    QVERIFY(funcType);
+    QCOMPARE(funcType->cppSignature(), QString("QList<Internet::Url >"));
+}
+
+void TestTemplates::testTemplateOnContainers()
+{
+    const char cppCode[] = "\
+    struct Base {};\
+    namespace Namespace {\
+    enum SomeEnum { E1, E2 };\
+    template<SomeEnum type> struct A {\
+        A<type> foo(const QList<A<type> >& a);\
+    };\
+    typedef A<E1> B;\
+    }\
+    ";
+    const char xmlCode[] = "\
+    <typesystem package=\"Package\">\
+        <container-type name='QList' type='list'/> \
+        <namespace-type name='Namespace' />\
+        <enum-type name='Namespace::SomeEnum'/>\
+        <object-type name='Base' />\
+        <object-type name='Namespace::A' generate='no'/> \
+        <object-type name='Namespace::B'/> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+
+    AbstractMetaClass* classB = classes.findClass("B");
+    QVERIFY(!classB->baseClass());
+    QVERIFY(classB->baseClassName().isNull());
+    const AbstractMetaFunction* func = classB->findFunction("foo");
+    AbstractMetaType* argType = func->arguments().first()->type();
+    QCOMPARE(argType->instantiations().count(), 1);
+    QCOMPARE(argType->typeEntry()->qualifiedCppName(), QString("QList"));
+
+    const AbstractMetaType* instance1 = argType->instantiations().first();
+    QCOMPARE(instance1->instantiations().count(), 1);
+    QCOMPARE(instance1->typeEntry()->qualifiedCppName(), QString("Namespace::A"));
+
+    const AbstractMetaType* instance2 = instance1->instantiations().first();
+    QCOMPARE(instance2->instantiations().count(), 0);
+    QCOMPARE(instance2->typeEntry()->qualifiedCppName(), QString("Namespace::E1"));
+}
+
+void TestTemplates::testTemplateValueAsArgument()
+{
+    const char cppCode[] = "\
+    template<typename T> struct List() {};\
+    void func(List<int> arg) {}\
+    ";
+
+    const char xmlCode[] = "\
+    <typesystem package='Package'>\
+        <primitive-type name='int' />\
+        <container-type name='List' type='list' />\
+        <function signature='func(List&lt;int&gt;)' />\
+    </typesystem>\
+    ";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaFunctionList globalFuncs = t.builder()->globalFunctions();
+    QCOMPARE(globalFuncs.count(), 1);
+
+    AbstractMetaFunction* func = globalFuncs.first();
+    QCOMPARE(func->minimalSignature(), QString("func(List<int>)"));
+    QCOMPARE(func->arguments().first()->type()->cppSignature(), QString("List<int >"));
+}
+
+void TestTemplates::testTemplatePointerAsArgument()
+{
+    const char cppCode[] = "\
+    template<typename T> struct List() {};\
+    void func(List<int>* arg) {}\
+    ";
+
+    const char xmlCode[] = "\
+    <typesystem package='Package'>\
+        <primitive-type name='int' />\
+        <container-type name='List' type='list' />\
+        <function signature='func(List&lt;int&gt;*)' />\
+    </typesystem>\
+    ";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaFunctionList globalFuncs = t.builder()->globalFunctions();
+    QCOMPARE(globalFuncs.count(), 1);
+
+    AbstractMetaFunction* func = globalFuncs.first();
+    QCOMPARE(func->minimalSignature(), QString("func(List<int>*)"));
+    QCOMPARE(func->arguments().first()->type()->cppSignature(), QString("List<int > *"));
+}
+
+void TestTemplates::testTemplateReferenceAsArgument()
+{
+    const char cppCode[] = "\
+    template<typename T> struct List() {};\
+    void func(List<int>& arg) {}\
+    ";
+
+    const char xmlCode[] = "\
+    <typesystem package='Package'>\
+        <primitive-type name='int' />\
+        <container-type name='List' type='list' />\
+        <function signature='func(List&lt;int&gt;&amp;)' />\
+    </typesystem>\
+    ";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaFunctionList globalFuncs = t.builder()->globalFunctions();
+    QCOMPARE(globalFuncs.count(), 1);
+
+    AbstractMetaFunction* func = globalFuncs.first();
+    QCOMPARE(func->minimalSignature(), QString("func(List<int>&)"));
+    QCOMPARE(func->arguments().first()->type()->cppSignature(), QString("List<int > &"));
+}
+
+void TestTemplates::testInheritanceFromContainterTemplate()
+{
+    const char cppCode[] = "\
+    template<typename T>\
+    struct ListContainer {\
+        inline void push_front(const T& t);\
+        inline T& front();\
+    };\
+    struct FooBar {};\
+    struct FooBars : public ListContainer<FooBar> {};\
+    ";
+
+    const char xmlCode[] = "\
+    <typesystem package='Package'>\
+        <container-type name='ListContainer' type='list' /> \
+        <value-type name='FooBar' />\
+        <value-type name='FooBars'>\
+            <modify-function signature='push_front(FooBar)' remove='all' />\
+            <modify-function signature='front()' remove='all' />\
+        </value-type>\
+    </typesystem>\
+    ";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClassList templates = t.builder()->templates();
+    QCOMPARE(classes.count(), 2);
+    QCOMPARE(templates.count(), 1);
+
+    const AbstractMetaClass* foobars = classes.findClass("FooBars");
+    QCOMPARE(foobars->functions().count(), 4);
+
+    const AbstractMetaClass* lc = templates.first();
+    QCOMPARE(lc->functions().count(), 2);
+}
+
+void TestTemplates::testTemplateInheritanceMixedWithForwardDeclaration()
+{
+    const char cppCode[] = "\
+    enum SomeEnum { E1, E2 };\
+    template<SomeEnum type> struct Future;\
+    template<SomeEnum type>\
+    struct A {\
+        A();\
+        void method();\
+        friend struct Future<type>;\
+    };\
+    typedef A<E1> B;\
+    template<SomeEnum type> struct Future {};\
+    ";
+    const char xmlCode[] = "\
+    <typesystem package='Package'>\
+        <enum-type name='SomeEnum' />\
+        <value-type name='A' generate='no' />\
+        <value-type name='B' />\
+        <value-type name='Future' generate='no' />\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+
+    AbstractMetaClass* classB = classes.findClass("B");
+    QVERIFY(!classB->baseClass());
+    QVERIFY(classB->baseClassName().isNull());
+    // 3 functions: simple constructor, copy constructor and "method()".
+    QCOMPARE(classB->functions().count(), 3);
+}
+
+void TestTemplates::testTemplateInheritanceMixedWithNamespaceAndForwardDeclaration()
+{
+    const char cppCode[] = "\
+    namespace Namespace {\
+    enum SomeEnum { E1, E2 };\
+    template<SomeEnum type> struct Future;\
+    template<SomeEnum type>\
+    struct A {\
+        A();\
+        void method();\
+        friend struct Future<type>;\
+    };\
+    typedef A<E1> B;\
+    template<SomeEnum type> struct Future {};\
+    };\
+    ";
+    const char xmlCode[] = "\
+    <typesystem package='Package'>\
+        <namespace-type name='Namespace' />\
+        <enum-type name='Namespace::SomeEnum' />\
+        <value-type name='Namespace::A' generate='no' />\
+        <value-type name='Namespace::B' />\
+        <value-type name='Namespace::Future' generate='no' />\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+
+    AbstractMetaClass* classB = classes.findClass("Namespace::B");
+    QVERIFY(!classB->baseClass());
+    QVERIFY(classB->baseClassName().isNull());
+    // 3 functions: simple constructor, copy constructor and "method()".
+    QCOMPARE(classB->functions().count(), 3);
+}
+
+void TestTemplates::testTypedefOfInstantiationOfTemplateClass()
+{
+    const char cppCode[] = "\
+    namespace NSpace {\
+    enum ClassType {\
+        TypeOne\
+    };\
+    template<ClassType CLASS_TYPE>\
+    struct BaseTemplateClass {\
+        inline ClassType getClassType() const { CLASS_TYPE; }\
+    };\
+    typedef BaseTemplateClass<TypeOne> TypeOneClass;\
+    }\
+    ";
+
+    const char xmlCode[] = "\
+    <typesystem package='Package'>\
+        <namespace-type name='NSpace'>\
+            <enum-type name='ClassType'/>\
+            <object-type name='BaseTemplateClass' generate='no'/>\
+            <object-type name='TypeOneClass'/>\
+        </namespace-type>\
+    </typesystem>\
+    ";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 3);
+
+    const AbstractMetaClass* base = classes.findClass("BaseTemplateClass");
+    QVERIFY(base);
+    const AbstractMetaClass* one = classes.findClass("TypeOneClass");
+    QVERIFY(one);
+    QCOMPARE(one->templateBaseClass(), base);
+    QCOMPARE(one->functions().count(), base->functions().count());
+    QVERIFY(one->isTypeAlias());
+    const ComplexTypeEntry* oneType = one->typeEntry();
+    const ComplexTypeEntry* baseType = base->typeEntry();
+    QCOMPARE(oneType->baseContainerType(), baseType);
+    QCOMPARE(one->baseClassNames(), QStringList("BaseTemplateClass<TypeOne>"));
+
+    QVERIFY(one->hasTemplateBaseClassInstantiations());
+    AbstractMetaTypeList instantiations = one->templateBaseClassInstantiations();
+    QCOMPARE(instantiations.count(), 1);
+    const AbstractMetaType* inst = instantiations.first();
+    QVERIFY(inst);
+    QVERIFY(!inst->isEnum());
+    QVERIFY(!inst->typeEntry()->isEnum());
+    QVERIFY(inst->typeEntry()->isEnumValue());
+    QCOMPARE(inst->cppSignature(), QString("NSpace::TypeOne"));
+}
+
+void TestTemplates::testContainerTypeIncompleteArgument()
+{
+    const char* cppCode ="\
+    template<typename T>\
+    class Vector {\
+        void method(const Vector& vector);\
+        Vector otherMethod();\
+    };\
+    template <typename T>\
+    void Vector<T>::method(const Vector<T>& vector) {}\
+    Vector Vector<T>::otherMethod() { return Vector<T>(); }\
+    typedef Vector<int> IntVector;\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'>\
+        <primitive-type name='int'/>\
+        <container-type name='Vector' type='vector'/>\
+        <value-type name='IntVector'/>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, true);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 1);
+
+    AbstractMetaClass* vector = classes.findClass("IntVector");
+    QVERIFY(vector);
+    QVERIFY(vector->typeEntry()->baseContainerType());
+    QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(vector->typeEntry()->baseContainerType())->type(), ContainerTypeEntry::VectorContainer);
+    QCOMPARE(vector->functions().count(), 4);
+
+    const AbstractMetaFunction* method = vector->findFunction("method");
+    QVERIFY(method);
+    QCOMPARE(method->signature(), QString("method(const Vector<int > & vector)"));
+
+    const AbstractMetaFunction* otherMethod = vector->findFunction("otherMethod");
+    QVERIFY(otherMethod);
+    QCOMPARE(otherMethod->signature(), QString("otherMethod()"));
+    QVERIFY(otherMethod->type());
+    QCOMPARE(otherMethod->type()->cppSignature(), QString("Vector<int >"));
+}
+
+QTEST_APPLESS_MAIN(TestTemplates)
+
+#include "testtemplates.moc"
diff --git a/ApiExtractor/tests/testtemplates.h b/ApiExtractor/tests/testtemplates.h
new file mode 100644
index 000000000..578691169
--- /dev/null
+++ b/ApiExtractor/tests/testtemplates.h
@@ -0,0 +1,45 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTTEMPLATES_H
+#define TESTTEMPLATES_H
+
+#include <QObject>
+
+class TestTemplates : public QObject
+{
+    Q_OBJECT
+private slots:
+    void testTemplateOnContainers();
+    void testTemplateWithNamespace();
+    void testTemplateValueAsArgument();
+    void testTemplatePointerAsArgument();
+    void testTemplateReferenceAsArgument();
+    void testInheritanceFromContainterTemplate();
+    void testTemplateInheritanceMixedWithForwardDeclaration();
+    void testTemplateInheritanceMixedWithNamespaceAndForwardDeclaration();
+    void testTypedefOfInstantiationOfTemplateClass();
+    void testContainerTypeIncompleteArgument();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testtoposort.cpp b/ApiExtractor/tests/testtoposort.cpp
new file mode 100644
index 000000000..d33786720
--- /dev/null
+++ b/ApiExtractor/tests/testtoposort.cpp
@@ -0,0 +1,65 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testtoposort.h"
+#include <QtTest/QTest>
+#include "graph.h"
+#include <QDebug>
+
+void TestTopoSort::testTopoSort()
+{
+    QLinkedList<int> result;
+    {
+        Graph g(3);
+        g.addEdge(1, 2);
+        g.addEdge(0, 1);
+        result = g.topologicalSort();
+        QCOMPARE(result.size(), 3);
+        QLinkedList<int>::iterator it = result.begin();
+        QCOMPARE(*it, 0);
+        QCOMPARE(*(++it), 1);
+        QCOMPARE(*(++it), 2);
+    }
+    {
+        Graph g(2);
+        result = g.topologicalSort();
+        QCOMPARE(result.size(), 2);
+        QLinkedList<int>::iterator it = result.begin();
+        QCOMPARE(*it, 1);
+        QCOMPARE(*(++it), 0);
+    }
+}
+
+void TestTopoSort::testCiclicGraph()
+{
+    Graph g(3);
+    g.addEdge(0, 1);
+    g.addEdge(1, 2);
+    g.addEdge(2, 0);
+    QLinkedList<int> result = g.topologicalSort();
+    QVERIFY(result.isEmpty());
+}
+
+QTEST_APPLESS_MAIN(TestTopoSort)
+
+#include "testtoposort.moc"
diff --git a/ApiExtractor/tests/testtoposort.h b/ApiExtractor/tests/testtoposort.h
new file mode 100644
index 000000000..ad6447abd
--- /dev/null
+++ b/ApiExtractor/tests/testtoposort.h
@@ -0,0 +1,37 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTTOPOSORT_H
+#define TESTTOPOSORT_H
+
+#include <QObject>
+
+class TestTopoSort : public QObject
+{
+Q_OBJECT
+private slots:
+    void testTopoSort();
+    void testCiclicGraph();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testtyperevision.cpp b/ApiExtractor/tests/testtyperevision.cpp
new file mode 100644
index 000000000..6fadfa9fa
--- /dev/null
+++ b/ApiExtractor/tests/testtyperevision.cpp
@@ -0,0 +1,64 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*/
+
+#include "testtyperevision.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+
+void TestTypeRevision::testRevisionAttr()
+{
+    const char* cppCode = "class Rev_0 {};"
+                          "class Rev_1 {};"
+                          "class Rev_2 { public: enum Rev_3 { X }; enum Rev_5 { Y }; };";
+    const char* xmlCode = "<typesystem package=\"Foo\">"
+                        "<value-type name=\"Rev_0\"/>"
+                        "<value-type name=\"Rev_1\" revision=\"1\"/>"
+                        "<object-type name=\"Rev_2\" revision=\"2\">"
+                        "    <enum-type name=\"Rev_3\" revision=\"3\" flags=\"Flag_4\" flags-revision=\"4\" />"
+                        "    <enum-type name=\"Rev_5\" revision=\"5\" flags=\"Flag_5\" />"
+                        "</object-type>"
+                        "</typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* rev0 = classes.findClass("Rev_0");
+    QCOMPARE(getTypeRevision(rev0->typeEntry()), 0);
+
+    AbstractMetaClass* rev1 = classes.findClass("Rev_1");
+    QCOMPARE(getTypeRevision(rev1->typeEntry()), 1);
+
+    AbstractMetaClass* rev2 = classes.findClass("Rev_2");
+    QCOMPARE(getTypeRevision(rev2->typeEntry()), 2);
+
+    AbstractMetaEnum* rev3 = rev2->findEnum("Rev_3");
+    QCOMPARE(getTypeRevision(rev3->typeEntry()), 3);
+    FlagsTypeEntry* rev4 = rev3->typeEntry()->flags();
+    QCOMPARE(getTypeRevision(rev4), 4);
+    AbstractMetaEnum* rev5 = rev2->findEnum("Rev_5");
+    QCOMPARE(getTypeRevision(rev5->typeEntry()), 5);
+    QCOMPARE(getTypeRevision(rev5->typeEntry()->flags()), 5);
+}
+
+QTEST_APPLESS_MAIN(TestTypeRevision)
+
+#include "testtyperevision.moc"
+
diff --git a/ApiExtractor/tests/testtyperevision.h b/ApiExtractor/tests/testtyperevision.h
new file mode 100644
index 000000000..24e94739f
--- /dev/null
+++ b/ApiExtractor/tests/testtyperevision.h
@@ -0,0 +1,36 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*/
+
+#ifndef TESTTYPEREVISION_H
+#define TESTTYPEREVISION_H
+
+#include <QObject>
+
+class TestTypeRevision : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void testRevisionAttr();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testutil.h b/ApiExtractor/tests/testutil.h
new file mode 100644
index 000000000..9519fb8b2
--- /dev/null
+++ b/ApiExtractor/tests/testutil.h
@@ -0,0 +1,72 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTUTIL_H
+#define TESTUTIL_H
+#include <QtCore/QBuffer>
+#include "abstractmetabuilder.h"
+#include "reporthandler.h"
+#include "typedatabase.h"
+
+class TestUtil
+{
+public:
+    TestUtil(const char* cppCode, const char* xmlCode,
+             bool silent = true, const char* apiVersion = 0,
+             QStringList dropTypeEntries = QStringList())
+        : m_builder(0)
+    {
+        ReportHandler::setSilent(silent);
+        m_builder = new AbstractMetaBuilder;
+        TypeDatabase* td = TypeDatabase::instance(true);
+        if (apiVersion)
+            td->setApiVersion("*", apiVersion);
+        td->setDropTypeEntries(dropTypeEntries);
+        QBuffer buffer;
+        // parse typesystem
+        buffer.setData(xmlCode);
+        td->parseFile(&buffer);
+        buffer.close();
+        // parse C++ code
+        buffer.setData(cppCode);
+        bool res = m_builder->build(&buffer);
+        Q_UNUSED(res);
+        Q_ASSERT(res);
+    }
+
+    ~TestUtil()
+    {
+        delete m_builder;
+        m_builder = 0;
+    }
+
+    AbstractMetaBuilder* builder()
+    {
+        return m_builder;
+    }
+
+private:
+    AbstractMetaBuilder* m_builder;
+};
+
+#endif
diff --git a/ApiExtractor/tests/testvaluetypedefaultctortag.cpp b/ApiExtractor/tests/testvaluetypedefaultctortag.cpp
new file mode 100644
index 000000000..e8f8d83ee
--- /dev/null
+++ b/ApiExtractor/tests/testvaluetypedefaultctortag.cpp
@@ -0,0 +1,57 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "testvaluetypedefaultctortag.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+void TestValueTypeDefaultCtorTag::testValueTypeDefaultCtorTagArgument()
+{
+    const char* cppCode ="\
+    struct A {\
+        A(int,int);\
+    };\
+    struct B {};\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'>\
+        <primitive-type name='int' />\
+        <value-type name='A' default-constructor='A(0, 0)' />\
+        <value-type name='B' />\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QVERIFY(classA->typeEntry()->hasDefaultConstructor());
+    QCOMPARE(classA->typeEntry()->defaultConstructor(), QString("A(0, 0)"));
+
+    AbstractMetaClass* classB = classes.findClass("B");
+    QVERIFY(classB);
+    QVERIFY(!classB->typeEntry()->hasDefaultConstructor());
+}
+
+QTEST_APPLESS_MAIN(TestValueTypeDefaultCtorTag)
+
+#include "testvaluetypedefaultctortag.moc"
diff --git a/ApiExtractor/tests/testvaluetypedefaultctortag.h b/ApiExtractor/tests/testvaluetypedefaultctortag.h
new file mode 100644
index 000000000..a271d5f8f
--- /dev/null
+++ b/ApiExtractor/tests/testvaluetypedefaultctortag.h
@@ -0,0 +1,36 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTVALUETYPEDEFAULTCTORTAG_H
+#define TESTVALUETYPEDEFAULTCTORTAG_H
+
+#include <QObject>
+
+class TestValueTypeDefaultCtorTag : public QObject
+{
+    Q_OBJECT
+    private slots:
+        void testValueTypeDefaultCtorTagArgument();
+};
+
+#endif
diff --git a/ApiExtractor/tests/testvoidarg.cpp b/ApiExtractor/tests/testvoidarg.cpp
new file mode 100644
index 000000000..7f9256ad9
--- /dev/null
+++ b/ApiExtractor/tests/testvoidarg.cpp
@@ -0,0 +1,81 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2009,2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#include "testvoidarg.h"
+#include <QtTest/QTest>
+#include "testutil.h"
+
+
+void TestVoidArg::testVoidParsedFunction()
+{
+    const char cppCode[] = "struct A { void a(void); };";
+    const char xmlCode[] = "\
+    <typesystem package=\"Foo\">\
+        <value-type name='A'/>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    const AbstractMetaFunction* addedFunc = classA->findFunction("a");
+    QCOMPARE(addedFunc->arguments().count(), 0);
+}
+
+void TestVoidArg::testVoidAddedFunction()
+{
+    const char cppCode[] = "struct A { };";
+    const char xmlCode[] = "\
+    <typesystem package=\"Foo\">\
+        <value-type name='A' >\
+            <add-function signature=\"a(void)\"/>\
+        </value-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    const AbstractMetaFunction* addedFunc = classA->findFunction("a");
+    QCOMPARE(addedFunc->arguments().count(), 0);
+
+}
+
+void TestVoidArg::testVoidPointerParsedFunction()
+{
+    const char cppCode[] = "struct A { void a(void*); };";
+    const char xmlCode[] = "\
+    <typesystem package=\"Foo\">\
+        <value-type name='A' />\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    const AbstractMetaFunction* addedFunc = classA->findFunction("a");
+    QCOMPARE(addedFunc->arguments().count(), 1);
+
+}
+
+QTEST_APPLESS_MAIN(TestVoidArg)
+
+#include "testvoidarg.moc"
+
diff --git a/ApiExtractor/tests/testvoidarg.h b/ApiExtractor/tests/testvoidarg.h
new file mode 100644
index 000000000..589a3572d
--- /dev/null
+++ b/ApiExtractor/tests/testvoidarg.h
@@ -0,0 +1,37 @@
+/*
+* This file is part of the API Extractor project.
+*
+* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+*
+* Contact: PySide team <contact@pyside.org>
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* version 2 as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA
+*
+*/
+
+#ifndef TESTVOIDARG_H
+#define TESTVOIDARG_H
+#include <QObject>
+
+class TestVoidArg : public QObject
+{
+    Q_OBJECT
+private slots:
+    void testVoidParsedFunction();
+    void testVoidPointerParsedFunction();
+    void testVoidAddedFunction();
+};
+
+#endif
diff --git a/ApiExtractor/tests/utf8code.txt b/ApiExtractor/tests/utf8code.txt
new file mode 100644
index 000000000..6d5fa9dcf
--- /dev/null
+++ b/ApiExtractor/tests/utf8code.txt
@@ -0,0 +1 @@
+áéíóú
\ No newline at end of file
diff --git a/ApiExtractor/typedatabase.cpp b/ApiExtractor/typedatabase.cpp
new file mode 100644
index 000000000..d5c1eb6ce
--- /dev/null
+++ b/ApiExtractor/typedatabase.cpp
@@ -0,0 +1,548 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "typedatabase.h"
+#include "typesystem.h"
+#include "typesystem_p.h"
+
+#include <QFile>
+#include <QXmlInputSource>
+#include "reporthandler.h"
+// #include <tr1/tuple>
+#include <algorithm>
+
+// package -> api-version
+typedef QMap<QString, QByteArray> ApiVersionMap;
+
+Q_GLOBAL_STATIC(ApiVersionMap, apiVersions)
+
+TypeDatabase::TypeDatabase() : m_suppressWarnings(true), m_apiVersion(0)
+{
+    addType(new VoidTypeEntry());
+    addType(new VarargsTypeEntry());
+}
+
+TypeDatabase* TypeDatabase::instance(bool newInstance)
+{
+    static TypeDatabase* db = 0;
+    if (!db || newInstance) {
+        if (db)
+            delete db;
+        db = new TypeDatabase;
+    }
+    return db;
+}
+
+QString TypeDatabase::normalizedSignature(const char* signature)
+{
+    QString normalized = QMetaObject::normalizedSignature(signature);
+
+    if (!instance() || !QString(signature).contains("unsigned"))
+        return normalized;
+
+    QStringList types;
+    types << "char" << "short" << "int" << "long";
+    foreach (const QString& type, types) {
+        if (instance()->findType(QString("u%1").arg(type)))
+            continue;
+        normalized.replace(QRegExp(QString("\\bu%1\\b").arg(type)), QString("unsigned %1").arg(type));
+    }
+
+    return normalized;
+}
+
+QStringList TypeDatabase::requiredTargetImports() const
+{
+    return m_requiredTargetImports;
+}
+
+void TypeDatabase::addRequiredTargetImport(const QString& moduleName)
+{
+    if (!m_requiredTargetImports.contains(moduleName))
+        m_requiredTargetImports << moduleName;
+}
+
+void TypeDatabase::addTypesystemPath(const QString& typesystem_paths)
+{
+    #if defined(Q_OS_WIN32)
+    char* path_splitter = const_cast<char*>(";");
+    #else
+    char* path_splitter = const_cast<char*>(":");
+    #endif
+    m_typesystemPaths += typesystem_paths.split(path_splitter);
+}
+
+IncludeList TypeDatabase::extraIncludes(const QString& className) const
+{
+    ComplexTypeEntry* typeEntry = findComplexType(className);
+    if (typeEntry)
+        return typeEntry->extraIncludes();
+    else
+        return IncludeList();
+}
+
+ContainerTypeEntry* TypeDatabase::findContainerType(const QString &name) const
+{
+    QString template_name = name;
+
+    int pos = name.indexOf('<');
+    if (pos > 0)
+        template_name = name.left(pos);
+
+    TypeEntry* type_entry = findType(template_name);
+    if (type_entry && type_entry->isContainer())
+        return static_cast<ContainerTypeEntry*>(type_entry);
+    return 0;
+}
+
+FunctionTypeEntry* TypeDatabase::findFunctionType(const QString& name) const
+{
+    TypeEntry* entry = findType(name);
+    if (entry && entry->type() == TypeEntry::FunctionType)
+        return static_cast<FunctionTypeEntry*>(entry);
+    return 0;
+}
+
+
+PrimitiveTypeEntry* TypeDatabase::findTargetLangPrimitiveType(const QString& targetLangName) const
+{
+    foreach (QList<TypeEntry*> entries, m_entries.values()) {
+        foreach (TypeEntry* e, entries) {
+            if (e && e->isPrimitive()) {
+                PrimitiveTypeEntry *pe = static_cast<PrimitiveTypeEntry*>(e);
+                if (pe->targetLangName() == targetLangName && pe->preferredConversion())
+                    return pe;
+            }
+        }
+    }
+
+    return 0;
+}
+
+TypeEntry* TypeDatabase::findType(const QString& name) const
+{
+    QList<TypeEntry *> entries = findTypes(name);
+    foreach (TypeEntry *entry, entries) {
+        if (entry &&
+            (!entry->isPrimitive() || static_cast<PrimitiveTypeEntry *>(entry)->preferredTargetLangType())) {
+            return entry;
+        }
+    }
+    return 0;
+}
+
+SingleTypeEntryHash TypeDatabase::entries() const
+{
+    TypeEntryHash entries = allEntries();
+
+    SingleTypeEntryHash returned;
+    QList<QString> keys = entries.keys();
+
+    foreach (QString key, keys)
+        returned[key] = findType(key);
+
+    return returned;
+}
+
+QList<const PrimitiveTypeEntry*> TypeDatabase::primitiveTypes() const
+{
+    TypeEntryHash entries = allEntries();
+    QList<const PrimitiveTypeEntry*> returned;
+    foreach(QString key, entries.keys()) {
+        foreach(const TypeEntry* typeEntry, entries[key]) {
+            if (typeEntry->isPrimitive())
+                returned.append((PrimitiveTypeEntry*) typeEntry);
+        }
+    }
+    return returned;
+}
+
+QList<const ContainerTypeEntry*> TypeDatabase::containerTypes() const
+{
+    TypeEntryHash entries = allEntries();
+    QList<const ContainerTypeEntry*> returned;
+    foreach(QString key, entries.keys()) {
+        foreach(const TypeEntry* typeEntry, entries[key]) {
+            if (typeEntry->isContainer())
+                returned.append((ContainerTypeEntry*) typeEntry);
+        }
+    }
+    return returned;
+}
+void TypeDatabase::addRejection(const QString& className, const QString& functionName,
+                                const QString& fieldName, const QString& enumName)
+{
+    TypeRejection r;
+    r.class_name = className;
+    r.function_name = functionName;
+    r.field_name = fieldName;
+    r.enum_name = enumName;
+
+    m_rejections << r;
+}
+
+bool TypeDatabase::isClassRejected(const QString& className) const
+{
+    if (!m_rebuildClasses.isEmpty())
+        return !m_rebuildClasses.contains(className);
+
+    foreach (const TypeRejection& r, m_rejections)
+    if (r.class_name == className && r.function_name == "*" && r.field_name == "*" && r.enum_name == "*")
+        return true;
+
+    return false;
+}
+
+bool TypeDatabase::isEnumRejected(const QString& className, const QString& enumName) const
+{
+    foreach (const TypeRejection& r, m_rejections) {
+        if (r.enum_name == enumName
+            && (r.class_name == className || r.class_name == "*")) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool TypeDatabase::isFunctionRejected(const QString& className, const QString& functionName) const
+{
+    foreach (const TypeRejection& r, m_rejections)
+    if (r.function_name == functionName &&
+        (r.class_name == className || r.class_name == "*"))
+        return true;
+    return false;
+}
+
+
+bool TypeDatabase::isFieldRejected(const QString& className, const QString& fieldName) const
+{
+    foreach (const TypeRejection& r, m_rejections)
+    if (r.field_name == fieldName &&
+        (r.class_name == className || r.class_name == "*"))
+        return true;
+    return false;
+}
+
+FlagsTypeEntry* TypeDatabase::findFlagsType(const QString &name) const
+{
+    FlagsTypeEntry* fte = (FlagsTypeEntry*) findType(name);
+    if (!fte) {
+        fte = (FlagsTypeEntry*) m_flagsEntries.value(name);
+        if (!fte) {
+            //last hope, search for flag without scope  inside of flags hash
+            foreach(QString key, m_flagsEntries.keys()) {
+                if (key.endsWith(name)) {
+                    fte = (FlagsTypeEntry*) m_flagsEntries.value(key);
+                    break;
+                }
+            }
+        }
+    }
+    return fte;
+}
+
+AddedFunctionList TypeDatabase::findGlobalUserFunctions(const QString& name) const
+{
+    AddedFunctionList addedFunctions;
+    foreach (AddedFunction func, m_globalUserFunctions) {
+        if (func.name() == name)
+            addedFunctions.append(func);
+    }
+    return addedFunctions;
+}
+
+
+QString TypeDatabase::globalNamespaceClassName(const TypeEntry * /*entry*/)
+{
+    return QLatin1String("Global");
+}
+
+FunctionModificationList TypeDatabase::functionModifications(const QString& signature) const
+{
+    FunctionModificationList lst;
+    for (int i = 0; i < m_functionMods.count(); ++i) {
+        const FunctionModification& mod = m_functionMods.at(i);
+        if (mod.signature == signature)
+            lst << mod;
+    }
+
+    return lst;
+}
+
+bool TypeDatabase::isSuppressedWarning(const QString& s) const
+{
+    if (!m_suppressWarnings)
+        return false;
+
+    foreach (const QString &_warning, m_suppressedWarnings) {
+        QString warning(QString(_warning).replace("\\*", "&place_holder_for_asterisk;"));
+
+        QStringList segs = warning.split("*", QString::SkipEmptyParts);
+        if (!segs.size())
+            continue;
+
+        int i = 0;
+        int pos = s.indexOf(QString(segs.at(i++)).replace("&place_holder_for_asterisk;", "*"));
+        //qDebug() << "s == " << s << ", warning == " << segs;
+        while (pos != -1) {
+            if (i == segs.size())
+                return true;
+            pos = s.indexOf(QString(segs.at(i++)).replace("&place_holder_for_asterisk;", "*"), pos);
+        }
+    }
+
+    return false;
+}
+
+QString TypeDatabase::modifiedTypesystemFilepath(const QString& tsFile) const
+{
+    if (!QFile::exists(tsFile)) {
+        int idx = tsFile.lastIndexOf('/');
+        QString fileName = idx >= 0 ? tsFile.right(tsFile.length() - idx - 1) : tsFile;
+        foreach (const QString &path, m_typesystemPaths) {
+            QString filepath(path + '/' + fileName);
+            if (QFile::exists(filepath))
+                return filepath;
+        }
+    }
+    return tsFile;
+}
+
+bool TypeDatabase::parseFile(const QString &filename, bool generate)
+{
+    QString filepath = modifiedTypesystemFilepath(filename);
+    if (m_parsedTypesystemFiles.contains(filepath))
+        return m_parsedTypesystemFiles[filepath];
+
+    QFile file(filepath);
+    if (!file.exists()) {
+        ReportHandler::warning("Can't find " + filename+", typesystem paths: "+m_typesystemPaths.join(", "));
+        return false;
+    }
+
+    int count = m_entries.size();
+    bool ok = parseFile(&file, generate);
+    m_parsedTypesystemFiles[filepath] = ok;
+    int newCount = m_entries.size();
+
+    ReportHandler::debugSparse(QString::fromLatin1("Parsed: '%1', %2 new entries")
+    .arg(filename)
+    .arg(newCount - count));
+    return ok;
+}
+
+bool TypeDatabase::parseFile(QIODevice* device, bool generate)
+{
+    if (m_apiVersion) // backwards compatibility with deprecated API
+        setApiVersion("*", QByteArray::number(m_apiVersion));
+
+    QXmlInputSource source(device);
+    QXmlSimpleReader reader;
+    Handler handler(this, generate);
+
+    reader.setContentHandler(&handler);
+    reader.setErrorHandler(&handler);
+
+    return reader.parse(&source, false);
+}
+
+PrimitiveTypeEntry *TypeDatabase::findPrimitiveType(const QString& name) const
+{
+    QList<TypeEntry*> entries = findTypes(name);
+
+    foreach (TypeEntry* entry, entries) {
+        if (entry && entry->isPrimitive() && static_cast<PrimitiveTypeEntry*>(entry)->preferredTargetLangType())
+            return static_cast<PrimitiveTypeEntry*>(entry);
+    }
+
+    return 0;
+}
+
+ComplexTypeEntry* TypeDatabase::findComplexType(const QString& name) const
+{
+    QList<TypeEntry*> entries = findTypes(name);
+    foreach (TypeEntry* entry, entries) {
+        if (entry && entry->isComplex())
+            return static_cast<ComplexTypeEntry*>(entry);
+    }
+    return 0;
+}
+
+ObjectTypeEntry* TypeDatabase::findObjectType(const QString& name) const
+{
+    QList<TypeEntry*> entries = findTypes(name);
+    foreach (TypeEntry* entry, entries) {
+        if (entry && entry->isObject())
+            return static_cast<ObjectTypeEntry*>(entry);
+    }
+    return 0;
+}
+
+NamespaceTypeEntry* TypeDatabase::findNamespaceType(const QString& name) const
+{
+    QList<TypeEntry*> entries = findTypes(name);
+    foreach (TypeEntry* entry, entries) {
+        if (entry && entry->isNamespace())
+            return static_cast<NamespaceTypeEntry*>(entry);
+    }
+    return 0;
+}
+
+bool TypeDatabase::supportedApiVersion(double version) const
+{
+    return version <= m_apiVersion;
+}
+
+bool TypeDatabase::shouldDropTypeEntry(const QString& fullTypeName) const
+{
+    return m_dropTypeEntries.contains(fullTypeName);
+}
+
+void TypeDatabase::setDropTypeEntries(QStringList dropTypeEntries)
+{
+    m_dropTypeEntries = dropTypeEntries;
+    m_dropTypeEntries.sort();
+}
+
+// Using std::pair to save some memory
+// the pair means (revision, typeIndex)
+// This global variable exists only because we can't break the ABI
+typedef QHash<const TypeEntry*, std::pair<int, int> > TypeRevisionMap;
+Q_GLOBAL_STATIC(TypeRevisionMap, typeEntryFields);
+static bool computeTypeIndexes = true;
+static int maxTypeIndex;
+
+int getTypeRevision(const TypeEntry* typeEntry)
+{
+    return typeEntryFields()->value(typeEntry).first;
+}
+
+void setTypeRevision(TypeEntry* typeEntry, int revision)
+{
+    (*typeEntryFields())[typeEntry].first = revision;
+    computeTypeIndexes = true;
+}
+
+static bool compareTypeEntriesByName(const TypeEntry* t1, const TypeEntry* t2)
+{
+    return t1->qualifiedCppName() < t2->qualifiedCppName();
+}
+
+static void _computeTypeIndexes()
+{
+    TypeDatabase* tdb = TypeDatabase::instance();
+    typedef QMap<int, QList<TypeEntry*> > GroupedTypeEntries;
+    GroupedTypeEntries groupedEntries;
+
+    // Group type entries by revision numbers
+    TypeEntryHash allEntries = tdb->allEntries();
+    foreach (QList<TypeEntry*> entryList, allEntries) {
+        foreach (TypeEntry* entry, entryList) {
+            if (entry->isPrimitive()
+                || entry->isContainer()
+                || entry->isFunction()
+                || !entry->generateCode()
+                || entry->isEnumValue()
+                || entry->isVarargs()
+                || entry->isTypeSystem()
+                || entry->isVoid()
+                || entry->isCustom())
+                continue;
+            groupedEntries[getTypeRevision(entry)] << entry;
+        }
+    }
+
+    maxTypeIndex = 0;
+    GroupedTypeEntries::iterator it = groupedEntries.begin();
+    for (; it != groupedEntries.end(); ++it) {
+        // Remove duplicates
+        QList<TypeEntry*>::iterator newEnd = std::unique(it.value().begin(), it.value().end());
+        it.value().erase(newEnd, it.value().end());
+        // Sort the type entries by name
+        qSort(it.value().begin(), newEnd, compareTypeEntriesByName);
+
+        foreach (TypeEntry* entry, it.value()) {
+            (*typeEntryFields())[entry].second = maxTypeIndex++;
+        }
+    }
+    computeTypeIndexes = false;
+}
+
+int getTypeIndex(const TypeEntry* typeEntry)
+{
+    if (computeTypeIndexes)
+        _computeTypeIndexes();
+    return typeEntryFields()->value(typeEntry).second;
+}
+
+int getMaxTypeIndex()
+{
+    if (computeTypeIndexes)
+        _computeTypeIndexes();
+    return maxTypeIndex;
+}
+
+void TypeDatabase::setApiVersion(const QString& package, const QByteArray& version)
+{
+    (*apiVersions())[package.trimmed()] = version.trimmed();
+}
+
+/**
+ * Returns -1, 0 or 1 if v1 is less, equal or greater than v2
+ */
+static int versionCheck(const QByteArray& v1, const QByteArray& v2)
+{
+    if (v1.isEmpty() || v2.isEmpty())
+        return 0;
+
+    QList<QByteArray> v1Components = v1.split('.');
+    QList<QByteArray> v2Components = v2.split('.');
+    int numComponents = qMax(v1Components.count(), v2Components.count());
+    while (v1Components.count() < numComponents)
+        v1Components.append("0");
+    while (v2Components.count() < numComponents)
+        v2Components.append("0");
+
+    for (int i = 0, max = v1Components.count(); i < max; ++i) {
+        int v1Comp = v1Components[i].toInt();
+        int v2Comp = v2Components[i].toInt();
+        if (v1Comp > v2Comp)
+            return 1;
+        else if (v1Comp < v2Comp)
+            return -1;
+    }
+    return 0;
+}
+
+bool TypeDatabase::checkApiVersion(const QString& package, const QByteArray& version) const
+{
+    ApiVersionMap* vMap = apiVersions();
+    ApiVersionMap::const_iterator it = vMap->begin();
+    for (; it != vMap->end(); ++it) {
+        QRegExp regex(it.key(), Qt::CaseSensitive, QRegExp::Wildcard);
+        if (regex.exactMatch(package))
+            return versionCheck(it.value(), version) >= 0;
+    }
+    return false;
+}
diff --git a/ApiExtractor/typedatabase.h b/ApiExtractor/typedatabase.h
new file mode 100644
index 000000000..8c735c1c1
--- /dev/null
+++ b/ApiExtractor/typedatabase.h
@@ -0,0 +1,226 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef TYPEDATABASE_H
+#define TYPEDATABASE_H
+
+#include <QStringList>
+#include "typesystem.h"
+
+APIEXTRACTOR_API void setTypeRevision(TypeEntry* typeEntry, int revision);
+APIEXTRACTOR_API int getTypeRevision(const TypeEntry* typeEntry);
+APIEXTRACTOR_API int getTypeIndex(const TypeEntry* typeEntry);
+APIEXTRACTOR_API int getMaxTypeIndex();
+
+class ContainerTypeEntry;
+class PrimitiveTypeEntry;
+class APIEXTRACTOR_API TypeDatabase
+{
+    TypeDatabase();
+    TypeDatabase(const TypeDatabase&);
+    TypeDatabase& operator=(const TypeDatabase&);
+public:
+
+    /**
+    * Return the type system instance.
+    * \param newInstance This parameter is useful just for unit testing, because singletons causes
+    *                    too many side effects on unit testing.
+    */
+    static TypeDatabase* instance(bool newInstance = false);
+
+    static QString normalizedSignature(const char* signature);
+
+    QStringList requiredTargetImports() const;
+
+    void addRequiredTargetImport(const QString& moduleName);
+
+    QStringList typesystemPaths() const
+    {
+        return m_typesystemPaths;
+    }
+
+    void addTypesystemPath(const QString& typesystem_paths);
+
+    IncludeList extraIncludes(const QString& className) const;
+
+    PrimitiveTypeEntry* findPrimitiveType(const QString& name) const;
+    ComplexTypeEntry* findComplexType(const QString& name) const;
+    ObjectTypeEntry* findObjectType(const QString& name) const;
+    NamespaceTypeEntry* findNamespaceType(const QString& name) const;
+    ContainerTypeEntry* findContainerType(const QString& name) const;
+    FunctionTypeEntry* findFunctionType(const QString& name) const;
+
+    TypeEntry* findType(const QString& name) const;
+
+    QList<TypeEntry *> findTypes(const QString &name) const
+    {
+        return m_entries.value(name);
+    }
+
+    TypeEntryHash allEntries() const
+    {
+        return m_entries;
+    }
+
+    SingleTypeEntryHash entries() const;
+
+    PrimitiveTypeEntry* findTargetLangPrimitiveType(const QString& targetLangName) const;
+
+    QList<const PrimitiveTypeEntry*> primitiveTypes() const;
+
+    QList<const ContainerTypeEntry*> containerTypes() const;
+
+    void addRejection(const QString& className, const QString& functionName,
+                        const QString& fieldName, const QString& enumName);
+    bool isClassRejected(const QString& className) const;
+    bool isFunctionRejected(const QString& className, const QString& functionName) const;
+    bool isFieldRejected(const QString& className, const QString& fieldName) const;
+    bool isEnumRejected(const QString& className, const QString& enumName) const;
+
+    void addType(TypeEntry* e)
+    {
+        m_entries[e->qualifiedCppName()].append(e);
+    }
+
+    SingleTypeEntryHash flagsEntries() const
+    {
+        return m_flagsEntries;
+    }
+    FlagsTypeEntry* findFlagsType(const QString& name) const;
+    void addFlagsType(FlagsTypeEntry* fte)
+    {
+        m_flagsEntries[fte->originalName()] = fte;
+    }
+
+    TemplateEntry* findTemplate(const QString& name) const
+    {
+        return m_templates[name];
+    }
+
+    void addTemplate(TemplateEntry* t)
+    {
+        m_templates[t->name()] = t;
+    }
+
+    AddedFunctionList globalUserFunctions() const
+    {
+        return m_globalUserFunctions;
+    }
+
+    void addGlobalUserFunctions(const AddedFunctionList& functions)
+    {
+        m_globalUserFunctions << functions;
+    }
+
+    AddedFunctionList findGlobalUserFunctions(const QString& name) const;
+
+    void addGlobalUserFunctionModifications(const FunctionModificationList& functionModifications)
+    {
+        m_functionMods << functionModifications;
+    }
+
+    void addGlobalUserFunctionModification(const FunctionModification& functionModification)
+    {
+        m_functionMods << functionModification;
+    }
+
+    FunctionModificationList functionModifications(const QString& signature) const;
+
+    void setSuppressWarnings(bool on)
+    {
+        m_suppressWarnings = on;
+    }
+
+    void addSuppressedWarning(const QString& s)
+    {
+        m_suppressedWarnings.append(s);
+    }
+
+    bool isSuppressedWarning(const QString& s) const;
+
+    void setRebuildClasses(const QStringList &cls)
+    {
+        m_rebuildClasses = cls;
+    }
+
+    static QString globalNamespaceClassName(const TypeEntry *te);
+    QString filename() const
+    {
+        return "typesystem.txt";
+    }
+
+    QString modifiedTypesystemFilepath(const QString& tsFile) const;
+    bool parseFile(const QString &filename, bool generate = true);
+    bool parseFile(QIODevice* device, bool generate = true);
+
+    APIEXTRACTOR_DEPRECATED(double apiVersion() const)
+    {
+        return m_apiVersion;
+    }
+
+    APIEXTRACTOR_DEPRECATED(void setApiVersion(double version))
+    {
+        m_apiVersion = version;
+    }
+    void setApiVersion(const QString& package, const QByteArray& version);
+
+    APIEXTRACTOR_DEPRECATED(bool supportedApiVersion(double version) const);
+    bool checkApiVersion(const QString& package, const QByteArray& version) const;
+
+    const QStringList& dropTypeEntries() const
+    {
+        return m_dropTypeEntries;
+    }
+
+    bool hasDroppedTypeEntries() const
+    {
+        return !m_dropTypeEntries.isEmpty();
+    }
+
+    bool shouldDropTypeEntry(const QString& fullTypeName) const;
+
+    void setDropTypeEntries(QStringList dropTypeEntries);
+
+private:
+    bool m_suppressWarnings;
+    TypeEntryHash m_entries;
+    SingleTypeEntryHash m_flagsEntries;
+    TemplateEntryHash m_templates;
+    QStringList m_suppressedWarnings;
+
+    AddedFunctionList m_globalUserFunctions;
+    FunctionModificationList m_functionMods;
+
+    QStringList m_requiredTargetImports;
+
+    QStringList m_typesystemPaths;
+    QHash<QString, bool> m_parsedTypesystemFiles;
+
+    QList<TypeRejection> m_rejections;
+    QStringList m_rebuildClasses;
+
+    double m_apiVersion;
+    QStringList m_dropTypeEntries;
+};
+
+#endif
diff --git a/ApiExtractor/typeparser.cpp b/ApiExtractor/typeparser.cpp
new file mode 100644
index 000000000..7c82a282f
--- /dev/null
+++ b/ApiExtractor/typeparser.cpp
@@ -0,0 +1,261 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "typeparser.h"
+
+#include <QtCore/QDebug>
+#include <QtCore/QStack>
+
+class Scanner
+{
+public:
+    enum Token {
+        StarToken,
+        AmpersandToken,
+        LessThanToken,
+        ColonToken,
+        CommaToken,
+        OpenParenToken,
+        CloseParenToken,
+        SquareBegin,
+        SquareEnd,
+        GreaterThanToken,
+
+        ConstToken,
+        Identifier,
+        NoToken
+    };
+
+    Scanner(const QString &s)
+            : m_pos(0), m_length(s.length()), m_chars(s.constData())
+    {
+    }
+
+    Token nextToken();
+    QString identifier() const;
+
+private:
+    int m_pos;
+    int m_length;
+    int m_tokenStart;
+    const QChar *m_chars;
+};
+
+QString Scanner::identifier() const
+{
+    return QString(m_chars + m_tokenStart, m_pos - m_tokenStart);
+}
+
+Scanner::Token Scanner::nextToken()
+{
+    Token tok = NoToken;
+
+    // remove whitespace
+    while (m_pos < m_length && m_chars[m_pos] == ' ')
+        ++m_pos;
+
+    m_tokenStart = m_pos;
+
+    while (m_pos < m_length) {
+
+        const QChar &c = m_chars[m_pos];
+
+        if (tok == NoToken) {
+            switch (c.toLatin1()) {
+            case '*': tok = StarToken; break;
+            case '&': tok = AmpersandToken; break;
+            case '<': tok = LessThanToken; break;
+            case '>': tok = GreaterThanToken; break;
+            case ',': tok = CommaToken; break;
+            case '(': tok = OpenParenToken; break;
+            case ')': tok = CloseParenToken; break;
+            case '[': tok = SquareBegin; break;
+            case ']' : tok = SquareEnd; break;
+            case ':':
+                tok = ColonToken;
+                Q_ASSERT(m_pos + 1 < m_length);
+                ++m_pos;
+                break;
+            default:
+                if (c.isLetterOrNumber() || c == '_')
+                    tok = Identifier;
+                else
+                    qFatal("Unrecognized character in lexer: %c", c.toLatin1());
+                break;
+            }
+        }
+
+        if (tok <= GreaterThanToken) {
+            ++m_pos;
+            break;
+        }
+
+        if (tok == Identifier) {
+            if (c.isLetterOrNumber() || c == '_')
+                ++m_pos;
+            else
+                break;
+        }
+    }
+
+    if (tok == Identifier && m_pos - m_tokenStart == 5) {
+        if (m_chars[m_tokenStart] == 'c'
+            && m_chars[m_tokenStart + 1] == 'o'
+            && m_chars[m_tokenStart + 2] == 'n'
+            && m_chars[m_tokenStart + 3] == 's'
+            && m_chars[m_tokenStart + 4] == 't')
+            tok = ConstToken;
+    }
+
+    return tok;
+
+}
+
+TypeParser::Info TypeParser::parse(const QString &str)
+{
+    Scanner scanner(str);
+
+    Info info;
+    QStack<Info *> stack;
+    stack.push(&info);
+
+    bool colon_prefix = false;
+    bool in_array = false;
+    QString array;
+
+    Scanner::Token tok = scanner.nextToken();
+    while (tok != Scanner::NoToken) {
+
+//         switch (tok) {
+//         case Scanner::StarToken: printf(" - *\n"); break;
+//         case Scanner::AmpersandToken: printf(" - &\n"); break;
+//         case Scanner::LessThanToken: printf(" - <\n"); break;
+//         case Scanner::GreaterThanToken: printf(" - >\n"); break;
+//         case Scanner::ColonToken: printf(" - ::\n"); break;
+//         case Scanner::CommaToken: printf(" - ,\n"); break;
+//         case Scanner::ConstToken: printf(" - const\n"); break;
+//         case Scanner::SquareBegin: printf(" - [\n"); break;
+//         case Scanner::SquareEnd: printf(" - ]\n"); break;
+//         case Scanner::Identifier: printf(" - '%s'\n", qPrintable(scanner.identifier())); break;
+//         default:
+//             break;
+//         }
+
+        switch (tok) {
+
+        case Scanner::StarToken:
+            ++stack.top()->indirections;
+            break;
+
+        case Scanner::AmpersandToken:
+            stack.top()->is_reference = true;
+            break;
+
+        case Scanner::LessThanToken:
+            stack.top()->template_instantiations << Info();
+            stack.push(&stack.top()->template_instantiations.last());
+            break;
+
+        case Scanner::CommaToken:
+            stack.pop();
+            stack.top()->template_instantiations << Info();
+            stack.push(&stack.top()->template_instantiations.last());
+            break;
+
+        case Scanner::GreaterThanToken:
+            stack.pop();
+            break;
+
+        case Scanner::ColonToken:
+            colon_prefix = true;
+            break;
+
+        case Scanner::ConstToken:
+            stack.top()->is_constant = true;
+            break;
+
+        case Scanner::OpenParenToken: // function pointers not supported
+        case Scanner::CloseParenToken: {
+            Info i;
+            i.is_busted = true;
+            return i;
+        }
+
+
+        case Scanner::Identifier:
+            if (in_array) {
+                array = scanner.identifier();
+            } else if (colon_prefix || stack.top()->qualified_name.isEmpty()) {
+                stack.top()->qualified_name << scanner.identifier();
+                colon_prefix = false;
+            } else {
+                stack.top()->qualified_name.last().append(" " + scanner.identifier());
+            }
+            break;
+
+        case Scanner::SquareBegin:
+            in_array = true;
+            break;
+
+        case Scanner::SquareEnd:
+            in_array = false;
+            stack.top()->arrays += array;
+            break;
+
+
+        default:
+            break;
+        }
+
+        tok = scanner.nextToken();
+    }
+
+    return info;
+}
+
+QString TypeParser::Info::instantiationName() const
+{
+    QString s(qualified_name.join("::"));
+    if (!template_instantiations.isEmpty()) {
+        QStringList insts;
+        foreach (Info info, template_instantiations)
+            insts << info.toString();
+        s += QString("< %1 >").arg(insts.join(", "));
+    }
+
+    return s;
+}
+
+QString TypeParser::Info::toString() const
+{
+    QString s;
+
+    if (is_constant) s += "const ";
+    s += instantiationName();
+    for (int i = 0; i < arrays.size(); ++i)
+        s += "[" + arrays.at(i) + "]";
+    s += QString(indirections, '*');
+    if (is_reference)  s += '&';
+
+    return s;
+}
diff --git a/ApiExtractor/typeparser.h b/ApiExtractor/typeparser.h
new file mode 100644
index 000000000..1d0c019db
--- /dev/null
+++ b/ApiExtractor/typeparser.h
@@ -0,0 +1,52 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef TYPEPARSER_H
+#define TYPEPARSER_H
+
+#include <QtCore/QList>
+#include <QtCore/QString>
+#include <QtCore/QStringList>
+
+class TypeParser
+{
+public:
+    struct Info
+    {
+        Info() : is_reference(false), is_constant(false), is_busted(false), indirections(0) { }
+        QStringList qualified_name;
+        QStringList arrays;
+        QList<Info> template_instantiations;
+        uint is_reference : 1;
+        uint is_constant : 1;
+        uint is_busted : 1;
+        uint indirections : 5;
+
+        QString toString() const;
+        QString instantiationName() const;
+    };
+
+    static Info parse(const QString &str);
+};
+
+#endif // TYPEPARSER_H
diff --git a/ApiExtractor/typesystem.cpp b/ApiExtractor/typesystem.cpp
new file mode 100644
index 000000000..a08c2df2e
--- /dev/null
+++ b/ApiExtractor/typesystem.cpp
@@ -0,0 +1,2482 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "typesystem.h"
+#include "typesystem_p.h"
+#include "typedatabase.h"
+#include "reporthandler.h"
+#include <QtXml>
+
+static QString strings_Object = QLatin1String("Object");
+static QString strings_String = QLatin1String("String");
+static QString strings_char = QLatin1String("char");
+static QString strings_jchar = QLatin1String("jchar");
+static QString strings_jobject = QLatin1String("jobject");
+
+static QList<CustomConversion*> customConversionsForReview = QList<CustomConversion*>();
+
+Handler::Handler(TypeDatabase* database, bool generate)
+            : m_database(database), m_generate(generate ? TypeEntry::GenerateAll : TypeEntry::GenerateForSubclass)
+{
+    m_currentEnum = 0;
+    m_current = 0;
+    m_currentDroppedEntry = 0;
+    m_currentDroppedEntryDepth = 0;
+    m_ignoreDepth = 0;
+
+    tagNames["rejection"] = StackElement::Rejection;
+    tagNames["custom-type"] = StackElement::CustomTypeEntry;
+    tagNames["primitive-type"] = StackElement::PrimitiveTypeEntry;
+    tagNames["container-type"] = StackElement::ContainerTypeEntry;
+    tagNames["object-type"] = StackElement::ObjectTypeEntry;
+    tagNames["value-type"] = StackElement::ValueTypeEntry;
+    tagNames["interface-type"] = StackElement::InterfaceTypeEntry;
+    tagNames["namespace-type"] = StackElement::NamespaceTypeEntry;
+    tagNames["enum-type"] = StackElement::EnumTypeEntry;
+    tagNames["function"] = StackElement::FunctionTypeEntry;
+    tagNames["extra-includes"] = StackElement::ExtraIncludes;
+    tagNames["include"] = StackElement::Include;
+    tagNames["inject-code"] = StackElement::InjectCode;
+    tagNames["modify-function"] = StackElement::ModifyFunction;
+    tagNames["modify-field"] = StackElement::ModifyField;
+    tagNames["access"] = StackElement::Access;
+    tagNames["remove"] = StackElement::Removal;
+    tagNames["rename"] = StackElement::Rename;
+    tagNames["typesystem"] = StackElement::Root;
+    tagNames["custom-constructor"] = StackElement::CustomMetaConstructor;
+    tagNames["custom-destructor"] = StackElement::CustomMetaDestructor;
+    tagNames["argument-map"] = StackElement::ArgumentMap;
+    tagNames["suppress-warning"] = StackElement::SuppressedWarning;
+    tagNames["load-typesystem"] = StackElement::LoadTypesystem;
+    tagNames["define-ownership"] = StackElement::DefineOwnership;
+    tagNames["replace-default-expression"] = StackElement::ReplaceDefaultExpression;
+    tagNames["reject-enum-value"] = StackElement::RejectEnumValue;
+    tagNames["replace-type"] = StackElement::ReplaceType;
+    tagNames["conversion-rule"] = StackElement::ConversionRule;
+    tagNames["native-to-target"] = StackElement::NativeToTarget;
+    tagNames["target-to-native"] = StackElement::TargetToNative;
+    tagNames["add-conversion"] = StackElement::AddConversion;
+    tagNames["modify-argument"] = StackElement::ModifyArgument;
+    tagNames["remove-argument"] = StackElement::RemoveArgument;
+    tagNames["remove-default-expression"] = StackElement::RemoveDefaultExpression;
+    tagNames["template"] = StackElement::Template;
+    tagNames["insert-template"] = StackElement::TemplateInstanceEnum;
+    tagNames["replace"] = StackElement::Replace;
+    tagNames["no-null-pointer"] = StackElement::NoNullPointers;
+    tagNames["reference-count"] = StackElement::ReferenceCount;
+    tagNames["parent"] = StackElement::ParentOwner;
+    tagNames["inject-documentation"] = StackElement::InjectDocumentation;
+    tagNames["modify-documentation"] = StackElement::ModifyDocumentation;
+    tagNames["add-function"] = StackElement::AddFunction;
+}
+
+bool Handler::error(const QXmlParseException &e)
+{
+    qWarning("Error: line=%d, column=%d, message=%s\n",
+             e.lineNumber(), e.columnNumber(), qPrintable(e.message()));
+    return false;
+}
+
+bool Handler::fatalError(const QXmlParseException &e)
+{
+    qWarning("Fatal error: line=%d, column=%d, message=%s\n",
+             e.lineNumber(), e.columnNumber(), qPrintable(e.message()));
+
+    return false;
+}
+
+bool Handler::warning(const QXmlParseException &e)
+{
+    qWarning("Warning: line=%d, column=%d, message=%s\n",
+             e.lineNumber(), e.columnNumber(), qPrintable(e.message()));
+
+    return false;
+}
+
+void Handler::fetchAttributeValues(const QString &name, const QXmlAttributes &atts,
+                                   QHash<QString, QString> *acceptedAttributes)
+{
+    Q_ASSERT(acceptedAttributes);
+
+    for (int i = 0; i < atts.length(); ++i) {
+        QString key = atts.localName(i).toLower();
+        QString val = atts.value(i);
+
+        if (!acceptedAttributes->contains(key))
+            ReportHandler::warning(QString("Unknown attribute for '%1': '%2'").arg(name).arg(key));
+         else
+            (*acceptedAttributes)[key] = val;
+
+    }
+}
+
+bool Handler::endElement(const QString &, const QString &localName, const QString &)
+{
+    if (m_ignoreDepth) {
+        --m_ignoreDepth;
+        return true;
+    }
+
+    if (m_currentDroppedEntry) {
+        if (m_currentDroppedEntryDepth == 1) {
+            m_current = m_currentDroppedEntry->parent;
+            delete m_currentDroppedEntry;
+            m_currentDroppedEntry = 0;
+            m_currentDroppedEntryDepth = 0;
+        } else {
+            ++m_currentDroppedEntryDepth;
+        }
+        return true;
+    }
+
+    QString tagName = localName.toLower();
+    if (tagName == "import-file")
+        return true;
+
+    if (!m_current)
+        return true;
+
+    switch (m_current->type) {
+    case StackElement::Root:
+        if (m_generate == TypeEntry::GenerateAll) {
+            TypeDatabase::instance()->addGlobalUserFunctions(m_contextStack.top()->addedFunctions);
+            TypeDatabase::instance()->addGlobalUserFunctionModifications(m_contextStack.top()->functionMods);
+            foreach (CustomConversion* customConversion, customConversionsForReview) {
+                foreach (CustomConversion::TargetToNativeConversion* toNative, customConversion->targetToNativeConversions())
+                    toNative->setSourceType(m_database->findType(toNative->sourceTypeName()));
+            }
+        }
+        break;
+    case StackElement::ObjectTypeEntry:
+    case StackElement::ValueTypeEntry:
+    case StackElement::InterfaceTypeEntry:
+    case StackElement::NamespaceTypeEntry: {
+        ComplexTypeEntry *centry = static_cast<ComplexTypeEntry *>(m_current->entry);
+        centry->setAddedFunctions(m_contextStack.top()->addedFunctions);
+        centry->setFunctionModifications(m_contextStack.top()->functionMods);
+        centry->setFieldModifications(m_contextStack.top()->fieldMods);
+        centry->setCodeSnips(m_contextStack.top()->codeSnips);
+        centry->setDocModification(m_contextStack.top()->docModifications);
+
+        if (centry->designatedInterface()) {
+            centry->designatedInterface()->setCodeSnips(m_contextStack.top()->codeSnips);
+            centry->designatedInterface()->setFunctionModifications(m_contextStack.top()->functionMods);
+        }
+    }
+    break;
+    case StackElement::NativeToTarget:
+    case StackElement::AddConversion: {
+        CustomConversion* customConversion = static_cast<TypeEntry*>(m_current->entry)->customConversion();
+        if (!customConversion) {
+            m_error = "CustomConversion object is missing.";
+            return false;
+        }
+
+        QString code = m_contextStack.top()->codeSnips.takeLast().code();
+        if (m_current->type == StackElement::AddConversion) {
+            if (customConversion->targetToNativeConversions().isEmpty()) {
+                m_error = "CustomConversion's target to native conversions missing.";
+                return false;
+            }
+            customConversion->targetToNativeConversions().last()->setConversion(code);
+        } else {
+            customConversion->setNativeToTargetConversion(code);
+        }
+    }
+    break;
+    case StackElement::CustomMetaConstructor: {
+        m_current->entry->setCustomConstructor(*m_current->value.customFunction);
+        delete m_current->value.customFunction;
+    }
+    break;
+    case StackElement::CustomMetaDestructor: {
+        m_current->entry->setCustomDestructor(*m_current->value.customFunction);
+        delete m_current->value.customFunction;
+    }
+    break;
+    case StackElement::EnumTypeEntry:
+        m_current->entry->setDocModification(m_contextStack.top()->docModifications);
+        m_contextStack.top()->docModifications = DocModificationList();
+        m_currentEnum = 0;
+        break;
+    case StackElement::Template:
+        m_database->addTemplate(m_current->value.templateEntry);
+        break;
+    case StackElement::TemplateInstanceEnum:
+        switch (m_current->parent->type) {
+        case StackElement::InjectCode:
+            if (m_current->parent->parent->type == StackElement::Root) {
+                CodeSnipList snips = m_current->parent->entry->codeSnips();
+                CodeSnip snip = snips.takeLast();
+                snip.addTemplateInstance(m_current->value.templateInstance);
+                snips.append(snip);
+                m_current->parent->entry->setCodeSnips(snips);
+                break;
+            }
+        case StackElement::NativeToTarget:
+        case StackElement::AddConversion:
+            m_contextStack.top()->codeSnips.last().addTemplateInstance(m_current->value.templateInstance);
+            break;
+        case StackElement::Template:
+            m_current->parent->value.templateEntry->addTemplateInstance(m_current->value.templateInstance);
+            break;
+        case StackElement::CustomMetaConstructor:
+        case StackElement::CustomMetaDestructor:
+            m_current->parent->value.customFunction->addTemplateInstance(m_current->value.templateInstance);
+            break;
+        case StackElement::ConversionRule:
+            m_contextStack.top()->functionMods.last().argument_mods.last().conversion_rules.last().addTemplateInstance(m_current->value.templateInstance);
+            break;
+        case StackElement::InjectCodeInFunction:
+            m_contextStack.top()->functionMods.last().snips.last().addTemplateInstance(m_current->value.templateInstance);
+            break;
+        default:
+            break; // nada
+        };
+        break;
+    default:
+        break;
+    }
+
+    if (m_current->type == StackElement::Root
+        || m_current->type == StackElement::NamespaceTypeEntry
+        || m_current->type == StackElement::InterfaceTypeEntry
+        || m_current->type == StackElement::ObjectTypeEntry
+        || m_current->type == StackElement::ValueTypeEntry
+        || m_current->type == StackElement::PrimitiveTypeEntry) {
+        StackElementContext* context = m_contextStack.pop();
+        delete context;
+    }
+
+    StackElement *child = m_current;
+    m_current = m_current->parent;
+    delete(child);
+
+    return true;
+}
+
+bool Handler::characters(const QString &ch)
+{
+    if (m_currentDroppedEntry || m_ignoreDepth)
+        return true;
+
+    if (m_current->type == StackElement::Template) {
+        m_current->value.templateEntry->addCode(ch);
+        return true;
+    }
+
+    if (m_current->type == StackElement::CustomMetaConstructor || m_current->type == StackElement::CustomMetaDestructor) {
+        m_current->value.customFunction->addCode(ch);
+        return true;
+    }
+
+    if (m_current->type == StackElement::ConversionRule
+        && m_current->parent->type == StackElement::ModifyArgument) {
+        m_contextStack.top()->functionMods.last().argument_mods.last().conversion_rules.last().addCode(ch);
+        return true;
+    }
+
+    if (m_current->type == StackElement::NativeToTarget || m_current->type == StackElement::AddConversion) {
+       m_contextStack.top()->codeSnips.last().addCode(ch);
+       return true;
+    }
+
+    if (m_current->parent) {
+        if ((m_current->type & StackElement::CodeSnipMask)) {
+            CodeSnipList snips;
+            switch (m_current->parent->type) {
+            case StackElement::Root:
+                snips = m_current->parent->entry->codeSnips();
+                snips.last().addCode(ch);
+                m_current->parent->entry->setCodeSnips(snips);
+                break;
+            case StackElement::ModifyFunction:
+            case StackElement::AddFunction:
+                m_contextStack.top()->functionMods.last().snips.last().addCode(ch);
+                m_contextStack.top()->functionMods.last().modifiers |= FunctionModification::CodeInjection;
+                break;
+            case StackElement::NamespaceTypeEntry:
+            case StackElement::ObjectTypeEntry:
+            case StackElement::ValueTypeEntry:
+            case StackElement::InterfaceTypeEntry:
+                m_contextStack.top()->codeSnips.last().addCode(ch);
+                break;
+            default:
+                Q_ASSERT(false);
+            };
+            return true;
+        }
+    }
+
+    if (m_current->type & StackElement::DocumentationMask)
+        m_contextStack.top()->docModifications.last().setCode(ch);
+
+    return true;
+}
+
+bool Handler::importFileElement(const QXmlAttributes &atts)
+{
+    QString fileName = atts.value("name");
+    if (fileName.isEmpty()) {
+        m_error = "Required attribute 'name' missing for include-file tag.";
+        return false;
+    }
+
+    QFile file(fileName);
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        file.setFileName(":/trolltech/generator/" + fileName);
+        if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+            m_error = QString("Could not open file: '%1'").arg(fileName);
+            return false;
+        }
+    }
+
+    QString quoteFrom = atts.value("quote-after-line");
+    bool foundFromOk = quoteFrom.isEmpty();
+    bool from = quoteFrom.isEmpty();
+
+    QString quoteTo = atts.value("quote-before-line");
+    bool foundToOk = quoteTo.isEmpty();
+    bool to = true;
+
+    QTextStream in(&file);
+    while (!in.atEnd()) {
+        QString line = in.readLine();
+        if (from && to && line.contains(quoteTo)) {
+            to = false;
+            foundToOk = true;
+            break;
+        }
+        if (from && to)
+            characters(line + "\n");
+        if (!from && line.contains(quoteFrom)) {
+            from = true;
+            foundFromOk = true;
+        }
+    }
+    if (!foundFromOk || !foundToOk) {
+        QString fromError = QString("Could not find quote-after-line='%1' in file '%2'.").arg(quoteFrom).arg(fileName);
+        QString toError = QString("Could not find quote-before-line='%1' in file '%2'.").arg(quoteTo).arg(fileName);
+
+        if (!foundToOk)
+            m_error = toError;
+        if (!foundFromOk)
+            m_error = fromError;
+        if (!foundFromOk && !foundToOk)
+            m_error = fromError + " " + toError;
+        return false;
+    }
+
+    return true;
+}
+
+bool Handler::convertBoolean(const QString &_value, const QString &attributeName, bool defaultValue)
+{
+    QString value = _value.toLower();
+    if (value == "true" || value == "yes")
+        return true;
+     else if (value == "false" || value == "no")
+        return false;
+     else {
+        QString warn = QString("Boolean value '%1' not supported in attribute '%2'. Use 'yes' or 'no'. Defaulting to '%3'.")
+                       .arg(value).arg(attributeName).arg(defaultValue ? "yes" : "no");
+
+        ReportHandler::warning(warn);
+        return defaultValue;
+    }
+}
+
+static bool convertRemovalAttribute(const QString& removalAttribute, Modification& mod, QString& errorMsg)
+{
+    QString remove = removalAttribute.toLower();
+    if (!remove.isEmpty()) {
+        if (remove == QLatin1String("all")) {
+            mod.removal = TypeSystem::All;
+        } else if (remove == QLatin1String("target")) {
+            mod.removal = TypeSystem::TargetLangAndNativeCode;
+        } else {
+            errorMsg = QString::fromLatin1("Bad removal type '%1'").arg(remove);
+            return false;
+        }
+    }
+    return true;
+}
+
+static void getNamePrefixRecursive(StackElement* element, QStringList& names)
+{
+    if (!element->parent || !element->parent->entry)
+        return;
+    getNamePrefixRecursive(element->parent, names);
+    names << element->parent->entry->name();
+}
+
+static QString getNamePrefix(StackElement* element)
+{
+    QStringList names;
+    getNamePrefixRecursive(element, names);
+    return names.join(".");
+}
+
+// Returns empty string if there's no error.
+static QString checkSignatureError(const QString& signature, const QString& tag)
+{
+    QString funcName = signature.left(signature.indexOf('(')).trimmed();
+    static QRegExp whiteSpace("\\s");
+    if (!funcName.startsWith("operator ") && funcName.contains(whiteSpace)) {
+        return QString("Error in <%1> tag signature attribute '%2'.\n"
+                       "White spaces aren't allowed in function names, "
+                       "and return types should not be part of the signature.")
+                  .arg(tag)
+                  .arg(signature);
+    }
+    return QString();
+}
+
+bool Handler::startElement(const QString &, const QString &n,
+                           const QString &, const QXmlAttributes &atts)
+{
+    if (m_ignoreDepth) {
+        ++m_ignoreDepth;
+        return true;
+    }
+
+    if (!m_defaultPackage.isEmpty() && atts.index("since") != -1) {
+        TypeDatabase* td = TypeDatabase::instance();
+        if (!td->checkApiVersion(m_defaultPackage, atts.value("since").toAscii())) {
+            ++m_ignoreDepth;
+            return true;
+        }
+    }
+
+
+    QString tagName = n.toLower();
+    if (tagName == "import-file")
+        return importFileElement(atts);
+
+    if (!tagNames.contains(tagName)) {
+        m_error = QString("Unknown tag name: '%1'").arg(tagName);
+        return false;
+    }
+
+    if (m_currentDroppedEntry) {
+        ++m_currentDroppedEntryDepth;
+        return true;
+    }
+
+    StackElement* element = new StackElement(m_current);
+    element->type = tagNames[tagName];
+
+    if (element->type == StackElement::Root && m_generate == TypeEntry::GenerateAll)
+        customConversionsForReview.clear();
+
+    if (element->type == StackElement::Root
+        || element->type == StackElement::NamespaceTypeEntry
+        || element->type == StackElement::InterfaceTypeEntry
+        || element->type == StackElement::ObjectTypeEntry
+        || element->type == StackElement::ValueTypeEntry
+        || element->type == StackElement::PrimitiveTypeEntry) {
+        m_contextStack.push(new StackElementContext());
+    }
+
+    if (element->type & StackElement::TypeEntryMask) {
+        QHash<QString, QString> attributes;
+        attributes["name"] = QString();
+        attributes["since"] = QString("0");
+        attributes["revision"] = QString("0");
+
+        switch (element->type) {
+        case StackElement::PrimitiveTypeEntry:
+            attributes["target-lang-name"] = QString();
+            attributes["target-lang-api-name"] = QString();
+            attributes["preferred-conversion"] = "yes";
+            attributes["preferred-target-lang-type"] = "yes";
+            attributes["default-constructor"] = QString();
+            break;
+        case StackElement::ContainerTypeEntry:
+            attributes["type"] = QString();
+            break;
+        case StackElement::EnumTypeEntry:
+            attributes["flags"] = QString();
+            attributes["flags-revision"] = QString();
+            attributes["upper-bound"] = QString();
+            attributes["lower-bound"] = QString();
+            attributes["force-integer"] = "no";
+            attributes["extensible"] = "no";
+            attributes["identified-by-value"] = QString();
+            break;
+        case StackElement::ValueTypeEntry:
+            attributes["default-constructor"] = QString();
+            // fall throooough
+        case StackElement::ObjectTypeEntry:
+            attributes["force-abstract"] = QString("no");
+            attributes["deprecated"] = QString("no");
+            attributes["hash-function"] = QString("");
+            attributes["stream"] = QString("no");
+            // fall throooough
+        case StackElement::InterfaceTypeEntry:
+            attributes["default-superclass"] = m_defaultSuperclass;
+            attributes["polymorphic-id-expression"] = QString();
+            attributes["delete-in-main-thread"] = QString("no");
+            attributes["held-type"] = QString();
+            attributes["copyable"] = QString();
+            // fall through
+        case StackElement::NamespaceTypeEntry:
+            attributes["target-lang-name"] = QString();
+            attributes["package"] = m_defaultPackage;
+            attributes["expense-cost"] = "1";
+            attributes["expense-limit"] = "none";
+            attributes["polymorphic-base"] = QString("no");
+            attributes["generate"] = QString("yes");
+            attributes["target-type"] = QString();
+            attributes["generic-class"] = QString("no");
+            break;
+        case StackElement::FunctionTypeEntry:
+            attributes["signature"] = QString();
+            attributes["rename"] = QString();
+            break;
+        default:
+            { } // nada
+        };
+
+        fetchAttributeValues(tagName, atts, &attributes);
+        QString name = attributes["name"];
+        double since = attributes["since"].toDouble();
+
+        if (m_database->hasDroppedTypeEntries()) {
+            QString identifier = getNamePrefix(element) + '.';
+            identifier += (element->type == StackElement::FunctionTypeEntry ? attributes["signature"] : name);
+            if (m_database->shouldDropTypeEntry(identifier)) {
+                m_currentDroppedEntry = element;
+                m_currentDroppedEntryDepth = 1;
+                ReportHandler::debugSparse(QString("Type system entry '%1' was intentionally dropped from generation.").arg(identifier));
+                return true;
+            }
+        }
+
+        // The top level tag 'function' has only the 'signature' tag
+        // and we should extract the 'name' value from it.
+        if (element->type == StackElement::FunctionTypeEntry) {
+            QString signature = attributes["signature"];
+            name = signature.left(signature.indexOf('(')).trimmed();
+            QString errorString = checkSignatureError(signature, "function");
+            if (!errorString.isEmpty()) {
+                m_error = errorString;
+                return false;
+            }
+            QString rename = attributes["rename"];
+            if (!rename.isEmpty()) {
+                static QRegExp functionNameRegExp("^[a-zA-Z_][a-zA-Z0-9_]*$");
+                if (!functionNameRegExp.exactMatch(rename)) {
+                    m_error = "can not rename '" + signature + "', '" + rename + "' is not a valid function name";
+                    return false;
+                }
+                FunctionModification mod(since);
+                mod.signature = signature;
+                mod.renamedToName = attributes["rename"];
+                mod.modifiers |= Modification::Rename;
+                m_contextStack.top()->functionMods << mod;
+            }
+        }
+
+        // We need to be able to have duplicate primitive type entries,
+        // or it's not possible to cover all primitive target language
+        // types (which we need to do in order to support fake meta objects)
+        if (element->type != StackElement::PrimitiveTypeEntry
+            && element->type != StackElement::FunctionTypeEntry) {
+            TypeEntry *tmp = m_database->findType(name);
+            if (tmp)
+                ReportHandler::warning(QString("Duplicate type entry: '%1'").arg(name));
+        }
+
+        if (element->type == StackElement::EnumTypeEntry) {
+            if (name.isEmpty()) {
+                name = attributes["identified-by-value"];
+            } else if (!attributes["identified-by-value"].isEmpty()) {
+                m_error = "can't specify both 'name' and 'identified-by-value' attributes";
+                return false;
+            }
+        }
+
+        // Fix type entry name using nesting information.
+        if (element->type & StackElement::TypeEntryMask
+            && element->parent && element->parent->type != StackElement::Root) {
+            name = element->parent->entry->name() + "::" + name;
+        }
+
+
+        if (name.isEmpty()) {
+            m_error = "no 'name' attribute specified";
+            return false;
+        }
+
+        switch (element->type) {
+        case StackElement::CustomTypeEntry:
+            element->entry = new TypeEntry(name, TypeEntry::CustomType, since);
+            break;
+        case StackElement::PrimitiveTypeEntry: {
+            QString targetLangName = attributes["target-lang-name"];
+            QString targetLangApiName = attributes["target-lang-api-name"];
+            QString preferredConversion = attributes["preferred-conversion"].toLower();
+            QString preferredTargetLangType = attributes["preferred-target-lang-type"].toLower();
+            QString defaultConstructor = attributes["default-constructor"];
+
+            if (targetLangName.isEmpty())
+                targetLangName = name;
+            if (targetLangApiName.isEmpty())
+                targetLangApiName = name;
+
+            PrimitiveTypeEntry *type = new PrimitiveTypeEntry(name, since);
+            type->setCodeGeneration(m_generate);
+            type->setTargetLangName(targetLangName);
+            type->setTargetLangApiName(targetLangApiName);
+            type->setTargetLangPackage(m_defaultPackage);
+            type->setDefaultConstructor(defaultConstructor);
+
+            bool preferred;
+            preferred = convertBoolean(preferredConversion, "preferred-conversion", true);
+            type->setPreferredConversion(preferred);
+            preferred = convertBoolean(preferredTargetLangType,
+                                       "preferred-target-lang-type", true);
+            type->setPreferredTargetLangType(preferred);
+
+            element->entry = type;
+            }
+            break;
+        case StackElement::ContainerTypeEntry:
+            {
+                QString typeName = attributes["type"];
+                ContainerTypeEntry::Type containerType =
+                        ContainerTypeEntry::containerTypeFromString(typeName);
+                if (typeName.isEmpty()) {
+                    m_error = "no 'type' attribute specified";
+                    return false;
+                } else if (containerType == ContainerTypeEntry::NoContainer) {
+                    m_error = "there is no container of type " + containerType;
+                    return false;
+                }
+
+                ContainerTypeEntry *type = new ContainerTypeEntry(name, containerType, since);
+                type->setCodeGeneration(m_generate);
+                element->entry = type;
+            }
+            break;
+        case StackElement::EnumTypeEntry: {
+            QStringList names = name.split(QLatin1String("::"));
+            if (names.size() == 1)
+                m_currentEnum = new EnumTypeEntry(QString(), name, since);
+             else
+                m_currentEnum =
+                    new EnumTypeEntry(QStringList(names.mid(0, names.size() - 1)).join("::"),
+                                      names.last(), since);
+            m_currentEnum->setAnonymous(!attributes["identified-by-value"].isEmpty());
+            element->entry = m_currentEnum;
+            m_currentEnum->setCodeGeneration(m_generate);
+            m_currentEnum->setTargetLangPackage(m_defaultPackage);
+            m_currentEnum->setUpperBound(attributes["upper-bound"]);
+            m_currentEnum->setLowerBound(attributes["lower-bound"]);
+            m_currentEnum->setForceInteger(convertBoolean(attributes["force-integer"], "force-integer", false));
+            m_currentEnum->setExtensible(convertBoolean(attributes["extensible"], "extensible", false));
+
+            // put in the flags parallel...
+            QString flagName = attributes["flags"];
+            if (!flagName.isEmpty()) {
+                FlagsTypeEntry *ftype = new FlagsTypeEntry("QFlags<" + name + ">", since);
+                ftype->setOriginator(m_currentEnum);
+                // Try to get the guess the qualified flag name
+                if (!flagName.contains("::") && names.count() > 1) {
+                    QStringList cpy(names);
+                    cpy.removeLast();
+                    cpy.append(flagName);
+                    flagName = cpy.join("::");
+                }
+
+                ftype->setOriginalName(flagName);
+                ftype->setCodeGeneration(m_generate);
+                QString n = ftype->originalName();
+
+                QStringList lst = n.split("::");
+                if (QStringList(lst.mid(0, lst.size() - 1)).join("::") != m_currentEnum->targetLangQualifier()) {
+                    ReportHandler::warning(QString("enum %1 and flags %2 differ in qualifiers")
+                                           .arg(m_currentEnum->targetLangQualifier())
+                                           .arg(lst.at(0)));
+                }
+
+                ftype->setFlagsName(lst.last());
+                m_currentEnum->setFlags(ftype);
+
+                m_database->addFlagsType(ftype);
+                m_database->addType(ftype);
+
+                QString revision = attributes["flags-revision"].isEmpty() ? attributes["revision"] : attributes["flags-revision"];
+                setTypeRevision(ftype, revision.toInt());
+            }
+        }
+        break;
+
+        case StackElement::InterfaceTypeEntry: {
+            ObjectTypeEntry *otype = new ObjectTypeEntry(name, since);
+            QString targetLangName = attributes["target-lang-name"];
+            if (targetLangName.isEmpty())
+                targetLangName = name;
+            InterfaceTypeEntry *itype =
+                new InterfaceTypeEntry(InterfaceTypeEntry::interfaceName(targetLangName), since);
+
+            if (!convertBoolean(attributes["generate"], "generate", true))
+                itype->setCodeGeneration(TypeEntry::GenerateForSubclass);
+            else
+                itype->setCodeGeneration(m_generate);
+            otype->setDesignatedInterface(itype);
+            itype->setOrigin(otype);
+            element->entry = otype;
+        }
+        // fall through
+        case StackElement::ValueTypeEntry: {
+            if (!element->entry) {
+                ValueTypeEntry* typeEntry = new ValueTypeEntry(name, since);
+                QString defaultConstructor = attributes["default-constructor"];
+                if (!defaultConstructor.isEmpty())
+                    typeEntry->setDefaultConstructor(defaultConstructor);
+                element->entry = typeEntry;
+            }
+
+        // fall through
+        case StackElement::NamespaceTypeEntry:
+            if (!element->entry)
+                element->entry = new NamespaceTypeEntry(name, since);
+
+        // fall through
+        case StackElement::ObjectTypeEntry:
+            if (!element->entry)
+                element->entry = new ObjectTypeEntry(name, since);
+
+            element->entry->setStream(attributes["stream"] == QString("yes"));
+
+            ComplexTypeEntry *ctype = static_cast<ComplexTypeEntry *>(element->entry);
+            ctype->setTargetLangPackage(attributes["package"]);
+            ctype->setDefaultSuperclass(attributes["default-superclass"]);
+            ctype->setGenericClass(convertBoolean(attributes["generic-class"], "generic-class", false));
+
+            if (!convertBoolean(attributes["generate"], "generate", true))
+                element->entry->setCodeGeneration(TypeEntry::GenerateForSubclass);
+            else
+                element->entry->setCodeGeneration(m_generate);
+
+            QString targetLangName = attributes["target-lang-name"];
+            if (!targetLangName.isEmpty())
+                ctype->setTargetLangName(targetLangName);
+
+            // The expense policy
+            QString limit = attributes["expense-limit"];
+            if (!limit.isEmpty() && limit != "none") {
+                ExpensePolicy ep;
+                ep.limit = limit.toInt();
+                ep.cost = attributes["expense-cost"];
+                ctype->setExpensePolicy(ep);
+            }
+
+
+            ctype->setIsPolymorphicBase(convertBoolean(attributes["polymorphic-base"], "polymorphic-base", false));
+            ctype->setPolymorphicIdValue(attributes["polymorphic-id-expression"]);
+            //Copyable
+            if (attributes["copyable"].isEmpty())
+                ctype->setCopyable(ComplexTypeEntry::Unknown);
+             else {
+                if (convertBoolean(attributes["copyable"], "copyable", false))
+                    ctype->setCopyable(ComplexTypeEntry::CopyableSet);
+                 else
+                    ctype->setCopyable(ComplexTypeEntry::NonCopyableSet);
+
+            }
+
+            if (element->type == StackElement::ObjectTypeEntry || element->type == StackElement::ValueTypeEntry)
+                ctype->setHashFunction(attributes["hash-function"]);
+
+
+            ctype->setHeldType(attributes["held-type"]);
+
+            if (element->type == StackElement::ObjectTypeEntry
+                || element->type == StackElement::ValueTypeEntry) {
+                if (convertBoolean(attributes["force-abstract"], "force-abstract", false))
+                    ctype->setTypeFlags(ctype->typeFlags() | ComplexTypeEntry::ForceAbstract);
+                if (convertBoolean(attributes["deprecated"], "deprecated", false))
+                    ctype->setTypeFlags(ctype->typeFlags() | ComplexTypeEntry::Deprecated);
+            }
+
+            if (element->type == StackElement::InterfaceTypeEntry
+                || element->type == StackElement::ValueTypeEntry
+                || element->type == StackElement::ObjectTypeEntry) {
+                if (convertBoolean(attributes["delete-in-main-thread"], "delete-in-main-thread", false))
+                    ctype->setTypeFlags(ctype->typeFlags() | ComplexTypeEntry::DeleteInMainThread);
+            }
+
+            QString targetType = attributes["target-type"];
+            if (!targetType.isEmpty() && element->entry->isComplex())
+                static_cast<ComplexTypeEntry *>(element->entry)->setTargetType(targetType);
+
+            // ctype->setInclude(Include(Include::IncludePath, ctype->name()));
+            ctype = ctype->designatedInterface();
+            if (ctype)
+                ctype->setTargetLangPackage(attributes["package"]);
+
+        }
+        break;
+        case StackElement::FunctionTypeEntry: {
+            QString signature = attributes["signature"];
+            signature = TypeDatabase::normalizedSignature(signature.toLatin1().constData());
+            element->entry = m_database->findType(name);
+            if (element->entry) {
+                if (element->entry->type() == TypeEntry::FunctionType) {
+                    reinterpret_cast<FunctionTypeEntry*>(element->entry)->addSignature(signature);
+                } else {
+                    m_error = QString("%1 expected to be a function, but isn't! Maybe it was already declared as a class or something else.").arg(name);
+                    return false;
+                }
+            } else {
+                element->entry = new FunctionTypeEntry(name, signature, since);
+                element->entry->setCodeGeneration(m_generate);
+            }
+        }
+        break;
+        default:
+            Q_ASSERT(false);
+        };
+
+        if (element->entry) {
+            m_database->addType(element->entry);
+            setTypeRevision(element->entry, attributes["revision"].toInt());
+        } else {
+            ReportHandler::warning(QString("Type: %1 was rejected by typesystem").arg(name));
+        }
+
+    } else if (element->type == StackElement::InjectDocumentation) {
+        // check the XML tag attributes
+        QHash<QString, QString> attributes;
+        attributes["mode"] = "replace";
+        attributes["format"] = "native";
+        attributes["since"] = QString("0");
+
+        fetchAttributeValues(tagName, atts, &attributes);
+        double since = attributes["since"].toDouble();
+
+        const int validParent = StackElement::TypeEntryMask
+                                | StackElement::ModifyFunction
+                                | StackElement::ModifyField;
+        if (m_current->parent && m_current->parent->type & validParent) {
+            QString modeName = attributes["mode"];
+            DocModification::Mode mode;
+            if (modeName == "append") {
+                mode = DocModification::Append;
+            } else if (modeName == "prepend") {
+                mode = DocModification::Prepend;
+            } else if (modeName == "replace") {
+                mode = DocModification::Replace;
+            } else {
+                m_error = "Unknow documentation injection mode: " + modeName;
+                return false;
+            }
+
+            static QHash<QString, TypeSystem::Language> languageNames;
+            if (languageNames.isEmpty()) {
+                languageNames["target"] = TypeSystem::TargetLangCode;
+                languageNames["native"] = TypeSystem::NativeCode;
+            }
+
+            QString format = attributes["format"].toLower();
+            TypeSystem::Language lang = languageNames.value(format, TypeSystem::NoLanguage);
+            if (lang == TypeSystem::NoLanguage) {
+                m_error = QString("unsupported class attribute: '%1'").arg(format);
+                return false;
+            }
+
+            QString signature = m_current->type & StackElement::TypeEntryMask ? QString() : m_currentSignature;
+            DocModification mod(mode, signature, since);
+            mod.format = lang;
+            m_contextStack.top()->docModifications << mod;
+        } else {
+            m_error = "inject-documentation must be inside modify-function, "
+                      "modify-field or other tags that creates a type";
+            return false;
+        }
+    } else if (element->type == StackElement::ModifyDocumentation) {
+        // check the XML tag attributes
+        QHash<QString, QString> attributes;
+        attributes["xpath"] = QString();
+        attributes["since"] = QString("0");
+        fetchAttributeValues(tagName, atts, &attributes);
+        double since = attributes["since"].toDouble();
+
+        const int validParent = StackElement::TypeEntryMask
+                                | StackElement::ModifyFunction
+                                | StackElement::ModifyField;
+        if (m_current->parent && m_current->parent->type & validParent) {
+            QString signature = (m_current->type & StackElement::TypeEntryMask) ? QString() : m_currentSignature;
+            m_contextStack.top()->docModifications << DocModification(attributes["xpath"], signature, since);
+        } else {
+            m_error = "modify-documentation must be inside modify-function, "
+                      "modify-field or other tags that creates a type";
+            return false;
+        }
+    } else if (element->type != StackElement::None) {
+        bool topLevel = element->type == StackElement::Root
+                        || element->type == StackElement::SuppressedWarning
+                        || element->type == StackElement::Rejection
+                        || element->type == StackElement::LoadTypesystem
+                        || element->type == StackElement::InjectCode
+                        || element->type == StackElement::ExtraIncludes
+                        || element->type == StackElement::ConversionRule
+                        || element->type == StackElement::AddFunction
+                        || element->type == StackElement::Template;
+
+        if (!topLevel && m_current->type == StackElement::Root) {
+            m_error = QString("Tag requires parent: '%1'").arg(tagName);
+            return false;
+        }
+
+        StackElement topElement = !m_current ? StackElement(0) : *m_current;
+        element->entry = topElement.entry;
+
+        QHash<QString, QString> attributes;
+        attributes["since"] = QString("0");
+        switch (element->type) {
+        case StackElement::Root:
+            attributes["package"] = QString();
+            attributes["default-superclass"] = QString();
+            break;
+        case StackElement::LoadTypesystem:
+            attributes["name"] = QString();
+            attributes["generate"] = "yes";
+            break;
+        case StackElement::NoNullPointers:
+            attributes["default-value"] = QString();
+            break;
+        case StackElement::SuppressedWarning:
+            attributes["text"] = QString();
+            break;
+        case StackElement::ReplaceDefaultExpression:
+            attributes["with"] = QString();
+            break;
+        case StackElement::DefineOwnership:
+            attributes["class"] = "target";
+            attributes["owner"] = "";
+            break;
+        case StackElement::AddFunction:
+            attributes["signature"] = QString();
+            attributes["return-type"] = QString("void");
+            attributes["access"] = QString("public");
+            attributes["static"] = QString("no");
+            break;
+        case StackElement::ModifyFunction:
+            attributes["signature"] = QString();
+            attributes["access"] = QString();
+            attributes["remove"] = QString();
+            attributes["rename"] = QString();
+            attributes["deprecated"] = QString("no");
+            attributes["associated-to"] = QString();
+            attributes["virtual-slot"] = QString("no");
+            attributes["thread"] = QString("no");
+            attributes["allow-thread"] = QString("no");
+            break;
+        case StackElement::ModifyArgument:
+            attributes["index"] = QString();
+            attributes["replace-value"] = QString();
+            attributes["invalidate-after-use"] = QString("no");
+            break;
+        case StackElement::ModifyField:
+            attributes["name"] = QString();
+            attributes["write"] = "true";
+            attributes["read"] = "true";
+            attributes["remove"] = QString();
+            break;
+        case StackElement::Access:
+            attributes["modifier"] = QString();
+            break;
+        case StackElement::Include:
+            attributes["file-name"] = QString();
+            attributes["location"] = QString();
+            break;
+        case StackElement::CustomMetaConstructor:
+            attributes["name"] = topElement.entry->name().toLower() + "_create";
+            attributes["param-name"] = "copy";
+            break;
+        case StackElement::CustomMetaDestructor:
+            attributes["name"] = topElement.entry->name().toLower() + "_delete";
+            attributes["param-name"] = "copy";
+            break;
+        case StackElement::ReplaceType:
+            attributes["modified-type"] = QString();
+            break;
+        case StackElement::InjectCode:
+            attributes["class"] = "target";
+            attributes["position"] = "beginning";
+            attributes["file"] = QString();
+            break;
+        case StackElement::ConversionRule:
+            attributes["class"] = QString();
+            attributes["file"] = QString();
+            break;
+        case StackElement::TargetToNative:
+            attributes["replace"] = QString("yes");
+            break;
+        case StackElement::AddConversion:
+            attributes["type"] = QString();
+            attributes["check"] = QString();
+            break;
+        case StackElement::RejectEnumValue:
+            attributes["name"] = "";
+            break;
+        case StackElement::ArgumentMap:
+            attributes["index"] = "1";
+            attributes["meta-name"] = QString();
+            break;
+        case StackElement::Rename:
+            attributes["to"] = QString();
+            break;
+        case StackElement::Rejection:
+            attributes["class"] = "*";
+            attributes["function-name"] = "*";
+            attributes["field-name"] = "*";
+            attributes["enum-name"] = "*";
+            break;
+        case StackElement::Removal:
+            attributes["class"] = "all";
+            break;
+        case StackElement::Template:
+            attributes["name"] = QString();
+            break;
+        case StackElement::TemplateInstanceEnum:
+            attributes["name"] = QString();
+            break;
+        case StackElement::Replace:
+            attributes["from"] = QString();
+            attributes["to"] = QString();
+            break;
+        case StackElement::ReferenceCount:
+            attributes["action"] = QString();
+            attributes["variable-name"] = QString();
+            break;
+        case StackElement::ParentOwner:
+            attributes["index"] = QString();
+            attributes["action"] = QString();
+        default:
+            { };
+        };
+
+        double since = 0;
+        if (attributes.count() > 0) {
+            fetchAttributeValues(tagName, atts, &attributes);
+            since = attributes["since"].toDouble();
+        }
+
+        switch (element->type) {
+        case StackElement::Root:
+            m_defaultPackage = attributes["package"];
+            m_defaultSuperclass = attributes["default-superclass"];
+            element->type = StackElement::Root;
+            {
+                TypeSystemTypeEntry* moduleEntry = reinterpret_cast<TypeSystemTypeEntry*>(
+                        m_database->findType(m_defaultPackage));
+                element->entry = moduleEntry ? moduleEntry : new TypeSystemTypeEntry(m_defaultPackage, since);
+                element->entry->setCodeGeneration(m_generate);
+            }
+
+            if ((m_generate == TypeEntry::GenerateForSubclass ||
+                 m_generate == TypeEntry::GenerateNothing) && m_defaultPackage != "")
+                TypeDatabase::instance()->addRequiredTargetImport(m_defaultPackage);
+
+            if (!element->entry->qualifiedCppName().isEmpty())
+                m_database->addType(element->entry);
+            break;
+        case StackElement::LoadTypesystem: {
+            QString name = attributes["name"];
+            if (name.isEmpty()) {
+                m_error = "No typesystem name specified";
+                return false;
+            }
+            bool generateChild = (convertBoolean(attributes["generate"], "generate", true) && (m_generate == TypeEntry::GenerateAll));
+            if (!m_database->parseFile(name, generateChild)) {
+                m_error = QString("Failed to parse: '%1'").arg(name);
+                return false;
+            }
+        }
+        break;
+        case StackElement::RejectEnumValue: {
+            if (!m_currentEnum) {
+                m_error = "<reject-enum-value> node must be used inside a <enum-type> node";
+                return false;
+            }
+            QString name = attributes["name"];
+        } break;
+        case StackElement::ReplaceType: {
+            if (topElement.type != StackElement::ModifyArgument) {
+                m_error = "Type replacement can only be specified for argument modifications";
+                return false;
+            }
+
+            if (attributes["modified-type"].isEmpty()) {
+                m_error = "Type replacement requires 'modified-type' attribute";
+                return false;
+            }
+
+            m_contextStack.top()->functionMods.last().argument_mods.last().modified_type = attributes["modified-type"];
+        }
+        break;
+        case StackElement::ConversionRule: {
+            if (topElement.type != StackElement::ModifyArgument
+                && topElement.type != StackElement::ValueTypeEntry
+                && topElement.type != StackElement::PrimitiveTypeEntry
+                && topElement.type != StackElement::ContainerTypeEntry) {
+                m_error = "Conversion rules can only be specified for argument modification, "
+                          "value-type, primitive-type or container-type conversion.";
+                return false;
+            }
+
+            static QHash<QString, TypeSystem::Language> languageNames;
+            if (languageNames.isEmpty()) {
+                languageNames["target"] = TypeSystem::TargetLangCode;
+                languageNames["native"] = TypeSystem::NativeCode;
+            }
+
+            QString languageAttribute = attributes["class"].toLower();
+            TypeSystem::Language lang = languageNames.value(languageAttribute, TypeSystem::NoLanguage);
+
+            if (topElement.type == StackElement::ModifyArgument) {
+               if (lang == TypeSystem::NoLanguage) {
+                    m_error = QString("unsupported class attribute: '%1'").arg(lang);
+                    return false;
+                }
+
+                CodeSnip snip(since);
+                snip.language = lang;
+                m_contextStack.top()->functionMods.last().argument_mods.last().conversion_rules.append(snip);
+            } else {
+                if (topElement.entry->hasConversionRule() || topElement.entry->hasCustomConversion()) {
+                    m_error = "Types can have only one conversion rule";
+                    return false;
+                }
+
+                // The old conversion rule tag that uses a file containing the conversion
+                // will be kept temporarily for compatibility reasons.
+                QString sourceFile = attributes["file"];
+                if (!sourceFile.isEmpty()) {
+                    if (m_generate != TypeEntry::GenerateForSubclass
+                        && m_generate != TypeEntry::GenerateNothing) {
+
+                        const char* conversionFlag = NATIVE_CONVERSION_RULE_FLAG;
+                        if (lang == TypeSystem::TargetLangCode)
+                            conversionFlag = TARGET_CONVERSION_RULE_FLAG;
+
+                        QFile conversionSource(sourceFile);
+                        if (conversionSource.open(QIODevice::ReadOnly | QIODevice::Text)) {
+                            topElement.entry->setConversionRule(conversionFlag + QString::fromUtf8(conversionSource.readAll()));
+                        } else {
+                            ReportHandler::warning("File containing conversion code for "
+                                                   + topElement.entry->name()
+                                                   + " type does not exist or is not readable: "
+                                                   + sourceFile);
+                        }
+                    }
+                }
+
+                CustomConversion* customConversion = new CustomConversion(static_cast<TypeEntry*>(m_current->entry));
+                customConversionsForReview.append(customConversion);
+            }
+        }
+        break;
+        case StackElement::NativeToTarget: {
+            if (topElement.type != StackElement::ConversionRule) {
+                m_error = "Native to Target conversion code can only be specified for custom conversion rules.";
+                return false;
+            }
+            m_contextStack.top()->codeSnips << CodeSnip(0);
+        }
+        break;
+        case StackElement::TargetToNative: {
+            if (topElement.type != StackElement::ConversionRule) {
+                m_error = "Target to Native conversions can only be specified for custom conversion rules.";
+                return false;
+            }
+            bool replace = attributes["replace"] == "yes";
+            static_cast<TypeEntry*>(m_current->entry)->customConversion()->setReplaceOriginalTargetToNativeConversions(replace);
+        }
+        break;
+        case StackElement::AddConversion: {
+            if (topElement.type != StackElement::TargetToNative) {
+                m_error = "Target to Native conversions can only be added inside 'target-to-native' tags.";
+                return false;
+            }
+            QString sourceTypeName = attributes["type"];
+            if (sourceTypeName.isEmpty()) {
+                m_error = "Target to Native conversions must specify the input type with the 'type' attribute.";
+                return false;
+            }
+            QString typeCheck = attributes["check"];
+            static_cast<TypeEntry*>(m_current->entry)->customConversion()->addTargetToNativeConversion(sourceTypeName, typeCheck);
+            m_contextStack.top()->codeSnips << CodeSnip(0);
+        }
+        break;
+        case StackElement::ModifyArgument: {
+            if (topElement.type != StackElement::ModifyFunction
+                && topElement.type != StackElement::AddFunction) {
+                m_error = QString::fromLatin1("argument modification requires function"
+                                              " modification as parent, was %1")
+                          .arg(topElement.type, 0, 16);
+                return false;
+            }
+
+            QString index = attributes["index"];
+            if (index == "return")
+                index = "0";
+            else if (index == "this")
+                index = "-1";
+
+            bool ok = false;
+            int idx = index.toInt(&ok);
+            if (!ok) {
+                m_error = QString("Cannot convert '%1' to integer").arg(index);
+                return false;
+            }
+
+            QString replace_value = attributes["replace-value"];
+
+            if (!replace_value.isEmpty() && idx) {
+                m_error = QString("replace-value is only supported for return values (index=0).");
+                return false;
+            }
+
+            ArgumentModification argumentModification = ArgumentModification(idx, since);
+            argumentModification.replace_value = replace_value;
+            argumentModification.resetAfterUse = convertBoolean(attributes["invalidate-after-use"], "invalidate-after-use", false);
+            m_contextStack.top()->functionMods.last().argument_mods.append(argumentModification);
+        }
+        break;
+        case StackElement::NoNullPointers: {
+            if (topElement.type != StackElement::ModifyArgument) {
+                m_error = "no-null-pointer requires argument modification as parent";
+                return false;
+            }
+
+            m_contextStack.top()->functionMods.last().argument_mods.last().noNullPointers = true;
+            if (!m_contextStack.top()->functionMods.last().argument_mods.last().index)
+                m_contextStack.top()->functionMods.last().argument_mods.last().nullPointerDefaultValue = attributes["default-value"];
+             else if (!attributes["default-value"].isEmpty())
+                ReportHandler::warning("default values for null pointer guards are only effective for return values");
+
+        }
+        break;
+        case StackElement::DefineOwnership: {
+            if (topElement.type != StackElement::ModifyArgument) {
+                m_error = "define-ownership requires argument modification as parent";
+                return false;
+            }
+
+            static QHash<QString, TypeSystem::Language> languageNames;
+            if (languageNames.isEmpty()) {
+                languageNames["target"] = TypeSystem::TargetLangCode;
+                languageNames["native"] = TypeSystem::NativeCode;
+            }
+
+            QString classAttribute = attributes["class"].toLower();
+            TypeSystem::Language lang = languageNames.value(classAttribute, TypeSystem::NoLanguage);
+            if (lang == TypeSystem::NoLanguage) {
+                m_error = QString("unsupported class attribute: '%1'").arg(classAttribute);
+                return false;
+            }
+
+            static QHash<QString, TypeSystem::Ownership> ownershipNames;
+            if (ownershipNames.isEmpty()) {
+                ownershipNames["target"] = TypeSystem::TargetLangOwnership;
+                ownershipNames["c++"] = TypeSystem::CppOwnership;
+                ownershipNames["default"] = TypeSystem::DefaultOwnership;
+            }
+
+            QString ownershipAttribute = attributes["owner"].toLower();
+            TypeSystem::Ownership owner = ownershipNames.value(ownershipAttribute, TypeSystem::InvalidOwnership);
+            if (owner == TypeSystem::InvalidOwnership) {
+                m_error = QString("unsupported owner attribute: '%1'").arg(ownershipAttribute);
+                return false;
+            }
+
+            m_contextStack.top()->functionMods.last().argument_mods.last().ownerships[lang] = owner;
+        }
+        break;
+        case StackElement::SuppressedWarning:
+            if (attributes["text"].isEmpty())
+                ReportHandler::warning("Suppressed warning with no text specified");
+            else
+                m_database->addSuppressedWarning(attributes["text"]);
+            break;
+        case StackElement::ArgumentMap: {
+            if (!(topElement.type & StackElement::CodeSnipMask)) {
+                m_error = "Argument maps requires code injection as parent";
+                return false;
+            }
+
+            bool ok;
+            int pos = attributes["index"].toInt(&ok);
+            if (!ok) {
+                m_error = QString("Can't convert position '%1' to integer")
+                          .arg(attributes["position"]);
+                return false;
+            }
+
+            if (pos <= 0) {
+                m_error = QString("Argument position %1 must be a positive number").arg(pos);
+                return false;
+            }
+
+            QString meta_name = attributes["meta-name"];
+            if (meta_name.isEmpty())
+                ReportHandler::warning("Empty meta name in argument map");
+
+
+            if (topElement.type == StackElement::InjectCodeInFunction)
+                m_contextStack.top()->functionMods.last().snips.last().argumentMap[pos] = meta_name;
+             else {
+                ReportHandler::warning("Argument maps are only useful for injection of code "
+                                       "into functions.");
+            }
+        }
+        break;
+        case StackElement::Removal: {
+            if (topElement.type != StackElement::ModifyFunction) {
+                m_error = "Function modification parent required";
+                return false;
+            }
+
+            static QHash<QString, TypeSystem::Language> languageNames;
+            if (languageNames.isEmpty()) {
+                languageNames["target"] = TypeSystem::TargetLangAndNativeCode;
+                languageNames["all"] = TypeSystem::All;
+            }
+
+            QString languageAttribute = attributes["class"].toLower();
+            TypeSystem::Language lang = languageNames.value(languageAttribute, TypeSystem::NoLanguage);
+            if (lang == TypeSystem::NoLanguage) {
+                m_error = QString("unsupported class attribute: '%1'").arg(languageAttribute);
+                return false;
+            }
+
+            m_contextStack.top()->functionMods.last().removal = lang;
+        }
+        break;
+        case StackElement::Rename:
+        case StackElement::Access: {
+            if (topElement.type != StackElement::ModifyField
+                && topElement.type != StackElement::ModifyFunction
+                && topElement.type != StackElement::ModifyArgument) {
+                m_error = "Function, field  or argument modification parent required";
+                return false;
+            }
+
+            Modification *mod = 0;
+            if (topElement.type == StackElement::ModifyFunction)
+                mod = &m_contextStack.top()->functionMods.last();
+            else if (topElement.type == StackElement::ModifyField)
+                mod = &m_contextStack.top()->fieldMods.last();
+
+            QString modifier;
+            if (element->type == StackElement::Rename) {
+                modifier = "rename";
+                QString renamed_to = attributes["to"];
+                if (renamed_to.isEmpty()) {
+                    m_error = "Rename modifier requires 'to' attribute";
+                    return false;
+                }
+
+                if (topElement.type == StackElement::ModifyFunction)
+                    mod->setRenamedTo(renamed_to);
+                else if (topElement.type == StackElement::ModifyField)
+                    mod->setRenamedTo(renamed_to);
+                else
+                    m_contextStack.top()->functionMods.last().argument_mods.last().renamed_to = renamed_to;
+            } else
+                modifier = attributes["modifier"].toLower();
+
+
+            if (modifier.isEmpty()) {
+                m_error = "No access modification specified";
+                return false;
+            }
+
+            static QHash<QString, FunctionModification::Modifiers> modifierNames;
+            if (modifierNames.isEmpty()) {
+                modifierNames["private"] = Modification::Private;
+                modifierNames["public"] = Modification::Public;
+                modifierNames["protected"] = Modification::Protected;
+                modifierNames["friendly"] = Modification::Friendly;
+                modifierNames["rename"] = Modification::Rename;
+                modifierNames["final"] = Modification::Final;
+                modifierNames["non-final"] = Modification::NonFinal;
+            }
+
+            if (!modifierNames.contains(modifier)) {
+                m_error = QString("Unknown access modifier: '%1'").arg(modifier);
+                return false;
+            }
+
+            if (mod)
+                mod->modifiers |= modifierNames[modifier];
+        }
+        break;
+        case StackElement::RemoveArgument:
+            if (topElement.type != StackElement::ModifyArgument) {
+                m_error = "Removing argument requires argument modification as parent";
+                return false;
+            }
+
+            m_contextStack.top()->functionMods.last().argument_mods.last().removed = true;
+            break;
+
+        case StackElement::ModifyField: {
+            QString name = attributes["name"];
+            if (name.isEmpty())
+                break;
+            FieldModification fm;
+            fm.name = name;
+            fm.modifiers = 0;
+
+            if (!convertRemovalAttribute(attributes["remove"], fm, m_error))
+                return false;
+
+            QString read = attributes["read"];
+            QString write = attributes["write"];
+
+            if (read == "true") fm.modifiers |= FieldModification::Readable;
+            if (write == "true") fm.modifiers |= FieldModification::Writable;
+
+            m_contextStack.top()->fieldMods << fm;
+        }
+        break;
+        case StackElement::AddFunction: {
+            if (!(topElement.type & (StackElement::ComplexTypeEntryMask | StackElement::Root))) {
+                m_error = QString::fromLatin1("Add function requires a complex type or a root tag as parent"
+                                              ", was=%1").arg(topElement.type, 0, 16);
+                return false;
+            }
+            QString signature = attributes["signature"];
+
+            signature = TypeDatabase::normalizedSignature(signature.toLocal8Bit().constData());
+            if (signature.isEmpty()) {
+                m_error = "No signature for the added function";
+                return false;
+            }
+
+            QString errorString = checkSignatureError(signature, "add-function");
+            if (!errorString.isEmpty()) {
+                m_error = errorString;
+                return false;
+            }
+
+            AddedFunction func(signature, attributes["return-type"], since);
+            func.setStatic(attributes["static"] == "yes");
+            if (!signature.contains("("))
+                signature += "()";
+            m_currentSignature = signature;
+
+            QString access = attributes["access"].toLower();
+            if (!access.isEmpty()) {
+                if (access == QLatin1String("protected")) {
+                    func.setAccess(AddedFunction::Protected);
+                } else if (access == QLatin1String("public")) {
+                    func.setAccess(AddedFunction::Public);
+                } else {
+                    m_error = QString::fromLatin1("Bad access type '%1'").arg(access);
+                    return false;
+                }
+            }
+
+            m_contextStack.top()->addedFunctions << func;
+
+            FunctionModification mod(since);
+            mod.signature = m_currentSignature;
+            m_contextStack.top()->functionMods << mod;
+        }
+        break;
+        case StackElement::ModifyFunction: {
+            if (!(topElement.type & StackElement::ComplexTypeEntryMask)) {
+                m_error = QString::fromLatin1("Modify function requires complex type as parent"
+                                              ", was=%1").arg(topElement.type, 0, 16);
+                return false;
+            }
+            QString signature = attributes["signature"];
+
+            signature = TypeDatabase::normalizedSignature(signature.toLocal8Bit().constData());
+            if (signature.isEmpty()) {
+                m_error = "No signature for modified function";
+                return false;
+            }
+
+            QString errorString = checkSignatureError(signature, "modify-function");
+            if (!errorString.isEmpty()) {
+                m_error = errorString;
+                return false;
+            }
+
+            FunctionModification mod(since);
+            m_currentSignature = mod.signature = signature;
+
+            QString access = attributes["access"].toLower();
+            if (!access.isEmpty()) {
+                if (access == QLatin1String("private"))
+                    mod.modifiers |= Modification::Private;
+                else if (access == QLatin1String("protected"))
+                    mod.modifiers |= Modification::Protected;
+                else if (access == QLatin1String("public"))
+                    mod.modifiers |= Modification::Public;
+                else if (access == QLatin1String("final"))
+                    mod.modifiers |= Modification::Final;
+                else if (access == QLatin1String("non-final"))
+                    mod.modifiers |= Modification::NonFinal;
+                else {
+                    m_error = QString::fromLatin1("Bad access type '%1'").arg(access);
+                    return false;
+                }
+            }
+
+            if (convertBoolean(attributes["deprecated"], "deprecated", false))
+                mod.modifiers |= Modification::Deprecated;
+
+            if (!convertRemovalAttribute(attributes["remove"], mod, m_error))
+                return false;
+
+            QString rename = attributes["rename"];
+            if (!rename.isEmpty()) {
+                mod.renamedToName = rename;
+                mod.modifiers |= Modification::Rename;
+            }
+
+            QString association = attributes["associated-to"];
+            if (!association.isEmpty())
+                mod.association = association;
+
+            mod.setIsThread(convertBoolean(attributes["thread"], "thread", false));
+            mod.setAllowThread(convertBoolean(attributes["allow-thread"], "allow-thread", false));
+
+            mod.modifiers |= (convertBoolean(attributes["virtual-slot"], "virtual-slot", false) ? Modification::VirtualSlot : 0);
+
+            m_contextStack.top()->functionMods << mod;
+        }
+        break;
+        case StackElement::ReplaceDefaultExpression:
+            if (!(topElement.type & StackElement::ModifyArgument)) {
+                m_error = "Replace default expression only allowed as child of argument modification";
+                return false;
+            }
+
+            if (attributes["with"].isEmpty()) {
+                m_error = "Default expression replaced with empty string. Use remove-default-expression instead.";
+                return false;
+            }
+
+            m_contextStack.top()->functionMods.last().argument_mods.last().replacedDefaultExpression = attributes["with"];
+            break;
+        case StackElement::RemoveDefaultExpression:
+            m_contextStack.top()->functionMods.last().argument_mods.last().removedDefaultExpression = true;
+            break;
+        case StackElement::CustomMetaConstructor:
+        case StackElement::CustomMetaDestructor: {
+            CustomFunction *func = new CustomFunction(attributes["name"]);
+            func->paramName = attributes["param-name"];
+            element->value.customFunction = func;
+        }
+        break;
+        case StackElement::ReferenceCount: {
+            if (topElement.type != StackElement::ModifyArgument) {
+                m_error = "reference-count must be child of modify-argument";
+                return false;
+            }
+
+            ReferenceCount rc;
+
+            static QHash<QString, ReferenceCount::Action> actions;
+            if (actions.isEmpty()) {
+                actions["add"] = ReferenceCount::Add;
+                actions["add-all"] = ReferenceCount::AddAll;
+                actions["remove"] = ReferenceCount::Remove;
+                actions["set"] = ReferenceCount::Set;
+                actions["ignore"] = ReferenceCount::Ignore;
+            }
+            rc.action = actions.value(attributes["action"].toLower(), ReferenceCount::Invalid);
+            rc.varName = attributes["variable-name"];
+
+            if (rc.action == ReferenceCount::Invalid) {
+                m_error = "unrecognized value for action attribute. supported actions:";
+                foreach (QString action, actions.keys())
+                    m_error += " " + action;
+            }
+
+            m_contextStack.top()->functionMods.last().argument_mods.last().referenceCounts.append(rc);
+        }
+        break;
+
+        case StackElement::ParentOwner: {
+            if (topElement.type != StackElement::ModifyArgument) {
+                m_error = "parent-policy must be child of modify-argument";
+                return false;
+            }
+
+            ArgumentOwner ao;
+
+            QString index = attributes["index"];
+            if (index == "return")
+                index = "0";
+            else if (index == "this")
+                index = "-1";
+
+            bool ok = false;
+            int idx = index.toInt(&ok);
+            if (!ok) {
+                m_error = QString("Cannot convert '%1' to integer").arg(index);
+                return false;
+            }
+
+            static QHash<QString, ArgumentOwner::Action> actions;
+            if (actions.isEmpty()) {
+                actions["add"] = ArgumentOwner::Add;
+                actions["remove"] = ArgumentOwner::Remove;
+            }
+
+            ao.action = actions.value(attributes["action"].toLower(), ArgumentOwner::Invalid);
+            if (!ao.action) {
+                m_error = QString("Invalid parent actionr");
+                return false;
+            }
+            ao.index = idx;
+            m_contextStack.top()->functionMods.last().argument_mods.last().owner = ao;
+        }
+        break;
+
+
+        case StackElement::InjectCode: {
+            if (!(topElement.type & StackElement::ComplexTypeEntryMask)
+                && (topElement.type != StackElement::AddFunction)
+                && (topElement.type != StackElement::ModifyFunction)
+                && (topElement.type != StackElement::Root)) {
+                m_error = "wrong parent type for code injection";
+                return false;
+            }
+
+            static QHash<QString, TypeSystem::Language> languageNames;
+            if (languageNames.isEmpty()) {
+                languageNames["target"] = TypeSystem::TargetLangCode; // em algum lugar do cpp
+                languageNames["native"] = TypeSystem::NativeCode; // em algum lugar do cpp
+                languageNames["shell"] = TypeSystem::ShellCode; // coloca no header, mas antes da declaracao da classe
+                languageNames["shell-declaration"] = TypeSystem::ShellDeclaration; // coloca no header, dentro da declaracao da classe
+                languageNames["library-initializer"] = TypeSystem::PackageInitializer;
+                languageNames["destructor-function"] = TypeSystem::DestructorFunction;
+                languageNames["constructors"] = TypeSystem::Constructors;
+                languageNames["interface"] = TypeSystem::Interface;
+            }
+
+            QString className = attributes["class"].toLower();
+            if (!languageNames.contains(className)) {
+                m_error = QString("Invalid class specifier: '%1'").arg(className);
+                return false;
+            }
+
+
+            static QHash<QString, CodeSnip::Position> positionNames;
+            if (positionNames.isEmpty()) {
+                positionNames["beginning"] = CodeSnip::Beginning;
+                positionNames["end"] = CodeSnip::End;
+                // QtScript
+                positionNames["declaration"] = CodeSnip::Declaration;
+                positionNames["prototype-initialization"] = CodeSnip::PrototypeInitialization;
+                positionNames["constructor-initialization"] = CodeSnip::ConstructorInitialization;
+                positionNames["constructor"] = CodeSnip::Constructor;
+            }
+
+            QString position = attributes["position"].toLower();
+            if (!positionNames.contains(position)) {
+                m_error = QString("Invalid position: '%1'").arg(position);
+                return false;
+            }
+
+            CodeSnip snip(since);
+            snip.language = languageNames[className];
+            snip.position = positionNames[position];
+            bool in_file = false;
+
+            QString file_name = attributes["file"];
+
+            //Handler constructor....
+            if (m_generate != TypeEntry::GenerateForSubclass &&
+                m_generate != TypeEntry::GenerateNothing &&
+                !file_name.isEmpty()) {
+                if (QFile::exists(file_name)) {
+                    QFile codeFile(file_name);
+                    if (codeFile.open(QIODevice::Text | QIODevice::ReadOnly)) {
+                        QString content = QString::fromUtf8(codeFile.readAll());
+                        content.prepend("// ========================================================================\n"
+                                        "// START of custom code block [file: " + file_name + "]\n");
+                        content.append("\n// END of custom code block [file: " + file_name + "]\n"
+                                       "// ========================================================================\n");
+                        snip.addCode(content);
+                        in_file = true;
+                    }
+                } else
+                    ReportHandler::warning("File for inject code not exist: " + file_name);
+
+            }
+
+            if (snip.language == TypeSystem::Interface && topElement.type != StackElement::InterfaceTypeEntry) {
+                m_error = "Interface code injections must be direct child of an interface type entry";
+                return false;
+            }
+
+            if (topElement.type == StackElement::ModifyFunction || topElement.type == StackElement::AddFunction) {
+                FunctionModification mod = m_contextStack.top()->functionMods.last();
+                if (snip.language == TypeSystem::ShellDeclaration) {
+                    m_error = "no function implementation in shell declaration in which to inject code";
+                    return false;
+                }
+
+                m_contextStack.top()->functionMods.last().snips << snip;
+                if (in_file)
+                    m_contextStack.top()->functionMods.last().modifiers |= FunctionModification::CodeInjection;
+                element->type = StackElement::InjectCodeInFunction;
+            } else if (topElement.type == StackElement::Root) {
+                element->entry->addCodeSnip(snip);
+            } else if (topElement.type != StackElement::Root) {
+                m_contextStack.top()->codeSnips << snip;
+            }
+
+        }
+        break;
+        case StackElement::Include: {
+            QString location = attributes["location"].toLower();
+
+            static QHash<QString, Include::IncludeType> locationNames;
+            if (locationNames.isEmpty()) {
+                locationNames["global"] = Include::IncludePath;
+                locationNames["local"] = Include::LocalPath;
+                locationNames["target"] = Include::TargetLangImport;
+            }
+
+            if (!locationNames.contains(location)) {
+                m_error = QString("Location not recognized: '%1'").arg(location);
+                return false;
+            }
+
+            Include::IncludeType loc = locationNames[location];
+            Include inc(loc, attributes["file-name"]);
+
+            ComplexTypeEntry *ctype = static_cast<ComplexTypeEntry *>(element->entry);
+            if (topElement.type & (StackElement::ComplexTypeEntryMask | StackElement::PrimitiveTypeEntry)) {
+                element->entry->setInclude(inc);
+            } else if (topElement.type == StackElement::ExtraIncludes) {
+                element->entry->addExtraInclude(inc);
+            } else {
+                m_error = "Only supported parent tags are primitive-type, complex types or extra-includes";
+                return false;
+            }
+
+            inc = ctype->include();
+            IncludeList lst = ctype->extraIncludes();
+            ctype = ctype->designatedInterface();
+            if (ctype) {
+                ctype->setExtraIncludes(lst);
+                ctype->setInclude(inc);
+            }
+        }
+        break;
+        case StackElement::Rejection: {
+            QString cls = attributes["class"];
+            QString function = attributes["function-name"];
+            QString field = attributes["field-name"];
+            QString enum_ = attributes["enum-name"];
+            if (cls == "*" && function == "*" && field == "*" && enum_ == "*") {
+                m_error = "bad reject entry, neither 'class', 'function-name' nor "
+                          "'field' specified";
+                return false;
+            }
+            m_database->addRejection(cls, function, field, enum_);
+        }
+        break;
+        case StackElement::Template:
+            element->value.templateEntry = new TemplateEntry(attributes["name"], since);
+            break;
+        case StackElement::TemplateInstanceEnum:
+            if (!(topElement.type & StackElement::CodeSnipMask) &&
+                (topElement.type != StackElement::Template) &&
+                (topElement.type != StackElement::CustomMetaConstructor) &&
+                (topElement.type != StackElement::CustomMetaDestructor) &&
+                (topElement.type != StackElement::NativeToTarget) &&
+                (topElement.type != StackElement::AddConversion) &&
+                (topElement.type != StackElement::ConversionRule)) {
+                m_error = "Can only insert templates into code snippets, templates, custom-constructors, "\
+                          "custom-destructors, conversion-rule, native-to-target or add-conversion tags.";
+                return false;
+            }
+            element->value.templateInstance = new TemplateInstance(attributes["name"], since);
+            break;
+        case StackElement::Replace:
+            if (topElement.type != StackElement::TemplateInstanceEnum) {
+                m_error = "Can only insert replace rules into insert-template.";
+                return false;
+            }
+            element->parent->value.templateInstance->addReplaceRule(attributes["from"], attributes["to"]);
+            break;
+        default:
+            break; // nada
+        };
+    }
+
+    m_current = element;
+    return true;
+}
+
+PrimitiveTypeEntry* PrimitiveTypeEntry::basicAliasedTypeEntry() const
+{
+    if (!m_aliasedTypeEntry)
+        return 0;
+
+    PrimitiveTypeEntry* baseAliasTypeEntry = m_aliasedTypeEntry->basicAliasedTypeEntry();
+    if (baseAliasTypeEntry)
+        return baseAliasTypeEntry;
+    else
+        return m_aliasedTypeEntry;
+}
+
+typedef QHash<const PrimitiveTypeEntry*, QString> PrimitiveTypeEntryTargetLangPackageMap;
+Q_GLOBAL_STATIC(PrimitiveTypeEntryTargetLangPackageMap, primitiveTypeEntryTargetLangPackages);
+
+void PrimitiveTypeEntry::setTargetLangPackage(const QString& package)
+{
+    primitiveTypeEntryTargetLangPackages()->insert(this, package);
+}
+QString PrimitiveTypeEntry::targetLangPackage() const
+{
+    if (!primitiveTypeEntryTargetLangPackages()->contains(this))
+        return this->::TypeEntry::targetLangPackage();
+    return primitiveTypeEntryTargetLangPackages()->value(this);
+}
+
+CodeSnipList TypeEntry::codeSnips() const
+{
+    return m_codeSnips;
+}
+
+QString Modification::accessModifierString() const
+{
+    if (isPrivate()) return "private";
+    if (isProtected()) return "protected";
+    if (isPublic()) return "public";
+    if (isFriendly()) return "friendly";
+    return QString();
+}
+
+FunctionModificationList ComplexTypeEntry::functionModifications(const QString &signature) const
+{
+    FunctionModificationList lst;
+    for (int i = 0; i < m_functionMods.count(); ++i) {
+        const FunctionModification &mod = m_functionMods.at(i);
+        if (mod.signature == signature)
+            lst << mod;
+    }
+    return lst;
+}
+
+FieldModification ComplexTypeEntry::fieldModification(const QString &name) const
+{
+    for (int i = 0; i < m_fieldMods.size(); ++i)
+        if (m_fieldMods.at(i).name == name)
+            return m_fieldMods.at(i);
+    FieldModification mod;
+    mod.name = name;
+    mod.modifiers = FieldModification::Readable | FieldModification::Writable;
+    return mod;
+}
+
+// The things we do not to break the ABI...
+typedef QHash<const ComplexTypeEntry*, QString> ComplexTypeEntryDefaultConstructorMap;
+Q_GLOBAL_STATIC(ComplexTypeEntryDefaultConstructorMap, complexTypeEntryDefaultConstructors);
+
+void ComplexTypeEntry::setDefaultConstructor(const QString& defaultConstructor)
+{
+    if (!defaultConstructor.isEmpty())
+        complexTypeEntryDefaultConstructors()->insert(this, defaultConstructor);
+}
+QString ComplexTypeEntry::defaultConstructor() const
+{
+    if (!complexTypeEntryDefaultConstructors()->contains(this))
+        return QString();
+    return complexTypeEntryDefaultConstructors()->value(this);
+}
+bool ComplexTypeEntry::hasDefaultConstructor() const
+{
+    return complexTypeEntryDefaultConstructors()->contains(this);
+}
+
+QString ContainerTypeEntry::targetLangPackage() const
+{
+    return QString();
+}
+
+QString ContainerTypeEntry::targetLangName() const
+{
+
+    switch (m_type) {
+    case StringListContainer: return "QStringList";
+    case ListContainer: return "QList";
+    case LinkedListContainer: return "QLinkedList";
+    case VectorContainer: return "QVector";
+    case StackContainer: return "QStack";
+    case QueueContainer: return "QQueue";
+    case SetContainer: return "QSet";
+    case MapContainer: return "QMap";
+    case MultiMapContainer: return "QMultiMap";
+    case HashContainer: return "QHash";
+    case MultiHashContainer: return "QMultiHash";
+    case PairContainer: return "QPair";
+    default:
+        qWarning("bad type... %d", m_type);
+        break;
+    }
+    return QString();
+}
+
+QString ContainerTypeEntry::qualifiedCppName() const
+{
+    if (m_type == StringListContainer)
+        return "QStringList";
+    return ComplexTypeEntry::qualifiedCppName();
+}
+
+QString EnumTypeEntry::targetLangQualifier() const
+{
+    TypeEntry *te = TypeDatabase::instance()->findType(m_qualifier);
+    if (te)
+        return te->targetLangName();
+    else
+        return m_qualifier;
+}
+
+QString EnumTypeEntry::targetLangApiName() const
+{
+    return "jint";
+}
+
+QString FlagsTypeEntry::targetLangApiName() const
+{
+    return "jint";
+}
+
+void EnumTypeEntry::addEnumValueRedirection(const QString &rejected, const QString &usedValue)
+{
+    m_enumRedirections << EnumValueRedirection(rejected, usedValue);
+}
+
+QString EnumTypeEntry::enumValueRedirection(const QString &value) const
+{
+    for (int i = 0; i < m_enumRedirections.size(); ++i)
+        if (m_enumRedirections.at(i).rejected == value)
+            return m_enumRedirections.at(i).used;
+    return QString();
+}
+
+QString FlagsTypeEntry::qualifiedTargetLangName() const
+{
+    return targetLangPackage() + "." + m_enum->targetLangQualifier() + "." + targetLangName();
+}
+
+/*!
+ * The Visual Studio 2002 compiler doesn't support these symbols,
+ * which our typedefs unforntuatly expand to.
+ */
+QString fixCppTypeName(const QString &name)
+{
+    if (name == "long long") return "qint64";
+    else if (name == "unsigned long long") return "quint64";
+    return name;
+}
+
+QString TemplateInstance::expandCode() const
+{
+    TemplateEntry *templateEntry = TypeDatabase::instance()->findTemplate(m_name);
+    if (templateEntry) {
+        QString res = templateEntry->code();
+        foreach (QString key, replaceRules.keys())
+            res.replace(key, replaceRules[key]);
+
+        return "// TEMPLATE - " + m_name + " - START" + res + "// TEMPLATE - " + m_name + " - END";
+    } else
+        ReportHandler::warning("insert-template referring to non-existing template '" + m_name + "'");
+
+    return QString();
+}
+
+
+QString CodeSnipAbstract::code() const
+{
+    QString res;
+    foreach (CodeSnipFragment codeFrag, codeList)
+        res.append(codeFrag.code());
+
+    return res;
+}
+
+QString CodeSnipFragment::code() const
+{
+    if (m_instance)
+        return m_instance->expandCode();
+    else
+        return m_code;
+}
+
+QString FunctionModification::toString() const
+{
+    QString str = signature + QLatin1String("->");
+    if (modifiers & AccessModifierMask) {
+        switch (modifiers & AccessModifierMask) {
+        case Private: str += QLatin1String("private"); break;
+        case Protected: str += QLatin1String("protected"); break;
+        case Public: str += QLatin1String("public"); break;
+        case Friendly: str += QLatin1String("friendly"); break;
+        }
+    }
+
+    if (modifiers & Final) str += QLatin1String("final");
+    if (modifiers & NonFinal) str += QLatin1String("non-final");
+
+    if (modifiers & Readable) str += QLatin1String("readable");
+    if (modifiers & Writable) str += QLatin1String("writable");
+
+    if (modifiers & CodeInjection) {
+        foreach (CodeSnip s, snips) {
+            str += QLatin1String("\n//code injection:\n");
+            str += s.code();
+        }
+    }
+
+    if (modifiers & Rename) str += QLatin1String("renamed:") + renamedToName;
+
+    if (modifiers & Deprecated) str += QLatin1String("deprecate");
+
+    if (modifiers & ReplaceExpression) str += QLatin1String("replace-expression");
+
+    return str;
+}
+
+bool FunctionModification::operator!=(const FunctionModification& other) const
+{
+    return !(*this == other);
+}
+
+bool FunctionModification::operator==(const FunctionModification& other) const
+{
+    if (signature != other.signature)
+        return false;
+
+    if (association != other.association)
+        return false;
+
+    if (modifiers != other.modifiers)
+        return false;
+
+    if (removal != other.removal)
+        return false;
+
+    if (m_thread != other.m_thread)
+        return false;
+
+    if (m_allowThread != other.m_allowThread)
+        return false;
+
+    if (m_version != other.m_version)
+        return false;
+
+    return true;
+}
+
+static AddedFunction::TypeInfo parseType(const QString& signature, int startPos = 0, int* endPos = 0)
+{
+    AddedFunction::TypeInfo result;
+    QRegExp regex("\\w");
+    int length = signature.length();
+    int start = signature.indexOf(regex, startPos);
+    if (start == -1) {
+        if (signature.mid(startPos + 1, 3) == "...") { // varargs
+            if (endPos)
+                *endPos = startPos + 4;
+            result.name = "...";
+        } else { // error
+            if (endPos)
+                *endPos = length;
+        }
+        return result;
+    }
+
+    int cantStop = 0;
+    QString paramString;
+    QChar c;
+    int i = start;
+    for (; i < length; ++i) {
+        c = signature[i];
+        if (c == '<')
+            cantStop++;
+        if (c == '>')
+            cantStop--;
+        if (cantStop < 0)
+            break; // FIXME: report error?
+        if ((c == ')' || c == ',') && !cantStop)
+            break;
+        paramString += signature[i];
+    }
+    if (endPos)
+        *endPos = i;
+
+    // Check default value
+    if (paramString.contains('=')) {
+        QStringList lst = paramString.split('=');
+        paramString = lst[0].trimmed();
+        result.defaultValue = lst[1].trimmed();
+    }
+
+    // check constness
+    if (paramString.startsWith("const ")) {
+        result.isConstant = true;
+        paramString.remove(0, sizeof("const")/sizeof(char));
+        paramString = paramString.trimmed();
+    }
+    // check reference
+    if (paramString.endsWith("&")) {
+        result.isReference = true;
+        paramString.chop(1);
+        paramString = paramString.trimmed();
+    }
+    // check Indirections
+    while (paramString.endsWith("*")) {
+        result.indirections++;
+        paramString.chop(1);
+        paramString = paramString.trimmed();
+    }
+    result.name = paramString;
+
+    return result;
+}
+
+AddedFunction::AddedFunction(QString signature, QString returnType, double vr) : m_access(Public), m_version(vr)
+{
+    Q_ASSERT(!returnType.isEmpty());
+    m_returnType = parseType(returnType);
+    signature = signature.trimmed();
+    int endPos = signature.indexOf('(');
+    if (endPos < 0) {
+        m_isConst = false;
+        m_name = signature;
+    } else {
+        m_name = signature.left(endPos).trimmed();
+        int signatureLength = signature.length();
+        while (endPos < signatureLength) {
+            TypeInfo arg = parseType(signature, endPos, &endPos);
+            if (!arg.name.isEmpty())
+                m_arguments.append(arg);
+            // end of parameters...
+            if (signature[endPos] == ')')
+                break;
+        }
+        // is const?
+        m_isConst = signature.right(signatureLength - endPos).contains("const");
+    }
+}
+
+QString ComplexTypeEntry::targetLangApiName() const
+{
+    return strings_jobject;
+}
+QString StringTypeEntry::targetLangApiName() const
+{
+    return strings_jobject;
+}
+QString StringTypeEntry::targetLangName() const
+{
+    return strings_String;
+}
+QString StringTypeEntry::targetLangPackage() const
+{
+    return QString();
+}
+QString CharTypeEntry::targetLangApiName() const
+{
+    return strings_jchar;
+}
+QString CharTypeEntry::targetLangName() const
+{
+    return strings_char;
+}
+QString VariantTypeEntry::targetLangApiName() const
+{
+    return strings_jobject;
+}
+QString VariantTypeEntry::targetLangName() const
+{
+    return strings_Object;
+}
+QString VariantTypeEntry::targetLangPackage() const
+{
+    return QString();
+}
+
+QString ContainerTypeEntry::typeName() const
+{
+    switch(m_type) {
+        case LinkedListContainer:
+            return "linked-list";
+        case ListContainer:
+            return "list";
+        case StringListContainer:
+            return "string-list";
+        case VectorContainer:
+            return "vector";
+        case StackContainer:
+            return "stack";
+        case QueueContainer:
+            return "queue";
+        case SetContainer:
+            return "set";
+        case MapContainer:
+            return "map";
+        case MultiMapContainer:
+            return "multi-map";
+        case HashContainer:
+            return "hash";
+        case MultiHashContainer:
+            return "multi-hash";
+        case PairContainer:
+            return "pair";
+        case NoContainer:
+        default:
+            return "?";
+    }
+}
+
+static bool strLess(const char* a, const char* b)
+{
+    return ::strcmp(a, b) < 0;
+}
+
+bool TypeEntry::isCppPrimitive() const
+{
+    if (!isPrimitive())
+        return false;
+
+    PrimitiveTypeEntry* aliasedType = ((PrimitiveTypeEntry*)this)->basicAliasedTypeEntry();
+    QByteArray typeName = (aliasedType ? aliasedType->name() : m_name).toAscii();
+
+    if (typeName.contains(' ') || m_type == VoidType)
+        return true;
+    // Keep this sorted!!
+    static const char* cppTypes[] = { "bool", "char", "double", "float", "int", "long", "long long", "short", "wchar_t" };
+    const int N = sizeof(cppTypes)/sizeof(char*);
+
+    const char** res = qBinaryFind(&cppTypes[0], &cppTypes[N], typeName.constData(), strLess);
+
+    return res != &cppTypes[N];
+}
+
+// Again, stuff to avoid ABI breakage.
+typedef QHash<const TypeEntry*, CustomConversion*> TypeEntryCustomConversionMap;
+Q_GLOBAL_STATIC(TypeEntryCustomConversionMap, typeEntryCustomConversionMap);
+
+TypeEntry::~TypeEntry()
+{
+    if (typeEntryCustomConversionMap()->contains(this)) {
+        CustomConversion* customConversion = typeEntryCustomConversionMap()->value(this);
+        typeEntryCustomConversionMap()->remove(this);
+        delete customConversion;
+    }
+}
+
+bool TypeEntry::hasCustomConversion() const
+{
+    return typeEntryCustomConversionMap()->contains(this);
+}
+void TypeEntry::setCustomConversion(CustomConversion* customConversion)
+{
+    if (customConversion)
+        typeEntryCustomConversionMap()->insert(this, customConversion);
+    else if (typeEntryCustomConversionMap()->contains(this))
+        typeEntryCustomConversionMap()->remove(this);
+}
+CustomConversion* TypeEntry::customConversion() const
+{
+    if (typeEntryCustomConversionMap()->contains(this))
+        return typeEntryCustomConversionMap()->value(this);
+    return 0;
+}
+
+/*
+static void injectCode(ComplexTypeEntry *e,
+                       const char *signature,
+                       const QByteArray &code,
+                       const ArgumentMap &args)
+{
+    CodeSnip snip;
+    snip.language = TypeSystem::NativeCode;
+    snip.position = CodeSnip::Beginning;
+    snip.addCode(QString::fromLatin1(code));
+    snip.argumentMap = args;
+
+    FunctionModification mod;
+    mod.signature = QMetaObject::normalizedSignature(signature);
+    mod.snips << snip;
+    mod.modifiers = Modification::CodeInjection;
+}
+*/
+
+struct CustomConversion::CustomConversionPrivate
+{
+    CustomConversionPrivate(const TypeEntry* ownerType)
+        : ownerType(ownerType), replaceOriginalTargetToNativeConversions(false)
+    {
+    }
+    const TypeEntry* ownerType;
+    QString nativeToTargetConversion;
+    bool replaceOriginalTargetToNativeConversions;
+    TargetToNativeConversions targetToNativeConversions;
+};
+
+struct CustomConversion::TargetToNativeConversion::TargetToNativeConversionPrivate
+{
+    TargetToNativeConversionPrivate()
+        : sourceType(0)
+    {
+    }
+    const TypeEntry* sourceType;
+    QString sourceTypeName;
+    QString sourceTypeCheck;
+    QString conversion;
+};
+
+CustomConversion::CustomConversion(TypeEntry* ownerType)
+{
+    m_d = new CustomConversionPrivate(ownerType);
+    if (ownerType)
+        ownerType->setCustomConversion(this);
+}
+
+CustomConversion::~CustomConversion()
+{
+    foreach (TargetToNativeConversion* targetToNativeConversion, m_d->targetToNativeConversions)
+        delete targetToNativeConversion;
+    m_d->targetToNativeConversions.clear();
+    delete m_d;
+}
+
+const TypeEntry* CustomConversion::ownerType() const
+{
+    return m_d->ownerType;
+}
+
+QString CustomConversion::nativeToTargetConversion() const
+{
+    return m_d->nativeToTargetConversion;
+}
+
+void CustomConversion::setNativeToTargetConversion(const QString& nativeToTargetConversion)
+{
+    m_d->nativeToTargetConversion = nativeToTargetConversion;
+}
+
+bool CustomConversion::replaceOriginalTargetToNativeConversions() const
+{
+    return m_d->replaceOriginalTargetToNativeConversions;
+}
+
+void CustomConversion::setReplaceOriginalTargetToNativeConversions(bool replaceOriginalTargetToNativeConversions)
+{
+    m_d->replaceOriginalTargetToNativeConversions = replaceOriginalTargetToNativeConversions;
+}
+
+bool CustomConversion::hasTargetToNativeConversions() const
+{
+    return !(m_d->targetToNativeConversions.isEmpty());
+}
+
+CustomConversion::TargetToNativeConversions& CustomConversion::targetToNativeConversions()
+{
+    return m_d->targetToNativeConversions;
+}
+
+const CustomConversion::TargetToNativeConversions& CustomConversion::targetToNativeConversions() const
+{
+    return m_d->targetToNativeConversions;
+}
+
+void CustomConversion::addTargetToNativeConversion(const QString& sourceTypeName,
+                                                   const QString& sourceTypeCheck,
+                                                   const QString& conversion)
+{
+    m_d->targetToNativeConversions.append(new TargetToNativeConversion(sourceTypeName, sourceTypeCheck, conversion));
+}
+
+CustomConversion::TargetToNativeConversion::TargetToNativeConversion(const QString& sourceTypeName,
+                                                                     const QString& sourceTypeCheck,
+                                                                     const QString& conversion)
+{
+    m_d = new TargetToNativeConversionPrivate;
+    m_d->sourceTypeName = sourceTypeName;
+    m_d->sourceTypeCheck = sourceTypeCheck;
+    m_d->conversion = conversion;
+}
+
+CustomConversion::TargetToNativeConversion::~TargetToNativeConversion()
+{
+    delete m_d;
+}
+
+const TypeEntry* CustomConversion::TargetToNativeConversion::sourceType() const
+{
+    return m_d->sourceType;
+}
+
+void CustomConversion::TargetToNativeConversion::setSourceType(const TypeEntry* sourceType)
+{
+    m_d->sourceType = sourceType;
+}
+
+bool CustomConversion::TargetToNativeConversion::isCustomType() const
+{
+    return !(m_d->sourceType);
+}
+
+QString CustomConversion::TargetToNativeConversion::sourceTypeName() const
+{
+    return m_d->sourceTypeName;
+}
+
+QString CustomConversion::TargetToNativeConversion::sourceTypeCheck() const
+{
+    return m_d->sourceTypeCheck;
+}
+
+QString CustomConversion::TargetToNativeConversion::conversion() const
+{
+    return m_d->conversion;
+}
+
+void CustomConversion::TargetToNativeConversion::setConversion(const QString& conversion)
+{
+    m_d->conversion = conversion;
+}
diff --git a/ApiExtractor/typesystem.h b/ApiExtractor/typesystem.h
new file mode 100644
index 000000000..c915cd424
--- /dev/null
+++ b/ApiExtractor/typesystem.h
@@ -0,0 +1,1960 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef TYPESYSTEM_H
+#define TYPESYSTEM_H
+
+#include <QtCore/QHash>
+#include <QtCore/QString>
+#include <QtCore/QStringList>
+#include <QtCore/QMap>
+#include <QtCore/QDebug>
+#include "apiextractormacros.h"
+#include "include.h"
+
+//Used to identify the conversion rule to avoid break API
+#define TARGET_CONVERSION_RULE_FLAG "0"
+#define NATIVE_CONVERSION_RULE_FLAG "1"
+
+class Indentor;
+
+class AbstractMetaType;
+class QTextStream;
+
+class EnumTypeEntry;
+class FlagsTypeEntry;
+
+typedef QMap<int, QString> ArgumentMap;
+
+class TemplateInstance;
+
+namespace TypeSystem
+{
+enum Language {
+    NoLanguage          = 0x0000,
+    TargetLangCode      = 0x0001,
+    NativeCode          = 0x0002,
+    ShellCode           = 0x0004,
+    ShellDeclaration    = 0x0008,
+    PackageInitializer  = 0x0010,
+    DestructorFunction  = 0x0020,
+    Constructors        = 0x0040,
+    Interface           = 0x0080,
+
+    // masks
+    All                 = TargetLangCode
+    | NativeCode
+    | ShellCode
+    | ShellDeclaration
+    | PackageInitializer
+    | Constructors
+    | Interface
+    | DestructorFunction,
+
+    TargetLangAndNativeCode   = TargetLangCode | NativeCode
+};
+
+enum Ownership {
+    InvalidOwnership,
+    DefaultOwnership,
+    TargetLangOwnership,
+    CppOwnership
+};
+};
+
+struct APIEXTRACTOR_API ReferenceCount
+{
+    ReferenceCount()  {}
+    enum Action { // 0x01 - 0xff
+        Invalid     = 0x00,
+        Add         = 0x01,
+        AddAll      = 0x02,
+        Remove      = 0x04,
+        Set         = 0x08,
+        Ignore      = 0x10,
+
+        ActionsMask = 0xff,
+
+        Padding     = 0xffffffff
+    };
+
+    Action action;
+    QString varName;
+};
+
+struct APIEXTRACTOR_API ArgumentOwner
+{
+    enum Action {
+        Invalid     = 0x00,
+        Add         = 0x01,
+        Remove      = 0x02
+    };
+    enum {
+        InvalidIndex = -2,
+        ThisIndex = -1,
+        ReturnIndex = 0,
+        FirstArgumentIndex = 1
+    };
+    ArgumentOwner() : action(ArgumentOwner::Invalid), index(ArgumentOwner::InvalidIndex) {}
+
+    Action action;
+    int index;
+};
+
+class APIEXTRACTOR_API CodeSnipFragment
+{
+private:
+    QString m_code;
+    TemplateInstance *m_instance;
+
+public:
+    CodeSnipFragment(const QString &code)
+        : m_code(code),
+          m_instance(0) {}
+
+    CodeSnipFragment(TemplateInstance *instance)
+        : m_instance(instance) {}
+
+    QString code() const;
+};
+
+class APIEXTRACTOR_API CodeSnipAbstract
+{
+public:
+    QString code() const;
+
+    void addCode(const QString &code)
+    {
+        codeList.append(CodeSnipFragment(code));
+    }
+
+    void addTemplateInstance(TemplateInstance *ti)
+    {
+        codeList.append(CodeSnipFragment(ti));
+    }
+
+    QList<CodeSnipFragment> codeList;
+};
+
+class APIEXTRACTOR_API CustomFunction : public CodeSnipAbstract
+{
+public:
+    CustomFunction(const QString &n = QString()) : name(n) { }
+
+    QString name;
+    QString paramName;
+};
+
+class APIEXTRACTOR_API TemplateEntry : public CodeSnipAbstract
+{
+public:
+    TemplateEntry(const QString &name, double vr)
+            : m_name(name), m_version(vr)
+    {
+    };
+
+    QString name() const
+    {
+        return m_name;
+    };
+
+    double version() const
+    {
+        return m_version;
+    }
+
+private:
+    QString m_name;
+    double m_version;
+};
+
+typedef QHash<QString, TemplateEntry *> TemplateEntryHash;
+
+class APIEXTRACTOR_API TemplateInstance
+{
+public:
+    TemplateInstance(const QString &name, double vr)
+            : m_name(name), m_version(vr) {}
+
+    void addReplaceRule(const QString &name, const QString &value)
+    {
+        replaceRules[name] = value;
+    }
+
+    QString expandCode() const;
+
+    QString name() const
+    {
+        return m_name;
+    }
+
+    double version() const
+    {
+        return m_version;
+    }
+
+private:
+    const QString m_name;
+    double m_version;
+    QHash<QString, QString> replaceRules;
+};
+
+
+class APIEXTRACTOR_API CodeSnip : public CodeSnipAbstract
+{
+public:
+    enum Position {
+        Beginning,
+        End,
+        AfterThis,
+        // QtScript
+        Declaration,
+        PrototypeInitialization,
+        ConstructorInitialization,
+        Constructor,
+        Any
+    };
+
+    CodeSnip(double vr) : language(TypeSystem::TargetLangCode), version(vr) { }
+    CodeSnip(double vr, TypeSystem::Language lang) : language(lang), version(vr) { }
+
+    TypeSystem::Language language;
+    Position position;
+    ArgumentMap argumentMap;
+    double version;
+};
+typedef QList<CodeSnip> CodeSnipList;
+
+struct APIEXTRACTOR_API ArgumentModification
+{
+    ArgumentModification(int idx, double vr)
+            : removedDefaultExpression(false), removed(false),
+              noNullPointers(false), index(idx), version(vr) {}
+
+    // Should the default expression be removed?
+    uint removedDefaultExpression : 1;
+    uint removed : 1;
+    uint noNullPointers : 1;
+    uint resetAfterUse : 1;
+
+    // The index of this argument
+    int index;
+
+    // Reference count flags for this argument
+    QList<ReferenceCount> referenceCounts;
+
+    // The text given for the new type of the argument
+    QString modified_type;
+
+    QString replace_value;
+
+    // The code to be used to construct a return value when noNullPointers is true and
+    // the returned value is null. If noNullPointers is true and this string is
+    // empty, then the base class implementation will be used (or a default construction
+    // if there is no implementation)
+    QString nullPointerDefaultValue;
+
+    // The text of the new default expression of the argument
+    QString replacedDefaultExpression;
+
+    // The new definition of ownership for a specific argument
+    QHash<TypeSystem::Language, TypeSystem::Ownership> ownerships;
+
+    // Different conversion rules
+    CodeSnipList conversion_rules;
+
+    //QObject parent(owner) of this argument
+    ArgumentOwner owner;
+
+    //Api version
+    double version;
+
+    //New name
+    QString renamed_to;
+};
+
+struct APIEXTRACTOR_API Modification
+{
+    enum Modifiers {
+        Private =               0x0001,
+        Protected =             0x0002,
+        Public =                0x0003,
+        Friendly =              0x0004,
+        AccessModifierMask =    0x000f,
+
+        Final =                 0x0010,
+        NonFinal =              0x0020,
+        FinalMask =             Final | NonFinal,
+
+        Readable =              0x0100,
+        Writable =              0x0200,
+
+        CodeInjection =         0x1000,
+        Rename =                0x2000,
+        Deprecated =            0x4000,
+        ReplaceExpression =     0x8000,
+        VirtualSlot =          0x10000 | NonFinal
+    };
+
+    Modification() : modifiers(0), removal(TypeSystem::NoLanguage) { }
+
+    bool isAccessModifier() const
+    {
+        return modifiers & AccessModifierMask;
+    }
+    Modifiers accessModifier() const
+    {
+        return Modifiers(modifiers & AccessModifierMask);
+    }
+    bool isPrivate() const
+    {
+        return accessModifier() == Private;
+    }
+    bool isProtected() const
+    {
+        return accessModifier() == Protected;
+    }
+    bool isPublic() const
+    {
+        return accessModifier() == Public;
+    }
+    bool isFriendly() const
+    {
+        return accessModifier() == Friendly;
+    }
+    bool isFinal() const
+    {
+        return modifiers & Final;
+    }
+    bool isNonFinal() const
+    {
+        return modifiers & NonFinal;
+    }
+    bool isVirtualSlot() const
+    {
+        return (modifiers & VirtualSlot) == VirtualSlot;
+    }
+    QString accessModifierString() const;
+
+    bool isDeprecated() const
+    {
+        return modifiers & Deprecated;
+    }
+
+    void setRenamedTo(const QString &name)
+    {
+        renamedToName = name;
+    }
+    QString renamedTo() const
+    {
+        return renamedToName;
+    }
+    bool isRenameModifier() const
+    {
+        return modifiers & Rename;
+    }
+
+    bool isRemoveModifier() const
+    {
+        return removal != TypeSystem::NoLanguage;
+    }
+
+    uint modifiers;
+    QString renamedToName;
+    TypeSystem::Language removal;
+};
+
+struct APIEXTRACTOR_API FunctionModification: public Modification
+{
+    FunctionModification(double vr) : m_thread(false), m_allowThread(false), m_version(vr) {}
+
+    bool isCodeInjection() const
+    {
+        return modifiers & CodeInjection;
+    }
+    void setIsThread(bool flag)
+    {
+        m_thread = flag;
+    }
+    bool isThread() const
+    {
+        return m_thread;
+    }
+    bool allowThread() const
+    {
+        return m_allowThread;
+    }
+    void setAllowThread(bool allow)
+    {
+        m_allowThread = allow;
+    }
+    double version() const
+    {
+        return m_version;
+    }
+
+    bool operator!=(const FunctionModification& other) const;
+    bool operator==(const FunctionModification& other) const;
+
+
+    QString toString() const;
+
+    QString signature;
+    QString association;
+    CodeSnipList snips;
+
+    QList<ArgumentModification> argument_mods;
+
+private:
+    FunctionModification() {}
+
+    bool m_thread;
+    bool m_allowThread;
+    double m_version;
+
+
+};
+typedef QList<FunctionModification> FunctionModificationList;
+
+struct APIEXTRACTOR_API FieldModification: public Modification
+{
+    bool isReadable() const
+    {
+        return modifiers & Readable;
+    }
+    bool isWritable() const
+    {
+        return modifiers & Writable;
+    }
+
+    QString name;
+};
+
+typedef QList<FieldModification> FieldModificationList;
+
+/**
+*   \internal
+*   Struct used to store information about functions added by the typesystem.
+*   This info will be used later to create a fake AbstractMetaFunction which
+*   will be inserted into the right AbstractMetaClass.
+*/
+struct APIEXTRACTOR_API AddedFunction
+{
+    /// Function access types.
+    enum Access {
+        Protected = 0x1,
+        Public =    0x2
+    };
+
+    /**
+    *   \internal
+    *   Internal struct used to store information about arguments and return type of the
+    *   functions added by the type system. This information is later used to create
+    *   AbstractMetaType and AbstractMetaArgument for the AbstractMetaFunctions.
+    */
+    struct TypeInfo {
+        TypeInfo() : isConstant(false), indirections(0), isReference(false) {}
+        QString name;
+        bool isConstant;
+        int indirections;
+        bool isReference;
+        QString defaultValue;
+    };
+
+    /// Creates a new AddedFunction with a signature and a return type.
+    AddedFunction(QString signature, QString returnType, double vr);
+
+    /// Returns the function name.
+    QString name() const
+    {
+        return m_name;
+    }
+
+    /// Set the function access type.
+    void setAccess(Access access)
+    {
+        m_access = access;
+    }
+
+    /// Returns the function access type.
+    Access access() const
+    {
+        return m_access;
+    }
+
+    /// Returns the function return type.
+    TypeInfo returnType() const
+    {
+        return m_returnType;
+    }
+
+    /// Returns a list of argument type infos.
+    QList<TypeInfo> arguments() const
+    {
+        return m_arguments;
+    }
+
+    /// Returns true if this is a constant method.
+    bool isConstant() const
+    {
+        return m_isConst;
+    }
+
+    /// Set this method static.
+    void setStatic(bool value)
+    {
+        m_isStatic = value;
+    }
+
+    /// Returns true if this is a static method.
+    bool isStatic() const
+    {
+        return m_isStatic;
+    }
+
+    double version() const
+    {
+        return m_version;
+    }
+private:
+    QString m_name;
+    Access m_access;
+    QList<TypeInfo> m_arguments;
+    TypeInfo m_returnType;
+    bool m_isConst;
+    bool m_isStatic;
+    double m_version;
+};
+typedef QList<AddedFunction> AddedFunctionList;
+
+struct APIEXTRACTOR_API ExpensePolicy
+{
+    ExpensePolicy() : limit(-1) {}
+    int limit;
+    QString cost;
+    bool isValid() const
+    {
+        return limit >= 0;
+    }
+};
+
+class InterfaceTypeEntry;
+class ObjectTypeEntry;
+
+class APIEXTRACTOR_API DocModification
+{
+public:
+    enum Mode {
+        Append,
+        Prepend,
+        Replace,
+        XPathReplace
+    };
+
+    DocModification(const QString& xpath, const QString& signature, double vr)
+            : format(TypeSystem::NativeCode), m_mode(XPathReplace),
+              m_xpath(xpath), m_signature(signature), m_version(vr) {}
+    DocModification(Mode mode, const QString& signature, double vr)
+            : m_mode(mode), m_signature(signature), m_version(vr) {}
+
+    void setCode(const QString& code)
+    {
+        m_code = code;
+    }
+    QString code() const
+    {
+        return m_code;
+    }
+    QString xpath() const
+    {
+        return m_xpath;
+    }
+    QString signature() const
+    {
+        return m_signature;
+    }
+    Mode mode() const
+    {
+        return m_mode;
+    }
+    double version() const
+    {
+        return m_version;
+    }
+
+    TypeSystem::Language format;
+
+private:
+    Mode m_mode;
+    QString m_code;
+    QString m_xpath;
+    QString m_signature;
+    double m_version;
+};
+
+typedef QList<DocModification> DocModificationList;
+
+class CustomConversion;
+
+class APIEXTRACTOR_API TypeEntry
+{
+public:
+    enum Type {
+        PrimitiveType,
+        VoidType,
+        VarargsType,
+        FlagsType,
+        EnumType,
+        EnumValue,
+        TemplateArgumentType,
+        ThreadType,
+        BasicValueType,
+        StringType,
+        ContainerType,
+        InterfaceType,
+        ObjectType,
+        NamespaceType,
+        VariantType,
+        JObjectWrapperType,
+        CharType,
+        ArrayType,
+        TypeSystemType,
+        CustomType,
+        TargetLangType,
+        FunctionType
+    };
+
+    enum CodeGeneration {
+        GenerateTargetLang      = 0x0001,
+        GenerateCpp             = 0x0002,
+        GenerateForSubclass     = 0x0004,
+
+        GenerateNothing         = 0,
+        GenerateAll             = 0xffff,
+        GenerateCode            = GenerateTargetLang | GenerateCpp
+    };
+
+    TypeEntry(const QString &name, Type t, double vr)
+            : m_name(name),
+              m_type(t),
+              m_codeGeneration(GenerateAll),
+              m_preferredConversion(true),
+              m_stream(false),
+              m_version(vr)
+    {
+    };
+
+    virtual ~TypeEntry();
+
+    Type type() const
+    {
+        return m_type;
+    }
+    bool isPrimitive() const
+    {
+        return m_type == PrimitiveType;
+    }
+    bool isEnum() const
+    {
+        return m_type == EnumType;
+    }
+    bool isFlags() const
+    {
+        return m_type == FlagsType;
+    }
+    bool isInterface() const
+    {
+        return m_type == InterfaceType;
+    }
+    bool isObject() const
+    {
+        return m_type == ObjectType;
+    }
+    bool isString() const
+    {
+        return m_type == StringType;
+    }
+    bool isChar() const
+    {
+        return m_type == CharType;
+    }
+    bool isNamespace() const
+    {
+        return m_type == NamespaceType;
+    }
+    bool isContainer() const
+    {
+        return m_type == ContainerType;
+    }
+    bool isVariant() const
+    {
+        return m_type == VariantType;
+    }
+    bool isJObjectWrapper() const
+    {
+        return m_type == JObjectWrapperType;
+    }
+    bool isArray() const
+    {
+        return m_type == ArrayType;
+    }
+    bool isTemplateArgument() const
+    {
+        return m_type == TemplateArgumentType;
+    }
+    bool isVoid() const
+    {
+        return m_type == VoidType;
+    }
+    bool isVarargs() const
+    {
+        return m_type == VarargsType;
+    }
+    bool isThread() const
+    {
+        return m_type == ThreadType;
+    }
+    bool isCustom() const
+    {
+        return m_type == CustomType;
+    }
+    bool isBasicValue() const
+    {
+        return m_type == BasicValueType;
+    }
+    bool isTypeSystem() const
+    {
+        return m_type == TypeSystemType;
+    }
+    bool isFunction() const
+    {
+        return m_type == FunctionType;
+    }
+    bool isEnumValue() const
+    {
+        return m_type == EnumValue;
+    }
+
+    virtual bool preferredConversion() const
+    {
+        return m_preferredConversion;
+    }
+    virtual void setPreferredConversion(bool b)
+    {
+        m_preferredConversion = b;
+    }
+
+    bool stream() const
+    {
+        return m_stream;
+    }
+
+    void setStream(bool b)
+    {
+        m_stream = b;
+    }
+
+    // The type's name in C++, fully qualified
+    QString name() const
+    {
+        return m_name;
+    }
+
+    uint codeGeneration() const
+    {
+        return m_codeGeneration;
+    }
+    void setCodeGeneration(uint cg)
+    {
+        m_codeGeneration = cg;
+    }
+
+    // Returns true if code must be generated for this entry,
+    // it will return false in case of types coming from typesystems
+    // included for reference only.
+    // NOTE: 'GenerateForSubclass' means 'generate="no"'
+    //       on 'load-typesystem' tag
+    inline bool generateCode() const
+    {
+        return m_codeGeneration != TypeEntry::GenerateForSubclass
+               && m_codeGeneration != TypeEntry::GenerateNothing;
+    }
+
+    virtual QString qualifiedCppName() const
+    {
+        return m_name;
+    }
+
+    /**
+     *   Its type's name in target language API
+     *   The target language API name represents how this type is
+     *   referred on low level code for the target language.
+     *   Examples: for Java this would be a JNI name, for Python
+     *   it should represent the CPython type name.
+     *   /return string representing the target language API name
+     *   for this type entry
+     */
+    virtual QString targetLangApiName() const
+    {
+        return m_name;
+    }
+
+    // The type's name in TargetLang
+    virtual QString targetLangName() const
+    {
+        return m_name;
+    }
+
+    // The type to lookup when converting to TargetLang
+    virtual QString lookupName() const
+    {
+        return targetLangName();
+    }
+
+    // The package
+    virtual QString targetLangPackage() const
+    {
+        return QString();
+    }
+
+    virtual QString qualifiedTargetLangName() const
+    {
+        QString pkg = targetLangPackage();
+        if (pkg.isEmpty())
+            return targetLangName();
+        return pkg + '.' + targetLangName();
+    }
+
+    virtual InterfaceTypeEntry *designatedInterface() const
+    {
+        return 0;
+    }
+
+    void setCustomConstructor(const CustomFunction &func)
+    {
+        m_customConstructor = func;
+    }
+    CustomFunction customConstructor() const
+    {
+        return m_customConstructor;
+    }
+
+    void setCustomDestructor(const CustomFunction &func)
+    {
+        m_customDestructor = func;
+    }
+    CustomFunction customDestructor() const
+    {
+        return m_customDestructor;
+    }
+
+    virtual bool isValue() const
+    {
+        return false;
+    }
+    virtual bool isComplex() const
+    {
+        return false;
+    }
+
+    virtual bool isNativeIdBased() const
+    {
+        return false;
+    }
+
+    CodeSnipList codeSnips() const;
+    void setCodeSnips(const CodeSnipList &codeSnips)
+    {
+        m_codeSnips = codeSnips;
+    }
+    void addCodeSnip(const CodeSnip &codeSnip)
+    {
+        m_codeSnips << codeSnip;
+    }
+
+    void setDocModification(const DocModificationList& docMods)
+    {
+        m_docModifications << docMods;
+    }
+    DocModificationList docModifications() const
+    {
+        return m_docModifications;
+    }
+
+    IncludeList extraIncludes() const
+    {
+        return m_extraIncludes;
+    }
+    void setExtraIncludes(const IncludeList &includes)
+    {
+        m_extraIncludes = includes;
+    }
+    void addExtraInclude(const Include &include)
+    {
+        if (!m_includesUsed.value(include.name(), false)) {
+            m_extraIncludes << include;
+            m_includesUsed[include.name()] = true;
+        }
+    }
+
+    Include include() const
+    {
+        return m_include;
+    }
+    void setInclude(const Include &inc)
+    {
+        m_include = inc;
+    }
+
+    // Replace conversionRule arg to CodeSnip in future version
+    /// Set the type convertion rule
+    void setConversionRule(const QString& conversionRule)
+    {
+        m_conversionRule = conversionRule;
+    }
+
+    /// Returns the type convertion rule
+    QString conversionRule() const
+    {
+        //skip conversions flag
+        return m_conversionRule.mid(1);
+    }
+
+    /// Returns true if there are any conversiton rule for this type, false otherwise.
+    bool hasConversionRule() const
+    {
+        return !m_conversionRule.isEmpty();
+    }
+
+    double version() const
+    {
+        return m_version;
+    }
+
+    /// TODO-CONVERTER: mark as deprecated
+    bool hasNativeConversionRule() const
+    {
+        return m_conversionRule.startsWith(NATIVE_CONVERSION_RULE_FLAG);
+    }
+
+    /// TODO-CONVERTER: mark as deprecated
+    bool hasTargetConversionRule() const
+    {
+        return m_conversionRule.startsWith(TARGET_CONVERSION_RULE_FLAG);
+    }
+
+    bool isCppPrimitive() const;
+
+    bool hasCustomConversion() const;
+    void setCustomConversion(CustomConversion* customConversion);
+    CustomConversion* customConversion() const;
+private:
+    QString m_name;
+    Type m_type;
+    uint m_codeGeneration;
+    CustomFunction m_customConstructor;
+    CustomFunction m_customDestructor;
+    bool m_preferredConversion;
+    CodeSnipList m_codeSnips;
+    DocModificationList m_docModifications;
+    IncludeList m_extraIncludes;
+    Include m_include;
+    QHash<QString, bool> m_includesUsed;
+    QString m_conversionRule;
+    bool m_stream;
+    double m_version;
+};
+typedef QHash<QString, QList<TypeEntry *> > TypeEntryHash;
+typedef QHash<QString, TypeEntry *> SingleTypeEntryHash;
+
+
+class APIEXTRACTOR_API TypeSystemTypeEntry : public TypeEntry
+{
+public:
+    TypeSystemTypeEntry(const QString &name, double vr)
+            : TypeEntry(name, TypeSystemType, vr)
+    {
+    };
+};
+
+class APIEXTRACTOR_API VoidTypeEntry : public TypeEntry
+{
+public:
+    VoidTypeEntry() : TypeEntry("void", VoidType, 0) { }
+};
+
+class APIEXTRACTOR_API VarargsTypeEntry : public TypeEntry
+{
+public:
+    VarargsTypeEntry() : TypeEntry("...", VarargsType, 0) { }
+};
+
+class APIEXTRACTOR_API TemplateArgumentEntry : public TypeEntry
+{
+public:
+    TemplateArgumentEntry(const QString &name, double vr)
+            : TypeEntry(name, TemplateArgumentType, vr), m_ordinal(0)
+    {
+    }
+
+    int ordinal() const
+    {
+        return m_ordinal;
+    }
+    void setOrdinal(int o)
+    {
+        m_ordinal = o;
+    }
+
+private:
+    int m_ordinal;
+};
+
+class APIEXTRACTOR_API ArrayTypeEntry : public TypeEntry
+{
+public:
+    ArrayTypeEntry(const TypeEntry *nested_type, double vr)
+            : TypeEntry("Array", ArrayType, vr), m_nestedType(nested_type)
+    {
+        Q_ASSERT(m_nestedType);
+    }
+
+    void setNestedTypeEntry(TypeEntry *nested)
+    {
+        m_nestedType = nested;
+    }
+    const TypeEntry *nestedTypeEntry() const
+    {
+        return m_nestedType;
+    }
+
+    QString targetLangName() const
+    {
+        return m_nestedType->targetLangName() + "[]";
+    }
+    QString targetLangApiName() const
+    {
+        if (m_nestedType->isPrimitive())
+            return m_nestedType->targetLangApiName() + "Array";
+        else
+            return "jobjectArray";
+    }
+
+private:
+    const TypeEntry *m_nestedType;
+};
+
+
+class APIEXTRACTOR_API PrimitiveTypeEntry : public TypeEntry
+{
+public:
+    PrimitiveTypeEntry(const QString &name, double vr)
+            : TypeEntry(name, PrimitiveType, vr),
+              m_preferredConversion(true),
+              m_preferredTargetLangType(true),
+              m_aliasedTypeEntry(0)
+    {
+    }
+
+    QString targetLangName() const
+    {
+        return m_targetLangName;
+    }
+    void setTargetLangName(const QString &targetLangName)
+    {
+        m_targetLangName  = targetLangName;
+    }
+
+    QString targetLangApiName() const
+    {
+        return m_targetLangApiName;
+    }
+    void setTargetLangApiName(const QString &targetLangApiName)
+    {
+        m_targetLangApiName = targetLangApiName;
+    }
+
+    QString defaultConstructor() const
+    {
+        return m_defaultConstructor;
+    }
+    void setDefaultConstructor(const QString& defaultConstructor)
+    {
+        m_defaultConstructor = defaultConstructor;
+    }
+    bool hasDefaultConstructor() const
+    {
+        return !m_defaultConstructor.isEmpty();
+    }
+
+    /**
+     *   The PrimitiveTypeEntry pointed by this type entry if it
+     *   represents an alias (i.e. a typedef).
+     *   /return the type pointed by the alias, or a null pointer
+     *   if the current object is not an alias
+     */
+    PrimitiveTypeEntry* aliasedTypeEntry() const { return m_aliasedTypeEntry; }
+
+    /**
+     *   Defines type aliased by this entry.
+     *   /param aliasedTypeEntry type aliased by this entry
+     */
+    void setAliasedTypeEntry(PrimitiveTypeEntry* aliasedTypeEntry)
+    {
+        m_aliasedTypeEntry = aliasedTypeEntry;
+    }
+
+    /**
+     *   Finds the most basic primitive type that the typedef represents,
+     *   i.e. a type that is not an alias.
+     *   /return the most basic non-aliased primitive type represented
+     *   by this typedef
+     */
+    PrimitiveTypeEntry* basicAliasedTypeEntry() const;
+
+    virtual bool preferredConversion() const
+    {
+        return m_preferredConversion;
+    }
+    virtual void setPreferredConversion(bool b)
+    {
+        m_preferredConversion = b;
+    }
+
+    virtual bool preferredTargetLangType() const
+    {
+        return m_preferredTargetLangType;
+    }
+    virtual void setPreferredTargetLangType(bool b)
+    {
+        m_preferredTargetLangType = b;
+    }
+
+    void setTargetLangPackage(const QString& package);
+    QString targetLangPackage() const;
+private:
+    QString m_targetLangName;
+    QString m_targetLangApiName;
+    QString m_defaultConstructor;
+    uint m_preferredConversion : 1;
+    uint m_preferredTargetLangType : 1;
+    PrimitiveTypeEntry* m_aliasedTypeEntry;
+};
+
+typedef QList<const PrimitiveTypeEntry*> PrimitiveTypeEntryList;
+
+struct APIEXTRACTOR_API EnumValueRedirection
+{
+    EnumValueRedirection(const QString &rej, const QString &us)
+            : rejected(rej),
+            used(us)
+    {
+    }
+    QString rejected;
+    QString used;
+};
+
+class APIEXTRACTOR_API EnumTypeEntry : public TypeEntry
+{
+public:
+    EnumTypeEntry(const QString &nspace, const QString &enumName, double vr)
+            : TypeEntry(nspace.isEmpty() ? enumName : nspace + QLatin1String("::") + enumName,
+                        EnumType, vr),
+            m_flags(0),
+            m_extensible(false)
+    {
+        m_qualifier = nspace;
+        m_targetLangName = enumName;
+    }
+
+    QString targetLangPackage() const
+    {
+        return m_packageName;
+    }
+    void setTargetLangPackage(const QString &package)
+    {
+        m_packageName = package;
+    }
+
+    QString targetLangName() const
+    {
+        return m_targetLangName;
+    }
+    QString targetLangQualifier() const;
+    QString qualifiedTargetLangName() const
+    {
+        QString qualifiedName;
+        QString pkg = targetLangPackage();
+        QString qualifier = targetLangQualifier();
+
+        if (!pkg.isEmpty())
+            qualifiedName += pkg + '.';
+        if (!qualifier.isEmpty())
+            qualifiedName += qualifier + '.';
+        qualifiedName += targetLangName();
+
+        return qualifiedName;
+    }
+
+    QString targetLangApiName() const;
+
+    QString qualifier() const
+    {
+        return m_qualifier;
+    }
+    void setQualifier(const QString &q)
+    {
+        m_qualifier = q;
+    }
+
+    virtual bool preferredConversion() const
+    {
+        return false;
+    }
+
+    bool isBoundsChecked() const
+    {
+        return m_lowerBound.isEmpty() && m_upperBound.isEmpty();
+    }
+
+    QString upperBound() const
+    {
+        return m_upperBound;
+    }
+    void setUpperBound(const QString &bound)
+    {
+        m_upperBound = bound;
+    }
+
+    QString lowerBound() const
+    {
+        return m_lowerBound;
+    }
+    void setLowerBound(const QString &bound)
+    {
+        m_lowerBound = bound;
+    }
+
+    void setFlags(FlagsTypeEntry *flags)
+    {
+        m_flags = flags;
+    }
+    FlagsTypeEntry *flags() const
+    {
+        return m_flags;
+    }
+
+    bool isExtensible() const
+    {
+        return m_extensible;
+    }
+    void setExtensible(bool is)
+    {
+        m_extensible = is;
+    }
+
+    bool isEnumValueRejected(const QString &name)
+    {
+        return m_rejectedEnums.contains(name);
+    }
+    void addEnumValueRejection(const QString &name)
+    {
+        m_rejectedEnums << name;
+    }
+    QStringList enumValueRejections() const
+    {
+        return m_rejectedEnums;
+    }
+
+    void addEnumValueRedirection(const QString &rejected, const QString &usedValue);
+    QString enumValueRedirection(const QString &value) const;
+
+    bool forceInteger() const
+    {
+        return m_forceInteger;
+    }
+    void setForceInteger(bool force)
+    {
+        m_forceInteger = force;
+    }
+
+    bool isAnonymous() const
+    {
+        return m_anonymous;
+    }
+    void setAnonymous(bool anonymous)
+    {
+        m_anonymous = anonymous;
+    }
+
+private:
+    QString m_packageName;
+    QString m_qualifier;
+    QString m_targetLangName;
+
+    QString m_lowerBound;
+    QString m_upperBound;
+
+    QStringList m_rejectedEnums;
+    QList<EnumValueRedirection> m_enumRedirections;
+
+    FlagsTypeEntry *m_flags;
+
+    bool m_extensible;
+    bool m_forceInteger;
+    bool m_anonymous;
+};
+
+class APIEXTRACTOR_API EnumValueTypeEntry : public TypeEntry
+{
+public:
+    EnumValueTypeEntry(const QString& name, const QString& value, const EnumTypeEntry* enclosingEnum, double vr)
+        : TypeEntry(name, TypeEntry::EnumValue, vr), m_value(value), m_enclosingEnum(enclosingEnum)
+    {
+    }
+
+    QString value() const { return m_value; }
+    const EnumTypeEntry* enclosingEnum() const { return m_enclosingEnum; }
+private:
+    QString m_value;
+    const EnumTypeEntry* m_enclosingEnum;
+};
+
+class APIEXTRACTOR_API FlagsTypeEntry : public TypeEntry
+{
+public:
+    FlagsTypeEntry(const QString &name, double vr) : TypeEntry(name, FlagsType, vr), m_enum(0)
+    {
+    }
+
+    QString qualifiedTargetLangName() const;
+    QString targetLangName() const
+    {
+        return m_targetLangName;
+    }
+    QString targetLangApiName() const;
+    virtual bool preferredConversion() const
+    {
+        return false;
+    }
+
+    QString originalName() const
+    {
+        return m_originalName;
+    }
+    void setOriginalName(const QString &s)
+    {
+        m_originalName = s;
+    }
+
+    QString flagsName() const
+    {
+        return m_targetLangName;
+    }
+    void setFlagsName(const QString &name)
+    {
+        m_targetLangName = name;
+    }
+
+    bool forceInteger() const
+    {
+        return m_enum->forceInteger();
+    }
+
+    EnumTypeEntry *originator() const
+    {
+        return m_enum;
+    }
+    void setOriginator(EnumTypeEntry *e)
+    {
+        m_enum = e;
+    }
+
+    QString targetLangPackage() const
+    {
+        return m_enum->targetLangPackage();
+    }
+
+private:
+    QString m_originalName;
+    QString m_targetLangName;
+    EnumTypeEntry *m_enum;
+};
+
+
+class APIEXTRACTOR_API ComplexTypeEntry : public TypeEntry
+{
+public:
+    enum TypeFlag {
+        ForceAbstract      = 0x1,
+        DeleteInMainThread = 0x2,
+        Deprecated         = 0x4
+    };
+    typedef QFlags<TypeFlag> TypeFlags;
+
+    enum CopyableFlag {
+        CopyableSet,
+        NonCopyableSet,
+        Unknown
+    };
+
+    ComplexTypeEntry(const QString &name, Type t, double vr)
+            : TypeEntry(QString(name).replace(".*::", ""), t, vr),
+            m_qualifiedCppName(name),
+            m_qobject(false),
+            m_polymorphicBase(false),
+            m_genericClass(false),
+            m_typeFlags(0),
+            m_copyableFlag(Unknown),
+            m_hashFunction(""),
+            m_baseContainerType(0)
+    {
+    }
+
+    bool isComplex() const
+    {
+        return true;
+    }
+
+    ComplexTypeEntry *copy() const
+    {
+        ComplexTypeEntry *centry = new ComplexTypeEntry(name(), type(), version());
+        centry->setInclude(include());
+        centry->setExtraIncludes(extraIncludes());
+        centry->setAddedFunctions(addedFunctions());
+        centry->setFunctionModifications(functionModifications());
+        centry->setFieldModifications(fieldModifications());
+        centry->setQObject(isQObject());
+        centry->setDefaultSuperclass(defaultSuperclass());
+        centry->setCodeSnips(codeSnips());
+        centry->setTargetLangPackage(targetLangPackage());
+        centry->setBaseContainerType(baseContainerType());
+        centry->setDefaultConstructor(defaultConstructor());
+
+        return centry;
+    }
+
+    void setLookupName(const QString &name)
+    {
+        m_lookupName = name;
+    }
+
+    virtual QString lookupName() const
+    {
+        return m_lookupName.isEmpty() ? targetLangName() : m_lookupName;
+    }
+
+    QString targetLangApiName() const;
+
+    void setTypeFlags(TypeFlags flags)
+    {
+        m_typeFlags = flags;
+    }
+
+    TypeFlags typeFlags() const
+    {
+        return m_typeFlags;
+    }
+
+    FunctionModificationList functionModifications() const
+    {
+        return m_functionMods;
+    }
+    void setFunctionModifications(const FunctionModificationList &functionModifications)
+    {
+        m_functionMods = functionModifications;
+    }
+    void addFunctionModification(const FunctionModification &functionModification)
+    {
+        m_functionMods << functionModification;
+    }
+    FunctionModificationList functionModifications(const QString &signature) const;
+
+    AddedFunctionList addedFunctions() const
+    {
+        return m_addedFunctions;
+    }
+    void setAddedFunctions(const AddedFunctionList &addedFunctions)
+    {
+        m_addedFunctions = addedFunctions;
+    }
+    void addNewFunction(const AddedFunction &addedFunction)
+    {
+        m_addedFunctions << addedFunction;
+    }
+
+    FieldModification fieldModification(const QString &name) const;
+    void setFieldModifications(const FieldModificationList &mods)
+    {
+        m_fieldMods = mods;
+    }
+    FieldModificationList fieldModifications() const
+    {
+        return m_fieldMods;
+    }
+
+    QString targetLangPackage() const
+    {
+        return m_package;
+    }
+    void setTargetLangPackage(const QString &package)
+    {
+        m_package = package;
+    }
+
+    bool isQObject() const
+    {
+        return m_qobject;
+    }
+    void setQObject(bool qobject)
+    {
+        m_qobject = qobject;
+    }
+
+    QString defaultSuperclass() const
+    {
+        return m_defaultSuperclass;
+    }
+    void setDefaultSuperclass(const QString &sc)
+    {
+        m_defaultSuperclass = sc;
+    }
+
+    virtual QString qualifiedCppName() const
+    {
+        return m_qualifiedCppName;
+    }
+
+
+    void setIsPolymorphicBase(bool on)
+    {
+        m_polymorphicBase = on;
+    }
+    bool isPolymorphicBase() const
+    {
+        return m_polymorphicBase;
+    }
+
+    void setPolymorphicIdValue(const QString &value)
+    {
+        m_polymorphicIdValue = value;
+    }
+    QString polymorphicIdValue() const
+    {
+        return m_polymorphicIdValue;
+    }
+
+    void setHeldType(const QString &value)
+    {
+        m_heldTypeValue = value;
+    }
+    QString heldTypeValue() const
+    {
+        return m_heldTypeValue;
+    }
+
+
+    void setExpensePolicy(const ExpensePolicy &policy)
+    {
+        m_expensePolicy = policy;
+    }
+    const ExpensePolicy &expensePolicy() const
+    {
+        return m_expensePolicy;
+    }
+
+    QString targetType() const
+    {
+        return m_targetType;
+    }
+    void setTargetType(const QString &code)
+    {
+        m_targetType = code;
+    }
+
+    QString targetLangName() const
+    {
+        return m_targetLangName.isEmpty()
+               ? TypeEntry::targetLangName()
+               : m_targetLangName;
+    }
+    void setTargetLangName(const QString &name)
+    {
+        m_targetLangName = name;
+    }
+
+    bool isGenericClass() const
+    {
+        return m_genericClass;
+    }
+    void setGenericClass(bool isGeneric)
+    {
+        m_genericClass = isGeneric;
+    }
+
+    CopyableFlag copyable() const
+    {
+        return m_copyableFlag;
+    }
+    void setCopyable(CopyableFlag flag)
+    {
+        m_copyableFlag = flag;
+    }
+
+    QString hashFunction() const
+    {
+        return m_hashFunction;
+    }
+    void setHashFunction(QString hashFunction)
+    {
+        m_hashFunction = hashFunction;
+    }
+
+    void setBaseContainerType(const ComplexTypeEntry *baseContainer)
+    {
+        m_baseContainerType = baseContainer;
+    }
+
+    const ComplexTypeEntry* baseContainerType() const
+    {
+        return m_baseContainerType;
+    }
+
+    QString defaultConstructor() const;
+    void setDefaultConstructor(const QString& defaultConstructor);
+    bool hasDefaultConstructor() const;
+
+private:
+    AddedFunctionList m_addedFunctions;
+    FunctionModificationList m_functionMods;
+    FieldModificationList m_fieldMods;
+    QString m_package;
+    QString m_defaultSuperclass;
+    QString m_qualifiedCppName;
+    QString m_targetLangName;
+
+    uint m_qobject : 1;
+    uint m_polymorphicBase : 1;
+    uint m_genericClass : 1;
+
+    QString m_polymorphicIdValue;
+    QString m_heldTypeValue;
+    QString m_lookupName;
+    QString m_targetType;
+    ExpensePolicy m_expensePolicy;
+    TypeFlags m_typeFlags;
+    CopyableFlag m_copyableFlag;
+    QString m_hashFunction;
+
+    const ComplexTypeEntry* m_baseContainerType;
+};
+
+class APIEXTRACTOR_API ContainerTypeEntry : public ComplexTypeEntry
+{
+public:
+    enum Type {
+        NoContainer,
+        ListContainer,
+        StringListContainer,
+        LinkedListContainer,
+        VectorContainer,
+        StackContainer,
+        QueueContainer,
+        SetContainer,
+        MapContainer,
+        MultiMapContainer,
+        HashContainer,
+        MultiHashContainer,
+        PairContainer,
+    };
+
+    ContainerTypeEntry(const QString &name, Type type, double vr)
+        : ComplexTypeEntry(name, ContainerType, vr), m_type(type)
+    {
+        setCodeGeneration(GenerateForSubclass);
+    }
+
+    Type type() const
+    {
+        return m_type;
+    }
+
+    QString typeName() const;
+    QString targetLangName() const;
+    QString targetLangPackage() const;
+    QString qualifiedCppName() const;
+
+    static Type containerTypeFromString(QString typeName)
+    {
+        static QHash<QString, Type> m_stringToContainerType;
+        if (m_stringToContainerType.isEmpty()) {
+            m_stringToContainerType["list"] = ListContainer;
+            m_stringToContainerType["string-list"] = StringListContainer;
+            m_stringToContainerType["linked-list"] = LinkedListContainer;
+            m_stringToContainerType["vector"] = VectorContainer;
+            m_stringToContainerType["stack"] = StackContainer;
+            m_stringToContainerType["queue"] = QueueContainer;
+            m_stringToContainerType["set"] = SetContainer;
+            m_stringToContainerType["map"] = MapContainer;
+            m_stringToContainerType["multi-map"] = MultiMapContainer;
+            m_stringToContainerType["hash"] = HashContainer;
+            m_stringToContainerType["multi-hash"] = MultiHashContainer;
+            m_stringToContainerType["pair"] = PairContainer;
+        }
+        return m_stringToContainerType.value(typeName, NoContainer);
+    }
+
+private:
+    Type m_type;
+};
+
+typedef QList<const ContainerTypeEntry*> ContainerTypeEntryList;
+
+class APIEXTRACTOR_API NamespaceTypeEntry : public ComplexTypeEntry
+{
+public:
+    NamespaceTypeEntry(const QString &name, double vr) : ComplexTypeEntry(name, NamespaceType, vr) { }
+};
+
+
+class APIEXTRACTOR_API ValueTypeEntry : public ComplexTypeEntry
+{
+public:
+    ValueTypeEntry(const QString &name, double vr) : ComplexTypeEntry(name, BasicValueType, vr) { }
+
+    bool isValue() const
+    {
+        return true;
+    }
+
+    virtual bool isNativeIdBased() const
+    {
+        return true;
+    }
+
+protected:
+    ValueTypeEntry(const QString &name, Type t, double vr) : ComplexTypeEntry(name, t, vr) { }
+};
+
+
+class APIEXTRACTOR_API StringTypeEntry : public ValueTypeEntry
+{
+public:
+    StringTypeEntry(const QString &name, double vr)
+            : ValueTypeEntry(name, StringType, vr)
+    {
+        setCodeGeneration(GenerateNothing);
+    }
+
+    QString targetLangApiName() const;
+    QString targetLangName() const;
+    QString targetLangPackage() const;
+
+    virtual bool isNativeIdBased() const
+    {
+        return false;
+    }
+};
+
+class APIEXTRACTOR_API CharTypeEntry : public ValueTypeEntry
+{
+public:
+    CharTypeEntry(const QString &name, double vr) : ValueTypeEntry(name, CharType, vr)
+    {
+        setCodeGeneration(GenerateNothing);
+    }
+
+    QString targetLangApiName() const;
+    QString targetLangName() const;
+    QString targetLangPackage() const
+    {
+        return QString();
+    }
+
+    virtual bool isNativeIdBased() const
+    {
+        return false;
+    }
+};
+
+class APIEXTRACTOR_API VariantTypeEntry: public ValueTypeEntry
+{
+public:
+    VariantTypeEntry(const QString &name, double vr) : ValueTypeEntry(name, VariantType, vr) { }
+
+    QString targetLangApiName() const;
+    QString targetLangName() const;
+    QString targetLangPackage() const;
+
+    virtual bool isNativeIdBased() const
+    {
+        return false;
+    }
+};
+
+
+class APIEXTRACTOR_API InterfaceTypeEntry : public ComplexTypeEntry
+{
+public:
+    InterfaceTypeEntry(const QString &name, double vr)
+            : ComplexTypeEntry(name, InterfaceType, vr) {}
+
+    static QString interfaceName(const QString &name)
+    {
+        return name + "Interface";
+    }
+
+    ObjectTypeEntry *origin() const
+    {
+        return m_origin;
+    }
+    void setOrigin(ObjectTypeEntry *origin)
+    {
+        m_origin = origin;
+    }
+
+    virtual bool isNativeIdBased() const
+    {
+        return true;
+    }
+    virtual QString qualifiedCppName() const
+    {
+        return ComplexTypeEntry::qualifiedCppName().left(ComplexTypeEntry::qualifiedCppName().length() - interfaceName("").length());
+    }
+
+private:
+    ObjectTypeEntry *m_origin;
+};
+
+
+class APIEXTRACTOR_API FunctionTypeEntry : public TypeEntry
+{
+public:
+    FunctionTypeEntry(const QString& name, const QString& signature, double vr)
+            : TypeEntry(name, FunctionType, vr)
+    {
+        addSignature(signature);
+    }
+    void addSignature(const QString& signature)
+    {
+        m_signatures << signature;
+    }
+
+    QStringList signatures() const
+    {
+        return m_signatures;
+    }
+
+    bool hasSignature(const QString& signature) const
+    {
+        return m_signatures.contains(signature);
+    }
+private:
+    QStringList m_signatures;
+};
+
+class APIEXTRACTOR_API ObjectTypeEntry : public ComplexTypeEntry
+{
+public:
+    ObjectTypeEntry(const QString &name, double vr)
+            : ComplexTypeEntry(name, ObjectType, vr), m_interface(0) {}
+
+    InterfaceTypeEntry *designatedInterface() const
+    {
+        return m_interface;
+    }
+    void setDesignatedInterface(InterfaceTypeEntry *entry)
+    {
+        m_interface = entry;
+    }
+
+    virtual bool isNativeIdBased() const
+    {
+        return true;
+    }
+
+private:
+    InterfaceTypeEntry *m_interface;
+};
+
+struct APIEXTRACTOR_API TypeRejection
+{
+    QString class_name;
+    QString function_name;
+    QString field_name;
+    QString enum_name;
+};
+
+APIEXTRACTOR_API QString fixCppTypeName(const QString &name);
+
+class APIEXTRACTOR_API CustomConversion
+{
+public:
+    CustomConversion(TypeEntry* ownerType);
+    ~CustomConversion();
+
+    const TypeEntry* ownerType() const;
+    QString nativeToTargetConversion() const;
+    void setNativeToTargetConversion(const QString& nativeToTargetConversion);
+
+    class APIEXTRACTOR_API TargetToNativeConversion
+    {
+    public:
+        TargetToNativeConversion(const QString& sourceTypeName,
+                                 const QString& sourceTypeCheck,
+                                 const QString& conversion = QString());
+        ~TargetToNativeConversion();
+
+        const TypeEntry* sourceType() const;
+        void setSourceType(const TypeEntry* sourceType);
+        bool isCustomType() const;
+        QString sourceTypeName() const;
+        QString sourceTypeCheck() const;
+        QString conversion() const;
+        void setConversion(const QString& conversion);
+    private:
+        struct TargetToNativeConversionPrivate;
+        TargetToNativeConversionPrivate* m_d;
+    };
+
+    /**
+     *  Returns true if the target to C++ custom conversions should
+     *  replace the original existing ones, and false if the custom
+     *  conversions should be added to the original.
+     */
+    bool replaceOriginalTargetToNativeConversions() const;
+    void setReplaceOriginalTargetToNativeConversions(bool replaceOriginalTargetToNativeConversions);
+
+    typedef QList<TargetToNativeConversion*> TargetToNativeConversions;
+    bool hasTargetToNativeConversions() const;
+    TargetToNativeConversions& targetToNativeConversions();
+    const TargetToNativeConversions& targetToNativeConversions() const;
+    void addTargetToNativeConversion(const QString& sourceTypeName,
+                                     const QString& sourceTypeCheck,
+                                     const QString& conversion = QString());
+private:
+    struct CustomConversionPrivate;
+    CustomConversionPrivate* m_d;
+};
+
+#endif // TYPESYSTEM_H
diff --git a/ApiExtractor/typesystem_p.h b/ApiExtractor/typesystem_p.h
new file mode 100644
index 000000000..e8f5f2406
--- /dev/null
+++ b/ApiExtractor/typesystem_p.h
@@ -0,0 +1,171 @@
+/*
+ * This file is part of the API Extractor project.
+ *
+ * Copyright (C) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+#ifndef TYPESYSTEM_P_H
+#define TYPESYSTEM_P_H
+
+#include <QStack>
+#include <QXmlDefaultHandler>
+#include "typesystem.h"
+
+class TypeDatabase;
+class StackElement
+{
+    public:
+        enum ElementType {
+            None = 0x0,
+
+            // Type tags (0x1, ... , 0xff)
+            ObjectTypeEntry             = 0x1,
+            ValueTypeEntry              = 0x2,
+            InterfaceTypeEntry          = 0x3,
+            NamespaceTypeEntry          = 0x4,
+            ComplexTypeEntryMask        = 0x7,
+
+            // Non-complex type tags (0x8, 0x9, ... , 0xf)
+            PrimitiveTypeEntry          = 0x8,
+            EnumTypeEntry               = 0x9,
+            ContainerTypeEntry          = 0xa,
+            FunctionTypeEntry           = 0xb,
+            CustomTypeEntry             = 0xc,
+            TypeEntryMask               = 0xf,
+
+            // Documentation tags
+            InjectDocumentation         = 0x10,
+            ModifyDocumentation         = 0x20,
+            DocumentationMask           = 0xf0,
+
+            // Simple tags (0x100, 0x200, ... , 0xf00)
+            ExtraIncludes               = 0x0100,
+            Include                     = 0x0200,
+            ModifyFunction              = 0x0300,
+            ModifyField                 = 0x0400,
+            Root                        = 0x0500,
+            CustomMetaConstructor       = 0x0600,
+            CustomMetaDestructor        = 0x0700,
+            ArgumentMap                 = 0x0800,
+            SuppressedWarning           = 0x0900,
+            Rejection                   = 0x0a00,
+            LoadTypesystem              = 0x0b00,
+            RejectEnumValue             = 0x0c00,
+            Template                    = 0x0d00,
+            TemplateInstanceEnum        = 0x0e00,
+            Replace                     = 0x0f00,
+            AddFunction                 = 0x1000,
+            NativeToTarget              = 0x1100,
+            TargetToNative              = 0x1200,
+            AddConversion               = 0x1300,
+            SimpleMask                  = 0x3f00,
+
+            // Code snip tags (0x1000, 0x2000, ... , 0xf000)
+            InjectCode                  = 0x4000,
+            InjectCodeInFunction        = 0x8000,
+            CodeSnipMask                = 0xc000,
+
+            // Function modifier tags (0x010000, 0x020000, ... , 0xf00000)
+            Access                      = 0x010000,
+            Removal                     = 0x020000,
+            Rename                      = 0x040000,
+            ModifyArgument              = 0x080000,
+            Thread                      = 0x100000,
+            FunctionModifiers           = 0xff0000,
+
+            // Argument modifier tags (0x01000000 ... 0xf0000000)
+            ConversionRule              = 0x01000000,
+            ReplaceType                 = 0x02000000,
+            ReplaceDefaultExpression    = 0x04000000,
+            RemoveArgument              = 0x08000000,
+            DefineOwnership             = 0x10000000,
+            RemoveDefaultExpression     = 0x20000000,
+            NoNullPointers              = 0x40000000,
+            ReferenceCount              = 0x80000000,
+            ParentOwner                 = 0x90000000,
+            ArgumentModifiers           = 0xff000000
+        };
+
+        StackElement(StackElement *p) : entry(0), type(None), parent(p) { }
+
+        TypeEntry* entry;
+        ElementType type;
+        StackElement *parent;
+
+        union {
+            TemplateInstance* templateInstance;
+            TemplateEntry* templateEntry;
+            CustomFunction* customFunction;
+        } value;
+};
+
+struct StackElementContext
+{
+    CodeSnipList codeSnips;
+    AddedFunctionList addedFunctions;
+    FunctionModificationList functionMods;
+    FieldModificationList fieldMods;
+    DocModificationList docModifications;
+};
+
+class Handler : public QXmlDefaultHandler
+{
+public:
+    Handler(TypeDatabase* database, bool generate);
+
+    bool startElement(const QString& namespaceURI, const QString& localName,
+                      const QString& qName, const QXmlAttributes& atts);
+    bool endElement(const QString& namespaceURI, const QString& localName, const QString& qName);
+
+    QString errorString() const
+    {
+        return m_error;
+    }
+
+    bool error(const QXmlParseException &exception);
+    bool fatalError(const QXmlParseException &exception);
+    bool warning(const QXmlParseException &exception);
+
+    bool characters(const QString &ch);
+
+private:
+    void fetchAttributeValues(const QString &name, const QXmlAttributes &atts,
+                              QHash<QString, QString> *acceptedAttributes);
+
+    bool importFileElement(const QXmlAttributes &atts);
+    bool convertBoolean(const QString &, const QString &, bool);
+
+    TypeDatabase* m_database;
+    StackElement* m_current;
+    StackElement* m_currentDroppedEntry;
+    int m_currentDroppedEntryDepth;
+    int m_ignoreDepth;
+    QString m_defaultPackage;
+    QString m_defaultSuperclass;
+    QString m_error;
+    TypeEntry::CodeGeneration m_generate;
+
+    EnumTypeEntry* m_currentEnum;
+    QStack<StackElementContext*> m_contextStack;
+
+    QHash<QString, StackElement::ElementType> tagNames;
+    QString m_currentSignature;
+};
+
+#endif