See what's going on with flipcode!




This section of the archives stores flipcode's complete Developer Toolbox collection, featuring a variety of mini-articles and source code contributions from our readers.

 

  Calculator Class
  Submitted by



I'm submitting my "calculator" class to you for code-of-the-day. What my class does is take a text string, and evaluates it into another text string.

For instance, you can do this:
calculator Calc;
char *result=calc.calculate("2+2+2");
MessageBox(result); 

It will return a string containing "6". It also evaluates parenthesis, like (2+2)*3... but it doesn't follow order of operations. Without parenthesis, it will simply go left to right. It evaluates most c/c++ operators (&,|,!=,==,>>,<<, etc) also. I originally developed this class as a part of a scripting language I was writing. It doesn't follow any class or MFC programming conventions, though, so some people might find it a little offensive to read. You can add variables to the class, so that you could evaluate a text string like (2+THING+3). You can even add a variable that points to a variable in your program-- so in a scripting language, it would allow the user to access your data.

John Raptis
www.raptisoft.com

Currently browsing [calculator.zip] (36,563 bytes) - [calculator.h] - (1,745 bytes)

class variable {
	private:
		void *m_pPointer;
		int m_nType;

public: variable(char *name, void *ptr, int type); ~variable();

char *m_pName; void Get(char *where); };

class calculator { private: char cstring[256]; char workstring[256];

int base; int precision;

int variables; long *variablelist; char vnull;

void DeBone(void); void CutString(long pos, long len); void InsertString(long pos, char *str); long GetOps(long pos, double *op1, double *op2); double GetOp(char *data); void Calc(void); void MakeFloat(char *result,double number); unsigned int StringToHex(char *str); unsigned int StringToBinary(char *str); void LongToBinary(long lNumber, char *pString); void InsertVariable(variable *v); variable *Check(char *string);

public: #define CALC_OK 0 #define CALC_BADDECIMAL 1 #define CALC_BADHEXADECIMAL 2 #define CALC_BADBINARY 3 #define CALC_BADVARIABLE 4 #define CALC_OPENPARENTHESIS 5 #define CALC_ALREADYEXISTS 6 #define CALC_NOTFOUND 7 #define CALC_INVALIDVARIABLE 8

calculator(); ~calculator();

int result;

char *calculate(char *string); char *calculate(char *string, char flag);

BOOL SetBase(int rbase); BOOL SetPrecision(int precision); int GetBase(); int GetPrecision();

int AddVariable_char(char *name, char *ptr); int AddVariable_short(char *name, short *ptr); int AddVariable_int(char *name, int *ptr); int AddVariable_long(char *name, long *ptr); int AddVariable_float(char *name, float *ptr); int AddVariable_double(char *name, double *ptr); int AddVariable_string(char *name, char *ptr); int RemoveVariable(char *name); };

Currently browsing [calculator.zip] (36,563 bytes) - [calculator.cpp] - (17,992 bytes)

#include "stdafx.h"
#include "resource.h"

#include <stdarg.h> #include <conio.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <memory.h> #include <dos.h> #include <math.h> #include <fcntl.h> #include <io.h> #include <sys\types.h> #include <sys\stat.h> #include <malloc.h> #include <float.h> #include <mmsystem.h> #include <assert.h> #include <commctrl.h> #include <commdlg.h> #include <windows.h>

#include "calculator.h"

calculator::calculator(void) { base=10; precision=2; variables=0; vnull=1; }

calculator::~calculator(void) { long *pLong; variable *v; int count=0;

if (vnull==1) { pLong=this->variablelist; while (count++<this->variables) { v=(variable *)*pLong; delete v; pLong++; } }

// Free up the variable list... }

void calculator::DeBone(void) { char *sptr,*cptr; char *newstr; short pcount; calculator *c;

sptr=&cstring[0]; pcount=0;

while (*sptr!=0) { if (*sptr=='(') { if (pcount==0) cptr=sptr+1; pcount++; } if (*sptr==')') { pcount--; if (pcount==0) { strncpy(workstring,cptr,sptr-cptr); workstring[sptr-cptr]=0;

c=new calculator(); c->precision=this->precision; c->base=this->base; c->vnull=0;

c->variables=this->variables; c->variablelist=this->variablelist;

newstr=c->calculate(workstring,1);

CutString(((cptr-1)-&cstring[0]),(sptr-cptr)+2); InsertString(((cptr-1)-&cstring[0]),newstr);

delete c; sptr=&cstring[0]; } } sptr++; } }

void calculator::CutString(long pos, long len) { strcpy(&cstring[pos],&cstring[pos+len]); }

void calculator::InsertString(long pos, char *str) { char hold[255]; hold[0]=0; strcpy(hold,&cstring[pos]); cstring[pos]=0; strcat(cstring,str); strcat(cstring,hold); }

long calculator::GetOps(long pos, double *op1, double *op2) { char *sptr,*basesptr;

char hold[255]; char *holdptr;

*op1=0; *op2=0;

sptr=&cstring[0]; while (sptr>&cstring[0] && (isalnum(*sptr) || *sptr=='.' || *sptr==127 || *sptr=='!'/*CHANGE*/)) sptr--; basesptr=sptr;

holdptr=&hold[0]; for (;;) { if (isalnum(*sptr) || *sptr=='.' || *sptr==127 || *sptr=='!'/*CHANGE*/) { *holdptr=*sptr; holdptr++; sptr++; } else break; } *holdptr=0; *op1=GetOp(hold);

hold[0]=0; holdptr=&hold[0]; for (;;) { if (isalnum(*sptr) || *sptr=='.' || *sptr==0 || *sptr==127 || *sptr=='!'/*CHANGE*/) break; sptr++; } while (*sptr!=0) { if (isalnum(*sptr) || *sptr=='.' || *sptr==127 || *sptr=='!'/*CHANGE*/) { *holdptr=*sptr; holdptr++; sptr++; } else break; } *holdptr=0; *op2=GetOp(hold);

return (sptr-basesptr); }

#define PI (3.1415926535) char tstring[256];

double calculator::GetOp(char *data) { char *dptr; char compliment; variable *v;

if (strlen(data)==0) return 0;

// Degrees and radians? Should I? So I would type sin(rad(45)) to do it correctly? dptr=data;

compliment=0; if (*dptr=='!') { dptr++; compliment=1; }

v=this->Check(dptr); if (v!=NULL) { v->Get(tstring); return GetOp(tstring); }

if (*(dptr+(strlen(dptr)-1))=='b') { *(dptr+(strlen(dptr)-1))=0; return (float)StringToBinary(dptr); }

if (strnicmp(dptr,"0x",2)==0) { dptr+=2; return (float)StringToHex(dptr); }

// Go through any of our pre-defined variables, and we can get a calculator class out of // it. // NOTE: We have an issue with the complement! if (strnicmp(dptr,"rad",3)==0) { dptr+=3; return (atof(dptr)*(PI/180)); } if (strnicmp(dptr,"deg",3)==0) { dptr+=3; return (atof(dptr)*(180/PI)); }

if (strnicmp(dptr,"sin",3)==0) { dptr+=3; return sin(GetOp(dptr)); } if (strnicmp(dptr,"cos",3)==0) { dptr+=3; return cos(atof(dptr)); } if (strnicmp(dptr,"tan",3)==0) { dptr+=3; return tan(atof(dptr)); } if (strnicmp(dptr,"atan",4)==0) { dptr+=4; return atan(atof(dptr)); } if (strnicmp(dptr,"asin",4)==0) { dptr+=4; return asin(atof(dptr)); } if (strnicmp(dptr,"acos",4)==0) { dptr+=4; return acos(atof(dptr)); } if (strnicmp(dptr,"sqrt",4)==0) { dptr+=4; return sqrt(atof(dptr)); }

if (*dptr==127/*CHANGE*/) { dptr++; if (compliment==1) { if (atof(dptr)==0) return 1; else return 0; } return -atof(dptr); }

if (compliment==1) { if (atof(dptr)==0) return 1; else return 0; } return atof(dptr); }

void calculator::Calc(void) { char *sptr; char hold[255]; double op1,op2,result; long len;

sptr=&cstring[0]; while (*sptr!=0) { switch (*sptr) { case '+': len=GetOps(sptr-&cstring[0],&op1,&op2); result=op1+op2; MakeFloat(hold,result);

CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; break; case '-': len=GetOps(sptr-&cstring[0],&op1,&op2); result=op1-op2;

MakeFloat(hold,result); CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; break; case '*': len=GetOps(sptr-&cstring[0],&op1,&op2); result=op1*op2;

MakeFloat(hold,result); CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; break; case '/': len=GetOps(sptr-&cstring[0],&op1,&op2); result=op1/op2; MakeFloat(hold,result); CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; break; case '^': len=GetOps(sptr-&cstring[0],&op1,&op2); result=pow(op1,op2); MakeFloat(hold,result); CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; break; case '&': len=GetOps(sptr-&cstring[0],&op1,&op2); result=(long)op1&(long)op2; MakeFloat(hold,result); CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; break; case '%': len=GetOps(sptr-&cstring[0],&op1,&op2); result=(long)op1%(long)op2; MakeFloat(hold,result); CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; break; case '|': len=GetOps(sptr-&cstring[0],&op1,&op2); result=(long)op1|(long)op2; MakeFloat(hold,result); CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; break; case '<': sptr++; if (*sptr=='<') { len=GetOps(sptr-&cstring[0],&op1,&op2); result=(long)op1<<(long)op2; MakeFloat(hold,result); CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; } else if (*sptr=='=') { len=GetOps(sptr-&cstring[0],&op1,&op2); result=(long)op1<=(long)op2; MakeFloat(hold,result); CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; } else { len=GetOps(sptr-&cstring[0],&op1,&op2); result=op1<op2; MakeFloat(hold,result); CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; } break; case '>': sptr++; if (*sptr=='>') { len=GetOps(sptr-&cstring[0],&op1,&op2); result=(long)op1>>(long)op2; MakeFloat(hold,result); CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; } else if (*sptr=='=') { len=GetOps(sptr-&cstring[0],&op1,&op2); result=(long)op1>=(long)op2; MakeFloat(hold,result); CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; } else { len=GetOps(sptr-&cstring[0],&op1,&op2); result=op1>op2; MakeFloat(hold,result); CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; } break; case '=': sptr++; if (*sptr=='=') { len=GetOps(sptr-&cstring[0],&op1,&op2); result=(long)op1==(long)op2; MakeFloat(hold,result); CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; } break; case '!': sptr++; if (*sptr=='=') { len=GetOps(sptr-&cstring[0],&op1,&op2); result=(long)op1!=(long)op2; MakeFloat(hold,result); CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; } else sptr--; // Otherwise, don't eliminate it, right? break; case '~': long temp; len=GetOps(sptr-&cstring[0],&op1,&op2); temp=(long)op1; temp^=(long)op2; result=(float)temp; MakeFloat(hold,result);

CutString(0,len); InsertString(0,hold); sptr=&cstring[0]; break; } sptr++; } }

char *calculator::calculate(char *string) { char *sptr;

result=CALC_OK;

strcpy(cstring,string); strcat(cstring,"+0"); DeBone(); Calc();

sptr=&cstring[0]; while (*sptr!=0) { if (*sptr==127/*CHANGE*/) *sptr='-'; sptr++; }

switch (base) { case 16: double fResult; long lResult; char string[255];

fResult=atof(cstring); lResult=(long)fResult; sprintf(string,"%.2x",lResult);

strupr(string);

if (strlen(string)%2!=0) sprintf(cstring,"0x0%s",string); else sprintf(cstring,"0x%s",string); break; case 2: fResult=atof(cstring); lResult=(long)fResult;

LongToBinary(lResult,cstring); break; }

return &cstring[0]; }

char *calculator::calculate(char *string, char flag) { result=CALC_OK;

strcpy(cstring,string); strcat(cstring,"+0");

DeBone(); Calc(); return &cstring[0]; }

void calculator::MakeFloat(char *string, double number) { switch (precision) { case 0: if (number>=0) sprintf(string,"%.0f",number); else sprintf(string,"%c%.0f",127,fabs(number)); break; case 1: if (number>=0) sprintf(string,"%.1f",number); else sprintf(string,"%c%.1f",127,fabs(number)); break; case 2: if (number>=0) sprintf(string,"%.2f",number); else sprintf(string,"%c%.2f",127,fabs(number)); //FUNK break; case 3: if (number>=0) sprintf(string,"%.3f",number); else sprintf(string,"%c%.3f",127,fabs(number)); break; case 4: if (number>=0) sprintf(string,"%.4f",number); else sprintf(string,"%c%.4f",127,fabs(number)); break; case 5: if (number>=0) sprintf(string,"%.5f",number); else sprintf(string,"%c%.5f",127,fabs(number)); break; case 6: if (number>=0) sprintf(string,"%.6f",number); else sprintf(string,"%c%.6f",127,fabs(number)); break; case 7: if (number>=0) sprintf(string,"%.7f",number); else sprintf(string,"%c%.7f",127,fabs(number)); break; case 8: if (number>=0) sprintf(string,"%.8f",number); else sprintf(string,"%c%.8f",127,fabs(number)); break; case 9: if (number>=0) sprintf(string,"%.9f",number); else sprintf(string,"%c%.9f",127,fabs(number)); break; case 10: if (number>=0) sprintf(string,"%.10f",number); else sprintf(string,"%c%.10f",127,fabs(number)); break; } }

unsigned int calculator::StringToHex(char *str) { unsigned int i, j = 0;

strupr(str);

while (str && *str && isxdigit(*str)) { i = *str++ - '0'; if (9<i) i-=7; j<<=4; j|=(i&0x0f); } return(j); }

unsigned int calculator::StringToBinary(char *str) { unsigned int result=0; unsigned int multi=1; char *pstr; pstr=str+(strlen(str)-1);

while (pstr>=str) { if (*pstr=='1') { result|=multi; multi<<=1; } else if (*pstr=='0') { multi<<=1; } pstr--; } return result; }

BOOL calculator::SetBase(int rbase) { if (rbase!=10 && rbase!=16 && rbase!=2) return FALSE;

this->base=rbase; return TRUE; }

BOOL calculator::SetPrecision(int nPrecision) { if (nPrecision<0) return FALSE; if (nPrecision>10) return FALSE;

precision=nPrecision; return TRUE; }

void calculator::LongToBinary(long lNumber, char *pString) { char *pStr; pStr=pString;

*pStr='0'; if (lNumber&0x00000001) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00000002) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00000004) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00000008) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00000010) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00000020) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00000040) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00000080) *pStr='1'; pStr++;

if (lNumber&0xFFFFFF00) { *pStr='0'; if (lNumber&0x00000100) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00000200) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00000400) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00000800) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00001000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00002000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00004000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00008000) *pStr='1'; pStr++; }

if (lNumber&0xFFFF0000) { *pStr='0'; if (lNumber&0x00010000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00020000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00040000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00080000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00100000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00200000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00400000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x00800000) *pStr='1'; pStr++; }

if (lNumber&0xFF000000) { *pStr='0'; if (lNumber&0x01000000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x02000000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x04000000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x08000000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x10000000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x20000000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x40000000) *pStr='1'; pStr++; *pStr='0'; if (lNumber&0x80000000) *pStr='1'; pStr++; }

*pStr=0; strrev(pString); strcat(pString,"b"); }

int calculator::GetBase(void) { return base; }

int calculator::GetPrecision(void) { return precision; }

#define VTYPE_CHAR 0 #define VTYPE_SHORT 1 #define VTYPE_INT 2 #define VTYPE_LONG 3 #define VTYPE_FLOAT 4 #define VTYPE_DOUBLE 5 #define VTYPE_STRING 6

void calculator::InsertVariable(variable *v) { long *ptr; if (this->variables==0) { this->variablelist=(long*)malloc(4); ptr=this->variablelist; this->variables=1; } else { this->variables++; this->variablelist=(long*)realloc(this->variablelist,this->variables*4); ptr=(this->variablelist+(this->variables-1)); }

*ptr=(long)v; }

BOOL calculator::RemoveVariable(char *name) { variable *v,*vv; long *pLong; int count=0;

v=this->Check(name); if (v==NULL) return CALC_NOTFOUND;

pLong=this->variablelist; while (count++<this->variables) { vv=(variable *)*pLong; if (vv==v) break; pLong++; } while (count++<this->variables) { *pLong=*(pLong+1); pLong++; } this->variables--; this->variablelist=(long*)realloc(this->variablelist,this->variables*4);

delete v; return CALC_OK; }

variable *calculator::Check(char *string) { long *pLong; variable *v; int count=0;

pLong=this->variablelist; while (count++<this->variables) { v=(variable *)*pLong; if (strcmp(v->m_pName,string)==0) return v;

pLong++; } return NULL; }

BOOL calculator::AddVariable_char(char *name, char *ptr) { variable *v;

v=this->Check(name); if (v!=NULL) return CALC_ALREADYEXISTS;

v=new variable(name,ptr,VTYPE_CHAR); InsertVariable(v); return CALC_OK; }

BOOL calculator::AddVariable_short(char *name, short *ptr) { variable *v;

v=this->Check(name); if (v!=NULL) return CALC_ALREADYEXISTS;

v=new variable(name,ptr,VTYPE_SHORT); InsertVariable(v); return CALC_OK; }

BOOL calculator::AddVariable_int(char *name, int *ptr) { variable *v;

v=this->Check(name); if (v!=NULL) return CALC_ALREADYEXISTS;

v=new variable(name,ptr,VTYPE_INT); InsertVariable(v); return CALC_OK; }

BOOL calculator::AddVariable_long(char *name, long *ptr) { variable *v;

v=this->Check(name); if (v!=NULL) return CALC_ALREADYEXISTS;

v=new variable(name,ptr,VTYPE_LONG); InsertVariable(v); return CALC_OK; }

BOOL calculator::AddVariable_float(char *name, float *ptr) { variable *v;

v=this->Check(name); if (v!=NULL) return CALC_ALREADYEXISTS; v=new variable(name,ptr,VTYPE_FLOAT); InsertVariable(v); return CALC_OK; }

BOOL calculator::AddVariable_double(char *name, double *ptr) { variable *v;

v=this->Check(name); if (v!=NULL) return CALC_ALREADYEXISTS; v=new variable(name,ptr,VTYPE_DOUBLE); InsertVariable(v); return CALC_OK; }

BOOL calculator::AddVariable_string(char *name, char *ptr) { variable *v;

v=this->Check(name); if (v!=NULL) return CALC_ALREADYEXISTS; v=new variable(name,ptr,VTYPE_STRING); InsertVariable(v); return CALC_OK; }



variable::variable(char *name, void *ptr, int type) { this->m_pName=(char*)malloc(strlen(name)+1); strcpy(this->m_pName,name);

this->m_pPointer=ptr; this->m_nType=type; }

variable::~variable() { free(this->m_pName); }

void variable::Get(char *where) { switch (this->m_nType) { case VTYPE_CHAR: sprintf(where,"%d",*(char*)this->m_pPointer); break; case VTYPE_SHORT: sprintf(where,"%d",*(short*)this->m_pPointer); break; case VTYPE_INT: sprintf(where,"%d",*(int*)this->m_pPointer); break; case VTYPE_LONG: sprintf(where,"%d",*(long*)this->m_pPointer); break; case VTYPE_FLOAT: sprintf(where,"%.10f",*(float*)this->m_pPointer); break; case VTYPE_DOUBLE: sprintf(where,"%.10f",*(double*)this->m_pPointer); break; case VTYPE_STRING: strncpy(where,(char*)this->m_pPointer,255); break; } }




The zip file viewer built into the Developer Toolbox made use of the zlib library, as well as the zlibdll source additions.

 

Copyright 1999-2008 (C) FLIPCODE.COM and/or the original content author(s). All rights reserved.
Please read our Terms, Conditions, and Privacy information.