src/encodings/ucs2.c

   1 /*
   2 Copyright (C) 2001-2008, The Perl Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/encodings/ucs2.c - UCS-2 encoding
   8
   9 =head1 DESCRIPTION
  10
  11 UCS-2 encoding with the help of the ICU library.
  12
  13 =head2 Functions
  14
  15 =over 4
  16
  17 =cut
  18
  19 */
  20
  21 #include "parrot/parrot.h"
  22 #include "../unicode.h"
  23
  24 /* HEADERIZER HFILE: src/encodings/ucs2.h */
  25
  26 /* HEADERIZER BEGIN: static */
  27 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
  28
  29 static void become_encoding(PARROT_INTERP, SHIM(STRING *src))
  30         __attribute__nonnull__(1);
  31
  32 PARROT_WARN_UNUSED_RESULT
  33 static UINTVAL bytes(PARROT_INTERP, ARGIN(STRING *src))
  34         __attribute__nonnull__(1)
  35         __attribute__nonnull__(2);
  36
  37 PARROT_WARN_UNUSED_RESULT
  38 static UINTVAL codepoints(PARROT_INTERP, ARGIN(STRING *src))
  39         __attribute__nonnull__(1)
  40         __attribute__nonnull__(2);
  41
  42 static UINTVAL get_byte(PARROT_INTERP,
  43     SHIM(const STRING *src),
  44     UINTVAL offset)
  45         __attribute__nonnull__(1);
  46
  47 PARROT_WARN_UNUSED_RESULT
  48 PARROT_CANNOT_RETURN_NULL
  49 static STRING * get_bytes(PARROT_INTERP,
  50     SHIM(STRING *src),
  51     UINTVAL offset,
  52     UINTVAL count)
  53         __attribute__nonnull__(1);
  54
  55 PARROT_WARN_UNUSED_RESULT
  56 PARROT_CANNOT_RETURN_NULL
  57 static STRING * get_bytes_inplace(PARROT_INTERP,
  58     SHIM(STRING *src),
  59     UINTVAL offset,
  60     UINTVAL count,
  61     SHIM(STRING *return_string))
  62         __attribute__nonnull__(1);
  63
  64 static UINTVAL get_codepoint(PARROT_INTERP,
  65     ARGIN(const STRING *src),
  66     UINTVAL offset)
  67         __attribute__nonnull__(1)
  68         __attribute__nonnull__(2);
  69
  70 PARROT_WARN_UNUSED_RESULT
  71 PARROT_CANNOT_RETURN_NULL
  72 static STRING * get_codepoints(PARROT_INTERP,
  73     ARGIN(STRING *src),
  74     UINTVAL offset,
  75     UINTVAL count)
  76         __attribute__nonnull__(1)
  77         __attribute__nonnull__(2);
  78
  79 PARROT_WARN_UNUSED_RESULT
  80 PARROT_CANNOT_RETURN_NULL
  81 static STRING * get_codepoints_inplace(PARROT_INTERP,
  82     SHIM(STRING *src),
  83     UINTVAL offset,
  84     UINTVAL count,
  85     SHIM(STRING *dest_string))
  86         __attribute__nonnull__(1);
  87
  88 static void iter_init(PARROT_INTERP,
  89     ARGIN(const STRING *src),
  90     ARGOUT(String_iter *iter))
  91         __attribute__nonnull__(1)
  92         __attribute__nonnull__(2)
  93         __attribute__nonnull__(3)
  94         FUNC_MODIFIES(*iter);
  95
  96 static void set_byte(PARROT_INTERP,
  97     SHIM(const STRING *src),
  98     UINTVAL offset,
  99     UINTVAL byte)
 100         __attribute__nonnull__(1);
 101
 102 static void set_bytes(PARROT_INTERP,
 103     SHIM(STRING *src),
 104     UINTVAL offset,
 105     UINTVAL count,
 106     SHIM(STRING *new_bytes))
 107         __attribute__nonnull__(1);
 108
 109 static void set_codepoint(PARROT_INTERP,
 110     ARGIN(STRING *src),
 111     UINTVAL offset,
 112     UINTVAL codepoint)
 113         __attribute__nonnull__(1)
 114         __attribute__nonnull__(2);
 115
 116 static void set_codepoints(PARROT_INTERP,
 117     SHIM(STRING *src),
 118     UINTVAL offset,
 119     UINTVAL count,
 120     SHIM(STRING *new_codepoints))
 121         __attribute__nonnull__(1);
 122
 123 PARROT_WARN_UNUSED_RESULT
 124 PARROT_CANNOT_RETURN_NULL
 125 static STRING * to_encoding(PARROT_INTERP,
 126     ARGIN(STRING *src),
 127     ARGMOD(STRING *dest))
 128         __attribute__nonnull__(1)
 129         __attribute__nonnull__(2)
 130         __attribute__nonnull__(3)
 131         FUNC_MODIFIES(*dest);
 132
 133 static UINTVAL ucs2_decode_and_advance(PARROT_INTERP,
 134     ARGMOD(String_iter *i))
 135         __attribute__nonnull__(1)
 136         __attribute__nonnull__(2)
 137         FUNC_MODIFIES(*i);
 138
 139 static void ucs2_encode_and_advance(PARROT_INTERP,
 140     ARGMOD(String_iter *i),
 141     UINTVAL c)
 142         __attribute__nonnull__(1)
 143         __attribute__nonnull__(2)
 144         FUNC_MODIFIES(*i);
 145
 146 static void ucs2_set_position(SHIM_INTERP,
 147     ARGMOD(String_iter *i),
 148     UINTVAL n)
 149         __attribute__nonnull__(2)
 150         FUNC_MODIFIES(*i);
 151
 152 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 153 /* HEADERIZER END: static */
 154
 155 #include "ucs2.h"
 156
 157 #if PARROT_HAS_ICU
 158 #  include <unicode/ustring.h>
 159 #endif
 160
 161 #define UNIMPL real_exception(interp, NULL, UNIMPLEMENTED, "unimpl ucs2")
 162
 163
 164
 165 /*
 166
 167 =item C<static STRING * to_encoding>
 168
 169 Converts the string C<src> to this particular encoding.  If C<dest> is
 170 provided, it will contain the result.  Otherwise this function operates in
 171 place.
 172
 173 =cut
 174
 175 */
 176
 177 PARROT_WARN_UNUSED_RESULT
 178 PARROT_CANNOT_RETURN_NULL
 179 static STRING *
 180 to_encoding(PARROT_INTERP, ARGIN(STRING *src), ARGMOD(STRING *dest))
 181 {
 182     STRING * const result =
 183         Parrot_utf16_encoding_ptr->to_encoding(interp, src, dest);
 184     /*
 185      * conversion to utf16 downgrads to ucs-2 if possible - check result
 186      */
 187     if (result->encoding == Parrot_utf16_encoding_ptr) {
 188         real_exception(interp, NULL, E_UnicodeError,
 189             "can't convert string with surrogates to ucs2");
 190     }
 191     return result;
 192 }
 193
 194 /*
 195
 196 =item C<static UINTVAL get_codepoint>
 197
 198 Returns the codepoint in string C<src> at position C<offset>.
 199
 200 =cut
 201
 202 */
 203
 204 static UINTVAL
 205 get_codepoint(PARROT_INTERP, ARGIN(const STRING *src), UINTVAL offset)
 206 {
 207 #if PARROT_HAS_ICU
 208     UChar * const s = (UChar*) src->strstart;
 209     return s[offset];
 210 #else
 211     real_exception(interp, NULL, E_LibraryNotLoadedError,
 212             "no ICU lib loaded");
 213 #endif
 214 }
 215
 216 /*
 217
 218 =item C<static void set_codepoint>
 219
 220 Sets, in string C<src> at position C<offset>, the codepoint C<codepoint>.
 221
 222 =cut
 223
 224 */
 225
 226 static void
 227 set_codepoint(PARROT_INTERP, ARGIN(STRING *src), UINTVAL offset, UINTVAL codepoint)
 228 {
 229 #if PARROT_HAS_ICU
 230     UChar * const s = (UChar*) src->strstart;
 231     s[offset] = codepoint;
 232 #else
 233     UNUSED(src);
 234     real_exception(interp, NULL, E_LibraryNotLoadedError,
 235             "no ICU lib loaded");
 236 #endif
 237 }
 238
 239 /*
 240
 241 =item C<static UINTVAL get_byte>
 242
 243 Returns the byte in string C<src> at position C<offset>.
 244
 245 =cut
 246
 247 */
 248
 249 static UINTVAL
 250 get_byte(PARROT_INTERP, SHIM(const STRING *src), UINTVAL offset)
 251 {
 252     UNIMPL;
 253 }
 254
 255 /*
 256
 257 =item C<static void set_byte>
 258
 259 Sets, in string C<src> at position C<offset>, the byte C<byte>.
 260
 261 =cut
 262
 263 */
 264
 265 static void
 266 set_byte(PARROT_INTERP, SHIM(const STRING *src), UINTVAL offset, UINTVAL byte)
 267 {
 268     UNIMPL;
 269 }
 270
 271 /*
 272
 273 =item C<static STRING * get_codepoints>
 274
 275 Returns the codepoints in string C<src> at position C<offset> and length
 276 C<count>.
 277
 278 =cut
 279
 280 */
 281
 282 PARROT_WARN_UNUSED_RESULT
 283 PARROT_CANNOT_RETURN_NULL
 284 static STRING *
 285 get_codepoints(PARROT_INTERP, ARGIN(STRING *src), UINTVAL offset, UINTVAL count)
 286 {
 287     STRING * const return_string = Parrot_make_COW_reference(interp, src);
 288 #if PARROT_HAS_ICU
 289     return_string->strstart = (char*)src->strstart + offset * sizeof (UChar);
 290     return_string->bufused = count * sizeof (UChar);
 291 #else
 292     {
 293         String_iter iter;
 294         UINTVAL start;
 295
 296         iter_init(interp, src, &iter);
 297         iter.set_position(interp, &iter, offset);
 298         start = iter.bytepos;
 299         return_string->strstart = (char *)return_string->strstart + start;
 300         iter.set_position(interp, &iter, offset + count);
 301         return_string->bufused = iter.bytepos - start;
 302     }
 303 #endif
 304     return_string->strlen = count;
 305     return_string->hashval = 0;
 306     return return_string;
 307 }
 308
 309 /*
 310
 311 =item C<static STRING * get_bytes>
 312
 313 Returns the bytes in string C<src> at position C<offset> and length C<count>.
 314
 315 =cut
 316
 317 */
 318
 319 PARROT_WARN_UNUSED_RESULT
 320 PARROT_CANNOT_RETURN_NULL
 321 static STRING *
 322 get_bytes(PARROT_INTERP, SHIM(STRING *src), UINTVAL offset, UINTVAL count)
 323 {
 324     UNIMPL;
 325 }
 326
 327
 328 /*
 329
 330 =item C<static STRING * get_codepoints_inplace>
 331
 332 Gets from string C<src> at position C<offset> C<count> codepoints and returns
 333 them in C<return_string>.
 334
 335 =cut
 336
 337 */
 338
 339 PARROT_WARN_UNUSED_RESULT
 340 PARROT_CANNOT_RETURN_NULL
 341 static STRING *
 342 get_codepoints_inplace(PARROT_INTERP, SHIM(STRING *src),
 343         UINTVAL offset, UINTVAL count, SHIM(STRING *dest_string))
 344 {
 345
 346     UNIMPL;
 347 }
 348
 349 /*
 350
 351 =item C<static STRING * get_bytes_inplace>
 352
 353 Gets from string C<src> at position C<offset> C<count> bytes and returns them
 354 in C<return_string>.
 355
 356 =cut
 357
 358 */
 359
 360 PARROT_WARN_UNUSED_RESULT
 361 PARROT_CANNOT_RETURN_NULL
 362 static STRING *
 363 get_bytes_inplace(PARROT_INTERP, SHIM(STRING *src),
 364         UINTVAL offset, UINTVAL count, SHIM(STRING *return_string))
 365 {
 366     UNIMPL;
 367 }
 368
 369 /*
 370
 371 =item C<static void set_codepoints>
 372
 373 Replaces in string C<src> at position C<offset> for C<count> codepoints with
 374 the contents of string C<new_codepoints>.
 375
 376 =cut
 377
 378 */
 379
 380 static void
 381 set_codepoints(PARROT_INTERP, SHIM(STRING *src),
 382         UINTVAL offset, UINTVAL count, SHIM(STRING *new_codepoints))
 383 {
 384     UNIMPL;
 385 }
 386
 387 /*
 388
 389 =item C<static void set_bytes>
 390
 391 Replaces in string C<src> at position C<offset> for C<count> bytes with the
 392 contents of string C<new_bytes>.
 393
 394 =cut
 395
 396 */
 397
 398 static void
 399 set_bytes(PARROT_INTERP, SHIM(STRING *src),
 400         UINTVAL offset, UINTVAL count, SHIM(STRING *new_bytes))
 401 {
 402     UNIMPL;
 403 }
 404
 405 /*
 406
 407 =item C<static void become_encoding>
 408
 409 Unconditionally makes the string be in this encoding, if that's valid
 410
 411 =cut
 412
 413 */
 414
 415 static void
 416 become_encoding(PARROT_INTERP, SHIM(STRING *src))
 417 {
 418     UNIMPL;
 419 }
 420
 421
 422 /*
 423
 424 =item C<static UINTVAL codepoints>
 425
 426 Returns the number of codepoints in string C<src>.
 427
 428 =cut
 429
 430 */
 431
 432 PARROT_WARN_UNUSED_RESULT
 433 static UINTVAL
 434 codepoints(PARROT_INTERP, ARGIN(STRING *src))
 435 {
 436 #if PARROT_HAS_ICU
 437     return src->bufused / sizeof (UChar);
 438 #else
 439     real_exception(interp, NULL, E_LibraryNotLoadedError,
 440             "no ICU lib loaded");
 441 #endif
 442 }
 443
 444 /*
 445
 446 =item C<static UINTVAL bytes>
 447
 448 Returns the number of bytes in string C<src>.
 449
 450 =cut
 451
 452 */
 453
 454 PARROT_WARN_UNUSED_RESULT
 455 static UINTVAL
 456 bytes(PARROT_INTERP, ARGIN(STRING *src))
 457 {
 458     return src->bufused;
 459 }
 460
 461 /*
 462
 463 =item C<static UINTVAL ucs2_decode_and_advance>
 464
 465 Moves the string iterator C<i> to the next UCS-2 codepoint.
 466
 467 =cut
 468
 469 */
 470
 471 #if PARROT_HAS_ICU
 472 static UINTVAL
 473 ucs2_decode_and_advance(PARROT_INTERP, ARGMOD(String_iter *i))
 474 {
 475     UChar * const s = (UChar*) i->str->strstart;
 476     size_t pos = i->bytepos / sizeof (UChar);
 477
 478     /* TODO either make sure that we don't go past end or use SAFE
 479      *      iter versions
 480      */
 481     const UChar c = s[pos++];
 482     i->charpos++;
 483     i->bytepos = pos * sizeof (UChar);
 484     return c;
 485 }
 486
 487 /*
 488
 489 =item C<static void ucs2_encode_and_advance>
 490
 491 With the string iterator C<i>, appends the codepoint C<c> and advances to the
 492 next position in the string.
 493
 494 =cut
 495
 496 */
 497
 498 static void
 499 ucs2_encode_and_advance(PARROT_INTERP, ARGMOD(String_iter *i), UINTVAL c)
 500 {
 501     UChar * const s = (UChar*) i->str->strstart;
 502     UINTVAL pos = i->bytepos / sizeof (UChar);
 503     s[pos++] = (UChar)c;
 504     i->charpos++;
 505     i->bytepos = pos * sizeof (UChar);
 506 }
 507
 508 /*
 509
 510 =item C<static void ucs2_set_position>
 511
 512 Moves the string iterator C<i> to the position C<n> in the string.
 513
 514 =cut
 515
 516 */
 517
 518 static void
 519 ucs2_set_position(SHIM_INTERP, ARGMOD(String_iter *i), UINTVAL n)
 520 {
 521     i->charpos = n;
 522     i->bytepos = n * sizeof (UChar);
 523 }
 524
 525 #endif
 526
 527 /*
 528
 529 =item C<static void iter_init>
 530
 531 Initializes for string C<src> the string iterator C<iter>.
 532
 533 =cut
 534
 535 */
 536
 537 static void
 538 iter_init(PARROT_INTERP, ARGIN(const STRING *src), ARGOUT(String_iter *iter))
 539 {
 540 #if PARROT_HAS_ICU
 541     iter->str = src;
 542     iter->bytepos = 0;
 543     iter->charpos = 0;
 544     iter->get_and_advance = ucs2_decode_and_advance;
 545     iter->set_and_advance = ucs2_encode_and_advance;
 546     iter->set_position =    ucs2_set_position;
 547 #else
 548     real_exception(interp, NULL, E_LibraryNotLoadedError,
 549             "no ICU lib loaded");
 550 #endif
 551 }
 552
 553 /*
 554
 555 =item C<ENCODING * Parrot_encoding_ucs2_init>
 556
 557 Initializes the UCS-2 encoding.
 558
 559 =cut
 560
 561 */
 562
 563 PARROT_CANNOT_RETURN_NULL
 564 ENCODING *
 565 Parrot_encoding_ucs2_init(PARROT_INTERP)
 566 {
 567     ENCODING * const return_encoding = Parrot_new_encoding(interp);
 568
 569     static const ENCODING base_encoding = {
 570         "ucs2",
 571         2, /* Max bytes per codepoint 0 .. 0x10ffff */
 572         to_encoding,
 573         get_codepoint,
 574         set_codepoint,
 575         get_byte,
 576         set_byte,
 577         get_codepoints,
 578         get_codepoints_inplace,
 579         get_bytes,
 580         get_bytes_inplace,
 581         set_codepoints,
 582         set_bytes,
 583         become_encoding,
 584         codepoints,
 585         bytes,
 586         iter_init
 587     };
 588     STRUCT_COPY_FROM_STRUCT(return_encoding, base_encoding);
 589     Parrot_register_encoding(interp, "ucs2", return_encoding);
 590     return return_encoding;
 591 }
 592
 593 /*
 594
 595 =back
 596
 597 =head1 SEE ALSO
 598
 599 F<src/encodings/fixed_8.c>,
 600 F<src/encodings/utf8.c>,
 601 F<src/string.c>,
 602 F<include/parrot/string.h>,
 603 F<docs/string.pod>.
 604
 605 =cut
 606
 607 */
 608
 609
 610 /*
 611  * Local variables:
 612  *   c-file-style: "parrot"
 613  * End:
 614  * vim: expandtab shiftwidth=4:
 615  */