Визуальное программирование. Считывание теста

#define _CRT_SECURE_NO_WARNINGS
#define _CRT_NON_CONFORMING_SWPRINTFS
#include <windows.h>
#include <stdlib.h>
#include <string>
#include <string.h>
#include <tchar.h>
#include <iostream>
#include "parser.h"
 
static TCHAR szWindowClass[] = _T("wndClass");
static TCHAR szTitle[] = _T("Calculator");
TCHAR buf[256];
TCHAR bufx[32];
 
HINSTANCE hInst;
 
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine, int nCmdShow)
{
 
    WNDCLASSEX wcex;
 
    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, IDI_APPLICATION);
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW);
    wcex.lpszMenuName   = NULL;
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, IDI_APPLICATION);
 
    if (!RegisterClassEx(&wcex))
    {
        MessageBox(NULL, _T("RegisterClassEx failed"), _T("Message"), 0);
        return __LINE__;
    }
 
    hInst = hInstance;
 
    HWND hWnd = CreateWindow(
        szWindowClass,
        szTitle,
        WS_SYSMENU,
        CW_USEDEFAULT, CW_USEDEFAULT,
        255, 220,
        NULL,
        NULL,
        hInstance,
        NULL
    );
 
    if (!hWnd)
    {
        MessageBox(NULL, _T("CreateWindow failed"), _T("Message"), 0);
        return __LINE__;
    }
 
    ShowWindow(hWnd,nCmdShow);
    UpdateWindow(hWnd);
 
   MSG msg;
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
 
    return (int) msg.wParam;
}
 
#define ID_EDIT_Fml  99
#define ID_EDIT_Val  99
#define ID_EDIT_Res  99
#define ID_BUTTON_GO    100
#define ID_BUTTON_C    101
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
 
    static HWND hButtonGo, hButtonC, hEditFml, hEditVal, hEditRes;
    PAINTSTRUCT ps;
    HDC hdc;
 
    switch (message)
    { // -2.5 + (-x) / (-x + 2)
        case WM_CREATE:
            hEditFml = CreateWindow(_T("edit"), _T(""), WS_CHILD | WS_VISIBLE | WS_BORDER | ES_RIGHT, 10, 5, 230, 35, hWnd, (HMENU)ID_EDIT_Fml, hInst, 0);
            hEditVal = CreateWindow(_T("edit"), _T(""), WS_CHILD | WS_VISIBLE | WS_BORDER | ES_RIGHT, 10, 45, 230, 35, hWnd, (HMENU)ID_EDIT_Val, hInst, 0);
            hEditRes = CreateWindow(_T("edit"), _T(""), WS_CHILD | WS_VISIBLE | WS_BORDER | ES_RIGHT, 10, 85, 230, 35, hWnd, (HMENU)ID_EDIT_Res, hInst, 0);
            hButtonGo = CreateWindow (_T("Button"), _T("go"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,  10, 150, 80, 30, hWnd, (HMENU)ID_BUTTON_GO, hInst, 0);
            hButtonC = CreateWindow (_T("Button"), _T("clear"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,  100, 150, 80, 30, hWnd, (HMENU)ID_BUTTON_C, hInst, 0);
            break;
        case WM_COMMAND:
            if((LOWORD(wParam)==ID_BUTTON_GO)&&(HIWORD(wParam)==BN_CLICKED))
            {
                GetWindowText(hEditFml, buf, sizeof(buf));
                GetWindowText(hEditVal, bufx, sizeof(bufx));
                typedef std::basic_string<TCHAR> tstring;
                tstring s(buf), sx(bufx);
                if('-' == sx[0])
                    sx = tstring(_T("(")) + sx + tstring(_T(")"));
                tstring::size_type ind;
                while((ind = s.find(TEXT('x'))) != std::basic_string<TCHAR>::npos)
                {
                    s.replace(ind, 1, sx);
                }
                SetWindowText(hEditRes, s.c_str());
                TParser parser;
                static double x[10];
                parser.SetX((double *)&x);
                try
                {
                  // Evaluate expr.
                  parser.Compile(const_cast<char*>(s.c_str()));
                  parser.Evaluate();
                  _stprintf(buf, TEXT("%lf"), parser.GetResult());
                }
                catch(TError error)
                {
                  // Print error.
                  _stprintf(buf, TEXT("NAN"));
                }
                SetWindowText(hEditRes, buf);
            }
            else if((LOWORD(wParam)==ID_BUTTON_C)&&(HIWORD(wParam)==BN_CLICKED))
            {
                SetWindowText(hEditFml, _T(""));
                SetWindowText(hEditVal, _T(""));
                SetWindowText(hEditRes, _T(""));
            }
        case WM_PAINT:
            hdc = BeginPaint(hWnd, &ps);
            EndPaint(hWnd, &ps);
            break;
        case WM_DESTROY:
            PostQuitMessage(0);
            break;
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
            break;
    }
    return 0;
}

// main.cpp
// Содержит тестовую программу для модуля parser.cpp.
// Writen by Chaos Master, 17th of Febrary, 2000.
 
// Includes
#define M_PI             3.1415926535897932384626433832795
#include <cstring>
#include <iostream>
#include <cstdio>
// parser.cpp
// Этот файл содержит реализацию класса TParser,
// осуществляющего разбор заданного математического выражения.
// Written by Chaos Master, 11th of Febrary, 2000.
 
// Includes
//#include "stdafx.h"
#include <math.h>
// parser.h
// Этот файл содержит описание класса TParser,
// осуществляющего разбор заданного математического выражения.
// Written by Chaos Master, 11th of Febrary, 2000.
 
#if !defined(__SOLVER_H)
#define __SOLVER_H
 
// Includes
#include <string.h>
#include <vector>
using namespace std;
 
// Defines
#define MAX_EXPR_LEN   255
#define MAX_TOKEN_LEN  80
 
struct TParserNode
{
   double value;
   TParserNode *left;
   TParserNode *right;
 
   TParserNode(double _value=0.0, TParserNode *_left=NULL, TParserNode *_right=NULL)
      { value = _value; left = _left; right = _right; }
};
 
struct TError
{
   char *error;
   int pos;
 
   TError() {};
   TError(char *_error, int _pos) { error=_error; pos=_pos; }
};
 
class TParser
{
  private:
   TParserNode *root;
   char *expr;
   char curToken[MAX_TOKEN_LEN];
   enum { PARSER_PLUS, PARSER_MINUS, PARSER_MULTIPLY, PARSER_DIVIDE, PARSER_PERCENT, PARSER_POWER,
          PARSER_SIN, PARSER_COS, PARSER_TG, PARSER_CTG, PARSER_ARCSIN, PARSER_ARCCOS, PARSER_ARCTG, PARSER_ARCCTG, PARSER_SH, PARSER_CH, PARSER_TH, PARSER_CTH,
          PARSER_EXP, PARSER_LG, PARSER_LN, PARSER_SQRT, PARSER_X, PARSER_L_BRACKET, PARSER_R_BRACKET, PARSER_E, PARSER_PI, PARSER_NUMBER, PARSER_END } typToken;
   int pos;
 
   const double *x;
   double result;
 
   vector<TParserNode *> history;
 
  private:
   TParserNode *CreateNode(double _value=0.0, TParserNode *_left=NULL, TParserNode *_right=NULL);
 
   TParserNode *Expr(void);
   TParserNode *Expr1(void);
   TParserNode *Expr2(void);
   TParserNode *Expr3(void);
   TParserNode *Expr4(void);
   TParserNode *Expr5(void);
 
   bool GetToken(void);
   bool IsDelim(void) { return (strchr("+-*/%^()[]", expr[pos])!=NULL); }
   bool IsLetter(void) { return ((expr[pos]>='a' && expr[pos]<='z') ||
                                 (expr[pos]>='A' && expr[pos]<='Z')); }
   bool IsDigit(void) { return (expr[pos]>='0' && expr[pos]<='9'); }
   bool IsPoint(void) { return (expr[pos]=='.'); }
 
   double CalcTree(TParserNode *tree);
   void  DelTree(TParserNode *tree);
 
   void SendError(int errNum);
 
  public:
   TParser() { result = 0.0; x = NULL; root = NULL; }
   ~TParser() { DelTree(root); root=NULL; }
   void SetX(const double *_x) { x=_x; }
   //void SetY(double _y) { y=_y; }
 
   bool Compile(char *expr);
   void Decompile() { DelTree(root); root=NULL; }
 
   double Evaluate();
   double Evaluate(double *_x) { SetX(_x); return Evaluate(); }
   double Evaluate(double x, ...) { SetX(&x); return Evaluate(); }
 
   double GetResult(void) { return result; }
};
 
#endif
 
// Defines
// operations...
#define OP_PLUS          0
#define OP_MINUS         1
#define OP_MULTIPLY      2
#define OP_DIVIDE        3
#define OP_PERCENT       4
#define OP_POWER         5
#define OP_UMINUS        6
 
#define OP_SIN           10
#define OP_COS           11
#define OP_TG            12
#define OP_CTG           13
#define OP_ARCSIN        14
#define OP_ARCCOS        15
#define OP_ARCTG         16
#define OP_ARCCTG        17
#define OP_SH            18
#define OP_CH            19
#define OP_TH            20
#define OP_CTH           21
#define OP_EXP           22
#define OP_LG            23
#define OP_LN            24
#define OP_SQRT          25
#define OP_X             26
 
// PI...
 
 
// Member functions
TParserNode *TParser::CreateNode(double _value, TParserNode *_left, TParserNode *_right)
{
   TParserNode *pNode = new TParserNode(_value, _left, _right);
   history.push_back(pNode);
   return pNode;
}
 
void TParser::SendError(int errNum)
{
   static char const*errs[7] = { NULL,
                            NULL,
                            "Unexpected end of expression",
                            "End of expression expected",
                            "'(' or '[' expected",
                            "')' or ']' expected",
                            NULL
                         };
   static char buffer[80];
 
   int len = strlen(curToken);
 
   if(*curToken=='\0')
      strcpy(curToken, "EOL");
 
   switch(errNum)
   {
      case 0:
         sprintf(buffer, "Unknown keyword: '%s'", curToken);
         errs[0] = buffer;
         break;
 
      case 1:
         sprintf(buffer, "Unknown symbol: '%s'", curToken);
         errs[1] = buffer;
         break;
 
      case 6:
         sprintf(buffer, "Unexpected '%s'", curToken);
         errs[6] = buffer;
         break;
   }
 
   TError error(const_cast<char*>(errs[errNum]), pos-len);
 
   for(int i=0; i<history.size(); i++)
      delete history[i];
   history.clear();
 
   root = NULL;
 
   throw error;
 
   return;
}
 
bool TParser::GetToken(void)
{
   *curToken = '\0';
 
   while(expr[pos]==' ') pos++;
 
   if(expr[pos]=='\0')
   {
      curToken[0] = '\0';
      typToken = PARSER_END;
      return true;
   }
   else if(IsDelim())
   {
      curToken[0] = expr[pos++];
      curToken[1] = '\0';
      switch(*curToken)
      {
         case '+': typToken = PARSER_PLUS; return true;
         case '-': typToken = PARSER_MINUS; return true;
         case '*': typToken = PARSER_MULTIPLY; return true;
         case '/': typToken = PARSER_DIVIDE; return true;
         case '%': typToken = PARSER_PERCENT; return true;
         case '^': typToken = PARSER_POWER; return true;
         case '[':
         case '(': typToken = PARSER_L_BRACKET; return true;
         case ']':
         case ')': typToken = PARSER_R_BRACKET; return true;
      }
   }
   else if(IsLetter())
   {
      int i=0;
      while(IsLetter()) curToken[i++] = expr[pos++];
      curToken[i] = '\0';
 
      int len = strlen(curToken);
      for(i=0; i<len; i++)
         if(curToken[i]>='A' && curToken[i]<='Z')
            curToken[i] += 'a' - 'A';
 
      if(!strcmp(curToken, "x"))           { typToken = PARSER_X; return true; }
      else if(!strcmp(curToken, "pi"))     { typToken = PARSER_PI; return true; }
      else if(!strcmp(curToken, "e"))      { typToken = PARSER_E; return true; }
      else if(!strcmp(curToken, "sin"))    { typToken = PARSER_SIN; return true; }
      else if(!strcmp(curToken, "cos"))    { typToken = PARSER_COS; return true; }
      else if(!strcmp(curToken, "tg"))     { typToken = PARSER_TG; return true; }
      else if(!strcmp(curToken, "ctg"))    { typToken = PARSER_CTG; return true; }
      else if(!strcmp(curToken, "arcsin")) { typToken = PARSER_ARCSIN; return true; }
      else if(!strcmp(curToken, "arccos")) { typToken = PARSER_ARCCOS; return true; }
      else if(!strcmp(curToken, "arctg"))  { typToken = PARSER_ARCTG; return true; }
      else if(!strcmp(curToken, "arcctg")) { typToken = PARSER_ARCCTG; return true; }
      else if(!strcmp(curToken, "sh"))     { typToken = PARSER_SH; return true; }
      else if(!strcmp(curToken, "ch"))     { typToken = PARSER_CH; return true; }
      else if(!strcmp(curToken, "th"))     { typToken = PARSER_TH; return true; }
      else if(!strcmp(curToken, "cth"))    { typToken = PARSER_CTH; return true; }
      else if(!strcmp(curToken, "exp"))    { typToken = PARSER_EXP; return true; }
      else if(!strcmp(curToken, "lg"))     { typToken = PARSER_LG; return true; }
      else if(!strcmp(curToken, "ln"))     { typToken = PARSER_LN; return true; }
      else if(!strcmp(curToken, "sqrt"))   { typToken = PARSER_SQRT; return true; }
      else SendError(0);
   }
   else if(IsDigit() || IsPoint())
   {
      int i=0;
      while(IsDigit()) curToken[i++] = expr[pos++];
      if(IsPoint())
      {
         curToken[i++] = expr[pos++];
         while(IsDigit()) curToken[i++] = expr[pos++];
      }
      curToken[i] = '\0';
      typToken = PARSER_NUMBER;
      return true;
   }
   else
   {
      curToken[0] = expr[pos++];
      curToken[1] = '\0';
      SendError(1);
   }
 
   return false;
}
 
bool TParser::Compile(char *_expr)
{
   pos = 0;
   expr = _expr;
   *curToken = '\0';
   if(root!=NULL)
   {
      DelTree(root);
      root = NULL;
   }
 
   history.clear();
 
   GetToken();
   if(typToken==PARSER_END) SendError(2);
   root = Expr();
   if(typToken!=PARSER_END) SendError(3);
 
   history.clear();
 
   return true;
}
 
TParserNode *TParser::Expr(void)
{
   TParserNode *temp = Expr1();
 
   while(1)
   {
      if(typToken==PARSER_PLUS)
      {
         GetToken();
         temp = CreateNode(OP_PLUS, temp, Expr1());
      }
      else if(typToken==PARSER_MINUS)
      {
         GetToken();
         temp = CreateNode(OP_MINUS, temp, Expr1());
      }
      else break;
   }
 
   return temp;
}
 
TParserNode *TParser::Expr1(void)
{
   TParserNode *temp = Expr2();
 
   while(1)
   {
      if(typToken==PARSER_MULTIPLY)
      {
         GetToken();
         temp = CreateNode(OP_MULTIPLY, temp, Expr2());
      }
      else if(typToken==PARSER_DIVIDE)
      {
         GetToken();
         temp = CreateNode(OP_DIVIDE, temp, Expr2());
      }
      else if(typToken==PARSER_PERCENT)
      {
         GetToken();
         temp = CreateNode(OP_PERCENT, temp, Expr2());
      }
      else break;
   }
 
   return temp;
}
 
TParserNode *TParser::Expr2(void)
{
   TParserNode *temp = Expr3();
 
   while(1)
   {
      if(typToken==PARSER_POWER)
      {
         GetToken();
         temp = CreateNode(OP_POWER, temp, Expr2());
      }
      else break;
   }
 
   return temp;
}
 
TParserNode *TParser::Expr3(void)
{
   TParserNode *temp;
 
   if(typToken==PARSER_PLUS)
   {
      GetToken();
      temp = Expr4();
   }
   else if(typToken==PARSER_MINUS)
   {
      GetToken();
      temp = CreateNode(OP_UMINUS, Expr4());
   }
   else
      temp = Expr4();
 
   return temp;
}
 
TParserNode *TParser::Expr4(void)
{
   TParserNode *temp;
 
   if(typToken>=PARSER_SIN && typToken<=PARSER_X)
   {
      temp = CreateNode(OP_SIN-PARSER_SIN+typToken);
      GetToken();
      if(typToken!=PARSER_L_BRACKET) SendError(4);
      GetToken();
      temp->left = Expr();
      if(typToken!=PARSER_R_BRACKET) SendError(5);
      GetToken();
   }
   else
      temp = Expr5();
 
   return temp;
}
 
TParserNode *TParser::Expr5(void)
{
   TParserNode *temp = 0;
 
   switch(typToken)
   {
      case PARSER_NUMBER:
         temp = CreateNode((double)atof(curToken));
         GetToken();
         break;
 
      case PARSER_PI:
         temp = CreateNode((double)M_PI);
         GetToken();
         break;
 
      case PARSER_E:
         temp = CreateNode((double)exp(1));
         GetToken();
         break;
 
      case PARSER_L_BRACKET:
         GetToken();
         temp = Expr();
         if(typToken!=PARSER_R_BRACKET) SendError(5);
         GetToken();
         break;
 
      default:
         SendError(6);
   }
 
   return temp;
}
 
double TParser::Evaluate(void)
{
   result = CalcTree(root);
   return result;
}
 
double TParser::CalcTree(TParserNode *tree)
{
   static double temp;
 
   if(tree->left==NULL && tree->right==NULL)
      return tree->value;
   else
      switch((int)tree->value)
      {
         case OP_PLUS:
            return CalcTree(tree->left)+CalcTree(tree->right);
 
         case OP_MINUS:
            return CalcTree(tree->left)-CalcTree(tree->right);
 
         case OP_MULTIPLY:
            return CalcTree(tree->left)*CalcTree(tree->right);
 
         case OP_DIVIDE:
            return CalcTree(tree->left)/CalcTree(tree->right);
 
         case OP_PERCENT:
            return (int)CalcTree(tree->left)%(int)CalcTree(tree->right);
 
         case OP_POWER:
            return (double)pow(CalcTree(tree->left),CalcTree(tree->right));
 
         case OP_UMINUS:
            return -CalcTree(tree->left);
 
         case OP_SIN:
            return sin(CalcTree(tree->left));
 
         case OP_COS:
            return cos(CalcTree(tree->left));
 
         case OP_TG:
            return tan(CalcTree(tree->left));
 
         case OP_CTG:
            return 1.0/tan(CalcTree(tree->left));
 
         case OP_ARCSIN:
            return asin(CalcTree(tree->left));
 
         case OP_ARCCOS:
            return acos(CalcTree(tree->left));
 
         case OP_ARCTG:
            return atan(CalcTree(tree->left));
 
         case OP_ARCCTG:
            return M_PI/2.0-atan(CalcTree(tree->left));
 
         case OP_SH:
            temp = CalcTree(tree->left);
            return (exp(temp)-exp(-temp))/2.0;
 
         case OP_CH:
            temp = CalcTree(tree->left);
            return (exp(temp)+exp(-temp))/2.0;
 
         case OP_TH:
            temp = CalcTree(tree->left);
            return (exp(temp)-exp(-temp))/(exp(temp)+exp(-temp));
 
         case OP_CTH:
            temp = CalcTree(tree->left);
            return (exp(temp)+exp(-temp))/(exp(temp)-exp(-temp));
 
         case OP_EXP:
            return exp(CalcTree(tree->left));
 
         case OP_LG:
            return log10(CalcTree(tree->left));
 
         case OP_LN:
            return log(CalcTree(tree->left));
 
         case OP_SQRT:
            return sqrt(CalcTree(tree->left));
 
         case OP_X:
            return x[int(CalcTree(tree->left))];
      }
 
   return 0;
}
 
void TParser::DelTree(TParserNode *tree)
{
   if(tree==NULL) return;
 
   DelTree(tree->left);
   DelTree(tree->right);
 
   delete tree;
 
   return;
}