Added code to print table contents

Joel Grunbaum

2021-07-20 d6113254ff97213878911c68f374d0cf5b0302f5

 ast.cpp

@@ -2,33 +2,29 @@
#include <string>
#include "ast.h"

MathInline::MathInline(std::string *e) {
MathInline::MathInline(std::string e) {
   expr = e;
}
MathInline::~MathInline() {
   delete expr;
}
std::string* MathInline::get_expr() {
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;
}
Link::~Link() {
   delete link;
   delete text;
}
std::string* Link::get_link() {

std::string Link::get_link() {
   return link;
}
std::string* Link::get_text() {

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

void* Link::visit(ast_visitor *v) {
   return v->visit_Link(this);
}
@@ -36,9 +32,11 @@
Text::Text(std::string tt) {
   t=tt;
}
std::string* Text::get_text() {
   return &t;

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

void* Text::visit(ast_visitor *v) {
   return v->visit_Text(this);
}
@@ -46,12 +44,15 @@
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);
}
@@ -59,12 +60,15 @@
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) {
   return v->visit_Format_Italic(this);
}
@@ -72,69 +76,74 @@
Format_Verbatim::Format_Verbatim(Format* ff) {
   f=ff;
}

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

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

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

Heading::Heading(int l, std::vector<Word*> w) {
Heading::Heading(int l, Line_Word *w) {
   level = l;
   words = w;
}

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

int Heading::get_level() {
   return level;
}
std::vector<Word*>* Heading::get_words() {
   return &words;

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

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

List::List(int l, int n, std::vector<Word*> w) {
List::List(int l, int n, Line_Word *w) {
   level = l;
   number = n;
   words = w;
}

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

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

int List::get_number() {
   return number;
}
std::vector<Word*>* List::get_words() {
   return &words;

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

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

MathDisp::MathDisp(std::string *e) {
MathDisp::MathDisp(std::string e) {
   expr = e;
}
MathDisp::~MathDisp() {
   delete expr;
}
std::string* MathDisp::get_expr() {

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

void* MathDisp::visit(ast_visitor *v) {
   return v->visit_MathDisp(this);
}
@@ -145,55 +154,70 @@
   }
   words.clear();
}

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

std::vector<Word*>* Line_Word::get_words() {
   return &words;
}

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++) {
      for (std::vector<Line_Word*>::size_type j = 0; j < table[i].size(); j++) {
         delete table[i][j];
   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];
      }
      table[i].clear();
      table[i]->clear();
   }
   table.clear();
}
std::vector<std::vector<Line_Word*>> Block_Table::get_table() {
   return 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) {
   if (i < table.size()) {
      return table[i];
   } else {
      return NULL;
   }
}

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 = new std::string();
   c = "";
}
Block_Code::~Block_Code() {
   delete c;
   delete lang;
}
int Block_Code::add_line(std::string *add) {
   *c = *c + *add + "\n";

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

std::string Block_Code::get_lang() {
   return lang;
}
std::string* Block_Code::get_code() {

std::string Block_Code::get_code() {
   return c;
}

void* Block_Code::visit(ast_visitor *v) {
   return v->visit_Block_Code(this);
}
@@ -204,47 +228,54 @@
   }
   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++) {
      delete blocks[i];
   }
   blocks.clear();
   delete title;
   delete author;
   delete date;
}
std::string* Document::get_title() {

std::string Document::get_title() {
   return title;
}
std::string* Document::get_author() {

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

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

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

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

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