rock-qtbindings 4.8.6.5

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

@@ -0,0 +1,267 @@
+/*
+  Copyright 2005 Roberto Raggi <roberto@kdevelop.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.
+*/
+
+#ifndef PP_ENGINE_H
+#define PP_ENGINE_H
+
+//krazy:excludeall=inline
+
+#include <QtCore/QHash>
+
+#include <QtCore/QStack>
+
+#include "../cppparser_export.h"
+#include "../problem.h"
+
+#include "pp-macro.h"
+#include "pp-macro-expander.h"
+#include "pp-scanner.h"
+
+typedef QVector<unsigned int> PreprocessedContents;
+
+namespace rpp {
+
+class Preprocessor;
+class Environment;
+
+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_OP2(op) \
+  inline Value operator op(const Value &other) \
+  { \
+    Value ret; \
+    if (is_ulong () || other.is_ulong ()) \
+      ret.set_ulong (ul op other.ul); \
+    else \
+      ret.set_long (l op other.l); \
+    return ret; \
+  }
+
+#define PP_DEFINE_BIN_OP(op, op2) \
+  inline Value &operator op2(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(+, +=)
+  PP_DEFINE_BIN_OP(-, -=)
+  PP_DEFINE_BIN_OP(*, *=)
+  PP_DEFINE_BIN_OP(/, /=)
+  PP_DEFINE_BIN_OP(%, %=)
+  PP_DEFINE_BIN_OP(<<, <<=)
+  PP_DEFINE_BIN_OP(>>, >>=)
+  PP_DEFINE_BIN_OP(&, &=)
+  PP_DEFINE_BIN_OP(|, |=)
+  PP_DEFINE_BIN_OP(^, ^=)
+  PP_DEFINE_BIN_OP2(<)
+  PP_DEFINE_BIN_OP2(>)
+  PP_DEFINE_BIN_OP2(!=)
+  PP_DEFINE_BIN_OP2(==)
+  PP_DEFINE_BIN_OP2(<=)
+  PP_DEFINE_BIN_OP2(>=)
+  PP_DEFINE_BIN_OP2(&&)
+  PP_DEFINE_BIN_OP2(||)
+
+#undef PP_DEFINE_BIN_OP
+};
+
+
+class CPPPARSER_EXPORT pp
+{
+  Environment* m_environment;
+  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;
+  QStack<IndexedString> m_files;
+  Preprocessor* m_preprocessor;
+  QList<Problem*> m_problems;
+
+  enum { MAX_LEVEL = 512 };
+  int _M_skipping[MAX_LEVEL];
+  int _M_true_test[MAX_LEVEL];
+  int iflevel;
+  int nextToken;
+  bool haveNextToken;
+  bool hideNext;
+  bool hadGuardCandidate, checkGuardEnd;
+  IndexedString guardCandidate;
+
+  union {
+    long token_value;
+    unsigned long token_uvalue;
+  };
+  IndexedString token_text;
+
+  enum TOKEN_TYPE
+  {
+    TOKENS_START = 1000,
+    TOKEN_NUMBER,
+    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,
+    TOKENS_END
+  };
+
+public:
+  pp(Preprocessor* preprocessor);
+  ~pp();
+
+  Preprocessor* preprocessor();
+
+  enum StringType { File, Data };
+
+  ///@todo Remove
+  inline QString currentFileNameString () const { return m_files.top().str(); }
+  
+  inline IndexedString currentFileName () const { return m_files.top(); }
+
+  Value eval_expression (Stream& input);
+
+  /** Read file @p fileName and preprocess
+   *  Currently the file is expected to be utf8-encoded. */
+  PreprocessedContents processFile(const QString& fileName);
+
+  /** Preprocess @p fileName with content @p data. Do not actually open file @p fileName
+   *  Currently the file is expected to be utf8-encoded. */
+  PreprocessedContents processFile(const QString& fileName, const QByteArray& data);
+
+  void operator () (Stream& input, Stream& output);
+
+  void checkMarkNeeded(Stream& input, Stream& output);
+
+  bool hideNextMacro() const;
+  void setHideNextMacro(bool hideNext);
+
+  Environment* environment() const;
+  // once set, belongs to the engine
+  void setEnvironment(Environment* env);
+
+  const QList<Problem*>& problems() const;
+  void problemEncountered(Problem *problem);
+
+  //Returns a hash-value computed from all until currently open branching-conditions and their decisions(like #ifdef's)
+  uint branchingHash() const;
+  
+private:
+  void processFileInternal(const QString& fileName, const QByteArray& fileContent, PreprocessedContents& result);
+
+  int skipping() const;
+  bool test_if_level();
+
+  void createProblem(Stream& input, const QString& description);
+  
+  void skip(Stream& input, Stream& output, bool outputText = true);
+
+  Value eval_primary(Stream& input);
+
+  Value eval_multiplicative(Stream& input);
+
+  Value eval_additive(Stream& input);
+
+  Value eval_shift(Stream& input);
+
+  Value eval_relational(Stream& input);
+
+  Value eval_equality(Stream& input);
+
+  Value eval_and(Stream& input);
+
+  Value eval_xor(Stream& input);
+
+  Value eval_or(Stream& input);
+
+  Value eval_logical_and(Stream& input);
+
+  Value eval_logical_or(Stream& input);
+
+  Value eval_constant_expression(Stream& input);
+
+  void handle_directive(uint directive, Stream& input, Stream& output);
+
+  void handle_include(bool skip_current_path, Stream& input, Stream& output);
+
+  void handle_define(Stream& input);
+
+  void handle_if(Stream& input);
+
+  void handle_else(int sourceLine);
+
+  void handle_elif(Stream& input);
+
+  void handle_endif(Stream& input, Stream& output);
+
+  void handle_ifdef(bool check_undefined, Stream& input);
+
+  void handle_undef(Stream& input);
+
+  int next_token (Stream& input);
+  int next_token_accept (Stream& input);
+  void accept_token();
+};
+
+}
+
+#endif // PP_ENGINE_H
+
+

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

@@ -0,0 +1,271 @@
+/*
+  Copyright 2006 Hamish Rodda <rodda@kde.org>
+  Copyright 2008-2009 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 "../indexedstring.h" //Needs to be up here, so qHash(IndexedString) is found
+
+#include <QtDebug>
+
+#include "pp-environment.h"
+
+#include "pp-macro.h"
+#include "pp-engine.h"
+#include "pp-location.h"
+// #include "macrorepository.h"
+
+using namespace rpp;
+
+Environment::Environment(pp* preprocessor)
+  : m_replaying(false)
+  , m_preprocessor(preprocessor)
+  , m_locationTable(new LocationTable)
+{
+}
+
+Environment::~Environment()
+{
+  delete m_locationTable;
+  if(!currentBlock()) {
+    //Delete all macros that are still here, because they are not part of a block
+    foreach(pp_macro* macro, m_environment)
+      delete macro;
+  }
+}
+
+LocationTable* Environment::locationTable() const
+{
+  return m_locationTable;
+}
+
+LocationTable* Environment::takeLocationTable()
+{
+  LocationTable* ret = m_locationTable;
+  m_locationTable = new LocationTable;
+  return ret;
+}
+
+MacroBlock* Environment::firstBlock() const
+{
+  if (!m_blocks.isEmpty())
+    return m_blocks[0];
+
+  return 0;
+}
+
+MacroBlock* Environment::currentBlock() const
+{
+  if (!m_blocks.isEmpty())
+    return m_blocks.top();
+
+  return 0;
+}
+
+void Environment::enterBlock(MacroBlock* block)
+{
+  if (!m_blocks.isEmpty())
+    m_blocks.top()->childBlocks.append(block);
+
+  m_blocks.push(block);
+}
+
+void Environment::visitBlock(MacroBlock* block, int depth)
+{
+  if (depth++ > 100) {
+    // TODO detect recursion?
+    qWarning() << "Likely cyclic include, aborting macro replay at depth 100" ;
+    return;
+  }
+
+  if (!block->condition.isEmpty()) {
+    Stream cs(&block->condition, Anchor(0,0));
+    Value result = m_preprocessor->eval_expression(cs);
+    if (result.is_zero()) {
+      if (block->elseBlock)
+        visitBlock(block->elseBlock, depth);
+      return;
+    }
+  }
+
+  bool wasReplaying = m_replaying;
+  m_replaying = true;
+
+  int macroIndex = 0;
+  int childIndex = 0;
+  while (macroIndex < block->macros.count() || childIndex < block->childBlocks.count()) {
+    MacroBlock* child = childIndex < block->childBlocks.count() ? block->childBlocks.at(childIndex) : 0;
+    pp_macro* macro = macroIndex < block->macros.count() ? block->macros.at(macroIndex) : 0;
+
+    Q_ASSERT(child || macro);
+
+    bool visitMacro = macro && (!child || (child->sourceLine < macro->sourceLine));
+
+    if (!visitMacro) {
+      Q_ASSERT(child);
+      visitBlock(child, depth);
+      ++childIndex;
+
+    } else {
+      Q_ASSERT(macro);
+      if (macro->defined)
+        setMacro(macro);
+      else
+        clearMacro(macro->name);
+      ++macroIndex;
+    }
+  }
+
+  // No need to visit else block, it will be skipped (already a matched block)
+
+  m_replaying = wasReplaying;
+}
+
+MacroBlock* Environment::enterBlock(int sourceLine, const QVector<uint>& condition)
+{
+  MacroBlock* ret = new MacroBlock(sourceLine);
+  ret->condition = condition;
+
+  enterBlock(ret);
+
+  return ret;
+}
+
+MacroBlock* Environment::elseBlock(int sourceLine, const QVector<uint>& condition)
+{
+  MacroBlock* ret = new MacroBlock(sourceLine);
+  ret->condition = condition;
+
+  Q_ASSERT(!m_blocks.isEmpty());
+  m_blocks.top()->elseBlock = ret;
+
+  m_blocks.pop();
+  m_blocks.push(ret);
+
+  return ret;
+}
+
+void Environment::swapMacros( Environment* parentEnvironment ) {
+  EnvironmentMap oldEnvironment = m_environment;
+  m_environment = parentEnvironment->m_environment;
+  parentEnvironment->m_environment = oldEnvironment;
+  
+  if(!parentEnvironment->currentBlock()) {
+    
+    if(currentBlock()) {
+      foreach(pp_macro* macro, m_environment)
+        currentBlock()->macros.append(macro);
+    }
+  }else{
+    //If both sides have a macro-block, it should be the same one, else the macros can not be safely swapped
+    Q_ASSERT(parentEnvironment->firstBlock() == firstBlock());
+  }
+}
+
+void Environment::leaveBlock()
+{
+  m_blocks.pop();
+}
+
+void Environment::clear()
+{
+  m_environment.clear();
+  m_blocks.clear();
+}
+
+void Environment::clearMacro(const IndexedString& name)
+{
+//   pp_macro* undef = new pp_macro();
+//   undef->name = name;
+//   undef->defined = false;
+//   if(!m_replaying)
+//     m_blocks.top()->macros.append(undef);
+// 
+//   setMacro(undef); //Before, m_environment.remove(..) was called
+
+ if(!m_replaying) {
+    pp_macro* undef = new pp_macro;
+    undef->name = name;
+    undef->defined = false;
+    m_blocks.top()->macros.append(undef);
+  }
+
+  ///@todo Think about how this plays together with environment-management
+  ///We need undef-macros to be put into the definedMacros etc. lists
+  m_environment.remove(name);
+}
+
+void Environment::setMacro(pp_macro* macro)
+{
+  if (!m_replaying && !m_blocks.isEmpty())
+    m_blocks.top()->macros.append(macro);
+
+/*  if( !macro->defined )
+    clearMacro(macro->name);
+  else*/
+    m_environment.insert(macro->name, macro);
+}
+
+const Environment::EnvironmentMap& Environment::environment() const {
+  return m_environment;
+}
+
+pp_macro* Environment::retrieveStoredMacro(const IndexedString& name) const
+{
+  EnvironmentMap::const_iterator it = m_environment.find(name);
+  if (it != m_environment.end())
+    return *it;
+
+  return 0;
+}
+
+pp_macro* Environment::retrieveMacro(const IndexedString& name, bool /*isImportant*/) const
+{
+  return retrieveStoredMacro(name);
+}
+
+MacroBlock::MacroBlock(int _sourceLine)
+  : elseBlock(0)
+  , sourceLine(_sourceLine)
+{
+}
+
+MacroBlock::~MacroBlock()
+{
+  foreach (pp_macro* macro, macros)
+    delete macro;
+  
+  qDeleteAll(childBlocks);
+  delete elseBlock;
+}
+
+void MacroBlock::setMacro(pp_macro* macro)
+{
+  macros.append(macro);
+}
+
+void rpp::Environment::cleanup()
+{
+  delete firstBlock();
+  clear();
+}
+
+QList<pp_macro*> Environment::allMacros() const
+{
+  return m_environment.values();
+}

data/ext/generator/parser/rpp/pp-environment.h

@@ -0,0 +1,119 @@
+/*
+  Copyright 2006 Hamish Rodda <rodda@kde.org>
+  Copyright 2008-2009 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 PP_ENVIRONMENT_H
+#define PP_ENVIRONMENT_H
+
+#include <QHash>
+#include <QMap>
+
+#include <QStack>
+
+#include "../cppparser_export.h"
+#include "../indexedstring.h"
+
+namespace rpp {
+
+class pp_macro;
+class pp;
+class LocationTable;
+
+class CPPPARSER_EXPORT MacroBlock
+{
+public:
+  MacroBlock(int _sourceLine);
+  virtual ~MacroBlock();
+
+  void setMacro(pp_macro* macro);
+
+  QList<MacroBlock*> childBlocks;
+
+  // The condition that opened this block(list of string indices)
+  QVector<uint> condition;
+  // The block to use if this block's condition was not met
+  MacroBlock* elseBlock;
+
+  // The source line where the block occurred
+  int sourceLine;
+
+  // This block is the owner of these macros
+  QList<pp_macro*> macros;
+};
+
+class CPPPARSER_EXPORT Environment
+{
+public:
+  typedef QHash<IndexedString, pp_macro*> EnvironmentMap;
+
+  Environment(pp* preprocessor);
+  virtual ~Environment();
+
+  MacroBlock* firstBlock() const;
+  MacroBlock* currentBlock() const;
+
+  void enterBlock(MacroBlock* block);
+  MacroBlock* enterBlock(int sourceLine, const QVector<uint>& condition = QVector<uint>());
+  MacroBlock* elseBlock(int sourceLine, const QVector<uint>& condition = QVector<uint>());
+  void leaveBlock();
+
+  // Replay previously saved blocks on this environment
+  void visitBlock(MacroBlock* block, int depth = 0);
+
+  void clear();
+
+  // For those not interested in the result, just in getting memory released etc.
+  void cleanup();
+
+  void clearMacro(const IndexedString& name);
+
+  //Note: Undef-macros are allowed too
+  virtual void setMacro(pp_macro* macro);
+
+  virtual pp_macro* retrieveMacro(const IndexedString& name, bool isImportant) const;
+  
+  //Returns macros that are really stored locally(retrieveMacro may be overridden to perform more complex actions)
+  pp_macro* retrieveStoredMacro(const IndexedString& name) const;
+  
+  QList<pp_macro*> allMacros() const;
+
+  //Take the set of environment-macros from the given environment
+  virtual void swapMacros( Environment* parentEnvironment );
+
+  //Faster access then allMacros(..), because nothing is copied
+  const EnvironmentMap& environment() const; //krazy:exclude=constref
+
+  LocationTable* locationTable() const;
+  LocationTable* takeLocationTable();
+
+private:
+  EnvironmentMap m_environment;
+
+  QStack<MacroBlock*> m_blocks;
+  bool m_replaying;
+  pp* m_preprocessor;
+  LocationTable* m_locationTable;
+};
+
+}
+
+#endif // PP_ENVIRONMENT_H
+
+

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

@@ -0,0 +1,38 @@
+/*
+  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-internal.h"
+#include "chartools.h"
+
+bool rpp::isComment(Stream& input)
+{
+  uint c1 = input;
+  uint c2 = input.peek();
+
+  return c1 == indexFromCharacter('/') && (c2 == indexFromCharacter('/') || c2 == indexFromCharacter('*'));
+}
+
+rpp::Stream& rpp::devnull()
+{
+  // Multithread safe
+  static rpp::Stream null;
+  return null;
+}