qtbindings 4.6.3.0-x86-mingw32

data/ext/generator/parser/rpp/pp-macro-expander.h

@@ -0,0 +1,130 @@
+/*
+  Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
+  Copyright 2006 Hamish Rodda <rodda@kde.org>
+  Copyright 2007-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_MACRO_EXPANDER_H
+#define PP_MACRO_EXPANDER_H
+
+#include <QtCore/QList>
+#include <QtCore/QHash>
+
+
+#include "pp-macro.h"
+#include "pp-stream.h"
+#include "pp-scanner.h"
+#include "anchor.h"
+#include "../simplecursor.h"
+
+namespace KDevelop {
+  class IndexedString;
+}
+
+namespace rpp {
+
+class pp;
+
+//The value of a preprocessor function-like macro parameter
+class pp_actual {
+public:
+  pp_actual() : forceValid(false) {
+  }
+  QList<PreprocessedContents> text;
+  QList<Anchor> inputPosition; //Each inputPosition marks the beginning of one item in the text list
+  bool forceValid;
+
+  bool isValid() const {
+    return !text.isEmpty() || forceValid;
+  }
+  void clear() {
+    forceValid = false;
+    text.clear();
+    inputPosition.clear();
+  }
+
+  PreprocessedContents mergeText() const {
+    if(text.count() == 1)
+      return text.at(0);
+    
+    PreprocessedContents ret;
+    
+    foreach(const PreprocessedContents& t, text)
+      ret += t;
+    return ret;
+  }
+};
+
+class pp_frame
+{
+public:
+  pp_frame (pp_macro* __expandingMacro, const QList<pp_actual>& __actuals);
+
+  int depth;
+  pp_macro* expandingMacro;
+  QList<pp_actual> actuals;
+};
+
+class pp_macro_expander
+{
+public:
+  explicit pp_macro_expander(pp* engine, pp_frame* frame = 0, bool inHeaderSection = false);
+
+  pp_actual resolve_formal(IndexedString name, Stream& input);
+
+  /// Expands text with the known macros. Continues until it finds a new text line
+  /// beginning with #, at which point control is returned.
+  void operator()(Stream& input, Stream& output);
+
+  void skip_argument_variadics (const QList<pp_actual>& __actuals, pp_macro *__macro,
+                                Stream& input, Stream& output);
+
+  bool in_header_section() const {
+    return m_in_header_section;
+  }
+  
+  bool foundSignificantContent() const {
+    return m_found_significant_content;
+  }
+  
+  void startSignificantContentSearch() {
+    m_search_significant_content = true;
+  }
+  
+private:
+  pp* m_engine;
+  pp_frame* m_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;
+
+  bool m_in_header_section;
+  bool m_search_significant_content, m_found_significant_content;
+};
+
+}
+
+#endif // PP_MACRO_EXPANDER_H
+

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

@@ -0,0 +1,153 @@
+/*
+  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-macro.h"
+#include "chartools.h"
+// #include "macrorepository.h"
+#include "../kdevvarlengtharray.h"
+
+using namespace rpp;
+
+#if 0
+namespace rpp {
+using namespace KDevelop;
+DEFINE_LIST_MEMBER_HASH(pp_macro, definition, IndexedString)
+DEFINE_LIST_MEMBER_HASH(pp_macro, formals, IndexedString)
+}
+#endif
+
+pp_macro::~pp_macro() {
+//   freeAppendedLists();
+}
+
+bool pp_macro::operator==(const pp_macro& rhs) const {
+  if(completeHash() != rhs.completeHash())
+    return false;
+  
+  return name == rhs.name && file == rhs.file &&
+         file == rhs.file &&
+         sourceLine == rhs.sourceLine &&
+         defined == rhs.defined &&
+         hidden == rhs.hidden &&
+         function_like == rhs.function_like &&
+         variadics == rhs.variadics &&
+         fixed == rhs.fixed &&
+         definition == rhs.definition &&
+         formals == rhs.formals;
+//          listsEqual(rhs);
+}
+
+void pp_macro::invalidateHash() {
+  m_valueHashValid = false;
+}
+
+pp_macro::pp_macro(const IndexedString& nm) : name(nm)
+  , sourceLine(-1)
+  , defined(true)
+  , hidden(false)
+  , function_like(false)
+  , variadics(false)
+  , fixed(false)
+  , m_valueHashValid(false)
+  , m_valueHash(0)
+{
+//   initializeAppendedLists();
+}
+
+pp_macro::pp_macro(const pp_macro& rhs, bool dynamic) : 
+   name(rhs.name),
+   file(rhs.file),
+   sourceLine(rhs.sourceLine),
+   defined(rhs.defined),
+   hidden(rhs.hidden),
+   function_like(rhs.function_like),
+   variadics(rhs.variadics),
+   fixed(rhs.fixed),
+   m_valueHashValid(true),
+   m_valueHash(rhs.valueHash()),
+   definition(rhs.definition),
+   formals(rhs.formals)
+{
+//   initializeAppendedLists(dynamic);
+//   copyListsFrom(rhs);
+}
+
+pp_macro::pp_macro(const char* nm) : name(IndexedString(nm, strlen(nm)))
+  , sourceLine(-1)
+  , defined(true)
+  , hidden(false)
+  , function_like(false)
+  , variadics(false)
+  , fixed(false)
+  , m_valueHashValid(false)
+  , m_valueHash(0)
+{
+//   initializeAppendedLists();
+}
+
+QString pp_macro::toString() const {
+  QString ret = name.str();
+  if(!defined)
+    ret = "undef " + ret;
+  if(function_like) {
+    ret += '(';
+    bool first = true;
+    for(uint a = 0; a < formals.size(); ++a) {
+      if(!first)
+        ret += ", ";
+      first = false;
+      
+      ret += formals[a].str();
+    }
+    ret += ')';
+  }
+  ret += ' ' + QString::fromUtf8(stringFromContents((uint*)definition.constData(), definition.size()));
+  
+  return ret;
+}
+
+void pp_macro::setDefinitionText(QString definition) {
+  setDefinitionText(definition.toUtf8());
+}
+
+void pp_macro::setDefinitionText(QByteArray definition) {
+  foreach(uint i, convertFromByteArray(definition))
+    this->definition.append(IndexedString::fromIndex(i));
+}
+
+void pp_macro::computeHash() const {
+    if( m_valueHashValid )
+      return;
+
+    m_valueHash = 27 * ( 137 + (defined ? 1 : 0 ) );
+
+    m_valueHash += 1741 * file.hash() + 238 * sourceLine + (hidden ? 19 : 0) + (function_like ? 811241 : 0) + (variadics ? 129119 : 0) + (fixed ? 1807 : 0);
+  
+    foreach(const IndexedString& definitionComponent, definition)
+      m_valueHash = definitionComponent.hash() + 17 * m_valueHash;
+
+    int a = 1;
+    foreach(const IndexedString& formal, formals) {
+        a *= 19;
+        m_valueHash += a * formal.hash();
+    }
+    m_valueHashValid = true;
+}

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

@@ -0,0 +1,176 @@
+/*
+  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_MACRO_H
+#define PP_MACRO_H
+
+//krazy:excludeall=inline
+
+#include <QtCore/QStringList>
+#include <QVector>
+#include "../indexedstring.h"
+#include "../cppparser_export.h"
+// #include "appendedlist.h"
+// #include <language/editor/hashedstring.h>
+// #include <language/duchain/appendedlist.h>
+
+#define FOREACH_CUSTOM(item, container, size) for(int a = 0, mustDo = 1; a < (int)size; ++a) if((mustDo = 1)) for(item(container[a]); mustDo; mustDo = 0)
+
+namespace rpp {
+
+// Q_DECL_EXPORT DECLARE_LIST_MEMBER_HASH(pp_macro, definition, IndexedString)
+// Q_DECL_EXPORT DECLARE_LIST_MEMBER_HASH(pp_macro, formals, IndexedString)
+
+  //This contains the data of a macro that can be marshalled by directly copying the memory
+struct CPPPARSER_EXPORT pp_macro
+{ ///@todo enable structure packing
+  pp_macro(const IndexedString& name = IndexedString());
+  pp_macro(const char* name);
+  pp_macro(const pp_macro& rhs, bool dynamic = true);
+  ~pp_macro();
+  
+  uint classSize() const {
+    return sizeof(pp_macro);
+  }
+  
+  /*uint itemSize() const {
+    return dynamicSize();
+  }*/
+  
+  typedef uint HashType;
+
+  IndexedString name;
+  IndexedString file;
+  
+  int sourceLine; //line
+
+  bool defined: 1; // !isUndefMacro
+  bool hidden: 1;
+  bool function_like: 1; // hasArguments
+  bool variadics: 1;
+  bool fixed : 1; //If this is set, the macro can not be overridden or undefined.
+  mutable bool m_valueHashValid : 1;
+  
+  //The valueHash is not necessarily valid
+  mutable HashType m_valueHash; //Hash that represents the values of all macros
+  
+  bool operator==(const pp_macro& rhs) const;
+  
+  bool isUndef() const  {
+    return !defined;
+  }
+  
+  unsigned int hash() const {
+    return completeHash();
+  }
+  
+  HashType idHash() const {
+    return name.hash();
+  }
+  
+  QString toString() const;
+  
+  struct NameCompare {
+    bool operator () ( const pp_macro& lhs, const pp_macro& rhs ) const {
+      return lhs.name.index() < rhs.name.index();
+    }
+    #ifdef Q_CC_MSVC
+    
+    HashType operator () ( const pp_macro& macro ) const
+    {
+        return macro.idHash();
+    }
+    
+    enum
+    { // parameters for hash table
+    bucket_size = 4,  // 0 < bucket_size
+    min_buckets = 8}; // min_buckets = 2 ^^ N, 0 < N
+    #endif
+  };
+
+  //Hash over id and value
+  struct CompleteHash {
+    HashType operator () ( const pp_macro& lhs ) const {
+        return lhs.completeHash();
+    }
+    
+    #ifdef Q_CC_MSVC
+    
+    bool operator () ( const pp_macro& lhs, const pp_macro& rhs ) const {
+        HashType lhash = lhs.valueHash()+lhs.idHash();
+        HashType rhash = rhs.valueHash()+rhs.idHash();
+        if( lhash < rhash ) return true;
+        else if( lhash > rhash ) return false;
+
+      int df = lhs.name.str().compare( rhs.name.str() );
+      return df < 0;
+    }
+    
+    enum
+    { // parameters for hash table
+    bucket_size = 4,  // 0 < bucket_size
+    min_buckets = 8}; // min_buckets = 2 ^^ N, 0 < N
+    #endif
+  };
+  
+  HashType valueHash() const {
+    if( !m_valueHashValid ) computeHash();
+    return m_valueHash;
+  }
+
+  ///Hash that identifies all of this macro, the value and the identity
+  HashType completeHash() const {
+    return valueHash() + idHash() * 3777;
+  }
+  
+  void invalidateHash();
+  
+  ///Convenient way of setting the definition, it is tokenized automatically
+  ///@param definition utf-8 representation of the definition text
+  void setDefinitionText(QByteArray definition);
+  
+  ///More convenient overload
+  void setDefinitionText(QString definition);
+  
+  void setDefinitionText(const char* definition) {
+    setDefinitionText(QByteArray(definition));
+  }
+  
+//   START_APPENDED_LISTS(pp_macro)
+//   APPENDED_LIST_FIRST(pp_macro, IndexedString, definition)
+//   APPENDED_LIST(pp_macro, IndexedString, formals, definition)
+//   END_APPENDED_LISTS(pp_macro, formals)
+
+  QVector<IndexedString> definition;
+  QVector<IndexedString> formals;
+
+  private:
+    pp_macro& operator=(const pp_macro& rhs);
+    void computeHash() const;
+};
+
+}
+
+inline uint qHash( const rpp::pp_macro& m ) {
+  return (uint)m.idHash();
+}
+
+#endif // PP_MACRO_H
+