Калькулятор

//*****************************************************
//
//       Программа анализа и вычисления значения
//       арифметического выражения Калькулятор
//
//  Можно вводить ар. выражения с операциями +-*/,
//  использовать скобки, имена, оператор присваивания =.
//  Имена можно не объявлять
// Инициализация по умолчанию - 0.
//  Выход - ввод пустой строки
//  Версия: 3.0 для Visual C++
//*****************************************************
#include <string>
#include <iostream>
 
 
using namespace std;
//****************************************************************
// Глобальные определения и объявления
//****************************************************************
int no_of_errors = 0;           // счетчик ошибок
 
enum token_value                // внутреннее представление лексем
{ NAME, NUMBER, END, FOR,
  PLUS='+', MINUS='-', MUL='*', DIV='/',
  ASSIGN='=', LP='(', RP=')'
};
 
token_value curr_tok;       // текущая лексема
 
double number_value;        // значение текущей числовой лексемы
const double default_value = 0; // значение переменной по умолчанию
char name_string[256];      // считанное имя для текущей лексемы
 
 
/////////////////////////////////////////////////////////////////////
//  Обработчик ошибок
//  Функция error выдает на экран сообщение об ошибке и
//  увеличивает счетчик ошибок
/////////////////////////////////////////////////////////////////////
int error(const char* s)
{
 
  char buf[256];
  cout << "error: " << buf << "\n";
  no_of_errors++;  
  return 1;
}
 
//****************************************************************
// Динамические структуры и их построение: двоичные деревья
//****************************************************************
struct node
{
  token_value type;
  union
  { double value;
    char *name;
  };
  node *left;  // Левое поддерево
  node *right; // Правое поддерево
};
 
/////////////////////////////////////////////////////////////////////
//   Перегруженная функция new_node создает новую вершину
//   двоичного дерева в зависимости от типа узла: число или имя.
/////////////////////////////////////////////////////////////////////
node *new_node(const token_value type)
{
  node * p = new node;
  p->type = type;
  p->left = p->right = NULL;
  return p;
}
 
//   Создание вершины дерева - числа
node *new_node(const token_value type, const double value)
{
  node * p = new_node(type);
  p->value = value;
  return p;
}
//Создание вершины дерева - имени
node *new_node(const token_value type,const char *name)
{
  node *p = new_node(type);
  p->name = new char[strlen(name)+1];
  strcpy(p->name,name);
  return p;
}
 
//****************************************************************
//   Работа с таблицей имен
//****************************************************************
struct name
{
  char* string;                        // имя переменной
  double value;                        // и связанное с ним значание
};
const int TBLSZ = 23;
name* table[TBLSZ];                    // таблица указателей на переменные
 
/////////////////////////////////////////////////////////////////////
//  Поиск-вставка имени в таблице имен
//  Функция возвращает указатель на найденную переменную(имя) и ее
//  значение
/////////////////////////////////////////////////////////////////////
name* insert(const char* p)
{
  // простой линейный поиск в таблице
  int ii;
  for (ii=0;ii<TBLSZ && table[ii];ii++)
    if (strcmp(p,table[ii]->string) == 0) return table[ii];
 
  if (ii==TBLSZ)
    {error("Нет памяти для вставки нового имени"); return NULL;};
 
  name* nn = new name; // вставка нового имени
  nn->string = new char[strlen(p)+1];
  strcpy(nn->string,p);
  nn->value = default_value; // инициализация по умолчанию
  table[ii++] = nn;
  return nn;
}
 
//****************************************************************
//  Сканер (лексический анализатор).
//  Функция производит ввод из входного потока и возвращает
//  очередную лексему во внутреннем представлении.
//****************************************************************
token_value get_token()
{
  char ch;
  do // игнорирует пропуски, за исключением \n
  { if (!cin.get(ch)) return curr_tok=END;
  } while (ch!='\n' && isspace(ch));
  switch (ch){
 
    case'\n':
      return curr_tok = END;
 
    case'*':
    case'/':
    case'+':
    case'-':
    case'(':
    case')':
    case'=':
      return curr_tok = token_value(ch);
 
    // Выделение числа
    case'0':    case'1':    case'2':    case'3':    case'4':
    case'5':    case'6':    case'7':    case'8':    case'9':
      cin.putback(ch);
      cin >> number_value;
      return curr_tok=NUMBER;
 
    // Выделение имени или ошибка
    default:
      if (isalpha(ch))
      {
    char* p = name_string;
    *p++ = ch;
    while (cin.get(ch) && isalnum(ch)) *p++ = ch;
    cin.putback(ch);
    *p = '\0';
    cout<<name_string<<endl;
    if (strcmp (name_string,"FOR")==0)
        return curr_tok=FOR;
    else
        return curr_tok = NAME;
      }
      error("Плохая лексема");
      return curr_tok=END;
  }
}
 
//****************************************************************
//  Синтаксический анализатор
//  Функции expr(), prim(), term() производят синтанализ
//  соответствующих синтаксический конструкций и формируют
//  двоичные деревья выражений
//****************************************************************
 
node *expr (); // предварительное объявление
 
// Разбор prim. Функция возвращает указатель на дерево, построенное
// из разобранного prim
node *prim ()
{
  node *p;
  switch (curr_tok)
  {
    case NUMBER :       // Число
      get_token();
      return new_node(NUMBER,number_value);
 
    case NAME:                  // Имя
      switch (get_token())
      {
    case ASSIGN:
    {
      p = new_node(ASSIGN);
      p->left = new_node(NAME,name_string);
      get_token();
      p->right = expr();
      return p;
    };
    default:
      return new_node(NAME,name_string);
      }
 
    case PLUS: case MINUS:     // Операция унарный плюс или минус
      p = new_node(curr_tok);
      get_token();
      p->left = new_node(NUMBER,0.0);
      p->right = prim();
      return p;
 
    case LP:                    // Выражение в скобках
      get_token();
      p = expr();
      if (curr_tok != RP) {error("Ожидается )"); return NULL;}
      get_token();
      return p;
 
    case FOR:
        p = new_node(FOR);
        get_token ();
        
        if (curr_tok==LP)
            get_token ();
        else
            {error("Ожидается (");
            return 0;}
        if(curr_tok==NUMBER)
            {p->left=new_node(NUMBER, number_value);
             get_token ();}
        else
            {error("Ожидается число");
            return 0;}
        if(curr_tok==RP)
            get_token ();
        else
            {error("Ожидается )");
            return 0;}
        
        if (curr_tok==LP)
            get_token ();
        else
            {error("Ожидается (");
            return 0;}
        p->right = expr ();
      
        if(curr_tok==RP)
            get_token ();
        else
            {error("Ожидается )");
            return 0;}
    default:
      {error("Ожидается primary");return NULL;}
  }
}
 
// Разбор term. Функция возвращает указатель на дерево, построенное
// из разобранного term
node *term ()
{
  node *p;
  node *left = prim();
  for (;;)
    switch (curr_tok)
    {
      case MUL:
      case DIV:
    p = new_node(curr_tok);
    get_token();
    p->left = left;
    p->right = prim();
    left = p;
    break;
 
      default:
    return left;
    }
}
 
// Разбор expr. Функция возвращает указатель на дерево, построенное
// из разобранного expr
node *expr()
{
  node *p;
  node *left = term();
  for (;;)
    switch (curr_tok)
    {
      case PLUS:
      case MINUS:
    p = new_node(curr_tok);
    p->left = left;
    get_token();
    p->right = term();
    left = p;
    break;
 
      default:
    return left;
    }
}
 
/////////////////////////////////////////////////////////////////////
// Вычислитель
// На входе - дерево p, значение которого нужно вычислить
// На выходе - вычисленное вещественное значение
/////////////////////////////////////////////////////////////////////
double eval(node *p)
{
  switch (p->type)
  {
    case NUMBER:
      return p->value;
 
 
 
    case NAME:
      return insert(p->name)->value;
 
    case ASSIGN:
      {double e = eval(p->right);
      name *n  = insert((p->left)->name);
      n->value = e;
      return e;
      }
    case PLUS:
      return eval(p->left) + eval(p->right);
 
    case MINUS:
      return eval(p->left) - eval(p->right);
 
    case MUL:
      return eval(p->left) * eval(p->right);
 
    case DIV:
      {
      double d = eval (p->right);
      if (d==0) {error("Деление на н0ль"); return 1;}
      return eval(p->left) / d;
      }
 
case FOR:
      { 
        double  b = p->left->value;
        double x;
         for(int i = 1; i<=b; i++)
            
           {
            double x = eval(p->right);
            cout<<x<<endl;
           
           }
          return  x;
      }
    default:
     {
      error("Не понял?");
      return 1;
      }
  }
}
 
/////////////////////////////////////////////////////////////////////
// Драйвер
// Функция осуществляет ввод в режиме "командной строки",
// обращается к синтаксическому анализатору для разбора выражения
// и построения двоичного дерева выражения, и к вычислителю для
// вычисления значения постороенного двоичного дерева
/////////////////////////////////////////////////////////////////////
int main()
{
  insert("pi")->value=3.1415926535897932384626433832795;
  insert("e")->value=2.718281828459045;
 
  while (cin)                      // Пока входной поток не пуст
  { cout << "calc>";
    get_token ();                  // Берем первую лексему
   
  if (curr_tok == END) break;    // Если не конец
  cout << eval(expr()) << "\n";  // Строим дерево, вычисляем его и выводим
    if (curr_tok != END) error ("Лишние символы");
  }
  return no_of_errors;
}