Classes/String/StringInput.cpp

#include "StringInput.h"
#include "../Files/FileTools.h"
#include "String.h"

//defaultValue is how many endTargetPointers,floatBuffer places their are reserved for

StringInput::StringInput()
{
        defaultValue=20;
        internBuffer=0;
        sourceBuffer=0;
        endBuffer=0;
        wordBuffer=0;
        endTargetPointers=(int*)malloc((sizeof(int))*defaultValue);
        endTargetPointers[0]=0;
        fileSize=0;
        defragMemory=1;
        floatBuffer=0;
        scanWordStatus=true;
        cutAndPasteBuffer=0;
        scanRowStatus=false;
        nextRowPosition=0;
        rowNumber=1;
        stringTools=new StringTools();
}

StringInput::~StringInput()
{
        if (internBuffer != 0 )
        {
                free(internBuffer);
                internBuffer=0;
        }

        if (wordBuffer != 0 )
        {
                free(wordBuffer);
                wordBuffer=0;
        }

        if (endTargetPointers != 0)
        {
                free(endTargetPointers);
                endTargetPointers=0;
        }

        if (floatBuffer != 0)
        {
                free(floatBuffer);
                floatBuffer=0;
        }

        if (cutAndPasteBuffer != 0)
        {
                free(cutAndPasteBuffer);
                floatBuffer=0;
        }

        if (stringTools!=null)
        {
                delete stringTools;
        }
}


// internBuffer=the start of the ascii buffer
// sourceBuffer=where the pointer is in the internBuffer
// endBuffer=the end of the internBuffer

//////////////////////////////////////////////////////////////////////////////////////
//read a ascii file
//////////////////////////////////////////////////////////////////////////////////////

void StringInput::readFile(char *filename)  
{
        if ( internBuffer != 0 )
        {
                free(internBuffer);
                internBuffer=0;
        }

        int fileBuffer=0;

        FileTools fileTools;

        fileStatus=fileTools.readStringFile(filename,&fileBuffer,&fileSize);

        internBuffer=(char*)fileBuffer;
        sourceBuffer=(char*)internBuffer;
        endBuffer=(char*)internBuffer;
        endBuffer+=fileSize;
        reserveWordBufferMemory();
        scanWordStatus=true;
        nextRowPosition=sourceBuffer;
        rowNumber=1;
        scanRowStatus=false;
}

int StringInput::getFileStatus()
{
        return fileStatus;
}

//////////////////////////////////////////////////////////////////////////////////////
//can i read more words??
//////////////////////////////////////////////////////////////////////////////////////

bool StringInput::getScanWordStatus()
{
        return scanWordStatus;
}

//////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////

bool StringInput::getScanEndFindWordStatus()
{
        return scanEndFindWordStatus;
}

//////////////////////////////////////////////////////////////////////////////////////
//is this the end of the row??
//////////////////////////////////////////////////////////////////////////////////////

bool StringInput::getScanRowStatus()
{
        bool tempScanRowStatus=scanRowStatus;

        if ( internBuffer != nextRowPosition )
        {
                if (scanRowStatus)
                {
                        sourceBuffer=nextRowPosition;
                        scanRowStatus=false;
                }
        }
        
        return tempScanRowStatus;
}

//////////////////////////////////////////////////////////////////////////////////////
//What for rowNumber are you on
//////////////////////////////////////////////////////////////////////////////////////

int StringInput::getRowNumber()
{
        return rowNumber;
}

//////////////////////////////////////////////////////////////////////////////////////
//set a String to the InternBuffer
//////////////////////////////////////////////////////////////////////////////////////

void StringInput::setInternBuffer(char *iInternBuffer)
{
        if (iInternBuffer != null)
        {
                if (internBuffer != null) 
                {
                        free(internBuffer);
                        internBuffer=0;
                }

                internBuffer=iInternBuffer;     
                fileSize=stringTools->sizeOfString(internBuffer);
                sourceBuffer=(char*)internBuffer;
                endBuffer=(char*)internBuffer;
                endBuffer+=fileSize;
                reserveWordBufferMemory();
                scanWordStatus=true;
                nextRowPosition=sourceBuffer;
                rowNumber=1;
                scanRowStatus=false;
        }
}

//////////////////////////////////////////////////////////////////////////////////////
//takes the start address from the internBuffer and copy its to the sourcebuffer pointer
//////////////////////////////////////////////////////////////////////////////////////

void StringInput::resetScanWord()
{
        sourceBuffer=internBuffer;
        rowNumber=1;
        nextRowPosition=internBuffer;
        scanRowStatus=false;
        scanWordStatus=true;
}

//////////////////////////////////////////////////////////////////////////////////////
//dont defrag memory, input the buffer size where you can store the word, when you are shure how large words their can be
//////////////////////////////////////////////////////////////////////////////////////

void StringInput::dontDefragMemory(int wordBufferSize)
{
        if (wordBuffer!=0)
        {
                free(wordBuffer);
                wordBuffer=0;
        }

        wordBuffer=(char*)malloc(wordBufferSize);
        defragMemory=0;
}

//////////////////////////////////////////////////////////////////////////////////////
//reserve WordBuffer Memory
//////////////////////////////////////////////////////////////////////////////////////

void StringInput::reserveWordBufferMemory()
{
        if (defragMemory==0)
        {
                if (wordBuffer!=0)
                {
                        free(wordBuffer);
                        wordBuffer=0;
                }
                                
                wordBuffer=(char*)malloc(fileSize);
        }
}

//////////////////////////////////////////////////////////////////////////////////////
//dont defrag memory, input the buffer size where you can store the word, when you are not shure how large words their can be
//////////////////////////////////////////////////////////////////////////////////////

void StringInput::dontDefragMemory()
{
        if ( internBuffer != 0 )
        {
                defragMemory=0;
                reserveWordBufferMemory();
        }
}

//////////////////////////////////////////////////////////////////////////////////////
//takes the size of a pointerlist
//////////////////////////////////////////////////////////////////////////////////////

int StringInput::sizeOfPointerList(int* pointerList)
{
        int size=0;

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

//////////////////////////////////////////////////////////////////////////////////////
//copy in endtargetpointers
//////////////////////////////////////////////////////////////////////////////////////

int *StringInput::getEndTargetPointers()
{
        return endTargetPointers;
}

//////////////////////////////////////////////////////////////////////////////////////
//clear endtargetpointers
//////////////////////////////////////////////////////////////////////////////////////

void StringInput::resetEndTargetPointers()
{
        endTargetPointers[0]=0;
}

//////////////////////////////////////////////////////////////////////////////////////
//seeks after next ascii character that not is a space in the internBuffer
//////////////////////////////////////////////////////////////////////////////////////

void StringInput::skipSpace()
{
        scanRowStatus=false;
        int forward=0;
        int sizeToEnd=endBuffer-sourceBuffer;

        while (forward < sizeToEnd)
        {
                if (sourceBuffer[0] == 13)
                {
                        sourceBuffer++;
                        scanRowStatus=true;
                        nextRowPosition=sourceBuffer;
                        rowNumber++;
                }
                else
                {
                        if( (sourceBuffer[0] == (' ')) || (sourceBuffer[0] == 10) )
                        {
                                sourceBuffer++;
                        }
                        else
                        {
                                forward=sizeToEnd;
                        }
                }

                forward++;
    }
}

//////////////////////////////////////////////////////////////////////////////////////
//looking for next space in the ascii buffer (internBuffer)
//////////////////////////////////////////////////////////////////////////////////////

int StringInput::nextSpace()
{
        int size=0;
        char *tempSourceBuffer=sourceBuffer; 
        int forward=0;
        int sizeToEnd=endBuffer-sourceBuffer;

        while (forward < sizeToEnd)
        {
                if( (tempSourceBuffer[0] != (' ')) && (tempSourceBuffer[0] != 10)  && (tempSourceBuffer[0] != 13) && (sourceBuffer[0] != 0) )
                {
                        tempSourceBuffer++;
                        size++;
                }
            else
            {
                        forward=sizeToEnd;
            }
        
                forward++;
        }
        
        return size;
}

//////////////////////////////////////////////////////////////////////////////////////
//reads from the internBuffer to another buffer, so long their is no space
//////////////////////////////////////////////////////////////////////////////////////

void StringInput::readToNextSpace(char *destBuffer)
{
        scanRowStatus=false;
        int forward=0;
        int sizeToEnd=endBuffer-sourceBuffer;

        while (forward < sizeToEnd)
        {
                if( (sourceBuffer[0] != (' ')) && (sourceBuffer[0] != 10) && (sourceBuffer[0] != 13) )
                {
                        destBuffer[0]=sourceBuffer[0];
                        sourceBuffer++;
                        destBuffer++;
                }
                else
                {
                        forward=sizeToEnd;
                }
        
                forward++;
        }

        if(     sourceBuffer[0] == 13 )
        {
                nextRowPosition=sourceBuffer+1;
                scanRowStatus=true;
                rowNumber++;
        }
        
}

//////////////////////////////////////////////////////////////////////////////////////
//seeks after a word then it return it, like "nisse" 
//////////////////////////////////////////////////////////////////////////////////////

char *StringInput::scanWord()
{
        scanWordStatus=false;
        char *tBuffer=0;

        if (internBuffer != 0)
        {
                int onetime=0;
                int sp=0;

                if ( sourceBuffer == internBuffer )
                {
                        if ( sourceBuffer[0] != ' ' )
                        {
                                onetime=1;      
                        }
                }

                if ( onetime == 0 && sourceBuffer != endBuffer )
                {
                        skipSpace();
                }       

                if ( sourceBuffer != endBuffer )
                {
                        scanWordStatus=true;
                        
                        int fSize=nextSpace();
                        fSize+=1;
        
                        if ( defragMemory == 0 )
                        {
                                tBuffer=wordBuffer;
                        }
                        else
                        {
                                if (wordBuffer!=0)
                                {
                                        free(wordBuffer);
                                        wordBuffer=0;
                                }
        
                                wordBuffer=(char*)malloc(sizeof(char)*fSize);
                                tBuffer=wordBuffer;
                        }
                
                        readToNextSpace(tBuffer);
                        tBuffer[fSize-1]=0;
                }
        }               

        return tBuffer;
}


//////////////////////////////////////////////////////////////////////////////////////
//scan words in the internBuffer until it find it , of it does not find it, it returns null(0)
//////////////////////////////////////////////////////////////////////////////////////

bool StringInput::findWord(char* word)
{
        char *tBuffer=0;
        bool statement=false;
        bool end=true;
        scanEndFindWordStatus=false;

        if ( sourceBuffer != endBuffer )
        {       
                while (end)
                {
                        tBuffer=scanWord();

                        if ( tBuffer != 0 )
                        {
                                int e=0;

                                while (endTargetPointers[e] != 0 && end == true)
                                {
                                        if (stringTools->compareString(tBuffer,(char*)endTargetPointers[e]))
                                        {
                                                scanEndFindWordStatus=true;
                                                statement=true;
                                                end=false;
                                        }
                                        
                                        e++;
                                }       

                                if (end)
                                {
                                        if (stringTools->compareString(tBuffer,word))
                                        {
                                                statement=true;
                                                end=false;
                                        }
                                }
                        }
                        else
                        {
                                end=false;
                        }
                }
        }
        
        return statement;
}

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

char *StringInput::findWordAndCutTheBack(char * word)
{
        char *lBuffer=0;

        if (findWord(word))
        {
                char *tBuffer=scanWord();
                int position=stringTools->backFind(tBuffer,92);
                lBuffer=tBuffer+position+1;
        }

        return lBuffer;
}

//////////////////////////////////////////////////////////////////////////////////////
//it seeks back and when it find the character it is looking for it takes the data that is forward and returns it 
//then it take the returned String data and add it together with another String data that it returns
//////////////////////////////////////////////////////////////////////////////////////

char *StringInput::cutTheBackMergeStrings(char * word, char *target)
{
        char *uBuffer=0;

        char *tBuffer=findWordAndCutTheBack(word);

        if ( tBuffer != 0 )
        {
                if (cutAndPasteBuffer!=0)
                {
                        free(cutAndPasteBuffer);
                        cutAndPasteBuffer=0;
                }

                cutAndPasteBuffer=stringTools->addStringTwoString(target,tBuffer);
                uBuffer=cutAndPasteBuffer;
        }

        return uBuffer;
}

//////////////////////////////////////////////////////////////////////////////////////
//scanwords a number of times that is selected  
//////////////////////////////////////////////////////////////////////////////////////

bool StringInput::scanWordForwardLoop(int numberOfTimes)
{
        bool statement=true;
        int r=0;
        char* tBuffer=0;

        while ( r<numberOfTimes && statement == true )
        {
                tBuffer=scanWord();

                if ( tBuffer != 0)
                {
                        if (defragMemory!=0)
                        {
                                free(tBuffer);
                                tBuffer=0;
                        }
                }
                else
                {
                        statement=false;
                }

                r++;
        }

        return statement;
}


//////////////////////////////////////////////////////////////////////////////////////
//it looks for a word when it finds it , it takes the specified number of float data after the word and returns it 
//if it finds a specified word that you have specified , it returns -1 (endtargert,endtarger2)
//////////////////////////////////////////////////////////////////////////////////////

float *StringInput::findWordReturnFloats(char * word, int howManyScanForward, int numberOfFloats)
{
        if ( floatBuffer != 0 )
        {
                free(floatBuffer);
                floatBuffer=0;
        }
        
        bool statement=findWord(word);

        if ( statement == true && scanEndFindWordStatus == false )
        {
                bool statement=scanWordForwardLoop(howManyScanForward);
                        
                if (statement)
                {       
                        char *tBuffer=scanWord();
                        String tTemp=tBuffer;
                        int number=tTemp.toInt();

                        int totalNumberOfFloats=(5+(numberOfFloats*3));
                        floatBuffer=(float*)malloc((sizeof(float)*totalNumberOfFloats)*number+sizeof(float));

                        floatBuffer[0]=(float)number;

                        for ( int n=0; n<number ; n++ )
                        {
                                for ( int n2=0; n2<totalNumberOfFloats ; n2++ )
                                {
                                        tBuffer=scanWord();

                                        if ( tBuffer != 0)
                                        {
                                                String tTemp=tBuffer;
                                                float fNumber=tTemp.toFloat();
                                                floatBuffer[1+n2+n*totalNumberOfFloats]=fNumber;

                                        }
                                }                                       
                        }
                }
        }

        return floatBuffer;
}


//////////////////////////////////////////////////////////////////////////////////////
//it looks for a word when it finds it , it takes the specified number of float data after the word and returns it 
//if it finds a specified word that you have specified , it returns -1 (endtargert,endtarger2)
//a special 
//////////////////////////////////////////////////////////////////////////////////////

float *StringInput::findAWordReturnFloats( char *word, int numberOf, float falseValue, int option) 
{
        if ( floatBuffer != 0 )
        {
                free(floatBuffer);
                floatBuffer=0;
        }

        bool statement=findWord(word);

        if ( statement == true && scanEndFindWordStatus == true )
        {
                if ( option != 2 )
                {
                        floatBuffer=(float*)malloc(sizeof(float)*numberOf);

                        for ( int r=0; r<numberOf; r++ )
                        {
                                floatBuffer[r]=falseValue;
                        }       
                }
    }
        else
        {               
                if ( statement == true  && scanEndFindWordStatus == false )
                {
                        floatBuffer=(float*)malloc(sizeof(float)*numberOf);

                        for ( int r=0; r<numberOf; r++ )
                        {
                                char *fBuffer=scanWord();
                                String fTemp=fBuffer;
                                floatBuffer[r]=fTemp.toFloat();

                                if (defragMemory!=0)
                                {
                                        free(fBuffer);
                                        fBuffer=0;
                                }
                        }

                        if ( ((char*)endTargetPointers[0]) != 0 && option == 1 )
                        {
                                bool statement=findWord((char*)endTargetPointers[0]);
                        }
                }
        }
                
        return floatBuffer;
}


bool StringInput::socketGetHttp(int socket)
{
        NetWorkTools netWorkTools;
        char *tempBuffer=netWorkTools.recieveHttpData(socket);
        setInternBuffer(tempBuffer);

        if (tempBuffer!=null)
        {
                return true;
        }

        return false;
}

char *StringInput::getInternBuffer()
{
        return internBuffer;
}
1	bearsoft	1.1	#include "StringInput.h"
2			#include "../Files/FileTools.h"
3			#include "String.h"
4
5			//defaultValue is how many endTargetPointers,floatBuffer places their are reserved for
6
7			StringInput::StringInput()
8			{
9			defaultValue=20;
10			internBuffer=0;
11			sourceBuffer=0;
12			endBuffer=0;
13			wordBuffer=0;
14			endTargetPointers=(int)malloc((sizeof(int))defaultValue);
15			endTargetPointers[0]=0;
16			fileSize=0;
17			defragMemory=1;
18			floatBuffer=0;
19			scanWordStatus=true;
20			cutAndPasteBuffer=0;
21			scanRowStatus=false;
22			nextRowPosition=0;
23			rowNumber=1;
24			stringTools=new StringTools();
25			}
26
27			StringInput::~StringInput()
28			{
29			if (internBuffer != 0 )
30			{
31			free(internBuffer);
32			internBuffer=0;
33			}
34
35			if (wordBuffer != 0 )
36			{
37			free(wordBuffer);
38			wordBuffer=0;
39			}
40
41			if (endTargetPointers != 0)
42			{
43			free(endTargetPointers);
44			endTargetPointers=0;
45			}
46
47			if (floatBuffer != 0)
48			{
49			free(floatBuffer);
50			floatBuffer=0;
51			}
52
53			if (cutAndPasteBuffer != 0)
54			{
55			free(cutAndPasteBuffer);
56			floatBuffer=0;
57			}
58
59			if (stringTools!=null)
60			{
61			delete stringTools;
62			}
63			}
64
65
66			// internBuffer=the start of the ascii buffer
67			// sourceBuffer=where the pointer is in the internBuffer
68			// endBuffer=the end of the internBuffer
69
70			//////////////////////////////////////////////////////////////////////////////////////
71			//read a ascii file
72			//////////////////////////////////////////////////////////////////////////////////////
73
74			void StringInput::readFile(char *filename)
75			{
76			if ( internBuffer != 0 )
77			{
78			free(internBuffer);
79			internBuffer=0;
80			}
81
82			int fileBuffer=0;
83
84			FileTools fileTools;
85
86			fileStatus=fileTools.readStringFile(filename,&fileBuffer,&fileSize);
87
88			internBuffer=(char*)fileBuffer;
89			sourceBuffer=(char*)internBuffer;
90			endBuffer=(char*)internBuffer;
91			endBuffer+=fileSize;
92			reserveWordBufferMemory();
93			scanWordStatus=true;
94			nextRowPosition=sourceBuffer;
95			rowNumber=1;
96			scanRowStatus=false;
97			}
98
99			int StringInput::getFileStatus()
100			{
101			return fileStatus;
102			}
103
104			//////////////////////////////////////////////////////////////////////////////////////
105			//can i read more words??
106			//////////////////////////////////////////////////////////////////////////////////////
107
108			bool StringInput::getScanWordStatus()
109			{
110			return scanWordStatus;
111			}
112
113			//////////////////////////////////////////////////////////////////////////////////////
114			//
115			//////////////////////////////////////////////////////////////////////////////////////
116
117			bool StringInput::getScanEndFindWordStatus()
118			{
119			return scanEndFindWordStatus;
120			}
121
122			//////////////////////////////////////////////////////////////////////////////////////
123			//is this the end of the row??
124			//////////////////////////////////////////////////////////////////////////////////////
125
126			bool StringInput::getScanRowStatus()
127			{
128			bool tempScanRowStatus=scanRowStatus;
129
130			if ( internBuffer != nextRowPosition )
131			{
132			if (scanRowStatus)
133			{
134			sourceBuffer=nextRowPosition;
135			scanRowStatus=false;
136			}
137			}
138
139			return tempScanRowStatus;
140			}
141
142			//////////////////////////////////////////////////////////////////////////////////////
143			//What for rowNumber are you on
144			//////////////////////////////////////////////////////////////////////////////////////
145
146			int StringInput::getRowNumber()
147			{
148			return rowNumber;
149			}
150
151			//////////////////////////////////////////////////////////////////////////////////////
152			//set a String to the InternBuffer
153			//////////////////////////////////////////////////////////////////////////////////////
154
155			void StringInput::setInternBuffer(char *iInternBuffer)
156			{
157			if (iInternBuffer != null)
158			{
159			if (internBuffer != null)
160			{
161			free(internBuffer);
162			internBuffer=0;
163			}
164
165			internBuffer=iInternBuffer;
166			fileSize=stringTools->sizeOfString(internBuffer);
167			sourceBuffer=(char*)internBuffer;
168			endBuffer=(char*)internBuffer;
169			endBuffer+=fileSize;
170			reserveWordBufferMemory();
171			scanWordStatus=true;
172			nextRowPosition=sourceBuffer;
173			rowNumber=1;
174			scanRowStatus=false;
175			}
176			}
177
178			//////////////////////////////////////////////////////////////////////////////////////
179			//takes the start address from the internBuffer and copy its to the sourcebuffer pointer
180			//////////////////////////////////////////////////////////////////////////////////////
181
182			void StringInput::resetScanWord()
183			{
184			sourceBuffer=internBuffer;
185			rowNumber=1;
186			nextRowPosition=internBuffer;
187			scanRowStatus=false;
188			scanWordStatus=true;
189			}
190
191			//////////////////////////////////////////////////////////////////////////////////////
192			//dont defrag memory, input the buffer size where you can store the word, when you are shure how large words their can be
193			//////////////////////////////////////////////////////////////////////////////////////
194
195			void StringInput::dontDefragMemory(int wordBufferSize)
196			{
197			if (wordBuffer!=0)
198			{
199			free(wordBuffer);
200			wordBuffer=0;
201			}
202
203			wordBuffer=(char*)malloc(wordBufferSize);
204			defragMemory=0;
205			}
206
207			//////////////////////////////////////////////////////////////////////////////////////
208			//reserve WordBuffer Memory
209			//////////////////////////////////////////////////////////////////////////////////////
210
211			void StringInput::reserveWordBufferMemory()
212			{
213			if (defragMemory==0)
214			{
215			if (wordBuffer!=0)
216			{
217			free(wordBuffer);
218			wordBuffer=0;
219			}
220
221			wordBuffer=(char*)malloc(fileSize);
222			}
223			}
224
225			//////////////////////////////////////////////////////////////////////////////////////
226			//dont defrag memory, input the buffer size where you can store the word, when you are not shure how large words their can be
227			//////////////////////////////////////////////////////////////////////////////////////
228
229			void StringInput::dontDefragMemory()
230			{
231			if ( internBuffer != 0 )
232			{
233			defragMemory=0;
234			reserveWordBufferMemory();
235			}
236			}
237
238			//////////////////////////////////////////////////////////////////////////////////////
239			//takes the size of a pointerlist
240			//////////////////////////////////////////////////////////////////////////////////////
241
242			int StringInput::sizeOfPointerList(int* pointerList)
243			{
244			int size=0;
245
246			while( pointerList[size] != 0 )
247			{
248			size++;
249			}
250
251			size++;
252
253			return size;
254			}
255
256			//////////////////////////////////////////////////////////////////////////////////////
257			//copy in endtargetpointers
258			//////////////////////////////////////////////////////////////////////////////////////
259
260			int *StringInput::getEndTargetPointers()
261			{
262			return endTargetPointers;
263			}
264
265			//////////////////////////////////////////////////////////////////////////////////////
266			//clear endtargetpointers
267			//////////////////////////////////////////////////////////////////////////////////////
268
269			void StringInput::resetEndTargetPointers()
270			{
271			endTargetPointers[0]=0;
272			}
273
274			//////////////////////////////////////////////////////////////////////////////////////
275			//seeks after next ascii character that not is a space in the internBuffer
276			//////////////////////////////////////////////////////////////////////////////////////
277
278			void StringInput::skipSpace()
279			{
280			scanRowStatus=false;
281			int forward=0;
282			int sizeToEnd=endBuffer-sourceBuffer;
283
284			while (forward < sizeToEnd)
285			{
286			if (sourceBuffer[0] == 13)
287			{
288			sourceBuffer++;
289			scanRowStatus=true;
290			nextRowPosition=sourceBuffer;
291			rowNumber++;
292			}
293			else
294			{
295			if( (sourceBuffer[0] == (' ')) \|\| (sourceBuffer[0] == 10) )
296			{
297			sourceBuffer++;
298			}
299			else
300			{
301			forward=sizeToEnd;
302			}
303			}
304
305			forward++;
306			}
307			}
308
309			//////////////////////////////////////////////////////////////////////////////////////
310			//looking for next space in the ascii buffer (internBuffer)
311			//////////////////////////////////////////////////////////////////////////////////////
312
313			int StringInput::nextSpace()
314			{
315			int size=0;
316			char *tempSourceBuffer=sourceBuffer;
317			int forward=0;
318			int sizeToEnd=endBuffer-sourceBuffer;
319
320			while (forward < sizeToEnd)
321			{
322			if( (tempSourceBuffer[0] != (' ')) && (tempSourceBuffer[0] != 10) && (tempSourceBuffer[0] != 13) && (sourceBuffer[0] != 0) )
323			{
324			tempSourceBuffer++;
325			size++;
326			}
327			else
328			{
329			forward=sizeToEnd;
330			}
331
332			forward++;
333			}
334
335			return size;
336			}
337
338			//////////////////////////////////////////////////////////////////////////////////////
339			//reads from the internBuffer to another buffer, so long their is no space
340			//////////////////////////////////////////////////////////////////////////////////////
341
342			void StringInput::readToNextSpace(char *destBuffer)
343			{
344			scanRowStatus=false;
345			int forward=0;
346			int sizeToEnd=endBuffer-sourceBuffer;
347
348			while (forward < sizeToEnd)
349			{
350			if( (sourceBuffer[0] != (' ')) && (sourceBuffer[0] != 10) && (sourceBuffer[0] != 13) )
351			{
352			destBuffer[0]=sourceBuffer[0];
353			sourceBuffer++;
354			destBuffer++;
355			}
356			else
357			{
358			forward=sizeToEnd;
359			}
360
361			forward++;
362			}
363
364			if( sourceBuffer[0] == 13 )
365			{
366			nextRowPosition=sourceBuffer+1;
367			scanRowStatus=true;
368			rowNumber++;
369			}
370
371			}
372
373			//////////////////////////////////////////////////////////////////////////////////////
374			//seeks after a word then it return it, like "nisse"
375			//////////////////////////////////////////////////////////////////////////////////////
376
377			char *StringInput::scanWord()
378			{
379			scanWordStatus=false;
380			char *tBuffer=0;
381
382			if (internBuffer != 0)
383			{
384			int onetime=0;
385			int sp=0;
386
387			if ( sourceBuffer == internBuffer )
388			{
389			if ( sourceBuffer[0] != ' ' )
390			{
391			onetime=1;
392			}
393			}
394
395			if ( onetime == 0 && sourceBuffer != endBuffer )
396			{
397			skipSpace();
398			}
399
400			if ( sourceBuffer != endBuffer )
401			{
402			scanWordStatus=true;
403
404			int fSize=nextSpace();
405			fSize+=1;
406
407			if ( defragMemory == 0 )
408			{
409			tBuffer=wordBuffer;
410			}
411			else
412			{
413			if (wordBuffer!=0)
414			{
415			free(wordBuffer);
416			wordBuffer=0;
417			}
418
419			wordBuffer=(char)malloc(sizeof(char)fSize);
420			tBuffer=wordBuffer;
421			}
422
423			readToNextSpace(tBuffer);
424			tBuffer[fSize-1]=0;
425			}
426			}
427
428			return tBuffer;
429			}
430
431
432			//////////////////////////////////////////////////////////////////////////////////////
433			//scan words in the internBuffer until it find it , of it does not find it, it returns null(0)
434			//////////////////////////////////////////////////////////////////////////////////////
435
436			bool StringInput::findWord(char* word)
437			{
438			char *tBuffer=0;
439			bool statement=false;
440			bool end=true;
441			scanEndFindWordStatus=false;
442
443			if ( sourceBuffer != endBuffer )
444			{
445			while (end)
446			{
447			tBuffer=scanWord();
448
449			if ( tBuffer != 0 )
450			{
451			int e=0;
452
453			while (endTargetPointers[e] != 0 && end == true)
454			{
455			if (stringTools->compareString(tBuffer,(char*)endTargetPointers[e]))
456			{
457			scanEndFindWordStatus=true;
458			statement=true;
459			end=false;
460			}
461
462			e++;
463			}
464
465			if (end)
466			{
467			if (stringTools->compareString(tBuffer,word))
468			{
469			statement=true;
470			end=false;
471			}
472			}
473			}
474			else
475			{
476			end=false;
477			}
478			}
479			}
480
481			return statement;
482			}
483
484			//////////////////////////////////////////////////////////////////////////////////////
485			//it seeks back and when it find the character it is looking for it takes the data that is forward and returns it
486			//////////////////////////////////////////////////////////////////////////////////////
487
488			char StringInput::findWordAndCutTheBack(char word)
489			{
490			char *lBuffer=0;
491
492			if (findWord(word))
493			{
494			char *tBuffer=scanWord();
495			int position=stringTools->backFind(tBuffer,92);
496			lBuffer=tBuffer+position+1;
497			}
498
499			return lBuffer;
500			}
501
502			//////////////////////////////////////////////////////////////////////////////////////
503			//it seeks back and when it find the character it is looking for it takes the data that is forward and returns it
504			//then it take the returned String data and add it together with another String data that it returns
505			//////////////////////////////////////////////////////////////////////////////////////
506
507			char StringInput::cutTheBackMergeStrings(char word, char *target)
508			{
509			char *uBuffer=0;
510
511			char *tBuffer=findWordAndCutTheBack(word);
512
513			if ( tBuffer != 0 )
514			{
515			if (cutAndPasteBuffer!=0)
516			{
517			free(cutAndPasteBuffer);
518			cutAndPasteBuffer=0;
519			}
520
521			cutAndPasteBuffer=stringTools->addStringTwoString(target,tBuffer);
522			uBuffer=cutAndPasteBuffer;
523			}
524
525			return uBuffer;
526			}
527
528			//////////////////////////////////////////////////////////////////////////////////////
529			//scanwords a number of times that is selected
530			//////////////////////////////////////////////////////////////////////////////////////
531
532			bool StringInput::scanWordForwardLoop(int numberOfTimes)
533			{
534			bool statement=true;
535			int r=0;
536			char* tBuffer=0;
537
538			while ( r<numberOfTimes && statement == true )
539			{
540			tBuffer=scanWord();
541
542			if ( tBuffer != 0)
543			{
544			if (defragMemory!=0)
545			{
546			free(tBuffer);
547			tBuffer=0;
548			}
549			}
550			else
551			{
552			statement=false;
553			}
554
555			r++;
556			}
557
558			return statement;
559			}
560
561
562
563			//////////////////////////////////////////////////////////////////////////////////////
564			//it looks for a word when it finds it , it takes the specified number of float data after the word and returns it
565			//if it finds a specified word that you have specified , it returns -1 (endtargert,endtarger2)
566			//////////////////////////////////////////////////////////////////////////////////////
567
568			float StringInput::findWordReturnFloats(char word, int howManyScanForward, int numberOfFloats)
569			{
570			if ( floatBuffer != 0 )
571			{
572			free(floatBuffer);
573			floatBuffer=0;
574			}
575
576			bool statement=findWord(word);
577
578			if ( statement == true && scanEndFindWordStatus == false )
579			{
580			bool statement=scanWordForwardLoop(howManyScanForward);
581
582			if (statement)
583			{
584			char *tBuffer=scanWord();
585			String tTemp=tBuffer;
586			int number=tTemp.toInt();
587
588			int totalNumberOfFloats=(5+(numberOfFloats*3));
589			floatBuffer=(float)malloc((sizeof(float)totalNumberOfFloats)*number+sizeof(float));
590
591			floatBuffer[0]=(float)number;
592
593			for ( int n=0; n<number ; n++ )
594			{
595			for ( int n2=0; n2<totalNumberOfFloats ; n2++ )
596			{
597			tBuffer=scanWord();
598
599			if ( tBuffer != 0)
600			{
601			String tTemp=tBuffer;
602			float fNumber=tTemp.toFloat();
603			floatBuffer[1+n2+n*totalNumberOfFloats]=fNumber;
604
605			}
606			}
607			}
608			}
609			}
610
611			return floatBuffer;
612			}
613
614
615
616			//////////////////////////////////////////////////////////////////////////////////////
617			//it looks for a word when it finds it , it takes the specified number of float data after the word and returns it
618			//if it finds a specified word that you have specified , it returns -1 (endtargert,endtarger2)
619			//a special
620			//////////////////////////////////////////////////////////////////////////////////////
621
622			float StringInput::findAWordReturnFloats( char word, int numberOf, float falseValue, int option)
623			{
624			if ( floatBuffer != 0 )
625			{
626			free(floatBuffer);
627			floatBuffer=0;
628			}
629
630			bool statement=findWord(word);
631
632			if ( statement == true && scanEndFindWordStatus == true )
633			{
634			if ( option != 2 )
635			{
636			floatBuffer=(float)malloc(sizeof(float)numberOf);
637
638			for ( int r=0; r<numberOf; r++ )
639			{
640			floatBuffer[r]=falseValue;
641			}
642			}
643			}
644			else
645			{
646			if ( statement == true && scanEndFindWordStatus == false )
647			{
648			floatBuffer=(float)malloc(sizeof(float)numberOf);
649
650			for ( int r=0; r<numberOf; r++ )
651			{
652			char *fBuffer=scanWord();
653			String fTemp=fBuffer;
654			floatBuffer[r]=fTemp.toFloat();
655
656			if (defragMemory!=0)
657			{
658			free(fBuffer);
659			fBuffer=0;
660			}
661			}
662
663			if ( ((char*)endTargetPointers[0]) != 0 && option == 1 )
664			{
665			bool statement=findWord((char*)endTargetPointers[0]);
666			}
667			}
668			}
669
670			return floatBuffer;
671			}
672
673
674			bool StringInput::socketGetHttp(int socket)
675			{
676			NetWorkTools netWorkTools;
677			char *tempBuffer=netWorkTools.recieveHttpData(socket);
678			setInternBuffer(tempBuffer);
679
680			if (tempBuffer!=null)
681			{
682			return true;
683			}
684
685			return false;
686			}
687
688			char *StringInput::getInternBuffer()
689			{
690			return internBuffer;
691			}