/** \file
* Implementation of the ANTLR3 string and string factory classes
*/
// [The "BSD licence"]
// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
// http://www.temporal-wave.com
// http://www.linkedin.com/in/jimidle
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// 3. The name of the author may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <antlr3string.h>
/* Factory API
*/
static pANTLR3_STRING newRaw8 (pANTLR3_STRING_FACTORY factory);
static pANTLR3_STRING newRawUTF16 (pANTLR3_STRING_FACTORY factory);
static pANTLR3_STRING newSize8 (pANTLR3_STRING_FACTORY factory, ANTLR3_UINT32 size);
static pANTLR3_STRING newSizeUTF16 (pANTLR3_STRING_FACTORY factory, ANTLR3_UINT32 size);
static pANTLR3_STRING newPtr8 (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 string, ANTLR3_UINT32 size);
static pANTLR3_STRING newPtrUTF16_8 (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 string, ANTLR3_UINT32 size);
static pANTLR3_STRING newPtrUTF16_UTF16 (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 string, ANTLR3_UINT32 size);
static pANTLR3_STRING newStr8 (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 string);
static pANTLR3_STRING newStrUTF16_8 (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 string);
static pANTLR3_STRING newStrUTF16_UTF16 (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 string);
static void destroy (pANTLR3_STRING_FACTORY factory, pANTLR3_STRING string);
static pANTLR3_STRING printable8 (pANTLR3_STRING_FACTORY factory, pANTLR3_STRING string);
static pANTLR3_STRING printableUTF16 (pANTLR3_STRING_FACTORY factory, pANTLR3_STRING string);
static void closeFactory(pANTLR3_STRING_FACTORY factory);
/* String API
*/
static pANTLR3_UINT8 set8 (pANTLR3_STRING string, const char * chars);
static pANTLR3_UINT8 setUTF16_8 (pANTLR3_STRING string, const char * chars);
static pANTLR3_UINT8 setUTF16_UTF16 (pANTLR3_STRING string, const char * chars);
static pANTLR3_UINT8 append8 (pANTLR3_STRING string, const char * newbit);
static pANTLR3_UINT8 appendUTF16_8 (pANTLR3_STRING string, const char * newbit);
static pANTLR3_UINT8 appendUTF16_UTF16 (pANTLR3_STRING string, const char * newbit);
static pANTLR3_UINT8 insert8 (pANTLR3_STRING string, ANTLR3_UINT32 point, const char * newbit);
static pANTLR3_UINT8 insertUTF16_8 (pANTLR3_STRING string, ANTLR3_UINT32 point, const char * newbit);
static pANTLR3_UINT8 insertUTF16_UTF16 (pANTLR3_STRING string, ANTLR3_UINT32 point, const char * newbit);
static pANTLR3_UINT8 setS (pANTLR3_STRING string, pANTLR3_STRING chars);
static pANTLR3_UINT8 appendS (pANTLR3_STRING string, pANTLR3_STRING newbit);
static pANTLR3_UINT8 insertS (pANTLR3_STRING string, ANTLR3_UINT32 point, pANTLR3_STRING newbit);
static pANTLR3_UINT8 addc8 (pANTLR3_STRING string, ANTLR3_UINT32 c);
static pANTLR3_UINT8 addcUTF16 (pANTLR3_STRING string, ANTLR3_UINT32 c);
static pANTLR3_UINT8 addi8 (pANTLR3_STRING string, ANTLR3_INT32 i);
static pANTLR3_UINT8 addiUTF16 (pANTLR3_STRING string, ANTLR3_INT32 i);
static pANTLR3_UINT8 inserti8 (pANTLR3_STRING string, ANTLR3_UINT32 point, ANTLR3_INT32 i);
static pANTLR3_UINT8 insertiUTF16 (pANTLR3_STRING string, ANTLR3_UINT32 point, ANTLR3_INT32 i);
static ANTLR3_UINT32 compare8 (pANTLR3_STRING string, const char * compStr);
static ANTLR3_UINT32 compareUTF16_8 (pANTLR3_STRING string, const char * compStr);
static ANTLR3_UINT32 compareUTF16_UTF16(pANTLR3_STRING string, const char * compStr);
static ANTLR3_UINT32 compareS (pANTLR3_STRING string, pANTLR3_STRING compStr);
static ANTLR3_UCHAR charAt8 (pANTLR3_STRING string, ANTLR3_UINT32 offset);
static ANTLR3_UCHAR charAtUTF16 (pANTLR3_STRING string, ANTLR3_UINT32 offset);
static pANTLR3_STRING subString8 (pANTLR3_STRING string, ANTLR3_UINT32 startIndex, ANTLR3_UINT32 endIndex);
static pANTLR3_STRING subStringUTF16 (pANTLR3_STRING string, ANTLR3_UINT32 startIndex, ANTLR3_UINT32 endIndex);
static ANTLR3_INT32 toInt32_8 (pANTLR3_STRING string);
static ANTLR3_INT32 toInt32_UTF16 (pANTLR3_STRING string);
static pANTLR3_STRING to8_8 (pANTLR3_STRING string);
static pANTLR3_STRING to8_UTF16 (pANTLR3_STRING string);
static pANTLR3_STRING toUTF8_8 (pANTLR3_STRING string);
static pANTLR3_STRING toUTF8_UTF16 (pANTLR3_STRING string);
/* Local helpers
*/
static void stringInit8 (pANTLR3_STRING string);
static void stringInitUTF16 (pANTLR3_STRING string);
static void ANTLR3_CDECL stringFree (pANTLR3_STRING string);
ANTLR3_API pANTLR3_STRING_FACTORY
antlr3StringFactoryNew(ANTLR3_UINT32 encoding)
{
pANTLR3_STRING_FACTORY factory;
/* Allocate memory
*/
factory = (pANTLR3_STRING_FACTORY) ANTLR3_CALLOC(1, sizeof(ANTLR3_STRING_FACTORY));
if (factory == NULL)
{
return NULL;
}
/* Now we make a new list to track the strings.
*/
factory->strings = antlr3VectorNew(0);
factory->index = 0;
if (factory->strings == NULL)
{
ANTLR3_FREE(factory);
return NULL;
}
// Install the API
//
// TODO: These encodings need equivalent functions to
// UTF16 and 8Bit if I am going to support those encodings in the STRING stuff.
// The STRING stuff was intended as a quick and dirty hack for people that did not
// want to worry about memory and performance very much, but nobody ever reads the
// notes or comments or uses the email list search. I want to discourage using these
// interfaces as it is much more efficient to use the pointers within the tokens
// directly, so I am not implementing the string stuff for the newer encodings.
// We install the standard 8 and 16 bit functions for the UTF 8 and 16 but they
// will not be useful beyond returning the text.
//
switch(encoding)
{
case ANTLR3_ENC_UTF32:
break;
case ANTLR3_ENC_UTF32BE:
break;
case ANTLR3_ENC_UTF32LE:
break;
case ANTLR3_ENC_UTF16BE:
case ANTLR3_ENC_UTF16LE:
case ANTLR3_ENC_UTF16:
factory->newRaw = newRawUTF16;
factory->newSize = newSizeUTF16;
factory->newPtr = newPtrUTF16_UTF16;
factory->newPtr8 = newPtrUTF16_8;
factory->newStr = newStrUTF16_UTF16;
factory->newStr8 = newStrUTF16_8;
factory->printable = printableUTF16;
factory->destroy = destroy;
factory->close = closeFactory;
break;
case ANTLR3_ENC_UTF8:
case ANTLR3_ENC_EBCDIC:
case ANTLR3_ENC_8BIT:
default:
factory->newRaw = newRaw8;
factory->newSize = newSize8;
factory->newPtr = newPtr8;
factory->newPtr8 = newPtr8;
factory->newStr = newStr8;
factory->newStr8 = newStr8;
factory->printable = printable8;
factory->destroy = destroy;
factory->close = closeFactory;
break;
}
return factory;
}
/**
*
* \param factory
* \return
*/
static pANTLR3_STRING
newRaw8 (pANTLR3_STRING_FACTORY factory)
{
pANTLR3_STRING string;
string = (pANTLR3_STRING) ANTLR3_MALLOC(sizeof(ANTLR3_STRING));
if (string == NULL)
{
return NULL;
}
/* Structure is allocated, now fill in the API etc.
*/
stringInit8(string);
string->factory = factory;
/* Add the string into the allocated list
*/
factory->strings->set(factory->strings, factory->index, (void *) string, (void (ANTLR3_CDECL *)(void *))(stringFree), ANTLR3_TRUE);
string->index = factory->index++;
return string;
}
/**
*
* \param factory
* \return
*/
static pANTLR3_STRING
newRawUTF16 (pANTLR3_STRING_FACTORY factory)
{
pANTLR3_STRING string;
string = (pANTLR3_STRING) ANTLR3_MALLOC(sizeof(ANTLR3_STRING));
if (string == NULL)
{
return NULL;
}
/* Structure is allocated, now fill in the API etc.
*/
stringInitUTF16(string);
string->factory = factory;
/* Add the string into the allocated list
*/
factory->strings->set(factory->strings, factory->index, (void *) string, (void (ANTLR3_CDECL *)(void *))(stringFree), ANTLR3_TRUE);
string->index = factory->index++;
return string;
}
static
void ANTLR3_CDECL stringFree (pANTLR3_STRING string)
{
/* First free the string itself if there was anything in it
*/
if (string->chars)
{
ANTLR3_FREE(string->chars);
}
/* Now free the space for this string
*/
ANTLR3_FREE(string);
return;
}
/**
*
* \param string
* \return
*/
static void
stringInit8 (pANTLR3_STRING string)
{
string->len = 0;
string->size = 0;
string->chars = NULL;
string->encoding = ANTLR3_ENC_8BIT ;
/* API for 8 bit strings*/
string->set = set8;
string->set8 = set8;
string->append = append8;
string->append8 = append8;
string->insert = insert8;
string->insert8 = insert8;
string->addi = addi8;
string->inserti = inserti8;
string->addc = addc8;
string->charAt = charAt8;
string->compare = compare8;
string->compare8 = compare8;
string->subString = subString8;
string->toInt32 = toInt32_8;
string->to8 = to8_8;
string->toUTF8 = toUTF8_8;
string->compareS = compareS;
string->setS = setS;
string->appendS = appendS;
string->insertS = insertS;
}
/**
*
* \param string
* \return
*/
static void
stringInitUTF16 (pANTLR3_STRING string)
{
string->len = 0;
string->size = 0;
string->chars = NULL;
string->encoding = ANTLR3_ENC_8BIT;
/* API for UTF16 strings */
string->set = setUTF16_UTF16;
string->set8 = setUTF16_8;
string->append = appendUTF16_UTF16;
string->append8 = appendUTF16_8;
string->insert = insertUTF16_UTF16;
string->insert8 = insertUTF16_8;
string->addi = addiUTF16;
string->inserti = insertiUTF16;
string->addc = addcUTF16;
string->charAt = charAtUTF16;
string->compare = compareUTF16_UTF16;
string->compare8 = compareUTF16_8;
string->subString = subStringUTF16;
string->toInt32 = toInt32_UTF16;
string->to8 = to8_UTF16;
string->toUTF8 = toUTF8_UTF16;
string->compareS = compareS;
string->setS = setS;
string->appendS = appendS;
string->insertS = insertS;
}
/**
*
* \param string
* \return
* TODO: Implement UTF-8
*/
static void
stringInitUTF8 (pANTLR3_STRING string)
{
string->len = 0;
string->size = 0;
string->chars = NULL;
/* API */
}
// Convert an 8 bit string into a UTF8 representation, which is in fact just the string itself
// a memcpy as we make no assumptions about the 8 bit encoding.
//
static pANTLR3_STRING
toUTF8_8 (pANTLR3_STRING string)
{
return string->factory->newPtr(string->factory, (pANTLR3_UINT8)(string->chars), string->len);
}
// Convert a UTF16 string into a UTF8 representation using the Unicode.org
// supplied C algorithms, which are now contained within the ANTLR3 C runtime
// as permitted by the Unicode license (within the source code antlr3convertutf.c/.h
// UCS2 has the same encoding as UTF16 so we can use UTF16 converter.
//
static pANTLR3_STRING
toUTF8_UTF16 (pANTLR3_STRING string)
{
UTF8 * outputEnd;
UTF16 * inputEnd;
pANTLR3_STRING utf8String;
ConversionResult cResult;
// Allocate the output buffer, which needs to accommodate potentially
// 3X (in bytes) the input size (in chars).
//
utf8String = string->factory->newStr8(string->factory, (pANTLR3_UINT8)"");
if (utf8String != NULL)
{
// Free existing allocation
//
ANTLR3_FREE(utf8String->chars);
// Reallocate according to maximum expected size
//
utf8String->size = string->len *3;
utf8String->chars = (pANTLR3_UINT8)ANTLR3_MALLOC(utf8String->size +1);
if (utf8String->chars != NULL)
{
inputEnd = (UTF16 *) (string->chars);
outputEnd = (UTF8 *) (utf8String->chars);
// Call the Unicode converter
//
cResult = ConvertUTF16toUTF8
(
(const UTF16**)&inputEnd,
((const UTF16 *)(string->chars)) + string->len,
&outputEnd,
outputEnd + utf8String->size - 1,
lenientConversion
);
// We don't really care if things failed or not here, we just converted
// everything that was vaguely possible and stopped when it wasn't. It is
// up to the grammar programmer to verify that the input is sensible.
//
utf8String->len = ANTLR3_UINT32_CAST(((pANTLR3_UINT8)outputEnd) - utf8String->chars);
*(outputEnd+1) = '\0'; // Always null terminate
}
}
return utf8String;
}
/**
* Creates a new string with enough capacity for size 8 bit characters plus a terminator.
*
* \param[in] factory - Pointer to the string factory that owns strings
* \param[in] size - In characters
* \return pointer to the new string.
*/
static pANTLR3_STRING
newSize8 (pANTLR3_STRING_FACTORY factory, ANTLR3_UINT32 size)
{
pANTLR3_STRING string;
string = factory->newRaw(factory);
if (string == NULL)
{
return string;
}
/* Always add one more byte for a terminator ;-)
*/
string->chars = (pANTLR3_UINT8) ANTLR3_MALLOC((size_t)(sizeof(ANTLR3_UINT8) * (size+1)));
*(string->chars) = '\0';
string->size = size + 1;
return string;
}
/**
* Creates a new string with enough capacity for size UTF16 characters plus a terminator.
*
* \param[in] factory - Pointer to the string factory that owns strings
* \param[in] size - In characters (count double for surrogate pairs!!!)
* \return pointer to the new string.
*/
static pANTLR3_STRING
newSizeUTF16 (pANTLR3_STRING_FACTORY factory, ANTLR3_UINT32 size)
{
pANTLR3_STRING string;
string = factory->newRaw(factory);
if (string == NULL)
{
return string;
}
/* Always add one more byte for a terminator ;-)
*/
string->chars = (pANTLR3_UINT8) ANTLR3_MALLOC((size_t)(sizeof(ANTLR3_UINT16) * (size+1)));
*(string->chars) = '\0';
string->size = size+1; /* Size is always in characters, as is len */
return string;
}
/** Creates a new 8 bit string initialized with the 8 bit characters at the
* supplied ptr, of pre-determined size.
* \param[in] factory - Pointer to the string factory that owns the strings
* \param[in] ptr - Pointer to 8 bit encoded characters
* \return pointer to the new string
*/
static pANTLR3_STRING
newPtr8 (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 ptr, ANTLR3_UINT32 size)
{
pANTLR3_STRING string;
string = factory->newSize(factory, size);
if (string == NULL)
{
return NULL;
}
if (size <= 0)
{
return string;
}
if (ptr != NULL)
{
ANTLR3_MEMMOVE(string->chars, (const void *)ptr, size);
*(string->chars + size) = '\0'; /* Terminate, these strings are usually used for Token streams and printing etc. */
string->len = size;
}
return string;
}
/** Creates a new UTF16 string initialized with the 8 bit characters at the
* supplied 8 bit character ptr, of pre-determined size.
* \param[in] factory - Pointer to the string factory that owns the strings
* \param[in] ptr - Pointer to 8 bit encoded characters
* \return pointer to the new string
*/
static pANTLR3_STRING
newPtrUTF16_8 (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 ptr, ANTLR3_UINT32 size)
{
pANTLR3_STRING string;
/* newSize accepts size in characters, not bytes
*/
string = factory->newSize(factory, size);
if (string == NULL)
{
return NULL;
}
if (size <= 0)
{
return string;
}
if (ptr != NULL)
{
pANTLR3_UINT16 out;
ANTLR3_INT32 inSize;
out = (pANTLR3_UINT16)(string->chars);
inSize = size;
while (inSize-- > 0)
{
*out++ = (ANTLR3_UINT16)(*ptr++);
}
/* Terminate, these strings are usually used for Token streams and printing etc.
*/
*(((pANTLR3_UINT16)(string->chars)) + size) = '\0';
string->len = size;
}
return string;
}
/** Creates a new UTF16 string initialized with the UTF16 characters at the
* supplied ptr, of pre-determined size.
* \param[in] factory - Pointer to the string factory that owns the strings
* \param[in] ptr - Pointer to UTF16 encoded characters
* \return pointer to the new string
*/
static pANTLR3_STRING
newPtrUTF16_UTF16 (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 ptr, ANTLR3_UINT32 size)
{
pANTLR3_STRING string;
string = factory->newSize(factory, size);
if (string == NULL)
{
return NULL;
}
if (size <= 0)
{
return string;
}
if (ptr != NULL)
{
ANTLR3_MEMMOVE(string->chars, (const void *)ptr, (size * sizeof(ANTLR3_UINT16)));
/* Terminate, these strings are usually used for Token streams and printing etc.
*/
*(((pANTLR3_UINT16)(string->chars)) + size) = '\0';
string->len = size;
}
return string;
}
/** Create a new 8 bit string from the supplied, null terminated, 8 bit string pointer.
* \param[in] factory - Pointer to the string factory that owns strings.
* \param[in] ptr - Pointer to the 8 bit encoded string
* \return Pointer to the newly initialized string
*/
static pANTLR3_STRING
newStr8 (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 ptr)
{
return factory->newPtr8(factory, ptr, (ANTLR3_UINT32)strlen((const char *)ptr));
}
/** Create a new UTF16 string from the supplied, null terminated, 8 bit string pointer.
* \param[in] factory - Pointer to the string factory that owns strings.
* \param[in] ptr - Pointer to the 8 bit encoded string
* \return POinter to the newly initialized string
*/
static pANTLR3_STRING
newStrUTF16_8 (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 ptr)
{
return factory->newPtr8(factory, ptr, (ANTLR3_UINT32)strlen((const char *)ptr));
}
/** Create a new UTF16 string from the supplied, null terminated, UTF16 string pointer.
* \param[in] factory - Pointer to the string factory that owns strings.
* \param[in] ptr - Pointer to the UTF16 encoded string
* \return Pointer to the newly initialized string
*/
static pANTLR3_STRING
newStrUTF16_UTF16 (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 ptr)
{
pANTLR3_UINT16 in;
ANTLR3_UINT32 count;
/** First, determine the length of the input string
*/
in = (pANTLR3_UINT16)ptr;
count = 0;
while (*in++ != '\0')
{
count++;
}
return factory->newPtr(factory, ptr, count);
}
static void
destroy (pANTLR3_STRING_FACTORY factory, pANTLR3_STRING string)
{
// Record which string we are deleting
//
ANTLR3_UINT32 strIndex = string->index;
// Ensure that the string was not factory made, or we would try
// to delete memory that wasn't allocated outside the factory
// block.
// Remove the specific indexed string from the vector
//
factory->strings->del(factory->strings, strIndex);
// One less string in the vector, so decrement the factory index
// so that the next string allocated is indexed correctly with
// respect to the vector.
//
factory->index--;
// Now we have to reindex the strings in the vector that followed
// the one we just deleted. We only do this if the one we just deleted
// was not the last one.
//
if (strIndex< factory->index)
{
// We must reindex the strings after the one we just deleted.
// The one that follows the one we just deleted is also out
// of whack, so we start there.
//
ANTLR3_UINT32 i;
for (i = strIndex; i < factory->index; i++)
{
// Renumber the entry
//
((pANTLR3_STRING)(factory->strings->elements[i].element))->index = i;
}
}
// The string has been destroyed and the elements of the factory are reindexed.
//
}
static pANTLR3_STRING
printable8(pANTLR3_STRING_FACTORY factory, pANTLR3_STRING instr)
{
pANTLR3_STRING string;
/* We don't need to be too efficient here, this is mostly for error messages and so on.
*/
pANTLR3_UINT8 scannedText;
ANTLR3_UINT32 i;
/* Assume we need as much as twice as much space to parse out the control characters
*/
string = factory->newSize(factory, instr->len *2 + 1);
/* Scan through and replace unprintable (in terms of this routine)
* characters
*/
scannedText = string->chars;
for (i = 0; i < instr->len; i++)
{
if (*(instr->chars + i) == '\n')
{
*scannedText++ = '\\';
*scannedText++ = 'n';
}
else if (*(instr->chars + i) == '\r')
{
*scannedText++ = '\\';
*scannedText++ = 'r';
}
else if (!isprint(*(instr->chars +i)))
{
*scannedText++ = '?';
}
else
{
*scannedText++ = *(instr->chars + i);
}
}
*scannedText = '\0';
string->len = (ANTLR3_UINT32)(scannedText - string->chars);
return string;
}
static pANTLR3_STRING
printableUTF16(pANTLR3_STRING_FACTORY factory, pANTLR3_STRING instr)
{
pANTLR3_STRING string;
/* We don't need to be too efficient here, this is mostly for error messages and so on.
*/
pANTLR3_UINT16 scannedText;
pANTLR3_UINT16 inText;
ANTLR3_UINT32 i;
ANTLR3_UINT32 outLen;
/* Assume we need as much as twice as much space to parse out the control characters
*/
string = factory->newSize(factory, instr->len *2 + 1);
/* Scan through and replace unprintable (in terms of this routine)
* characters
*/
scannedText = (pANTLR3_UINT16)(string->chars);
inText = (pANTLR3_UINT16)(instr->chars);
outLen = 0;
for (i = 0; i < instr->len; i++)
{
if (*(inText + i) == '\n')
{
*scannedText++ = '\\';
*scannedText++ = 'n';
outLen += 2;
}
else if (*(inText + i) == '\r')
{
*scannedText++ = '\\';
*scannedText++ = 'r';
outLen += 2;
}
else if (!isprint(*(inText +i)))
{
*scannedText++ = '?';
outLen++;
}
else
{
*scannedText++ = *(inText + i);
outLen++;
}
}
*scannedText = '\0';
string->len = outLen;
return string;
}
/** Fascist Capitalist Pig function created
* to oppress the workers comrade.
*/
static void
closeFactory (pANTLR3_STRING_FACTORY factory)
{
/* Delete the vector we were tracking the strings with, this will
* causes all the allocated strings to be deallocated too
*/
factory->strings->free(factory->strings);
/* Delete the space for the factory itself
*/
ANTLR3_FREE((void *)factory);
}
static pANTLR3_UINT8
append8 (pANTLR3_STRING string, const char * newbit)
{
ANTLR3_UINT32 len;
len = (ANTLR3_UINT32)strlen(newbit);
if (string->size < (string->len + len + 1))
{
string->chars = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(string->len + len + 1));
string->size = string->len + len + 1;
}
/* Note we copy one more byte than the strlen in order to get the trailing
*/
ANTLR3_MEMMOVE((void *)(string->chars + string->len), newbit, (ANTLR3_UINT32)(len+1));
string->len += len;
return string->chars;
}
static pANTLR3_UINT8
appendUTF16_8 (pANTLR3_STRING string, const char * newbit)
{
ANTLR3_UINT32 len;
pANTLR3_UINT16 apPoint;
ANTLR3_UINT32 count;
len = (ANTLR3_UINT32)strlen(newbit);
if (string->size < (string->len + len + 1))
{
string->chars = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)((sizeof(ANTLR3_UINT16)*(string->len + len + 1))));
string->size = string->len + len + 1;
}
apPoint = ((pANTLR3_UINT16)string->chars) + string->len;
string->len += len;
for (count = 0; count < len; count++)
{
*apPoint++ = *(newbit + count);
}
*apPoint = '\0';
return string->chars;
}
static pANTLR3_UINT8
appendUTF16_UTF16 (pANTLR3_STRING string, const char * newbit)
{
ANTLR3_UINT32 len;
pANTLR3_UINT16 in;
/** First, determine the length of the input string
*/
in = (pANTLR3_UINT16)newbit;
len = 0;
while (*in++ != '\0')
{
len++;
}
if (string->size < (string->len + len + 1))
{
string->chars = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)( sizeof(ANTLR3_UINT16) *(string->len + len + 1) ));
string->size = string->len + len + 1;
}
/* Note we copy one more byte than the strlen in order to get the trailing delimiter
*/
ANTLR3_MEMMOVE((void *)(((pANTLR3_UINT16)string->chars) + string->len), newbit, (ANTLR3_UINT32)(sizeof(ANTLR3_UINT16)*(len+1)));
string->len += len;
return string->chars;
}
static pANTLR3_UINT8
set8 (pANTLR3_STRING string, const char * chars)
{
ANTLR3_UINT32 len;
len = (ANTLR3_UINT32)strlen(chars);
if (string->size < len + 1)
{
string->chars = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(len + 1));
string->size = len + 1;
}
/* Note we copy one more byte than the strlen in order to get the trailing '\0'
*/
ANTLR3_MEMMOVE((void *)(string->chars), chars, (ANTLR3_UINT32)(len+1));
string->len = len;
return string->chars;
}
static pANTLR3_UINT8
setUTF16_8 (pANTLR3_STRING string, const char * chars)
{
ANTLR3_UINT32 len;
ANTLR3_UINT32 count;
pANTLR3_UINT16 apPoint;
len = (ANTLR3_UINT32)strlen(chars);
if (string->size < len + 1)
{
string->chars = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(sizeof(ANTLR3_UINT16)*(len + 1)));
string->size = len + 1;
}
apPoint = ((pANTLR3_UINT16)string->chars);
string->len = len;
for (count = 0; count < string->len; count++)
{
*apPoint++ = *(chars + count);
}
*apPoint = '\0';
return string->chars;
}
static pANTLR3_UINT8
setUTF16_UTF16 (pANTLR3_STRING string, const char * chars)
{
ANTLR3_UINT32 len;
pANTLR3_UINT16 in;
/** First, determine the length of the input string
*/
in = (pANTLR3_UINT16)chars;
len = 0;
while (*in++ != '\0')
{
len++;
}
if (string->size < len + 1)
{
string->chars = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(sizeof(ANTLR3_UINT16)*(len + 1)));
string->size = len + 1;
}
/* Note we copy one more byte than the strlen in order to get the trailing '\0'
*/
ANTLR3_MEMMOVE((void *)(string->chars), chars, (ANTLR3_UINT32)((len+1) * sizeof(ANTLR3_UINT16)));
string->len = len;
return string->chars;
}
static pANTLR3_UINT8
addc8 (pANTLR3_STRING string, ANTLR3_UINT32 c)
{
if (string->size < string->len + 2)
{
string->chars = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(string->len + 2));
string->size = string->len + 2;
}
*(string->chars + string->len) = (ANTLR3_UINT8)c;
*(string->chars + string->len + 1) = '\0';
string->len++;
return string->chars;
}
static pANTLR3_UINT8
addcUTF16 (pANTLR3_STRING string, ANTLR3_UINT32 c)
{
pANTLR3_UINT16 ptr;
if (string->size < string->len + 2)
{
string->chars = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(sizeof(ANTLR3_UINT16) * (string->len + 2)));
string->size = string->len + 2;
}
ptr = (pANTLR3_UINT16)(string->chars);
*(ptr + string->len) = (ANTLR3_UINT16)c;
*(ptr + string->len + 1) = '\0';
string->len++;
return string->chars;
}
static pANTLR3_UINT8
addi8 (pANTLR3_STRING string, ANTLR3_INT32 i)
{
ANTLR3_UINT8 newbit[32];
sprintf((char *)newbit, "%d", i);
return string->append8(string, (const char *)newbit);
}
static pANTLR3_UINT8
addiUTF16 (pANTLR3_STRING string, ANTLR3_INT32 i)
{
ANTLR3_UINT8 newbit[32];
sprintf((char *)newbit, "%d", i);
return string->append8(string, (const char *)newbit);
}
static pANTLR3_UINT8
inserti8 (pANTLR3_STRING string, ANTLR3_UINT32 point, ANTLR3_INT32 i)
{
ANTLR3_UINT8 newbit[32];
sprintf((char *)newbit, "%d", i);
return string->insert8(string, point, (const char *)newbit);
}
static pANTLR3_UINT8
insertiUTF16 (pANTLR3_STRING string, ANTLR3_UINT32 point, ANTLR3_INT32 i)
{
ANTLR3_UINT8 newbit[32];
sprintf((char *)newbit, "%d", i);
return string->insert8(string, point, (const char *)newbit);
}
static pANTLR3_UINT8
insert8 (pANTLR3_STRING string, ANTLR3_UINT32 point, const char * newbit)
{
ANTLR3_UINT32 len;
if (point >= string->len)
{
return string->append(string, newbit);
}
len = (ANTLR3_UINT32)strlen(newbit);
if (len == 0)
{
return string->chars;
}
if (string->size < (string->len + len + 1))
{
string->chars = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(string->len + len + 1));
string->size = string->len + len + 1;
}
/* Move the characters we are inserting before, including the delimiter
*/
ANTLR3_MEMMOVE((void *)(string->chars + point + len), (void *)(string->chars + point), (ANTLR3_UINT32)(string->len - point + 1));
/* Note we copy the exact number of bytes
*/
ANTLR3_MEMMOVE((void *)(string->chars + point), newbit, (ANTLR3_UINT32)(len));
string->len += len;
return string->chars;
}
static pANTLR3_UINT8
insertUTF16_8 (pANTLR3_STRING string, ANTLR3_UINT32 point, const char * newbit)
{
ANTLR3_UINT32 len;
ANTLR3_UINT32 count;
pANTLR3_UINT16 inPoint;
if (point >= string->len)
{
return string->append8(string, newbit);
}
len = (ANTLR3_UINT32)strlen(newbit);
if (len == 0)
{
return string->chars;
}
if (string->size < (string->len + len + 1))
{
string->chars = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(sizeof(ANTLR3_UINT16)*(string->len + len + 1)));
string->size = string->len + len + 1;
}
/* Move the characters we are inserting before, including the delimiter
*/
ANTLR3_MEMMOVE((void *)(((pANTLR3_UINT16)string->chars) + point + len), (void *)(((pANTLR3_UINT16)string->chars) + point), (ANTLR3_UINT32)(sizeof(ANTLR3_UINT16)*(string->len - point + 1)));
string->len += len;
inPoint = ((pANTLR3_UINT16)(string->chars))+point;
for (count = 0; count<len; count++)
{
*(inPoint + count) = (ANTLR3_UINT16)(*(newbit+count));
}
return string->chars;
}
static pANTLR3_UINT8
insertUTF16_UTF16 (pANTLR3_STRING string, ANTLR3_UINT32 point, const char * newbit)
{
ANTLR3_UINT32 len;
pANTLR3_UINT16 in;
if (point >= string->len)
{
return string->append(string, newbit);
}
/** First, determine the length of the input string
*/
in = (pANTLR3_UINT16)newbit;
len = 0;
while (*in++ != '\0')
{
len++;
}
if (len == 0)
{
return string->chars;
}
if (string->size < (string->len + len + 1))
{
string->chars = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(sizeof(ANTLR3_UINT16)*(string->len + len + 1)));
string->size = string->len + len + 1;
}
/* Move the characters we are inserting before, including the delimiter
*/
ANTLR3_MEMMOVE((void *)(((pANTLR3_UINT16)string->chars) + point + len), (void *)(((pANTLR3_UINT16)string->chars) + point), (ANTLR3_UINT32)(sizeof(ANTLR3_UINT16)*(string->len - point + 1)));
/* Note we copy the exact number of characters
*/
ANTLR3_MEMMOVE((void *)(((pANTLR3_UINT16)string->chars) + point), newbit, (ANTLR3_UINT32)(sizeof(ANTLR3_UINT16)*(len)));
string->len += len;
return string->chars;
}
static pANTLR3_UINT8 setS (pANTLR3_STRING string, pANTLR3_STRING chars)
{
return string->set(string, (const char *)(chars->chars));
}
static pANTLR3_UINT8 appendS (pANTLR3_STRING string, pANTLR3_STRING newbit)
{
/* We may be passed an empty string, in which case we just return the current pointer
*/
if (newbit == NULL || newbit->len == 0 || newbit->size == 0 || newbit->chars == NULL)
{
return string->chars;
}
else
{
return string->append(string, (const char *)(newbit->chars));
}
}
static pANTLR3_UINT8 insertS (pANTLR3_STRING string, ANTLR3_UINT32 point, pANTLR3_STRING newbit)
{
return string->insert(string, point, (const char *)(newbit->chars));
}
/* Function that compares the text of a string to the supplied
* 8 bit character string and returns a result a la strcmp()
*/
static ANTLR3_UINT32
compare8 (pANTLR3_STRING string, const char * compStr)
{
return strcmp((const char *)(string->chars), compStr);
}
/* Function that compares the text of a string with the supplied character string
* (which is assumed to be in the same encoding as the string itself) and returns a result
* a la strcmp()
*/
static ANTLR3_UINT32
compareUTF16_8 (pANTLR3_STRING string, const char * compStr)
{
pANTLR3_UINT16 ourString;
ANTLR3_UINT32 charDiff;
ourString = (pANTLR3_UINT16)(string->chars);
while (((ANTLR3_UCHAR)(*ourString) != '\0') && ((ANTLR3_UCHAR)(*compStr) != '\0'))
{
charDiff = *ourString - *compStr;
if (charDiff != 0)
{
return charDiff;
}
ourString++;
compStr++;
}
/* At this point, one of the strings was terminated
*/
return (ANTLR3_UINT32)((ANTLR3_UCHAR)(*ourString) - (ANTLR3_UCHAR)(*compStr));
}
/* Function that compares the text of a string with the supplied character string
* (which is assumed to be in the same encoding as the string itself) and returns a result
* a la strcmp()
*/
static ANTLR3_UINT32
compareUTF16_UTF16 (pANTLR3_STRING string, const char * compStr8)
{
pANTLR3_UINT16 ourString;
pANTLR3_UINT16 compStr;
ANTLR3_UINT32 charDiff;
ourString = (pANTLR3_UINT16)(string->chars);
compStr = (pANTLR3_UINT16)(compStr8);
while (((ANTLR3_UCHAR)(*ourString) != '\0') && ((ANTLR3_UCHAR)(*((pANTLR3_UINT16)compStr)) != '\0'))
{
charDiff = *ourString - *compStr;
if (charDiff != 0)
{
return charDiff;
}
ourString++;
compStr++;
}
/* At this point, one of the strings was terminated
*/
return (ANTLR3_UINT32)((ANTLR3_UCHAR)(*ourString) - (ANTLR3_UCHAR)(*compStr));
}
/* Function that compares the text of a string with the supplied string
* (which is assumed to be in the same encoding as the string itself) and returns a result
* a la strcmp()
*/
static ANTLR3_UINT32
compareS (pANTLR3_STRING string, pANTLR3_STRING compStr)
{
return string->compare(string, (const char *)compStr->chars);
}
/* Function that returns the character indexed at the supplied
* offset as a 32 bit character.
*/
static ANTLR3_UCHAR
charAt8 (pANTLR3_STRING string, ANTLR3_UINT32 offset)
{
if (offset > string->len)
{
return (ANTLR3_UCHAR)'\0';
}
else
{
return (ANTLR3_UCHAR)(*(string->chars + offset));
}
}
/* Function that returns the character indexed at the supplied
* offset as a 32 bit character.
*/
static ANTLR3_UCHAR
charAtUTF16 (pANTLR3_STRING string, ANTLR3_UINT32 offset)
{
if (offset > string->len)
{
return (ANTLR3_UCHAR)'\0';
}
else
{
return (ANTLR3_UCHAR)(*((pANTLR3_UINT16)(string->chars) + offset));
}
}
/* Function that returns a substring of the supplied string a la .subString(s,e)
* in java runtimes.
*/
static pANTLR3_STRING
subString8 (pANTLR3_STRING string, ANTLR3_UINT32 startIndex, ANTLR3_UINT32 endIndex)
{
pANTLR3_STRING newStr;
if (endIndex > string->len)
{
endIndex = string->len + 1;
}
newStr = string->factory->newPtr(string->factory, string->chars + startIndex, endIndex - startIndex);
return newStr;
}
/* Returns a substring of the supplied string a la .subString(s,e)
* in java runtimes.
*/
static pANTLR3_STRING
subStringUTF16 (pANTLR3_STRING string, ANTLR3_UINT32 startIndex, ANTLR3_UINT32 endIndex)
{
pANTLR3_STRING newStr;
if (endIndex > string->len)
{
endIndex = string->len + 1;
}
newStr = string->factory->newPtr(string->factory, (pANTLR3_UINT8)((pANTLR3_UINT16)(string->chars) + startIndex), endIndex - startIndex);
return newStr;
}
/* Function that can convert the characters in the string to an integer
*/
static ANTLR3_INT32
toInt32_8 (struct ANTLR3_STRING_struct * string)
{
return atoi((const char *)(string->chars));
}
/* Function that can convert the characters in the string to an integer
*/
static ANTLR3_INT32
toInt32_UTF16 (struct ANTLR3_STRING_struct * string)
{
pANTLR3_UINT16 input;
ANTLR3_INT32 value;
ANTLR3_BOOLEAN negate;
value = 0;
input = (pANTLR3_UINT16)(string->chars);
negate = ANTLR3_FALSE;
if (*input == (ANTLR3_UCHAR)'-')
{
negate = ANTLR3_TRUE;
input++;
}
else if (*input == (ANTLR3_UCHAR)'+')
{
input++;
}
while (*input != '\0' && isdigit(*input))
{
value = value * 10;
value += ((ANTLR3_UINT32)(*input) - (ANTLR3_UINT32)'0');
input++;
}
return negate ? -value : value;
}
/* Function that returns a pointer to an 8 bit version of the string,
* which in this case is just the string as this is
* 8 bit encodiing anyway.
*/
static pANTLR3_STRING to8_8 (pANTLR3_STRING string)
{
return string;
}
/* Function that returns an 8 bit version of the string,
* which in this case is returning all the UTF16 characters
* narrowed back into 8 bits, with characters that are too large
* replaced with '_'
*/
static pANTLR3_STRING to8_UTF16 (pANTLR3_STRING string)
{
pANTLR3_STRING newStr;
ANTLR3_UINT32 i;
/* Create a new 8 bit string
*/
newStr = newRaw8(string->factory);
if (newStr == NULL)
{
return NULL;
}
/* Always add one more byte for a terminator
*/
newStr->chars = (pANTLR3_UINT8) ANTLR3_MALLOC((size_t)(string->len + 1));
newStr->size = string->len + 1;
newStr->len = string->len;
/* Now copy each UTF16 charActer , making it an 8 bit character of
* some sort.
*/
for (i=0; i<string->len; i++)
{
ANTLR3_UCHAR c;
c = *(((pANTLR3_UINT16)(string->chars)) + i);
*(newStr->chars + i) = (ANTLR3_UINT8)(c > 255 ? '_' : c);
}
/* Terminate
*/
*(newStr->chars + newStr->len) = '\0';
return newStr;
}