init branch with slight changes to the code in gapc.cc and signature.cc

src/cpp.cc

@@ -1928,6 +1928,10 @@ void Printer::Cpp::print_subseq_typedef(const AST &ast) {
     << ", unsigned> TUSubsequence;\n\n";
 }
 
+void Printer::Cpp::enum_graph_print() {
+  stream << indent() << "unsigned int parentID" << endl;
+}
+
 
 void Printer::Cpp::header(const AST &ast) {
   if (!ast.code_mode().subopt_buddy()) {
@@ -2482,7 +2486,6 @@ void Printer::Cpp::backtrack_footer(const AST &ast) {
   print_subopt_fn(ast);
 }
 
-
 void Printer::Cpp::print_value_pp(const AST &ast) {
   stream << indent() << "template <typename Value>";
   stream << " void  print_result(std::ostream &out, "
@@ -2506,9 +2509,8 @@ void Printer::Cpp::print_value_pp(const AST &ast) {
   stream << indent() << "} else {" << endl;
   inc_indent();
   stream << indent() << "out << res << '\\n';" << endl;
-  dec_indent();
+  indent();
   stream << indent() << '}' << endl;
-
   dec_indent();
   stream << indent() << '}' << endl << endl;
 }
@@ -2519,7 +2521,6 @@ void Printer::Cpp::close_class() {
   stream << indent() << "};" << endl << endl;
 }
 
-
 void Printer::Cpp::typedefs(Code::Gen &code) {
   stream << "#ifndef NO_GAPC_TYPEDEFS" << endl;
   stream << indent() << "namespace gapc {" << endl;

src/cpp.hh

@@ -177,6 +177,7 @@ class Cpp : public Base {
 
     void print(const Type::Multi &expr);
 
+    void enum_graph_print();
     void header(const AST &ast);
     void header_footer(const AST &ast);
     void footer(const AST &ast);
@@ -199,6 +200,7 @@ class Cpp : public Base {
 
  public:
     void backtrack_footer(const AST &ast);
+    void backtrack_tree_footer(const AST &ast);
 
  private:
     void print(const std::list<Statement::Var_Decl*> &l);

src/gapc.cc

@@ -368,6 +368,9 @@ class Main {
     driver.ast.set_outside_nt_list(&opts.outside_nt_list);
     driver.parse_product(opts.product);
 
+
+
+
     if (driver.is_failing()) {
       throw LogError("Seen parse errors.");
     }
@@ -450,6 +453,7 @@ class Main {
    */
   void back(Instance *i = 0, Instance *instance_buddy = 0) {
     Instance *instance = i;
+
     if (!i || instance_buddy) {
       if (opts.backtrack || opts.subopt || opts.kbacktrack) {
         instance = driver.ast.split_instance_for_backtrack(opts.instance);
@@ -679,6 +683,8 @@ class Main {
         + opts.plot_grammar_file + " > foo.pdf' to generate a PDF.");
     }
 
+
+
     driver.ast.set_class_name(opts.class_name);
 
 
@@ -741,7 +747,6 @@ class Main {
     }
 
     hh.backtrack_footer(driver.ast);
-
     hh.close_class();
   }
 

src/parser.y

@@ -764,7 +764,8 @@ algebra: algebra_head '{' fn_defs '}'
 \begin{lstlisting}
 automatic_specifier:
         @enum@ |
-        @count@
+        @count@ |
+        @trees@
         ;
 \end{lstlisting}
 The {\tt automatic} keyword specifies the auto generation of the

src/signature.cc

@@ -149,10 +149,14 @@ Algebra *Signature::generate(std::string *n, std::string *mode) {
     return generate_count(n);
   if (*mode == "enum")
     return generate_enum(n);
+  if (*mode == "trees")
+    return generate_trees(n);
   return NULL;
 }
 
 
+
+
 struct Generate_Stmts {
   virtual void apply(Fn_Def &fn) const = 0;
   virtual ~Generate_Stmts() {}
@@ -413,6 +417,156 @@ Algebra *Signature::generate_enum(std::string *n) {
 }
 
 
+
+//------------------------------------------------------------------------------------------------------------
+
+
+struct Generate_Tree_Stmts : public Generate_Stmts {
+ private:
+  // closes nodes for simple tracks
+  void apply(std::list<Statement::Base*> &l, Para_Decl::Simple *s,
+             Statement::Var_Decl *&cur) const {
+    Statement::Fn_Call *f = new Statement::Fn_Call(
+      Statement::Fn_Call::STR_APPEND);
+    f->add_arg(*cur);
+    f->add_arg(s->name());
+    l.push_back(f);
+  }
+
+  // Generating Child Nodes for grammar operations in Multitrack
+  void apply(std::list<Statement::Base*> &l, Para_Decl::Multi *m,
+             Statement::Var_Decl *&cur) const {
+    Statement::Fn_Call * f = new Statement::Fn_Call(
+      Statement::Fn_Call::STR_APPEND);
+    f->add_arg(*cur);
+    f->add_arg(new Expr::Const("child {node {"));
+    l.push_back(f);
+
+    const std::list<Para_Decl::Simple*> &p = m->list();
+    std::list<Para_Decl::Simple*>::const_iterator j = p.begin();
+    if (j != p.end()) {
+      apply(l, *j, cur);
+      ++j;
+    }
+    for (; j != p.end(); ++j) {
+      f = new Statement::Fn_Call(Statement::Fn_Call::STR_APPEND);
+      f->add_arg(*cur);
+      f->add_arg(new Expr::Const(", "));
+      f->add_arg(new Expr::Const(2));
+      l.push_back(f);
+      apply(l, *j, cur);
+    }
+
+    f = new Statement::Fn_Call(Statement::Fn_Call::STR_APPEND);
+    f->add_arg(*cur);
+    f->add_arg(new Expr::Const("}}"));
+    f->add_arg(new Expr::Const(2));
+    l.push_back(f);
+  }
+
+
+  void apply(std::list<Statement::Base*> &l,
+             const std::list<Para_Decl::Base*> &paras,
+             Statement::Var_Decl *&cur) const {
+    std::list<Statement::Base*> apps;
+    unsigned int a = 0;
+    for (std::list<Para_Decl::Base*>::const_iterator i = paras.begin();
+         i != paras.end(); ++i) {
+      if (a > 0 && !(a % 3)) {
+        std::ostringstream o;
+        o << "ret_" << a;
+        Type::External *str = new Type::External("Rope");
+        Statement::Var_Decl *t = new Statement::Var_Decl(str, o.str());
+        l.push_back(t);
+        Statement::Fn_Call *f =
+        new Statement::Fn_Call(Statement::Fn_Call::STR_APPEND);
+        f->add_arg(*cur);
+        f->add_arg(*t);
+        cur = t;
+        apps.push_front(f);
+      }
+      Statement::Fn_Call *f = new Statement::Fn_Call(
+        Statement::Fn_Call::STR_APPEND);
+      f->add_arg(*cur);
+      Para_Decl::Multi *m = dynamic_cast<Para_Decl::Multi*>(*i);
+     if (m) {
+        f->add_arg(new Expr::Const(' '));
+        l.push_back(f);
+        apply(l, m, cur);
+      } else {
+        Para_Decl::Simple *s = dynamic_cast<Para_Decl::Simple*>(*i);
+        f->add_arg(new Expr::Const("child {node {"));
+        l.push_back(f);
+        assert(s);
+        apply(l, s, cur);
+      }
+      a++;
+
+     if (!m) {
+     Statement::Fn_Call *g = new Statement::Fn_Call(
+              Statement::Fn_Call::STR_APPEND);
+     g->add_arg(*cur);
+     g->add_arg(new Expr::Const("}}"));
+     l.push_back(g);
+      }
+    }
+
+    l.insert(l.end(), apps.begin(), apps.end());
+  }
+
+ public:
+  void apply(Fn_Def &fn) const {
+    if (fn.is_Choice_Fn()) {
+      Statement::Return *ret = new Statement::Return(fn.names.front());
+      fn.stmts.push_back(ret);
+      return;
+    }
+    Type::External *str = new Type::External("Rope");
+    Statement::Var_Decl *ret = new Statement::Var_Decl(str, "ret");
+    fn.stmts.push_back(ret);
+    Statement::Fn_Call *f = new Statement::Fn_Call(
+      Statement::Fn_Call::STR_APPEND);
+    f->add_arg(*ret);
+    std::string t = "child {node {" + *fn.name + "}";
+    f->add_arg(new Expr::Const(t));
+    f->add_arg(new Expr::Const(static_cast<int>(t.size())));
+    fn.stmts.push_back(f);
+
+    Statement::Var_Decl *cur = ret;
+    std::list<Statement::Base*> l;
+    apply(l, fn.paras, cur);
+    fn.stmts.insert(fn.stmts.end(), l.begin(), l.end());
+
+    if (fn.ntparas().size() > 0) {
+      f = new Statement::Fn_Call(Statement::Fn_Call::STR_APPEND);
+      f->add_arg(*ret);
+      f->add_arg(new Expr::Const(';'));
+      fn.stmts.push_back(f);
+      std::list<Statement::Base*> lntparas;
+      apply(lntparas, fn.ntparas(), ret);
+      fn.stmts.insert(fn.stmts.end(), lntparas.begin(), lntparas.end());
+    }
+    f = new Statement::Fn_Call(Statement::Fn_Call::STR_APPEND);
+    f->add_arg(*ret);
+    f->add_arg(new Expr::Const(' '));
+    fn.stmts.push_back(f);
+    f = new Statement::Fn_Call(Statement::Fn_Call::STR_APPEND);
+    f->add_arg(*ret);
+    f->add_arg(new Expr::Const('}'));
+    fn.stmts.push_back(f);
+    Statement::Return *r = new Statement::Return(*ret);
+    fn.stmts.push_back(r);
+  }
+};
+
+
+Algebra *Signature::generate_trees(std::string *n) {
+  return generate_algebra(n, Mode::PRETTY, new Type::External("Rope"),
+                          Generate_Tree_Stmts());
+}
+//------------------------------------------------------------------------------------------------------------
+
+
 struct Generate_Backtrace_Stmts : public Generate_Stmts {
   Generate_Backtrace_Stmts() : value_type(0), pos_type(0) {}
   Type::Base *value_type;

src/signature.hh

@@ -97,6 +97,7 @@ class Signature : public Signature_Base {
  private:
     Algebra *generate_count(std::string *n);
     Algebra *generate_enum(std::string *n);
+    Algebra *generate_trees(std::string *n);
     Algebra *generate_algebra(
       std::string *n, Mode::Type mode_type, Type::Base *answer_type,
       Type::Base *alph, const Generate_Stmts &generate_stmts);