soutade/KissCount
1
0
Fork 0
Code Issues Pull Requests Packages Releases 1 Wiki Activity
ab176b9fc3
KissCount/src/ParseExp.cpp
Grégory Soutadé f2dcfcb356 * Corrects a lot of bugs 
* Add Tabulation when it's a meta operation child
2010-10-14 22:16:22 +02:00

451 lines
9.0 KiB
C++
Raw Blame History

/*
Copyright 2010 Grégory Soutadé
This file is part of KissCount.
KissCount is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
KissCount is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with KissCount. If not, see <http://www.gnu.org/licenses/>.
*/
#include <string.h>
#include <stdio.h>
#include <iostream>
#include "ParseExp.h"
/*
Algorithm
The idea of this parser is very simple : Create a binary tree with an operator, a left and a right operand.
Leafs are constants to be computed. This structure is more flexbile than a simple stack and very easy to parse
(for resultat computation).
A simple expression (3+4) will be represented by :
+
3 4
Another example (3+4+5) :
+
3 +
4 5
If an operator is less prioritary than his father we have to do a transformation.
Example with 3*4+5.
in first instance we may have this tree :
*
3 +
4 5
So we must reverse the tree into something like :
+
* 5
3 4
At each step the parser must read one operand and one operator,
fill a node with the operator and left operand and recurse on right
operand. Finally we stop with a constant (a leaf).
Operations in parenthesis must be computed separatly and filled into
the tree like constants.
*/
/* Less to most prioritary */
enum {CST, ADD, SUB, MUL, DIV, MOD, EXP};
enum {DOUBLE_POINTED=1, INVALID_CHAR, INVALID_PARENTHESIS, INVALID_OPERATION};
#ifdef DEBUG
#define P(x) x
#else
#define P(x)
#endif
double atof(char* s, int size)
{
int neg = 0;
double res = 0;
for (; size--; s++)
{
if (*s == '.')
{
neg = 10;
continue;
}
if (neg > 0)
{
res += (double) (*s - '0') / (double)neg;
neg *= 10;
}
else
{
res *= 10;
res += *s - '0';
}
}
return res;
}
void ParseExp(char** expr, struct parse_opt* root, bool needParenthesis)
{
char* temp;
bool pointed = false;
struct parse_opt* l, *r, *op, *op_tmp;
char type = -1;
bool negative = false, number = false;
l = r = op = op_tmp = NULL;
if (!**expr) return;
for (temp=*expr; **expr; (*expr)++)
{
if (**expr == '(')
{
op_tmp = new struct parse_opt;
op_tmp->type = CST;
op_tmp->root = root;
op_tmp->l = op_tmp->r = NULL;
(*expr)++;
ParseExp(expr, op_tmp, true);
l = op_tmp;
root->l = l;
continue;
}
if (**expr == ')')
{
if (!needParenthesis)
throw INVALID_PARENTHESIS;
if ((*expr-temp) == 0)
throw INVALID_OPERATION;
break;
}
if (**expr >= '0' && **expr <= '9')
continue;
if (**expr == '.')
{
if (!pointed)
pointed = true;
else
throw DOUBLE_POINTED;
continue;
}
if (type != -1)
throw INVALID_OPERATION;
switch(**expr)
{
case '+':
type = ADD;
break;
case '-':
if (temp == *expr)
{
if (negative)
throw INVALID_OPERATION;
temp++;
negative = true;
continue;
}
type = SUB;
break;
case '/':
type = DIV;
break;
case '*':
type = MUL;
break;
// case '%':
// type = MOD;
// break;
default:
throw INVALID_CHAR;
}
number= true;
if (!l)
{
if ((*expr-temp) == 0)
throw INVALID_OPERATION;
l = new struct parse_opt;
l->type = CST;
l->root = root;
l->l = NULL; l->r = NULL;
l->value = atof(temp, *expr-temp);
if (negative)
l->value *= -1.0;
root->l = l;
}
// Here [temp..expr] must be left operand + operator
if (root->root && root->root->type >= type)
{
// Reverse tree
op = new parse_opt;
op->root = root->root;
op->type = root->root->type;
op->r = l;
op->l = root->root->l;
op->l->root = op;
root->root->l = op;
root->root->type = type;
root->type = CST;
root->value = 0.0;
root->l = NULL ; root->r = NULL;
(*expr)++;
ParseExp(expr, root, needParenthesis);
break;
temp=*expr;
}
else
{
// Recurse on right operand
root->type = type;
// atof
r = new struct parse_opt;
r->type = CST;
r->root = root;
r->l = NULL; r->r = NULL;
r->value = 0.0;
root->r = r;
(*expr)++;
ParseExp(expr, r, needParenthesis);
break;
temp=*expr;
}
}
if (needParenthesis && **expr != ')')
throw INVALID_PARENTHESIS;
if (!number)
{
if ((*expr-temp) == 0)
throw INVALID_OPERATION;
if (op_tmp)
*root = *op_tmp;
else
{
root->type = CST;
root->l = NULL; root->r = NULL;
root->value = atof(temp, *expr-temp);
if (negative)
root->value *= -1.0;
}
}
return ;
}
double EvaluateExpr(struct parse_opt* root, bool del)
{
double l, r;
char type;
type = root->type;
if (root->type != CST)
{
l = EvaluateExpr(root->l, del);
r = EvaluateExpr(root->r, del);
}
else
l = root->value;
if (del)
{
if (root->l) delete root->l;
if (root->r) delete root->r;
}
switch (type)
{
case ADD:
P(std::cout << l << " + " << r << std::endl);
return l+r;
case SUB:
P(std::cout << l << " - " << r << std::endl);
return l+r;
case MUL:
P(std::cout << l << " * " << r << std::endl);
return l*r;
case DIV:
P(std::cout << l << " / " << r << std::endl);
return l/r;
// case MOD:
// return EvaluateExpr(root->l) % EvaluateExpr(root->r);
case EXP:
P(std::cout << l << " ^ " << r << std::endl);
return l*r;
case CST:
return l;
default:
return 0.0;
}
}
#ifdef DEBUG
int main()
{
char* e1 = new char[100] ;
char* e = e1;
struct parse_opt root, *r;
try
{
memset(&root, 0, sizeof(root));
r = &root;
strcpy(e1, "4*3");
ParseExp(&e1, r, false);
std::cout << e << " = " << EvaluateExpr(&root, true) << "\n";
e1 = e;
memset(e1, 0, 100);
strcpy(e1, "4*3+5");
memset(&root, 0, sizeof(root));
r = &root;
ParseExp(&e1, r, false);
std::cout << e << " = " << EvaluateExpr(&root, true) << "\n";
e1 = e;
memset(e1, 0, 100);
strcpy(e1, "3+3+3");
memset(&root, 0, sizeof(root));
r = &root;
ParseExp(&e1, r, false);
std::cout << e << " = " << EvaluateExpr(&root, true) << "\n";
e1 = e;
memset(e1, 0, 100);
strcpy(e1, "3+3+3+3");
memset(&root, 0, sizeof(root));
r = &root;
ParseExp(&e1, r, false);
std::cout << e << " = " << EvaluateExpr(&root, true) << "\n";
e1 = e;
memset(e1, 0, 100);
strcpy(e1, "4+3*5");
memset(&root, 0, sizeof(root));
r = &root;
ParseExp(&e1, r, false);
std::cout << e << " = " << EvaluateExpr(&root, true) << "\n";
e1 = e;
memset(e1, 0, 100);
strcpy(e1, "-4+3*5/2");
memset(&root, 0, sizeof(root));
r = &root;
ParseExp(&e1, r, false);
std::cout << e << " = " << EvaluateExpr(&root, true) << "\n";
e1 = e;
memset(e1, 0, 100);
strcpy(e1, "5+-4");
memset(&root, 0, sizeof(root));
r = &root;
ParseExp(&e1, r, false);
std::cout << e << " = " << EvaluateExpr(&root, true) << "\n";
e1 = e;
memset(e1, 0, 100);
strcpy(e1, "5--4");
memset(&root, 0, sizeof(root));
r = &root;
ParseExp(&e1, r, false);
std::cout << e << " = " << EvaluateExpr(&root, true) << "\n";
e1 = e;
memset(e1, 0, 100);
strcpy(e1, "4*(3+2)");
memset(&root, 0, sizeof(root));
r = &root;
ParseExp(&e1, r, false);
std::cout << e << " = " << EvaluateExpr(&root, true) << "\n";
e1 = e;
memset(e1, 0, 100);
strcpy(e1, "(3+2)*4");
memset(&root, 0, sizeof(root));
r = &root;
ParseExp(&e1, r, false);
std::cout << e << " = " << EvaluateExpr(&root, true) << "\n";
e1 = e;
memset(e1, 0, 100);
strcpy(e1, "4*(3+2)+5");
memset(&root, 0, sizeof(root));
r = &root;
ParseExp(&e1, r, false);
std::cout << e << " = " << EvaluateExpr(&root, true) << "\n";
e1 = e;
memset(e1, 0, 100);
strcpy(e1, "5+(3+2)*4");
memset(&root, 0, sizeof(root));
r = &root;
ParseExp(&e1, r, false);
std::cout << e << " = " << EvaluateExpr(&root, true) << "\n";
e1 = e;
memset(e1, 0, 100);
strcpy(e1, "3+(3+(3+3))");
memset(&root, 0, sizeof(root));
r = &root;
ParseExp(&e1, r, false);
std::cout << e << " = " << EvaluateExpr(&root, true) << "\n";
e1 = e;
memset(e1, 0, 100);
strcpy(e1, "3+(3+(3+(3+3)))*5");
memset(&root, 0, sizeof(root));
r = &root;
ParseExp(&e1, r, false);
std::cout << e << " = " << EvaluateExpr(&root, true) << "\n";
e1 = e;
memset(e1, 0, 100);
strcpy(e1, "5+(3/(6+8--5)*9)*4");
memset(&root, 0, sizeof(root));
r = &root;
ParseExp(&e1, r, false);
std::cout << e << " = " << EvaluateExpr(&root, true) << "\n";
e1 = e;
memset(e1, 0, 100);
strcpy(e1, "5+(3*(6+8--5)/9)*4");
memset(&root, 0, sizeof(root));
r = &root;
ParseExp(&e1, r, false);
std::cout << e << " = " << EvaluateExpr(&root, true) << "\n";
}
catch (int e)
{
std::cout << "Error " << e << std::endl;
}
return 0;
}
#endif
Reference in New Issue View Git Blame Copy Permalink