virtual bool Visit(BDiskDevice* device)
{
return Visit(device, 0);
}
void PrettyPrinter::PrintDeclarations(ZoneList<Declaration*>* declarations) {
for (int i = 0; i < declarations->length(); i++) {
if (i > 0) Print(" ");
Visit(declarations->at(i));
}
}
void
OrderedTask::AcceptTaskPointVisitor(TaskPointConstVisitor& visitor) const
{
Visit(task_points, visitor);
}
void PrettyPrinter::VisitThrow(Throw* node) {
Print("throw ");
Visit(node->exception());
}
void PrettyPrinter::VisitCallNew(CallNew* node) {
Print("new (");
Visit(node->expression());
Print(")");
PrintArguments(node->arguments());
}
void PrettyPrinter::VisitWithStatement(WithStatement* node) {
Print("with (");
Visit(node->expression());
Print(") ");
Visit(node->statement());
}
void PrettyPrinter::VisitAssignment(Assignment* node) {
Visit(node->target());
Print(" %s ", Token::String(node->op()));
Visit(node->value());
}
void operator()(T& type)
{
Visit(type);
}
void Visit( bool b )
{
Visit( int(b) );
}
void Visit(const AirspaceWarningManager &awm) {
for (auto i = awm.begin(), end = awm.end(); i != end; ++i)
Visit(*i);
}
void Visit(const ProtectedAirspaceWarningManager &awm) {
const ProtectedAirspaceWarningManager::Lease lease(awm);
Visit(lease);
}
void addSubNodes(FunctionDecl* FD) {
for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) {
Visit(FD->getParamDecl(i));
Doc.toParent();
}
}
void
AirspaceVisitor::Visit(const Airspace &as)
{
Visit(*as.get_airspace());
}
void Inliner::VisitChildren(Stmt *node) {
for(Stmt::child_iterator I = node->child_begin(), E = node->child_end();I != E;++I)
if(*I) Visit(*I);
}
void PrettyPrinter::VisitExpressionStatement(ExpressionStatement* node) {
Visit(node->expression());
Print(";");
}
// Visits a node returns total weight
double Visit(const DependencyGraph::Node* dependencyNode, GroupedDependencyGraph::Node* refByNode, unsigned int times)
{
unsigned int fileHandle = dependencyNode->GetData().fileHandle;
FileToNodeMap::iterator it = m_FileMap.find(fileHandle);
GroupedDependencyGraph::Node* groupNode = NULL;
if (it != m_FileMap.end())
{
groupNode = m_GroupedGraph.GetHead()->GetChildren().GetNode(it->second);
m_GroupedGraph.GetHead()->GetChildren().GetLink(it->second).count += times;
}
else
{
NodeWeight weight;
weight.fileHandle = fileHandle;
weight.myWeight = GetFileWeight(fileHandle);
weight.myTotalWeight = 0.0;
weight.totalWeight = 0.0;
groupNode = m_GroupedGraph.CreateNode(weight);
LinkWeight linkData;
linkData.count = 1;
unsigned int nodeId = m_GroupedGraph.GetHead()->GetChildren().AddLink(groupNode, linkData);
m_FileMap.insert( FileToMapEntry(fileHandle, nodeId) );
}
unsigned int refById;
FindNodeByFileHandle matchFunc(refByNode->GetData().fileHandle);
if (groupNode->GetRefBy().FindNode(&matchFunc, refById))
{
groupNode->GetRefBy().GetLink(refById).count += times;
}
else
{
NodeWeight nodeDescr;
nodeDescr.fileHandle = refByNode->GetData().fileHandle;
nodeDescr.myTotalWeight = 0;
nodeDescr.totalWeight = 0;
GroupedDependencyGraph::Node* newNode = m_GroupedGraph.CreateNode(nodeDescr);
LinkWeight linkData;
linkData.count = times;
groupNode->GetRefBy().AddLink(newNode, linkData);
}
double totalWeight = 0.0;
for(unsigned int i=0; i < dependencyNode->GetChildren().GetCount(); i++)
{
const DependencyGraph::Node* child = dependencyNode->GetChildren().GetNode(i);
double w = Visit(child, groupNode, dependencyNode->GetChildren().GetLink(i).count);
unsigned int linkId;
FindNodeByFileHandle matchFunc(child->GetData().fileHandle);
if (groupNode->GetChildren().FindNode(&matchFunc, linkId))
{
GroupedDependencyGraph::Node* groupDependency = groupNode->GetChildren().GetNode(linkId);
groupDependency->GetData().myTotalWeight += GetFileWeight(child->GetData().fileHandle);
groupDependency->GetData().totalWeight += w;
groupNode->GetChildren().GetLink(linkId).count += 1;
}
else
{
NodeWeight nodeDescr;
nodeDescr.fileHandle = child->GetData().fileHandle;
nodeDescr.myTotalWeight = GetFileWeight(child->GetData().fileHandle);
nodeDescr.totalWeight = w;
GroupedDependencyGraph::Node* newNode = m_GroupedGraph.CreateNode(nodeDescr);
LinkWeight linkData;
linkData.count = 1;
groupNode->GetChildren().AddLink(newNode, linkData);
}
totalWeight += w;
}
double fileWeight = GetFileWeight(fileHandle);
groupNode->GetData().myTotalWeight += fileWeight;
totalWeight += fileWeight;
groupNode->GetData().totalWeight += totalWeight;
return totalWeight;
}
void PrettyPrinter::VisitReturnStatement(ReturnStatement* node) {
Print("return ");
Visit(node->expression());
Print(";");
}
void
Serialiser::Visit(const AnnularSectorZone &data)
{
Visit((const SectorZone&)data);
node.SetAttribute(_T("inner_radius"), data.GetInnerRadius());
}
void PrettyPrinter::VisitTryFinallyStatement(TryFinallyStatement* node) {
Print("try ");
Visit(node->try_block());
Print(" finally ");
Visit(node->finally_block());
}
CXChildVisitResult Cursor::VisitorWrapper(CXCursor cursor, CXCursor parent,
CXClientData client_data) {
auto visitor = static_cast<CursorVisitor*>(client_data);
return visitor->Visit(Cursor(cursor), Cursor(parent));
}
void PrettyPrinter::VisitYield(Yield* node) {
Print("yield ");
Visit(node->expression());
}
void operator()(const Waypoint &wp) {
Visit(wp);
}
void PrettyPrinter::VisitCall(Call* node) {
Visit(node->expression());
PrintArguments(node->arguments());
}
void PrettyPrinter::VisitModuleVariable(ModuleVariable* node) {
Visit(node->proxy());
}
const char* PrettyPrinter::Print(AstNode* node) {
Init();
Visit(node);
return output_;
}
void PrettyPrinter::VisitModulePath(ModulePath* node) {
Visit(node->module());
Print(".");
PrintLiteral(node->name(), false);
}
NodeContext VisitCastExpr(CastExpr* CE) {
NodeContext result = Visit(CE->getSubExpr());
return result;
}
void PrettyPrinter::VisitModuleStatement(ModuleStatement* node) {
Print("module ");
PrintLiteral(node->proxy()->name(), false);
Print(" ");
Visit(node->body());
}
void CqParseTreeViz::Visit(IqParseNodeUnaryOp& node)
{
Visit(*static_cast<IqParseNodeOperator*>(
node.GetInterface(ParseNode_Operator)));
}
RValueTy AggregateExprEmitter::EmitExpr(const Expr *E) {
return Visit(E);
}
