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.