pico/tts/svox_ssml_parser.cpp

/*
 * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/

#include "svox_ssml_parser.h"
#include <utils/Log.h>
#include <cutils/jstring.h>
#include <string.h>
#include <utils/String16.h>

#define SSML_PITCH_XLOW     "50"
#define SSML_PITCH_LOW      "75"
#define SSML_PITCH_MEDIUM   "100"
#define SSML_PITCH_HIGH     "150"
#define SSML_PITCH_XHIGH    "200"
#define SSML_RATE_XSLOW     "30"
#define SSML_RATE_SLOW      "60"
#define SSML_RATE_MEDIUM    "100"
#define SSML_RATE_FAST      "250"
#define SSML_RATE_XFAST     "500"
#define SSML_VOLUME_SILENT  "0"
#define SSML_VOLUME_XLOW    "25"
#define SSML_VOLUME_LOW     "70"
#define SSML_VOLUME_MEDIUM  "120"
#define SSML_VOLUME_LOUD    "300"
#define SSML_VOLUME_XLOUD   "450"
#define SSML_BREAK_NONE     "0ms"
#define SSML_BREAK_XWEAK    "100ms"
#define SSML_BREAK_WEAK     "300ms"
#define SSML_BREAK_MEDIUM   "600ms"
#define SSML_BREAK_STRONG   "1s"
#define SSML_BREAK_XSTRONG  "3s"

extern int cnvIpaToXsampa(const char16_t* ipaString, size_t ipaStringSize, char** outXsampaString);
extern char * createPhonemeString( const char * xsampa, int length );

SvoxSsmlParser::SvoxSsmlParser() : m_isInBreak(0), m_appendix(NULL), m_docLanguage(NULL)
{
    mParser = XML_ParserCreate("UTF-8");
    if (mParser)
    {
        XML_SetElementHandler(mParser, starttagHandler, endtagHandler);
        XML_SetCharacterDataHandler(mParser, textHandler);
        XML_SetUserData(mParser, (void*)this);
        m_datasize = 512;
        m_data = new char[m_datasize];
        m_data[0] = '\0';
    }
}

SvoxSsmlParser::~SvoxSsmlParser()
{
    if (mParser)
        XML_ParserFree(mParser);
    if (m_data)
        delete [] m_data;
    if (m_appendix)
        delete [] m_appendix;
    if (m_docLanguage)
        delete [] m_docLanguage;
}

int SvoxSsmlParser::initSuccessful()
{
    return (mParser && m_data);
}

int SvoxSsmlParser::parseDocument(const char* ssmldoc, int isFinal)
{
    int doclen = (int)strlen(ssmldoc) + 1;
    int status = XML_Parse(mParser, ssmldoc, doclen, isFinal);
    if (status == XML_STATUS_ERROR)
    {
        /* Note: for some reason Expat almost always complains about invalid tokens, even when document is well formed */
        ALOGI("Parser error at line %d: %s\n", (int)XML_GetCurrentLineNumber(mParser), XML_ErrorString(XML_GetErrorCode(mParser)));
    }
    return status;
}

char* SvoxSsmlParser::getParsedDocument()
{
    return m_data;
}

char* SvoxSsmlParser::getParsedDocumentLanguage()
{
    return m_docLanguage;
}

void SvoxSsmlParser::starttagHandler(void* data, const XML_Char* element, const XML_Char** attributes)
{
    ((SvoxSsmlParser*)data)->startElement(element, attributes);
}

void SvoxSsmlParser::startElement(const XML_Char* element, const XML_Char** attributes)
{
    if (strcmp(element, "speak") == 0)
    {
        if (strlen(m_data) > 0)
        {
            /* we have old data, get rid of it and reallocate memory */
            delete m_data;
            m_data = NULL;
            m_datasize = 512;
            m_data = new char[m_datasize];
            if (!m_data)
            {
                ALOGE("Error: failed to allocate memory for string!\n");
                return;
            }
        }

        /* the only attribute supported in the speak tag is xml:lang, all others are ignored */
        for (int i = 0; attributes[i]; i += 2)
        {
            if (strcmp(attributes[i], "xml:lang") == 0)
            {
                if (!m_docLanguage)
                {
                    m_docLanguage = new char[strlen(attributes[i+1])+1];
                }
                strcpy(m_docLanguage, attributes[i+1]);
                break;
            }
        }
    }
    else if (strcmp(element, "p") == 0) /* currently no attributes are supported for <p> */
    {
        if (strlen(m_data) + 4 > (size_t)m_datasize)
        {
            if (!growDataSize(100))
            {
                ALOGE("Error: failed to allocate memory for string!\n");
                return;
            }
        }
        strcat(m_data, "<p>");
    }
    else if (strcmp(element, "s") == 0) /* currently no attributes are supported for <s> */
    {
        if (strlen(m_data) + 4 > (size_t)m_datasize)
        {
            if (!growDataSize(100))
            {
                ALOGE("Error: failed to allocate memory for string!\n");
                return;
            }
        }
        strcat(m_data, "<s>");
    }
    else if (strcmp(element, "phoneme") == 0) /* only ipa and xsampa alphabets are supported */
    {
        int alpha = 1; /* set to 1 if alphabet is ipa */
        int tagComplete = 0; /* set to 1 if phoneme tag has already been added */
    char16_t* ph = NULL;
        char* xsampastr = NULL;
    size_t phsize = 0;
    size_t xsampasize = 0;

        for (int i = 0; attributes[i]; i += 2)
        {
            if (strcmp(attributes[i], "alphabet") == 0)
            {
                if (strcmp(attributes[i+1], "xsampa") == 0)
                {
                    alpha = 0;
                }
            }
            if (strcmp(attributes[i], "ph") == 0)
            {
          ph = new char16_t[strlen8to16(attributes[i+1]) + 1];
          ph = strdup8to16(attributes[i+1], &phsize);
            }
        }
        if (!ph)
        {
            /* error, no phonetic string */
            ALOGE("Error: bad SSML syntax, ph attribute not supplied.");
            return;
        }

        if (alpha)
        {
          /* need to convert phoneme string to xsampa */
      xsampasize = cnvIpaToXsampa(ph, phsize, &xsampastr);
      delete [] ph;
      if (!xsampastr)
            {
                ALOGE("Error: failed to allocate memory for IPA string conversion");
                return;
            }
        }
        else
        {
      xsampastr = strndup16to8(ph, phsize);
      xsampasize = strlen(xsampastr);
          delete [] ph;
        }

        /* split XSAMPA string into multiple phonemes if needed */
        if (strstr(xsampastr, " ") || strstr(xsampastr, "#")) /* check again to see if we have multiple words */
        {
            char* phonstr = createPhonemeString(xsampastr, strlen(xsampastr) + 1);
            free(xsampastr);
            xsampastr = NULL;
            xsampastr = (char*)malloc(strlen(phonstr) + 1);
            strcpy(xsampastr, phonstr);
            free(phonstr);
            phonstr = NULL;
            tagComplete = 1;
        }

        if (tagComplete)
        {
            if (strlen(m_data) + strlen(xsampastr) + 1 > (size_t)m_datasize)
            {
                if (!growDataSize(100))
                {
                    ALOGE("Error: failed to allocate memory for string!");
                    free(xsampastr);
                    return;
                }
            }
        }
        else
        {
            if (strlen(m_data) + strlen(xsampastr) + 17 > (size_t)m_datasize)
            {
                if (!growDataSize(100))
                {
                    ALOGE("Error: failed to allocate memory for string!");
                    free(xsampastr);
                    return;
                }
            }
            strcat(m_data, "<phoneme ph='");
        }

        strcat(m_data, xsampastr);
        free(xsampastr);

    if (!tagComplete)
      {
        if (strlen(m_data) + 4 > (size_t)m_datasize)
          {
        if (!growDataSize(100))
          {
            ALOGE("Error: failed to allocate memory for string!\n");
            return;
          }
          }
        strcat(m_data, "'/>");
      }

        m_isInBreak = 1; /* set flag to indicate any text between open and close tag is to be discarded */
    }
    else if (strcmp(element, "break") == 0)
    {
        if (strlen(m_data) + 17 > (size_t)m_datasize)
        {
            if (!growDataSize(100))
            {
                ALOGE("Error: failed to allocate memory for string!\n");
                return;
            }
        }
        strcat(m_data, "<break time='");
        char* time = NULL;

        for (int i = 0; attributes[i]; i += 2)
        {
            if (strcmp(attributes[i], "time") == 0)
            {
                time = new char[strlen(attributes[i+1]) + 1];
                if (!time)
                {
                    ALOGE("Error: failed to allocate memory for string!\n");
                    return;
                }
                strcpy(time, attributes[i+1]);
            }
            else if (strcmp(attributes[i], "strength") == 0 && !time)
            {
                time = convertBreakStrengthToTime(attributes[i+1]);
            }
        }
        if (!time)
        {
            time = new char[6];
            if (!time)
            {
                ALOGE("Error: failed to allocate memory for string!\n");
                return;
            }
            strcpy(time, SSML_BREAK_WEAK); /* if no time or strength attributes are specified, default to weak break */
        }
        if (strlen(m_data) + strlen(time) + 4 > (size_t)m_datasize)
        {
            if (!growDataSize(100))
            {
                ALOGE("Error: failed to allocate memory for string!\n");
                return;
            }
        }
        strcat(m_data, time);
        strcat(m_data, "'/>");
        m_isInBreak = 1; /* set flag to indicate any text between open and close tag is to be discarded */
    }
    else if (strcmp(element, "prosody") == 0) /* only pitch, rate and volume attributes are supported */
    {
        for (int i = 0; attributes[i]; i += 2)
        {
            if (strcmp(attributes[i], "pitch") == 0)
            {
                char* svoxpitch = convertToSvoxPitch(attributes[i+1]);
                if (!svoxpitch)
                {
                    ALOGE("Error: failed to allocate memory for string!\n");
                    return;
                }
                if (!svoxpitch)
                {
                    svoxpitch = new char[4];
                    if (!svoxpitch)
                    {
                        ALOGE("Error: failed to allocate memory for string!\n");
                        return;
                    }
                    strcpy(svoxpitch, "100");
                }
                char* pitch = new char[17 + strlen(svoxpitch)];
                if (!pitch)
                {
                    ALOGE("Error: failed to allocate memory for string!\n");
                    return;
                }
                sprintf(pitch, "<pitch level='%s'>", svoxpitch);
                if (strlen(m_data) + strlen(pitch) + 1 > (size_t)m_datasize)
                {
                    if (!growDataSize(100))
                    {
                        ALOGE("Error: failed to allocate memory for string!\n");
                        return;
                    }
                }
                strcat(m_data, pitch);
                if (!m_appendix)
                {
                    m_appendix = new char[30];
                    m_appendix[0] = '\0';
                }
                strcat(m_appendix, "</pitch>");
                delete [] svoxpitch;
                delete [] pitch;
            }
            else if (strcmp(attributes[i], "rate") == 0)
            {
                char* svoxrate = convertToSvoxRate(attributes[i+1]);
                if (!svoxrate)
                {
                    svoxrate = new char[4];
                    if (!svoxrate)
                    {
                        ALOGE("Error: failed to allocate memory for string!\n");
                        return;
                    }
                    strcpy(svoxrate, "100");
                }
                char* rate = new char[17 + strlen(svoxrate)];
                if (!rate)
                {
                    ALOGE("Error: failed to allocate memory for string!\n");
                    return;
                }
                sprintf(rate, "<speed level='%s'>", svoxrate);
                if (strlen(m_data) + strlen(rate) + 1 > (size_t)m_datasize)
                {
                    if (!growDataSize(100))
                    {
                        ALOGE("Error: failed to allocate memory for string!\n");
                        return;
                    }
                }
                strcat(m_data, rate);
                if (!m_appendix)
                {
                    m_appendix = new char[30];
                    if (!m_appendix)
                    {
                        ALOGE("Error: failed to allocate memory for string!\n");
                        return;
                    }
                    m_appendix[0] = '\0';
                }
                strcat(m_appendix, "</speed>");
                delete [] svoxrate;
                delete [] rate;
            }
            else if (strcmp(attributes[i], "volume") == 0)
            {
                char* svoxvol = convertToSvoxVolume(attributes[i+1]);
                if (!svoxvol)
                {
                    svoxvol = new char[4];
                    if (!svoxvol)
                    {
                        ALOGE("Error: failed to allocate memory for string!\n");
                        return;
                    }
                    strcpy(svoxvol, "100");
                }
                char* volume = new char[18 + strlen(svoxvol)];
                if (!volume)
                {
                    ALOGE("Error: failed to allocate memory for string!\n");
                    return;
                }
                sprintf(volume, "<volume level='%s'>", svoxvol);
                if (strlen(m_data) + strlen(volume) + 1 > (size_t)m_datasize)
                {
                    if (!growDataSize(100))
                    {
                        ALOGE("Error: failed to allocate memory for string!\n");
                        return;
                    }
                }
                strcat(m_data, volume);
                if (!m_appendix)
                {
                    m_appendix = new char[30];
                    m_appendix[0] = '\0';
                }
                strcat(m_appendix, "</volume>");
                delete [] svoxvol;
                delete [] volume;
            }
        }
    }
    else if (strcmp(element, "audio") == 0) /* only 16kHz 16bit wav files are supported as src */
    {
        if (strlen(m_data) + 17 > (size_t)m_datasize)
        {
            if (!growDataSize(100))
            {
                ALOGE("Error: failed to allocate memory for string!\n");
                return;
            }
        }
        strcat(m_data, "<usesig file='");

        for (int i = 0; attributes[i]; i += 2)
        {
            if (strcmp(attributes[i], "src") == 0)
            {
                if (strlen(m_data) + strlen(attributes[i+1]) + 1 > (size_t)m_datasize)
                {
                    if (!growDataSize(100))
                    {
                        ALOGE("Error: failed to allocate memory for string!\n");
                        return;
                    }
                }
                strcat(m_data, attributes[i+1]);
            }
        }
        strcat(m_data, "'>");
    }
}

void SvoxSsmlParser::endtagHandler(void* data, const XML_Char* element)
{
    ((SvoxSsmlParser*)data)->endElement(element);
}

void SvoxSsmlParser::endElement(const XML_Char* element)
{
    if (strcmp(element, "speak") == 0)
    {
      /* do nothing */
    }
    else if (strcmp(element, "p") == 0)
    {
        if (strlen(m_data) + 5 > (size_t)m_datasize)
        {
            if (!growDataSize(100))
            {
                ALOGE("Error: failed to allocate memory for string!\n");
                return;
            }
        }
        strcat(m_data, "</p>");
    }
    else if (strcmp(element, "s") == 0)
    {
        if (strlen(m_data) + 5 > (size_t)m_datasize)
        {
            if (!growDataSize(100))
            {
                ALOGE("Error: failed to allocate memory for string!\n");
                return;
            }
        }
        strcat(m_data, "</s>");
    }
    else if (strcmp(element, "phoneme") == 0)
    {
        m_isInBreak = 0; /* indicate we are no longer in phoneme tag */
    }
    else if (strcmp(element, "break") == 0)
    {
        m_isInBreak = 0; /* indicate we are no longer in break tag */
    }
    else if (strcmp(element, "prosody") == 0)
    {
        if (m_appendix)
        {
            if (strlen(m_data) + strlen(m_appendix) + 1 > (size_t)m_datasize)
            {
                if (!growDataSize(100))
                {
                    ALOGE("Error: failed to allocate memory for string!\n");
                    return;
                }
            }
            strcat(m_data, m_appendix);
            delete [] m_appendix;
            m_appendix = NULL;
        }
    }
    else if (strcmp(element, "audio") == 0)
    {
        if (strlen(m_data) + 10 > (size_t)m_datasize)
        {
            if (!growDataSize(100))
            {
                ALOGE("Error: failed to allocate memory for string!\n");
                return;
            }
        }
        strcat(m_data, "</usesig>");
    }
}

void SvoxSsmlParser::textHandler(void* data, const XML_Char* text, int length)
{
    ((SvoxSsmlParser*)data)->textElement(text, length);
}

void SvoxSsmlParser::textElement(const XML_Char* text, int length)
{
    if (m_isInBreak)
    {
        return; /* handles the case when someone has added text inside the break or phoneme tag - this text is thrown away */
    }

    char* content = new char[length + 1];
    if (!content)
    {
        ALOGE("Error: failed to allocate memory for string!\n");
        return;
    }
    strncpy(content, text, length);
    content[length] = '\0';

    if (strlen(m_data) + strlen(content) + 1 > (size_t)m_datasize)
    {
        if (!growDataSize(100))
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return;
        }
    }
    strcat(m_data, content);
    delete [] content;
}

/**
convertToSvoxPitch
Converts SSML pitch labels to SVOX pitch levels
*/
char* SvoxSsmlParser::convertToSvoxPitch(const char* value)
{
    char* converted = NULL;
    if (strcmp(value, "x-low") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_PITCH_XLOW);
    }
    else if (strcmp(value, "low") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_PITCH_LOW);
    }
    else if (strcmp(value, "medium") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_PITCH_MEDIUM);
    }
    else if (strcmp(value, "default") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_PITCH_MEDIUM);
    }
    else if (strcmp(value, "high") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_PITCH_HIGH);
    }
    else if (strcmp(value, "x-high") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_PITCH_XHIGH);
    }
    return converted;
}

/**
    convertToSvoxRate
    Converts SSML rate labels to SVOX speed levels
*/
char* SvoxSsmlParser::convertToSvoxRate(const char* value)
{
    char* converted = NULL;
    if (strcmp(value, "x-slow") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_RATE_XSLOW);
    }
    else if (strcmp(value, "slow") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_RATE_SLOW);
    }
    else if (strcmp(value, "medium") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_RATE_MEDIUM);
    }
    else if (strcmp(value, "default") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_RATE_MEDIUM);
    }
    else if (strcmp(value, "fast") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_RATE_FAST);
    }
    else if (strcmp(value, "x-fast") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_RATE_XFAST);
    }
    return converted;
}

/**
convertToSvoxVolume
Converts SSML volume labels to SVOX volume levels
*/
char* SvoxSsmlParser::convertToSvoxVolume(const char* value)
{
    char* converted = NULL;
    if (strcmp(value, "silent") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_VOLUME_SILENT);
    }
    else if (strcmp(value, "x-low") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_VOLUME_XLOW);
    }
    else if (strcmp(value, "low") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_VOLUME_LOW);
    }
    else if (strcmp(value, "medium") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_VOLUME_MEDIUM);
    }
    else if (strcmp(value, "default") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_VOLUME_MEDIUM);
    }
    else if (strcmp(value, "loud") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_VOLUME_LOUD);
    }
    else if (strcmp(value, "x-loud") == 0)
    {
        converted = new char[4];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_VOLUME_XLOUD);
    }
    return converted;
}

/**
convertBreakStrengthToTime
Converts SSML break strength labels to SVOX break time
*/
char* SvoxSsmlParser::convertBreakStrengthToTime(const char* value)
{
    char* converted = NULL;
    if (strcmp(value, "none") == 0)
    {
        converted = new char[6];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_BREAK_NONE);
    }
    else if (strcmp(value, "x-weak") == 0)
    {
        converted = new char[6];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_BREAK_XWEAK);
    }
    else if (strcmp(value, "weak") == 0)
    {
        converted = new char[6];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_BREAK_WEAK);
    }
    else if (strcmp(value, "medium") == 0)
    {
        converted = new char[6];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_BREAK_MEDIUM);
    }
    else if (strcmp(value, "strong") == 0)
    {
        converted = new char[6];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_BREAK_STRONG);
    }
    else if (strcmp(value, "x-strong") == 0)
    {
        converted = new char[6];
        if (!converted)
        {
            ALOGE("Error: failed to allocate memory for string!\n");
            return NULL;
        }
        strcpy(converted, SSML_BREAK_XSTRONG);
    }
    return converted;
}

/**
growDataSize
Increases the size of the internal text storage member
*/
int SvoxSsmlParser::growDataSize(int sizeToGrow)
{
    char* tmp = new char[m_datasize];
    if (!tmp)
        return 0;

    strcpy(tmp, m_data);
    delete [] m_data;
    m_data = NULL;
    m_data = new char[m_datasize + sizeToGrow];
    if (!m_data)
    {
        m_data = tmp;
        return 0;
    }
    m_datasize += sizeToGrow;
    strcpy(m_data, tmp);
    delete [] tmp;
    tmp = NULL;
    return 1;
}