WSxM_header.C

Go to the documentation of this file.

/***********************************************************************
*
*       File Name: WSxM_header.C
*
*       Description: functions for managing the WSxM_HEADER structure defined in Header.h
*
***********************************************************************/

/* this is not a main PlugIn file and here is no Docu to scan...
% PlugInModuleIgnore
*/

//#include <malloc.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include "WSxM_header.h"

// Define the max. number of chars in a header argument if not done in WSxM_io.C
#ifndef WSXM_MAXCHARS
#define WSXM_MAXCHARS 1000
#endif
/***********************************************************************
*
*       Function void HeaderInit (WSxM_HEADER *pHeader);
*
*       Description: Initializes the values of the WSxM_HEADER structure. It should
*                    be called always before using any of the other functions
*
***********************************************************************/

void HeaderInit (WSxM_HEADER *pHeader)
{
        if (pHeader == NULL)
                return;

        pHeader->tszTitles = NULL;
        pHeader->tszLabels = NULL;
        pHeader->tszValues = NULL;

        pHeader->iNumFields = 0;
}

/***********************************************************************
*
*       Function int HeaderRead (WSxM_HEADER *pHeader, FILE *pFile);
*
*       Description: Reads a WSxM_HEADER from a file. It is important that the file
*                    should have been opened for reading, and the WSxM_HEADER should
*                    have been initializated calling HeaderInit
*
*       Inputs:
*                       - pHeader: pointer to the WSxM_HEADER object to store the data in
*                       - pFile: File pointer to read the header from
*
*       Outputs:
*                       - pHeader: will be filled with the data read from pFile
*                       - pFile: the file pointer will go to the end of the header
*
*       Return value:
*                       0 if the header was correctly read, -1 elsewhere
*
***********************************************************************/

int HeaderRead (WSxM_HEADER *pHeader, FILE *pFile)
{
        int iStatus = 0;

        if ((pHeader == NULL) || (pFile == NULL))
                return -1;

        if (pHeader->iNumFields != 0)
                return -1;

        /* Read the file line by line */

        while (iStatus == 0)
        {
                iStatus = HeaderReadLine (pHeader,pFile);
        }

        if (iStatus == -1) /* Error */
        {
                return -1;
        }

        return 0;
}

/* Header write */

/***********************************************************************
*
*       Function int HeaderWrite (WSxM_HEADER *pHeader, FILE *pFile);
*
*       Description: Writes the WSxM_HEADER object to a file. It is important that the file
*                    should have been opened for writing (not append).
*
*       Inputs:
*                       - pHeader: pointer to the WSxM_HEADER object with the data
*                       - pFile: File pointer to write the data header
*
*
*       Return value:
*                       0 if the header was correctly write, -1 elsewhere
*
***********************************************************************/

int HeaderWrite (WSxM_HEADER *pHeader, FILE *pFile)
{
        int i, j;
        char *pCharAux;                                         /* for swapping in bubble sort */                                         
        char szAuxTitle[100], szAuxLabel[100], szAuxValue[WSXM_MAXCHARS]; /* for writting in file        */

        /* sorts the WSxM_HEADER object by title and label using bubble sort algorithm */
                   
        for (i=0; i < pHeader->iNumFields; i++)
        {
                for (j = 0; j < (pHeader->iNumFields-i-1); j++)
                {
                        if ((strcmp (pHeader->tszTitles[j], pHeader->tszTitles[j+1]) > 0)||
                (strcmp (pHeader->tszTitles[j], pHeader->tszTitles[j+1]) == 0)&&
                (strcmp (pHeader->tszLabels[j], pHeader->tszLabels[j+1]) > 0))
                        {
                                /* the element j is bigger than j+1 one so we swap them    */
                                /* we must swap the elements j and j+1 in the three arrays */

                                /* swaps the titles */
                                pCharAux = pHeader->tszTitles[j];
                                pHeader->tszTitles[j] = pHeader->tszTitles[j+1];
                                pHeader->tszTitles[j+1] = pCharAux;

                                /* swaps the labels */
                                pCharAux = pHeader->tszLabels[j];
                                pHeader->tszLabels[j] = pHeader->tszLabels[j+1];
                                pHeader->tszLabels[j+1] = pCharAux;

                                /* swaps the values */
                                pCharAux = pHeader->tszValues[j];
                                pHeader->tszValues[j] = pHeader->tszValues[j+1];
                                pHeader->tszValues[j+1] = pCharAux;
                        }
                }
        }

        /* writes the pre-header info in the file */
        fprintf (pFile, "%s", TEXT_COPYRIGHT_NANOTEC);
        fprintf (pFile, "%s", STM_IMAGE_FILE_ID);
        fprintf (pFile, "%s%d\n", IMAGE_HEADER_SIZE_TEXT, HeaderGetSize (pHeader));

        /* In the first time there is no previous title */
        strcpy (szAuxTitle, "");

        /* writes all the fields in the file */
        for (i=0; i<pHeader->iNumFields; i++)
        {
                /* if the title is diferent than the previous one we write the title in the file */
                if (strcmp (szAuxTitle, pHeader->tszTitles[i]) != 0)
                {
                        /* Special characteres in the title */
                        strcpy (szAuxTitle, pHeader->tszTitles[i]);
                        ReplaceStringInString (szAuxTitle, "\\","\\\\");
                        ReplaceStringInString (szAuxTitle, "\r\n","\\n");

                        /* writes the title in the file */
                        fprintf (pFile, "\n[%s]\n\n", szAuxTitle);
                }

                /* Special characteres in the label */
                strcpy (szAuxLabel, pHeader->tszLabels[i]);
                ReplaceStringInString (szAuxLabel, "\\","\\\\");
                ReplaceStringInString (szAuxLabel, "\r\n","\\n");

                /* Special characteres in the value */
                strcpy (szAuxValue, pHeader->tszValues[i]);
                ReplaceStringInString (szAuxValue, "\\","\\\\");
                ReplaceStringInString (szAuxValue, "\r\n","\\n");
                RemoveLeftAndRightWhitesFromString (szAuxValue);

                /* writes the label and the value in the file */
                fprintf (pFile, "    %s: %s\n", szAuxLabel, szAuxValue);
        }

        /* writes the header end */
        fprintf (pFile, "\n[%s]\n",IMAGE_HEADER_END_TEXT);

        return 0;
}

/* Header access to one field */

/* Read */

/***********************************************************************
*
*       Function double HeaderGetAsNumber (WSxM_HEADER *pHeader, char *szTitle, char *szLabel);
*
*       Description: gets the title-label couple value as a number from the 
*               WSxM_HEADER object, the WSxM_HEADER should have been initializated
*               calling HeaderInit
*
*       Inputs: 
*               - pHeader: pointer to the WSxM_HEADER object
*               - szTitle: title of the field to be accesed
*               - szLabel: label of the field to be accesed
*
*       Return value:
*                       a double with the title-label couple value, 0 on error
*
***********************************************************************/

double HeaderGetAsNumber        (WSxM_HEADER *pHeader, char *szTitle, char *szLabel)
{
  char szValue[WSXM_MAXCHARS] = ""; // the default size of 100 should be okey, but to be consistent ..
  if (HeaderGetAsString (pHeader, szTitle, szLabel, szValue) != 0) /* error */
    {
      return 0;
    }
  return atof (szValue);
}

/***********************************************************************
*
*       Function int HeaderGetAsString (WSxM_HEADER *pHeader, char *szTitle, char *szLabel, char *szValue);
*
*       Description: gets the title-label couple value as a string from the 
*               WSxM_HEADER object
*
*       Inputs:
*               - pHeader: pointer to the WSxM_HEADER object
*               - szTitle: title of the field to be accesed
*               - szLabel: label of the field to be accesed
*
*       Outputs:
*               - szValue: will be filled with the title-label couple value as a string
*                 (this must be allocated)
*
*       Return value:
*               0 if the value was correctly accessed, -1 elsewhere
*
***********************************************************************/

int HeaderGetAsString           (WSxM_HEADER *pHeader, char *szTitle, char *szLabel, char *szValue)
{
        int iIndex;

        /* seeks the title-label couple */
        for (iIndex=0; iIndex<pHeader->iNumFields; iIndex++)
        {
                if ((strcmp (szTitle, pHeader->tszTitles[iIndex]) == 0)&&(strcmp (szLabel, pHeader->tszLabels[iIndex]) == 0))
                {
                        /* title-label couple found at position iIndex */
                        break;
                }
        }

        if (iIndex == pHeader->iNumFields)
        {
                /* the for loop didn't found the title-label couple in WSxM_HEADER object */
                return -1;
        }

        /* asign the value of the title-label couple to the pointer szValue */
        strcpy (szValue, pHeader->tszValues[iIndex]);

        /* access succesful */
        return 0;
}

/***********************************************************************
*
*       Function void HeaderReadTitle (char *szLine, char *szTitle);
*
*       Description: reads a title from a line
*
*       Inputs:
*               - szLine: line with the title
*
*       Outputs:
*               - szTitle: title readed from the line (this must be allocated),
*                 szTitle=="" if there is no title in the line.
*
*       Return value:
*               none
*
***********************************************************************/

void HeaderReadTitle (char *szLine, char *szTitle)
{
        int iIndex=0;

        /* If the line don't begin by a left square bracket it isn't a title line */
        if (szLine[0] != '[')
        {
                strcpy (szTitle, "");
                return;
        }

        /* we seek the right square bracket */
        while (szLine[iIndex] != ']')
        {
                iIndex++;
        }

        /* at this point iIndex is the position of the right square bracket */

        /* szLine[1] to skip the left square bracket */
        strncpy (szTitle, &szLine[1], iIndex-1);
        szTitle[iIndex-1] = '\0';
}

/***********************************************************************
*
*       Function void HeaderReadLabel (szLine, szLabel);
*
*       Description: reads a label from a line
*
*       Inputs:
*               - szLine: line with the label
*
*       Outputs:
*               - szLabel: label readed from the line (this must be allocated),
*                 szValue=="" if there is no label in the line.
*
*       Return value:
*               none
*
***********************************************************************/

void HeaderReadLabel (char *szLine, char *szLabel)
{
        unsigned int iIndex=0;

        /* we seek the ':' character */
        while (szLine[iIndex] != ':')
        {
                if (iIndex == strlen (szLine))
                {
                        /* there is no label in this line */
                        strcpy (szLabel, "");
                        return;
                }
                iIndex++;
        }

        /* at this point iIndex is the position of the ':' character */

        /* we copy the label from the line */
        strncpy (szLabel, szLine, iIndex);
        szLabel[iIndex] = '\0';
}

/***********************************************************************
*
*       Function void HeaderReadValue (char *szLine, char *szValue);
*
*       Description: reads a value from a line
*
*       Inputs:
*               - szLine: line with the value
*
*       Outputs:
*               - szLabel: value readed from the line (this must be allocated),
*                 szValue=="" if there is no value in the line.
*
*       Return value:
*               none
*
***********************************************************************/

void HeaderReadValue (char *szLine, char *szValue)
{
        unsigned int iIndex=0;

        /* we seek the ':' character and skip the blank after */
        while (szLine[iIndex] != ':')
        {
                if (iIndex == strlen (szLine))
                {
                        /* there is no value in this line */
                        strcpy (szValue, "");
                        return;
                }
                iIndex++;
        }

        /* skips the ': ' */
        iIndex+=2;

        /* at this point iIndex is the position of the first value character */

        /* szLine[iIndex] to skip the line before ': ' and -1 not to copy return carriage */
        strncpy (szValue, &szLine[iIndex], strlen (szLine)-iIndex-1);
        szValue[strlen (szLine)-iIndex-1] = '\0';
}

/* Write */

/***********************************************************************
*
*       Function void HeaderSetAsFloating (WSxM_HEADER *pHeader, char *szTitle, char *szLabel, double lfValue);
*
*       Description: sets a title-label couple value in double format to the
*               WSxM_HEADER object
*
*       Inputs:
*               - pHeader: pointer to the WSxM_HEADER object to set the value in
*               - szTitle: title of the field to be set
*               - szLabel: label of the field to be set
*               - lfValue: value to be set
*
*       Return value:
*               none
*
***********************************************************************/

void HeaderSetAsFloating        (WSxM_HEADER *pHeader, char *szTitle, char *szLabel, double lfValue)
{
  char szValue[WSXM_MAXCHARS] = "";

        /* converts the double value to a string value */
        sprintf (szValue, "%.61f",lfValue);

        /* sets the value in the WSxM_HEADER object as a string */
        HeaderSetAsString (pHeader, szTitle, szLabel, szValue);
}

/***********************************************************************
*
*       Function void HeaderSetAsInt (WSxM_HEADER *pHeader, char *szTitle, char *szLabel, int iValue);
*
*       Description: sets a title-label couple value in int format to the
*               WSxM_HEADER object
*
*       Inputs:
*               - pHeader: pointer to the WSxM_HEADER object to set the value in
*               - szTitle: title of the field to be set
*               - szLabel: label of the field to be set
*               - iValue: value to be set
*
*       Return value:
*               none
*
***********************************************************************/

void HeaderSetAsInt                     (WSxM_HEADER *pHeader, char *szTitle, char *szLabel, int iValue)
{
  char szValue[WSXM_MAXCHARS] = ""; 

        /* converts the int value to a string value */
    sprintf (szValue, "%d", iValue);

        /* sets the value in the WSxM_HEADER object as a string */
    HeaderSetAsString (pHeader, szTitle, szLabel, szValue);
}

/***********************************************************************
*
*       Function void HeaderSetAsInt (WSxM_HEADER *pHeader, char *szTitle, char *szLabel, int iValue);
*
*       Description: sets a title-label couple value in string format to the
*               WSxM_HEADER object
*
*       Inputs:
*                       - pHeader: pointer to the WSxM_HEADER object to set the value in
*                       - szTitle: title of the field to be set
*           - szLabel: label of the field to be set
*           - szValue: string value to be set
*
*       Return value:
*                       none
*
***********************************************************************/

void HeaderSetAsString          (WSxM_HEADER *pHeader, char *szTitle, char *szLabel, char *szValue)
{
        int iIndex;

        /* sets the value in the WSxM_HEADER object */

        /* seeks the title-label couple */
        for (iIndex=0; iIndex<pHeader->iNumFields; iIndex++)
        {
                if ((strcmp (szTitle, pHeader->tszTitles[iIndex]) == 0)&&(strcmp (szLabel, pHeader->tszLabels[iIndex]) == 0))
                {
                        /* title-label couple found at position iIndex */
                        /* updates the title-label couple value */
                        pHeader->tszValues[iIndex] = (char *) realloc (pHeader->tszValues[iIndex], (strlen (szValue)+1) * sizeof(char));
                        strcpy (pHeader->tszValues[iIndex], szValue);

                        return;
                }
        }

        /* title-label couple not found, is a new field */
        HeaderAddValue (pHeader, szTitle, szLabel, szValue);
}

/***********************************************************************
*
*       Function void HeaderDestroy (WSxM_HEADER *pHeader);
*
*       Description: frees all the allocated memory in the Header
*
***********************************************************************/

void HeaderDestroy (WSxM_HEADER *pHeader)
{
        int i; /* Counter */

        if (pHeader->iNumFields == 0) /* No need to destroy */
        {
                return;
        }

        for (i=0; i < pHeader->iNumFields; i++)
        {
                free (pHeader->tszTitles[i]);
                free (pHeader->tszLabels[i]);
                free (pHeader->tszValues[i]);
        }

        free (pHeader->tszTitles);
        free (pHeader->tszLabels);
        free (pHeader->tszValues);

        pHeader->tszTitles = NULL;
        pHeader->tszLabels = NULL;
        pHeader->tszValues = NULL;

        pHeader->iNumFields = 0;
}

/* Internally used functions */

/***********************************************************************
*
*       Function int HeaderReadLine (WSxM_HEADER *pHeader, FILE *pFile);
*
*       Description: Reads a text line from a file. It is important that the file
*                    should have been opened for reading, and the WSxM_HEADER should
*                    have been initializated calling HeaderInit
*
*       Inputs:
*               - pHeader: pointer to the WSxM_HEADER object to store the data in
*               - pFile: File pointer to read the header from
*
*       Outputs:
*               - pHeader: will be filled with the data read from pFile
*               - pFile: the file pointer will go to the end of the header
*
*       Return value:
*               0 if the header was correctly read, -1 elsewhere
*
***********************************************************************/

int HeaderReadLine (WSxM_HEADER *pHeader, FILE *pFile)
{
        /* multiplication in the string sizes is because the string can grow later */

        static char szTitle[WSXM_MAXCHARS*2] = "";
        char szLine[WSXM_MAXCHARS*2]; 
        char szTryTitle[WSXM_MAXCHARS*2];
        char szLabel[WSXM_MAXCHARS*2];
        char szValue[WSXM_MAXCHARS*2];
        char *szReturn;

        szReturn = fgets (szLine,WSXM_MAXCHARS,pFile);

        if (szReturn == NULL)
                return -1; /* File Error */

        /* Line read. We see the data it has */

        RemoveLeftAndRightWhitesFromString (szLine);

        /* Special characteres */

        ReplaceStringInString (szLine,"\\n","\r\n");
        ReplaceStringInString (szLine,"\\\\","\\");

        /* We try to read a label-value couple */

        HeaderReadLabel (szLine,szLabel);
        HeaderReadValue (szLine,szValue);

        /* We try to read it as a title */

    HeaderReadTitle (szLine,szTryTitle);

    if (strlen (szTryTitle) > 0) /* It is a title */
    {
                /* If it indicates the header end, we will return 1 */

                if (strcmp (szTryTitle,IMAGE_HEADER_END_TEXT) == 0)
                        return 1;
                else
                {
                        strcpy (szTitle,szTryTitle);
                        return 0;
                }
    }

        /* If it is not a header field (we have not read any title yet) we ignore it */

        if (strlen (szTitle) == 0)
        {
                return 0;
        }

        /* If it is not a couple label: value, we don't mind about this line */

    if (strlen (szLabel) != 0)
    {
        /* We have a new value. We add it to the header */

                HeaderAddValue (pHeader,szTitle,szLabel,szValue);
    }

        return 0;
}

/***********************************************************************
*
*       Function int HeaderGetSize (WSxM_HEADER *pHeader);
*
*       Description: Gets the size of the image header in the file.
*
*       Inputs:
*               - pHeader: pointer to the WSxM_HEADER object end of the header
*
*       Return value:
*               the size of the header, -1 on error
*
***********************************************************************/

int HeaderGetSize (WSxM_HEADER *pHeader)
{
        int i;
        int iSize = 0;         /* size at this moment                        */
        int iNumOfTitles = 0;  /* Number of titles written in the file       */
        int iNumDigits;        /* Number of digits for the image header size */
        char szTitle[100] = "", szLabel[100], szValue[WSXM_MAXCHARS]; 

        /* size of the pre-header and the carriage return */
        iSize = sizeof (TEXT_COPYRIGHT_NANOTEC) + sizeof (STM_IMAGE_FILE_ID) + sizeof (IMAGE_HEADER_SIZE_TEXT);

        /* size of all the fields in the HEADER object */
    for (i=0; i<pHeader->iNumFields; i++)
    {
                /* if there is a new title we increase the number of titles and adds its size */
        if (strcmp (szTitle, pHeader->tszTitles[i]) != 0)
        {
                        strcpy (szTitle, pHeader->tszTitles[i]);
            iNumOfTitles++;
            iSize += strlen (szTitle);
        }

                strcpy (szLabel, pHeader->tszLabels[i]);

                /* Special characteres in the szLabel string */
                ReplaceStringInString (szLabel,"\\n","\r\n");
                ReplaceStringInString (szLabel,"\\\\","\\");

                strcpy (szValue, pHeader->tszValues[i]);

                /* Special characteres in the szValue string */
                ReplaceStringInString (szValue,"\\n","\r\n");
                ReplaceStringInString (szValue,"\\\\","\\");
                RemoveLeftAndRightWhitesFromString (szValue);

                /* adds the size of the label and the value */
                iSize += strlen (szLabel) + strlen (szValue);
    }

        /* adds the size of the square brackets (2 bytes), the carriage return (3*2 bytes  */ 
        /* for each title)                                                                 */
        iSize += iNumOfTitles * (6 + 2);

        /* adds the size of the carriage return (2 bytes for each label) and the blanks (6 bytes for each label) */
        iSize += pHeader->iNumFields * (6 + 2);

        /* adds the size of the header end text, the square brackets and the carriage return */
        iSize += sizeof (IMAGE_HEADER_END_TEXT) + 2 + 4;

    /* adds the size of the characteres for the image header size in pre-header */
    iNumDigits = (int)floor(log10(iSize)) + 1;
    iSize += iNumDigits;
    if (iNumDigits != (int)floor((log10(iSize)) + 1))
        iSize++;

    return iSize;
}

/***********************************************************************
*
*       Function int HeaderAddValue (WSxM_HEADER *pHeader, char *szTitle, char *szLabel,char *szValue);
*
*       Description: adds the tripla title-label-value to the WSxM_HEADER object
*
*       Inputs:
*               - pHeader: pointer to the WSxM_HEADER object to store the data in
*               - szTitle: title of the field to be added
*               - szLabel: label of the field to be added
*               - szValue: string value to be added
*
*       Return value:
*               0 if the header was correctly updated, -1 elsewhere
*
***********************************************************************/

int     HeaderAddValue (WSxM_HEADER *pHeader, char *szTitle, char *szLabel,char *szValue)
{
        /* grows the three arrays for the new title-label-value tripla */
        pHeader->tszTitles = (char **) realloc (pHeader->tszTitles, (pHeader->iNumFields+1)*sizeof (char *));
        pHeader->tszLabels = (char **) realloc (pHeader->tszLabels, (pHeader->iNumFields+1)*sizeof (char *));
        pHeader->tszValues = (char **) realloc (pHeader->tszValues, (pHeader->iNumFields+1)*sizeof (char *));

        /* adds the title in the last position of the titles array allocating memory */
        pHeader->tszTitles[pHeader->iNumFields] = (char *) calloc (strlen (szTitle)+1, sizeof(char));
        if (pHeader->tszTitles[pHeader->iNumFields] == NULL) /* error */
        {
                return -1;
        }
        strcpy (pHeader->tszTitles[pHeader->iNumFields], szTitle);

        /* adds the label in the last position of the labels array allocating memory */
        pHeader->tszLabels[pHeader->iNumFields] = (char *) calloc (strlen (szLabel)+1, sizeof(char));
        if (pHeader->tszLabels[pHeader->iNumFields] == NULL) /* error */
        {
                /* frees the memory allocated in this function */
                free (pHeader->tszTitles[pHeader->iNumFields]);

                return -1;
        }
        strcpy (pHeader->tszLabels[pHeader->iNumFields], szLabel);

        /* adds the value in the last position of the values array allocating memory */
        pHeader->tszValues[pHeader->iNumFields] = (char *) calloc (strlen (szValue)+1, sizeof(char));
        if (pHeader->tszValues[pHeader->iNumFields] == NULL) /* error */
        {
                /* frees the memory allocated in this function */
                free (pHeader->tszTitles[pHeader->iNumFields]);
                free (pHeader->tszLabels[pHeader->iNumFields]);

                return -1;
        }
        strcpy (pHeader->tszValues[pHeader->iNumFields], szValue);

        /* increments the number of fields */
        pHeader->iNumFields++;

        return 0;
}

/***********************************************************************
*
*       Function void RemoveLeftAndRightWhitesFromString (char *szString);
*
*       Description: removes the white-space characteres (0x09, 0x0D or 0x20)
*               at the right and left of the string szString.
*
*       Inputs:
*                       - szString: the string we want to remove the white-space characteres
*
*   Outputs:
*           - szString: the string without white-space character
*
*       Return value:
*                       none
*
***********************************************************************/

void RemoveLeftAndRightWhitesFromString (char *szString)
{
        char szAuxString[WSXM_MAXCHARS];
        int iIndex = 0;

        /* Seeks the first non white-space character (0x09, 0x0D or 0x20) */
        while (isspace (szString[iIndex]))
        {
                iIndex++;
        }

        /* We copy the string without white-space characters at the left */
        strcpy (szAuxString, &szString[iIndex]);

        /* Seeks the last non white-space character (0x09, 0x0D or 0x20) */
        iIndex = strlen (szAuxString);
        while (isspace (szString[iIndex]))
        {
                iIndex--;
        }

        /* Puts the zero (mark of end of string) after the last non white-space character */
        szString[iIndex+1] = '\0';

        /* We copy the new szString without white-space characters */
        strcpy (szString, szAuxString);
}

/***********************************************************************
*
*       Function void ReplaceStringInString (char *szDest, const char *szOld, const char *szNew);
*
*       Description: replaces instances of the substring szOld with 
*               instances of the string szNew.
*
*       Inputs:
*               - szDest: the string where will be made the replacemets
*               - szOld: the substring to be replaced by lpszNew
*               - szNew: the substring replacing lpszOld
*
*      Outputs:
*               - szDest: the string with the replacements
*
*      Return value:
*               none
*
***********************************************************************/

void ReplaceStringInString (char *szDest, const char *szOld, const char *szNew)
{
        int iIndex=0, iAuxStringIndex=0;
        char szAuxString[WSXM_MAXCHARS];
        strcpy (szAuxString,"");
        /* We copy the string with the replacements to the auxiliar string */

        /* Searches for the substring szOld */
        while (szDest[iIndex]!='\0') /* while not end of string */
        {
                if (strncmp (&szDest[iIndex], szOld, strlen(szOld)) == 0)
                {
                        /* Writes the substring szNew in the substring szOld position */
                        strcpy (&szAuxString[iAuxStringIndex], szNew);
                        iAuxStringIndex += strlen (szNew);
                        iIndex += strlen (szOld);
                }
                else
                {
                        /* We copy the character without any change */
                        szAuxString[iAuxStringIndex] = szDest [iIndex];
                        iAuxStringIndex++;
                        iIndex++;
                }
        }

        /* Puts the zero (mark of end of string) to the auxiliar string */
        szAuxString[iAuxStringIndex] = '\0';

        /* We copy the new string to szDest */
        strcpy (szDest, szAuxString);
}

---