Alien-SmokeQt
view release on metacpan or search on metacpan
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
generator/generatorenvironment.h view on Meta::CPAN
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 PARSERENVIRONMENT_H
#define PARSERENVIRONMENT_H
#include <rpp/pp-environment.h>
class GeneratorEnvironment : public rpp::Environment
{
public:
GeneratorEnvironment(rpp::pp* preprocessor);
~GeneratorEnvironment();
virtual void setMacro(rpp::pp_macro* macro);
private:
rpp::pp_macro* q_property;
};
#endif // PARSERENVIRONMENT_H
generator/generatorpreprocessor.h view on Meta::CPAN
#include <rpp/pp-engine.h>
#include <rpp/pp-stream.h>
#include <rpp/preprocessor.h>
namespace rpp {
class MacroBlock;
}
extern QList<QString> parsedHeaders;
class Preprocessor : public rpp::Preprocessor
{
public:
Preprocessor(const QList<QDir>& includeDirs = QList<QDir>(), const QStringList& defines = QStringList(),
const QFileInfo& file = QFileInfo());
virtual ~Preprocessor();
virtual rpp::Stream* sourceNeeded(QString& fileName, rpp::Preprocessor::IncludeType type, int sourceLine, bool skipCurrentPath);
void setFile(const QFileInfo& file);
QFileInfo file();
void setIncludeDirs(QList<QDir> dirs);
generator/generatorpreprocessor.h view on Meta::CPAN
rpp::MacroBlock *m_topBlock;
QList<QDir> m_includeDirs;
QStringList m_defines;
QFileInfo m_file;
PreprocessedContents m_contents;
QHash<QString, QPair<QFileInfo, PreprocessedContents> > m_cache;
QList<PreprocessedContents> m_localContent;
QStack<QFileInfo> m_fileStack;
};
class HeaderStream : public rpp::Stream
{
public:
HeaderStream(PreprocessedContents* contents, QStack<QFileInfo>* stack) : rpp::Stream(contents), m_stack(stack) {}
virtual ~HeaderStream() { m_stack->pop(); }
private:
QStack<QFileInfo>* m_stack;
};
#endif // GENERATORPREPROCESSOR_H
generator/generators/smoke/helpers.cpp view on Meta::CPAN
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;
generator/generators/smoke/helpers.cpp view on Meta::CPAN
}
}
bool Util::canClassBeInstanciated(const Class* klass)
{
static QHash<const Class*, bool> cache;
if (cache.contains(klass))
return cache[klass];
bool ctorFound = false, publicCtorFound = false, privatePureVirtualsFound = false;
foreach (const Method& meth, klass->methods()) {
if (meth.isConstructor()) {
ctorFound = true;
if (meth.access() != Access_private) {
// this class can be instanstiated
publicCtorFound = true;
}
} else if ((meth.flags() & Method::PureVirtual) && meth.access() == Access_private) {
privatePureVirtualsFound = true;
}
}
// The class can be instanstiated if it has a public constructor or no constructor at all
// because then it has a default one generated by the compiler.
// If it has private pure virtuals, then it can't be instanstiated either.
bool ret = ((publicCtorFound || !ctorFound) && !privatePureVirtualsFound);
cache[klass] = ret;
return ret;
}
bool Util::canClassBeCopied(const Class* klass)
{
static QHash<const Class*, bool> cache;
if (cache.contains(klass))
return cache[klass];
generator/generators/smoke/helpers.cpp view on Meta::CPAN
{
static QHash<const Class*, bool> cache;
if (cache.contains(klass))
return cache[klass];
if (klass->isNameSpace()) {
cache[klass] = false;
return false;
}
bool publicDtorFound = true;
foreach (const Method& meth, klass->methods()) {
if (meth.isDestructor()) {
if (meth.access() != Access_public)
publicDtorFound = false;
// a class has only one destructor, so break here
break;
}
}
cache[klass] = publicDtorFound;
return publicDtorFound;
}
const Method* Util::findDestructor(const Class* klass)
{
foreach (const Method& meth, klass->methods()) {
if (meth.isDestructor()) {
return &meth;
}
}
const Method* dtor = 0;
generator/generators/smoke/helpers.cpp view on Meta::CPAN
{
methods << &meth;
}
}
foreach (const Class::BaseClassSpecifier& baseClass, klass->baseClasses()) {
methods += collectVirtualMethods(baseClass.baseClass);
}
return methods;
}
// don't make this public - it's just a utility function for the next method and probably not what you would expect it to be
static bool operator==(const Method& rhs, const Method& lhs)
{
// These have to be equal for methods to be the same. Return types don't have an effect, ignore them.
bool ok = (rhs.name() == lhs.name() && rhs.isConst() == lhs.isConst() && rhs.parameters().count() == lhs.parameters().count());
if (!ok)
return false;
// now check the parameter types for equality
for (int i = 0; i < rhs.parameters().count(); i++) {
if (rhs.parameters()[i].type() != lhs.parameters()[i].type())
generator/generators/smoke/writeClasses.cpp view on Meta::CPAN
void SmokeClassFiles::writeClass(QTextStream& out, const Class* klass, const QString& className, QSet<QString>& includes)
{
const QString underscoreName = QString(className).replace("::", "__");
const QString smokeClassName = "x_" + underscoreName;
QString switchCode;
QTextStream switchOut(&switchCode);
out << QString("class %1").arg(smokeClassName);
if (!klass->isNameSpace()) {
out << QString(" : public %1").arg(className);
if (Util::hasClassVirtualDestructor(klass) && Util::hasClassPublicDestructor(klass)) {
out << ", public __internal_SmokeClass";
}
}
out << " {\n";
if (Util::canClassBeInstanciated(klass)) {
out << " SmokeBinding* _binding;\n";
out << "public:\n";
out << " void x_0(Smoke::Stack x) {\n";
out << " // set the smoke binding\n";
out << " _binding = (SmokeBinding*)x[1].s_class;\n";
out << " }\n";
switchOut << " case 0: xself->x_0(args);\tbreak;\n";
} else {
out << "public:\n";
}
int xcall_index = 1;
const Method *destructor = 0;
foreach (const Method& meth, klass->methods()) {
if (meth.access() == Access_private)
continue;
if (meth.isDestructor()) {
destructor = &meth;
continue;
generator/generatorvisitor.cpp view on Meta::CPAN
}
inSignals.top() = false;
inSlots.top() = false;
ParserOptions::resolveTypedefs = oldResolveTypedefs;
const ListNode<std::size_t> *it = node->specs->toFront(), *end = it;
do {
if (it->element) {
const Token& t = token(it->element);
if (t.kind == Token_public)
access.top() = Access_public;
else if (t.kind == Token_protected)
access.top() = Access_protected;
else if (t.kind == Token_private)
access.top() = Access_private;
// signal/slot handling; don't resolve typedefs in signals and slots
if (t.kind == Token_signals) {
access.top() = Access_protected;
inSignals.top() = true;
ParserOptions::resolveTypedefs = false;
generator/generatorvisitor.cpp view on Meta::CPAN
}
it = it->next;
} while (end != it);
DefaultVisitor::visitAccessSpecifier(node);
}
void GeneratorVisitor::visitBaseSpecifier(BaseSpecifierAST* node)
{
Class::BaseClassSpecifier baseClass;
int _kind = token(node->access_specifier).kind;
if (_kind == Token_public) {
baseClass.access = Access_public;
} else if (_kind == Token_protected) {
baseClass.access = Access_protected;
} else {
baseClass.access = Access_private;
}
baseClass.isVirtual = (node->virt > 0);
nc->run(node->name);
BasicTypeDeclaration* base = resolveType(nc->qualifiedName().join("::"));
if (!base)
return;
generator/generatorvisitor.cpp view on Meta::CPAN
}
void GeneratorVisitor::visitClassSpecifier(ClassSpecifierAST* node)
{
if (klass.isEmpty())
return;
if (kind == Class::Kind_Class)
access.push(Access_private);
else
access.push(Access_public);
inSignals.push(false);
inSlots.push(false);
inClass++;
q_properties.push(QList<QProperty>());
klass.top()->setFileName(m_header);
klass.top()->setIsForwardDecl(false);
if (klass.count() > 1) {
// get the element before the last element, which is the parent
Class* parent = klass[klass.count() - 2];
generator/generatorvisitor.cpp view on Meta::CPAN
tc->run(node);
createType = true;
DefaultVisitor::visitElaboratedTypeSpecifier(node);
}
void GeneratorVisitor::visitEnumSpecifier(EnumSpecifierAST* node)
{
nc->run(node->name);
Class* parent = klass.isEmpty() ? 0 : klass.top();
currentEnum = Enum(nc->name(), nspace.join("::"), parent);
Access a = (access.isEmpty() ? Access_public : access.top());
currentEnum.setAccess(a);
currentEnum.setFileName(m_header);
QHash<QString, Enum>::iterator it = enums.insert(currentEnum.toString(), currentEnum);
currentEnumRef = &it.value();
visitNodes(this, node->enumerators);
if (parent)
parent->appendChild(currentEnumRef);
}
void GeneratorVisitor::visitEnumerator(EnumeratorAST* node)
generator/generatorvisitor.cpp view on Meta::CPAN
kind = Class::Kind_Class;
} else if (_kind == Token_struct) {
kind = Class::Kind_Struct;
}
if (_kind == Token_class || _kind == Token_struct) {
tc->run(node->type_specifier);
if (tc->qualifiedName().isEmpty()) return;
// for nested classes
Class* parent = klass.isEmpty() ? 0 : klass.top();
Class _class = Class(tc->qualifiedName().last(), nspace.join("::"), parent, kind);
Access a = (access.isEmpty() ? Access_public : access.top());
_class.setAccess(a);
QString name = _class.toString();
// This class has already been parsed.
if (classes.contains(name) && !classes[name].isForwardDecl())
return;
QHash<QString, Class>::iterator item = classes.insert(name, _class);
if (inTemplate) {
item.value().setIsTemplate(true);
return;
}
generator/generatorvisitor.cpp view on Meta::CPAN
DefaultVisitor::visitTypedef(node);
// TODO: probably has to be extended to cover structs and classes, too
// makes something like 'typedef enum { Bar } Foo;' look like a proper enum.
if (ast_cast<EnumSpecifierAST*>(node->type_specifier)) {
nc->run(node->init_declarators->at(0)->element->declarator->id);
currentEnumRef->setName(nc->name());
}
}
// don't make this public - it's just a utility function for the next method and probably not what you would expect it to be
static bool operator==(const Method& rhs, const Method& lhs)
{
// these have to be equal for methods to be the same
bool ok = (rhs.name() == lhs.name() && rhs.isConst() == lhs.isConst() &&
rhs.parameters().count() == lhs.parameters().count() && rhs.type() == lhs.type());
if (!ok)
return false;
// now check the parameter types for equality
for (int i = 0; i < rhs.parameters().count(); i++) {
generator/generatorvisitor.h view on Meta::CPAN
struct QProperty
{
QString type;
bool isPtr;
QString name;
QString read;
QString write;
};
class GeneratorVisitor : public DefaultVisitor
{
public:
GeneratorVisitor(ParseSession *session, const QString& header = QString());
virtual ~GeneratorVisitor();
BasicTypeDeclaration* resolveTypeInSuperClasses(const Class* klass, const QString& name);
BasicTypeDeclaration* resolveType(const QString& name);
BasicTypeDeclaration* resolveType(QString& name);
QString resolveEnumMember(const QString& name);
QString resolveEnumMember(const QString& parent, const QString& name);
QPair<bool, bool> parseCv(const ListNode<std::size_t> *cv);
protected:
generator/name_compiler.h view on Meta::CPAN
#include "generator_export.h"
#include "default_visitor.h"
#include "type.h"
class ParseSession;
class OperatorAST;
class GeneratorVisitor;
class GENERATOR_EXPORT NameCompiler: protected DefaultVisitor
{
public:
NameCompiler(ParseSession* session, GeneratorVisitor* visitor);
void run(NameAST *node);
void run(UnqualifiedNameAST *node) { m_typeSpecifier = 0; internal_run(node); }
QString name() const { return m_name.join("::"); }
const QStringList& qualifiedName() const { return m_name; }
// the int specifies the position of the template arguments.
// in case of Foo<void*, int>::Bar it would be 0 => { void*, int }
QMap<int, QList<Type> > templateArguments() const { return m_templateArgs; }
generator/parser/ast.h view on Meta::CPAN
int kind;
std::size_t start_token;
std::size_t end_token;
};
struct CommentAST {
const ListNode<std::size_t> *comments; //A list of comment-tokens
};
struct TypeSpecifierAST: public AST
{
const ListNode<std::size_t> *cv; // const or volatile tokens
};
struct StatementAST: public AST
{
};
struct ExpressionAST: public AST
{
};
struct DeclarationAST: public AST, public CommentAST
{
};
struct AccessSpecifierAST: public DeclarationAST
{
DECLARE_AST_NODE(AccessSpecifier)
const ListNode<std::size_t> *specs;
};
struct AsmDefinitionAST: public DeclarationAST
{
DECLARE_AST_NODE(AsmDefinition)
const ListNode<std::size_t> *cv;
};
struct BaseClauseAST: public AST // ### kill me
{
DECLARE_AST_NODE(BaseClause)
const ListNode<BaseSpecifierAST*> *base_specifiers;
};
struct BaseSpecifierAST: public AST
{
DECLARE_AST_NODE(BaseSpecifier)
std::size_t virt;
std::size_t access_specifier;
NameAST *name;
};
struct BinaryExpressionAST: public ExpressionAST
{
DECLARE_AST_NODE(BinaryExpression)
std::size_t op; //Index of the token that describes the operator
ExpressionAST *left_expression;
ExpressionAST *right_expression;
};
///An expression used to do more detailed processing of SIGNAL(..) and SLOT(..) specifications
struct SignalSlotExpressionAST : public ExpressionAST {
DECLARE_AST_NODE(SignalSlotExpression)
//The unqualified name also contains the argument types in its template-arguments
UnqualifiedNameAST *name;
};
struct CastExpressionAST: public ExpressionAST
{
DECLARE_AST_NODE(CastExpression)
TypeIdAST *type_id;
ExpressionAST *expression;
};
struct ClassMemberAccessAST: public ExpressionAST
{
DECLARE_AST_NODE(ClassMemberAccess)
std::size_t op; //Index of the token that describes the operator
NameAST *name;
};
struct ClassSpecifierAST: public TypeSpecifierAST
{
DECLARE_AST_NODE(ClassSpecifier)
WinDeclSpecAST *win_decl_specifiers;
std::size_t class_key;
NameAST *name;
BaseClauseAST *base_clause;
const ListNode<DeclarationAST*> *member_specs;
};
struct CompoundStatementAST: public StatementAST
{
DECLARE_AST_NODE(CompoundStatement)
const ListNode<StatementAST*> *statements;
};
struct ConditionAST: public AST
{
DECLARE_AST_NODE(Condition)
TypeSpecifierAST *type_specifier;
DeclaratorAST *declarator;
ExpressionAST *expression;
};
struct ConditionalExpressionAST: public ExpressionAST
{
DECLARE_AST_NODE(ConditionalExpression)
ExpressionAST *condition;
ExpressionAST *left_expression;
ExpressionAST *right_expression;
};
/**
* type_id is the type that should be casted to
* expression is the expression casted from
* sub_expressions is a list of post-fix expressions, see PostfixExpressionAST
*/
struct CppCastExpressionAST: public ExpressionAST
{
DECLARE_AST_NODE(CppCastExpression)
std::size_t op; //Index of the token that describes the operator
TypeIdAST *type_id;
ExpressionAST *expression;
const ListNode<ExpressionAST*> *sub_expressions;
};
struct CtorInitializerAST: public AST
{
DECLARE_AST_NODE(CtorInitializer)
std::size_t colon;
const ListNode<MemInitializerAST*> *member_initializers;
};
struct DeclarationStatementAST: public StatementAST
{
DECLARE_AST_NODE(DeclarationStatement)
DeclarationAST *declaration;
};
struct DeclaratorAST: public AST
{
DECLARE_AST_NODE(Declarator)
const ListNode<PtrOperatorAST*> *ptr_ops;
DeclaratorAST *sub_declarator;
NameAST *id;
ExpressionAST *bit_expression;
const ListNode<ExpressionAST*> *array_dimensions;
bool parameter_is_initializer; //Used by the declaration-builder to mark a parameter-declaration clause as a mis-parsed initializer
ParameterDeclarationClauseAST *parameter_declaration_clause;
const ListNode<std::size_t> *fun_cv;
ExceptionSpecificationAST *exception_spec;
};
struct DeleteExpressionAST: public ExpressionAST
{
DECLARE_AST_NODE(DeleteExpression)
std::size_t scope_token;
std::size_t delete_token;
std::size_t lbracket_token;
std::size_t rbracket_token;
ExpressionAST *expression;
};
struct DoStatementAST: public StatementAST
{
DECLARE_AST_NODE(DoStatement)
StatementAST *statement;
ExpressionAST *expression;
};
struct ElaboratedTypeSpecifierAST: public TypeSpecifierAST
{
DECLARE_AST_NODE(ElaboratedTypeSpecifier)
std::size_t type;
NameAST *name;
};
struct EnumSpecifierAST: public TypeSpecifierAST
{
DECLARE_AST_NODE(EnumSpecifier)
NameAST *name;
const ListNode<EnumeratorAST*> *enumerators;
};
struct EnumeratorAST: public AST, public CommentAST
{
DECLARE_AST_NODE(Enumerator)
std::size_t id;
ExpressionAST *expression;
};
struct ExceptionSpecificationAST: public AST
{
DECLARE_AST_NODE(ExceptionSpecification)
std::size_t ellipsis;
const ListNode<TypeIdAST*> *type_ids;
};
struct ExpressionOrDeclarationStatementAST: public StatementAST
{
DECLARE_AST_NODE(ExpressionOrDeclarationStatement)
StatementAST *expression;
StatementAST *declaration;
// This was not originally part of the AST - added by the context visitor
bool expressionChosen;
};
///An expression terminated by a semicolon or similar
struct ExpressionStatementAST: public StatementAST
{
DECLARE_AST_NODE(ExpressionStatement)
ExpressionAST *expression;
};
struct FunctionCallAST: public ExpressionAST
{
DECLARE_AST_NODE(FunctionCall)
ExpressionAST *arguments;
};
struct FunctionDefinitionAST: public DeclarationAST
{
DECLARE_AST_NODE(FunctionDefinition)
const ListNode<std::size_t> *storage_specifiers;
const ListNode<std::size_t> *function_specifiers;
TypeSpecifierAST *type_specifier;
InitDeclaratorAST *init_declarator;
StatementAST *function_body;
WinDeclSpecAST *win_decl_specifiers;
CtorInitializerAST *constructor_initializers;
};
struct ForStatementAST: public StatementAST
{
DECLARE_AST_NODE(ForStatement)
StatementAST *init_statement;
ConditionAST *condition;
ExpressionAST *expression;
StatementAST *statement;
};
struct IfStatementAST: public StatementAST
{
DECLARE_AST_NODE(IfStatement)
ConditionAST *condition;
StatementAST *statement;
StatementAST *else_statement;
};
struct IncrDecrExpressionAST: public ExpressionAST
{
DECLARE_AST_NODE(IncrDecrExpression)
std::size_t op; //Index of the token that describes the operator
};
struct InitDeclaratorAST: public AST
{
DECLARE_AST_NODE(InitDeclarator)
DeclaratorAST *declarator;
InitializerAST *initializer;
};
struct InitializerAST: public AST
{
DECLARE_AST_NODE(Initializer)
InitializerClauseAST *initializer_clause;
ExpressionAST *expression;
};
struct InitializerClauseAST: public AST
{
DECLARE_AST_NODE(InitializerClause)
// either 'expression' or 'initializer_list' or neither are used.
// neither are used when the clause represents the empty initializer "{}"
// assignment expression
ExpressionAST *expression;
const ListNode<InitializerClauseAST*> *initializer_list;
};
struct LabeledStatementAST: public StatementAST
{
DECLARE_AST_NODE(LabeledStatement)
std::size_t label;
//The constant label expression
ExpressionAST *expression;
StatementAST* statement;
};
struct LinkageBodyAST: public AST
{
DECLARE_AST_NODE(LinkageBody)
const ListNode<DeclarationAST*> *declarations;
};
struct LinkageSpecificationAST: public DeclarationAST
{
DECLARE_AST_NODE(LinkageSpecification)
std::size_t extern_type;
LinkageBodyAST *linkage_body;
DeclarationAST *declaration;
};
struct MemInitializerAST: public AST
{
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;
};
struct NamespaceAliasDefinitionAST: public DeclarationAST
{
DECLARE_AST_NODE(NamespaceAliasDefinition)
std::size_t namespace_name;
NameAST *alias_name;
};
struct NewDeclaratorAST: public AST
{
DECLARE_AST_NODE(NewDeclarator)
PtrOperatorAST *ptr_op;
NewDeclaratorAST *sub_declarator;
const ListNode<ExpressionAST*> *expressions;
};
struct NewExpressionAST: public ExpressionAST
{
DECLARE_AST_NODE(NewExpression)
std::size_t scope_token;
std::size_t new_token;
ExpressionAST *expression;
TypeIdAST *type_id;
NewTypeIdAST *new_type_id;
NewInitializerAST *new_initializer;
};
struct NewInitializerAST: public AST
{
DECLARE_AST_NODE(NewInitializer)
ExpressionAST *expression;
};
struct NewTypeIdAST: public AST
{
DECLARE_AST_NODE(NewTypeId)
TypeSpecifierAST *type_specifier;
NewInitializerAST *new_initializer;
NewDeclaratorAST *new_declarator;
};
struct OperatorAST: public AST
{
DECLARE_AST_NODE(Operator)
std::size_t op; //Index of the token that describes the operator
std::size_t open;
std::size_t close;
};
struct OperatorFunctionIdAST: public AST
{
DECLARE_AST_NODE(OperatorFunctionId)
OperatorAST *op;
TypeSpecifierAST *type_specifier;
const ListNode<PtrOperatorAST*> *ptr_ops;
};
struct ParameterDeclarationAST: public AST
{
DECLARE_AST_NODE(ParameterDeclaration)
TypeSpecifierAST *type_specifier;
DeclaratorAST *declarator;
ExpressionAST *expression;
};
struct ParameterDeclarationClauseAST: public AST
{
DECLARE_AST_NODE(ParameterDeclarationClause)
const ListNode<ParameterDeclarationAST*> *parameter_declarations;
std::size_t ellipsis;
};
/**
* A post-fix expression is an expression that consists of one primary expression and multiple sub-expressions that are evaluated from
* left to right, each sub-expression based on the previous expression.
*
*
* Examples:
* "a->b" : "a" is the primary expression, "->b" is a sub-expression
* "a->b(5,3)" : "a" is the primary expression, "->b" is a sub-expression, and "(5,3)" is a sub-expression
**/
struct PostfixExpressionAST: public ExpressionAST
{
DECLARE_AST_NODE(PostfixExpression)
TypeSpecifierAST *type_specifier;
ExpressionAST *expression;
const ListNode<ExpressionAST*> *sub_expressions;
};
struct PrimaryExpressionAST: public ExpressionAST
{
DECLARE_AST_NODE(PrimaryExpression)
StringLiteralAST *literal;
std::size_t token;
StatementAST *expression_statement;
ExpressionAST *sub_expression;
NameAST *name;
};
struct PtrOperatorAST: public AST
{
DECLARE_AST_NODE(PtrOperator)
const ListNode<std::size_t> *cv;
std::size_t op; //Index of the token that describes the operator. Is zero when mem_ptr is non-zero.
PtrToMemberAST *mem_ptr;
};
struct PtrToMemberAST: public AST
{
DECLARE_AST_NODE(PtrToMember)
};
struct JumpStatementAST : public StatementAST
{
DECLARE_AST_NODE(JumpStatement)
// index of operator token which describes the jump, one of
// 'break', 'continue' or 'goto. Return statements are handled by
// ReturnStatementAST
std::size_t op;
// identifier for 'goto' statements
std::size_t identifier;
};
struct ReturnStatementAST: public StatementAST
{
DECLARE_AST_NODE(ReturnStatement)
ExpressionAST *expression;
};
struct SimpleDeclarationAST: public DeclarationAST
{
DECLARE_AST_NODE(SimpleDeclaration)
const ListNode<std::size_t> *storage_specifiers;
const ListNode<std::size_t> *function_specifiers;
TypeSpecifierAST *type_specifier;
const ListNode<InitDeclaratorAST*> *init_declarators;
WinDeclSpecAST *win_decl_specifiers;
};
struct SimpleTypeSpecifierAST: public TypeSpecifierAST
{
DECLARE_AST_NODE(SimpleTypeSpecifier)
const ListNode<std::size_t> *integrals;
std::size_t type_of;
TypeIdAST *type_id;
ExpressionAST *expression;
NameAST *name;
};
struct SizeofExpressionAST: public ExpressionAST
{
DECLARE_AST_NODE(SizeofExpression)
std::size_t sizeof_token;
TypeIdAST *type_id;
ExpressionAST *expression;
};
struct StringLiteralAST: public AST
{
DECLARE_AST_NODE(StringLiteral)
const ListNode<std::size_t> *literals;
};
/// operator []
struct SubscriptExpressionAST: public ExpressionAST
{
DECLARE_AST_NODE(SubscriptExpression)
ExpressionAST *subscript;
};
struct SwitchStatementAST: public StatementAST
{
DECLARE_AST_NODE(SwitchStatement)
ConditionAST *condition;
StatementAST *statement;
};
struct TemplateArgumentAST: public AST
{
DECLARE_AST_NODE(TemplateArgument)
TypeIdAST *type_id;
ExpressionAST *expression;
};
struct TemplateDeclarationAST: public DeclarationAST
{
DECLARE_AST_NODE(TemplateDeclaration)
std::size_t exported;
const ListNode<TemplateParameterAST*> *template_parameters;
DeclarationAST* declaration;
};
struct TemplateParameterAST: public AST
{
DECLARE_AST_NODE(TemplateParameter)
TypeParameterAST *type_parameter; //This is used if this is a template-parameter like "class A"
ParameterDeclarationAST *parameter_declaration; //This is used if this is a template-parameter like "int a"
};
struct ThrowExpressionAST: public ExpressionAST
{
DECLARE_AST_NODE(ThrowExpression)
std::size_t throw_token;
ExpressionAST *expression;
};
struct TranslationUnitAST: public AST, public CommentAST
{
DECLARE_AST_NODE(TranslationUnit)
const ListNode<DeclarationAST*> *declarations;
///true if either a '}' was missing at the end, or there was a '}' too much.
///This indicates a temporary state where the user is typing, and the document is completely invalid.
bool hadMissingCompoundTokens;
// Note: non AST related, saves parsing session...
ParseSession* session;
};
struct TryBlockStatementAST: public StatementAST
{
DECLARE_AST_NODE(TryBlockStatement)
StatementAST* try_block;
const ListNode<CatchStatementAST*> *catch_blocks;
};
struct CatchStatementAST: public StatementAST
{
DECLARE_AST_NODE(CatchStatement)
ConditionAST* condition;
StatementAST* statement;
};
struct TypeIdAST: public AST
{
DECLARE_AST_NODE(TypeId)
TypeSpecifierAST *type_specifier;
DeclaratorAST *declarator;
};
///"typename"
struct TypeIdentificationAST: public ExpressionAST
{
DECLARE_AST_NODE(TypeIdentification)
std::size_t typename_token;
NameAST *name;
ExpressionAST *expression;
};
struct TypeParameterAST: public AST
{
DECLARE_AST_NODE(TypeParameter)
std::size_t type;
NameAST *name;
TypeIdAST *type_id;
const ListNode<TemplateParameterAST*> *template_parameters;
NameAST *template_name;
};
struct TypedefAST: public DeclarationAST
{
DECLARE_AST_NODE(Typedef)
TypeSpecifierAST *type_specifier;
const ListNode<InitDeclaratorAST*> *init_declarators;
};
struct UnaryExpressionAST: public ExpressionAST
{
DECLARE_AST_NODE(UnaryExpression)
std::size_t op; //Index of the token that describes the operator
ExpressionAST *expression;
};
struct UnqualifiedNameAST: public AST
{
DECLARE_AST_NODE(UnqualifiedName)
std::size_t tilde;
std::size_t id;
OperatorFunctionIdAST *operator_id;
const ListNode<TemplateArgumentAST*> *template_arguments;
};
struct UsingAST: public DeclarationAST
{
DECLARE_AST_NODE(Using)
std::size_t type_name;
NameAST *name;
};
struct UsingDirectiveAST: public DeclarationAST
{
DECLARE_AST_NODE(UsingDirective)
NameAST *name;
};
struct WhileStatementAST: public StatementAST
{
DECLARE_AST_NODE(WhileStatement)
ConditionAST *condition;
StatementAST *statement;
};
struct WinDeclSpecAST: public AST
{
DECLARE_AST_NODE(WinDeclSpec)
std::size_t specifier;
std::size_t modifier;
};
template <class _Tp>
_Tp *CreateNode(pool *memory_pool)
{
generator/parser/codegenerator.h view on Meta::CPAN
#define CODEGENERATOR_H
#include <QTextStream>
#include <QString>
#include "cppparser_export.h"
#include "default_visitor.h"
class Token;
class CPPPARSER_EXPORT CodeGenerator : public DefaultVisitor
{
public:
CodeGenerator(ParseSession* session);
virtual ~CodeGenerator();
QString output();
protected:
virtual void visitAccessSpecifier (AccessSpecifierAST*);
virtual void visitAsmDefinition (AsmDefinitionAST*);
virtual void visitBaseClause (BaseClauseAST*);
virtual void visitBaseSpecifier (BaseSpecifierAST*);
generator/parser/commentformatter.h view on Meta::CPAN
class ListNode;
/**
* This class cares about extracting the interesting information out of a comment.
* For example it removes all the stars at the beginning, and re-indents the text.
* */
class ParseSession;
class CPPPARSER_EXPORT CommentFormatter {
public:
///Processes the comment represented by the given token-number within the parse-session's token-stream
static QByteArray formatComment( size_t token, const ParseSession* session );
///Processes the list of comments represented by the given token-number within the parse-session's token-stream
static QByteArray formatComment( const ListNode<size_t>* node, const ParseSession* session );
private:
};
#endif
generator/parser/commentparser.h view on Meta::CPAN
#ifndef COMMENTPARSER_H
#define COMMENTPARSER_H
#include <QString>
#include <set>
class ParseSession;
class Comment {
public:
explicit Comment( size_t token = 0, int line = -1 );
operator bool() const;
inline int line() const {
return m_line;
}
bool operator==( const Comment& comment ) const;
generator/parser/commentparser.h view on Meta::CPAN
int m_line;
size_t m_token;
};
class CommentStore {
private:
typedef std::set< Comment > CommentSet;
CommentSet m_comments;
public:
/**
* Returns & removes the first comment currently in the comment-store
* */
Comment takeFirstComment();
/**
* Returns the comment nearest to the line of "end"(inclusive), and returns & removes it
* */
Comment takeCommentInRange( int endLine, int startLine = 0 );
generator/parser/control.h view on Meta::CPAN
#include <QtCore/QList>
struct Declarator;
struct Type;
/**Parser control information.
Provides problem tracking, context(visibility)-aware symbol name tables,
typedef table and other information about the parsing process.*/
class CPPPARSER_EXPORT Control
{
public:
Control();
~Control();
const QList<Problem*>& problems() const;
/**Adds a problem to the list of problems.*/
void reportProblem(Problem *problem);
private:
QList<Problem*> _M_problems;
generator/parser/default_visitor.h view on Meta::CPAN
*/
#ifndef DEFAULT_VISITOR_H
#define DEFAULT_VISITOR_H
#include <QtCore/Qt>
#include "cppparser_export.h"
#include "visitor.h"
class CPPPARSER_EXPORT DefaultVisitor: public Visitor
{
public:
DefaultVisitor() {}
protected:
virtual void visitAccessSpecifier(AccessSpecifierAST *);
virtual void visitAsmDefinition(AsmDefinitionAST *);
virtual void visitBaseClause(BaseClauseAST *);
virtual void visitBaseSpecifier(BaseSpecifierAST *);
virtual void visitBinaryExpression(BinaryExpressionAST *);
virtual void visitCastExpression(CastExpressionAST *);
virtual void visitClassMemberAccess(ClassMemberAccessAST *);
generator/parser/dumptree.h view on Meta::CPAN
#include "cppparser_export.h"
#include "default_visitor.h"
class TokenStream;
//Contains the name for each AST kind enumerator
CPPPARSER_EXPORT extern char const * const names[];
class CPPPARSER_EXPORT DumpTree: protected DefaultVisitor
{
public:
DumpTree();
virtual ~DumpTree();
void dump(AST *node, TokenStream* tokenStream = 0);
protected:
virtual void visit(AST *node);
private:
TokenStream* m_tokenStream;
generator/parser/indexedstring.h view on Meta::CPAN
///Whenever reference-counting is enabled for a range that contains the IndexedString, it will manipulate the reference-counts.
///The duchain storage mechanisms automatically are about correctly managing that condition, so you don't need to care, and can
///just use this class in every duchain data type without restrictions.
///
///@warning Do not use IndexedString after QCoreApplication::aboutToQuit() has been emitted, items that are not disk-referenced will be invalid at that point
///
///Empty strings have an index of zero.
///Strings of length one are not put into the repository, but are encoded directly within the index:
///They are encoded like 0xffff00bb where bb is the byte of the character.
class CPPPARSER_EXPORT IndexedString {
public:
IndexedString();
///@param str must be a utf8 encoded string, does not need to be 0-terminated.
///@param length must be its length in bytes.
///@param hash must be a hash as constructed with the here defined hash functions. If it is zero, it will be computed.
explicit IndexedString( const char* str, unsigned short length, unsigned int hash = 0 );
///Needs a zero terminated string. When the information is already available, try using the other constructor.
explicit IndexedString( const char* str );
explicit IndexedString( char c );
generator/parser/kdevvarlengtharray.h view on Meta::CPAN
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** This file may be used under the terms of the GNU General Public
** License versions 2.0 or 3.0 as published by the Free Software
** Foundation and appearing in the files LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Alternatively you may (at
** your option) use any later version of the GNU General Public
** License if such license has been publicly approved by Trolltech ASA
** (or its successors, if any) and the KDE Free Qt Foundation. In
** addition, as a special exception, Trolltech gives you certain
** additional rights. These rights are described in the Trolltech GPL
** Exception version 1.2, which can be found at
** http://www.trolltech.com/products/qt/gplexception/ and in the file
** GPL_EXCEPTION.txt in this package.
**
** Please review the following information to ensure GNU General
** Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/. If
generator/parser/kdevvarlengtharray.h view on Meta::CPAN
QT_BEGIN_NAMESPACE
QT_MODULE(Core)
//When this is uncommented, a QVector will be used instead of a variable-length array. This is useful for debugging, to find problems in KDevVarLengthArray
// #define FAKE_KDEVVARLENGTH_ARRAY
#ifdef FAKE_KDEVVARLENGTH_ARRAY
template<class T, int Prealloc = 256>
class KDevVarLengthArray : public QVector<T> {
public:
///Inserts the given item at the given position, moving all items behind the position back
void insert(const T& item, int position) {
QVector<T>::insert(position, item);
}
// Removes exactly one occurrence of the given value from the array. Returns false if none was found.
bool removeOne(const T& value) {
int i = this->indexOf(value);
if(i == -1)
return false;
generator/parser/kdevvarlengtharray.h view on Meta::CPAN
void append(const T *buf, int size) {
for(int a = 0; a < size; ++a)
append(buf[a]);
}
};
#else
template<class T, int Prealloc = 256>
class KDevVarLengthArray
{
public:
inline explicit KDevVarLengthArray(int size = 0);
inline KDevVarLengthArray(const KDevVarLengthArray<T, Prealloc> &other)
: a(Prealloc), s(0), ptr(reinterpret_cast<T *>(array))
{
append(other.constData(), other.size());
}
inline ~KDevVarLengthArray() {
if (QTypeInfo<T>::isComplex) {
generator/parser/lexer.cpp view on Meta::CPAN
ADD_TOKEN(mutable);
ADD_TOKEN(namespace);
ADD_TOKEN(new);
ADD_TOKEN(not);
ADD_TOKEN(not_eq);
ADD_TOKEN(operator);
ADD_TOKEN(or);
ADD_TOKEN(or_eq);
ADD_TOKEN(private);
ADD_TOKEN(protected);
ADD_TOKEN(public);
ADD_TOKEN(register);
ADD_TOKEN(reinterpret_cast);
ADD_TOKEN(return);
ADD_TOKEN(short);
ADD_TOKEN(signals);
ADD_TOKEN(signed);
ADD_TOKEN(sizeof);
ADD_TOKEN(slots);
ADD_TOKEN(static);
ADD_TOKEN(static_cast);
generator/parser/lexer.h view on Meta::CPAN
struct NameSymbol;
class Lexer;
class Control;
class ParseSession;
typedef void (Lexer::*scan_fun_ptr)();
/**Token.*/
class CPPPARSER_EXPORT Token
{
public:
///kind of the token @see TOKEN_KIND enum reference.
int kind;
///position in the preprocessed buffer
std::size_t position;
///size of the token in the preprocessed buffer. Do not confuse this with symbolLength.
std::size_t size;
///pointer to the parse session.
const ParseSession* session;
//Symbol associated to the token. This only works if this is a simple symbol
generator/parser/lexer.h view on Meta::CPAN
The stream has a "cursor" which is simply an integer which defines
the offset (index) of the token currently "observed" from the beginning of
the stream.*/
class CPPPARSER_EXPORT TokenStream
{
private:
TokenStream(const TokenStream &);
void operator = (const TokenStream &);
public:
/**Creates a token stream with the default size of 1024 tokens.*/
inline TokenStream(std::size_t size = 1024)
: tokens(0),
index(0),
token_count(0)
{
resize(size);
}
inline ~TokenStream()
generator/parser/lexer.h view on Meta::CPAN
std::size_t index;
std::size_t token_count;
private:
friend class Lexer;
};
/**C++ Lexer.*/
class CPPPARSER_EXPORT Lexer
{
public:
/**
* Constructor.
*
* \param token_stream Provides a stream of tokens to the lexer.
* \param location_table a table which will be filled with non-preprocessed line -> offset values
* \param line_table a table which will be filled with (non-preproccessed line which contains a preprocessor line) -> offset values
*/
Lexer(Control *control);
/**Finds tokens in the @p contents buffer and fills the @ref token_stream.*/
generator/parser/memorypool.h view on Meta::CPAN
#define MEMORYPOOL_H
#include "rxx_allocator.h"
#include <cstring>
/**Memory pool for chars.*/
class pool
{
rxx_allocator<char> __alloc;
public:
/**Allocates the @p size bytes in the pool.*/
inline void *allocate(std::size_t __size);
};
inline void *pool::allocate(std::size_t __size)
{
return __alloc.allocate(__size);
}
#endif // MEMORYPOOL_H
generator/parser/name_compiler.h view on Meta::CPAN
#include "cppparser_export.h"
#include "default_visitor.h"
// #include <language/duchain/identifier.h>
// #include <language/duchain/declaration.h>
class ParseSession;
class OperatorAST;
class CPPPARSER_EXPORT NameCompiler: protected DefaultVisitor
{
public:
NameCompiler(ParseSession* session);
///@param target If this is nonzero, the identifier will be written to that place without any copying.
void run(NameAST *node/*, KDevelop::QualifiedIdentifier* target = 0*/);
void run(UnqualifiedNameAST *node) { m_typeSpecifier = 0; internal_run(node); }
QString name() const { return m_name.join("::"); }
const QStringList& qualifiedName() const { return m_name; }
const QStringList& templateArgs() const { return m_templateArgs; }
generator/parser/parser.cpp view on Meta::CPAN
case Token_namespace:
case Token_using:
case Token_typedef:
case Token_asm:
case Token_template:
case Token_export:
case Token_const: // cv
case Token_volatile: // cv
case Token_public:
case Token_protected:
case Token_private:
case Token_signals: // Qt
case Token_slots: // Qt
return true;
case '}':
return false;
default:
advance();
generator/parser/parser.cpp view on Meta::CPAN
bool done = false;
while (!done)
{
switch(session->token_stream->lookAhead())
{
case Token_signals:
case Token_slots:
case Token_k_dcop:
case Token_k_dcop_signals:
case Token_public:
case Token_protected:
case Token_private:
specs = snoc(specs, session->token_stream->cursor(), session->mempool);
advance();
break;
default:
done = true;
break;
}
generator/parser/parser.cpp view on Meta::CPAN
std::size_t start = session->token_stream->cursor();
BaseSpecifierAST *ast = CreateNode<BaseSpecifierAST>(session->mempool);
if (session->token_stream->lookAhead() == Token_virtual)
{
ast->virt = session->token_stream->cursor();
advance();
int tk = session->token_stream->lookAhead();
if (tk == Token_public || tk == Token_protected
|| tk == Token_private)
{
ast->access_specifier = session->token_stream->cursor();
advance();
}
}
else
{
int tk = session->token_stream->lookAhead();
if (tk == Token_public || tk == Token_protected
|| tk == Token_private)
{
ast->access_specifier = session->token_stream->cursor();
advance();
}
if (session->token_stream->lookAhead() == Token_virtual)
{
ast->virt = session->token_stream->cursor();
advance();
generator/parser/parser.h view on Meta::CPAN
class TokenStream;
class Control;
/**
The Parser.
LL(k) parser for c++ code.
*/
class CPPPARSER_EXPORT Parser
{
public:
Parser(Control *control);
~Parser();
/**Parses the @p contents of the buffer of given @p size using the
memory pool @p p to store tokens found.
Calls lexer to tokenize all contents buffer, skips the first token
(because the lexer provides Token_EOF as the first token,
creates and fills the AST and returns translation unit or 0
if nothing was parsed.
generator/parser/parser.h view on Meta::CPAN
/**Convenience method to report problems. Constructs the problem
using the information about the current line and column in the buffer
that is being parsed. Then stores the problem in the control object.*/
void reportError(const QString& msg);
/**Reports a syntax error about unexpected token. The token
reported is LA (look-ahead) from the stream.*/
void syntaxError();
/**Reports a syntax error about required token when LA is wrong.*/
void tokenRequiredError(int expected);
public:
bool parseAbstractDeclarator(DeclaratorAST *&node);
bool parseAccessSpecifier(DeclarationAST *&node);
bool parseAdditiveExpression(ExpressionAST *&node);
bool parseAndExpression(ExpressionAST *&node, bool templArgs = false);
bool parseAsmDefinition(DeclarationAST *&node);
bool parseAssignmentExpression(ExpressionAST *&node);
bool parseBaseClause(BaseClauseAST *&node);
bool parseBaseSpecifier(BaseSpecifierAST *&node);
bool parseBlockDeclaration(DeclarationAST *&node);
bool parseCastExpression(ExpressionAST *&node);
generator/parser/parsesession.h view on Meta::CPAN
class Token;
typedef QVector<unsigned int> PreprocessedContents;
namespace rpp { class MacroBlock; class LocationTable; }
/// Contains everything needed to keep an AST useful once the rest of the parser
/// has gone away.
class CPPPARSER_EXPORT ParseSession
{
public:
ParseSession();
~ParseSession();
/**
* Return the position of the preprocessed source \a offset in the original source
* If the "collapsed" member of the returned anchor is true, the position is within a collapsed range.
@param collapseIfMacroExpansion @see LocationTable::positionForOffset
* \note the return line starts from 0, not 1.
*/
rpp::Anchor positionAt(std::size_t offset, bool collapseIfMacroExpansion = false) const;
generator/parser/rpp/anchor.h view on Meta::CPAN
#include <QtCore/Qt>
#include "../cppparser_export.h"
#include "../simplecursor.h"
namespace rpp {
/**
* A SimpleCursor with additional boolean value whether the range opened by this anchor is collapsed.
* If that value is true, it means that Everything behind the anchor until the next one is collapsed to the exact position of this anchor.
* */
class CPPPARSER_EXPORT Anchor : public SimpleCursor {
public:
Anchor() : collapsed(false) {
}
explicit Anchor(const SimpleCursor& cursor, bool _collapsed=false, SimpleCursor _macroExpansion=SimpleCursor::invalid()) : SimpleCursor(cursor), collapsed(_collapsed), macroExpansion(_macroExpansion) {
}
explicit Anchor(int line, int column, bool _collapsed=false, SimpleCursor _macroExpansion=SimpleCursor::invalid()) : SimpleCursor(line, column), collapsed(_collapsed), macroExpansion(_macroExpansion) {
}
bool collapsed;
generator/parser/rpp/appendedlist.h view on Meta::CPAN
};
/**
* Manages a repository of items for temporary usage. The items will be allocated with an index on alloc(),
* and freed on free(index). When freed, the same index will be re-used for a later allocation, thus no real allocations
* will be happening in most cases.
* The returned indices will always be ored with DynamicAppendedListMask.
*
*/
template<class T, bool threadSafe = true>
class TemporaryDataManager {
public:
TemporaryDataManager(QString id = QString()) : m_itemsUsed(0), m_itemsSize(0), m_items(0), m_id(id) {
uint first = alloc(); //Allocate the zero item, just to reserve that index
Q_ASSERT(first == (uint)DynamicAppendedListMask);
}
~TemporaryDataManager() {
free(DynamicAppendedListMask); //Free the zero index, so we don't get wrong warnings
uint cnt = usedItemCount();
if(cnt) //Don't use kDebug, because that may not work during destruction
std::cout << m_id.toLocal8Bit().data() << " There were items left on destruction: " << usedItemCount() << "\n";
generator/parser/rpp/appendedlist.h view on Meta::CPAN
* - Except for these appended lists, only contain directly copyable data like indices(no pointers, no virtual functions)
* - Implement operator==(..) which should compare everything, including the lists. @warning The default operator will not work!
* - Implement a hash() function. The hash should equal for two instances when operator==(..) returns true.
* - Should be completely functional without a constructor called, only the data copied
* - Implement a "bool persistent() const" function, that should check the reference-count or other information to decide whether the item should stay in the repository
* If those conditions are fulfilled, the data can easily be put into a repository using this request class.
* */
template<class Type, uint averageAppendedBytes = 8>
class AppendedListItemRequest {
public:
AppendedListItemRequest(const Type& item) : m_item(item) {
}
enum {
AverageSize = sizeof(Type) + averageAppendedBytes
};
unsigned int hash() const {
return m_item.hash();
}
generator/parser/rpp/pp-engine.h view on Meta::CPAN
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(); }
generator/parser/rpp/pp-environment.h view on Meta::CPAN
#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
generator/parser/rpp/pp-environment.h view on Meta::CPAN
// 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>());
generator/parser/rpp/pp-location.h view on Meta::CPAN
#include "../simplecursor.h"
#include "anchor.h"
typedef QVector<unsigned int> PreprocessedContents;
namespace rpp {
class CPPPARSER_EXPORT LocationTable
{
public:
LocationTable();
/// Generates the location table from the contents
LocationTable(const PreprocessedContents& contents);
///@param contents is allowed to be zero only if offset is zero, or if anchor.column is zero.
void anchor(std::size_t offset, Anchor anchor, const PreprocessedContents* contents);
/**
* Return the position of the preprocessed source \a offset in the original source
generator/parser/rpp/pp-macro-expander.h view on Meta::CPAN
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() {
generator/parser/rpp/pp-macro-expander.h view on Meta::CPAN
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);
( run in 0.567 second using v1.01-cache-2.11-cpan-64827b87656 )