Classes/String/StringTools.cpp

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


StringTools::StringTools()
{
}

StringTools::~StringTools()
{
}

//////////////////////////////////////////////////////////////////////////////////////
//compare two Strings against each other, without the null in the end of the Strings
//////////////////////////////////////////////////////////////////////////////////////

bool StringTools::compareString(char *source, char *source2)
{
        bool statement=true;

        if ( source != null && source2 != null )
        {
                int sizeSource=sizeOfString(source);
                int sizeSource2=sizeOfString(source2);

                if( sizeSource == sizeSource2 )
                {
                        for ( int s=0; s<sizeSource ; s++ )
                        {
                                if ( source[s] != source2[s] )
                                {
                                        statement=false;
                                        break;
                                }
                        }
                }
                else
                {
                        statement=false;
                }
        }
        else
        {
                statement=false;
        }

        return statement;
}

//////////////////////////////////////////////////////////////////////////////////////
//compare two Strings against each other, without the null in the end of the Strings
//////////////////////////////////////////////////////////////////////////////////////

bool StringTools::compareString(char *source, int sizeSource, char *source2, int sizeSource2)
{
        bool statement=true;

        if ( source != null && source2 != null )
        {
                if( sizeSource == sizeSource2 )
                {
                        for ( int s=0; s<sizeSource ; s++ )
                        {
                                if ( source[s] != source2[s] )
                                {
                                        statement=false;
                                        break;
                                }
                        }
                }
                else
                {
                        statement=false;
                }
        }
        else
        {
                statement=false;
        }

        return statement;
}

//////////////////////////////////////////////////////////////////////////////////////
//compare two Strings against each other, without the null in the end of the Strings
//////////////////////////////////////////////////////////////////////////////////////

bool StringTools::compareStringAPart(char *source, int sizeSource, char *source2, int sizeSource2)
{
        bool statement=true;

        if ( source != null && source2 != null )
        {
                if ( sizeSource != 0 )
                {
                        --sizeSource;
                }

                if( sizeSource <= sizeSource2 )
                {
                        for ( int s=0; s<sizeSource ; s++ )
                        {
                                if ( source[s] != source2[s] )
                                {
                                        statement=false;
                                        break;
                                }
                        }
                }
                else
                {
                        statement=false;
                }
        }
        else
        {
                statement=false;
        }

        return statement;
}

//////////////////////////////////////////////////////////////////////////////////////
//takes the size of a String include the null in the end
//////////////////////////////////////////////////////////////////////////////////////

int StringTools::sizeOfString(char *source)
{
        int size=0;

        while ( source[size] != 0 )
        {
                size++;
        }

        size++;

        return size;
}

//////////////////////////////////////////////////////////////////////////////////////
//takes the size of a String includes not the null in the end
//////////////////////////////////////////////////////////////////////////////////////

int StringTools::sizeOfStringWithOutEndNull(char *source)
{
        int size=0;

        while ( source[size] != 0 )
        {
                size++;
        }

        return size;
}


//////////////////////////////////////////////////////////////////////////////////////
//takes the size of a String include the null in the end
//////////////////////////////////////////////////////////////////////////////////////

int StringTools::sizeOfString(char *source, char *endSource)
{
        int size=0;

        bool statement=true;

        while (statement)
        {
                if (source < endSource)
                {
                        if (source[0] != 0)
                        {               
                                source++;
                                size++;
                        }
                        else
                        {
                                statement=false;
                        }
                }
                else
                {
                        statement=false;
                }
        }

        size++;

        return size;
}


//////////////////////////////////////////////////////////////////////////////////////
//copy a String to another destination includes the null in the of the String
//////////////////////////////////////////////////////////////////////////////////////

void StringTools::copyString(char *source, char *dest)
{
        int size=sizeOfString(source);

        int s;

        for (  s=0; s<(size-1) ; s++ )
        {
                dest[s]=source[s];
        }

        dest[s]=0;
}

//////////////////////////////////////////////////////////////////////////////////////
//copy a String to another destination includes the null in the of the String
//////////////////////////////////////////////////////////////////////////////////////

void StringTools::copyString(char *source, int sourceSize, char *dest)
{

/*      int size=sourceSize/4;
        int rest=sourceSize%4;

        int *intSource=(int*)source;
        int *intDest=(int*)dest;

        for ( int i=0; i<size ; i++ )
        {
                intDest[0]=intSource[0];
                intDest++;
                intSource++;
        }

        source=(char*)intSource;
        dest=(char*)intDest;

        for (int s=0; s<rest ; s++ )
        {
                dest[0]=source[0];
                dest++;
                source++;
        }
*/

        for (int s=0; s<sourceSize ; s++ )
        {
                dest[0]=source[0];
                dest++;
                source++;
        }

        dest[0]=0;
}


//////////////////////////////////////////////////////////////////////////////////////
//add two Strings together and returns a new String
//////////////////////////////////////////////////////////////////////////////////////

char *StringTools::addStringTwoString(char *source, char *source2)
{
        int forward=0;

        int sourceSize=sizeOfString(source)-1;
        int source2Size=sizeOfString(source2);

        char *buffer=(char*)malloc(sourceSize+source2Size);

        for ( int s=0 ; s<sourceSize ; s++ )
        {
                buffer[forward]=source[s];
                forward++;
        }
        
        for ( int s2=0 ; s2<source2Size ; s2++ )
        {
                buffer[forward]=source2[s2];
                forward++;
        }

        return buffer;
}

//////////////////////////////////////////////////////////////////////////////////////
//add two Strings together and returns a new String
//////////////////////////////////////////////////////////////////////////////////////

char *StringTools::addStringTwoString(char *source, int sourceSize, char *source2, int sourceSize2)
{
        int forward=0;

        sourceSize2++;

        char *buffer=(char*)malloc(sourceSize+sourceSize2);

        for ( int s=0 ; s<sourceSize ; s++ )
        {
                buffer[forward]=source[s];
                forward++;
        }
        
        for ( int s2=0 ; s2<(sourceSize2) ; s2++ )
        {
                buffer[forward]=source2[s2];
                forward++;
        }

        return buffer;
}


//////////////////////////////////////////////////////////////////////////////////////
//compare two Strings against each other, without the null in the end of the Strings
//////////////////////////////////////////////////////////////////////////////////////

bool StringTools::isStringSmaller(char *source, int sourceSize, char *source2, int sourceSize2)
{
        bool statement=true;
        bool equalStatement=true;
        int size=0;

        if (sourceSize<sourceSize2)
        {
                size=sourceSize2;
        }
        else
        {
                size=sourceSize;
        }
        
//      --size;

        for ( int r=0; r<size ; r++ )
        {
                if ( source[r] < source2[r] )
                {
                        statement=false;                        

                        if ( source[r] != source2[r] )
                        {
                                equalStatement=false;
                        }

                        break;
                }
                else
                {
                        if ( source[r] != source2[r] )
                        {
                                equalStatement=false;
                                break;
                        }
                }

                if ( source[r] != source2[r] )
                {
                        equalStatement=false;
                }

        }

        if (equalStatement == true)
        {
                if (sourceSize > sourceSize2 )
                {
                        statement=false;
                }
        }

        return statement;
}

bool StringTools::isStringLarger(char *source, int sourceSize, char *source2, int sourceSize2)
{
        return isStringSmaller(source2, sourceSize2, source, sourceSize);
}


//////////////////////////////////////////////////////////////////////////////////////
//compare two Strings against each other, without the null in the end of the Strings
//////////////////////////////////////////////////////////////////////////////////////

bool StringTools::isStringValueSmaller(char *source, int sourceSize, char *source2, int sourceSize2)
{
        bool statement=true;
        bool equalStatement=true;

        if (sourceSize<sourceSize2)
        {
                return true;
        }

        if (sourceSize>sourceSize2)
        {
                return false;
        }
        
        for ( int r=0; r<sourceSize ; r++ )
        {
                if ( source[r] < source2[r] )
                {
                        return true;
                }
        }

        return false;
}

bool StringTools::isStringValueLarger(char *source, int sourceSize, char *source2, int sourceSize2)
{       
        return isStringValueSmaller(source2, sourceSize2, source, sourceSize);
}

//////////////////////////////////////////////////////////////////////////////////////
//find a chareter , seeking back, returning the position on it
//////////////////////////////////////////////////////////////////////////////////////

int StringTools::backFind(char *source, char target)
{
        int size=sizeOfString(source)-1;
        
        int position=size;

        while ( position >= 0 && source[position] != target )
        {
                --position;     
        }

        return position;
}


//////////////////////////////////////////////////////////////////////////////////////
//it seeks back and when it find the character it is looking for it takes the data that is forward and returns it 
//////////////////////////////////////////////////////////////////////////////////////

char *StringTools::cutTheBack(char * word, int *length, char target)
{
        if (word != null)
        {
                int position=backFind(word,target);

                //cout << position << endl;

                if (position >= 0)
                {
                        char *tempWord=word;
                        word+=position+1;
                        
                        int size=sizeOfStringWithOutEndNull(word);
                        length[0]=size;
                        if (size>0)
                        {
                                char *tempWord2=(char*)malloc(size*sizeof(char)+sizeof(char));
                                copyString(word,tempWord2);
                                word=tempWord2;
                                free(tempWord);
                        }
                        else
                        {
                                free(tempWord);
                                word=null;
                                length[0]=0;
                        }
                }
                else
                {
                        free(word);
                        word=null;
                        length[0]=0;
                }
        }

        return word;
}

char *StringTools::cutTheBegining(char * word, int *length, char target)
{
        if ( word != null )
        {
                int position=backFind(word,target);

                //cout << position << endl;

                if (position >= 0)
                {
                        word[position]=0;
                        length[0]=sizeOfStringWithOutEndNull(word);
                }
                else
                {
                        if(word!=null)
                        {
                                free(word);
                                word=null;
                                length[0]=0;
                        }
                }
        }

        return word;
}

bool StringTools::checkBack(char *file, int fileSize, char *fileFormat, int fileFormatSize)
{
        if ( fileFormatSize <= fileSize)
        {
                fileSize-=fileFormatSize;
                return compareString((file+fileSize), fileFormatSize, fileFormat, fileFormatSize);
        }

        return false;
}


bool StringTools::checkFront(char *file, int fileSize, char *fileFormat, int fileFormatSize)
{
        if ( fileFormatSize <= fileSize)
        {
                return compareString(file, fileFormatSize, fileFormat, fileFormatSize);
        }

        return false;
}

bool StringTools::theFilePathIsNotUnder(char *buffer, int length, char *filePath, int filePathLength)
{
        length++;
        filePathLength++;

        char *tempBuffer=(char*)malloc(length*sizeof(char));
        copyString(buffer,tempBuffer);
        
        char *backPath="/../";
        int backPathSize=5;

        int i=0;

        while(tempBuffer[i]!=0)
        {
                if( tempBuffer[i] == backPath[0] || (tempBuffer[i] == backPath[1] && i == 0))
                {
                        int stepForward=0;

                        if ((tempBuffer[i] == backPath[1] && i == 0))
                        {
                                stepForward=1;
                        }

                        bool correct=true;

                        if ( (i+backPathSize) <= length)
                        {
                                for ( int b=0; b<(backPathSize-1-stepForward) ; b++ )
                                {
                                        if (backPath[b+stepForward] != tempBuffer[i+b])
                                        {
                                                correct=false;
                                                break;
                                        }
                                }
                        }
                        else
                        {
                                correct=false;
                        }

                        if(correct)
                        {
                                int lastPosition=0;
                                int position=i-1;

                                if ( position >= 0 )
                                {
                                        for ( int k=0; k<(i-1) ; k++ )
                                        {
                                                if ( tempBuffer[position] == backPath[0] )
                                                {
                                                        lastPosition=position;
                                                        break;  
                                                }
                                                --position;
                                        }
                                }
                                else
                                {
                                        lastPosition=0;
                                }


                                moveBack(tempBuffer, lastPosition, i+(backPathSize-3-stepForward), length);
                                i=lastPosition-1;

                                if ( i < -1 )
                                {
                                        i=-1;
                                }
                        }

                }
                        i++;
        }


        char *memTemp=tempBuffer;

        if ( tempBuffer[0] == '/' )
        {
                tempBuffer++;
        }

        cout << tempBuffer << endl;

        int tempBufferLength=sizeOfString(tempBuffer);

        bool status=compareStringAPart(filePath, filePathLength,tempBuffer, tempBufferLength);  

        free(memTemp);

        return status; 
}

void StringTools::moveBack(char *tempBuffer, int forward, int howLong, int length)
{
        howLong++;
        int kSize=0;

        if ( howLong < length )
        {
                int k=howLong;

                while ( tempBuffer[k] != 0 )
                {
                        kSize++;
                        k++;
                }
        
                kSize++;

                int l;

                for ( l=0; l<kSize ; l++ )
                {
                        tempBuffer[forward+l]=tempBuffer[l+howLong];
                }
                
                
                kSize+=forward;
                tempBuffer[kSize]=0;
        }
}
1	bearsoft	1.1	#include "StringTools.h"
2			#include "../System/SystemDefine.h"
3			#include <iostream.h>
4
5
6			StringTools::StringTools()
7			{
8			}
9
10			StringTools::~StringTools()
11			{
12			}
13
14			//////////////////////////////////////////////////////////////////////////////////////
15			//compare two Strings against each other, without the null in the end of the Strings
16			//////////////////////////////////////////////////////////////////////////////////////
17
18			bool StringTools::compareString(char source, char source2)
19			{
20			bool statement=true;
21
22			if ( source != null && source2 != null )
23			{
24			int sizeSource=sizeOfString(source);
25			int sizeSource2=sizeOfString(source2);
26
27			if( sizeSource == sizeSource2 )
28			{
29			for ( int s=0; s<sizeSource ; s++ )
30			{
31			if ( source[s] != source2[s] )
32			{
33			statement=false;
34			break;
35			}
36			}
37			}
38			else
39			{
40			statement=false;
41			}
42			}
43			else
44			{
45			statement=false;
46			}
47
48			return statement;
49			}
50
51			//////////////////////////////////////////////////////////////////////////////////////
52			//compare two Strings against each other, without the null in the end of the Strings
53			//////////////////////////////////////////////////////////////////////////////////////
54
55			bool StringTools::compareString(char source, int sizeSource, char source2, int sizeSource2)
56			{
57			bool statement=true;
58
59			if ( source != null && source2 != null )
60			{
61			if( sizeSource == sizeSource2 )
62			{
63			for ( int s=0; s<sizeSource ; s++ )
64			{
65			if ( source[s] != source2[s] )
66			{
67			statement=false;
68			break;
69			}
70			}
71			}
72			else
73			{
74			statement=false;
75			}
76			}
77			else
78			{
79			statement=false;
80			}
81
82			return statement;
83			}
84
85			//////////////////////////////////////////////////////////////////////////////////////
86			//compare two Strings against each other, without the null in the end of the Strings
87			//////////////////////////////////////////////////////////////////////////////////////
88
89			bool StringTools::compareStringAPart(char source, int sizeSource, char source2, int sizeSource2)
90			{
91			bool statement=true;
92
93			if ( source != null && source2 != null )
94			{
95			if ( sizeSource != 0 )
96			{
97			--sizeSource;
98			}
99
100			if( sizeSource <= sizeSource2 )
101			{
102			for ( int s=0; s<sizeSource ; s++ )
103			{
104			if ( source[s] != source2[s] )
105			{
106			statement=false;
107			break;
108			}
109			}
110			}
111			else
112			{
113			statement=false;
114			}
115			}
116			else
117			{
118			statement=false;
119			}
120
121			return statement;
122			}
123
124			//////////////////////////////////////////////////////////////////////////////////////
125			//takes the size of a String include the null in the end
126			//////////////////////////////////////////////////////////////////////////////////////
127
128			int StringTools::sizeOfString(char *source)
129			{
130			int size=0;
131
132			while ( source[size] != 0 )
133			{
134			size++;
135			}
136
137			size++;
138
139			return size;
140			}
141
142			//////////////////////////////////////////////////////////////////////////////////////
143			//takes the size of a String includes not the null in the end
144			//////////////////////////////////////////////////////////////////////////////////////
145
146			int StringTools::sizeOfStringWithOutEndNull(char *source)
147			{
148			int size=0;
149
150			while ( source[size] != 0 )
151			{
152			size++;
153			}
154
155			return size;
156			}
157
158
159			//////////////////////////////////////////////////////////////////////////////////////
160			//takes the size of a String include the null in the end
161			//////////////////////////////////////////////////////////////////////////////////////
162
163			int StringTools::sizeOfString(char source, char endSource)
164			{
165			int size=0;
166
167			bool statement=true;
168
169			while (statement)
170			{
171			if (source < endSource)
172			{
173			if (source[0] != 0)
174			{
175			source++;
176			size++;
177			}
178			else
179			{
180			statement=false;
181			}
182			}
183			else
184			{
185			statement=false;
186			}
187			}
188
189			size++;
190
191			return size;
192			}
193
194
195			//////////////////////////////////////////////////////////////////////////////////////
196			//copy a String to another destination includes the null in the of the String
197			//////////////////////////////////////////////////////////////////////////////////////
198
199			void StringTools::copyString(char source, char dest)
200			{
201			int size=sizeOfString(source);
202
203			int s;
204
205			for ( s=0; s<(size-1) ; s++ )
206			{
207			dest[s]=source[s];
208			}
209
210			dest[s]=0;
211			}
212
213			//////////////////////////////////////////////////////////////////////////////////////
214			//copy a String to another destination includes the null in the of the String
215			//////////////////////////////////////////////////////////////////////////////////////
216
217			void StringTools::copyString(char source, int sourceSize, char dest)
218			{
219
220			/* int size=sourceSize/4;
221			int rest=sourceSize%4;
222
223			int intSource=(int)source;
224			int intDest=(int)dest;
225
226			for ( int i=0; i<size ; i++ )
227			{
228			intDest[0]=intSource[0];
229			intDest++;
230			intSource++;
231			}
232
233			source=(char*)intSource;
234			dest=(char*)intDest;
235
236			for (int s=0; s<rest ; s++ )
237			{
238			dest[0]=source[0];
239			dest++;
240			source++;
241			}
242			*/
243
244			for (int s=0; s<sourceSize ; s++ )
245			{
246			dest[0]=source[0];
247			dest++;
248			source++;
249			}
250
251			dest[0]=0;
252			}
253
254
255
256			//////////////////////////////////////////////////////////////////////////////////////
257			//add two Strings together and returns a new String
258			//////////////////////////////////////////////////////////////////////////////////////
259
260			char StringTools::addStringTwoString(char source, char *source2)
261			{
262			int forward=0;
263
264			int sourceSize=sizeOfString(source)-1;
265			int source2Size=sizeOfString(source2);
266
267			char buffer=(char)malloc(sourceSize+source2Size);
268
269			for ( int s=0 ; s<sourceSize ; s++ )
270			{
271			buffer[forward]=source[s];
272			forward++;
273			}
274
275			for ( int s2=0 ; s2<source2Size ; s2++ )
276			{
277			buffer[forward]=source2[s2];
278			forward++;
279			}
280
281			return buffer;
282			}
283
284			//////////////////////////////////////////////////////////////////////////////////////
285			//add two Strings together and returns a new String
286			//////////////////////////////////////////////////////////////////////////////////////
287
288			char StringTools::addStringTwoString(char source, int sourceSize, char *source2, int sourceSize2)
289			{
290			int forward=0;
291
292			sourceSize2++;
293
294			char buffer=(char)malloc(sourceSize+sourceSize2);
295
296			for ( int s=0 ; s<sourceSize ; s++ )
297			{
298			buffer[forward]=source[s];
299			forward++;
300			}
301
302			for ( int s2=0 ; s2<(sourceSize2) ; s2++ )
303			{
304			buffer[forward]=source2[s2];
305			forward++;
306			}
307
308			return buffer;
309			}
310
311
312			//////////////////////////////////////////////////////////////////////////////////////
313			//compare two Strings against each other, without the null in the end of the Strings
314			//////////////////////////////////////////////////////////////////////////////////////
315
316			bool StringTools::isStringSmaller(char source, int sourceSize, char source2, int sourceSize2)
317			{
318			bool statement=true;
319			bool equalStatement=true;
320			int size=0;
321
322			if (sourceSize<sourceSize2)
323			{
324			size=sourceSize2;
325			}
326			else
327			{
328			size=sourceSize;
329			}
330
331			// --size;
332
333			for ( int r=0; r<size ; r++ )
334			{
335			if ( source[r] < source2[r] )
336			{
337			statement=false;
338
339			if ( source[r] != source2[r] )
340			{
341			equalStatement=false;
342			}
343
344			break;
345			}
346			else
347			{
348			if ( source[r] != source2[r] )
349			{
350			equalStatement=false;
351			break;
352			}
353			}
354
355			if ( source[r] != source2[r] )
356			{
357			equalStatement=false;
358			}
359
360			}
361
362			if (equalStatement == true)
363			{
364			if (sourceSize > sourceSize2 )
365			{
366			statement=false;
367			}
368			}
369
370			return statement;
371			}
372
373			bool StringTools::isStringLarger(char source, int sourceSize, char source2, int sourceSize2)
374			{
375			return isStringSmaller(source2, sourceSize2, source, sourceSize);
376			}
377
378
379			//////////////////////////////////////////////////////////////////////////////////////
380			//compare two Strings against each other, without the null in the end of the Strings
381			//////////////////////////////////////////////////////////////////////////////////////
382
383			bool StringTools::isStringValueSmaller(char source, int sourceSize, char source2, int sourceSize2)
384			{
385			bool statement=true;
386			bool equalStatement=true;
387
388			if (sourceSize<sourceSize2)
389			{
390			return true;
391			}
392
393			if (sourceSize>sourceSize2)
394			{
395			return false;
396			}
397
398			for ( int r=0; r<sourceSize ; r++ )
399			{
400			if ( source[r] < source2[r] )
401			{
402			return true;
403			}
404			}
405
406			return false;
407			}
408
409			bool StringTools::isStringValueLarger(char source, int sourceSize, char source2, int sourceSize2)
410			{
411			return isStringValueSmaller(source2, sourceSize2, source, sourceSize);
412			}
413
414			//////////////////////////////////////////////////////////////////////////////////////
415			//find a chareter , seeking back, returning the position on it
416			//////////////////////////////////////////////////////////////////////////////////////
417
418			int StringTools::backFind(char *source, char target)
419			{
420			int size=sizeOfString(source)-1;
421
422			int position=size;
423
424			while ( position >= 0 && source[position] != target )
425			{
426			--position;
427			}
428
429			return position;
430			}
431
432
433			//////////////////////////////////////////////////////////////////////////////////////
434			//it seeks back and when it find the character it is looking for it takes the data that is forward and returns it
435			//////////////////////////////////////////////////////////////////////////////////////
436
437			char StringTools::cutTheBack(char word, int *length, char target)
438			{
439			if (word != null)
440			{
441			int position=backFind(word,target);
442
443			//cout << position << endl;
444
445			if (position >= 0)
446			{
447			char *tempWord=word;
448			word+=position+1;
449
450			int size=sizeOfStringWithOutEndNull(word);
451			length[0]=size;
452			if (size>0)
453			{
454			char tempWord2=(char)malloc(size*sizeof(char)+sizeof(char));
455			copyString(word,tempWord2);
456			word=tempWord2;
457			free(tempWord);
458			}
459			else
460			{
461			free(tempWord);
462			word=null;
463			length[0]=0;
464			}
465			}
466			else
467			{
468			free(word);
469			word=null;
470			length[0]=0;
471			}
472			}
473
474			return word;
475			}
476
477			char StringTools::cutTheBegining(char word, int *length, char target)
478			{
479			if ( word != null )
480			{
481			int position=backFind(word,target);
482
483			//cout << position << endl;
484
485			if (position >= 0)
486			{
487			word[position]=0;
488			length[0]=sizeOfStringWithOutEndNull(word);
489			}
490			else
491			{
492			if(word!=null)
493			{
494			free(word);
495			word=null;
496			length[0]=0;
497			}
498			}
499			}
500
501			return word;
502			}
503
504			bool StringTools::checkBack(char file, int fileSize, char fileFormat, int fileFormatSize)
505			{
506			if ( fileFormatSize <= fileSize)
507			{
508			fileSize-=fileFormatSize;
509			return compareString((file+fileSize), fileFormatSize, fileFormat, fileFormatSize);
510			}
511
512			return false;
513			}
514
515
516			bool StringTools::checkFront(char file, int fileSize, char fileFormat, int fileFormatSize)
517			{
518			if ( fileFormatSize <= fileSize)
519			{
520			return compareString(file, fileFormatSize, fileFormat, fileFormatSize);
521			}
522
523			return false;
524			}
525
526			bool StringTools::theFilePathIsNotUnder(char buffer, int length, char filePath, int filePathLength)
527			{
528			length++;
529			filePathLength++;
530
531			char tempBuffer=(char)malloc(length*sizeof(char));
532			copyString(buffer,tempBuffer);
533
534			char *backPath="/../";
535			int backPathSize=5;
536
537			int i=0;
538
539			while(tempBuffer[i]!=0)
540			{
541			if( tempBuffer[i] == backPath[0] \|\| (tempBuffer[i] == backPath[1] && i == 0))
542			{
543			int stepForward=0;
544
545			if ((tempBuffer[i] == backPath[1] && i == 0))
546			{
547			stepForward=1;
548			}
549
550			bool correct=true;
551
552			if ( (i+backPathSize) <= length)
553			{
554			for ( int b=0; b<(backPathSize-1-stepForward) ; b++ )
555			{
556			if (backPath[b+stepForward] != tempBuffer[i+b])
557			{
558			correct=false;
559			break;
560			}
561			}
562			}
563			else
564			{
565			correct=false;
566			}
567
568			if(correct)
569			{
570			int lastPosition=0;
571			int position=i-1;
572
573			if ( position >= 0 )
574			{
575			for ( int k=0; k<(i-1) ; k++ )
576			{
577			if ( tempBuffer[position] == backPath[0] )
578			{
579			lastPosition=position;
580			break;
581			}
582			--position;
583			}
584			}
585			else
586			{
587			lastPosition=0;
588			}
589
590
591			moveBack(tempBuffer, lastPosition, i+(backPathSize-3-stepForward), length);
592			i=lastPosition-1;
593
594			if ( i < -1 )
595			{
596			i=-1;
597			}
598			}
599
600			}
601			i++;
602			}
603
604
605			char *memTemp=tempBuffer;
606
607			if ( tempBuffer[0] == '/' )
608			{
609			tempBuffer++;
610			}
611
612			cout << tempBuffer << endl;
613
614			int tempBufferLength=sizeOfString(tempBuffer);
615
616			bool status=compareStringAPart(filePath, filePathLength,tempBuffer, tempBufferLength);
617
618			free(memTemp);
619
620			return status;
621			}
622
623			void StringTools::moveBack(char *tempBuffer, int forward, int howLong, int length)
624			{
625			howLong++;
626			int kSize=0;
627
628			if ( howLong < length )
629			{
630			int k=howLong;
631
632			while ( tempBuffer[k] != 0 )
633			{
634			kSize++;
635			k++;
636			}
637
638			kSize++;
639
640			int l;
641
642			for ( l=0; l<kSize ; l++ )
643			{
644			tempBuffer[forward+l]=tempBuffer[l+howLong];
645			}
646
647
648			kSize+=forward;
649			tempBuffer[kSize]=0;
650			}
651			}