Classes/String/Parse.cpp

#include "Parse.h"

#include "../System/System.h"
#include "../System/SystemDefine.h"
#include <math.h>
#include "StringTools.h"

Parse::Parse()
{
}

Parse::~Parse()
{
}

//////////////////////////////////////////////////////////////////////////////////////
//add a Integer String to a Decimal String and returns the result as a char array
//////////////////////////////////////////////////////////////////////////////////////

char *Parse::addIntToDecimal(char *source, int *sourceLength,  char *dest, int *destLength, int *totalLength)
{
        int forward=0;

        totalLength[0]=(sourceLength[0]+destLength[0]);

        char *intDecimalDest=(char*)malloc(totalLength[0]*sizeof(char));

        for ( int s=0 ; s<sourceLength[0] ; s++ )
        {
                intDecimalDest[forward]=source[s];
                forward++;
        }

        for ( int s2=0 ; s2<(destLength[0]+1) ; s2++ )
        {
                intDecimalDest[forward]=dest[s2];
                forward++;
        }

        return intDecimalDest;
}

//////////////////////////////////////////////////////////////////////////////////////
//converts a int to a String (char buffer) 
//////////////////////////////////////////////////////////////////////////////////////

char* Parse::intToString(int integer, int *length)
{
        return intToString(integer, length, false);
}

char* Parse::intToString(int integer, int *length, bool decimalStatement)
{
        char *intDest=(char*)malloc(12*sizeof(char));

        if ( integer == 0 )
        {
                if (decimalStatement)
                {
                        intDest[0]='-';
                        intDest[1]='0';
                        intDest[2]=0;
                        length[0]=2;
                }
                else
                {
                        intDest[0]='0';
                        intDest[1]=0;
                        length[0]=1;
                }

                return intDest;
        }
        
        int size=9;

        int div=100000000;      
        int forward=0;

        if ( integer < 0 )
        {
                integer*=-1;
                intDest[0]=(char)'-';
                forward++;
                
        }

        int start=0;

        for ( int h=0; h<size ; h++ )
        {
                int num=integer/div;

                if ( num != 0 )
                {
                        start=1;
                }

                intDest[forward]=(char)((int)'0'+num);

                integer-=(num*div);
                div/=10;
        
                if ( start == 1)
                {
                        forward++;
                }
        }

        intDest[forward]=0;

        length[0]=forward;

        return intDest;
}

//////////////////////////////////////////////////////////////////////////////////////
//converts the decimal part of the float to a String   
//////////////////////////////////////////////////////////////////////////////////////

char* Parse::floatToStringDecimal(float source, int *length)
{
        char *decimalDest=(char*)malloc(7*sizeof(char));

        if ( source == 0 )
        {
                decimalDest[0]=0;
                return decimalDest;
        }

        int size=4;
        int div=1*10*10*10;

        source*=div*10;

        int hdec=(int)floor(source);

        decimalDest[0]='.';

        int forward=1;

        for ( int h=0; h<size ; h++ )
        {
                int num=hdec/div;

                decimalDest[forward]=(char)((int)'0'+num);

                hdec-=(num*div);
                div/=10;
        
                forward++;
        }

        decimalDest[forward]=0;

        length[0]=forward;

        return decimalDest;
}

//////////////////////////////////////////////////////////////////////////////////////
//converts a float to a String then it returns it 
//////////////////////////////////////////////////////////////////////////////////////

char* Parse::floatToString(float source, int *length)
{
        char *intDest=0;
        int integer=0;
        float floatSource=0;
        bool decimalStatement=false;
        int floatLength[1]={0};
        int intLength[1]={0};

        if ( source >= 0 )
        {
                floatSource=source;
                integer=(int)floor((double)source);
                intDest=intToString(integer, intLength);
                floatSource-=(float)integer;
        }
        else
        {
                floatSource=source*-1;
                integer=(int)ceil((double)source);
                intDest=intToString(integer, intLength, true);
                floatSource+=(float)integer;
        }

        char *decimalDest=floatToStringDecimal(floatSource, floatLength);
        char *intDecimalDest=addIntToDecimal(intDest, intLength, decimalDest, floatLength, length);
        free(intDest);
        free(decimalDest);
        return intDecimalDest;
}

//////////////////////////////////////////////////////////////////////////////////////
//converts a String to a float if that is now possible
//////////////////////////////////////////////////////////////////////////////////////

float Parse::stringToFloat(char *string)
{
        float integer=0;
        float decimal=0;
        float floatValue=0;
        int statement=0;
        int neg=1;
        float ggr=1;
        int r=0;

        while ( string[r] != 0 && statement == 0 )
        {
                if ( string[r] == 'e' )
                {
                        statement=1;
                }

                r++;
        }

        if ( statement == 0 )
        {
                r=0;

                if ( string[r] == '-' )
                {
                        neg=-1;
                        r++;
                }

                int stop=0;

                while(string[r] != 0 && stop == 0)
                {
                        if (string[r] == '.')
                        {
                                stop=1;
                        }
                        else
                        {
                                integer*=ggr;
                                integer+=(string[r]-'0');
                                integer*=10;
                        }       
        
                        r++;
                }

                if ( integer != 0 )
                {
                        integer/=10;
                }
        
                if ( stop == 1 )
                {
                        ggr=1;

                        while(string[r] != 0)
                        {
                                float tempDecimal=(float)(string[r]-'0');
                                ggr*=10;
                                tempDecimal/=ggr;
                                decimal+=tempDecimal;

                                r++;
                        }
                }
        
                floatValue=(integer+decimal)*neg;
        }

        return floatValue;
}


//////////////////////////////////////////////////////////////////////////////////////
//converts a String to a int, if that is now possible
//////////////////////////////////////////////////////////////////////////////////////

int Parse::stringToInt(char *string)
{
        int integer=0;
        int statement=0;
        int neg=1;
        int ggr=1;
        int r=0;

        while ( string[r] != 0 && statement == 0 )
        {
                if ( string[r] == 'e' )
                {
                        statement=1;
                }

                r++;
        }

        if ( statement == 0 )
        {
                r=0;

                if ( string[r] == '-' )
                {
                        neg=-1;
                        r++;
                }

                int stop=0;

                while(string[r] != 0 )
                {
                        integer*=ggr;
                        integer+=(string[r]-'0');
                        integer*=10;
        
                        r++;
                }

                if ( integer != 0 )
                {
                        integer/=10;
                }
        }
                
        return integer;
}

1	bearsoft	1.1	#include "Parse.h"
2
3			#include "../System/System.h"
4			#include "../System/SystemDefine.h"
5			#include <math.h>
6			#include "StringTools.h"
7
8			Parse::Parse()
9			{
10			}
11
12			Parse::~Parse()
13			{
14			}
15
16			//////////////////////////////////////////////////////////////////////////////////////
17			//add a Integer String to a Decimal String and returns the result as a char array
18			//////////////////////////////////////////////////////////////////////////////////////
19
20			char Parse::addIntToDecimal(char source, int sourceLength, char dest, int destLength, int totalLength)
21			{
22			int forward=0;
23
24			totalLength[0]=(sourceLength[0]+destLength[0]);
25
26			char intDecimalDest=(char)malloc(totalLength[0]*sizeof(char));
27
28			for ( int s=0 ; s<sourceLength[0] ; s++ )
29			{
30			intDecimalDest[forward]=source[s];
31			forward++;
32			}
33
34			for ( int s2=0 ; s2<(destLength[0]+1) ; s2++ )
35			{
36			intDecimalDest[forward]=dest[s2];
37			forward++;
38			}
39
40			return intDecimalDest;
41			}
42
43			//////////////////////////////////////////////////////////////////////////////////////
44			//converts a int to a String (char buffer)
45			//////////////////////////////////////////////////////////////////////////////////////
46
47			char* Parse::intToString(int integer, int *length)
48			{
49			return intToString(integer, length, false);
50			}
51
52			char* Parse::intToString(int integer, int *length, bool decimalStatement)
53			{
54			char intDest=(char)malloc(12*sizeof(char));
55
56			if ( integer == 0 )
57			{
58			if (decimalStatement)
59			{
60			intDest[0]='-';
61			intDest[1]='0';
62			intDest[2]=0;
63			length[0]=2;
64			}
65			else
66			{
67			intDest[0]='0';
68			intDest[1]=0;
69			length[0]=1;
70			}
71
72			return intDest;
73			}
74
75			int size=9;
76
77			int div=100000000;
78			int forward=0;
79
80			if ( integer < 0 )
81			{
82			integer*=-1;
83			intDest[0]=(char)'-';
84			forward++;
85
86			}
87
88			int start=0;
89
90			for ( int h=0; h<size ; h++ )
91			{
92			int num=integer/div;
93
94			if ( num != 0 )
95			{
96			start=1;
97			}
98
99			intDest[forward]=(char)((int)'0'+num);
100
101			integer-=(num*div);
102			div/=10;
103
104			if ( start == 1)
105			{
106			forward++;
107			}
108			}
109
110			intDest[forward]=0;
111
112			length[0]=forward;
113
114			return intDest;
115			}
116
117			//////////////////////////////////////////////////////////////////////////////////////
118			//converts the decimal part of the float to a String
119			//////////////////////////////////////////////////////////////////////////////////////
120
121			char* Parse::floatToStringDecimal(float source, int *length)
122			{
123			char decimalDest=(char)malloc(7*sizeof(char));
124
125			if ( source == 0 )
126			{
127			decimalDest[0]=0;
128			return decimalDest;
129			}
130
131			int size=4;
132			int div=11010*10;
133
134			source=div10;
135
136			int hdec=(int)floor(source);
137
138			decimalDest[0]='.';
139
140			int forward=1;
141
142			for ( int h=0; h<size ; h++ )
143			{
144			int num=hdec/div;
145
146			decimalDest[forward]=(char)((int)'0'+num);
147
148			hdec-=(num*div);
149			div/=10;
150
151			forward++;
152			}
153
154			decimalDest[forward]=0;
155
156			length[0]=forward;
157
158			return decimalDest;
159			}
160
161			//////////////////////////////////////////////////////////////////////////////////////
162			//converts a float to a String then it returns it
163			//////////////////////////////////////////////////////////////////////////////////////
164
165			char* Parse::floatToString(float source, int *length)
166			{
167			char *intDest=0;
168			int integer=0;
169			float floatSource=0;
170			bool decimalStatement=false;
171			int floatLength[1]={0};
172			int intLength[1]={0};
173
174			if ( source >= 0 )
175			{
176			floatSource=source;
177			integer=(int)floor((double)source);
178			intDest=intToString(integer, intLength);
179			floatSource-=(float)integer;
180			}
181			else
182			{
183			floatSource=source*-1;
184			integer=(int)ceil((double)source);
185			intDest=intToString(integer, intLength, true);
186			floatSource+=(float)integer;
187			}
188
189			char *decimalDest=floatToStringDecimal(floatSource, floatLength);
190			char *intDecimalDest=addIntToDecimal(intDest, intLength, decimalDest, floatLength, length);
191			free(intDest);
192			free(decimalDest);
193			return intDecimalDest;
194			}
195
196			//////////////////////////////////////////////////////////////////////////////////////
197			//converts a String to a float if that is now possible
198			//////////////////////////////////////////////////////////////////////////////////////
199
200			float Parse::stringToFloat(char *string)
201			{
202			float integer=0;
203			float decimal=0;
204			float floatValue=0;
205			int statement=0;
206			int neg=1;
207			float ggr=1;
208			int r=0;
209
210			while ( string[r] != 0 && statement == 0 )
211			{
212			if ( string[r] == 'e' )
213			{
214			statement=1;
215			}
216
217			r++;
218			}
219
220			if ( statement == 0 )
221			{
222			r=0;
223
224			if ( string[r] == '-' )
225			{
226			neg=-1;
227			r++;
228			}
229
230			int stop=0;
231
232			while(string[r] != 0 && stop == 0)
233			{
234			if (string[r] == '.')
235			{
236			stop=1;
237			}
238			else
239			{
240			integer*=ggr;
241			integer+=(string[r]-'0');
242			integer*=10;
243			}
244
245			r++;
246			}
247
248			if ( integer != 0 )
249			{
250			integer/=10;
251			}
252
253			if ( stop == 1 )
254			{
255			ggr=1;
256
257			while(string[r] != 0)
258			{
259			float tempDecimal=(float)(string[r]-'0');
260			ggr*=10;
261			tempDecimal/=ggr;
262			decimal+=tempDecimal;
263
264			r++;
265			}
266			}
267
268			floatValue=(integer+decimal)*neg;
269			}
270
271			return floatValue;
272			}
273
274
275			//////////////////////////////////////////////////////////////////////////////////////
276			//converts a String to a int, if that is now possible
277			//////////////////////////////////////////////////////////////////////////////////////
278
279			int Parse::stringToInt(char *string)
280			{
281			int integer=0;
282			int statement=0;
283			int neg=1;
284			int ggr=1;
285			int r=0;
286
287			while ( string[r] != 0 && statement == 0 )
288			{
289			if ( string[r] == 'e' )
290			{
291			statement=1;
292			}
293
294			r++;
295			}
296
297			if ( statement == 0 )
298			{
299			r=0;
300
301			if ( string[r] == '-' )
302			{
303			neg=-1;
304			r++;
305			}
306
307			int stop=0;
308
309			while(string[r] != 0 )
310			{
311			integer*=ggr;
312			integer+=(string[r]-'0');
313			integer*=10;
314
315			r++;
316			}
317
318			if ( integer != 0 )
319			{
320			integer/=10;
321			}
322			}
323
324			return integer;
325			}
326