bundles/org.simantics.databoard/cpp/DataBoardTest/libantlr3c-3.2/src/antlr3string.c

   1 /** \file\r
   2  * Implementation of the ANTLR3 string and string factory classes\r
   3  */\r
   4 \r
   5 // [The "BSD licence"]\r
   6 // Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC\r
   7 // http://www.temporal-wave.com\r
   8 // http://www.linkedin.com/in/jimidle\r
   9 //\r
  10 // All rights reserved.\r
  11 //\r
  12 // Redistribution and use in source and binary forms, with or without\r
  13 // modification, are permitted provided that the following conditions\r
  14 // are met:\r
  15 // 1. Redistributions of source code must retain the above copyright\r
  16 //    notice, this list of conditions and the following disclaimer.\r
  17 // 2. Redistributions in binary form must reproduce the above copyright\r
  18 //    notice, this list of conditions and the following disclaimer in the\r
  19 //    documentation and/or other materials provided with the distribution.\r
  20 // 3. The name of the author may not be used to endorse or promote products\r
  21 //    derived from this software without specific prior written permission.\r
  22 //\r
  23 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\r
  24 // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\r
  25 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\r
  26 // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\r
  27 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
  28 // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
  29 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
  30 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
  31 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\r
  32 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  33 \r
  34 #include    <antlr3string.h>\r
  35 \r
  36 /* Factory API\r
  37  */\r
  38 static    pANTLR3_STRING    newRaw8     (pANTLR3_STRING_FACTORY factory);\r
  39 static    pANTLR3_STRING    newRaw16    (pANTLR3_STRING_FACTORY factory);\r
  40 static    pANTLR3_STRING    newSize8    (pANTLR3_STRING_FACTORY factory, ANTLR3_UINT32 size);\r
  41 static    pANTLR3_STRING    newSize16   (pANTLR3_STRING_FACTORY factory, ANTLR3_UINT32 size);\r
  42 static    pANTLR3_STRING    newPtr8     (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 string, ANTLR3_UINT32 size);\r
  43 static    pANTLR3_STRING    newPtr16_8  (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 string, ANTLR3_UINT32 size);\r
  44 static    pANTLR3_STRING    newPtr16_16 (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 string, ANTLR3_UINT32 size);\r
  45 static    pANTLR3_STRING    newStr8     (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 string);\r
  46 static    pANTLR3_STRING    newStr16_8  (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 string);\r
  47 static    pANTLR3_STRING    newStr16_16 (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 string);\r
  48 static    void              destroy     (pANTLR3_STRING_FACTORY factory, pANTLR3_STRING string);\r
  49 static    pANTLR3_STRING    printable8  (pANTLR3_STRING_FACTORY factory, pANTLR3_STRING string);\r
  50 static    pANTLR3_STRING    printable16 (pANTLR3_STRING_FACTORY factory, pANTLR3_STRING string);\r
  51 static    void              closeFactory(pANTLR3_STRING_FACTORY factory);\r
  52 \r
  53 /* String API\r
  54  */\r
  55 static    pANTLR3_UINT8     set8        (pANTLR3_STRING string, const char * chars);\r
  56 static    pANTLR3_UINT8     set16_8     (pANTLR3_STRING string, const char * chars);\r
  57 static    pANTLR3_UINT8     set16_16    (pANTLR3_STRING string, const char * chars);\r
  58 static    pANTLR3_UINT8     append8     (pANTLR3_STRING string, const char * newbit);\r
  59 static    pANTLR3_UINT8     append16_8  (pANTLR3_STRING string, const char * newbit);\r
  60 static    pANTLR3_UINT8     append16_16 (pANTLR3_STRING string, const char * newbit);\r
  61 static    pANTLR3_UINT8     insert8     (pANTLR3_STRING string, ANTLR3_UINT32 point, const char * newbit);\r
  62 static    pANTLR3_UINT8     insert16_8  (pANTLR3_STRING string, ANTLR3_UINT32 point, const char * newbit);\r
  63 static    pANTLR3_UINT8     insert16_16 (pANTLR3_STRING string, ANTLR3_UINT32 point, const char * newbit);\r
  64 \r
  65 static    pANTLR3_UINT8     setS        (pANTLR3_STRING string, pANTLR3_STRING chars);\r
  66 static    pANTLR3_UINT8     appendS     (pANTLR3_STRING string, pANTLR3_STRING newbit);\r
  67 static    pANTLR3_UINT8     insertS     (pANTLR3_STRING string, ANTLR3_UINT32 point, pANTLR3_STRING newbit);\r
  68 \r
  69 static    pANTLR3_UINT8     addc8       (pANTLR3_STRING string, ANTLR3_UINT32 c);\r
  70 static    pANTLR3_UINT8     addc16      (pANTLR3_STRING string, ANTLR3_UINT32 c);\r
  71 static    pANTLR3_UINT8     addi8       (pANTLR3_STRING string, ANTLR3_INT32 i);\r
  72 static    pANTLR3_UINT8     addi16      (pANTLR3_STRING string, ANTLR3_INT32 i);\r
  73 static    pANTLR3_UINT8     inserti8    (pANTLR3_STRING string, ANTLR3_UINT32 point, ANTLR3_INT32 i);\r
  74 static    pANTLR3_UINT8     inserti16   (pANTLR3_STRING string, ANTLR3_UINT32 point, ANTLR3_INT32 i);\r
  75 \r
  76 static    ANTLR3_UINT32     compare8    (pANTLR3_STRING string, const char * compStr);\r
  77 static    ANTLR3_UINT32     compare16_8 (pANTLR3_STRING string, const char * compStr);\r
  78 static    ANTLR3_UINT32     compare16_16(pANTLR3_STRING string, const char * compStr);\r
  79 static    ANTLR3_UINT32     compareS    (pANTLR3_STRING string, pANTLR3_STRING compStr);\r
  80 static    ANTLR3_UCHAR      charAt8     (pANTLR3_STRING string, ANTLR3_UINT32 offset);\r
  81 static    ANTLR3_UCHAR      charAt16    (pANTLR3_STRING string, ANTLR3_UINT32 offset);\r
  82 static    pANTLR3_STRING    subString8  (pANTLR3_STRING string, ANTLR3_UINT32 startIndex, ANTLR3_UINT32 endIndex);\r
  83 static    pANTLR3_STRING    subString16 (pANTLR3_STRING string, ANTLR3_UINT32 startIndex, ANTLR3_UINT32 endIndex);\r
  84 static    ANTLR3_INT32      toInt32_8   (pANTLR3_STRING string);\r
  85 static    ANTLR3_INT32      toInt32_16  (pANTLR3_STRING string);\r
  86 static    pANTLR3_STRING    to8_8               (pANTLR3_STRING string);\r
  87 static    pANTLR3_STRING    to8_16              (pANTLR3_STRING string);\r
  88 static  pANTLR3_STRING          toUTF8_8        (pANTLR3_STRING string);\r
  89 static  pANTLR3_STRING          toUTF8_16       (pANTLR3_STRING string);\r
  90 \r
  91 /* Local helpers\r
  92  */\r
  93 static  void                    stringInit8     (pANTLR3_STRING string);\r
  94 static  void                    stringInit16    (pANTLR3_STRING string);\r
  95 static  void    ANTLR3_CDECL    stringFree      (pANTLR3_STRING string);\r
  96 \r
  97 ANTLR3_API pANTLR3_STRING_FACTORY \r
  98 antlr3StringFactoryNew()\r
  99 {\r
 100         pANTLR3_STRING_FACTORY  factory;\r
 101 \r
 102         /* Allocate memory\r
 103         */\r
 104         factory = (pANTLR3_STRING_FACTORY) ANTLR3_MALLOC(sizeof(ANTLR3_STRING_FACTORY));\r
 105 \r
 106         if      (factory == NULL)\r
 107         {\r
 108                 return  NULL;\r
 109         }\r
 110 \r
 111         /* Now we make a new list to track the strings.\r
 112         */\r
 113         factory->strings        = antlr3VectorNew(0);\r
 114         factory->index  = 0;\r
 115 \r
 116         if      (factory->strings == NULL)\r
 117         {\r
 118                 ANTLR3_FREE(factory);\r
 119                 return  NULL;\r
 120         }\r
 121 \r
 122         /* Install the API (8 bit assumed)\r
 123         */\r
 124         factory->newRaw         =  newRaw8;\r
 125         factory->newSize        =  newSize8;\r
 126 \r
 127         factory->newPtr         =  newPtr8;\r
 128         factory->newPtr8        =  newPtr8;\r
 129         factory->newStr         =  newStr8;\r
 130         factory->newStr8        =  newStr8;\r
 131         factory->destroy        =  destroy;\r
 132         factory->printable      =  printable8;\r
 133         factory->destroy        =  destroy;\r
 134         factory->close          =  closeFactory;\r
 135 \r
 136         return  factory;\r
 137 }\r
 138 \r
 139 /** Create a string factory that is UCS2 (16 bit) encoding based\r
 140  */\r
 141 ANTLR3_API pANTLR3_STRING_FACTORY \r
 142 antlr3UCS2StringFactoryNew()\r
 143 {\r
 144      pANTLR3_STRING_FACTORY  factory;\r
 145 \r
 146     /* Allocate an 8 bit factory, then override with 16 bit UCS2 functions where we \r
 147      * need to.\r
 148      */\r
 149     factory     = antlr3StringFactoryNew();\r
 150 \r
 151     if  (factory == NULL)\r
 152     {\r
 153                 return  NULL;\r
 154     }\r
 155 \r
 156     /* Override the 8 bit API with the UCS2 (mostly just 16 bit) API\r
 157      */\r
 158     factory->newRaw     =  newRaw16;\r
 159     factory->newSize    =  newSize16;\r
 160 \r
 161     factory->newPtr     =  newPtr16_16;\r
 162     factory->newPtr8    =  newPtr16_8;\r
 163     factory->newStr     =  newStr16_16;\r
 164     factory->newStr8    =  newStr16_8;\r
 165     factory->printable  =  printable16;\r
 166 \r
 167     factory->destroy    =  destroy;\r
 168     factory->destroy    =  destroy;\r
 169     factory->close      =  closeFactory;\r
 170 \r
 171     return  factory;\r
 172 }\r
 173 \r
 174 /**\r
 175  *\r
 176  * \param factory \r
 177  * \return \r
 178  */\r
 179 static    pANTLR3_STRING    \r
 180 newRaw8 (pANTLR3_STRING_FACTORY factory)\r
 181 {\r
 182     pANTLR3_STRING  string;\r
 183 \r
 184     string  = (pANTLR3_STRING) ANTLR3_MALLOC(sizeof(ANTLR3_STRING));\r
 185 \r
 186     if  (string == NULL)\r
 187     {\r
 188                 return  NULL;\r
 189     }\r
 190 \r
 191     /* Structure is allocated, now fill in the API etc.\r
 192      */\r
 193     stringInit8(string);\r
 194     string->factory = factory;\r
 195 \r
 196     /* Add the string into the allocated list\r
 197      */\r
 198     factory->strings->set(factory->strings, factory->index, (void *) string, (void (ANTLR3_CDECL *)(void *))(stringFree), ANTLR3_TRUE);\r
 199     string->index   = factory->index++;\r
 200 \r
 201     return string;\r
 202 }\r
 203 /**\r
 204  *\r
 205  * \param factory \r
 206  * \return \r
 207  */\r
 208 static    pANTLR3_STRING    \r
 209 newRaw16        (pANTLR3_STRING_FACTORY factory)\r
 210 {\r
 211     pANTLR3_STRING  string;\r
 212 \r
 213     string  = (pANTLR3_STRING) ANTLR3_MALLOC(sizeof(ANTLR3_STRING));\r
 214 \r
 215     if  (string == NULL)\r
 216     {\r
 217                 return  NULL;\r
 218     }\r
 219 \r
 220     /* Structure is allocated, now fill in the API etc.\r
 221      */\r
 222     stringInit16(string);\r
 223     string->factory = factory;\r
 224 \r
 225     /* Add the string into the allocated list\r
 226      */\r
 227     factory->strings->set(factory->strings, factory->index, (void *) string, (void (ANTLR3_CDECL *)(void *))(stringFree), ANTLR3_TRUE);\r
 228     string->index   = factory->index++;\r
 229 \r
 230     return string;\r
 231 }\r
 232 static   \r
 233 void    ANTLR3_CDECL stringFree  (pANTLR3_STRING string)\r
 234 {\r
 235     /* First free the string itself if there was anything in it\r
 236      */\r
 237     if  (string->chars)\r
 238     {\r
 239         ANTLR3_FREE(string->chars);\r
 240     }\r
 241 \r
 242     /* Now free the space for this string\r
 243      */\r
 244     ANTLR3_FREE(string);\r
 245 \r
 246     return;\r
 247 }\r
 248 /**\r
 249  *\r
 250  * \param string \r
 251  * \return \r
 252  */\r
 253 static  void\r
 254 stringInit8  (pANTLR3_STRING string)\r
 255 {\r
 256     string->len                 = 0;\r
 257     string->size                = 0;\r
 258     string->chars               = NULL;\r
 259     string->encoding    = ANTLR3_ENCODING_LATIN1;\r
 260 \r
 261     /* API for 8 bit strings*/\r
 262 \r
 263     string->set         = set8;\r
 264     string->set8        = set8;\r
 265     string->append      = append8;\r
 266     string->append8     = append8;\r
 267     string->insert      = insert8;\r
 268     string->insert8     = insert8;\r
 269     string->addi        = addi8;\r
 270     string->inserti     = inserti8;\r
 271     string->addc        = addc8;\r
 272     string->charAt      = charAt8;\r
 273     string->compare     = compare8;\r
 274     string->compare8    = compare8;\r
 275     string->subString   = subString8;\r
 276     string->toInt32     = toInt32_8;\r
 277     string->to8         = to8_8;\r
 278         string->toUTF8  = toUTF8_8;\r
 279     string->compareS    = compareS;\r
 280     string->setS        = setS;\r
 281     string->appendS     = appendS;\r
 282     string->insertS     = insertS;\r
 283 \r
 284 }\r
 285 /**\r
 286  *\r
 287  * \param string \r
 288  * \return \r
 289  */\r
 290 static  void\r
 291 stringInit16  (pANTLR3_STRING string)\r
 292 {\r
 293     string->len         = 0;\r
 294     string->size        = 0;\r
 295     string->chars       = NULL;\r
 296     string->encoding    = ANTLR3_ENCODING_UCS2;\r
 297 \r
 298     /* API for 16 bit strings */\r
 299 \r
 300     string->set         = set16_16;\r
 301     string->set8        = set16_8;\r
 302     string->append      = append16_16;\r
 303     string->append8     = append16_8;\r
 304     string->insert      = insert16_16;\r
 305     string->insert8     = insert16_8;\r
 306     string->addi        = addi16;\r
 307     string->inserti     = inserti16;\r
 308     string->addc        = addc16;\r
 309     string->charAt      = charAt16;\r
 310     string->compare     = compare16_16;\r
 311     string->compare8    = compare16_8;\r
 312     string->subString   = subString16;\r
 313     string->toInt32     = toInt32_16;\r
 314     string->to8         = to8_16;\r
 315         string->toUTF8  = toUTF8_16;\r
 316 \r
 317     string->compareS    = compareS;\r
 318     string->setS        = setS;\r
 319     string->appendS     = appendS;\r
 320     string->insertS     = insertS;\r
 321 }\r
 322 /**\r
 323  *\r
 324  * \param string \r
 325  * \return \r
 326  * TODO: Implement UTF-8\r
 327  */\r
 328 static  void\r
 329 stringInitUTF8  (pANTLR3_STRING string)\r
 330 {\r
 331     string->len     = 0;\r
 332     string->size    = 0;\r
 333     string->chars   = NULL;\r
 334 \r
 335     /* API */\r
 336 \r
 337 }\r
 338 \r
 339 // Convert an 8 bit string into a UTF8 representation, which is in fact just the string itself\r
 340 // a memcpy as we make no assumptions about the 8 bit encoding.\r
 341 //\r
 342 static  pANTLR3_STRING          \r
 343 toUTF8_8        (pANTLR3_STRING string)\r
 344 {\r
 345         return string->factory->newPtr(string->factory, (pANTLR3_UINT8)(string->chars), string->len);\r
 346 }\r
 347 \r
 348 // Convert a 16 bit (UCS2) string into a UTF8 representation using the Unicode.org\r
 349 // supplied C algorithms, which are now contained within the ANTLR3 C runtime\r
 350 // as permitted by the Unicode license (within the source code antlr3convertutf.c/.h\r
 351 // UCS2 has the same encoding as UTF16 so we can use UTF16 converter.\r
 352 //\r
 353 static  pANTLR3_STRING  \r
 354 toUTF8_16       (pANTLR3_STRING string)\r
 355 {\r
 356         \r
 357         UTF8                            * outputEnd;    \r
 358         UTF16                           * inputEnd;\r
 359         pANTLR3_STRING          utf8String;\r
 360 \r
 361         ConversionResult        cResult;\r
 362 \r
 363         // Allocate the output buffer, which needs to accommodate potentially\r
 364         // 3X (in bytes) the input size (in chars).\r
 365         //\r
 366         utf8String      = string->factory->newStr8(string->factory, (pANTLR3_UINT8)"");\r
 367 \r
 368         if      (utf8String != NULL)\r
 369         {\r
 370                 // Free existing allocation\r
 371                 //\r
 372                 ANTLR3_FREE(utf8String->chars);\r
 373 \r
 374                 // Reallocate according to maximum expected size\r
 375                 //\r
 376                 utf8String->size        = string->len *3;\r
 377                 utf8String->chars       = (pANTLR3_UINT8)ANTLR3_MALLOC(utf8String->size +1);\r
 378 \r
 379                 if      (utf8String->chars != NULL)\r
 380                 {\r
 381                         inputEnd  = (UTF16 *)   (string->chars);\r
 382                         outputEnd = (UTF8 *)    (utf8String->chars);\r
 383 \r
 384                         // Call the Unicode converter\r
 385                         //\r
 386                         cResult =  ConvertUTF16toUTF8\r
 387                                                         (\r
 388                                                                 (const UTF16**)&inputEnd, \r
 389                                                                 ((const UTF16 *)(string->chars)) + string->len, \r
 390                                                                 &outputEnd, \r
 391                                                                 outputEnd + utf8String->size - 1,\r
 392                                                                 lenientConversion\r
 393                                                         );\r
 394 \r
 395                         // We don't really care if things failed or not here, we just converted\r
 396                         // everything that was vaguely possible and stopped when it wasn't. It is\r
 397                         // up to the grammar programmer to verify that the input is sensible.\r
 398                         //\r
 399                         utf8String->len = ANTLR3_UINT32_CAST(((pANTLR3_UINT8)outputEnd) - utf8String->chars);\r
 400 \r
 401                         *(outputEnd+1) = '\0';          // Always null terminate\r
 402                 }\r
 403         }\r
 404         return utf8String;\r
 405 }\r
 406 \r
 407 /**\r
 408  * Creates a new string with enough capacity for size 8 bit characters plus a terminator.\r
 409  *\r
 410  * \param[in] factory - Pointer to the string factory that owns strings\r
 411  * \param[in] size - In characters\r
 412  * \return pointer to the new string.\r
 413  */\r
 414 static    pANTLR3_STRING    \r
 415 newSize8        (pANTLR3_STRING_FACTORY factory, ANTLR3_UINT32 size)\r
 416 {\r
 417     pANTLR3_STRING  string;\r
 418 \r
 419     string  = factory->newRaw(factory);\r
 420 \r
 421     if  (string == NULL)\r
 422     {\r
 423                 return  string;\r
 424     }\r
 425 \r
 426     /* Always add one more byte for a terminator ;-)\r
 427      */\r
 428     string->chars               = (pANTLR3_UINT8) ANTLR3_MALLOC((size_t)(sizeof(ANTLR3_UINT8) * (size+1)));\r
 429         *(string->chars)        = '\0';\r
 430     string->size                = size + 1;\r
 431 \r
 432 \r
 433     return string;\r
 434 }\r
 435 /**\r
 436  * Creates a new string with enough capacity for size 16 bit characters plus a terminator.\r
 437  *\r
 438  * \param[in] factory - POitner to the string factory that owns strings\r
 439  * \param[in] size - In characters\r
 440  * \return pointer to the new string.\r
 441  */\r
 442 static    pANTLR3_STRING    \r
 443 newSize16       (pANTLR3_STRING_FACTORY factory, ANTLR3_UINT32 size)\r
 444 {\r
 445     pANTLR3_STRING  string;\r
 446 \r
 447     string  = factory->newRaw(factory);\r
 448 \r
 449     if  (string == NULL)\r
 450     {\r
 451                 return  string;\r
 452     }\r
 453 \r
 454     /* Always add one more byte for a terminator ;-)\r
 455      */ \r
 456     string->chars               = (pANTLR3_UINT8) ANTLR3_MALLOC((size_t)(sizeof(ANTLR3_UINT16) * (size+1)));\r
 457         *(string->chars)        = '\0';\r
 458     string->size                = size+1;       /* Size is always in characters, as is len */\r
 459 \r
 460     return string;\r
 461 }\r
 462 \r
 463 /** Creates a new 8 bit string initialized with the 8 bit characters at the \r
 464  *  supplied ptr, of pre-determined size.\r
 465  * \param[in] factory - Pointer to the string factory that owns the strings\r
 466  * \param[in] ptr - Pointer to 8 bit encoded characters\r
 467  * \return pointer to the new string\r
 468  */\r
 469 static    pANTLR3_STRING    \r
 470 newPtr8 (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 ptr, ANTLR3_UINT32 size)\r
 471 {\r
 472         pANTLR3_STRING  string;\r
 473 \r
 474         string  = factory->newSize(factory, size);\r
 475 \r
 476         if      (string == NULL)\r
 477         {\r
 478                 return  NULL;\r
 479         }\r
 480 \r
 481         if      (size <= 0)\r
 482         {\r
 483                 return  string;\r
 484         }\r
 485 \r
 486         if      (ptr != NULL)\r
 487         {\r
 488                 ANTLR3_MEMMOVE(string->chars, (const void *)ptr, size);\r
 489                 *(string->chars + size) = '\0';     /* Terminate, these strings are usually used for Token streams and printing etc.    */\r
 490                 string->len = size;\r
 491         }\r
 492 \r
 493         return  string;\r
 494 }\r
 495 \r
 496 /** Creates a new 16 bit string initialized with the 8 bit characters at the \r
 497  *  supplied 8 bit character ptr, of pre-determined size.\r
 498  * \param[in] factory - Pointer to the string factory that owns the strings\r
 499  * \param[in] ptr - Pointer to 8 bit encoded characters\r
 500  * \return pointer to the new string\r
 501  */\r
 502 static    pANTLR3_STRING    \r
 503 newPtr16_8      (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 ptr, ANTLR3_UINT32 size)\r
 504 {\r
 505         pANTLR3_STRING  string;\r
 506 \r
 507         /* newSize accepts size in characters, not bytes\r
 508         */\r
 509         string  = factory->newSize(factory, size);\r
 510 \r
 511         if      (string == NULL)\r
 512         {\r
 513                 return  NULL;\r
 514         }\r
 515 \r
 516         if      (size <= 0)\r
 517         {\r
 518                 return  string;\r
 519         }\r
 520 \r
 521         if      (ptr != NULL)\r
 522         {\r
 523                 pANTLR3_UINT16  out;\r
 524                 ANTLR3_INT32    inSize;\r
 525 \r
 526                 out = (pANTLR3_UINT16)(string->chars);\r
 527                 inSize  = size;\r
 528 \r
 529                 while   (inSize-- > 0)\r
 530                 {\r
 531                         *out++ = (ANTLR3_UINT16)(*ptr++);\r
 532                 }\r
 533 \r
 534                 /* Terminate, these strings are usually used for Token streams and printing etc.        \r
 535                 */\r
 536                 *(((pANTLR3_UINT16)(string->chars)) + size) = '\0';\r
 537 \r
 538                 string->len = size;\r
 539         }\r
 540 \r
 541         return  string;\r
 542 }\r
 543 \r
 544 /** Creates a new 16 bit string initialized with the 16 bit characters at the \r
 545  *  supplied ptr, of pre-determined size.\r
 546  * \param[in] factory - Pointer to the string factory that owns the strings\r
 547  * \param[in] ptr - Pointer to 16 bit encoded characters\r
 548  * \return pointer to the new string\r
 549  */\r
 550 static    pANTLR3_STRING    \r
 551 newPtr16_16     (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 ptr, ANTLR3_UINT32 size)\r
 552 {\r
 553         pANTLR3_STRING  string;\r
 554 \r
 555         string  = factory->newSize(factory, size);\r
 556 \r
 557         if      (string == NULL)\r
 558         {\r
 559                 return  NULL;\r
 560         }\r
 561 \r
 562         if      (size <= 0)\r
 563         {\r
 564                 return  string;\r
 565         }\r
 566 \r
 567         if      (ptr != NULL)\r
 568         {\r
 569                 ANTLR3_MEMMOVE(string->chars, (const void *)ptr, (size * sizeof(ANTLR3_UINT16)));\r
 570 \r
 571                 /* Terminate, these strings are usually used for Token streams and printing etc.        \r
 572                 */\r
 573                 *(((pANTLR3_UINT16)(string->chars)) + size) = '\0';         \r
 574                 string->len = size;\r
 575         }\r
 576 \r
 577         return  string;\r
 578 }\r
 579 \r
 580 /** Create a new 8 bit string from the supplied, null terminated, 8 bit string pointer.\r
 581  * \param[in] factory - Pointer to the string factory that owns strings.\r
 582  * \param[in] ptr - Pointer to the 8 bit encoded string\r
 583  * \return Pointer to the newly initialized string\r
 584  */\r
 585 static    pANTLR3_STRING    \r
 586 newStr8 (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 ptr)\r
 587 {\r
 588     return factory->newPtr8(factory, ptr, (ANTLR3_UINT32)strlen((const char *)ptr));\r
 589 }\r
 590 \r
 591 /** Create a new 16 bit string from the supplied, null terminated, 8 bit string pointer.\r
 592  * \param[in] factory - Pointer to the string factory that owns strings.\r
 593  * \param[in] ptr - Pointer to the 8 bit encoded string\r
 594  * \return POinter to the newly initialized string\r
 595  */\r
 596 static    pANTLR3_STRING    \r
 597 newStr16_8      (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 ptr)\r
 598 {\r
 599     return factory->newPtr8(factory, ptr, (ANTLR3_UINT32)strlen((const char *)ptr));\r
 600 }\r
 601 \r
 602 /** Create a new 16 bit string from the supplied, null terminated, 16 bit string pointer.\r
 603  * \param[in] factory - Pointer to the string factory that owns strings.\r
 604  * \param[in] ptr - Pointer to the 16 bit encoded string\r
 605  * \return Pointer to the newly initialized string\r
 606  */\r
 607 static    pANTLR3_STRING    \r
 608 newStr16_16     (pANTLR3_STRING_FACTORY factory, pANTLR3_UINT8 ptr)\r
 609 {\r
 610     pANTLR3_UINT16  in;\r
 611     ANTLR3_UINT32   count;\r
 612 \r
 613     /** First, determine the length of the input string\r
 614      */\r
 615     in      = (pANTLR3_UINT16)ptr;\r
 616     count   = 0;\r
 617 \r
 618     while   (*in++ != '\0')\r
 619     {\r
 620                 count++;\r
 621     }\r
 622     return factory->newPtr(factory, ptr, count);\r
 623 }\r
 624 \r
 625 static    void              \r
 626 destroy (pANTLR3_STRING_FACTORY factory, pANTLR3_STRING string)\r
 627 {\r
 628     // Record which string we are deleting\r
 629     //\r
 630     ANTLR3_UINT32 strIndex = string->index;\r
 631     \r
 632     // Ensure that the string was not factory made, or we would try\r
 633     // to delete memory that wasn't allocated outside the factory\r
 634     // block.\r
 635     // Remove the specific indexed string from the vector\r
 636     //\r
 637     factory->strings->del(factory->strings, strIndex);\r
 638 \r
 639     // One less string in the vector, so decrement the factory index\r
 640     // so that the next string allocated is indexed correctly with\r
 641     // respect to the vector.\r
 642     //\r
 643     factory->index--;\r
 644 \r
 645     // Now we have to reindex the strings in the vector that followed\r
 646     // the one we just deleted. We only do this if the one we just deleted\r
 647     // was not the last one.\r
 648     //\r
 649     if  (strIndex< factory->index)\r
 650     {\r
 651         // We must reindex the strings after the one we just deleted.\r
 652         // The one that follows the one we just deleted is also out\r
 653         // of whack, so we start there.\r
 654         //\r
 655         ANTLR3_UINT32 i;\r
 656 \r
 657         for (i = strIndex; i < factory->index; i++)\r
 658         {\r
 659             // Renumber the entry\r
 660             //\r
 661             ((pANTLR3_STRING)(factory->strings->elements[i].element))->index = i;\r
 662         }\r
 663     }\r
 664 \r
 665     // The string has been destroyed and the elements of the factory are reindexed.\r
 666     //\r
 667 \r
 668 }\r
 669 \r
 670 static    pANTLR3_STRING    \r
 671 printable8(pANTLR3_STRING_FACTORY factory, pANTLR3_STRING instr)\r
 672 {\r
 673     pANTLR3_STRING  string;\r
 674     \r
 675     /* We don't need to be too efficient here, this is mostly for error messages and so on.\r
 676      */\r
 677     pANTLR3_UINT8   scannedText;\r
 678     ANTLR3_UINT32   i;\r
 679 \r
 680     /* Assume we need as much as twice as much space to parse out the control characters\r
 681      */\r
 682     string  = factory->newSize(factory, instr->len *2 + 1);\r
 683 \r
 684     /* Scan through and replace unprintable (in terms of this routine)\r
 685      * characters\r
 686      */\r
 687     scannedText = string->chars;\r
 688 \r
 689     for (i = 0; i < instr->len; i++)\r
 690     {\r
 691                 if (*(instr->chars + i) == '\n')\r
 692                 {\r
 693                         *scannedText++ = '\\';\r
 694                         *scannedText++ = 'n';\r
 695                 }\r
 696                 else if (*(instr->chars + i) == '\r')\r
 697                 {\r
 698                         *scannedText++ = '\\';\r
 699                         *scannedText++ = 'r';\r
 700                 }\r
 701                 else if (!isprint(*(instr->chars +i)))\r
 702                 {\r
 703                         *scannedText++ = '?';\r
 704                 }\r
 705                 else\r
 706                 {\r
 707                         *scannedText++ = *(instr->chars + i);\r
 708                 }\r
 709     }\r
 710     *scannedText  = '\0';\r
 711 \r
 712     string->len = (ANTLR3_UINT32)(scannedText - string->chars);\r
 713     \r
 714     return  string;\r
 715 }\r
 716 \r
 717 static    pANTLR3_STRING    \r
 718 printable16(pANTLR3_STRING_FACTORY factory, pANTLR3_STRING instr)\r
 719 {\r
 720     pANTLR3_STRING  string;\r
 721     \r
 722     /* We don't need to be too efficient here, this is mostly for error messages and so on.\r
 723      */\r
 724     pANTLR3_UINT16  scannedText;\r
 725     pANTLR3_UINT16  inText;\r
 726     ANTLR3_UINT32   i;\r
 727     ANTLR3_UINT32   outLen;\r
 728 \r
 729     /* Assume we need as much as twice as much space to parse out the control characters\r
 730      */\r
 731     string  = factory->newSize(factory, instr->len *2 + 1);\r
 732 \r
 733     /* Scan through and replace unprintable (in terms of this routine)\r
 734      * characters\r
 735      */\r
 736     scannedText = (pANTLR3_UINT16)(string->chars);\r
 737     inText      = (pANTLR3_UINT16)(instr->chars);\r
 738     outLen      = 0;\r
 739 \r
 740     for (i = 0; i < instr->len; i++)\r
 741     {\r
 742                 if (*(inText + i) == '\n')\r
 743                 {\r
 744                         *scannedText++   = '\\';\r
 745                         *scannedText++   = 'n';\r
 746                         outLen      += 2;\r
 747                 }\r
 748                 else if (*(inText + i) == '\r')\r
 749                 {\r
 750                         *scannedText++   = '\\';\r
 751                         *scannedText++   = 'r';\r
 752                         outLen      += 2;\r
 753                 }\r
 754                 else if (!isprint(*(inText +i)))\r
 755                 {\r
 756                         *scannedText++ = '?';\r
 757                         outLen++;\r
 758                 }\r
 759                 else\r
 760                 {\r
 761                         *scannedText++ = *(inText + i);\r
 762                         outLen++;\r
 763                 }\r
 764     }\r
 765     *scannedText  = '\0';\r
 766 \r
 767     string->len = outLen;\r
 768     \r
 769     return  string;\r
 770 }\r
 771 \r
 772 /** Fascist Capitalist Pig function created\r
 773  *  to oppress the workers comrade.\r
 774  */\r
 775 static    void              \r
 776 closeFactory    (pANTLR3_STRING_FACTORY factory)\r
 777 {\r
 778     /* Delete the vector we were tracking the strings with, this will\r
 779      * causes all the allocated strings to be deallocated too\r
 780      */\r
 781     factory->strings->free(factory->strings);\r
 782 \r
 783     /* Delete the space for the factory itself\r
 784      */\r
 785     ANTLR3_FREE((void *)factory);\r
 786 }\r
 787 \r
 788 static    pANTLR3_UINT8   \r
 789 append8 (pANTLR3_STRING string, const char * newbit)\r
 790 {\r
 791     ANTLR3_UINT32 len;\r
 792 \r
 793     len = (ANTLR3_UINT32)strlen(newbit);\r
 794 \r
 795     if  (string->size < (string->len + len + 1))\r
 796     {\r
 797                 string->chars   = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(string->len + len + 1));\r
 798                 string->size    = string->len + len + 1;\r
 799     }\r
 800 \r
 801     /* Note we copy one more byte than the strlen in order to get the trailing\r
 802      */\r
 803     ANTLR3_MEMMOVE((void *)(string->chars + string->len), newbit, (ANTLR3_UINT32)(len+1));\r
 804     string->len += len;\r
 805 \r
 806     return string->chars;\r
 807 }\r
 808 \r
 809 static    pANTLR3_UINT8   \r
 810 append16_8      (pANTLR3_STRING string, const char * newbit)\r
 811 {\r
 812     ANTLR3_UINT32   len;\r
 813     pANTLR3_UINT16  apPoint;\r
 814     ANTLR3_UINT32   count;\r
 815 \r
 816     len = (ANTLR3_UINT32)strlen(newbit);\r
 817 \r
 818     if  (string->size < (string->len + len + 1))\r
 819     {\r
 820                 string->chars   = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)((sizeof(ANTLR3_UINT16)*(string->len + len + 1))));\r
 821                 string->size    = string->len + len + 1;\r
 822     }\r
 823 \r
 824     apPoint = ((pANTLR3_UINT16)string->chars) + string->len;\r
 825     string->len += len;\r
 826 \r
 827     for (count = 0; count < len; count++)\r
 828     {\r
 829                 *apPoint++   = *(newbit + count);\r
 830     }\r
 831     *apPoint = '\0';\r
 832 \r
 833     return string->chars;\r
 834 }\r
 835 \r
 836 static    pANTLR3_UINT8   \r
 837 append16_16     (pANTLR3_STRING string, const char * newbit)\r
 838 {\r
 839     ANTLR3_UINT32 len;\r
 840     pANTLR3_UINT16  in;\r
 841 \r
 842     /** First, determine the length of the input string\r
 843      */\r
 844     in      = (pANTLR3_UINT16)newbit;\r
 845     len   = 0;\r
 846 \r
 847     while   (*in++ != '\0')\r
 848     {\r
 849                 len++;\r
 850     }\r
 851 \r
 852     if  (string->size < (string->len + len + 1))\r
 853     {\r
 854                 string->chars   = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)( sizeof(ANTLR3_UINT16) *(string->len + len + 1) ));\r
 855                 string->size    = string->len + len + 1;\r
 856     }\r
 857 \r
 858     /* Note we copy one more byte than the strlen in order to get the trailing delimiter\r
 859      */\r
 860     ANTLR3_MEMMOVE((void *)(((pANTLR3_UINT16)string->chars) + string->len), newbit, (ANTLR3_UINT32)(sizeof(ANTLR3_UINT16)*(len+1)));\r
 861     string->len += len;\r
 862 \r
 863     return string->chars;\r
 864 }\r
 865 \r
 866 static    pANTLR3_UINT8   \r
 867 set8    (pANTLR3_STRING string, const char * chars)\r
 868 {\r
 869     ANTLR3_UINT32       len;\r
 870 \r
 871     len = (ANTLR3_UINT32)strlen(chars);\r
 872     if  (string->size < len + 1)\r
 873     {\r
 874                 string->chars   = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(len + 1));\r
 875                 string->size    = len + 1;\r
 876     }\r
 877 \r
 878     /* Note we copy one more byte than the strlen in order to get the trailing '\0'\r
 879      */\r
 880     ANTLR3_MEMMOVE((void *)(string->chars), chars, (ANTLR3_UINT32)(len+1));\r
 881     string->len     = len;\r
 882 \r
 883     return  string->chars;\r
 884 \r
 885 }\r
 886 \r
 887 static    pANTLR3_UINT8   \r
 888 set16_8 (pANTLR3_STRING string, const char * chars)\r
 889 {\r
 890     ANTLR3_UINT32       len;\r
 891     ANTLR3_UINT32       count;\r
 892     pANTLR3_UINT16      apPoint;\r
 893 \r
 894     len = (ANTLR3_UINT32)strlen(chars);\r
 895     if  (string->size < len + 1)\r
 896         {\r
 897                 string->chars   = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(sizeof(ANTLR3_UINT16)*(len + 1)));\r
 898                 string->size    = len + 1;\r
 899     }\r
 900     apPoint = ((pANTLR3_UINT16)string->chars);\r
 901     string->len = len;\r
 902 \r
 903     for (count = 0; count < string->len; count++)\r
 904     {\r
 905                 *apPoint++   = *(chars + count);\r
 906     }\r
 907     *apPoint = '\0';\r
 908 \r
 909     return  string->chars;\r
 910 }\r
 911 \r
 912 static    pANTLR3_UINT8   \r
 913 set16_16    (pANTLR3_STRING string, const char * chars)\r
 914 {\r
 915     ANTLR3_UINT32   len;\r
 916     pANTLR3_UINT16  in;\r
 917 \r
 918     /** First, determine the length of the input string\r
 919      */\r
 920     in      = (pANTLR3_UINT16)chars;\r
 921     len   = 0;\r
 922 \r
 923     while   (*in++ != '\0')\r
 924     {\r
 925                 len++;\r
 926     }\r
 927 \r
 928     if  (string->size < len + 1)\r
 929     {\r
 930                 string->chars   = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(sizeof(ANTLR3_UINT16)*(len + 1)));\r
 931                 string->size    = len + 1;\r
 932     }\r
 933 \r
 934     /* Note we copy one more byte than the strlen in order to get the trailing '\0'\r
 935      */\r
 936     ANTLR3_MEMMOVE((void *)(string->chars), chars, (ANTLR3_UINT32)((len+1) * sizeof(ANTLR3_UINT16)));\r
 937     string->len     = len;\r
 938 \r
 939     return  string->chars;\r
 940 \r
 941 }\r
 942 \r
 943 static    pANTLR3_UINT8   \r
 944 addc8   (pANTLR3_STRING string, ANTLR3_UINT32 c)\r
 945 {\r
 946     if  (string->size < string->len + 2)\r
 947     {\r
 948                 string->chars   = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(string->len + 2));\r
 949                 string->size    = string->len + 2;\r
 950     }\r
 951     *(string->chars + string->len)      = (ANTLR3_UINT8)c;\r
 952     *(string->chars + string->len + 1)  = '\0';\r
 953     string->len++;\r
 954 \r
 955     return  string->chars;\r
 956 }\r
 957 \r
 958 static    pANTLR3_UINT8   \r
 959 addc16  (pANTLR3_STRING string, ANTLR3_UINT32 c)\r
 960 {\r
 961     pANTLR3_UINT16  ptr;\r
 962 \r
 963     if  (string->size < string->len + 2)\r
 964     {\r
 965                 string->chars   = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(sizeof(ANTLR3_UINT16) * (string->len + 2)));\r
 966                 string->size    = string->len + 2;\r
 967     }\r
 968     ptr = (pANTLR3_UINT16)(string->chars);\r
 969 \r
 970     *(ptr + string->len)        = (ANTLR3_UINT16)c;\r
 971     *(ptr + string->len + 1)    = '\0';\r
 972     string->len++;\r
 973 \r
 974     return  string->chars;\r
 975 }\r
 976 \r
 977 static    pANTLR3_UINT8   \r
 978 addi8   (pANTLR3_STRING string, ANTLR3_INT32 i)\r
 979 {\r
 980     ANTLR3_UINT8            newbit[32];\r
 981 \r
 982     sprintf((char *)newbit, "%d", i);\r
 983 \r
 984     return  string->append8(string, (const char *)newbit);\r
 985 }\r
 986 static    pANTLR3_UINT8   \r
 987 addi16  (pANTLR3_STRING string, ANTLR3_INT32 i)\r
 988 {\r
 989     ANTLR3_UINT8            newbit[32];\r
 990 \r
 991     sprintf((char *)newbit, "%d", i);\r
 992 \r
 993     return  string->append8(string, (const char *)newbit);\r
 994 }\r
 995 \r
 996 static    pANTLR3_UINT8\r
 997 inserti8    (pANTLR3_STRING string, ANTLR3_UINT32 point, ANTLR3_INT32 i)\r
 998 {\r
 999     ANTLR3_UINT8            newbit[32];\r
1000 \r
1001     sprintf((char *)newbit, "%d", i);\r
1002     return  string->insert8(string, point, (const char *)newbit);\r
1003 }\r
1004 static    pANTLR3_UINT8\r
1005 inserti16    (pANTLR3_STRING string, ANTLR3_UINT32 point, ANTLR3_INT32 i)\r
1006 {\r
1007     ANTLR3_UINT8            newbit[32];\r
1008 \r
1009     sprintf((char *)newbit, "%d", i);\r
1010     return  string->insert8(string, point, (const char *)newbit);\r
1011 }\r
1012 \r
1013 static  pANTLR3_UINT8\r
1014 insert8 (pANTLR3_STRING string, ANTLR3_UINT32 point, const char * newbit)\r
1015 {\r
1016     ANTLR3_UINT32       len;\r
1017 \r
1018     if  (point >= string->len)\r
1019     {\r
1020                 return  string->append(string, newbit);\r
1021     }\r
1022  \r
1023     len = (ANTLR3_UINT32)strlen(newbit);\r
1024 \r
1025     if  (len == 0)\r
1026     {\r
1027                 return  string->chars;\r
1028     }\r
1029 \r
1030     if  (string->size < (string->len + len + 1))\r
1031     {\r
1032                 string->chars   = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(string->len + len + 1));\r
1033                 string->size    = string->len + len + 1;\r
1034     }\r
1035 \r
1036     /* Move the characters we are inserting before, including the delimiter\r
1037      */\r
1038     ANTLR3_MEMMOVE((void *)(string->chars + point + len), (void *)(string->chars + point), (ANTLR3_UINT32)(string->len - point + 1));\r
1039 \r
1040     /* Note we copy the exact number of bytes\r
1041      */\r
1042     ANTLR3_MEMMOVE((void *)(string->chars + point), newbit, (ANTLR3_UINT32)(len));\r
1043     \r
1044     string->len += len;\r
1045 \r
1046     return  string->chars;\r
1047 }\r
1048 \r
1049 static  pANTLR3_UINT8\r
1050 insert16_8      (pANTLR3_STRING string, ANTLR3_UINT32 point, const char * newbit)\r
1051 {\r
1052     ANTLR3_UINT32       len;\r
1053     ANTLR3_UINT32       count;\r
1054     pANTLR3_UINT16      inPoint;\r
1055 \r
1056     if  (point >= string->len)\r
1057     {\r
1058                 return  string->append8(string, newbit);\r
1059     }\r
1060  \r
1061     len = (ANTLR3_UINT32)strlen(newbit);\r
1062 \r
1063     if  (len == 0)\r
1064     {\r
1065                 return  string->chars;\r
1066     }\r
1067 \r
1068     if  (string->size < (string->len + len + 1))\r
1069     {\r
1070         string->chars   = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(sizeof(ANTLR3_UINT16)*(string->len + len + 1)));\r
1071         string->size    = string->len + len + 1;\r
1072     }\r
1073 \r
1074     /* Move the characters we are inserting before, including the delimiter\r
1075      */\r
1076     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
1077 \r
1078     string->len += len;\r
1079     \r
1080     inPoint = ((pANTLR3_UINT16)(string->chars))+point;\r
1081     for (count = 0; count<len; count++)\r
1082     {\r
1083                 *(inPoint + count) = (ANTLR3_UINT16)(*(newbit+count));\r
1084     }\r
1085 \r
1086     return  string->chars;\r
1087 }\r
1088 \r
1089 static  pANTLR3_UINT8\r
1090 insert16_16     (pANTLR3_STRING string, ANTLR3_UINT32 point, const char * newbit)\r
1091 {\r
1092     ANTLR3_UINT32       len;\r
1093     pANTLR3_UINT16      in;\r
1094 \r
1095     if  (point >= string->len)\r
1096     {\r
1097                 return  string->append(string, newbit);\r
1098     }\r
1099  \r
1100     /** First, determine the length of the input string\r
1101      */\r
1102     in      = (pANTLR3_UINT16)newbit;\r
1103     len     = 0;\r
1104 \r
1105     while   (*in++ != '\0')\r
1106     {\r
1107                 len++;\r
1108     }\r
1109 \r
1110     if  (len == 0)\r
1111     {\r
1112                 return  string->chars;\r
1113     }\r
1114 \r
1115     if  (string->size < (string->len + len + 1))\r
1116     {\r
1117                 string->chars   = (pANTLR3_UINT8) ANTLR3_REALLOC((void *)string->chars, (ANTLR3_UINT32)(sizeof(ANTLR3_UINT16)*(string->len + len + 1)));\r
1118                 string->size    = string->len + len + 1;\r
1119     }\r
1120 \r
1121     /* Move the characters we are inserting before, including the delimiter\r
1122      */\r
1123     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
1124 \r
1125 \r
1126     /* Note we copy the exact number of characters\r
1127      */\r
1128     ANTLR3_MEMMOVE((void *)(((pANTLR3_UINT16)string->chars) + point), newbit, (ANTLR3_UINT32)(sizeof(ANTLR3_UINT16)*(len)));\r
1129     \r
1130     string->len += len;\r
1131 \r
1132     return  string->chars;\r
1133 }\r
1134 \r
1135 static    pANTLR3_UINT8     setS        (pANTLR3_STRING string, pANTLR3_STRING chars)\r
1136 {\r
1137     return  string->set(string, (const char *)(chars->chars));\r
1138 }\r
1139 \r
1140 static    pANTLR3_UINT8     appendS     (pANTLR3_STRING string, pANTLR3_STRING newbit)\r
1141 {\r
1142     /* We may be passed an empty string, in which case we just return the current pointer\r
1143      */\r
1144     if  (newbit == NULL || newbit->len == 0 || newbit->size == 0 || newbit->chars == NULL)\r
1145     {\r
1146                 return  string->chars;\r
1147     }\r
1148     else\r
1149     {\r
1150                 return  string->append(string, (const char *)(newbit->chars));\r
1151     }\r
1152 }\r
1153 \r
1154 static    pANTLR3_UINT8     insertS     (pANTLR3_STRING string, ANTLR3_UINT32 point, pANTLR3_STRING newbit)\r
1155 {\r
1156     return  string->insert(string, point, (const char *)(newbit->chars));\r
1157 }\r
1158 \r
1159 /* Function that compares the text of a string to the supplied\r
1160  * 8 bit character string and returns a result a la strcmp()\r
1161  */\r
1162 static ANTLR3_UINT32   \r
1163 compare8        (pANTLR3_STRING string, const char * compStr)\r
1164 {\r
1165     return  strcmp((const char *)(string->chars), compStr);\r
1166 }\r
1167 \r
1168 /* Function that compares the text of a string with the supplied character string\r
1169  * (which is assumed to be in the same encoding as the string itself) and returns a result\r
1170  * a la strcmp()\r
1171  */\r
1172 static ANTLR3_UINT32   \r
1173 compare16_8     (pANTLR3_STRING string, const char * compStr)\r
1174 {\r
1175     pANTLR3_UINT16  ourString;\r
1176     ANTLR3_UINT32   charDiff;\r
1177 \r
1178     ourString   = (pANTLR3_UINT16)(string->chars);\r
1179 \r
1180     while   (((ANTLR3_UCHAR)(*ourString) != '\0') && ((ANTLR3_UCHAR)(*compStr) != '\0'))\r
1181     {\r
1182                 charDiff = *ourString - *compStr;\r
1183                 if  (charDiff != 0)\r
1184                 {\r
1185                         return charDiff;\r
1186                 }\r
1187                 ourString++;\r
1188                 compStr++;\r
1189     }\r
1190 \r
1191     /* At this point, one of the strings was terminated\r
1192      */\r
1193     return (ANTLR3_UINT32)((ANTLR3_UCHAR)(*ourString) - (ANTLR3_UCHAR)(*compStr));\r
1194 \r
1195 }\r
1196 \r
1197 /* Function that compares the text of a string with the supplied character string\r
1198  * (which is assumed to be in the same encoding as the string itself) and returns a result\r
1199  * a la strcmp()\r
1200  */\r
1201 static ANTLR3_UINT32   \r
1202 compare16_16    (pANTLR3_STRING string, const char * compStr8)\r
1203 {\r
1204     pANTLR3_UINT16  ourString;\r
1205     pANTLR3_UINT16  compStr;\r
1206     ANTLR3_UINT32   charDiff;\r
1207 \r
1208     ourString   = (pANTLR3_UINT16)(string->chars);\r
1209     compStr     = (pANTLR3_UINT16)(compStr8);\r
1210 \r
1211     while   (((ANTLR3_UCHAR)(*ourString) != '\0') && ((ANTLR3_UCHAR)(*((pANTLR3_UINT16)compStr)) != '\0'))\r
1212     {\r
1213                 charDiff = *ourString - *compStr;\r
1214                 if  (charDiff != 0)\r
1215                 {\r
1216                         return charDiff;\r
1217                 }\r
1218                 ourString++;\r
1219                 compStr++;\r
1220     }\r
1221 \r
1222     /* At this point, one of the strings was terminated\r
1223      */\r
1224     return (ANTLR3_UINT32)((ANTLR3_UCHAR)(*ourString) - (ANTLR3_UCHAR)(*compStr));\r
1225 }\r
1226 \r
1227 /* Function that compares the text of a string with the supplied string\r
1228  * (which is assumed to be in the same encoding as the string itself) and returns a result\r
1229  * a la strcmp()\r
1230  */\r
1231 static ANTLR3_UINT32   \r
1232 compareS    (pANTLR3_STRING string, pANTLR3_STRING compStr)\r
1233 {\r
1234     return  string->compare(string, (const char *)compStr->chars);\r
1235 }\r
1236 \r
1237 \r
1238 /* Function that returns the character indexed at the supplied\r
1239  * offset as a 32 bit character.\r
1240  */\r
1241 static ANTLR3_UCHAR    \r
1242 charAt8     (pANTLR3_STRING string, ANTLR3_UINT32 offset)\r
1243 {\r
1244     if  (offset > string->len)\r
1245     {\r
1246                 return (ANTLR3_UCHAR)'\0';\r
1247     }\r
1248     else\r
1249     {\r
1250                 return  (ANTLR3_UCHAR)(*(string->chars + offset));\r
1251     }\r
1252 }\r
1253 \r
1254 /* Function that returns the character indexed at the supplied\r
1255  * offset as a 32 bit character.\r
1256  */\r
1257 static ANTLR3_UCHAR    \r
1258 charAt16    (pANTLR3_STRING string, ANTLR3_UINT32 offset)\r
1259 {\r
1260     if  (offset > string->len)\r
1261     {\r
1262                 return (ANTLR3_UCHAR)'\0';\r
1263     }\r
1264     else\r
1265     {\r
1266                 return  (ANTLR3_UCHAR)(*((pANTLR3_UINT16)(string->chars) + offset));\r
1267     }\r
1268 }\r
1269 \r
1270 /* Function that returns a substring of the supplied string a la .subString(s,e)\r
1271  * in java runtimes.\r
1272  */\r
1273 static pANTLR3_STRING\r
1274 subString8   (pANTLR3_STRING string, ANTLR3_UINT32 startIndex, ANTLR3_UINT32 endIndex)\r
1275 {\r
1276     pANTLR3_STRING newStr;\r
1277 \r
1278     if  (endIndex > string->len)\r
1279     {\r
1280                 endIndex = string->len + 1;\r
1281     }\r
1282     newStr  = string->factory->newPtr(string->factory, string->chars + startIndex, endIndex - startIndex);\r
1283 \r
1284     return newStr;\r
1285 }\r
1286 \r
1287 /* Returns a substring of the supplied string a la .subString(s,e)\r
1288  * in java runtimes.\r
1289  */\r
1290 static pANTLR3_STRING\r
1291 subString16  (pANTLR3_STRING string, ANTLR3_UINT32 startIndex, ANTLR3_UINT32 endIndex)\r
1292 {\r
1293     pANTLR3_STRING newStr;\r
1294 \r
1295     if  (endIndex > string->len)\r
1296     {\r
1297                 endIndex = string->len + 1;\r
1298     }\r
1299     newStr  = string->factory->newPtr(string->factory, (pANTLR3_UINT8)((pANTLR3_UINT16)(string->chars) + startIndex), endIndex - startIndex);\r
1300 \r
1301     return newStr;\r
1302 }\r
1303 \r
1304 /* Function that can convert the characters in the string to an integer\r
1305  */\r
1306 static ANTLR3_INT32\r
1307 toInt32_8           (struct ANTLR3_STRING_struct * string)\r
1308 {\r
1309     return  atoi((const char *)(string->chars));\r
1310 }\r
1311 \r
1312 /* Function that can convert the characters in the string to an integer\r
1313  */\r
1314 static ANTLR3_INT32\r
1315 toInt32_16       (struct ANTLR3_STRING_struct * string)\r
1316 {\r
1317     pANTLR3_UINT16  input;\r
1318     ANTLR3_INT32   value;\r
1319     ANTLR3_BOOLEAN  negate;\r
1320 \r
1321     value   = 0;\r
1322     input   = (pANTLR3_UINT16)(string->chars);\r
1323     negate  = ANTLR3_FALSE;\r
1324 \r
1325     if  (*input == (ANTLR3_UCHAR)'-')\r
1326     {\r
1327                 negate = ANTLR3_TRUE;\r
1328                 input++;\r
1329     }\r
1330     else if (*input == (ANTLR3_UCHAR)'+')\r
1331     {\r
1332                 input++;\r
1333     }\r
1334 \r
1335     while   (*input != '\0' && isdigit(*input))\r
1336     {\r
1337                 value    = value * 10;\r
1338                 value   += ((ANTLR3_UINT32)(*input) - (ANTLR3_UINT32)'0');\r
1339                 input++;\r
1340     }\r
1341 \r
1342     return negate ? -value : value;\r
1343 }\r
1344 \r
1345 /* Function that returns a pointer to an 8 bit version of the string,\r
1346  * which in this case is just the string as this is \r
1347  * 8 bit encodiing anyway.\r
1348  */\r
1349 static    pANTLR3_STRING            to8_8       (pANTLR3_STRING string)\r
1350 {\r
1351     return  string;\r
1352 }\r
1353 \r
1354 /* Function that returns an 8 bit version of the string,\r
1355  * which in this case is returning all the 16 bit characters\r
1356  * narrowed back into 8 bits, with characters that are too large\r
1357  * replaced with '_'\r
1358  */\r
1359 static    pANTLR3_STRING    to8_16      (pANTLR3_STRING string)\r
1360 {\r
1361         pANTLR3_STRING  newStr;\r
1362         ANTLR3_UINT32   i;\r
1363 \r
1364         /* Create a new 8 bit string\r
1365         */\r
1366         newStr  = newRaw8(string->factory);\r
1367 \r
1368         if      (newStr == NULL)\r
1369         {\r
1370                 return  NULL;\r
1371         }\r
1372 \r
1373         /* Always add one more byte for a terminator\r
1374         */\r
1375         newStr->chars   = (pANTLR3_UINT8) ANTLR3_MALLOC((size_t)(string->len + 1));\r
1376         newStr->size    = string->len + 1;\r
1377         newStr->len         = string->len;\r
1378 \r
1379         /* Now copy each 16 bit charActer , making it an 8 bit character of \r
1380         * some sort.\r
1381         */\r
1382         for     (i=0; i<string->len; i++)\r
1383         {\r
1384                 ANTLR3_UCHAR    c;\r
1385 \r
1386                 c = *(((pANTLR3_UINT16)(string->chars)) + i);\r
1387 \r
1388                 *(newStr->chars + i) = (ANTLR3_UINT8)(c > 255 ? '_' : c);\r
1389         }\r
1390 \r
1391         /* Terminate\r
1392         */\r
1393         *(newStr->chars + newStr->len) = '\0';\r
1394 \r
1395         return newStr;\r
1396 }\r