static AllocationTypes CheckAllocationType(const CXXStaticCastExpr* castNode)
{
QualType targetType = castNode->getTypeAsWritten();
if (const IdentifierInfo* info = targetType.getBaseTypeIdentifier())
{
return info->getName().equals("Recycler") ?
AllocationTypes::Recycler : AllocationTypes::NonRecycler;
}
else
{
// Unknown template dependent allocator types
return AllocationTypes::Unknown;
}
}
bool TeslaVisitor::VisitFunctionDecl(FunctionDecl *F) {
// Only analyse non-deleted definitions (i.e. definitions with bodies).
if (!F->doesThisDeclarationHaveABody())
return true;
// We only parse functions that return __tesla_automaton_description*.
const Type *RetTy = F->getResultType().getTypePtr();
if (!RetTy->isPointerType())
return true;
QualType Pointee = RetTy->getPointeeType();
auto TypeID = Pointee.getBaseTypeIdentifier();
if (!TypeID)
return true;
OwningPtr<Parser> P;
StringRef FnName = F->getName();
// Build a Parser appropriate to what we're parsing.
string RetTypeName = TypeID->getName();
if (RetTypeName == AUTOMATON_DESC)
P.reset(Parser::AutomatonParser(F, *Context));
else if ((RetTypeName == AUTOMATON_USAGE) && (FnName != AUTOMATON_USES))
P.reset(Parser::MappingParser(F, *Context));
else
return true;
// Actually parse the function.
if (!P)
return false;
OwningPtr<AutomatonDescription> Description;
OwningPtr<Usage> Use;
if (!P->Parse(Description, Use))
return false;
if (Description)
Automata.push_back(Description.take());
if (Use)
Roots.push_back(Use.take());
return true;
}
/// \brief If the new variable name conflicts with any type used in the loop,
/// then we mark that variable name as taken.
bool DeclFinderASTVisitor::VisitTypeLoc(TypeLoc TL) {
QualType QType = TL.getType();
// Check if our name conflicts with a type, to handle for typedefs.
if (QType.getAsString() == Name) {
Found = true;
return false;
}
// Check for base type conflicts. For example, when a struct is being
// referenced in the body of the loop, the above getAsString() will return the
// whole type (ex. "struct s"), but will be caught here.
if (const IdentifierInfo *Ident = QType.getBaseTypeIdentifier()) {
if (Ident->getName() == Name) {
Found = true;
return false;
}
}
return true;
}
void ExprEngine::VisitCXXNewExpr(const CXXNewExpr *CNE, ExplodedNode *Pred,
ExplodedNodeSet &Dst) {
// FIXME: Much of this should eventually migrate to CXXAllocatorCall.
// Also, we need to decide how allocators actually work -- they're not
// really part of the CXXNewExpr because they happen BEFORE the
// CXXConstructExpr subexpression. See PR12014 for some discussion.
unsigned blockCount = currBldrCtx->blockCount();
const LocationContext *LCtx = Pred->getLocationContext();
DefinedOrUnknownSVal symVal = UnknownVal();
FunctionDecl *FD = CNE->getOperatorNew();
bool IsStandardGlobalOpNewFunction = false;
if (FD && !isa<CXXMethodDecl>(FD) && !FD->isVariadic()) {
if (FD->getNumParams() == 2) {
QualType T = FD->getParamDecl(1)->getType();
if (const IdentifierInfo *II = T.getBaseTypeIdentifier())
// NoThrow placement new behaves as a standard new.
IsStandardGlobalOpNewFunction = II->getName().equals("nothrow_t");
}
else
// Placement forms are considered non-standard.
IsStandardGlobalOpNewFunction = (FD->getNumParams() == 1);
}
// We assume all standard global 'operator new' functions allocate memory in
// heap. We realize this is an approximation that might not correctly model
// a custom global allocator.
if (IsStandardGlobalOpNewFunction)
symVal = svalBuilder.getConjuredHeapSymbolVal(CNE, LCtx, blockCount);
else
symVal = svalBuilder.conjureSymbolVal(nullptr, CNE, LCtx, CNE->getType(),
blockCount);
ProgramStateRef State = Pred->getState();
CallEventManager &CEMgr = getStateManager().getCallEventManager();
CallEventRef<CXXAllocatorCall> Call =
CEMgr.getCXXAllocatorCall(CNE, State, LCtx);
// Invalidate placement args.
// FIXME: Once we figure out how we want allocators to work,
// we should be using the usual pre-/(default-)eval-/post-call checks here.
State = Call->invalidateRegions(blockCount);
if (!State)
return;
// If this allocation function is not declared as non-throwing, failures
// /must/ be signalled by exceptions, and thus the return value will never be
// NULL. -fno-exceptions does not influence this semantics.
// FIXME: GCC has a -fcheck-new option, which forces it to consider the case
// where new can return NULL. If we end up supporting that option, we can
// consider adding a check for it here.
// C++11 [basic.stc.dynamic.allocation]p3.
if (FD) {
QualType Ty = FD->getType();
if (const FunctionProtoType *ProtoType = Ty->getAs<FunctionProtoType>())
if (!ProtoType->isNothrow(getContext()))
State = State->assume(symVal, true);
}
StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
if (CNE->isArray()) {
// FIXME: allocating an array requires simulating the constructors.
// For now, just return a symbolicated region.
const MemRegion *NewReg = symVal.castAs<loc::MemRegionVal>().getRegion();
QualType ObjTy = CNE->getType()->getAs<PointerType>()->getPointeeType();
const ElementRegion *EleReg =
getStoreManager().GetElementZeroRegion(NewReg, ObjTy);
State = State->BindExpr(CNE, Pred->getLocationContext(),
loc::MemRegionVal(EleReg));
Bldr.generateNode(CNE, Pred, State);
return;
}
// FIXME: Once we have proper support for CXXConstructExprs inside
// CXXNewExpr, we need to make sure that the constructed object is not
// immediately invalidated here. (The placement call should happen before
// the constructor call anyway.)
SVal Result = symVal;
if (FD && FD->isReservedGlobalPlacementOperator()) {
// Non-array placement new should always return the placement location.
SVal PlacementLoc = State->getSVal(CNE->getPlacementArg(0), LCtx);
Result = svalBuilder.evalCast(PlacementLoc, CNE->getType(),
CNE->getPlacementArg(0)->getType());
}
// Bind the address of the object, then check to see if we cached out.
State = State->BindExpr(CNE, LCtx, Result);
ExplodedNode *NewN = Bldr.generateNode(CNE, Pred, State);
if (!NewN)
return;
// If the type is not a record, we won't have a CXXConstructExpr as an
// initializer. Copy the value over.
if (const Expr *Init = CNE->getInitializer()) {
if (!isa<CXXConstructExpr>(Init)) {
assert(Bldr.getResults().size() == 1);
Bldr.takeNodes(NewN);
evalBind(Dst, CNE, NewN, Result, State->getSVal(Init, LCtx),
/*FirstInit=*/IsStandardGlobalOpNewFunction);
}
}
}
bool ScanfSpecifier::fixType(QualType QT, const LangOptions &LangOpt)
{
if (!QT->isPointerType())
return false;
QualType PT = QT->getPointeeType();
const BuiltinType *BT = PT->getAs<BuiltinType>();
if (!BT)
return false;
// Pointer to a character.
if (PT->isAnyCharacterType()) {
CS.setKind(ConversionSpecifier::sArg);
if (PT->isWideCharType())
LM.setKind(LengthModifier::AsWideChar);
else
LM.setKind(LengthModifier::None);
return true;
}
// Figure out the length modifier.
switch (BT->getKind()) {
// no modifier
case BuiltinType::UInt:
case BuiltinType::Int:
case BuiltinType::Float:
LM.setKind(LengthModifier::None);
break;
// hh
case BuiltinType::Char_U:
case BuiltinType::UChar:
case BuiltinType::Char_S:
case BuiltinType::SChar:
LM.setKind(LengthModifier::AsChar);
break;
// h
case BuiltinType::Short:
case BuiltinType::UShort:
LM.setKind(LengthModifier::AsShort);
break;
// l
case BuiltinType::Long:
case BuiltinType::ULong:
case BuiltinType::Double:
LM.setKind(LengthModifier::AsLong);
break;
// ll
case BuiltinType::LongLong:
case BuiltinType::ULongLong:
LM.setKind(LengthModifier::AsLongLong);
break;
// L
case BuiltinType::LongDouble:
LM.setKind(LengthModifier::AsLongDouble);
break;
// Don't know.
default:
return false;
}
// Handle size_t, ptrdiff_t, etc. that have dedicated length modifiers in C99.
if (isa<TypedefType>(PT) && (LangOpt.C99 || LangOpt.CPlusPlus0x)) {
const IdentifierInfo *Identifier = QT.getBaseTypeIdentifier();
if (Identifier->getName() == "size_t") {
LM.setKind(LengthModifier::AsSizeT);
} else if (Identifier->getName() == "ssize_t") {
// Not C99, but common in Unix.
LM.setKind(LengthModifier::AsSizeT);
} else if (Identifier->getName() == "intmax_t") {
LM.setKind(LengthModifier::AsIntMax);
} else if (Identifier->getName() == "uintmax_t") {
LM.setKind(LengthModifier::AsIntMax);
} else if (Identifier->getName() == "ptrdiff_t") {
LM.setKind(LengthModifier::AsPtrDiff);
}
}
// Figure out the conversion specifier.
if (PT->isRealFloatingType())
CS.setKind(ConversionSpecifier::fArg);
else if (PT->isSignedIntegerType())
CS.setKind(ConversionSpecifier::dArg);
else if (PT->isUnsignedIntegerType()) {
// Preserve the original formatting, e.g. 'X', 'o'.
if (!CS.isUIntArg()) {
CS.setKind(ConversionSpecifier::uArg);
}
} else
llvm_unreachable("Unexpected type");
return true;
}
bool PrintfSpecifier::fixType(QualType QT, const LangOptions &LangOpt) {
// Handle strings first (char *, wchar_t *)
if (QT->isPointerType() && (QT->getPointeeType()->isAnyCharacterType())) {
CS.setKind(ConversionSpecifier::sArg);
// Disable irrelevant flags
HasAlternativeForm = 0;
HasLeadingZeroes = 0;
// Set the long length modifier for wide characters
if (QT->getPointeeType()->isWideCharType())
LM.setKind(LengthModifier::AsWideChar);
else
LM.setKind(LengthModifier::None);
return true;
}
// We can only work with builtin types.
const BuiltinType *BT = QT->getAs<BuiltinType>();
if (!BT)
return false;
// Set length modifier
switch (BT->getKind()) {
case BuiltinType::Bool:
case BuiltinType::WChar_U:
case BuiltinType::WChar_S:
case BuiltinType::Char16:
case BuiltinType::Char32:
case BuiltinType::UInt128:
case BuiltinType::Int128:
case BuiltinType::Half:
// Various types which are non-trivial to correct.
return false;
#define SIGNED_TYPE(Id, SingletonId)
#define UNSIGNED_TYPE(Id, SingletonId)
#define FLOATING_TYPE(Id, SingletonId)
#define BUILTIN_TYPE(Id, SingletonId) \
case BuiltinType::Id:
#include "clang/AST/BuiltinTypes.def"
// Misc other stuff which doesn't make sense here.
return false;
case BuiltinType::UInt:
case BuiltinType::Int:
case BuiltinType::Float:
case BuiltinType::Double:
LM.setKind(LengthModifier::None);
break;
case BuiltinType::Char_U:
case BuiltinType::UChar:
case BuiltinType::Char_S:
case BuiltinType::SChar:
LM.setKind(LengthModifier::AsChar);
break;
case BuiltinType::Short:
case BuiltinType::UShort:
LM.setKind(LengthModifier::AsShort);
break;
case BuiltinType::Long:
case BuiltinType::ULong:
LM.setKind(LengthModifier::AsLong);
break;
case BuiltinType::LongLong:
case BuiltinType::ULongLong:
LM.setKind(LengthModifier::AsLongLong);
break;
case BuiltinType::LongDouble:
LM.setKind(LengthModifier::AsLongDouble);
break;
}
// Handle size_t, ptrdiff_t, etc. that have dedicated length modifiers in C99.
if (isa<TypedefType>(QT) && (LangOpt.C99 || LangOpt.CPlusPlus0x)) {
const IdentifierInfo *Identifier = QT.getBaseTypeIdentifier();
if (Identifier->getName() == "size_t") {
LM.setKind(LengthModifier::AsSizeT);
} else if (Identifier->getName() == "ssize_t") {
// Not C99, but common in Unix.
LM.setKind(LengthModifier::AsSizeT);
} else if (Identifier->getName() == "intmax_t") {
LM.setKind(LengthModifier::AsIntMax);
} else if (Identifier->getName() == "uintmax_t") {
LM.setKind(LengthModifier::AsIntMax);
} else if (Identifier->getName() == "ptrdiff_t") {
LM.setKind(LengthModifier::AsPtrDiff);
}
}
// Set conversion specifier and disable any flags which do not apply to it.
// Let typedefs to char fall through to int, as %c is silly for uint8_t.
if (isa<TypedefType>(QT) && QT->isAnyCharacterType()) {
CS.setKind(ConversionSpecifier::cArg);
LM.setKind(LengthModifier::None);
Precision.setHowSpecified(OptionalAmount::NotSpecified);
HasAlternativeForm = 0;
HasLeadingZeroes = 0;
HasPlusPrefix = 0;
}
// Test for Floating type first as LongDouble can pass isUnsignedIntegerType
else if (QT->isRealFloatingType()) {
CS.setKind(ConversionSpecifier::fArg);
}
else if (QT->isSignedIntegerType()) {
CS.setKind(ConversionSpecifier::dArg);
HasAlternativeForm = 0;
}
else if (QT->isUnsignedIntegerType()) {
// Preserve the original formatting, e.g. 'X', 'o'.
if (!cast<PrintfConversionSpecifier>(CS).isUIntArg())
CS.setKind(ConversionSpecifier::uArg);
HasAlternativeForm = 0;
HasPlusPrefix = 0;
} else {
llvm_unreachable("Unexpected type");
}
return true;
}
/*
this helper function is called when the traversal reaches a node of type Stmt
*/
void StmtHelper(Stmt *x){
//variable used for <cond> </cond>
//bool condition = false;
bool isElse = false;
if(x != NULL){
string output = "";
//find current level and next level
int intLevel = getLevelStmt(x); int intNextLevel = intLevel+1;
//convert them both to strings to use for output
string level; string nextLevel;
stringstream ss;
ss << intLevel;
level = ss.str();
stringstream ss2;
ss2 << intNextLevel;
nextLevel = ss2.str();
const Stmt* parent = getStmtParent(x, Context);
//PROBLEM
if(x->getStmtClassName() != std::string("ForStmt") && isFlowControl(x, Context)){
//return;
}
//if the parent is calling any type of funciton then this node should be enclosed in <args> </args>
string filename;
if(callStackDebug && !callStack.empty()){
cerr << "stmt: call stack top: " << callStack.top()->getStmtClassName() << endl;
}
while(!callStack.empty() && numClosingArgsNeeded > 0
&& !isParentStmt(parent, callStack.top()->getStmtClassName())){
if(debugPrint){
cerr << "adding args" << endl;
}
numClosingArgsNeeded--;
output += "</args,1>\n";
callStack.pop();
if(callStackDebug){
cerr << "popping" << endl;
printCallStack();
}
}
if(isParentStmtInCurFile(x,"CXXConstructExpr") && isParentStmt(x, "CXXConstructExpr")){
if(debugPrint){
cerr << "setting previousConstructorCall to true" << endl;
}
}else if(isParentStmtInCurFile(x,"CXXTemporaryObjectExpr") && isParentStmt(x, "CXXTemporaryObjectExpr")){
if(debugPrint){
cerr << "setting previousTempConstructorCallArg" << endl;
}
}else if(isParentStmt(x, "CallExpr")){
if(debugPrint){
cerr << "setting previousCallArgs to true" << endl;
}
}else if(isParentStmt(x, "CXXMemberCallExpr")){
if(debugPrint){
cerr << "setting previousMemberCallArgs to true" << endl;
}
}
//if the parent is a variable declaration then this node should be encolsed in <decl> </decl>
if(isParentStmt(x, "Var")){
previousRhsDecl = true;
if(debugPrint){
cout << "setting prev var to true" << endl;
}
}else if(previousRhsDecl && numClosingVarsNeeded > 0){
//if the current node is not a child of a variable declaration
//but the previous node was a child of a variable declation
//then we know to print a </decl>
output +="</variableDecl,1>\n";
numClosingVarsNeeded--;
previousRhsDecl = false;
}
if(parent != NULL && strcmp(parent->getStmtClassName(), "IfStmt") == 0){
if(debugPrint){
cerr << "possibly an if statement" << endl;
}
//find the first child of the if statemt
const Stmt* firstChild = NULL;
auto children = parent->children();
for(const Stmt* child : children){
if(child != NULL){
firstChild = child;
break;
}
}
//if the first child is the current node, then we know it is part of the condition
if(firstChild != NULL && x->getLocStart() == firstChild->getLocStart()){
if(debugPrint){
cerr << "part of the condition" << endl;
}
prevCondition = true;
}else if(prevCondition){
output +="</cond,1>\n";
prevCondition = false;
}
//find if else
const IfStmt* ifstmt = (IfStmt*) parent;
const Stmt* elseStmt = ifstmt->getElse();
if(elseStmt != NULL){
if(debugPrint){
cout << "checking if " << x->getLocStart().printToString(Context->getSourceManager());
cout << " == " << elseStmt->getLocStart().printToString(Context->getSourceManager());
cout << " : " << (x->getLocStart() == elseStmt->getLocStart()) << endl;
}
if(x->getLocStart() == elseStmt->getLocStart()){
isElse = true;
}
}
}
string node = x->getStmtClassName();
if(node == "ReturnStmt"){
output += "<return";
}else if(node == "ForStmt"){
output += "<forLoop";
}else if(node == "WhileStmt"){
output += "<whileLoop";
}else if(node == "DoStmt"){
output += "<do";
}else if(node == "IfStmt"){
if(parent->getStmtClassName() != std::string("IfStmt")){
stringstream ssminus;
ssminus << (intLevel-1);
output += "<ifBlock," + ssminus.str() + ">\n";
intLevel += 1;
stringstream ssif;
ssif << intLevel;
level = ssif.str();
}
output += "<ifStatement";
}else if(node == "SwitchStmt"){
output += "<switch";
}else if(node == "CaseStmt"){
output += "<case";
}else if(node == "CXXMemberCallExpr"){
CXXMemberCallExpr* ce = (CXXMemberCallExpr*) x;
Expr* obj = ce->getImplicitObjectArgument();
CallExpr* expr = (CallExpr*) x;
output += "<object: ";
QualType qt = obj->getType();
output += qt.getBaseTypeIdentifier()->getName().str();
output += "; calling func: ";
output += expr->getDirectCallee()->getNameInfo().getAsString();
output += ", " + level + ">\n";
output += "<args";
numClosingArgsNeeded++;
callStack.push(x);
if(callStackDebug){
cerr << "pushing" << endl;
printCallStack();
}
}else if(node == "CallExpr"){
CallExpr* expr = (CallExpr*) x;
output += "<calling func: ";
output += expr->getDirectCallee()->getNameInfo().getAsString();
output += ", " + level + ">\n";
output += "<args";
numClosingArgsNeeded++;
callStack.push(x);
if(callStackDebug){
cerr << "pushing" << endl;
printCallStack();
}
}else if(node == "CXXConstructExpr"){
CXXConstructExpr* ce = (CXXConstructExpr*) x;
//Decl* CD = ce->getConstructor();
string filename;
//if(isInCurFile(Context, CD, filename)){
CXXMethodDecl* MD = ce->getConstructor();
output += "<calling func: ";
output += MD->getNameInfo().getAsString();
output += "," + level + ">\n";
output += "<args";
numClosingArgsNeeded++;
callStack.push(x);
if(callStackDebug){
cerr << "pushing" << endl;
printCallStack();
}
//}
}else if(node == "BinaryOperator"){
BinaryOperator* binaryOp = (BinaryOperator*) x;
if(binaryOp->isAssignmentOp()){
output += "<assignment";
}else if(binaryOp->isComparisonOp()){
output += "<comparison";
}else{
output += "<binaryOp";
}
}else if(node == "UnaryOperator"){
UnaryOperator* uo = (UnaryOperator*) x;
string op = uo->getOpcodeStr(uo->getOpcode()).str();
if(op != "-"){
output += "<unaryOp";
}
}else if(node == "CompoundAssignOperator"){
output += "<augAssign";
}else if(node == "CompoundStmt"){
if(isElse){
output += "<elseStatement";
}else{
output += "<compoundStmt";
}
}else if(node == "CXXThrowExpr"){
output += "<raisingException";
}else if(node == "CXXTryStmt"){
output += "<try";
}else if(node == "CXXCatchStmt"){
output += "<except";
}else if(node == "CXXOperatorCallExpr"){
CXXOperatorCallExpr* ce = (CXXOperatorCallExpr*) x;
if(ce->isAssignmentOp()){
output += "<assignment";
}
}else if(node == "CXXTemporaryObjectExpr"){
CXXTemporaryObjectExpr* ce = (CXXTemporaryObjectExpr*) x;
Decl* CD = ce->getConstructor();
string filename;
if(isInCurFile(Context, CD, filename)){
CXXMethodDecl* MD = ce->getConstructor();
output += "<calling func: ";
output += MD->getNameInfo().getAsString();
output += "," + level + ">\n";
output += "<args";
numClosingArgsNeeded++;
callStack.push(x);
if(callStackDebug){
cerr << "pushing" << endl;
printCallStack();
}
}
}else if(node == "DeclRefExpr"){
if(parent != NULL && parent->getStmtClassName() == std::string("ImplicitCastExpr")){
DeclRefExpr* dr = (DeclRefExpr*) x;
ValueDecl* d = (ValueDecl*) dr->getDecl();
//cout << d->getQualType().getAsString() << endl;
if(d != NULL){
QualType qt = d->getType();
//cout << qt.getAsString() << endl;
if(qt.getAsString() == "std::vector<int, class std::allocator<int> >::const_reference (std::vector::size_type) const noexcept"){
//string type = io->getName().str();
//cout << type << endl;
//if(type == "vector"){
output += "<expr";
//}
}
}
}
}else{
if(allNodes){
output += "<";
output += node;
output += ">";
}
}
if(output.size() != 0 && !endsIn(output, "</cond,1>\n") &&
!endsIn(output,"</variableDecl,1>\n") && !endsIn(output,"</args,1>\n")
&& !endsIn(output,">") && !endsIn(output, ">\n")){
output += ", " + level + ">";
cout << output << endl;
output = "";
}else if(output.size() != 0){
cout << output << endl;
output = "";
if(debugPrint){
cerr << "printing output" << endl;
}
}
}
}
/*
this helper function is called when the traversal reaches a node of type Decl
*/
bool DeclHelper(Decl *D){
const Stmt* parent = getStmtParent(D, Context);
//const Stmt* parentsParent = getStmtParent(parent, Context);
//if it is part of the (init; condition; increment) of a for loop, we don't care about it
if(isFlowControl(D, Context)){
return false;
}
//supresses the catch stmt's arguments
if(parent != NULL && strcmp(parent->getStmtClassName(), "CXXCatchStmt") == 0){
return true;
}
string filename;
if(!isInCurFile(Context, D, filename) && filename.size() != 0){
return false;
}else if(filename.size() == 0){
return true;
}
string output = "";
//get the name of the node type
string node = D->getDeclKindName();
//calculate the current level, nextLevel, and previousLevel
int intLevel = getLevelDecl(D);int intNextLevel = intLevel+1;
int intNextNextLevel = intLevel+2; int intPrevLevel = intLevel-1;
//create string values for the levels to use as output
string level; string nextLevel;
string nextNextLevel; string prevLevel;
stringstream ss; stringstream ss2; stringstream ss3; stringstream ss4;
ss << intLevel;
level = ss.str();
ss2 << intNextLevel;
nextLevel = ss2.str();
ss3 << intPrevLevel;
prevLevel = ss3.str();
ss4 << intNextNextLevel;
nextNextLevel = ss4.str();
if(callStackDebug && !callStack.empty()){
cerr << "decl: call stack top: " << callStack.top()->getStmtClassName() << endl;
}
//if top of stack is no longer a parent
while(!callStack.empty() && numClosingArgsNeeded > 0
&& !isParentDecl(D, callStack.top()->getStmtClassName())){
if(debugPrint){
cerr << "adding args" << endl;
}
numClosingArgsNeeded--;
output += "</args,1>\n";
callStack.pop();
if(callStackDebug){
cerr << "poping" << endl;
printCallStack();
}
}
//add new calls to stack
if(isParentDeclInCurFile(D,"CXXConstructExpr") && isParentDecl(D, "CXXConstructExpr")){
if(debugPrint){
cerr << "setting previousConstructorCall to true" << endl;
}
}else if(isParentDeclInCurFile(D,"CXXTemporaryObjectExpr") && isParentDecl(D, "CXXTemporaryObjectExpr")){
if(debugPrint){
cerr << "setting previousTempConstructorCallArg" << endl;
}
}else if(isParentDecl(D, "CallExpr")){
if(debugPrint){
cerr << "setting previousCallArgs to true" << endl;
}
}else if(isParentDecl(D, "CXXMemberCallExpr")){
if(debugPrint){
cerr << "setting previousMemberCallArg to true" << endl;
}
}
if(isParentDecl(getDeclParent(D, Context), "Var")){
previousRhsDecl = true;
if(debugPrint){
cout << "setting prev var to true" << endl;
}
}else if(previousRhsDecl && numClosingVarsNeeded > 0){
//if the current node is not a child of a variable declaration
//but the previous node was a child of a variable declation
//then we know to print a </decl>
output +="</variableDecl,1>\n";
numClosingVarsNeeded--;
previousRhsDecl = false;
}
if(node == "Var"){
output += "<variableDecl, " + prevLevel + ">";
numClosingVarsNeeded++;
VarDecl* VD = (VarDecl*) D;
if(!VD->hasInit()){
output +="\n</variableDecl,1>\n";
numClosingVarsNeeded--;
}
}else if(node == "Function"){
FunctionDecl* FD = (FunctionDecl*) D;
output += "<functionDef," + level +">";
//add function name to the output
output += "\n<name: " + FD->getNameInfo().getAsString()
+ "," + nextLevel + ">";
}else if(node == "CXXRecord"){
const Decl* parent = getDeclParent(D, Context);
if(parent && strcmp(parent->getDeclKindName(), "CXXRecord") != 0){
CXXRecordDecl* CD = (CXXRecordDecl*) D;
output += "<classDef," + level + ">";
output += "\n<name: " + CD->getNameAsString() + "," + nextLevel + ">";
output += "\n<bases," + nextLevel + ">";
//iterate over all bases and add them to the output
CXXRecordDecl::base_class_iterator basesItr = CD->bases_begin();
while(basesItr != CD->bases_end()){
QualType qt = basesItr->getType();
output += "\n<base: " + qt.getBaseTypeIdentifier()->getName().str();
output += "," + nextNextLevel + ">";
basesItr++;
}
//iterate over all of the virtual bases and add them to the output
auto vBasesItr = CD->vbases_begin();
while(vBasesItr != CD->vbases_end()){
QualType qt = vBasesItr->getType();
output += "\n<base: " + qt.getBaseTypeIdentifier()->getName().str();
output += "," + nextNextLevel + ">";
vBasesItr++;
}
}
}else if(node == "CXXDestructor"){
CXXDestructorDecl* CD = (CXXDestructorDecl*) D;
if(!CD->isImplicit()){
output += "<functionDef," + level +">";
//add function name to the output
output += "\n<name: ~" + CD->getNameInfo().getAsString()
+ "," + nextLevel + ">";
}
}else if(node == "CXXConstructor"){
CXXConstructorDecl* CD = (CXXConstructorDecl*) D;
if(!CD->isImplicit()){
output += "<functionDef," + level +">";
//add function name to the output
output += "\n<name: " + CD->getNameInfo().getAsString()
+ "," + nextLevel + ">";
}
}else if(node == "CXXMethod"){
CXXMethodDecl* CM = (CXXMethodDecl*) D;
if(!CM->isImplicit()){
output += "<functionDef," + level +">";
//add function name to the output
output += "\n<name: " + CM->getNameInfo().getAsString()
+ "," + nextLevel + ">";
}
}else{
if(debugPrint){
output += "<";
output += node;
output += ">";
}
}
if(output.size() != 0){
cout << output << endl;
}
return true;
}