src/encodings/fixed_8.c

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