Format code, add format for strikethrough and underline, replace line with ...

Joel Grunbaum

2021-08-12 ca483d438742be9650a5045e846b974f57c67e4f

Format code, add format for strikethrough and underline, replace line
with word

 ast.cpp

@@ -1,177 +1,114 @@
#include <vector>
#include <string>
#include "ast.h"
#include <string>
#include <vector>

MathInline::MathInline(std::string e) {
    expr = e;
}
std::string MathInline::get_expr() {
    return expr;
}
void* MathInline::visit(ast_visitor *v) {
    return v->visit_MathInline(this);
}
MathInline::MathInline(std::string e) { expr = e; }
std::string MathInline::get_expr() { return expr; }
void *MathInline::visit(ast_visitor *v) { return v->visit_MathInline(this); }

Link::Link(std::string l, std::string t) {
Link::Link(std::string l, std::string t)
{
    link = l;
    text = t;
}

std::string Link::get_link() {
    return link;
}
std::string Link::get_link() { return link; }
std::string Link::get_text() { return text; }
void *Link::visit(ast_visitor *v) { return v->visit_Link(this); }
Text::Text(std::string tt) { t = tt; }
std::string Text::get_text() { return t; }
void *Text::visit(ast_visitor *v) { return v->visit_Text(this); }
Format_Bold::Format_Bold(Format *ff) { f = ff; }
Format_Bold::~Format_Bold() { delete f; }
Format *Format_Bold::get_f() { return f; }
void *Format_Bold::visit(ast_visitor *v) { return v->visit_Format_Bold(this); }
Format_Italic::Format_Italic(Format *ff) { f = ff; }
Format_Italic::~Format_Italic() { delete f; }
Format *Format_Italic::get_f() { return f; }

std::string Link::get_text() {
    return text;
}

void* Link::visit(ast_visitor *v) {
    return v->visit_Link(this);
}

Text::Text(std::string tt) {
    t=tt;
}

std::string Text::get_text() {
    return t;
}

void* Text::visit(ast_visitor *v) {
    return v->visit_Text(this);
}

Format_Bold::Format_Bold(Format* ff) {
    f=ff;
}

Format_Bold::~Format_Bold() {
    delete f;
}

Format* Format_Bold::get_f() {
    return f;
}

void* Format_Bold::visit(ast_visitor *v) {
    return v->visit_Format_Bold(this);
}

Format_Italic::Format_Italic(Format* ff) {
    f=ff;
}

Format_Italic::~Format_Italic() {
    delete f;
}

Format* Format_Italic::get_f() {
    return f;
}

void* Format_Italic::visit(ast_visitor *v) {
void *Format_Italic::visit(ast_visitor *v)
{
    return v->visit_Format_Italic(this);
}

Format_Verbatim::Format_Verbatim(Format* ff) {
    f=ff;
}
Format_Verbatim::Format_Verbatim(Format *ff) { f = ff; }
Format_Verbatim::~Format_Verbatim() { delete f; }
Format *Format_Verbatim::get_f() { return f; }

Format_Verbatim::~Format_Verbatim() {
    delete f;
}

Format* Format_Verbatim::get_f() {
    return f;
}

void* Format_Verbatim::visit(ast_visitor *v) {
void *Format_Verbatim::visit(ast_visitor *v)
{
    return v->visit_Format_Verbatim(this);
}

Heading::Heading(int l, Line_Word *w) {
Format_Underline::Format_Underline(Format *ff) { f = ff; }
Format_Underline::~Format_Underline() { delete f; }
Format *Format_Underline::get_f() { return f; }

void *Format_Underline::visit(ast_visitor *v)
{
    return v->visit_Format_Underline(this);
}

Format_Strikethrough::Format_Strikethrough(Format *ff) { f = ff; }
Format_Strikethrough::~Format_Strikethrough() { delete f; }
Format *Format_Strikethrough::get_f() { return f; }

void *Format_Strikethrough::visit(ast_visitor *v)
{
    return v->visit_Format_Strikethrough(this);
}

Heading::Heading(int l, Line_Word *w)
{
    level = l;
    words = w;
}

Heading::~Heading() {
    delete words;
}
Heading::~Heading() { delete words; }
int Heading::get_level() { return level; }
Line_Word *Heading::get_words() { return words; }
void *Heading::visit(ast_visitor *v) { return v->visit_Heading(this); }

int Heading::get_level() {
    return level;
}

Line_Word* Heading::get_words() {
    return words;
}

void* Heading::visit(ast_visitor *v) {
    return v->visit_Heading(this);
}

List::List(int l, int n, Line_Word *w) {
List::List(int l, int n, Line_Word *w)
{
    level = l;
    number = n;
    words = w;
}

List::~List() {
    delete words;
}
List::~List() { delete words; }
int List::get_level() { return level; }
int List::get_number() { return number; }
Line_Word *List::get_words() { return words; }
void *List::visit(ast_visitor *v) { return v->visit_List(this); }
MathDisp::MathDisp(std::string e) { expr = e; }
std::string MathDisp::get_expr() { return expr; }
void *MathDisp::visit(ast_visitor *v) { return v->visit_MathDisp(this); }

int List::get_level() {
    return level;
}

int List::get_number() {
    return number;
}

Line_Word* List::get_words() {
    return words;
}

void* List::visit(ast_visitor *v) {
    return v->visit_List(this);
}

MathDisp::MathDisp(std::string e) {
    expr = e;
}

std::string MathDisp::get_expr() {
    return expr;
}

void* MathDisp::visit(ast_visitor *v) {
    return v->visit_MathDisp(this);
}

Line_Word::~Line_Word() {
    for (std::vector<Word*>::size_type i = 0; i < words.size(); i++) {
Line_Word::~Line_Word()
{
    for (std::vector<Word *>::size_type i = 0; i < words.size(); i++) {
        delete words[i];
    }
    words.clear();
}

int Line_Word::add_word(Word *w) {
int Line_Word::add_word(Word *w)
{
    words.push_back(w);
    return 0;
}

std::vector<Word*>* Line_Word::get_words() {
    return &words;
}
std::vector<Word *> *Line_Word::get_words() { return &words; }
void *Line_Word::visit(ast_visitor *v) { return v->visit_Line_Word(this); }

void* Line_Word::visit(ast_visitor *v) {
    return v->visit_Line_Word(this);
}

Block_Table::~Block_Table() {
    for (std::vector<std::vector<Line_Word*>*>::size_type i = 0; i < table.size(); i++) {
        std::vector<Line_Word*> *t = table[i];
        for (std::vector<Line_Word*>::size_type j = 0; j < t->size(); j++) {
Block_Table::~Block_Table()
{
    for (std::vector<std::vector<Line_Word *> *>::size_type i = 0;
         i < table.size(); i++) {
        std::vector<Line_Word *> *t = table[i];
        for (std::vector<Line_Word *>::size_type j = 0; j < t->size();
             j++) {
            delete (*t)[j];
        }
        t->clear();
@@ -180,16 +117,20 @@
    table.clear();
}

std::vector<std::vector<Line_Word*>*>* Block_Table::get_table() {
std::vector<std::vector<Line_Word *> *> *Block_Table::get_table()
{
    return &table;
}

int Block_Table::add_row(std::vector<Line_Word*>* row) {
int Block_Table::add_row(std::vector<Line_Word *> *row)
{
    table.push_back(row);
    return 0;
}

std::vector<Line_Word*>* Block_Table::get_row(std::vector<Line_Word*>::size_type i) {
std::vector<Line_Word *> *
Block_Table::get_row(std::vector<Line_Word *>::size_type i)
{
    if (i < table.size()) {
        return table[i];
    } else {
@@ -197,86 +138,54 @@
    }
}

void* Block_Table::visit(ast_visitor *v) {
    return v->visit_Block_Table(this);
}
void *Block_Table::visit(ast_visitor *v) { return v->visit_Block_Table(this); }

Block_Code::Block_Code(std::string l) {
Block_Code::Block_Code(std::string l)
{
    lang = l;
    c = "";
}

int Block_Code::add_line(std::string add) {
int Block_Code::add_line(std::string add)
{
    c = c + add + "\n";
    return 0;
}

std::string Block_Code::get_lang() {
    return lang;
}
std::string Block_Code::get_lang() { return lang; }
std::string Block_Code::get_code() { return c; }
void *Block_Code::visit(ast_visitor *v) { return v->visit_Block_Code(this); }

std::string Block_Code::get_code() {
    return c;
}
Block_Word::Block_Word(Line_Word *lw) { words = lw; }
Block_Word::~Block_Word() { delete words; }
int Block_Word::add_word(Word *w) { return words->add_word(w); }
Line_Word *Block_Word::get_words() { return words; }
void *Block_Word::visit(ast_visitor *v) { return v->visit_Block_Word(this); }

void* Block_Code::visit(ast_visitor *v) {
    return v->visit_Block_Code(this);
}

Block_Line::~Block_Line() {
    for (std::vector<Line*>::size_type i = 0; i < lines.size(); i++) {
        delete lines[i];
    }
    lines.clear();
}

std::vector<Line*>* Block_Line::get_lines() {
    return &lines;
}

int Block_Line::add_line(Line* l) {
    lines.push_back(l);
    return 0;
}

void* Block_Line::visit(ast_visitor *v) {
    return v->visit_Block_Line(this);
}

Document::Document(std::string t, std::string a, std::string d) {
Document::Document(std::string t, std::string a, std::string d)
{
    title = t;
    author = a;
    date = d;
}

Document::~Document() {
    for (std::vector<Block*>::size_type i = 0; i < blocks.size(); i++) {
Document::~Document()
{
    for (std::vector<Block *>::size_type i = 0; i < blocks.size(); i++) {
        delete blocks[i];
    }
    blocks.clear();
}

std::string Document::get_title() {
    return title;
}
std::string Document::get_title() { return title; }
std::string Document::get_author() { return author; }
std::string Document::get_date() { return date; }
std::vector<Block *> *Document::get_blocks() { return &blocks; }

std::string Document::get_author() {
    return author;
}

std::string Document::get_date() {
    return date;
}

std::vector<Block*>* Document::get_blocks() {
    return &blocks;
}

int Document::add_block(Block *b) {
int Document::add_block(Block *b)
{
    blocks.push_back(b);
    return 0;
}

void* Document::visit(ast_visitor *v) {
    return v->visit_Document(this);
}
void *Document::visit(ast_visitor *v) { return v->visit_Document(this); }

 ast.h

@@ -1,11 +1,11 @@
#ifndef AST_H
#define AST_H
#include <vector>
#include <string>
#include <vector>

//class ast_node;
// class ast_node;
class ast_visitor;
//class Document;
// class Document;
// class Block;
// class Block_Table;
// class Block_Code;
@@ -24,171 +24,233 @@
// class Format_Verbatim;
// class Text;

class ast_node {
public:
    virtual ~ast_node()=default;
    virtual void* visit(ast_visitor *v)=0;
class ast_node
{
      public:
    virtual ~ast_node() = default;
    virtual void *visit(ast_visitor *v) = 0;
};

class Word: public ast_node {};
class Word : public ast_node
{
};

class MathInline: public Word {
class MathInline : public Word
{
    std::string expr;
public:

      public:
    MathInline(std::string e);
    std::string get_expr();
    void* visit(ast_visitor *v);
    void *visit(ast_visitor *v);
};

class Link: public Word {
class Link : public Word
{
    std::string link, text;
public:

      public:
    Link(std::string l, std::string t);
    std::string get_link();
    std::string get_text();
    void* visit(ast_visitor *v);
    void *visit(ast_visitor *v);
};

class Format: public Word {};
class Format : public Word
{
};

class Text: public Format {
class Text : public Format
{
    std::string t;
public:

      public:
    Text(std::string tt);
    std::string get_text();
    void* visit(ast_visitor *v);
    void *visit(ast_visitor *v);
};

class Format_Bold: public Format {
class Format_Bold : public Format
{
    Format *f;
public:
    Format_Bold(Format* ff);

      public:
    Format_Bold(Format *ff);
    ~Format_Bold();
    Format* get_f();
    void* visit(ast_visitor *v);
    Format *get_f();
    void *visit(ast_visitor *v);
};

class Format_Italic: public Format {
class Format_Italic : public Format
{
    Format *f;
public:
    Format_Italic(Format* ff);

      public:
    Format_Italic(Format *ff);
    ~Format_Italic();
    Format* get_f();
    void* visit(ast_visitor *v);
    Format *get_f();
    void *visit(ast_visitor *v);
};

class Format_Verbatim: public Format {
class Format_Verbatim : public Format
{
    Format *f;
public:
    Format_Verbatim(Format* ff);
    ~Format_Verbatim();
    Format* get_f();
    void* visit(ast_visitor *v);
};
class Line: public ast_node {};

class Line_Word: public Line {
    std::vector<Word*> words;
public:
      public:
    Format_Verbatim(Format *ff);
    ~Format_Verbatim();
    Format *get_f();
    void *visit(ast_visitor *v);
};

class Format_Underline : public Format
{
    Format *f;

      public:
    Format_Underline(Format *ff);
    ~Format_Underline();
    Format *get_f();
    void *visit(ast_visitor *v);
};

class Format_Strikethrough : public Format
{
    Format *f;

      public:
    Format_Strikethrough(Format *ff);
    ~Format_Strikethrough();
    Format *get_f();
    void *visit(ast_visitor *v);
};

// class Line : public ast_node {};

class Line_Word : public Word
{
    std::vector<Word *> words;

      public:
    ~Line_Word();
    int add_word(Word *w);
    std::vector<Word*>* get_words();
    void* visit(ast_visitor *v);
    std::vector<Word *> *get_words();
    void *visit(ast_visitor *v);
};

class Heading: public Line {
class Heading : public Word
{
    int level;
    Line_Word *words;
public:

      public:
    Heading(int l, Line_Word *w);
    ~Heading();
    int get_level();
    Line_Word* get_words();
    void* visit(ast_visitor *v);
    Line_Word *get_words();
    void *visit(ast_visitor *v);
};

class List: public Line {
class List : public Word
{
    int level, number;
    Line_Word *words;
public:

      public:
    List(int l, int n, Line_Word *w);
    ~List();
    int get_level();
    int get_number();
    Line_Word* get_words();
    void* visit(ast_visitor *v);
    Line_Word *get_words();
    void *visit(ast_visitor *v);
};

class MathDisp: public Line {
class MathDisp : public Word
{
    std::string expr;
public:

      public:
    MathDisp(std::string e);
    std::string get_expr();
    void* visit(ast_visitor *v);
    void *visit(ast_visitor *v);
};

class Block : public ast_node
{
};

class Block: public ast_node {};
class Block_Table : public Block
{
    std::vector<std::vector<Line_Word *> *> table;

class Block_Table: public Block {
    std::vector<std::vector<Line_Word*>*> table;
public:
      public:
    ~Block_Table();
    std::vector<std::vector<Line_Word*>*>* get_table();
    int add_row(std::vector<Line_Word*>* row);
    std::vector<Line_Word*>* get_row(std::vector<Line_Word*>::size_type i);
    void* visit(ast_visitor *v);
    std::vector<std::vector<Line_Word *> *> *get_table();
    int add_row(std::vector<Line_Word *> *row);
    std::vector<Line_Word *> *
    get_row(std::vector<Line_Word *>::size_type i);
    void *visit(ast_visitor *v);
};

class Block_Code: public Block {
class Block_Code : public Block
{
    std::string c;
    std::string lang;
public:

      public:
    Block_Code(std::string l);
    int add_line(std::string add);
    std::string get_lang();
    std::string get_code();
    void* visit(ast_visitor *v);
    void *visit(ast_visitor *v);
};

class Block_Line: public Block {
    std::vector<Line*> lines;
public:
    ~Block_Line();
    std::vector<Line*>* get_lines();
    int add_line(Line* l);
    void* visit(ast_visitor *v);
class Block_Word : public Block
{
    Line_Word *words;

      public:
    Block_Word(Line_Word *lw);
    ~Block_Word();
    int add_word(Word *w);
    Line_Word *get_words();
    void *visit(ast_visitor *v);
};

class Document: public ast_node {
class Document : public ast_node
{
    std::string title, author, date;
    std::vector<Block*> blocks;
public:
    std::vector<Block *> blocks;

      public:
    Document(std::string t, std::string a, std::string d);
    ~Document();
    std::string get_title();
    std::string get_author();
    std::string get_date();
    std::vector<Block*>* get_blocks();
    std::vector<Block *> *get_blocks();
    int add_block(Block *b);
    void* visit(ast_visitor *v);
    void *visit(ast_visitor *v);
};

class ast_visitor {
public:
    virtual void* visit_Document(Document *d)=0;
    virtual void* visit_Block_Table(Block_Table *bt)=0;
    virtual void* visit_Block_Code(Block_Code *bc)=0;
    virtual void* visit_Block_Line(Block_Line *bl)=0;
    virtual void* visit_Heading(Heading *h)=0;
    virtual void* visit_List(List *l)=0;
    virtual void* visit_MathDisp(MathDisp *md)=0;
    virtual void* visit_Line_Word(Line_Word *lw)=0;
    virtual void* visit_Link(Link *l)=0;
    virtual void* visit_MathInline(MathInline *mi)=0;
    virtual void* visit_Format_Bold(Format_Bold *fb)=0;
    virtual void* visit_Format_Italic(Format_Italic *fi)=0;
    virtual void* visit_Format_Verbatim(Format_Verbatim *fv)=0;
    virtual void* visit_Text(Text *t)=0;
class ast_visitor
{
      public:
    virtual void *visit_Document(Document *d) = 0;
    virtual void *visit_Block_Table(Block_Table *bt) = 0;
    virtual void *visit_Block_Code(Block_Code *bc) = 0;
    virtual void *visit_Block_Word(Block_Word *bw) = 0;
    virtual void *visit_Heading(Heading *h) = 0;
    virtual void *visit_List(List *l) = 0;
    virtual void *visit_MathDisp(MathDisp *md) = 0;
    virtual void *visit_Line_Word(Line_Word *lw) = 0;
    virtual void *visit_Link(Link *l) = 0;
    virtual void *visit_MathInline(MathInline *mi) = 0;
    virtual void *visit_Format_Bold(Format_Bold *fb) = 0;
    virtual void *visit_Format_Italic(Format_Italic *fi) = 0;
    virtual void *visit_Format_Verbatim(Format_Verbatim *fv) = 0;
    virtual void *visit_Format_Underline(Format_Underline *fu) = 0;
    virtual void *visit_Format_Strikethrough(Format_Strikethrough *fs) = 0;
    virtual void *visit_Text(Text *t) = 0;
};
#endif

 gens.h

@@ -2,24 +2,25 @@
#define GENS_H
#include "ast.h"

class gen: public ast_visitor {
public:
    virtual ~gen()=default;
    virtual void set_file(std::string file_name)=0;
    virtual void* visit_Document(Document *d)=0;
    virtual void* visit_Block_Table(Block_Table *bt)=0;
    virtual void* visit_Block_Code(Block_Code *bc)=0;
    virtual void* visit_Block_Line(Block_Line *bl)=0;
    virtual void* visit_Heading(Heading *h)=0;
    virtual void* visit_List(List *l)=0;
    virtual void* visit_MathDisp(MathDisp *md)=0;
    virtual void* visit_Line_Word(Line_Word *lw)=0;
    virtual void* visit_Link(Link *l)=0;
    virtual void* visit_MathInline(MathInline *mi)=0;
    virtual void* visit_Format_Bold(Format_Bold *fb)=0;
    virtual void* visit_Format_Italic(Format_Italic *fi)=0;
    virtual void* visit_Format_Verbatim(Format_Verbatim *fv)=0;
    virtual void* visit_Text(Text *t)=0;
class gen : public ast_visitor
{
      public:
    virtual ~gen() = default;
    virtual void set_file(std::string file_name) = 0;
    virtual void *visit_Document(Document *d) = 0;
    virtual void *visit_Block_Table(Block_Table *bt) = 0;
    virtual void *visit_Block_Code(Block_Code *bc) = 0;
    virtual void *visit_Block_Word(Block_Word *bl) = 0;
    virtual void *visit_Heading(Heading *h) = 0;
    virtual void *visit_List(List *l) = 0;
    virtual void *visit_MathDisp(MathDisp *md) = 0;
    virtual void *visit_Line_Word(Line_Word *lw) = 0;
    virtual void *visit_Link(Link *l) = 0;
    virtual void *visit_MathInline(MathInline *mi) = 0;
    virtual void *visit_Format_Bold(Format_Bold *fb) = 0;
    virtual void *visit_Format_Italic(Format_Italic *fi) = 0;
    virtual void *visit_Format_Verbatim(Format_Verbatim *fv) = 0;
    virtual void *visit_Text(Text *t) = 0;
};

#include "gens/dot.h"

 gens/dot.cpp

@@ -1,32 +1,30 @@
#include "dot.h"
#include "../ast.h"
#include "../gens.h"
#include <fstream>
#include <iostream>
#include <string>
#include "../ast.h"
#include "../gens.h"
#include "dot.h"

dot_gen::~dot_gen() {
    out.close();
}
dot_gen::~dot_gen() { out.close(); }

void dot_gen::set_file(std::string file_name) {
    out.open(file_name);
}
void dot_gen::set_file(std::string file_name) { out.open(file_name); }

std::string* dot_gen::new_node() {
std::string *dot_gen::new_node()
{
    std::string *o = new std::string();
    *o = "Node"+std::to_string(node_cnt++);
    *o = "Node" + std::to_string(node_cnt++);
    return o;
}

void* dot_gen::visit_Document(Document *d) {
void *dot_gen::visit_Document(Document *d)
{
    out << "digraph ast {" << std::endl;
    node_cnt = 0;
    std::string *doc_id = new_node();
    out << *doc_id << " [label=\"Document\"];" << std::endl;
    std::vector<Block*> *b = d->get_blocks();
    for (std::vector<Block*>::size_type i = 0; i < b->size(); i++) {
        std::string* ret_id = (std::string *)(*b)[i]->visit(this);
    std::vector<Block *> *b = d->get_blocks();
    for (std::vector<Block *>::size_type i = 0; i < b->size(); i++) {
        std::string *ret_id = (std::string *)(*b)[i]->visit(this);
        out << *doc_id << "->" << *ret_id << ";" << std::endl;
        delete ret_id;
    }
@@ -35,17 +33,21 @@
    return NULL;
}

void* dot_gen::visit_Block_Table(Block_Table *bt) {
void *dot_gen::visit_Block_Table(Block_Table *bt)
{
    std::string *b_id = new_node();
    std::vector<std::vector<Line_Word*>*> *t = bt->get_table();
    std::vector<std::vector<Line_Word *> *> *t = bt->get_table();
    out << *b_id << " [label=\"Block Table\"];" << std::endl;
    for (std::vector<std::vector<Line_Word*>*>::size_type i = 0; i < t->size(); i++) {
    for (std::vector<std::vector<Line_Word *> *>::size_type i = 0;
         i < t->size(); i++) {
        std::string *row_id = new_node();
        out << *row_id << " [label=\"Row(" << i << ")\"];" << std::endl;
        out << *b_id << "->" << *row_id << ";" << std::endl;
        std::vector<Line_Word*> *r = (*t)[i];
        for (std::vector<Line_Word*>::size_type j = 0; j < r->size(); j++) {
            std::string *ret_id = (std::string*)(*r)[j]->visit(this);
        std::vector<Line_Word *> *r = (*t)[i];
        for (std::vector<Line_Word *>::size_type j = 0; j < r->size();
             j++) {
            std::string *ret_id =
                (std::string *)(*r)[j]->visit(this);
            out << *row_id << "->" << *ret_id << ";" << std::endl;
            delete ret_id;
        }
@@ -54,103 +56,138 @@
    return b_id;
}

void* dot_gen::visit_Block_Code(Block_Code *bc) {
void *dot_gen::visit_Block_Code(Block_Code *bc)
{
    std::string *c_id = new_node();
    out << *c_id << " [label=\"Block Code(" << bc->get_lang() << ")\"];" << std::endl;
    out << *c_id << " [label=\"Block Code(" << bc->get_lang() << ")\"];"
        << std::endl;
    return c_id;
}

void* dot_gen::visit_Block_Line(Block_Line *bl) {
    std::string *bl_id = new_node();
    std::vector<Line*> *l = bl->get_lines();
    out << *bl_id << " [label=\"Block Line\"];" << std::endl;
    for (std::vector<Line*>::size_type i = 0; i < l->size(); i++) {
        std::string *ret_id = (std::string*)(*l)[i]->visit(this);
        out << *bl_id << "->" << *ret_id << ";" << std::endl;
        delete ret_id;
    }
    return bl_id;
void *dot_gen::visit_Block_Word(Block_Word *bl)
{
    std::string *bw_id = new_node();
    out << *bw_id << " [label=\"Block Word\"];" << std::endl;
    std::string *ret_id = (std::string *)bl->get_words()->visit(this);
    out << *bw_id << "->" << *ret_id << ";" << std::endl;
    delete ret_id;
    return bw_id;
}

void* dot_gen::visit_Heading(Heading *h) {
void *dot_gen::visit_Heading(Heading *h)
{
    std::string *h_id = new_node();
    Line_Word *w = h->get_words();
    out << *h_id << " [label=\"Heading\"];" << std::endl;
    std::string *ret_id = (std::string*)w->visit(this);
    std::string *ret_id = (std::string *)w->visit(this);
    out << *h_id << "->" << *ret_id << ";" << std::endl;
    delete ret_id;
    return h_id;
}

void* dot_gen::visit_List(List *l) {
void *dot_gen::visit_List(List *l)
{
    std::string *l_id = new_node();
    Line_Word *w = l->get_words();
    out << *l_id << " [label=\"List(l: " << l->get_level() << ", n:" << l->get_number() << ")\"];" << std::endl;
    std::string *ret_id = (std::string*)w->visit(this);
    out << *l_id << " [label=\"List(l: " << l->get_level()
        << ", n:" << l->get_number() << ")\"];" << std::endl;
    std::string *ret_id = (std::string *)w->visit(this);
    out << *l_id << "->" << *ret_id << ";" << std::endl;
    delete ret_id;
    return l_id;
}

void* dot_gen::visit_MathDisp(MathDisp *md) {
void *dot_gen::visit_MathDisp(MathDisp *md)
{
    std::string *md_id = new_node();
    out << *md_id << " [label=\"MathDisp(" << md->get_expr() << ")\"];" << std::endl;
    out << *md_id << " [label=\"MathDisp(" << md->get_expr() << ")\"];"
        << std::endl;
    return md_id;
}

void* dot_gen::visit_Line_Word(Line_Word *lw) {
void *dot_gen::visit_Line_Word(Line_Word *lw)
{
    std::string *lw_id = new_node();
    std::vector<Word*> *w = lw->get_words();
    std::vector<Word *> *w = lw->get_words();
    out << *lw_id << " [label=\"Line Word\"];" << std::endl;
    for (std::vector<Word*>::size_type i = 0; i < w->size(); i++) {
        std::string *ret_id = (std::string*)(*w)[i]->visit(this);
    for (std::vector<Word *>::size_type i = 0; i < w->size(); i++) {
        std::string *ret_id = (std::string *)(*w)[i]->visit(this);
        out << *lw_id << "->" << *ret_id << ";" << std::endl;
        delete ret_id;
    }
    return lw_id;
}

void* dot_gen::visit_MathInline(MathInline *mi) {
void *dot_gen::visit_MathInline(MathInline *mi)
{
    std::string *mi_id = new_node();
    out << *mi_id << " [label=\"Math Inline(" << mi->get_expr() << ")\"];" << std::endl;
    out << *mi_id << " [label=\"Math Inline(" << mi->get_expr() << ")\"];"
        << std::endl;
    return mi_id;
}

void* dot_gen::visit_Link(Link *l) {
void *dot_gen::visit_Link(Link *l)
{
    std::string *l_id = new_node();
    out << *l_id << " [label=\"Link(" << l->get_link() << "," << l->get_text() << ")\"];" << std::endl;
    out << *l_id << " [label=\"Link(" << l->get_link() << ","
        << l->get_text() << ")\"];" << std::endl;
    return l_id;
}

void* dot_gen::visit_Text(Text *t) {
void *dot_gen::visit_Text(Text *t)
{
    std::string *t_id = new_node();
    out << *t_id << " [label=\"Text(" << t->get_text() << ")\"];" << std::endl;
    out << *t_id << " [label=\"Text(" << t->get_text() << ")\"];"
        << std::endl;
    return t_id;
}

void* dot_gen::visit_Format_Bold(Format_Bold *fb) {
void *dot_gen::visit_Format_Bold(Format_Bold *fb)
{
    std::string *fb_id = new_node();
    out << *fb_id << " [label=\"Format Bold\"];" << std::endl;
    std::string *ret_id = (std::string*)fb->get_f()->visit(this);
    std::string *ret_id = (std::string *)fb->get_f()->visit(this);
    out << *fb_id << "->" << *ret_id << ";" << std::endl;
    delete ret_id;
    return fb_id;
}

void* dot_gen::visit_Format_Italic(Format_Italic *fi) {
void *dot_gen::visit_Format_Italic(Format_Italic *fi)
{
    std::string *fi_id = new_node();
    out << *fi_id << " [label=\"Format Italic\"];" << std::endl;
    std::string *ret_id = (std::string*)fi->get_f()->visit(this);
    std::string *ret_id = (std::string *)fi->get_f()->visit(this);
    out << *fi_id << "->" << *ret_id << ";" << std::endl;
    delete ret_id;
    return fi_id;
}

void* dot_gen::visit_Format_Verbatim(Format_Verbatim *fv) {
void *dot_gen::visit_Format_Verbatim(Format_Verbatim *fv)
{
    std::string *fv_id = new_node();
    out << *fv_id << " [label=\"Format Verbatim\"];" << std::endl;
    std::string *ret_id = (std::string*)fv->get_f()->visit(this);
    std::string *ret_id = (std::string *)fv->get_f()->visit(this);
    out << *fv_id << "->" << *ret_id << ";" << std::endl;
    delete ret_id;
    return fv_id;
}

void *dot_gen::visit_Format_Strikethrough(Format_Strikethrough *fs)
{
    std::string *fs_id = new_node();
    out << *fs_id << " [label=\"Format Strikethrough\"];" << std::endl;
    std::string *ret_id = (std::string *)fs->get_f()->visit(this);
    out << *fs_id << "->" << *ret_id << ";" << std::endl;
    delete ret_id;
    return fs_id;
}

void *dot_gen::visit_Format_Underline(Format_Underline *fu)
{
    std::string *fu_id = new_node();
    out << *fu_id << " [label=\"Format Underline\"];" << std::endl;
    std::string *ret_id = (std::string *)fu->get_f()->visit(this);
    out << *fu_id << "->" << *ret_id << ";" << std::endl;
    delete ret_id;
    return fu_id;
}

 gens/dot.h

@@ -1,29 +1,33 @@
#ifndef DOT_H
#define DOT_H
#include <fstream>
#include "../ast.h"
#include "../gens.h"
#include <fstream>

class dot_gen: public gen {
class dot_gen : public gen
{
    std::ofstream out;
    int node_cnt;
public:

      public:
    ~dot_gen();
    void set_file(std::string file_name);
    std::string* new_node();
    void* visit_Document(Document *d);
    void* visit_Block_Table(Block_Table *bt);
    void* visit_Block_Code(Block_Code *bc);
    void* visit_Block_Line(Block_Line *bl);
    void* visit_Heading(Heading *h);
    void* visit_List(List *l);
    void* visit_MathDisp(MathDisp *md);
    void* visit_Line_Word(Line_Word *lw);
    void* visit_MathInline(MathInline *mi);
    void* visit_Link(Link *l);
    void* visit_Text(Text *t);
    void* visit_Format_Bold(Format_Bold *fb);
    void* visit_Format_Italic(Format_Italic *fi);
    void* visit_Format_Verbatim(Format_Verbatim *fv);
    std::string *new_node();
    void *visit_Document(Document *d);
    void *visit_Block_Table(Block_Table *bt);
    void *visit_Block_Code(Block_Code *bc);
    void *visit_Block_Word(Block_Word *bl);
    void *visit_Heading(Heading *h);
    void *visit_List(List *l);
    void *visit_MathDisp(MathDisp *md);
    void *visit_Line_Word(Line_Word *lw);
    void *visit_MathInline(MathInline *mi);
    void *visit_Link(Link *l);
    void *visit_Text(Text *t);
    void *visit_Format_Bold(Format_Bold *fb);
    void *visit_Format_Italic(Format_Italic *fi);
    void *visit_Format_Verbatim(Format_Verbatim *fv);
    void *visit_Format_Strikethrough(Format_Strikethrough *fs);
    void *visit_Format_Underline(Format_Underline *fu);
};
#endif

 main.cpp

@@ -1,14 +1,14 @@
#include <iostream>
#include <string>
#include "ast.h"
#include "gens.h"
#include "parsers.h"
#include <iostream>
#include <string>

int main(int argc, char** argv)
int main(int argc, char **argv)
{
    Document *d;
    parser *p = new tester();
    gen *g = new dot_gen();
    dot_gen *g = new dot_gen();
    g->set_file("temp.dot");
    d = p->parse();
    d->visit(g);

 parsers/tester.cpp

@@ -1,51 +1,51 @@
#include <string>
#include "../ast.h"
#include "tester.h"
#include "../ast.h"
#include <string>

void tester::set_file(std::string file_name)
void tester::set_file(std::string file_name) { return; }

Document *tester::parse()
{
    return;
}
    Document *d = new Document("a", "b", "c");

Document* tester::parse()
{
    Document *d = new Document("a","b","c");

    //block line test
    Block_Line *bl = new Block_Line();
    Line_Word *lw = new Line_Word();
    d->add_block(bl);
    bl->add_line(lw);
    Block_Word *bw = new Block_Word(lw);
    d->add_block(bw);

    // Formats
    lw->add_word(new Format_Bold(new Text("Bold")));
    lw->add_word(new Format_Italic(new Text("Italic")));
    lw->add_word(new Format_Verbatim(new Text("Verbatim")));
    lw->add_word(new Text("Text"));
    lw->add_word(new Format_Bold(new Format_Italic(new Text("BoldItalic"))));
    lw->add_word(new MathInline("1+1=2"));
    lw->add_word(new Link("link","text"));
    lw->add_word(
        new Format_Bold(new Format_Italic(new Text("BoldItalic"))));
    lw->add_word(new Format_Strikethrough(new Text("Strikethrough")));
    lw->add_word(new Format_Underline(new Text("Underline")));

    //heading test
    // Other words
    lw->add_word(new MathInline("1+1=2"));
    lw->add_word(new Link("link", "text"));
    bw->add_word(new MathDisp("1+1=2"));

    // heading test
    lw = new Line_Word();
    lw->add_word(new Text("heading"));
    Heading *h = new Heading(1, lw);
    bl->add_line(h);
    bw->add_word(h);

    //list test
    // list test
    lw = new Line_Word();
    lw->add_word(new Text("ordered"));
    List *l = new List(1,1,lw);
    bl->add_line(l);
    List *l = new List(1, 1, lw);
    bw->add_word(l);
    lw = new Line_Word();
    lw->add_word(new Text("unordered"));
    l = new List(1,0,lw);
    bl->add_line(l);
    l = new List(1, 0, lw);
    bw->add_word(l);

    //mathdisp test
    bl->add_line(new MathDisp("1+1=2"));

    //table test
    // table test
    Block_Table *bt = new Block_Table();
    std::vector<Line_Word*>* row = new std::vector<Line_Word*>();
    std::vector<Line_Word *> *row = new std::vector<Line_Word *>();
    lw = new Line_Word();
    lw->add_word(new Text("Table1"));
    row->push_back(lw);
@@ -53,7 +53,7 @@
    lw->add_word(new Text("Table2"));
    row->push_back(lw);
    bt->add_row(row);
    row = new std::vector<Line_Word*>();
    row = new std::vector<Line_Word *>();
    lw = new Line_Word();
    lw->add_word(new Text("Table3"));
    row->push_back(lw);
@@ -63,7 +63,7 @@
    bt->add_row(row);
    d->add_block(bt);

    //code test
    // code test
    Block_Code *bc = new Block_Code("C");
    bc->add_line("#include <stdio.h>");
    bc->add_line("int main(void)\n{\nprintf(\"Hello World!\\n\");\n}");

 spec.org

@@ -18,12 +18,12 @@
- Link :: Link to other place, containing link text and link destination

Document: Block*
Block: Table | Line* | Code
Block: Table | Word* | Code
Table: Word* (2d array)
Code: Straight strings
Line: Heading | List | Word* | MathDisp
Word: MathInline | Link | Format
Format: Bold | Italic | Verbatim | Text
# Line: Heading | List | Word* | MathDisp
Word: MathInline | Link | Format | Heading | List | MathDisp
Format: Bold | Italic | Verbatim | Text | Underline | Strikethrough
Italic: Format
Bold: Format
Verbatim: Format
@@ -61,6 +61,8 @@
Italic is between ~/ /~.
Bold is between ~* *~.
Verbatim is between ~\~ \~~.
Strikethrough is ~+ +~.
Underline is ~_ _~.
*** Link
Links are ~[[destination][text]]~.
*** Comments