Question

我正在重写IR类别和算法不断变化的编译器的IR。当前的编译器至少有2个当前的IR，这些IR用于我要合并的不同阶段。

首先，我们有一个AST层次结构，它基于Node抽象基类和与之关联的访问者模式。接下来，我们有一个单独的语义层次结构，该层次结构使用了各种类（我可能可以全部重新设置基础，以便Node也是所有这些类的最低级别的类）。随着我们认识到更多的专业化，语义层次结构可能会增长。这些类有一个单独的Visitor模式。创建了2个“可执行” IR用于执行生成的程序。

我的目标是合并AST和语义层次结构，并合并它们生成的可执行形式。这将减少由于两种形式的不一致而导致的错误的数量。

但是，正如我指出的那样，语义层次结构很可能会添加新的类。此外，我们还可能会添加新的访问者算法。

所以，我想要做的是这样的事情：

class VisitorBase;
class Node;

template Visitable<T> {
   virtual preVisitAccept(VisitorBase *v) { 
      v->preVisit(static_cast<T *>this); }
   virtual inVisitAccept(VisitorBase *v) { 
      v->inVisit(static_cast<T *>this); }
   virtual postVisitAccept(VisitorBase *v) { 
      v->postVisit(static_cast<T *>this); }
   };

template Visitor<T> {
   virtual preVisit(Node *n) { /* do nothing by default */ }
   virtual inVisit(Node *n) { /* do nothing by default */ }
   virtual postVisit(Node *n) { /* do nothing by default */ }
   };

class VisitorBase : Visitor<VistorBase> {
   };

class Node : Visitable<Node> {
   // Code that walks the tree will be probably here 
   // invoking pre, in, and post visit functions as appropriate
}

class ArithOp: node {
   // I don't mind repeating this in each class
   // Some visitor may be specialized on this function
   preVisitAccept(VisitorBase *v) override { 
      v->preVisit(static_cast<arithOp *>this); }
   ...
}

class PrettyPrintVisitor : VisitorBase {
    //  Here is a specialized visitor
    preVisit(ArithOp *n) override { /* specialized code /* }
}

我不介意在每个派生节点类或每个访问者类中重复一些代码。

我想摆脱的是一个脆弱的静态列表（我们必须更新），该列表包含从Node继承的所有类型，但是仍然可以对它们进行两次分派。如果我们不得不多次重复这样的列表，那将特别糟糕。我基本上不希望节点知道访问者（除了当有为该节点定制的访问者时），也不希望其他节点类知道。我也不想让访问者知道节点（除了定制访问者的节点类型以外）。而且，我不希望有任何此类信息的中央存储库，因为它将成为始终触发重新编译世界的头文件。...

我对代码实验有任何想法吗？我们可能会使用G ++或CLang进行编译。

Answer 1

在访问者中执行的双重调度是将一对（visitor_dynamic_type，acceptor_dynamic_type）对与函数（C ++函数）相关联的函数（从函数的数学意义上来说）。

由于您不希望基本访问者知道从基本接受器派生的所有类型，因此必须通过抽象该类型的方式来标识acceptor_dynamic_type。因此，我们可以使用type_index。（您可能会找到更好的方法来提供对某些地图可能更友好的ID）

因此，您可以通过这种方式（几乎是伪代码）来实现访客：

template<class T>
struct Visitor {
   map<type_index,void(T&,Node&)>* vfuncs //equivalent a vtbl_ptr
   void Visit(Node& n){
      //manual devirtualization step1: look if a function exist
      //                               for the dynamic type of the acceptor
      if (auto it=vfuncs.find(typeid(n));it!=vfuncs.end()){
          (*it)(statis_cast<T&>(*this),n);
          }
      else{ //do default stuff}
      };
   };
//only visit concrete_Node
struct concrete_visitor:visitor_base{
   static void visit(visitor_base& v,Node& n){
       //manual devirtualization step2: cast references
       auto& cn = static_cast<concrete_Node&>(n);
       auto& self = static_cast<concrete_visitor&>(v);
       //...
       }
   static inline map<type_index,void(visitor_base&,Node&)> vfuncs
                                             {typeid(concrete_Node),&visit};
   concrete_visitor():visitor_base{&vfuncs}{} //vtbl_ptr initialization
   };

具体不再是访客模式。这只是原始的蛮力去虚拟化，而要在地图上进行搜索。

我可以将CRTP与虚拟函数或函子一起用于可容忍对类进行更改的访问者算法

1 个答案: