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