qtbindings 4.6.3.0-x86-mingw32

data/ext/generator/parser/rpp/chartools.cpp

@@ -0,0 +1,126 @@
+/*
+  Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
+
+  Permission to use, copy, modify, distribute, and sell this software and its
+  documentation for any purpose is hereby granted without fee, provided that
+  the above copyright notice appear in all copies and that both that
+  copyright notice and this permission notice appear in supporting
+  documentation.
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+  KDEVELOP TEAM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+  AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "chartools.h"
+#include "../kdevvarlengtharray.h"
+#include "../indexedstring.h"
+
+#include <QString>
+#include <QVector>
+
+QByteArray stringFromContents(const PreprocessedContents& contents, int offset, int count) {
+  QByteArray ret;
+  for(int a = offset; a < (count ? offset+count : contents.size()); ++a) {
+    if(isCharacter(contents[a]))
+      ret.append(characterFromIndex(contents[a]));
+    else
+      ret += IndexedString::fromIndex(contents[a]).byteArray();
+  }
+  return ret;
+}
+
+QByteArray stringFromContents(const uint* contents, int count) {
+  QByteArray ret;
+  for(int a = 0; a < count; ++a) {
+    if(isCharacter(contents[a]))
+      ret.append(characterFromIndex(contents[a]));
+    else
+      ret += IndexedString::fromIndex(contents[a]).byteArray();
+  }
+  return ret;
+}
+
+QByteArray stringFromContentsWithGaps(const PreprocessedContents& contents, int offset, int count) {
+  QByteArray ret;
+  for(int a = offset; a < (count ? offset+count : contents.size()); ++a) {
+    if(isCharacter(contents[a]))
+      ret.append(characterFromIndex(contents[a]));
+    else
+      ret += IndexedString::fromIndex(contents[a]).byteArray();
+    ret.append(" ");
+  }
+  return ret;
+}
+
+PreprocessedContents convertFromByteArray(const QByteArray& array) {
+  PreprocessedContents to;
+  to.resize(array.size());
+  const char* data = array.constData();
+  const char* dataEnd = data + array.size();
+  unsigned int* target = to.data();
+  
+  
+  while(data < dataEnd) {
+    *target = indexFromCharacter(*data);
+    ++data;
+    ++target;
+  }
+  return to;
+}
+
+PreprocessedContents tokenizeFromByteArray(const QByteArray& array) {
+  PreprocessedContents to;
+  
+  const char* data = array.constData();
+  const char* dataEnd = data + array.size();
+  //unsigned int* target = to.data();
+  
+  KDevVarLengthArray<char, 100> identifier;
+  
+  IndexedString::RunningHash hash;
+
+  bool tokenizing = false;
+  
+  while(data < dataEnd) {
+    
+    if(!tokenizing) {
+      if(isLetter(*data) || *data == '_')
+        tokenizing = true;
+    }
+    
+    if(tokenizing) {
+      if(isLetterOrNumber(*data) || *data == '_') {
+        hash.append(*data);
+        identifier.append(*data);
+      }else{
+        //End of token
+        to.append( IndexedString(identifier.constData(), identifier.size(), hash.hash).index() );
+        //kDebug() << "word" << "\"" + IndexedString(to.back()).str() + "\"";
+        hash.clear();
+        identifier.clear();
+        tokenizing = false;
+      }
+    }
+    
+    if(!tokenizing)
+      to.append( indexFromCharacter(*data) );
+    ++data;
+  }
+  
+  if(tokenizing)
+    to.append( IndexedString(identifier.constData(), identifier.size(), hash.hash).index() );
+  
+  
+/*  kDebug() << QString::fromUtf8(stringFromContents(to));
+  kDebug() << QString::fromUtf8(array);
+  Q_ASSERT(stringFromContents(to) == array);*/
+  
+  return to;
+}

data/ext/generator/parser/rpp/chartools.h

@@ -0,0 +1,90 @@
+/*
+  Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
+
+  Permission to use, copy, modify, distribute, and sell this software and its
+  documentation for any purpose is hereby granted without fee, provided that
+  the above copyright notice appear in all copies and that both that
+  copyright notice and this permission notice appear in supporting
+  documentation.
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+  KDEVELOP TEAM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+  AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef CHARTOOLS
+#define CHARTOOLS
+#include <QChar>
+
+#include "../cppparser_export.h"
+
+template<class T>
+class QVector;
+class QString;
+class QByteArray;
+typedef QVector<unsigned int> PreprocessedContents;
+
+inline bool isSpace(char c) {
+  return QChar(c).isSpace();
+}
+
+inline bool isLetter(char c) {
+  return QChar(c).isLetter();
+}
+
+inline bool isLetterOrNumber(char c) {
+  return QChar(c).isLetterOrNumber();
+}
+
+inline bool isNumber(char c) {
+  return QChar(c).isNumber();
+}
+
+//Takes an index as delt with during preprocessing, and determines whether it is a fake-index that represents
+//a character. If the 0xffff0000 bits are set, it is a custom character.
+#define isCharacter(index) ((index & 0xffff0000) == 0xffff0000)
+
+//Creates an index that represents the given character
+#define indexFromCharacter(character) ((unsigned int)character | 0xffff0000)
+
+//Extracts the character that is represented by the index
+#define characterFromIndex(index) ((char)(index & 0xffff))
+
+inline bool isSpace(unsigned int c) {
+  return isCharacter(c) && QChar(characterFromIndex(c)).isSpace();
+}
+
+inline bool isLetter(unsigned int c) {
+  return isCharacter(c) && QChar(characterFromIndex(c)).isLetter();
+}
+
+inline bool isLetterOrNumber(unsigned int c) {
+  return isCharacter(c) && QChar(characterFromIndex(c)).isLetterOrNumber();
+}
+
+inline bool isNumber(unsigned int c) {
+  return isCharacter(c) && QChar(characterFromIndex(c)).isNumber();
+}
+
+///Opposite of convertFromByteArray
+CPPPARSER_EXPORT QByteArray stringFromContents(const PreprocessedContents& contents, int offset = 0, int count = 0);
+
+///Opposite of convertFromByteArray
+CPPPARSER_EXPORT QByteArray stringFromContents(const uint* contents, int count);
+
+///Returns a string that has a gap inserted between the tokens(for debugging)
+CPPPARSER_EXPORT QByteArray stringFromContentsWithGaps(const PreprocessedContents& contents, int offset = 0, int count = 0);
+
+///Converts the byte array to a vector of fake-indices containing the text
+CPPPARSER_EXPORT PreprocessedContents convertFromByteArray(const QByteArray& array);
+
+///Converts the byte array to a vector of fake-indices containing the text
+///This also tokenizes the given array when possible
+CPPPARSER_EXPORT PreprocessedContents tokenizeFromByteArray(const QByteArray& array);
+#endif

data/ext/generator/parser/rpp/macrorepository.cpp

@@ -0,0 +1,44 @@
+/*
+   Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
+
+   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.
+*/
+
+#include "macrorepository.h"
+
+//The text is supposed to be utf8 encoded
+using namespace rpp;
+
+size_t MacroRepositoryItemRequest::itemSize() const {
+  return macro.dynamicSize();
+}
+
+MacroRepositoryItemRequest::MacroRepositoryItemRequest(const rpp::pp_macro& _macro) : macro(_macro) {
+  _macro.completeHash(); //Make sure the hash is valid
+}
+
+void MacroRepositoryItemRequest::destroy(rpp::pp_macro* item, KDevelop::AbstractItemRepository&) {
+  item->~pp_macro();
+}
+
+void MacroRepositoryItemRequest::createItem(rpp::pp_macro* item) const {
+  new (item) pp_macro(macro, false);
+  Q_ASSERT(*item == macro);
+}
+
+//Should return whether the here requested item equals the given item
+bool MacroRepositoryItemRequest::equals(const rpp::pp_macro* item) const {
+  return macro == *item;
+}

data/ext/generator/parser/rpp/macrorepository.h

@@ -0,0 +1,59 @@
+/*
+   Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
+
+   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 MACROREPOSITORY_H
+#define MACROREPOSITORY_H
+
+#include <language/duchain/repositories/itemrepository.h>
+#include <cppparserexport.h>
+#include "pp-macro.h"
+
+struct Q_DECL_EXPORT MacroRepositoryItemRequest {
+
+  //The text is supposed to be utf8 encoded
+  MacroRepositoryItemRequest(const rpp::pp_macro& _macro);
+  
+  enum {
+    AverageSize = 20 //This should be the approximate average size of an Item
+  };
+
+  typedef unsigned int HashType;
+  
+  HashType hash() const {
+    return macro.completeHash();
+  }
+  
+  size_t itemSize() const;
+  
+  void createItem(rpp::pp_macro* item) const;
+  
+  static void destroy(rpp::pp_macro* item, KDevelop::AbstractItemRepository&);
+  
+  static bool persistent(const rpp::pp_macro* /*item*/) {
+    return true; //Macros are reference-counted through the macro sets
+  }
+  
+  //Should return whether the here requested item equals the given item
+  bool equals(const rpp::pp_macro* item) const;
+  
+  const rpp::pp_macro& macro;
+};
+
+typedef KDevelop::ItemRepository<rpp::pp_macro, MacroRepositoryItemRequest> MacroDataRepository;
+
+#endif

data/ext/generator/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__

data/ext/generator/parser/rpp/pp-engine.cpp

@@ -0,0 +1,1216 @@
+/*
+  Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
+  Copyright 2006 Hamish Rodda <rodda@kde.org>
+
+  Permission to use, copy, modify, distribute, and sell this software and its
+  documentation for any purpose is hereby granted without fee, provided that
+  the above copyright notice appear in all copies and that both that
+  copyright notice and this permission notice appear in supporting
+  documentation.
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+  KDEVELOP TEAM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+  AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "pp-engine.h"
+
+#include <QFile>
+#include <QTextStream>
+#include <QtDebug>
+
+#include "pp-internal.h"
+#include "preprocessor.h"
+#include "pp-environment.h"
+#include "pp-location.h"
+#include "chartools.h"
+// #include "macrorepository.h"
+
+using namespace rpp;
+
+#define RETURN_ON_FAIL(x) if(!(x)) { ++input; qDebug() << "Preprocessor: Condition not satisfied"; return; }
+
+pp::pp(Preprocessor* preprocessor)
+  : m_environment(new Environment(this))
+  , expand(this, 0, true)
+  , m_preprocessor(preprocessor)
+  , nextToken(0)
+  , haveNextToken(false)
+  , hideNext(false)
+  , hadGuardCandidate(false)
+  , checkGuardEnd(false)
+{
+  iflevel = 0;
+  _M_skipping[iflevel] = 0;
+  _M_true_test[iflevel] = 0;
+}
+
+pp::~pp()
+{
+  delete m_environment;
+}
+
+Preprocessor* pp::preprocessor() {
+  return m_preprocessor;
+}
+
+PreprocessedContents pp::processFile(const QString& fileName)
+{
+    QFile file(fileName);
+    if (!file.open(QIODevice::ReadOnly))
+    {
+        qWarning() << "file '" << fileName << "' not found!" ;
+        return PreprocessedContents();
+    }
+
+    PreprocessedContents result;
+    processFileInternal(fileName, file.readAll(), result);
+    return result;
+}
+
+PreprocessedContents pp::processFile(const QString& fileName, const QByteArray& data)
+{
+    PreprocessedContents result;
+    processFileInternal(fileName, data, result);
+    return result;
+}
+
+void pp::processFileInternal(const QString& fileName, const QByteArray& fileContents, PreprocessedContents& result)
+{
+    m_files.push(IndexedString(fileName));
+    // Guestimate as to how much expansion will occur
+    result.reserve(int(fileContents.length() * 1.2));
+    PreprocessedContents contents = convertFromByteArray(fileContents);
+    {
+      Stream is(&contents);
+      Stream rs(&result, m_environment->locationTable());
+      operator () (is, rs);
+    }
+    result.squeeze();
+}
+
+uint ifDirective = IndexedString("if").index();
+uint elseDirective = IndexedString("else").index();
+uint elifDirective = IndexedString("elif").index();
+uint ifdefDirective = IndexedString("ifdef").index();
+uint undefDirective = IndexedString("undef").index();
+uint endifDirective = IndexedString("endif").index();
+uint ifndefDirective = IndexedString("ifndef").index();
+uint defineDirective = IndexedString("define").index();
+uint includeDirective = IndexedString("include").index();
+uint includeNextDirective = IndexedString("include_next").index();
+
+void pp::handle_directive(uint directive, Stream& input, Stream& output)
+{
+  skip_blanks (input, output);
+  if(!(directive == ifndefDirective)) {
+    hadGuardCandidate = true; //Too late, the guard must be the first directive
+  }
+  if(checkGuardEnd) {
+    guardCandidate = IndexedString();
+    checkGuardEnd = false;
+  }
+  
+  if(directive == defineDirective)
+      if (! skipping ())
+        return handle_define(input);
+
+  if(directive == includeDirective || directive == includeNextDirective)
+      if (! skipping ())
+        return handle_include (directive == includeNextDirective, input, output);
+
+  if(directive == undefDirective)
+      if (! skipping ())
+        return handle_undef(input);
+
+  if(directive == elifDirective)
+      return handle_elif(input);
+
+  if(directive == elseDirective)
+      return handle_else(input.inputPosition().line);
+
+  if(directive == endifDirective)
+      return handle_endif(input, output);
+
+  if(directive == ifDirective)
+      return handle_if(input);
+
+  if(directive == ifdefDirective)
+      return handle_ifdef(false, input);
+
+  if(directive == ifndefDirective)
+      return handle_ifdef(true, input);
+}
+
+void pp::handle_include(bool skip_current_path, Stream& input, Stream& output)
+{
+  if (isLetter(input.current()) || input == '_') {
+    pp_macro_expander expand_include(this);
+
+    Anchor inputPosition = input.inputPosition();
+    SimpleCursor originalInputPosition = input.originalInputPosition();
+    PreprocessedContents includeString;
+    {
+      Stream cs(&includeString);
+      expand_include(input, cs);
+    }
+
+    skip_blanks(input, devnull());
+    RETURN_ON_FAIL(!includeString.isEmpty() && (includeString.first() == indexFromCharacter('<') || includeString.first() == indexFromCharacter('"')));
+
+    Stream newInput(&includeString, inputPosition);
+    newInput.setOriginalInputPosition(originalInputPosition);
+    handle_include(skip_current_path, newInput, output);
+    return;
+  }
+
+  RETURN_ON_FAIL(input == '<' || input == '"');
+  char quote((input == '"') ? '"' : '>');
+  ++input;
+
+  PreprocessedContents includeNameB;
+
+  while (!input.atEnd() && input != quote) {
+    RETURN_ON_FAIL(input != '\n');
+
+    includeNameB.append(input);
+    ++input;
+  }
+
+  QString includeName(QString::fromUtf8(stringFromContents(includeNameB)));
+
+  Stream* include = m_preprocessor->sourceNeeded(includeName, quote == '"' ? Preprocessor::IncludeLocal : Preprocessor::IncludeGlobal, input.inputPosition().line, skip_current_path);
+
+  if (include && !include->atEnd()) {
+//     m_files.push(IndexedString(includeName));
+
+//     output.mark(Anchor(0, 0));
+
+    operator()(*include, output);
+
+    // restore the file name and sync the buffer
+//     output.mark(input.inputPosition());
+  }
+
+  delete include;
+}
+
+void pp::operator () (Stream& input, Stream& output)
+{
+  int previousIfLevel = iflevel;
+
+  forever
+  {
+    haveNextToken = false;
+
+    if (skipping()) {
+      skip_blanks(input, devnull());
+
+    } else {
+      skip_blanks(input, output);
+    }
+
+    if (input.atEnd()) {
+      break;
+
+    } else if (input == '#') {
+      skip_blanks(++input, devnull());
+
+      uint directive = skip_identifier(input);
+
+      skip_blanks(input, devnull());
+
+      Anchor inputPosition = input.inputPosition();
+      SimpleCursor originalInputPosition = input.originalInputPosition();
+
+      PreprocessedContents skipped;
+      {
+        Stream ss(&skipped);
+        skip (input, ss);
+      }
+
+      Stream ss(&skipped, inputPosition);
+      ss.setOriginalInputPosition(originalInputPosition);
+      handle_directive(directive, ss, output);
+
+    } else if (input == '\n') {
+      output << input;
+      ++input;
+
+    } else if (skipping ()) {
+      skip (input, devnull());
+
+    } else {
+      output.mark(input.inputPosition());
+      if(checkGuardEnd) {
+        expand.startSignificantContentSearch();
+      }
+      
+      expand (input, output);
+      if(checkGuardEnd) {
+        if(expand.foundSignificantContent() || !input.atEnd()) {
+          guardCandidate = IndexedString();
+        }
+        checkGuardEnd = false;
+      }
+    }
+  }
+  
+  if(!guardCandidate.isEmpty())
+    preprocessor()->foundHeaderGuard(input, guardCandidate);
+
+  if (iflevel != previousIfLevel && !input.skippedToEnd())
+    createProblem(input, "Unterminated #if statement");
+}
+
+void pp::createProblem(Stream& input, const QString& description) {
+    Problem* problem = new Problem;
+    problem->file = currentFileNameString();
+    problem->position = input.originalInputPosition();
+    problem->description = description;
+    problemEncountered(problem);
+}
+
+void pp::handle_define (Stream& input)
+{
+  pp_macro* macro = new pp_macro;
+  macro->file = currentFileName();
+  macro->sourceLine = input.originalInputPosition().line;
+
+  skip_blanks (input, devnull());
+  macro->name = IndexedString::fromIndex(skip_identifier(input)); //@todo make macros utf8 too
+
+  if (!input.atEnd() && input == '(')
+  {
+    macro->function_like = true;
+
+    skip_blanks (++input, devnull()); // skip '('
+    uint formal = skip_identifier(input);
+    if (formal)
+      macro->formals.append( IndexedString::fromIndex(formal) );
+
+    skip_blanks(input, devnull());
+
+    if (input == '.') {
+      macro->variadics = true;
+
+      do {
+        ++input;
+
+      } while (input == '.');
+    }
+
+    while (!input.atEnd() && input == ',')
+    {
+      skip_blanks(++input, devnull());
+
+      uint formal = skip_identifier(input);
+      if (formal)
+        macro->formals.append( IndexedString::fromIndex(formal) );
+
+      skip_blanks (input, devnull());
+
+      if (input == '.') {
+        macro->variadics = true;
+
+        do {
+          ++input;
+
+        } while (input == '.');
+      }
+    }
+
+    RETURN_ON_FAIL(input == ')');
+    ++input;
+  }
+
+  skip_blanks (input, devnull());
+
+  while (!input.atEnd() && input != '\n')
+  {
+    if(input == '/' && (input.peekNextCharacter() == '/' || input.peekNextCharacter() == '*')) {
+      skip_comment_or_divop(input, devnull());
+      if(!input.atEnd() && input != '\n')
+        skip_blanks (input, devnull());
+      continue;
+    }
+    if (input == '\\')
+    {
+      int pos = input.offset();
+      skip_blanks (++input, devnull());
+
+      if (!input.atEnd() && input == '\n')
+      {
+        skip_blanks(++input, devnull());
+        macro->definition.append(IndexedString::fromIndex(indexFromCharacter(' ')));
+        continue;
+
+      } else {
+        // Whoops, rewind :)
+        input.seek(pos);
+      }
+    }
+
+    macro->definition.append(IndexedString::fromIndex(input.current()));
+    ++input;
+  }
+
+  m_environment->setMacro(macro);
+}
+
+
+void pp::skip (Stream& input, Stream& output, bool outputText)
+{
+  pp_skip_string_literal skip_string_literal;
+  pp_skip_char_literal skip_char_literal;
+
+  while (!input.atEnd() && input != '\n')
+  {
+    if (input == '/')
+    {
+      skip_comment_or_divop (input, output, outputText);
+    }
+    else if (input == '"')
+    {
+      skip_string_literal (input, output);
+    }
+    else if (input == '\'')
+    {
+      skip_char_literal (input, output);
+    }
+    else if (input == '\\')
+    {
+      output << input;
+      skip_blanks (++input, output);
+
+      if (!input.atEnd() && input == '\n')
+      {
+        output << input;
+        ++input;
+      }
+    }
+    else
+    {
+      output << input;
+      ++input;
+    }
+  }
+}
+
+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]; }
+
+Value pp::eval_primary(Stream& input)
+{
+  int start = input.offset();
+  bool expect_paren = false;
+  int token = next_token_accept(input);
+  Value result;
+
+  switch (token) {
+    case TOKEN_NUMBER:
+      result.set_long(token_value);
+      break;
+
+    case TOKEN_UNUMBER:
+      result.set_ulong(token_uvalue);
+      break;
+
+    case TOKEN_DEFINED:
+      token = next_token_accept(input);
+
+      if (token == '(')
+      {
+        expect_paren = true;
+        token = next_token_accept(input);
+      }
+
+      if (token != TOKEN_IDENTIFIER)
+      {
+        Problem* problem = new Problem;
+        problem->file = currentFileNameString();
+        problem->position = input.originalInputPosition();
+        QChar tk(token);
+        problem->description = QString("Expected \"identifier\", found: %1").arg((tk < TOKENS_END && tk > TOKENS_START) ? QString(tk) : QString("character %1").arg(token));
+        problem->explanation = QString("<h5>Token text</h5><pre>%1</pre><h5>Input</h5><pre>%2</pre>").arg(token_text.str())
+                                       .arg(QString::fromUtf8(input.stringFrom(start)));
+        problemEncountered(problem);
+        break;
+      }
+
+      {
+        pp_macro* m = m_environment->retrieveMacro(token_text, true);
+        result.set_long( (m && !m->isUndef()) ? 1 : 0);
+      }
+
+      token = next_token(input); // skip '('
+
+      if (expect_paren) {
+        if (token != ')') {
+          Problem* problem = new Problem;
+          problem->file = currentFileNameString();
+          problem->position = input.originalInputPosition();
+          QChar tk(token);
+          problem->description = QString("Expected \")\", found %1").arg(tk.isLetterOrNumber() ? QString(tk) : QString("character %1").arg(token));
+          problem->explanation = QString("<h5>Token text</h5><pre>%1</pre><h5>Input</h5><pre>%2</pre>").arg(token_text.str())
+                                         .arg(QString::fromUtf8(input.stringFrom(start)));
+          problemEncountered(problem);
+        } else {
+          accept_token();
+        }
+      }
+      break;
+
+    case TOKEN_IDENTIFIER:
+      break;
+
+    case '-':
+      result.set_long(- eval_primary(input).l);
+      break;
+
+    case '+':
+      result.set_long(+ eval_primary(input).l);
+      break;
+
+    case '!':
+      result.set_long(eval_primary(input).is_zero());
+      break;
+
+    case '(':
+      result = eval_constant_expression(input);
+      token = next_token(input);
+
+      if (token != ')') {
+        Problem* problem = new Problem;
+        problem->file = currentFileNameString();
+        problem->position = input.originalInputPosition();
+        QChar tk(token);
+        problem->description = QString("Expected \")\", found %1").arg(tk.isLetterOrNumber() ? QString(tk) : QString("character %1").arg(token));
+        problem->explanation = QString("<h5>Token text</h5><pre>%1</pre><h5>Input</h5><pre>%2</pre>").arg(token_text.str())
+                                       .arg(QString::fromUtf8(input.stringFrom(start)));
+        problemEncountered(problem);
+      } else {
+        accept_token();
+      }
+
+      break;
+
+    default:
+      break;
+  }
+
+  return result;
+}
+
+Value pp::eval_multiplicative(Stream& input)
+{
+  int start = input.offset();
+
+  Value result = eval_primary(input);
+
+  int token = next_token(input);
+
+  while (token == '*' || token == '/' || token == '%') {
+    accept_token();
+
+    Value value = eval_primary(input);
+
+    if (token == '*') {
+      result *= value;
+
+    } else if (token == '/') {
+      if (value.is_zero()) {
+        Problem* problem = new Problem;
+        problem->file = currentFileNameString();
+        problem->position = input.originalInputPosition();
+        problem->description = "Division by zero";
+        problem->explanation = QString("Input text: %1").arg(QString::fromUtf8(input.stringFrom(start)));
+        problemEncountered(problem);
+        result.set_long(0);
+
+      } else {
+        result /= value;
+      }
+
+    } else {
+      if (value.is_zero()) {
+        Problem* problem = new Problem;
+        problem->file = currentFileNameString();
+        problem->position = input.originalInputPosition();
+        problem->description = "Division by zero";
+        problem->description = QString("Input text: %1").arg(QString::fromUtf8(input.stringFrom(start)));
+        problemEncountered(problem);
+        result.set_long(0);
+
+      } else {
+        result %= value;
+      }
+    }
+
+    token = next_token(input);
+  }
+
+  return result;
+}
+
+Value pp::eval_additive(Stream& input)
+{
+  Value result = eval_multiplicative(input);
+
+  int token = next_token(input);
+
+  while (token == '+' || token == '-') {
+    accept_token();
+
+    Value value = eval_multiplicative(input);
+
+    if (token == '+')
+      result += value;
+    else
+      result -= value;
+
+    token = next_token(input);
+  }
+
+  return result;
+}
+
+
+Value pp::eval_shift(Stream& input)
+{
+  Value result = eval_additive(input);
+
+  int token;
+  token = next_token(input);
+
+  while (token == TOKEN_LT_LT || token == TOKEN_GT_GT) {
+    accept_token();
+
+    Value value = eval_additive(input);
+
+    if (token == TOKEN_LT_LT)
+      result <<= value;
+    else
+      result >>= value;
+
+    token = next_token(input);
+  }
+
+  return result;
+}
+
+
+Value pp::eval_relational(Stream& input)
+{
+  Value result = eval_shift(input);
+
+  int token = next_token(input);
+
+  while (token == '<'
+      || token == '>'
+      || token == TOKEN_LT_EQ
+      || token == TOKEN_GT_EQ)
+  {
+    accept_token();
+    Value value = eval_shift(input);
+
+    switch (token)
+    {
+      default:
+        Q_ASSERT(0);
+        break;
+
+      case '<':
+        result = result < value;
+        break;
+
+      case '>':
+        result = result > value;
+        break;
+
+      case TOKEN_LT_EQ:
+        result = result <= value;
+        break;
+
+      case TOKEN_GT_EQ:
+        result = result >= value;
+        break;
+    }
+
+    token = next_token(input);
+  }
+
+  return result;
+}
+
+
+Value pp::eval_equality(Stream& input)
+{
+  Value result = eval_relational(input);
+
+  int token = next_token(input);
+
+  while (token == TOKEN_EQ_EQ || token == TOKEN_NOT_EQ) {
+    accept_token();
+    Value value = eval_relational(input);
+
+    if (token == TOKEN_EQ_EQ)
+      result = result == value;
+    else
+      result = result != value;
+
+    token = next_token(input);
+  }
+
+  return result;
+}
+
+
+Value pp::eval_and(Stream& input)
+{
+  Value result = eval_equality(input);
+
+  int token = next_token(input);
+
+  while (token == '&') {
+    accept_token();
+    Value value = eval_equality(input);
+    result &= value;
+    token = next_token(input);
+  }
+
+  return result;
+}
+
+
+Value pp::eval_xor(Stream& input)
+{
+  Value result = eval_and(input);
+
+  int token;
+  token = next_token(input);
+
+  while (token == '^') {
+    accept_token();
+    Value value = eval_and(input);
+    result ^= value;
+    token = next_token(input);
+  }
+
+  return result;
+}
+
+
+Value pp::eval_or(Stream& input)
+{
+  Value result = eval_xor(input);
+
+  int token = next_token(input);
+
+  while (token == '|') {
+    accept_token();
+    Value value = eval_xor(input);
+    result |= value;
+    token = next_token(input);
+  }
+
+  return result;
+}
+
+
+Value pp::eval_logical_and(Stream& input)
+{
+  Value result = eval_or(input);
+
+  int token = next_token(input);
+
+  while (token == TOKEN_AND_AND) {
+    accept_token();
+    Value value = eval_or(input);
+    result = result && value;
+    token = next_token(input);
+  }
+
+  return result;
+}
+
+
+Value pp::eval_logical_or(Stream& input)
+{
+  Value result = eval_logical_and(input);
+
+  int token = next_token(input);
+
+  while (token == TOKEN_OR_OR) {
+    accept_token();
+    Value value = eval_logical_and(input);
+    result = result || value;
+    token = next_token(input);
+  }
+
+  return result;
+}
+
+
+Value pp::eval_constant_expression(Stream& input)
+{
+  Value result = eval_logical_or(input);
+
+  int token = next_token(input);
+
+  if (token == '?')
+  {
+    accept_token();
+    Value left_value = eval_constant_expression(input);
+    skip_blanks(input, devnull());
+
+    token = next_token_accept(input);
+    if (token == ':')
+    {
+      Value right_value = eval_constant_expression(input);
+
+      result = !result.is_zero() ? left_value : right_value;
+    }
+    else
+    {
+      Problem* problem = new Problem;
+      problem->file = currentFileNameString();
+      problem->position = input.originalInputPosition();
+      problem->description = QString("expected ``:'' = %1").arg(int(token));
+      problemEncountered(problem);
+      result = left_value;
+    }
+  }
+
+  return result;
+}
+
+
+Value pp::eval_expression(Stream& input)
+{
+  skip_blanks(input, devnull());
+  return eval_constant_expression(input);
+}
+
+
+void pp::handle_if (Stream& input)
+{
+  if (test_if_level())
+  {
+    pp_macro_expander expand_condition(this);
+    skip_blanks(input, devnull());
+
+    Anchor inputPosition = input.inputPosition();
+    SimpleCursor originalInputPosition = input.originalInputPosition();
+    PreprocessedContents condition;
+    {
+      Stream cs(&condition);
+      expand_condition(input, cs);
+    }
+
+    environment()->enterBlock(input.inputPosition().line, condition);
+
+    Stream cs(&condition, inputPosition);
+    cs.setOriginalInputPosition(originalInputPosition);
+    Value result = eval_expression(cs);
+
+    _M_true_test[iflevel] = !result.is_zero();
+    _M_skipping[iflevel] = result.is_zero();
+
+  } else {
+    // Capture info for precompiled macros
+    pp_macro_expander expand_condition(this);
+    skip_blanks(input, devnull());
+    PreprocessedContents condition;
+    {
+      Stream cs(&condition);
+      expand_condition(input, cs);
+    }
+
+    environment()->enterBlock(input.inputPosition().line, condition);
+
+    _M_true_test[iflevel] = true;
+    _M_skipping[iflevel] = true;
+  }
+}
+
+
+void pp::handle_else(int sourceLine)
+{
+  if(iflevel == 1)
+    guardCandidate = IndexedString();
+
+  if (iflevel == 0 && !skipping ())
+  {
+    Problem* problem = new Problem;
+    problem->file = currentFileNameString();
+    problem->position = SimpleCursor(sourceLine, 0);
+    problem->description = "#else without #if";
+    problemEncountered(problem);
+  }
+  else if (iflevel > 0 && _M_skipping[iflevel - 1])
+  {
+    _M_skipping[iflevel] = true;
+    environment()->elseBlock(sourceLine);
+  }
+  else
+  {
+    _M_skipping[iflevel] = _M_true_test[iflevel];
+    environment()->elseBlock(sourceLine);
+  }
+}
+
+
+void pp::handle_elif(Stream& input)
+{
+  if(iflevel == 1)
+    guardCandidate = IndexedString();
+  
+  RETURN_ON_FAIL(iflevel > 0);
+
+  if (iflevel == 0 && !skipping())
+  {
+    Problem* problem = new Problem;
+    problem->file = currentFileNameString();
+    problem->position = input.originalInputPosition();
+    problem->description = "#else without #if";
+    problemEncountered(problem);
+  }
+  else
+  {
+    pp_macro_expander expand_condition(this);
+    skip_blanks(input, devnull());
+
+    Anchor inputPosition = input.inputPosition();
+    SimpleCursor originalInputPosition = input.originalInputPosition();
+    PreprocessedContents condition;
+    {
+      Stream cs(&condition);
+      cs.setOriginalInputPosition(originalInputPosition);
+      expand_condition(input, cs);
+    }
+
+    environment()->elseBlock(input.inputPosition().line, condition);
+
+    if (!_M_true_test[iflevel] && !_M_skipping[iflevel - 1])
+    {
+      Stream cs(&condition, inputPosition);
+      Value result = eval_expression(cs);
+      _M_true_test[iflevel] = !result.is_zero();
+      _M_skipping[iflevel] = result.is_zero();
+    }
+    else
+    {
+      _M_skipping[iflevel] = true;
+    }
+  }
+}
+
+
+void pp::handle_endif(Stream& input, Stream& output)
+{
+  if (iflevel == 0 && !skipping())
+  {
+    Problem* problem = new Problem;
+    problem->file = currentFileNameString();
+    problem->position = input.originalInputPosition();
+    problem->description = QString("#endif without #if at output line %1")
+                                   .arg(m_environment->locationTable()->anchorForOffset(output.offset()).anchor.line);
+    problemEncountered(problem);
+  }
+  else
+  {
+    environment()->leaveBlock();
+
+    _M_skipping[iflevel] = 0;
+    _M_true_test[iflevel] = 0;
+
+    --iflevel;
+    if(iflevel == 0) {
+      if(!guardCandidate.isEmpty()) {
+        checkGuardEnd = true;
+      }
+    }
+  }
+}
+
+uint pp::branchingHash() const
+{
+  uint hash = 0;
+  for( int a = 0; a <= iflevel; a++ ) {
+    hash *= 19;
+    if( _M_skipping[a] )
+      hash += 3;
+    if( _M_true_test[a] )
+      hash += 7;
+  }
+  return hash;
+}
+
+void pp::handle_ifdef (bool check_undefined, Stream& input)
+{
+  IndexedString macro_name = IndexedString::fromIndex(skip_identifier(input));
+///@todo eventually fix the block description
+  if(check_undefined && expand.in_header_section() && guardCandidate.isEmpty() && !hadGuardCandidate && iflevel == 0) {
+    //It's the first #ifndef and the header-section hasn't ended yet, assume it to be the header-guard
+    guardCandidate = macro_name;
+  }
+
+  hadGuardCandidate = true;
+  
+  environment()->enterBlock(input.inputPosition().line);//, QString("%1defined(%2)").arg(check_undefined ? "!" : "").arg(macro_name).toUtf8());
+
+  if (test_if_level())
+  {
+    pp_macro* macro = m_environment->retrieveMacro(macro_name, true);
+    bool value = false;
+    if( macro && macro->defined )
+      value = true;
+
+    if (check_undefined)
+      value = !value;
+
+    _M_true_test[iflevel] = value;
+    _M_skipping[iflevel] = !value;
+  }
+}
+
+
+void pp::handle_undef(Stream& input)
+{
+  skip_blanks (input, devnull());
+
+  IndexedString macro_name = IndexedString::fromIndex(skip_identifier(input));
+  RETURN_ON_FAIL(!macro_name.isEmpty());
+
+  pp_macro* macro = new pp_macro;
+  macro->file = currentFileName();
+  macro->name = macro_name;
+  macro->sourceLine = input.originalInputPosition().line;
+
+  macro->defined = false;
+
+  m_environment->setMacro(macro);
+}
+
+IndexedString definedText("defined");
+
+int pp::next_token (Stream& input)
+{
+  if (haveNextToken)
+    return nextToken;
+
+  skip_blanks(input, devnull());
+
+  if (input.atEnd())
+  {
+    return 0;
+  }
+
+  char ch = 0;
+  if(isCharacter(input.current()))
+    ch = characterFromIndex(input.current());
+  char ch2 = input.peekNextCharacter();
+
+  nextToken = 0;
+
+  switch (ch) {
+    case '/':
+      if (ch2 == '/' || ch2 == '*')
+      {
+        skip_comment_or_divop(input, devnull());
+        return next_token(input);
+      }
+      ++input;
+      nextToken = '/';
+      break;
+
+    case '<':
+      ++input;
+      if (ch2 == '<')
+      {
+        ++input;
+        nextToken = TOKEN_LT_LT;
+      }
+      else if (ch2 == '=')
+      {
+        ++input;
+        nextToken = TOKEN_LT_EQ;
+      }
+      else
+        nextToken = '<';
+
+      break;
+
+    case '>':
+      ++input;
+      if (ch2 == '>')
+      {
+        ++input;
+        nextToken = TOKEN_GT_GT;
+      }
+      else if (ch2 == '=')
+      {
+        ++input;
+        nextToken = TOKEN_GT_EQ;
+      }
+      else
+        nextToken = '>';
+
+      break;
+
+    case '!':
+      ++input;
+      if (ch2 == '=')
+      {
+        ++input;
+        nextToken = TOKEN_NOT_EQ;
+      }
+      else
+        nextToken = '!';
+
+      break;
+
+    case '=':
+      ++input;
+      if (ch2 == '=')
+      {
+        ++input;
+        nextToken = TOKEN_EQ_EQ;
+      }
+      else
+        nextToken = '=';
+
+      break;
+
+    case '|':
+      ++input;
+      if (ch2 == '|')
+      {
+        ++input;
+        nextToken = TOKEN_OR_OR;
+      }
+      else
+        nextToken = '|';
+
+      break;
+
+    case '&':
+      ++input;
+      if (ch2 == '&')
+      {
+        ++input;
+        nextToken = TOKEN_AND_AND;
+      }
+      else
+        nextToken = '&';
+
+      break;
+
+    default:
+      if (isLetter(ch) || ch == '_' || !isCharacter(input.current()))
+      {
+        token_text = IndexedString::fromIndex( skip_identifier (input) );
+        if (token_text == definedText)
+          nextToken = TOKEN_DEFINED;
+        else
+          nextToken = TOKEN_IDENTIFIER;
+      }
+      else if (isNumber(ch))
+      {
+        PreprocessedContents byteNumber;
+        {
+          Stream ns(&byteNumber);
+          skip_number(input, ns);
+        }
+
+        QString number(QString::fromUtf8(stringFromContents(byteNumber)));
+        int base = 10;
+        if (number.startsWith("0x")) {
+          base = 16;
+        } else if (number.startsWith('0')) {
+          base = 8;
+        }
+
+        if (number.endsWith('u', Qt::CaseInsensitive)) {
+          token_uvalue = number.toULong(0, base);
+          nextToken = TOKEN_UNUMBER;
+
+        } else {
+          token_value = number.toLong(0, base);
+          nextToken = TOKEN_NUMBER;
+        }
+      }
+      else
+      {
+        if(isCharacter(input.current()))
+          nextToken = characterFromIndex(input.current());
+        else
+          nextToken = TOKEN_IDENTIFIER;
+        ++input;
+      }
+  }
+
+  //kDebug(9007) << "Next token '" << ch << ch2 << "'" << nextToken << "txt" << token_text << "val" << token_value;
+
+  haveNextToken = true;
+  return nextToken;
+}
+
+int pp::next_token_accept (Stream& input)
+{
+  int result = next_token(input);
+  accept_token();
+  return result;
+}
+
+void pp::accept_token()
+{
+  haveNextToken = false;
+  nextToken = 0;
+}
+
+bool pp::hideNextMacro( ) const
+{
+  return hideNext;
+}
+
+void pp::setHideNextMacro( bool h )
+{
+  hideNext = h;
+}
+
+Environment* pp::environment( ) const
+{
+  return m_environment;
+}
+
+void pp::setEnvironment(Environment* env)
+{
+  delete m_environment;
+  m_environment = env;
+}
+
+const QList< Problem* > & rpp::pp::problems() const
+{
+  return m_problems;
+}
+
+void rpp::pp::problemEncountered(Problem *problem)
+{
+  m_problems.append(problem);
+}