Поток ofstream не считывает данные в документ .txt

string name_to_out = "x.txt";
Token Token_stream::get(ofstream& ost)   // считывает символы из потока, принимает поток ofstream
{
    if (full) { full = false; return buffer; }
    char ch;
    cin >> ch;     
    ost.open(name_to_out, ios_base::out);
    ost << ch;      // должно считать символ в файл "x.txt" к примеру, но этого не происходит. Почему?
    switch (ch) {
    // ....
}
void calculate(ofstream &ost) {
    
        ost.open(name_to_out, ios_base::out);
            Token t = ts.get(ost);   // передача ost в качестве аргумента
            double res = statement(ost);  // вычисления
            cout << result << res << endl;
            ost.open(name_to_out, ios_base::out);   // вручную опять открываю
            ost << res;   // должно считать res в документ "x.txt", но этого не происходит, почему?
        //} 
}
 
int main() {
        ofstream ost;   // создаем поток
        ost.open(name_to_out,ios_base::out);
    calculate(ost);     // передаем ost в качестве аргумента
        system("pause");
        return 0;
    
}

ost.open(name_to_out, ios_base::out);

void calculate(ofstream &ost) {
    if (!ost) error("File not aviable: Calculate 1");
        ost.open(name_to_out, ios_base::out);
if (!ost) error("File not aviable: Calculate 2");
            Token t = ts.get(ost);   // передача ost в качестве аргумента
            double res = statement(ost);  // вычисления
            cout << result << res << endl;
            ost.open(name_to_out, ios_base::out);   // вручную опять открываю
            ost << res;   // должно считать res в документ "x.txt", но этого не происходит, почему?
if (!ost) error("File not aviable: Calculate 3");
        //} 
}

int main() {
        ofstream ost(name_to_out);   // создаем поток
        if (!ost)
        {
             cout << "Error opening file!" << endl;
             system("pause");
             return 0;
        }
        
        calculate(ost);     // передаем ost в качестве аргумента
        
        system("pause");
        return 0;
    
}

// калькулятор, использующий pasing(синтаксический анализ)
 
#include <locale.h>
#include "stdafx.h"
#include <Windows.h>
#include "std_lib_facilities.h"
string name_to_out = "x.txt";
 
struct Token {   // класс Токен
    char kind;
    double value;
    string name;
    Token(char ch) :kind(ch), value(0) { } // может принимать символ и только
    Token(char ch, double val) :kind(ch), value(val) { } // принимает символ и его значение
    Token(char ch, string n) : kind(ch), name (n) { } // принимает символ и строку
};
 
class Token_stream {         // поток токенов
    bool full;
    Token buffer;
public:
    Token_stream() :full(0), buffer(0) { } // стартуем с пустого буфера
    Token get(ifstream& ist);
    Token get(ofstream& ost);   // функция член получения токенов
    void unget(Token t) { buffer = t; full = true; }  // буфер, принимает токен записывает его в буфер и изменяет индикатор на тру
    void ignore(char);  // функция игнора для очистки буфера для последующих вычислений
};
 
const char let = '#';
const char exit1 = 'e';
const char print = ';';
const char number = '8';
const char name = 'a';
const char squirt = 's';
const char p0w = 'p';
const char is = ':';
const char help = 'h';
const char Area = 'c';
const double pi = 3.14;
 
Token Token_stream::get(ifstream& ist) {
    if (full) { full = false; return buffer; }
    char ch;
    ist >> ch;
    cout << ch << endl;
    switch (ch) {
    case '(':
    case ')':
    case '+':
    case '-':
    case '*':
    case '/':
    case '%':
    case ';':
    case '=':
    case ',':
    case ':':
        return Token(ch);
    case '.':
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
    {   ist.unget();
    double val;
    ist >> val;
    return Token(number, val);
    }
    case 'h': case 'H': {
        return Token(help);
    }
    case '#': return Token(let);
 
    default:
        //if (isalpha(ch)) {
        //  string s;
        //  s += ch;
        //  while (ist >> ch && (isalpha(ch) || isdigit(ch) || ch == '_' || ch == ':')) {
        //      if (ch == ':') {
        //          ist.putback(ch);
        //          return Token(is, s);
        //      }
        //      s += ch;
        //      if (s == "Area" || s == "AREA" || s == "area") {
        //          return Token(Area);
        //      }
        //      if (s == "sqrt") {
        //          return Token(squirt);
        //      }
        //      if (s == "pow") {
        //          return Token(p0w);
        //      }
        //  }
        //  if (s == "exit") {
        //      return Token(exit1);
        //  }
        //  ist.unget();
        //  return Token(name, s);
        //  // возвращаем "а" и строку
        //}
        error("Bad token");
    }
}
 
Token Token_stream::get(ofstream& ost)
{
    if (full) { cout << "Buffer done" << endl; full = false; return buffer; }
    if (!ost) error("File not aviable: Token Get");
    char ch;
    cin >> ch;
    cout << ch << endl;
    switch (ch) {
    case '(':
    case ')':
    case '+':
    case '-':
    case '*':
    case '/':
    case '%':
    case ';':
    case '=':
    case ',':
    case ':':
        ost << ch;
        return Token(ch);
    case '.':
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
    {   cin.unget();
    double val;
    cin >> val;
    ost << val;
    return Token(number, val);
    }
    case 'h': case 'H': {
        return Token(help);
    }
    case '#': return Token(let);
    default:
        if (isalpha(ch)) {
            string s;
            s += ch;
            while (cin >> ch && (isalpha(ch) || isdigit(ch) || ch == '_' || ch == ':')) {
                if (ch == ':') {
                    cin.putback(ch);
                
                    return Token(is, s);
 
                }
                s += ch;
                if (s == "Area" || s == "AREA" || s == "area") {
                    return Token(Area);
                }
                if (s == "sqrt") {
                    return Token(squirt);
                }
                if (s == "pow") {
                    return Token(p0w);
                }
            }
            if (s == "exit") {
                return Token(exit1);
            }
            cin.unget();
                return Token(name, s);
                    // возвращаем "а" и строку
        }
        error("Bad token");
    }
}
 
void Token_stream::ignore(char c)  // принимает " ; "
{
    if (full && c == buffer.kind) {   // проверяет индикатор буфера и сравнивает полученое значение с значением в буфере, меняет индикатор и возвращает
        full = false;
        return;
    }
    full = false;  // меняет индикатор
 
    char ch;
    while (cin >> ch)    // считывает до тех пор пока не обнаружится символ печати
        if (ch == c) return;
}
Token_stream ts;
 
struct Variable {   // структура для внесения в вектор переменных
    string name;
    double value;
    Variable(string n, double v) :name(n), value(v) { } // принимает строку(название переменно) и ее значение 
};
 
class Symbol_table {
    vector<Variable> var_table;
public:
    void push_back(string s, double value);
    double get_value(string s);
    void set_value(string s, double d);
    bool is_declared(string s);
    void define_name(string s, double value);
};
 
vector<Variable> names;
void Symbol_table::push_back(string s, double value ) {
    var_table.push_back(Variable(s, value));
}
void Symbol_table::define_name(string a, double value) {
    var_table.push_back(Variable(a, value));
}
 
double Symbol_table::get_value(string s)  // при необходимости возвращает значение внесенной пользователем переменной
{
    for (int i = 0; i<var_table.size(); ++i)  // перебирает элементы
        if (var_table[i].name == s) return var_table[i].value;  // ищет совпадение, если оно найдено возвращает значение найденной переменной
    error("get: undefined name ", s);
}
 
void Symbol_table::set_value(string s, double d)   // изменяет значение введенной пользователем переменной
{
    for (int i = 0; i <= var_table.size(); ++i) // перебирает элементы
        if (var_table[i].name == s) {
            var_table[i].value = d;
            return;
        }
    error("set: undefined name ", s);
}
 
bool Symbol_table::is_declared(string s)   // задекларированная переменная? если да, возвращаем тру, если нет - фолс
{
    for (int i = 0; i< var_table.size(); ++i)
        if (var_table[i].name == s) return true;
    return false;
}
 
Symbol_table var_table;
 
double expression(Token_stream& ts, ofstream &ost);
double expression(Token_stream& ts, ifstream& ist);
 
double primary(Token_stream& ts, ofstream &ost)
{
    Token t = ts.get(ost);
    switch (t.kind) {
    case '(':
    {   double d = expression(ts, ost);
    t = ts.get(ost);
    if (t.kind != ')') error("')' expected");
    return d;
    }
    case '-':
        return -primary(ts, ost);
    case number:
        return t.value;
    case name:             // если значение "а" то возвращаем значение переменной
        return var_table.get_value(t.name);
    case squirt: {           // если получили "s" вычисляем корень
        int a;                // для записи выражения
        t = ts.get(ost);            // получаем лексему
        if (t.kind != '(') {
            error("'(' expected");
        }
        a = expression(ts, ost);        //вычисляем выражение
        if (a < 0) {
            error("Expression in sqrt() < 0", a);
        }
        t = ts.get(ost);             //берем следующую лексему
        if (t.kind != ')') {
            error("')' expected");
        }
        return sqrt(a);           //возвращаем корень числа
    }
    case p0w: {             // вычисляем (число, его степень)
        double a;            // для записи выражения
        int b;
        t = ts.get(ost);            // получаем лексему
        if (t.kind != '(') {
            error("'(' expected");
        }
        a = expression(ts, ost);
        t = ts.get(ost);
        if (t.kind != ',') {
            error(" ',' expected in pow");
        }
        b = narrow_cast<int>(expression(ts, ost));
        t = ts.get(ost);
        if (t.kind != ')') {
            error("')' expected");
        }
        return pow(a, b);
 
    }
    default:
        error("Primary exprected");
    }
}
double primary(Token_stream& ts, ifstream &ist)
{
    Token t = ts.get(ist);
    switch (t.kind) {
    case '(':
    {   double d = expression(ts, ist);
    t = ts.get(ist);
    if (t.kind != ')') error("')' expected");
    return d;
    }
    case '-':
        return -primary(ts,ist);
    case number:
        return t.value;
    case name:             // если значение "а" то возвращаем значение переменной
        return var_table.get_value(t.name);
    case squirt: {           // если получили "s" вычисляем корень
        int a;                // для записи выражения
        t = ts.get(ist);            // получаем лексему
        if (t.kind != '(') {
            error("'(' expected");
        }
        a = expression(ts, ist);        //вычисляем выражение
        if (a < 0) {
            error("Expression in sqrt() < 0", a);
        }
        t = ts.get(ist);             //берем следующую лексему
        if (t.kind != ')') {
            error("')' expected");
        }
        return sqrt(a);           //возвращаем корень числа
    }
    case p0w: {             // вычисляем (число, его степень)
        double a;            // для записи выражения
        int b;
        t = ts.get(ist);            // получаем лексему
        if (t.kind != '(') {
            error("'(' expected");
        }
        a = expression(ts, ist);
        t = ts.get(ist);
        if (t.kind != ',') {
            error(" ',' expected in pow");
        }
        b = narrow_cast<int>(expression(ts, ist));
        t = ts.get(ist);
        if (t.kind != ')') {
            error("')' expected");
        }
        return pow(a, b);
 
    }
    default:
        error("Primary exprected");
    }
}
 
double term(Token_stream& ts, ofstream &ost)
{
    double left = primary(ts, ost);
    while (true) {
        Token t = ts.get(ost);
        switch (t.kind) {
        case '*':
            left *= primary(ts, ost);
            break;
        case '/':
        {   double d = primary(ts, ost);
        if (d == 0) error("divide by zero");
        left /= d;
        break;
        }
        default:
            ts.unget(t);
            return left;
        }
    }
}
double term(Token_stream& ts, ifstream &ist)
{
    double left = primary(ts, ist);
    while (true) {
        Token t = ts.get(ist);
        switch (t.kind) {
        case '*':
            left *= primary(ts, ist);
            break;
        case '/':
        {   double d = primary(ts, ist);
        if (d == 0) error("divide by zero");
        left /= d;
        break;
        }
        default:
            ts.unget(t);
            return left;
        }
    }
}
 
double expression(Token_stream& ts, ofstream &ost)
{
    double left = term(ts, ost);
    while (true) {
        Token t = ts.get(ost);
        switch (t.kind) {
        case '+':
            left += term(ts, ost);
            break;
        case '-':
            left -= term(ts, ost);
            break;
        default:
            ts.unget(t);
            return left;
        }
    }
}
double expression(Token_stream& ts, ifstream &ist)
{
    double left = term(ts, ist);
    while (true) {
        Token t = ts.get(ist);
        switch (t.kind) {
        case '+':
            left += term(ts, ist);
            break;
        case '-':
            left -= term(ts, ist);
            break;
        default:
            ts.unget(t);
            return left;
        }
    }
}
 
double declaration(ofstream &ost)    // декларация переменной 
{
    Token t = ts.get(ost);
    if (t.kind != 'a') error("name expected in declaration"); // если не тип а
    string name = t.name;
    if (var_table.is_declared(name)) error(name, " declared twice");      // если задекларированная, то выдать ошибку
    Token t2 = ts.get(ost);
    if (t2.kind != '=') error("= missing in declaration of ", name);
    double d = expression(ts, ost);
    var_table.push_back(name,d); // внесение переменной в вектор
    return d;
}
double declaration(ifstream &ist)    // декларация переменной 
{
    Token t = ts.get(ist);
    if (t.kind != 'a') error("name expected in declaration"); // если не тип а
    string name = t.name;
    if (var_table.is_declared(name)) error(name, " declared twice");      // если задекларированная, то выдать ошибку
    Token t2 = ts.get(ist);
    if (t2.kind != '=') error("= missing in declaration of ", name);
    double d = expression(ts, ist);
    var_table.push_back(name, d); // внесение переменной в вектор
    return d;
}
 
double AreaCircle() {
    double area;
    double radius;
    cout << "Enter a radius:";
    cin >> radius;
    area = 2 * pi * radius;
    cout << "S ";
    return area;
}
 
 
 
void UserHelp() {
    cout << "If you wanna declarate some variable: '# name = value;'" << endl;
    cout << "If you wanna change the value of declarated variable: 'name:value;'" << endl;
    cout << "If you wanna add/divide/multiply/minus two or more value you need: 'value */+- value ...'" << endl;
    cout << "If you end your writing and want to get result: put the ';' in the end of string" << endl;
    cout << "If you wanna exit from the programm: enter 'exit'" << endl;
}
 
double statement(ofstream &ost)
{
    Token t = ts.get(ost);
    switch (t.kind) {
    case help: {
        UserHelp();
        return 0;
    }
    case let:
        return declaration(ost);
    // case is: return v_t.re_declaration(t);
    case Area: {
        return AreaCircle();
    }
    default:
        ts.unget(t);
        return expression(ts, ost);
    }
}
 
double statement(ifstream& ist)
{
    Token t = ts.get(ist);
    switch (t.kind) {
    case help: {
        UserHelp();
        return 0;
    }
    case let:
        return declaration(ist);
        // case is: return v_t.re_declaration(t);
    case Area: {
        return AreaCircle();
    }
    default:
        ts.unget(t);
        return expression(ts, ist);
    }
}
 
void clean_up_mess()
{
    ts.ignore(print);
}
 
const string prompt = "> ";
const string result = "= ";
 
 
void calculate(ofstream &ost) {
    setlocale(LC_ALL, "Russian");
    while (true) try {
        /*string a;
        cout << "Read document?" << endl;
        cin >> a;
        if (a == "yes" || a == "Yes") {
            ifstream ist{ "y.txt" };
            while (ist) {
                Token t = ts.get(ist);
                while (t.kind == print) t = ts.get(ist);
                if (t.kind == exit1) {
                    keep_window_open();
                    return;
                }
                ts.unget(t);
                cout << result << statement(ist) << endl;
                if (ist.eof()) cout << "Ist.eof()";
                if (ist.fail()) cout << "Ist.fail()";
                if (ist.bad()) cout << "Ist.bad()";
            }
        }
        else {*/
        if (!ost) error("File not aviable: Calculate 1");
            cout << prompt;
            Token t = ts.get(ost);
            while (t.kind == print) t = ts.get(ost);
            if (t.kind == exit1) {
                keep_window_open();
                return;
            }
            ts.unget(t);
            double res = statement(ost);
            cout << result << res << endl;
            if (!ost) error("File not aviable: Calculate 2");
            ost << res;
        //} 
    }
    catch (runtime_error& e) {
        ost << e.what() << endl;
        cerr << e.what() << endl;
        clean_up_mess();
    }
}
 
int main() {
 
    setlocale(LC_ALL, "Russian");
    try {
    ofstream ost{ name_to_out };
    if (!ost) {
        cout << "Error openning file!" << endl;
        system("pause");
        return 0;
    }
    cout << "If you need help: enter 'H' or 'h'" << endl;
    calculate(ost);
    system("pause");
    return 0;
}
    catch (exception& e) {
        cerr << "exception: " << e.what() << endl;
        char c;
        while (cin >> c&& c != ';');
        return 1;
    }
    catch (...) {
        cerr << "exception\n";
        char c;
        while (cin >> c && c != ';');
        return 2;
    }
}