rock-qtbindings 4.8.6.5

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

@@ -0,0 +1,65 @@
+/*
+  Copyright 2005 Harald Fernengel <harry@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 "preprocessor.h"
+
+#include <QFile>
+#include <QTextStream>
+
+#include "pp-stream.h"
+#include "pp-engine.h"
+#include "pp-environment.h"
+
+using namespace rpp;
+
+Preprocessor::~Preprocessor()
+{
+}
+
+// QString Preprocessor::processString(const QString& string)
+// {
+//     pp proc(this);
+// 
+//     QString ret = QString::fromUtf8(proc.processFile("anonymous", string.toUtf8()));
+// 
+//     proc.environment()->cleanup();
+// 
+//     return ret;
+// }
+
+Stream * Preprocessor::sourceNeeded( QString & fileName, IncludeType type, int sourceLine, bool skipCurrentPath )
+{
+  Q_UNUSED(fileName)
+  Q_UNUSED(type)
+  Q_UNUSED(sourceLine)
+  Q_UNUSED(skipCurrentPath)
+
+  return 0;
+}
+
+void Preprocessor::headerSectionEnded(rpp::Stream& stream)
+{
+  Q_UNUSED(stream)
+}
+
+void Preprocessor::foundHeaderGuard(rpp::Stream& /*stream*/, IndexedString /*guardName*/)
+{
+}

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

@@ -0,0 +1,80 @@
+/*
+  Copyright 2005 Harald Fernengel <harry@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.
+*/
+
+#ifndef PREPROCESSOR_H
+#define PREPROCESSOR_H
+
+#include <QtCore/QString>
+#include "../indexedstring.h"
+#include "../cppparser_export.h"
+
+namespace rpp {
+
+class Stream;
+
+class CPPPARSER_EXPORT Preprocessor
+{
+public:
+    enum IncludeType {
+      /// An include specified as being local (eg. "file.h")
+      IncludeLocal,
+      /// An include specified as being global (eg. &lt;file.h&gt;)
+      IncludeGlobal
+    };
+
+    virtual ~Preprocessor();
+
+//     QString processString(const QString& string);
+
+    
+    /**
+     * This function is called by the preprocessor whenever
+     * it encounters an include directive.
+     *
+     * This class is permitted to modify \a fileName%; this
+     * value will be used when marking the file in the preprocessed
+     * output.
+     *
+     * \param fileName name of the source file to include
+     * \param type the way that the file was requested
+     * \param skipCurrentPath whether the path fileName was found in should be skipped(gcc extension include_next)
+     *
+     * \return a Stream with the appropriate contents to allow
+     * the file to be #included.  Ownership of the Stream is yielded to
+     * class pp at this point.
+     */
+    virtual Stream* sourceNeeded(QString& fileName, IncludeType type, int sourceLine, bool skipCurrentPath);
+
+    /**
+     * Is called when the header-section ended. The header-section is the top of the file, that consists only if #include, #define, and #ifdef statements, or comments.
+     * It ends as soon as anything else is found. You can use stream.toEnd() to stop the preprocessing.
+     * */
+    virtual void headerSectionEnded(rpp::Stream& stream);
+    
+    /**
+     * Is called when a header-guard protection has been detected for the currently processed file
+     * */
+    virtual void foundHeaderGuard(rpp::Stream& stream, IndexedString guardName);
+};
+
+}
+
+#endif

data/ext/generator/parser/rpp/rpp.pri

@@ -0,0 +1,2 @@
+SOURCES += $$RXXPATH/rpp/preprocessor.cpp
+INCLUDEPATH += $$PWD $$RXXPATH/rpp

data/ext/generator/parser/rpp/test/t001.cpp

@@ -0,0 +1,23 @@
+.
+/*
+  ciao roberto
+*/
+.
+#define A 1
+.
+#if A - 1 == 0
+OK
+#else
+KO
+#endif
+.
+#undef A
+.
+#define A(a,b) a + b
+#define C(a,b) A(b,a)
+.
+#define comp(a,b) #a #b
+#define str(a) #a
+.
+C(1,2) comp(me, you) str(kdevelop is cool)
+.

data/ext/generator/parser/rpp/test/t002.cpp

@@ -0,0 +1,15 @@
+EXPECT 2x DIV0 ERROR
+#define A 0
+.
+#if 10 / A
+KO
+#else
+OK
+#endif
+.
+#if 10 % A
+KO
+#else
+OK
+#endif
+.

data/ext/generator/parser/rpp/test/t003.cpp

@@ -0,0 +1,10 @@
+.
+#define B
+#define A defined B
+.
+#if A
+OK
+#else
+KO
+#endif
+.

data/ext/generator/parser/rpp/test/t004.cpp

@@ -0,0 +1,9 @@
+.
+#define M A\
+  B C
+.
+M
+.
+.
+.
+.

data/ext/generator/parser/rpp/test/t005.cpp

@@ -0,0 +1,10 @@
+.
+#define COND 1 \
+    && 0
+.
+#if COND
+KO
+#else
+OK
+#endif
+.

data/ext/generator/parser/rpp/test/t006.cpp

@@ -0,0 +1,10 @@
+.
+#define code(more) \
+ int main () \
+ { more \
+ }
+.
+code(int x;
+     int y)
+.
+.

data/ext/generator/parser/rpp/test/t007.cpp

@@ -0,0 +1,6 @@
+/*
+,
+,
+*/
+ciao
+.

data/ext/generator/parser/rpp/test/t008.cpp

@@ -0,0 +1,6 @@
+#define Q_FOO(a) blah(int a)
+
+#define qfoo(a) Q_FOO(a)
+
+// Should be blah(int j)
+qfoo(j)

data/ext/generator/parser/rpp/test/t009.cpp

@@ -0,0 +1,5 @@
+# define __nonnull(params) params
+__nonnull((1));
+#ifdef blah
+#define blah2(a) ((a).)
+#endif

data/ext/generator/parser/rpp/test/t010.cpp

@@ -0,0 +1,15 @@
+#include "test.h"
+
+#define TEST_H
+
+#if defined(TEST_H)
+OK
+#else
+ERROR
+#endif
+
+#if !defined(TEST_H)
+ERROR
+#else
+OK
+#endif

data/ext/generator/parser/rpp/test/t011.cpp

@@ -0,0 +1,9 @@
+#define BLANK_MACRO
+
+class BLANK_MACRO Blah
+{
+public:
+  void BLANK_MACRO testFoo() const;
+
+  void testMe();
+};

data/ext/generator/parser/rpp/tests/CMakeLists.txt

@@ -0,0 +1,17 @@
+set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
+include_directories( ${CMAKE_SOURCE_DIR}/languages/cpp/parser ${CMAKE_CURRENT_SOURCE_DIR}/..  )
+
+
+########### next target ###############
+
+set(pp_SRCS
+    main.cpp
+)
+
+kde4_add_executable(pp TEST ${pp_SRCS})
+target_link_libraries(pp ${KDE4_KDECORE_LIBS} kdev4cpprpp)
+
+if (WIN32)
+	# Realign the stack, for compatibility with an older ABI.
+	set_target_properties (pp PROPERTIES COMPILE_FLAGS -mstackrealign)
+endif (WIN32)

data/ext/generator/parser/rpp/tests/main.cpp

@@ -0,0 +1,69 @@
+/*
+  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.
+*/
+
+#include "pp-engine.h"
+
+#include <QtDebug>
+
+#include "preprocessor.h"
+#include "pp-environment.h"
+#include "pp-location.h"
+#include "chartools.h"
+
+using namespace rpp;
+
+int main (int /*argc*/, char *argv[])
+{
+  bool no_stdinc = false;
+  bool no_stdincpp = false;
+
+  char const *filename = *++argv;
+  if (!filename)
+    {
+      qDebug() << "usage: pp file.cpp";
+      return EXIT_FAILURE;
+    }
+
+  Preprocessor p;
+
+  QStringList ip;
+
+  pp preprocess(&p);
+
+  preprocess.processFile(QString("pp-configuration")); // ### put your macros here!
+
+  preprocess.environment()->enterBlock(0, PreprocessedContents());
+
+  QString result = QString::fromUtf8(stringFromContents(preprocess.processFile(QString(filename))));
+
+  preprocess.environment()->cleanup();
+
+  QStringList resultLines = result.split('\n');
+  for (int i = 0; i < resultLines.count(); ++i)
+    qDebug() << i << ":" << resultLines[i];
+
+  preprocess.environment()->locationTable()->dump();
+  
+  /*foreach (const Preprocessor::MacroItem& macro, p.macros())
+    kDebug(9007) << "Macro '" << macro.name << "' param (" << macro.parameters << ") def (" << macro.definition << ") isFnLike (" << macro.isFunctionLike << ") filename (" << macro.fileName << ")";*/
+
+  return EXIT_SUCCESS;
+}
+

data/ext/generator/parser/rxx.pri

@@ -0,0 +1,50 @@
+
+isEmpty(RXXPATH):RXXPATH = $$PWD
+
+INCLUDEPATH += $$RXXPATH
+
+DEFINES += RXX_ALLOCATOR_INIT_0
+
+HEADERS += $$RXXPATH/ast.h \
+           $$RXXPATH/lexer.h \
+           $$RXXPATH/listnode.h \
+           $$RXXPATH/parser.h \
+           $$RXXPATH/rxx_allocator.h \
+           $$RXXPATH/memorypool.h \
+           $$RXXPATH/tokens.h \
+           $$RXXPATH/symbol.h \
+           $$RXXPATH/control.h \
+           $$RXXPATH/visitor.h \
+           $$RXXPATH/default_visitor.h \
+           $$RXXPATH/dumptree.h \
+           $$RXXPATH/binder.h \
+           $$RXXPATH/codemodel.h \
+           $$RXXPATH/codemodel_fwd.h \
+           $$RXXPATH/type_compiler.h \
+           $$RXXPATH/name_compiler.h \
+           $$RXXPATH/declarator_compiler.h \
+           $$RXXPATH/class_compiler.h \
+           $$RXXPATH/codemodel_finder.h \
+           $$RXXPATH/compiler_utils.h \
+           $$RXXPATH/kdevsharedptr.h \
+           $$RXXPATH/problem.h
+
+SOURCES += $$RXXPATH/ast.cpp \
+           $$RXXPATH/lexer.cpp \
+           $$RXXPATH/listnode.cpp \
+           $$RXXPATH/parser.cpp \
+           $$RXXPATH/memorypool.cpp \
+           $$RXXPATH/control.cpp \
+           $$RXXPATH/visitor.cpp \
+           $$RXXPATH/default_visitor.cpp \
+           $$RXXPATH/dumptree.cpp \
+           $$RXXPATH/tokens.cpp \
+           $$RXXPATH/binder.cpp \
+           $$RXXPATH/codemodel.cpp \
+           $$RXXPATH/type_compiler.cpp \
+           $$RXXPATH/name_compiler.cpp \
+           $$RXXPATH/declarator_compiler.cpp \
+           $$RXXPATH/class_compiler.cpp \
+           $$RXXPATH/codemodel_finder.cpp \
+           $$RXXPATH/compiler_utils.cpp \
+           $$RXXPATH/problem.cpp

data/ext/generator/parser/rxx_allocator.h

@@ -0,0 +1,128 @@
+/* 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>
+
+/**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;
+  }
+
+  /**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
+

data/ext/generator/parser/safetycounter.h

@@ -0,0 +1,57 @@
+
+/***************************************************************************
+   Copyright 2006 David Nolden <david.nolden.kdevelop@art-master.de>
+***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef __SAFETYCOUNTER_H__
+#define __SAFETYCOUNTER_H__
+
+#include <QtCore/QtDebug>
+
+struct SafetyCounter {
+  int safetyCounter;
+  const int maxSafetyCounter;
+  
+  SafetyCounter( int max = 40000 ) : safetyCounter(0), maxSafetyCounter(max) {
+  }
+  
+  void init() {
+    safetyCounter = 0;
+  }
+  
+  SafetyCounter& operator ++() {
+    safetyCounter++;
+    return *this;
+  }
+
+  ///Returns whether the counter is ok, but without increasing it
+  bool ok() const {
+    return safetyCounter < maxSafetyCounter;
+  }
+  
+  operator bool() {
+    safetyCounter++;
+    bool ret = safetyCounter < maxSafetyCounter;
+	  if( !ret ) {
+			if( safetyCounter == maxSafetyCounter ) {
+#ifdef DEPTHBACKTRACE
+      	qDebug() << "WARNING: Safety-counter reached count > " << maxSafetyCounter << ", operation stopped";
+#endif
+			}
+	  }
+    
+    return ret;
+  }
+  
+};
+
+#endif

data/ext/generator/parser/simplecursor.h

@@ -0,0 +1,74 @@
+/* This file is part of KDevelop
+    Copyright 2007 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 SIMPLECURSOR_H
+#define SIMPLECURSOR_H
+
+#include "cppparser_export.h"
+
+struct CPPPARSER_EXPORT SimpleCursor {
+
+ int line, column;
+
+ SimpleCursor() : line(0), column(0) {
+ }
+
+ SimpleCursor(int _line, int _column) : line(_line), column(_column) {
+ }
+
+ static SimpleCursor invalid() {
+     return SimpleCursor(-1, -1);
+ }
+
+ bool isValid() const {
+     return line != -1 || column != -1;
+ }
+
+ bool operator<(const SimpleCursor& rhs) const {
+     return line < rhs.line || (line == rhs.line && column < rhs.column);
+ }
+ 
+ bool operator<=(const SimpleCursor& rhs) const {
+     return line < rhs.line || (line == rhs.line && column <= rhs.column);
+ }
+
+ bool operator>(const SimpleCursor& rhs) const {
+     return line > rhs.line || (line == rhs.line && column > rhs.column);
+ }
+ 
+ bool operator>=(const SimpleCursor& rhs) const {
+     return line > rhs.line || (line == rhs.line && column >= rhs.column);
+ }
+
+ bool operator ==(const SimpleCursor& rhs) const {
+     return line == rhs.line && column == rhs.column;
+ }
+ 
+ bool operator !=(const SimpleCursor& rhs) const {
+     return !(*this == rhs);
+ }
+
+ SimpleCursor operator +(const SimpleCursor& rhs) const {
+     return SimpleCursor(line + rhs.line, column + rhs.column);
+ }
+};
+
+inline uint qHash(const SimpleCursor& cursor) {
+    return cursor.line * 53 + cursor.column * 47;
+}
+
+#endif