Объясните код создания аналога Excel на С++

#include <map> 
#include <string> 
#include <iostream> 
#include <set> 
#include <assert.h> 
#include <stdexcept>
using namespace std;
 
int parse_integer(const string& val) { 
return atoi(val.c_str()); 
} 
 
string toString(int i) { 
char buf[32]; 
return itoa(i, buf, 10); 
} 
 
struct Table { 
typedef string cell_addr_t; 
typedef map<cell_addr_t, string> cell_str_cont_t; 
typedef map<cell_addr_t, int> cell_num_cont_t; 
typedef set<cell_addr_t> cell_set_t; 
 
Table() : w(0), h(0) {} 
 
size_t w, h; 
cell_str_cont_t exprs, values; 
cell_num_cont_t num_values; 
cell_set_t evaluated, evaluating; 
 
cell_addr_t make_addr(size_t i, size_t j) { 
return char('A' + j) + toString(i + 1); 
} 
 
void input() { //ââîä
 
cin>>h>>w; 
for (size_t i = 0; i < h; ++i) 
for (size_t j = 0; j < w; ++j) { 
string val; 
cin>>val; 
if (!val.empty()) { 
exprs[make_addr(i, j)] = val; 
} 
} 
} 
 
enum cell_kinds { cell_empty, cell_str, cell_num, 
cell_expr, cell_error }; 
 
cell_kinds cell_kind(cell_addr_t addr) { 
if (exprs[addr].empty()) return cell_empty; 
if (exprs[addr][0] == '\'') return cell_str; 
if (exprs[addr][0] == '=') return cell_expr; 
 
//ýòî äîëæíî áûòü ÷èñëî êëåòîê, ïðîâåðèòü ýòî:
const char  *p = exprs[addr].c_str(); 
while (*p) { 
if (!isdigit(*p)) return cell_error; //ïðîâåðêà íà äåñÿòè÷íîå ÷èñëî(isdigit)
p++; 
} 
return cell_num; 
} 
 
void validate_addr(const cell_addr_t& addr) { 
int j = addr[0] - 'A' + 1; 
int i = addr[1] - '0'; 
 
if ((i >= 1) && (j >= 1) && (i <= h) && (j <= w)) return; 
else throw runtime_error("wrong cell address"); 
} 
 
int get_evald_num(cell_addr_t addr) { 
string strval = get_evald_str(addr); //pull evaluation 
 
cell_num_cont_t::iterator it = num_values.find(addr); 
if (it != num_values.end()) { 
return it->second; 
} else { 
if (!strval.empty() && strval[0] == '#') //it's an error 
throw runtime_error(strval.substr(1)); 
throw runtime_error("not a number"); 
} 
} 
 
int read_term(const char*&p) { 
if (isdigit(*p)) { 
int val = atoi(p); 
while (isdigit(*p)) ++p; 
return val; 
} else { 
cell_addr_t addr(p, 2); 
validate_addr(addr); 
p += 2; 
return get_evald_num(addr); 
} 
} 
 
int eval_expr_int(const char* p) { 
assert(p!=0&&*p!=0); 
 
int res = read_term(p); 
 
//read other terms (if any) and perform operation 
do { 
switch (*p) { 
case 0: break; 
case '+': res += read_term(++p);break; 
case '*': res *= read_term(++p);break; 
case '/': res /= read_term(++p);break; 
case '-': res -= read_term(++p);break; 
default: throw runtime_error("error in expression"); 
}; 
} while (*p); 
return res; 
} 
 
string make_error(const string& msg) { 
return "#" + msg; 
} 
 
string eval_expr(cell_addr_t addr) { 
evaluating.insert(addr); 
try { 
int val = eval_expr_int(exprs[addr].c_str() + 1); //skip = 
num_values[addr] = val; 
evaluating.erase(addr); 
return toString(val); 
} catch (runtime_error& e) { 
evaluating.erase(addr); 
return make_error(e.what()); 
} 
} 
 
string get_evald_str(cell_addr_t addr) { 
 
if (evaluated.count(addr)) { //if it's evaluated 
return values[addr]; 
//TODO: check if it's present, do not create empty cells 
} 
 
if (evaluating.count(addr)) { 
evaluating.erase(addr); 
evaluated.insert(addr);//we've evaluated that this is cicrular reference 
string val = make_error("Err"); 
values[addr] = val; 
return val; 
} 
 
string val; 
 
switch (cell_kind(addr)) { 
case cell_empty: break; 
case cell_str: val = exprs[addr].substr(1);break; //skip first char 
case cell_num: 
val = exprs[addr]; 
num_values[addr] = parse_integer(val); 
break; 
case cell_expr: val = eval_expr(addr);break; 
case cell_error: val = make_error("error in expression"); 
} 
evaluated.insert(addr); 
values[addr] = val; 
return val; 
}              
 
void output() { 
for (size_t i = 0; i < h; ++i) { 
for (size_t j = 0; j < w; ++j) { 
cout<<get_evald_str(make_addr(i, j)); 
if (j != w - 1)
cout<<"\t"; 
} 
cout<<endl; 
} 
}
}; 
int main() { 
Table t; 
t.input(); 
t.output(); 
return 0; 
}