URL https://opencores.org/ocsvn/pavr/pavr/trunk

Subversion Repositories pavr

[/] [pavr/] [trunk/] [tools/] [common/] [tagScan.c] - Blame information for rev 6

Details | Compare with Previous | View Log


// <File Header>
// </File Header>
 
// <File Info>
// </File Info>
 
// <File Body>
#include <string.h>
#include <io.h>
#include <stdio.h>
#include <stdlib.h>
#include "tagScan.h"
 
// File IO operations (read/write) occur in chunks of FILE_IO_DATA_CHUNK.
// A tag must be shorter than FILE_IO_DATA_CHUNK/2.
#define FILE_IO_DATA_CHUNK 1000
 
 
 
// scanTag_t private methods
 
void scanTag_t_setStatus(scanTag_t *stag, int errCode)
{
   stag->errCode = errCode;
   switch (stag->errCode)
   {
      case TAG_SCAN_OK:
      {
         strcpy(stag->errMsg, "Tag scanning OK.\n");
      }; break;
      case TAG_SCAN_TAG_NOT_FOUND:
      {
         strcpy(stag->errMsg, "Tag scanning error: could not find tag.\n");
      }; break;
      case TAG_SCAN_MULTIPLE_TAG:
      {
         strcpy(stag->errMsg, "Tag scanning error: multiple tag match.\n");
      }; break;
      case TAG_SCAN_END_BEFORE_BEGIN:
      {
         strcpy(stag->errMsg, "Tag scanning error: `end' tag before `begin' tag.\n");
      }; break;
      case TAG_SCAN_FILE_NOT_FOUND:
      {
         strcpy(stag->errMsg, "Tag scanning error: file not found.");
      }; break;
      case TAG_SCAN_MALLOC_ERR:
      {
         strcpy(stag->errMsg, "Tag scanning error: could not allocate memory.\n");
      }; break;
      case TAG_SCAN_FILE_IO_ERR:
      {
         strcpy(stag->errMsg, "Tag scanning error: file IO error.\n");
      }; break;
      default:
      {
         strcpy(stag->errMsg, "Unknown error during tag scanning.");
      }; break;
   }
}
 
 
 
long int scanTag_t_findNextTag(char* tag, long int crtPos, FILE* fStr, scanTag_t *stag)
{
   char str1[FILE_IO_DATA_CHUNK+2];
   char *stringPos1, *stringPos2, *stringPos3;
   long int retVal, str1offset, str1offsetTot;
   long int nrItemsRead;
   int tagFound;
   int partialMatch;
   int fStrEOF;
 
   retVal = crtPos;
   if (fseek(fStr, crtPos, SEEK_SET)==0)
   {
      tagFound = 0;
      fStrEOF=0;
      while ((tagFound==0) && (fStrEOF==0))
      {
         nrItemsRead = fread(str1, 1, FILE_IO_DATA_CHUNK, fStr);
         if (nrItemsRead!=FILE_IO_DATA_CHUNK) fStrEOF=1;
         str1[nrItemsRead] = NULL;
         str1offset = 0;
         str1offsetTot = 0;
 
         stringPos1 = str1;
         while ((tagFound==0) && (*stringPos1!=NULL))
         {
            stringPos2 = tag;
            str1offset = str1offsetTot;
            partialMatch = 0;
            while ((tagFound==0) && (*stringPos1!=NULL) && (*stringPos2!=NULL))
            {
               if (*stringPos1==*stringPos2)
               {
                  partialMatch = 1;
                  stringPos1++;
                  stringPos2++;
                  str1offsetTot++;
                  if (*stringPos2==NULL)
                  {
                     tagFound = 1;
                     retVal = ftell(fStr)-nrItemsRead+str1offset;
                     break;
                  }
               }
               else
               {
                  if (partialMatch==0)
                  {
                     stringPos1++;
                     str1offset++;
                     str1offsetTot++;
                  }
                  partialMatch = 0;
                  break;
               }
            }
         }
         if (tagFound==0)
         {
            // Tag not found in this data chunk.
            // Rewind with twice tag's length and get a new data chunk.
            fseek(fStr, -2*strlen(tag), SEEK_CUR);
         }
      }
   }
   if (tagFound == 0)
      scanTag_t_setStatus(stag, TAG_SCAN_TAG_NOT_FOUND);
   return retVal;
}
 
 
 
long int scanTag_t_findTag(char *tag, FILE *fStr, scanTag_t *stag)
{
   long int pos1, pos2;
 
   pos1 = 0;
   pos2 = scanTag_t_findNextTag(tag, pos1, fStr, stag);
   // Does that tag appear at least once?
   if (stag->errCode == TAG_SCAN_OK) {
      // Yes, the tag appears at least once.
      scanTag_t_findNextTag(tag, pos2+strlen(tag), fStr, stag);
      // Does that tag appear exactly once?
      if (stag->errCode == TAG_SCAN_TAG_NOT_FOUND) {
         // Yes, the tag appears exactly once. Reset status to OK.
         scanTag_t_setStatus(stag, TAG_SCAN_OK);
         return pos2;
      }
      else {
         // No, multiple tag matched.
         scanTag_t_setStatus(stag, TAG_SCAN_MULTIPLE_TAG);
         return 0;
      }
   }
   else {
      // No, tag not found.
      scanTag_t_setStatus(stag, TAG_SCAN_TAG_NOT_FOUND);
      return 0;
   }
}
 
 
 
// scanTag_t public methods
 
void scanTag_t_construct(scanTag_t *stag)
{
   stag->readText = (char *) malloc(1);
   if (stag->readText==NULL)
   {
      fprintf(stdout, "Error: could not allocate memory. Exitting...\n");
      exit(1);
   }
   stag->errMsg = (char*) malloc(TAG_SCAN_MSG_MAX_LEN);
   if (stag->errMsg==NULL)
   {
      fprintf(stdout, "Error: could not allocate memory. Exitting...\n");
      exit(1);
   }
   scanTag_t_setStatus(stag, TAG_SCAN_OK);
}
 
 
 
void scanTag_t_destruct(scanTag_t *stag)
{
   free(stag->readText);
   free(stag->errMsg);
}
 
 
 
char *scanTag_t_getStatus(scanTag_t *stag)
{
   return stag->errMsg;
}
 
 
 
void scanTag_t_readTaggedText(char *tagBegin, char *tagEnd, char *fName, scanTag_t *stag)
{
   long int pos1, pos2;
   FILE *fStr;
   long int nrItemsRead;
 
   scanTag_t_setStatus(stag, TAG_SCAN_OK);
   fStr = fopen(fName, "rb");
   if (fStr != NULL)
   {
      pos1 = scanTag_t_findTag(tagBegin, fStr, stag);
      pos2 = scanTag_t_findTag(tagEnd, fStr, stag);
      if (stag->errCode == TAG_SCAN_OK)
      {
         if ((long int)(pos1+strlen(tagBegin))<=pos2)
         {
            free(stag->readText);
            stag->readText = (char*) malloc(pos2-pos1-strlen(tagBegin)+2);
            if (stag->readText!=NULL)
            {
               fseek(fStr, pos1+strlen(tagBegin), SEEK_SET);
               nrItemsRead = fread(stag->readText, 1, pos2-pos1-strlen(tagBegin), fStr);
               if (nrItemsRead == (long int)(pos2-pos1-strlen(tagBegin)))
               {
                  stag->readText[pos2-pos1-strlen(tagBegin)] = NULL;
                  fclose(fStr);
               }
               else
               {
                  scanTag_t_setStatus(stag, TAG_SCAN_UNKNOWN_ERR);
                  fclose(fStr);
               }
            }
            else
            {
               scanTag_t_setStatus(stag, TAG_SCAN_MALLOC_ERR);
               fclose(fStr);
            }
         }
         else
         {
            scanTag_t_setStatus(stag, TAG_SCAN_END_BEFORE_BEGIN);
            fclose(fStr);
         }
      }
   }
   else
   {
      scanTag_t_setStatus(stag, TAG_SCAN_FILE_NOT_FOUND);
   }
}
 
 
 
void scanTag_t_writeTaggedText(char* tag_begin, char* tag_end, char* newText, char* fName, scanTag_t* stag)
{
   long int pos1, pos2;
   FILE *fSrc, *fDst;
   char *tStr;
   long int nrItemsRead;
   int fSrcEOF;
   long int fSrcOffsetNew, fSrcOffsetOld;
 
   scanTag_t_setStatus(stag, TAG_SCAN_OK);
   fSrc = fopen(fName, "rb");
   if (fSrc != NULL)
   {
      pos1 = scanTag_t_findTag(tag_begin, fSrc, stag);
      pos2 = scanTag_t_findTag(tag_end, fSrc, stag);
      if (stag->errCode == TAG_SCAN_OK)
      {
         if ((long int)(pos1+strlen(tag_begin))<=pos2)
         {
            // Open src and dst file.
            tStr = (char*) malloc(strlen(fName)+1+2);
            if (tStr!=NULL)
            {
               strcpy(tStr, fName);
               strcat(tStr, "~");
               fSrc = fopen(fName, "rb");
               fDst = fopen(tStr, "wb+");
               if ((fSrc!=NULL) && (fDst!=NULL))
               {
                  // Both src and dst opened.
                  free(tStr);
                  tStr = (char*) malloc(FILE_IO_DATA_CHUNK+2);
                  if (tStr!=NULL)
                  {
                     // Blindly copy src to dst.
                     fSrcEOF = 0;
                     while (fSrcEOF == 0)
                     {
                        nrItemsRead = fread(tStr, 1, FILE_IO_DATA_CHUNK, fSrc);
                        tStr[nrItemsRead] = NULL;
                        if (nrItemsRead != FILE_IO_DATA_CHUNK)
                           fSrcEOF = 1;
                        fwrite(tStr, 1, strlen(tStr), fDst);
                     }
 
                     // Copy back only what's needed.
                     // First, interchange src and dst.
                     fclose(fSrc);
                     fclose(fDst);
                     free(tStr);
                     tStr = (char*) malloc(strlen(fName)+1+2);
                     strcpy(tStr, fName);
                     strcat(tStr, "~");
                     fSrc = fopen(tStr, "rb");
                     fDst = fopen(fName, "wb+");
                     // Now scan for tags and replace text.
                     free(tStr);
                     tStr = (char*) malloc(FILE_IO_DATA_CHUNK+2);
                     //pos1 = scanTag_t_findTag(tag_begin, fSrc, stag);
                     //pos2 = scanTag_t_findTag(tag_end, fSrc, stag);
                     fseek(fSrc, 0, SEEK_SET);
                     fseek(fDst, 0, SEEK_SET);
                     fSrcOffsetNew = 0;
                     while (fSrcOffsetNew < pos1)
                     {
                        nrItemsRead = fread(tStr, 1, FILE_IO_DATA_CHUNK, fSrc);
                        tStr[nrItemsRead] = NULL;
                        fSrcOffsetOld = fSrcOffsetNew;
                        fSrcOffsetNew = ftell(fSrc);
                        if (fSrcOffsetNew > pos1)
                           tStr[pos1 - fSrcOffsetOld] = NULL;
                        fwrite(tStr, 1, strlen(tStr), fDst);
                        fflush(fDst);
                     }
 
                     fwrite(tag_begin, 1, strlen(tag_begin), fDst);
                     fflush(fDst);
                     fwrite(newText, 1, strlen(newText), fDst);
                     fflush(fDst);
                     fwrite(tag_end, 1, strlen(tag_end), fDst);
                     fflush(fDst);
 
                     if (fseek(fSrc, pos2+strlen(tag_end), SEEK_SET)==0)
                     {
                        fSrcEOF = 0;
                        while (fSrcEOF == 0)
                        {
                           nrItemsRead = fread(tStr, 1, FILE_IO_DATA_CHUNK, fSrc);
                           tStr[nrItemsRead] = NULL;
                           if (nrItemsRead != FILE_IO_DATA_CHUNK)
                              fSrcEOF = 1;
                           fwrite(tStr, 1, strlen(tStr), fDst);
                        }
                     }
                     else
                     {
                        free(tStr);
                        fclose(fSrc);
                        fclose(fDst);
                        scanTag_t_setStatus(stag, TAG_SCAN_UNKNOWN_ERR);
                        return;
                     }
 
                     free(tStr);
                     fclose(fSrc);
                     fclose(fDst);
                  }
                  else
                  {
                     scanTag_t_setStatus(stag, TAG_SCAN_MALLOC_ERR);
                     return;
                  }
               }
               else
               {
                  free(tStr);
                  scanTag_t_setStatus(stag, TAG_SCAN_FILE_IO_ERR);
                  return;
               }
            }
            else
            {
               scanTag_t_setStatus(stag, TAG_SCAN_MALLOC_ERR);
               return;
            }
         }
         else
         {
            scanTag_t_setStatus(stag, TAG_SCAN_END_BEFORE_BEGIN);
            fclose(fSrc);
            return;
         }
      }
   }
   else
   {
      scanTag_t_setStatus(stag, TAG_SCAN_FILE_NOT_FOUND);
      return;
   }
}
// </File Body>

Browse

Tools

Subversion Repositories pavr

[/] [pavr/] [trunk/] [tools/] [common/] [tagScan.c] - Blame information for rev 6

Line No.	Rev	Author	Line
1	4	doru	`// <File Header>`
2			`// </File Header>`
3
4			`// <File Info>`
5			`// </File Info>`
6
7			`// <File Body>`
8			`#include <string.h>`
9			`#include <io.h>`
10			`#include <stdio.h>`
11			`#include <stdlib.h>`
12			`#include "tagScan.h"`
13
14			`// File IO operations (read/write) occur in chunks of FILE_IO_DATA_CHUNK.`
15			`// A tag must be shorter than FILE_IO_DATA_CHUNK/2.`
16			`#define FILE_IO_DATA_CHUNK 1000`
17
18
19
20			`// scanTag_t private methods`
21
22			`void scanTag_t_setStatus(scanTag_t *stag, int errCode)`
23			`{`
24			`stag->errCode = errCode;`
25			`switch (stag->errCode)`
26			`{`
27			`case TAG_SCAN_OK:`
28			`{`
29			`strcpy(stag->errMsg, "Tag scanning OK.\n");`
30			`}; break;`
31			`case TAG_SCAN_TAG_NOT_FOUND:`
32			`{`
33			`strcpy(stag->errMsg, "Tag scanning error: could not find tag.\n");`
34			`}; break;`
35			`case TAG_SCAN_MULTIPLE_TAG:`
36			`{`
37			`strcpy(stag->errMsg, "Tag scanning error: multiple tag match.\n");`
38			`}; break;`
39			`case TAG_SCAN_END_BEFORE_BEGIN:`
40			`{`
41			strcpy(stag->errMsg, "Tag scanning error: `end' tag before `begin' tag.\n");
42			`}; break;`
43			`case TAG_SCAN_FILE_NOT_FOUND:`
44			`{`
45			`strcpy(stag->errMsg, "Tag scanning error: file not found.");`
46			`}; break;`
47			`case TAG_SCAN_MALLOC_ERR:`
48			`{`
49			`strcpy(stag->errMsg, "Tag scanning error: could not allocate memory.\n");`
50			`}; break;`
51			`case TAG_SCAN_FILE_IO_ERR:`
52			`{`
53			`strcpy(stag->errMsg, "Tag scanning error: file IO error.\n");`
54			`}; break;`
55			`default:`
56			`{`
57			`strcpy(stag->errMsg, "Unknown error during tag scanning.");`
58			`}; break;`
59			`}`
60			`}`
61
62
63
64			`long int scanTag_t_findNextTag(char* tag, long int crtPos, FILE* fStr, scanTag_t *stag)`
65			`{`
66			`char str1[FILE_IO_DATA_CHUNK+2];`
67			`char stringPos1, stringPos2, *stringPos3;`
68			`long int retVal, str1offset, str1offsetTot;`
69			`long int nrItemsRead;`
70			`int tagFound;`
71			`int partialMatch;`
72			`int fStrEOF;`
73
74			`retVal = crtPos;`
75			`if (fseek(fStr, crtPos, SEEK_SET)==0)`
76			`{`
77			`tagFound = 0;`
78			`fStrEOF=0;`
79			`while ((tagFound==0) && (fStrEOF==0))`
80			`{`
81			`nrItemsRead = fread(str1, 1, FILE_IO_DATA_CHUNK, fStr);`
82			`if (nrItemsRead!=FILE_IO_DATA_CHUNK) fStrEOF=1;`
83			`str1[nrItemsRead] = NULL;`
84			`str1offset = 0;`
85			`str1offsetTot = 0;`
86
87			`stringPos1 = str1;`
88			`while ((tagFound==0) && (*stringPos1!=NULL))`
89			`{`
90			`stringPos2 = tag;`
91			`str1offset = str1offsetTot;`
92			`partialMatch = 0;`
93			`while ((tagFound==0) && (stringPos1!=NULL) && (stringPos2!=NULL))`
94			`{`
95			`if (stringPos1==stringPos2)`
96			`{`
97			`partialMatch = 1;`
98			`stringPos1++;`
99			`stringPos2++;`
100			`str1offsetTot++;`
101			`if (*stringPos2==NULL)`
102			`{`
103			`tagFound = 1;`
104			`retVal = ftell(fStr)-nrItemsRead+str1offset;`
105			`break;`
106			`}`
107			`}`
108			`else`
109			`{`
110			`if (partialMatch==0)`
111			`{`
112			`stringPos1++;`
113			`str1offset++;`
114			`str1offsetTot++;`
115			`}`
116			`partialMatch = 0;`
117			`break;`
118			`}`
119			`}`
120			`}`
121			`if (tagFound==0)`
122			`{`
123			`// Tag not found in this data chunk.`
124			`// Rewind with twice tag's length and get a new data chunk.`
125			`fseek(fStr, -2*strlen(tag), SEEK_CUR);`
126			`}`
127			`}`
128			`}`
129			`if (tagFound == 0)`
130			`scanTag_t_setStatus(stag, TAG_SCAN_TAG_NOT_FOUND);`
131			`return retVal;`
132			`}`
133
134
135
136			`long int scanTag_t_findTag(char tag, FILE fStr, scanTag_t *stag)`
137			`{`
138			`long int pos1, pos2;`
139
140			`pos1 = 0;`
141			`pos2 = scanTag_t_findNextTag(tag, pos1, fStr, stag);`
142			`// Does that tag appear at least once?`
143			`if (stag->errCode == TAG_SCAN_OK) {`
144			`// Yes, the tag appears at least once.`
145			`scanTag_t_findNextTag(tag, pos2+strlen(tag), fStr, stag);`
146			`// Does that tag appear exactly once?`
147			`if (stag->errCode == TAG_SCAN_TAG_NOT_FOUND) {`
148			`// Yes, the tag appears exactly once. Reset status to OK.`
149			`scanTag_t_setStatus(stag, TAG_SCAN_OK);`
150			`return pos2;`
151			`}`
152			`else {`
153			`// No, multiple tag matched.`
154			`scanTag_t_setStatus(stag, TAG_SCAN_MULTIPLE_TAG);`
155			`return 0;`
156			`}`
157			`}`
158			`else {`
159			`// No, tag not found.`
160			`scanTag_t_setStatus(stag, TAG_SCAN_TAG_NOT_FOUND);`
161			`return 0;`
162			`}`
163			`}`
164
165
166
167			`// scanTag_t public methods`
168
169			`void scanTag_t_construct(scanTag_t *stag)`
170			`{`
171			`stag->readText = (char *) malloc(1);`
172			`if (stag->readText==NULL)`
173			`{`
174			`fprintf(stdout, "Error: could not allocate memory. Exitting...\n");`
175			`exit(1);`
176			`}`
177			`stag->errMsg = (char*) malloc(TAG_SCAN_MSG_MAX_LEN);`
178			`if (stag->errMsg==NULL)`
179			`{`
180			`fprintf(stdout, "Error: could not allocate memory. Exitting...\n");`
181			`exit(1);`
182			`}`
183			`scanTag_t_setStatus(stag, TAG_SCAN_OK);`
184			`}`
185
186
187
188			`void scanTag_t_destruct(scanTag_t *stag)`
189			`{`
190			`free(stag->readText);`
191			`free(stag->errMsg);`
192			`}`
193
194
195
196			`char scanTag_t_getStatus(scanTag_t stag)`
197			`{`
198			`return stag->errMsg;`
199			`}`
200
201
202
203			`void scanTag_t_readTaggedText(char tagBegin, char tagEnd, char fName, scanTag_t stag)`
204			`{`
205			`long int pos1, pos2;`
206			`FILE *fStr;`
207			`long int nrItemsRead;`
208
209			`scanTag_t_setStatus(stag, TAG_SCAN_OK);`
210			`fStr = fopen(fName, "rb");`
211			`if (fStr != NULL)`
212			`{`
213			`pos1 = scanTag_t_findTag(tagBegin, fStr, stag);`
214			`pos2 = scanTag_t_findTag(tagEnd, fStr, stag);`
215			`if (stag->errCode == TAG_SCAN_OK)`
216			`{`
217			`if ((long int)(pos1+strlen(tagBegin))<=pos2)`
218			`{`
219			`free(stag->readText);`
220			`stag->readText = (char*) malloc(pos2-pos1-strlen(tagBegin)+2);`
221			`if (stag->readText!=NULL)`
222			`{`
223			`fseek(fStr, pos1+strlen(tagBegin), SEEK_SET);`
224			`nrItemsRead = fread(stag->readText, 1, pos2-pos1-strlen(tagBegin), fStr);`
225			`if (nrItemsRead == (long int)(pos2-pos1-strlen(tagBegin)))`
226			`{`
227			`stag->readText[pos2-pos1-strlen(tagBegin)] = NULL;`
228			`fclose(fStr);`
229			`}`
230			`else`
231			`{`
232			`scanTag_t_setStatus(stag, TAG_SCAN_UNKNOWN_ERR);`
233			`fclose(fStr);`
234			`}`
235			`}`
236			`else`
237			`{`
238			`scanTag_t_setStatus(stag, TAG_SCAN_MALLOC_ERR);`
239			`fclose(fStr);`
240			`}`
241			`}`
242			`else`
243			`{`
244			`scanTag_t_setStatus(stag, TAG_SCAN_END_BEFORE_BEGIN);`
245			`fclose(fStr);`
246			`}`
247			`}`
248			`}`
249			`else`
250			`{`
251			`scanTag_t_setStatus(stag, TAG_SCAN_FILE_NOT_FOUND);`
252			`}`
253			`}`
254
255
256
257			`void scanTag_t_writeTaggedText(char* tag_begin, char* tag_end, char* newText, char* fName, scanTag_t* stag)`
258			`{`
259			`long int pos1, pos2;`
260			`FILE fSrc, fDst;`
261			`char *tStr;`
262			`long int nrItemsRead;`
263			`int fSrcEOF;`
264			`long int fSrcOffsetNew, fSrcOffsetOld;`
265
266			`scanTag_t_setStatus(stag, TAG_SCAN_OK);`
267			`fSrc = fopen(fName, "rb");`
268			`if (fSrc != NULL)`
269			`{`
270			`pos1 = scanTag_t_findTag(tag_begin, fSrc, stag);`
271			`pos2 = scanTag_t_findTag(tag_end, fSrc, stag);`
272			`if (stag->errCode == TAG_SCAN_OK)`
273			`{`
274			`if ((long int)(pos1+strlen(tag_begin))<=pos2)`
275			`{`
276			`// Open src and dst file.`
277			`tStr = (char*) malloc(strlen(fName)+1+2);`
278			`if (tStr!=NULL)`
279			`{`
280			`strcpy(tStr, fName);`
281			`strcat(tStr, "~");`
282			`fSrc = fopen(fName, "rb");`
283			`fDst = fopen(tStr, "wb+");`
284			`if ((fSrc!=NULL) && (fDst!=NULL))`
285			`{`
286			`// Both src and dst opened.`
287			`free(tStr);`
288			`tStr = (char*) malloc(FILE_IO_DATA_CHUNK+2);`
289			`if (tStr!=NULL)`
290			`{`
291			`// Blindly copy src to dst.`
292			`fSrcEOF = 0;`
293			`while (fSrcEOF == 0)`
294			`{`
295			`nrItemsRead = fread(tStr, 1, FILE_IO_DATA_CHUNK, fSrc);`
296			`tStr[nrItemsRead] = NULL;`
297			`if (nrItemsRead != FILE_IO_DATA_CHUNK)`
298			`fSrcEOF = 1;`
299			`fwrite(tStr, 1, strlen(tStr), fDst);`
300			`}`
301
302			`// Copy back only what's needed.`
303			`// First, interchange src and dst.`
304			`fclose(fSrc);`
305			`fclose(fDst);`
306			`free(tStr);`
307			`tStr = (char*) malloc(strlen(fName)+1+2);`
308			`strcpy(tStr, fName);`
309			`strcat(tStr, "~");`
310			`fSrc = fopen(tStr, "rb");`
311			`fDst = fopen(fName, "wb+");`
312			`// Now scan for tags and replace text.`
313			`free(tStr);`
314			`tStr = (char*) malloc(FILE_IO_DATA_CHUNK+2);`
315			`//pos1 = scanTag_t_findTag(tag_begin, fSrc, stag);`
316			`//pos2 = scanTag_t_findTag(tag_end, fSrc, stag);`
317			`fseek(fSrc, 0, SEEK_SET);`
318			`fseek(fDst, 0, SEEK_SET);`
319			`fSrcOffsetNew = 0;`
320			`while (fSrcOffsetNew < pos1)`
321			`{`
322			`nrItemsRead = fread(tStr, 1, FILE_IO_DATA_CHUNK, fSrc);`
323			`tStr[nrItemsRead] = NULL;`
324			`fSrcOffsetOld = fSrcOffsetNew;`
325			`fSrcOffsetNew = ftell(fSrc);`
326			`if (fSrcOffsetNew > pos1)`
327			`tStr[pos1 - fSrcOffsetOld] = NULL;`
328			`fwrite(tStr, 1, strlen(tStr), fDst);`
329			`fflush(fDst);`
330			`}`
331
332			`fwrite(tag_begin, 1, strlen(tag_begin), fDst);`
333			`fflush(fDst);`
334			`fwrite(newText, 1, strlen(newText), fDst);`
335			`fflush(fDst);`
336			`fwrite(tag_end, 1, strlen(tag_end), fDst);`
337			`fflush(fDst);`
338
339			`if (fseek(fSrc, pos2+strlen(tag_end), SEEK_SET)==0)`
340			`{`
341			`fSrcEOF = 0;`
342			`while (fSrcEOF == 0)`
343			`{`
344			`nrItemsRead = fread(tStr, 1, FILE_IO_DATA_CHUNK, fSrc);`
345			`tStr[nrItemsRead] = NULL;`
346			`if (nrItemsRead != FILE_IO_DATA_CHUNK)`
347			`fSrcEOF = 1;`
348			`fwrite(tStr, 1, strlen(tStr), fDst);`
349			`}`
350			`}`
351			`else`
352			`{`
353			`free(tStr);`
354			`fclose(fSrc);`
355			`fclose(fDst);`
356			`scanTag_t_setStatus(stag, TAG_SCAN_UNKNOWN_ERR);`
357			`return;`
358			`}`
359
360			`free(tStr);`
361			`fclose(fSrc);`
362			`fclose(fDst);`
363			`}`
364			`else`
365			`{`
366			`scanTag_t_setStatus(stag, TAG_SCAN_MALLOC_ERR);`
367			`return;`
368			`}`
369			`}`
370			`else`
371			`{`
372			`free(tStr);`
373			`scanTag_t_setStatus(stag, TAG_SCAN_FILE_IO_ERR);`
374			`return;`
375			`}`
376			`}`
377			`else`
378			`{`
379			`scanTag_t_setStatus(stag, TAG_SCAN_MALLOC_ERR);`
380			`return;`
381			`}`
382			`}`
383			`else`
384			`{`
385			`scanTag_t_setStatus(stag, TAG_SCAN_END_BEFORE_BEGIN);`
386			`fclose(fSrc);`
387			`return;`
388			`}`
389			`}`
390			`}`
391			`else`
392			`{`
393			`scanTag_t_setStatus(stag, TAG_SCAN_FILE_NOT_FOUND);`
394			`return;`
395			`}`
396			`}`
397			`// </File Body>`