Alien-SmokeQt
view release on metacpan or search on metacpan
generator/generatorenvironment.cpp
generator/generatorenvironment.h
generator/generator_export.h
generator/generatorpreprocessor.cpp
generator/generatorpreprocessor.h
generator/generators/CMakeLists.txt
generator/generators/dump/CMakeLists.txt
generator/generators/dump/generator_dump.cpp
generator/generators/smoke/CMakeLists.txt
generator/generators/smoke/generator_smoke.cpp
generator/generators/smoke/globals.h
generator/generators/smoke/helpers.cpp
generator/generators/smoke/writeClasses.cpp
generator/generators/smoke/writeSmokeDataFile.cpp
generator/generatorvisitor.cpp
generator/generatorvisitor.h
generator/main.cpp
generator/name_compiler.cpp
generator/name_compiler.h
generator/options.cpp
generator/options.h
cmake/modules/FindQScintilla.cmake view on Meta::CPAN
#
# Redistribution and use is allowed according to the terms of the FreeBSD license.
IF(NOT QT4_FOUND)
INCLUDE(FindQt4)
ENDIF(NOT QT4_FOUND)
SET(QSCINTILLA_FOUND FALSE)
IF(QT4_FOUND)
FIND_PATH(QSCINTILLA_INCLUDE_DIR qsciglobal.h
"${QT_INCLUDE_DIR}/Qsci" /usr/include /usr/include/Qsci
)
SET(QSCINTILLA_NAMES ${QSCINTILLA_NAMES} qscintilla2 libqscintilla2)
FIND_LIBRARY(QSCINTILLA_LIBRARY
NAMES ${QSCINTILLA_NAMES}
PATHS ${QT_LIBRARY_DIR}
)
IF (QSCINTILLA_LIBRARY AND QSCINTILLA_INCLUDE_DIR)
cmake/modules/FindQwt5.cmake view on Meta::CPAN
ENDIF(NOT QT4_FOUND)
IF( QT4_FOUND )
# Is Qwt5 installed? Look for header files
FIND_PATH( Qwt5_INCLUDE_DIR qwt.h
PATHS ${QT_INCLUDE_DIR} /usr/local/qwt/include /usr/include/qwt
PATH_SUFFIXES qwt qwt5 qwt-qt4 qwt5-qt4 qwt-qt3 qwt5-qt3 include qwt/include qwt5/include qwt-qt4/include qwt5-qt4/include qwt-qt3/include qwt5-qt3/include ENV PATH)
# Find Qwt version
IF( Qwt5_INCLUDE_DIR )
FILE( READ ${Qwt5_INCLUDE_DIR}/qwt_global.h QWT_GLOBAL_H )
STRING( REGEX MATCH "#define *QWT_VERSION *(0x05*)" QWT_IS_VERSION_5 ${QWT_GLOBAL_H})
IF( QWT_IS_VERSION_5 )
STRING(REGEX REPLACE ".*#define[\\t\\ ]+QWT_VERSION_STR[\\t\\ ]+\"([0-9]+\\.[0-9]+\\.[0-9]+)\".*" "\\1" Qwt_VERSION "${QWT_GLOBAL_H}")
# Find Qwt5 library linked to Qt4
FIND_LIBRARY( Qwt5_Qt4_TENTATIVE_LIBRARY NAMES qwt5-qt4 qwt-qt4 qwt5 qwt PATHS /usr/local/qwt/lib /usr/local/lib /usr/lib ${QT_LIBRARY_DIR})
IF( UNIX AND NOT CYGWIN)
IF( Qwt5_Qt4_TENTATIVE_LIBRARY )
#MESSAGE("Qwt5_Qt4_TENTATIVE_LIBRARY = ${Qwt5_Qt4_TENTATIVE_LIBRARY}")
generator/generator_export.h view on Meta::CPAN
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef GENERATOR_EXPORT_H
#define GENERATOR_EXPORT_H
#include <qglobal.h>
// When building the library, export the symbols - otherwise import them.
#ifdef __GENERATOR_BUILDING
# define GENERATOR_EXPORT Q_DECL_EXPORT
#else
# define GENERATOR_EXPORT Q_DECL_IMPORT
#endif
#endif
generator/generators/smoke/generator_smoke.cpp view on Meta::CPAN
#include <QSet>
#include <QString>
#include <QtDebug>
#include <QtXml>
#include <iostream>
#include <type.h>
#include "globals.h"
#include "../../options.h"
QDir Options::outputDir = QDir::current();
QList<QFileInfo> Options::headerList;
QStringList Options::classList;
int Options::parts = 20;
QString Options::module = "qt";
QStringList Options::parentModules;
QStringList Options::scalarTypes;
generator/generators/smoke/globals.h view on Meta::CPAN
void generateVirtualMethod(QTextStream& out, const Method& meth, QSet<QString>& includes);
void writeClass(QTextStream& out, const Class* klass, const QString& className, QSet<QString>& includes);
SmokeDataFile *m_smokeData;
};
struct Util
{
static QHash<QString, QString> typeMap;
static QHash<const Method*, const Function*> globalFunctionMap;
static QHash<const Method*, const Field*> fieldAccessors;
static bool isVirtualInheritancePath(const Class* desc, const Class* super);
static QList<const Class*> superClassList(const Class* klass);
static QList<const Class*> descendantsList(const Class* klass);
static void preparse(QSet<Type*> *usedTypes, QSet<const Class*> *superClasses, const QList<QString>& keys);
static bool canClassBeInstanciated(const Class* klass);
static bool canClassBeCopied(const Class* klass);
generator/generators/smoke/helpers.cpp view on Meta::CPAN
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <QHash>
#include <QList>
#include <QStack>
#include <type.h>
#include "globals.h"
#include "../../options.h"
QHash<QString, QString> Util::typeMap;
QHash<const Method*, const Function*> Util::globalFunctionMap;
QHash<const Method*, const Field*> Util::fieldAccessors;
// looks up the inheritance path from desc to super and sets 'virt' to true if it encounters a virtual base
static bool isVirtualInheritancePathPrivate(const Class* desc, const Class* super, bool *virt)
{
foreach (const Class::BaseClassSpecifier bspec, desc->baseClasses()) {
if (bspec.baseClass == super || isVirtualInheritancePathPrivate(bspec.baseClass, super, virt)) {
if (bspec.isVirtual)
*virt = true;
return true;
generator/generators/smoke/helpers.cpp view on Meta::CPAN
return (lhs.name() == rhs.name() && lhs.declaringType() == rhs.declaringType() && lhs.type() == rhs.type());
}
bool operator==(const EnumMember& lhs, const EnumMember& rhs)
{
return (lhs.name() == rhs.name() && lhs.declaringType() == rhs.declaringType() && lhs.type() == rhs.type());
}
void Util::preparse(QSet<Type*> *usedTypes, QSet<const Class*> *superClasses, const QList<QString>& keys)
{
Class& globalSpace = classes["QGlobalSpace"];
globalSpace.setName("QGlobalSpace");
globalSpace.setKind(Class::Kind_Class);
globalSpace.setIsNameSpace(true);
// add all functions as methods to a class called 'QGlobalSpace' or a class that represents a namespace
for (QHash<QString, Function>::const_iterator it = functions.constBegin(); it != functions.constEnd(); it++) {
const Function& fn = it.value();
QString fnString = fn.toString();
// gcc doesn't like this function... for whatever reason
if (fn.name() == "_IO_ftrylockfile"
// functions in named namespaces are covered by the class list - only check for top-level functions here
|| (fn.nameSpace().isEmpty() && !Options::functionNameIncluded(fn.qualifiedName()) && !Options::functionSignatureIncluded(fnString))
|| Options::typeExcluded(fnString))
{
// we don't want that function...
continue;
}
Class* parent = &globalSpace;
if (!fn.nameSpace().isEmpty()) {
parent = &classes[fn.nameSpace()];
if (parent->name().isEmpty()) {
parent->setName(fn.nameSpace());
parent->setKind(Class::Kind_Class);
parent->setIsNameSpace(true);
}
}
Method meth = Method(parent, fn.name(), fn.type(), Access_public, fn.parameters());
meth.setFlag(Method::Static);
parent->appendMethod(meth);
// map this method to the function, so we can later retrieve the header it was defined in
globalFunctionMap[&parent->methods().last()] = &fn;
int methIndex = parent->methods().size() - 1;
addOverloads(meth);
// handle the methods appended by addOverloads()
for (int i = parent->methods().size() - 1; i > methIndex; --i)
globalFunctionMap[&parent->methods()[i]] = &fn;
(*usedTypes) << meth.type();
foreach (const Parameter& param, meth.parameters())
(*usedTypes) << param.type();
}
// all enums that don't have a parent are put under QGlobalSpace, too
for (QHash<QString, Enum>::iterator it = enums.begin(); it != enums.end(); it++) {
Enum& e = it.value();
if (!e.parent()) {
Class* parent = &globalSpace;
if (!e.nameSpace().isEmpty()) {
parent = &classes[e.nameSpace()];
if (parent->name().isEmpty()) {
parent->setName(e.nameSpace());
parent->setKind(Class::Kind_Class);
parent->setIsNameSpace(true);
}
}
Type *t = 0;
generator/generators/smoke/writeClasses.cpp view on Meta::CPAN
#include <QCoreApplication>
#include <QDir>
#include <QFile>
#include <QMap>
#include <QSet>
#include <QTextStream>
#include <type.h>
#include "globals.h"
#include "../../options.h"
SmokeClassFiles::SmokeClassFiles(SmokeDataFile *data)
: m_smokeData(data)
{
}
void SmokeClassFiles::write()
{
write(m_smokeData->includedClasses);
generator/generators/smoke/writeClasses.cpp view on Meta::CPAN
int index, bool dynamicDispatch, QSet<QString>& includes)
{
QString methodBody;
QTextStream out(&methodBody);
out << indent;
if (meth.isConstructor()) {
out << smokeClassName << "* xret = new " << smokeClassName << "(";
} else {
const Function* func = Util::globalFunctionMap[&meth];
if (func)
includes.insert(func->fileName());
if (meth.type()->getClass())
includes.insert(meth.type()->getClass()->fileName());
if (meth.type()->isFunctionPointer() || meth.type()->isArray())
out << meth.type()->toString("xret") << " = ";
else if (meth.type() != Type::Void)
out << meth.type()->toString() << " xret = ";
generator/generators/smoke/writeSmokeDataFile.cpp view on Meta::CPAN
*/
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QMap>
#include <QTextStream>
#include <type.h>
#include "globals.h"
#include "../../options.h"
uint qHash(const QVector<int> intList)
{
const char *byteArray = (const char*) intList.constData();
int length = sizeof(int) * intList.count();
return qHash(QByteArray::fromRawData(byteArray, length));
}
SmokeDataFile::SmokeDataFile()
generator/generatorvisitor.cpp view on Meta::CPAN
if (member.name() == name) {
name.prepend(klass.top()->toString() + "::");
return 0;
}
}
}
clazz = clazz->parent();
}
}
// look through all global enums in our namespace
QStringList nspace = this->nspace;
do {
QString n = nspace.join("::");
foreach (const Enum& e, enums.values()) {
if (e.parent())
continue;
if (e.nameSpace() == n) {
foreach (const EnumMember& member, e.members()) {
if (member.name() == name) {
generator/generatorvisitor.cpp view on Meta::CPAN
currentMethod.appendExceptionType(tc->type());
it = it->next;
} while (it != end);
}
}
klass.top()->appendMethod(currentMethod);
return;
}
// global function
if (node->parameter_declaration_clause && !inMethod && !inClass) {
if (!declName.contains("::")) {
Type* returnType = currentTypeRef;
currentFunction = Function(declName, nspace.join("::"), returnType);
currentFunction.setFileName(m_header);
// build parameter list
inMethod = true;
visit(node->parameter_declaration_clause);
inMethod = false;
QString name = currentFunction.toString();
generator/generatorvisitor.cpp view on Meta::CPAN
return;
}
// field
if (!inMethod && !klass.isEmpty() && inClass) {
Field field = Field(klass.top(), declName, currentTypeRef, access.top());
if (isStatic) field.setFlag(Field::Static);
klass.top()->appendField(field);
return;
} else if (!inMethod && !inClass) {
// global variable
if (!globals.contains(declName)) {
GlobalVar var = GlobalVar(declName, nspace.join("::"), currentTypeRef);
var.setFileName(m_header);
globals[var.name()] = var;
}
return;
}
}
void GeneratorVisitor::visitElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST* node)
{
tc->run(node);
createType = true;
DefaultVisitor::visitElaboratedTypeSpecifier(node);
generator/name_compiler.cpp view on Meta::CPAN
return *_M_name;
}*/
void NameCompiler::run(NameAST *node/*, QualifiedIdentifier* target*/)
{
// if(target)
// _M_name = target;
// else
// _M_name = &m_localName;
m_typeSpecifier = 0; internal_run(node); /*if(node && node->global) _M_name->setExplicitlyGlobal( node->global );*/
}
generator/parser/ast.h view on Meta::CPAN
DECLARE_AST_NODE(MemInitializer)
NameAST *initializer_id;
ExpressionAST *expression;
};
struct NameAST: public AST
{
DECLARE_AST_NODE(Name)
bool global;
const ListNode<UnqualifiedNameAST*> *qualified_names;
UnqualifiedNameAST *unqualified_name;
};
struct NamespaceAST: public DeclarationAST
{
DECLARE_AST_NODE(Namespace)
std::size_t namespace_name;
LinkageBodyAST *linkage_body;
generator/parser/codegenerator.cpp view on Meta::CPAN
{
visit(node->initializer_id);
m_output << "(";
visit(node->expression);
m_output << ")";
}
void CodeGenerator::visitName(NameAST* node)
{
if (node->global)
printToken( Token_scope );
if (node->qualified_names) {
commaPrintNodes( this, node->qualified_names, token_text( Token_scope ) );
printToken( Token_scope );
}
visit(node->unqualified_name);
}
generator/parser/cppparser_export.h view on Meta::CPAN
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 CPPPARSER_EXPORT_H
#define CPPPARSER_EXPORT_H
#include <qglobal.h>
// When building the library, export the symbols - otherwise import them.
#ifdef __CPPPARSER_BUILDING
# define CPPPARSER_EXPORT Q_DECL_EXPORT
#else
# define CPPPARSER_EXPORT Q_DECL_IMPORT
#endif
#endif
generator/parser/indexedstring.cpp view on Meta::CPAN
///@param str must be a utf8 encoded string, does not need to be 0-terminated.
///@param length must be its length in bytes.
IndexedString::IndexedString( const char* str, unsigned short length, unsigned int hash ) {
if(!length)
m_index = 0;
else if(length == 1)
m_index = 0xffff0000 | str[0];
else {
m_index = getIndex(QString::fromUtf8(str, length));
/*QMutexLocker lock(globalIndexedStringRepository->mutex());
m_index = globalIndexedStringRepository->index(IndexedStringRepositoryItemRequest(str, hash ? hash : hashString(str, length), length));
if(shouldDoDUChainReferenceCounting(this))
increase(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);*/
}
}
IndexedString::IndexedString( char c ) {
m_index = 0xffff0000 | c;
}
IndexedString::IndexedString( const QUrl& url ) {
QByteArray array(url.path().toUtf8());
const char* str = array.constData();
int size = array.size();
if(!size)
m_index = 0;
else if(size == 1)
m_index = 0xffff0000 | str[0];
else {
m_index = getIndex(QString::fromUtf8(str));
/*QMutexLocker lock(globalIndexedStringRepository->mutex());
m_index = globalIndexedStringRepository->index(IndexedStringRepositoryItemRequest(str, hashString(str, size), size));
if(shouldDoDUChainReferenceCounting(this))
increase(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);*/
}
}
IndexedString::IndexedString( const QString& string ) {
QByteArray array(string.toUtf8());
const char* str = array.constData();
int size = array.size();
if(!size)
m_index = 0;
else if(size == 1)
m_index = 0xffff0000 | str[0];
else {
m_index = getIndex(string);
/*QMutexLocker lock(globalIndexedStringRepository->mutex());
m_index = globalIndexedStringRepository->index(IndexedStringRepositoryItemRequest(str, hashString(str, size), size));
if(shouldDoDUChainReferenceCounting(this))
increase(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);*/
}
}
IndexedString::IndexedString( const char* str) {
unsigned int length = strlen(str);
if(!length)
m_index = 0;
else if(length == 1)
m_index = 0xffff0000 | str[0];
else {
m_index = getIndex(QString::fromUtf8(str));
/*QMutexLocker lock(globalIndexedStringRepository->mutex());
m_index = globalIndexedStringRepository->index(IndexedStringRepositoryItemRequest(str, hashString(str, length), length));
if(shouldDoDUChainReferenceCounting(this))
increase(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);*/
}
}
IndexedString::IndexedString( const QByteArray& str) {
unsigned int length = str.length();
if(!length)
m_index = 0;
else if(length == 1)
m_index = 0xffff0000 | str[0];
else {
m_index = getIndex(QString::fromUtf8(str));
/*QMutexLocker lock(globalIndexedStringRepository->mutex());
m_index = globalIndexedStringRepository->index(IndexedStringRepositoryItemRequest(str, hashString(str, length), length));
if(shouldDoDUChainReferenceCounting(this))
increase(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);*/
}
}
IndexedString::~IndexedString() {
/*if(m_index && (m_index & 0xffff0000) != 0xffff0000) {
if(shouldDoDUChainReferenceCounting(this)) {
QMutexLocker lock(globalIndexedStringRepository->mutex());
decrease(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);
}
}*/
}
IndexedString::IndexedString( const IndexedString& rhs ) : m_index(rhs.m_index) {
/*if(m_index && (m_index & 0xffff0000) != 0xffff0000) {
if(shouldDoDUChainReferenceCounting(this)) {
QMutexLocker lock(globalIndexedStringRepository->mutex());
increase(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);
}
}*/
}
IndexedString& IndexedString::operator=(const IndexedString& rhs) {
if(m_index == rhs.m_index)
return *this;
/*if(m_index && (m_index & 0xffff0000) != 0xffff0000) {
if(shouldDoDUChainReferenceCounting(this)) {
QMutexLocker lock(globalIndexedStringRepository->mutex());
decrease(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);
}
}*/
m_index = rhs.m_index;
/*if(m_index && (m_index & 0xffff0000) != 0xffff0000) {
if(shouldDoDUChainReferenceCounting(this)) {
QMutexLocker lock(globalIndexedStringRepository->mutex());
increase(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);
}
}*/
return *this;
}
QUrl IndexedString::toUrl() const {
QUrl url( str() );
return url;
}
QString IndexedString::str() const {
if(!m_index)
return QString();
else if((m_index & 0xffff0000) == 0xffff0000)
return QString(QChar((char)m_index & 0xff));
else
return strings()->at(m_index); /*stringFromItem(globalIndexedStringRepository->itemFromIndex(m_index));*/
}
int IndexedString::length() const {
if(!m_index)
return 0;
else if((m_index & 0xffff0000) == 0xffff0000)
return 1;
else
return strings()->at(m_index).length(); /*globalIndexedStringRepository->itemFromIndex(m_index)->length;*/
}
QByteArray IndexedString::byteArray() const {
if(!m_index)
return QByteArray();
else if((m_index & 0xffff0000) == 0xffff0000)
return QString(QChar((char)m_index & 0xff)).toUtf8();
else
return strings()->at(m_index).toUtf8(); /*arrayFromItem(globalIndexedStringRepository->itemFromIndex(m_index));*/
}
unsigned int IndexedString::hashString(const char* str, unsigned short length) {
RunningHash running;
for(int a = length-1; a >= 0; --a) {
running.append(*str);
++str;
}
return running.hash;
}
generator/parser/name_compiler.cpp view on Meta::CPAN
return *_M_name;
}*/
void NameCompiler::run(NameAST *node/*, QualifiedIdentifier* target*/)
{
// if(target)
// _M_name = target;
// else
// _M_name = &m_localName;
m_typeSpecifier = 0; internal_run(node); /*if(node && node->global) _M_name->setExplicitlyGlobal( node->global );*/
}
generator/parser/parser.cpp view on Meta::CPAN
{
std::size_t start = session->token_stream->cursor();
WinDeclSpecAST *winDeclSpec = 0;
parseWinDeclSpec(winDeclSpec);
NameAST *ast = CreateNode<NameAST>(session->mempool);
if (session->token_stream->lookAhead() == Token_scope)
{
ast->global = true;
advance();
}
std::size_t idx = session->token_stream->cursor();
while (true)
{
UnqualifiedNameAST *n = 0;
if (!parseUnqualifiedName(n)) {
return false;
generator/parser/parser.cpp view on Meta::CPAN
}
bool Parser::parsePtrToMember(PtrToMemberAST *&node)
{
#if defined(__GNUC__)
#warning "implemente me (AST)"
#endif
std::size_t start = session->token_stream->cursor();
std::size_t global_scope = 0;
if (session->token_stream->lookAhead() == Token_scope)
{
global_scope = session->token_stream->cursor();
advance();
}
UnqualifiedNameAST *name = 0;
while (session->token_stream->lookAhead() == Token_identifier)
{
if (!parseUnqualifiedName(name))
break;
if (session->token_stream->lookAhead() == Token_scope
generator/parser/rpp/appendedlist.h view on Meta::CPAN
Boston, MA 02110-1301, USA.
*/
#ifndef APPENDEDLIST_H
#define APPENDEDLIST_H
#include <QtCore/QMutex>
#include <QtCore/QVector>
#include <QtCore/QStack>
#include <QtCore/QPair>
// #include <kglobal.h>
// #include <kdebug.h>
#include "../kdevvarlengtharray.h"
#include <iostream>
#include <time.h>
namespace KDevelop {
class AbstractItemRepository;
/**
* This file contains macros and classes that can be used to conveniently implement classes that store the data of an arbitrary count
* of additional lists within the same memory block directly behind the class data, in a way that one the whole data can be stored by one copy-operation
* to another place, like needed in ItemRepository. These macros simplify having two versions of a class: One that has its lists attached in memory,
* and one version that has them contained as a directly accessible KDevVarLengthArray. Both versions have their lists accessible through access-functions,
* have a completeSize() function that computes the size of the one-block version, and a copyListsFrom(..) function which can copy the lists from one
* version to the other.
*
* @warning Always follow these rules:
* You must call initalizeAppendedLists(bool) on construction, also in any copy-constructor, but before calling copyFrom(..).
* The parameter to that function should be whether the lists in the items should be dynamic, and thus most times "true".
* You must call freeAppendedLists() on destruction, our you will be leaking memory(only when dynamic)
*
* For each embedded list, you must use macros to define a global hash that will be used to allocate the temporary lists, example fir identifier.cpp:
* DEFINE_LIST_MEMBER_HASH(IdentifierPrivate, templateIdentifiers, uint);
*
* See identifier.cpp for an example how to use these classes. @todo Document this a bit more
* */
enum {
DynamicAppendedListMask = 1 << 31
};
enum {
generator/parser/rpp/preprocessor.h view on Meta::CPAN
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. <file.h>)
IncludeGlobal
};
virtual ~Preprocessor();
// QString processString(const QString& string);
/**
* This function is called by the preprocessor whenever
generator/parser/tokens.cpp view on Meta::CPAN
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 "tokens.h"
#include <QtCore/qglobal.h>
static char const * const _S_token_names[] = {
"K_DCOP",
"Q_OBJECT",
"__attribute__",
"__typeof",
"and",
"and_eq",
"arrow",
generator/type.cpp view on Meta::CPAN
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "type.h"
QHash<QString, Class> classes;
QHash<QString, Typedef> typedefs;
QHash<QString, Enum> enums;
QHash<QString, Function> functions;
QHash<QString, GlobalVar> globals;
QHash<QString, Type> types;
QString BasicTypeDeclaration::toString() const
{
QString ret;
Class* parent = m_parent;
while (parent) {
ret.prepend(parent->name() + "::");
parent = parent->parent();
}
generator/type.h view on Meta::CPAN
class Typedef;
class Enum;
class GlobalVar;
class Function;
class Type;
extern GENERATOR_EXPORT QHash<QString, Class> classes;
extern GENERATOR_EXPORT QHash<QString, Typedef> typedefs;
extern GENERATOR_EXPORT QHash<QString, Enum> enums;
extern GENERATOR_EXPORT QHash<QString, Function> functions;
extern GENERATOR_EXPORT QHash<QString, GlobalVar> globals;
extern GENERATOR_EXPORT QHash<QString, Type> types;
class Method;
class Field;
enum Access {
Access_public,
Access_protected,
Access_private
};
smoke/qt/qimageblitz/qimageblitz_includes.h view on Meta::CPAN
#ifdef __SMOKEGEN_RUN__
# define QIMAGEBLITZ_EXPORT
#endif
#include <QtCore>
#include <qimageblitz.h>
#include <qglobal.h>
smoke/qt/qsci/qscintilla2_includes.h view on Meta::CPAN
#include <qsciabstractapis.h>
#include <qsciapis.h>
#include <qscicommand.h>
#include <qscicommandset.h>
#include <qscidocument.h>
#include <qsciglobal.h>
#include <qscilexerbash.h>
#include <qscilexerbatch.h>
#include <qscilexercmake.h>
#include <qscilexercpp.h>
#include <qscilexercsharp.h>
#include <qscilexercss.h>
#include <qscilexercustom.h>
#include <qscilexerd.h>
#include <qscilexerdiff.h>
#include <qscilexerfortran77.h>
smoke/qt/qtcore/QtGuess.txt view on Meta::CPAN
if (MSVC)
list(APPEND qtdefines "Q_CC_MSVC")
endif (MSVC)
foreach(test_entry ${define_tests})
if(${${test_entry}} GREATER ${qt_test_threshold})
list(APPEND test_targets ${test_entry})
endif(${${test_entry}} GREATER ${qt_test_threshold})
endforeach(test_entry ${define_tests})
file(STRINGS "${QT_QTCORE_INCLUDE_DIR}/qglobal.h" qglobal_h NEWLINE_CONSUME)
file(STRINGS "${QT_QTCORE_INCLUDE_DIR}/qconfig.h" qconfig_h NEWLINE_CONSUME)
file(STRINGS "${QT_QTCORE_INCLUDE_DIR}/qfeatures.h" qfeatures_h NEWLINE_CONSUME)
set(qtheaders "${qglobal_h}\n${qconfig_h}\n${qfeatures}")
string(REGEX REPLACE "\n" ";" qtheaders "${qtheaders}")
file(REMOVE_RECURSE ${CMAKE_CURRENT_BINARY_DIR}/qtdefines.cpp ${CMAKE_CURRENT_BINARY_DIR}/qtdefines)
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/qtdefines.cpp "#include <cstdio>\n#include \"qglobal.h\"\nint main(int argc, char** argv)\n{\n")
foreach( line ${qtheaders} )
if(line MATCHES "^#[ ]*define[ ]+(QT_[A-Z_0-9]+)[ ]*$")
#ifdef DEF; printf "DEF"; #endif
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/qtdefines.cpp "#ifdef ${CMAKE_MATCH_1}\n#ifdef QTDEF_MULTI\nprintf(\";\");\n#endif\n#ifndef QTDEF_MULTI\n#define QTDEF_MULTI\n#endif\nprintf(\"${CMAKE_MATCH_1}\");\n#endif\n")
endif(line MATCHES "^#[ ]*define[ ]+(QT_[A-Z_0-9]+)[ ]*$")
endforeach(line)
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/qtdefines.cpp "return 0;\n}\n")
try_run(qtdefines_run qtdefines_compile ${CMAKE_CURRENT_BINARY_DIR}/qtdefines
${CMAKE_CURRENT_BINARY_DIR}/qtdefines.cpp
smoke/qt/qttest/qttest_includes.h view on Meta::CPAN
#include <qsignalspy.h>
#include <qtest.h>
#include <qtest_global.h>
#include <qtest_gui.h>
#include <qtestaccessible.h>
#include <qtestassert.h>
#include <qtestcase.h>
#include <qtestdata.h>
#include <qtestevent.h>
#include <qtesteventloop.h>
#include <qtestkeyboard.h>
#include <qtestmouse.h>
#include <qtestspontaneevent.h>
smoke/qt/qwt/qwt_includes.h view on Meta::CPAN
#include <qwt_counter.h>
#include <qwt_curve_fitter.h>
#include <qwt_data.h>
#include <qwt_dial.h>
#include <qwt_dial_needle.h>
#include <qwt_double_interval.h>
#include <qwt_double_range.h>
#include <qwt_double_rect.h>
#include <qwt_dyngrid_layout.h>
#include <qwt_event_pattern.h>
#include <qwt_global.h>
#include <qwt_interval_data.h>
#include <qwt_knob.h>
#include <qwt_layout_metrics.h>
#include <qwt_legend.h>
#include <qwt_legend_item.h>
#include <qwt_legend_itemmanager.h>
#include <qwt_magnifier.h>
#include <qwt_math.h>
#include <qwt_paint_buffer.h>
#include <qwt_painter.h>
( run in 1.056 second using v1.01-cache-2.11-cpan-49f99fa48dc )