src/spf_vtable.c

   1 /*
   2 Copyright (C) 2001-2009, Parrot Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/spf_vtable.c - Parrot sprintf
   8
   9 =head1 DESCRIPTION
  10
  11 Implements the two families of functions C<Parrot_sprintf> may use to
  12 retrieve arguments.
  13
  14 =head2 Var args Functions
  15
  16 =over 4
  17
  18 =cut
  19
  20 */
  21
  22 #define IN_SPF_SYSTEM
  23
  24 #include "parrot/parrot.h"
  25
  26 #include <stdarg.h>
  27 #include "spf_vtable.str"
  28
  29 /* HEADERIZER HFILE: none */
  30
  31 /* HEADERIZER BEGIN: static */
  32 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
  33
  34 PARROT_CANNOT_RETURN_NULL
  35 PARROT_WARN_UNUSED_RESULT
  36 static STRING * getchr_pmc(PARROT_INTERP,
  37     SHIM(INTVAL size),
  38     ARGMOD(SPRINTF_OBJ *obj))
  39         __attribute__nonnull__(1)
  40         __attribute__nonnull__(3)
  41         FUNC_MODIFIES(*obj);
  42
  43 PARROT_CANNOT_RETURN_NULL
  44 PARROT_WARN_UNUSED_RESULT
  45 static STRING * getchr_va(PARROT_INTERP,
  46     SHIM(INTVAL size),
  47     ARGIN(SPRINTF_OBJ *obj))
  48         __attribute__nonnull__(1)
  49         __attribute__nonnull__(3);
  50
  51 PARROT_WARN_UNUSED_RESULT
  52 static HUGEFLOATVAL getfloat_pmc(PARROT_INTERP,
  53     INTVAL size,
  54     ARGIN(SPRINTF_OBJ *obj))
  55         __attribute__nonnull__(1)
  56         __attribute__nonnull__(3);
  57
  58 PARROT_WARN_UNUSED_RESULT
  59 static HUGEFLOATVAL getfloat_va(PARROT_INTERP,
  60     INTVAL size,
  61     ARGIN(SPRINTF_OBJ *obj))
  62         __attribute__nonnull__(1)
  63         __attribute__nonnull__(3);
  64
  65 PARROT_WARN_UNUSED_RESULT
  66 static HUGEINTVAL getint_pmc(PARROT_INTERP,
  67     INTVAL size,
  68     ARGIN(SPRINTF_OBJ *obj))
  69         __attribute__nonnull__(1)
  70         __attribute__nonnull__(3);
  71
  72 PARROT_WARN_UNUSED_RESULT
  73 static HUGEINTVAL getint_va(PARROT_INTERP,
  74     INTVAL size,
  75     ARGIN(SPRINTF_OBJ *obj))
  76         __attribute__nonnull__(1)
  77         __attribute__nonnull__(3);
  78
  79 PARROT_WARN_UNUSED_RESULT
  80 PARROT_CANNOT_RETURN_NULL
  81 static void * getptr_pmc(PARROT_INTERP,
  82     SHIM(INTVAL size),
  83     ARGIN(SPRINTF_OBJ *obj))
  84         __attribute__nonnull__(1)
  85         __attribute__nonnull__(3);
  86
  87 PARROT_WARN_UNUSED_RESULT
  88 PARROT_CAN_RETURN_NULL
  89 static void * getptr_va(SHIM_INTERP,
  90     SHIM(INTVAL size),
  91     ARGIN(SPRINTF_OBJ *obj))
  92         __attribute__nonnull__(3);
  93
  94 PARROT_WARN_UNUSED_RESULT
  95 PARROT_CANNOT_RETURN_NULL
  96 static STRING * getstring_pmc(PARROT_INTERP,
  97     SHIM(INTVAL size),
  98     ARGIN(SPRINTF_OBJ *obj))
  99         __attribute__nonnull__(1)
 100         __attribute__nonnull__(3);
 101
 102 PARROT_WARN_UNUSED_RESULT
 103 PARROT_CANNOT_RETURN_NULL
 104 static STRING * getstring_va(PARROT_INTERP,
 105     INTVAL size,
 106     ARGIN(SPRINTF_OBJ *obj))
 107         __attribute__nonnull__(1)
 108         __attribute__nonnull__(3);
 109
 110 PARROT_WARN_UNUSED_RESULT
 111 static UHUGEINTVAL getuint_pmc(PARROT_INTERP,
 112     INTVAL size,
 113     ARGIN(SPRINTF_OBJ *obj))
 114         __attribute__nonnull__(1)
 115         __attribute__nonnull__(3);
 116
 117 PARROT_WARN_UNUSED_RESULT
 118 static UHUGEINTVAL getuint_va(PARROT_INTERP,
 119     INTVAL size,
 120     ARGIN(SPRINTF_OBJ *obj))
 121         __attribute__nonnull__(1)
 122         __attribute__nonnull__(3);
 123
 124 #define ASSERT_ARGS_getchr_pmc __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 125        PARROT_ASSERT_ARG(interp) \
 126     , PARROT_ASSERT_ARG(obj))
 127 #define ASSERT_ARGS_getchr_va __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 128        PARROT_ASSERT_ARG(interp) \
 129     , PARROT_ASSERT_ARG(obj))
 130 #define ASSERT_ARGS_getfloat_pmc __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 131        PARROT_ASSERT_ARG(interp) \
 132     , PARROT_ASSERT_ARG(obj))
 133 #define ASSERT_ARGS_getfloat_va __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 134        PARROT_ASSERT_ARG(interp) \
 135     , PARROT_ASSERT_ARG(obj))
 136 #define ASSERT_ARGS_getint_pmc __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 137        PARROT_ASSERT_ARG(interp) \
 138     , PARROT_ASSERT_ARG(obj))
 139 #define ASSERT_ARGS_getint_va __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 140        PARROT_ASSERT_ARG(interp) \
 141     , PARROT_ASSERT_ARG(obj))
 142 #define ASSERT_ARGS_getptr_pmc __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 143        PARROT_ASSERT_ARG(interp) \
 144     , PARROT_ASSERT_ARG(obj))
 145 #define ASSERT_ARGS_getptr_va __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 146        PARROT_ASSERT_ARG(obj))
 147 #define ASSERT_ARGS_getstring_pmc __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 148        PARROT_ASSERT_ARG(interp) \
 149     , PARROT_ASSERT_ARG(obj))
 150 #define ASSERT_ARGS_getstring_va __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 151        PARROT_ASSERT_ARG(interp) \
 152     , PARROT_ASSERT_ARG(obj))
 153 #define ASSERT_ARGS_getuint_pmc __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 154        PARROT_ASSERT_ARG(interp) \
 155     , PARROT_ASSERT_ARG(obj))
 156 #define ASSERT_ARGS_getuint_va __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
 157        PARROT_ASSERT_ARG(interp) \
 158     , PARROT_ASSERT_ARG(obj))
 159 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 160 /* HEADERIZER END: static */
 161
 162 /*
 163
 164 =item C<static STRING * getchr_va(PARROT_INTERP, INTVAL size, SPRINTF_OBJ *obj)>
 165
 166 Gets a C<char> out of the C<va_list> in C<obj> and returns it as a
 167 Parrot C<STRING>.
 168
 169 C<size> is unused.
 170
 171 =cut
 172
 173 */
 174
 175 PARROT_CANNOT_RETURN_NULL
 176 PARROT_WARN_UNUSED_RESULT
 177 static STRING *
 178 getchr_va(PARROT_INTERP, SHIM(INTVAL size), ARGIN(SPRINTF_OBJ *obj))
 179 {
 180     ASSERT_ARGS(getchr_va)
 181     va_list *arg = (va_list *)(obj->data);
 182
 183     /* char promoted to int */
 184     char ch = (char)va_arg(*arg, int);
 185
 186     return Parrot_str_new_init(interp, &ch, 1, Parrot_latin1_encoding_ptr, 0);
 187 }
 188
 189 /*
 190
 191 =item C<static HUGEINTVAL getint_va(PARROT_INTERP, INTVAL size, SPRINTF_OBJ
 192 *obj)>
 193
 194 Gets an integer out of the C<va_list> in C<obj> and returns it as a
 195 Parrot C<STRING>.
 196
 197 C<size> is an C<enum spf_type_t> value which indicates the storage type
 198 of the integer.
 199
 200 =cut
 201
 202 */
 203
 204 PARROT_WARN_UNUSED_RESULT
 205 static HUGEINTVAL
 206 getint_va(PARROT_INTERP, INTVAL size, ARGIN(SPRINTF_OBJ *obj))
 207 {
 208     ASSERT_ARGS(getint_va)
 209     va_list * const arg = (va_list *)(obj->data);
 210
 211     switch (size) {
 212       case SIZE_REG:
 213         return va_arg(*arg, int);
 214
 215       case SIZE_SHORT:
 216         /* "'short int' is promoted to 'int' when passed through '...'" */
 217         return (short)va_arg(*arg, int);
 218
 219       case SIZE_LONG:
 220         return va_arg(*arg, long);
 221
 222       case SIZE_HUGE:
 223         return va_arg(*arg, HUGEINTVAL);
 224
 225       case SIZE_XVAL:
 226         return va_arg(*arg, INTVAL);
 227
 228       case SIZE_OPCODE:
 229         return va_arg(*arg, opcode_t);
 230
 231       case SIZE_PMC:
 232         {
 233             PMC * const pmc = (PMC *)va_arg(*arg, PMC *);
 234             return VTABLE_get_integer(interp, pmc);
 235         }
 236
 237       default:
 238         PANIC(interp, "Invalid int type!");
 239     }
 240 }
 241
 242 /*
 243
 244 =item C<static UHUGEINTVAL getuint_va(PARROT_INTERP, INTVAL size, SPRINTF_OBJ
 245 *obj)>
 246
 247 Gets an unsigned integer out of the C<va_list> in C<obj> and returns it
 248 as a Parrot C<STRING>.
 249
 250 C<size> is an C<enum spf_type_t> value which indicates the storage type
 251 of the integer.
 252
 253 =cut
 254
 255 */
 256
 257 PARROT_WARN_UNUSED_RESULT
 258 static UHUGEINTVAL
 259 getuint_va(PARROT_INTERP, INTVAL size, ARGIN(SPRINTF_OBJ *obj))
 260 {
 261     ASSERT_ARGS(getuint_va)
 262     va_list * const arg = (va_list *)(obj->data);
 263
 264     switch (size) {
 265       case SIZE_REG:
 266         return va_arg(*arg, unsigned int);
 267
 268       case SIZE_SHORT:
 269         /* short int promoted HLAGHLAGHLAGH. See note above */
 270         return (unsigned short)va_arg(*arg, unsigned int);
 271
 272       case SIZE_LONG:
 273         return va_arg(*arg, unsigned long);
 274
 275       case SIZE_HUGE:
 276         return va_arg(*arg, UHUGEINTVAL);
 277
 278       case SIZE_XVAL:
 279         return va_arg(*arg, UINTVAL);
 280
 281       case SIZE_OPCODE:
 282         return va_arg(*arg, opcode_t);
 283
 284       case SIZE_PMC:
 285         {
 286             PMC * const pmc = va_arg(*arg, PMC *);
 287             return (UINTVAL)VTABLE_get_integer(interp, pmc);
 288         }
 289
 290       default:
 291         PANIC(interp, "Invalid uint type!");
 292     }
 293 }
 294
 295 /*
 296
 297 =item C<static HUGEFLOATVAL getfloat_va(PARROT_INTERP, INTVAL size, SPRINTF_OBJ
 298 *obj)>
 299
 300 Gets an floating-point number out of the C<va_list> in C<obj> and
 301 returns it as a Parrot C<STRING>.
 302
 303 C<size> is an C<enum spf_type_t> value which indicates the storage type of
 304 the number.
 305
 306 =cut
 307
 308 */
 309
 310 PARROT_WARN_UNUSED_RESULT
 311 static HUGEFLOATVAL
 312 getfloat_va(PARROT_INTERP, INTVAL size, ARGIN(SPRINTF_OBJ *obj))
 313 {
 314     ASSERT_ARGS(getfloat_va)
 315     va_list * const arg = (va_list *)(obj->data);
 316
 317     switch (size) {
 318       case SIZE_SHORT:
 319         /* float is promoted to double */
 320         return (HUGEFLOATVAL)(float)va_arg(*arg, double);
 321
 322       case SIZE_REG:
 323         return (HUGEFLOATVAL)(double)va_arg(*arg, double);
 324
 325       case SIZE_HUGE:
 326         return (HUGEFLOATVAL)(HUGEFLOATVAL) va_arg(*arg, HUGEFLOATVAL);
 327
 328       case SIZE_XVAL:
 329         return (HUGEFLOATVAL)(FLOATVAL) va_arg(*arg, FLOATVAL);
 330
 331       case SIZE_PMC:
 332         {
 333             PMC * const pmc = (PMC *)va_arg(*arg, PMC *);
 334
 335             return (HUGEFLOATVAL)(VTABLE_get_number(interp, pmc));
 336         }
 337
 338       default:
 339         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_CHARACTER,
 340             "Internal sprintf doesn't recognize size %d for a float", size);
 341     }
 342 }
 343
 344 /*
 345
 346 =item C<static STRING * getstring_va(PARROT_INTERP, INTVAL size, SPRINTF_OBJ
 347 *obj)>
 348
 349 Gets an string out of the C<va_list> in C<obj> and returns it as a
 350 Parrot C<STRING>.
 351
 352 C<size> is an C<enum spf_type_t> value which indicates the storage type
 353 of the string.
 354
 355 =cut
 356
 357 */
 358
 359 PARROT_WARN_UNUSED_RESULT
 360 PARROT_CANNOT_RETURN_NULL
 361 static STRING *
 362 getstring_va(PARROT_INTERP, INTVAL size, ARGIN(SPRINTF_OBJ *obj))
 363 {
 364     ASSERT_ARGS(getstring_va)
 365     va_list * const arg = (va_list *)(obj->data);
 366
 367     switch (size) {
 368     case SIZE_REG:
 369         {
 370             const char * const cstr = (char *)va_arg(*arg, char *);
 371
 372             return cstr2pstr(cstr);
 373         }
 374
 375     case SIZE_PSTR:
 376         {
 377             STRING * const s = (STRING *)va_arg(*arg, STRING *);
 378             return s ? s : CONST_STRING(interp, "(null)");
 379
 380         }
 381
 382     case SIZE_PMC:
 383         {
 384             PMC * const pmc = (PMC *)va_arg(*arg, PMC *);
 385             STRING * const s = VTABLE_get_string(interp, pmc);
 386
 387             return s;
 388         }
 389
 390     default:
 391         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_CHARACTER,
 392             "Internal sprintf doesn't recognize size %d for a string", size);
 393     }
 394 }
 395
 396 /*
 397
 398 =item C<static void * getptr_va(PARROT_INTERP, INTVAL size, SPRINTF_OBJ *obj)>
 399
 400 Gets a C<void *> out of the C<va_list> in C<obj> and returns it.
 401
 402 C<size> is unused.
 403
 404 =cut
 405
 406 */
 407
 408 PARROT_WARN_UNUSED_RESULT
 409 PARROT_CAN_RETURN_NULL
 410 static void *
 411 getptr_va(SHIM_INTERP, SHIM(INTVAL size), ARGIN(SPRINTF_OBJ *obj))
 412 {
 413     ASSERT_ARGS(getptr_va)
 414     va_list * const arg = (va_list *)(obj->data);
 415
 416     return (void *)va_arg(*arg, void *);
 417 }
 418
 419 const SPRINTF_OBJ va_core = {
 420     NULL, 0, getchr_va, getint_va, getuint_va,
 421     getfloat_va, getstring_va, getptr_va
 422 };
 423
 424 /*
 425
 426 =back
 427
 428 =head2 PMC Functions
 429
 430 =over 4
 431
 432 =item C<static STRING * getchr_pmc(PARROT_INTERP, INTVAL size, SPRINTF_OBJ
 433 *obj)>
 434
 435 Same as C<getchr_va()> except that a vtable is used to get the value
 436 from C<obj>.
 437
 438 =cut
 439
 440 */
 441
 442 PARROT_CANNOT_RETURN_NULL
 443 PARROT_WARN_UNUSED_RESULT
 444 static STRING *
 445 getchr_pmc(PARROT_INTERP, SHIM(INTVAL size), ARGMOD(SPRINTF_OBJ *obj))
 446 {
 447     ASSERT_ARGS(getchr_pmc)
 448     STRING *s;
 449     PMC * const tmp = VTABLE_get_pmc_keyed_int(interp,
 450             ((PMC *)obj->data),
 451             (obj->index));
 452
 453     ++obj->index;
 454     s = VTABLE_get_string(interp, tmp);
 455     return Parrot_str_substr(interp, s, 0, 1);
 456 }
 457
 458 /*
 459
 460 =item C<static HUGEINTVAL getint_pmc(PARROT_INTERP, INTVAL size, SPRINTF_OBJ
 461 *obj)>
 462
 463 Same as C<getint_va()> except that a vtable is used to get the value
 464 from C<obj>.
 465
 466 =cut
 467
 468 */
 469
 470 PARROT_WARN_UNUSED_RESULT
 471 static HUGEINTVAL
 472 getint_pmc(PARROT_INTERP, INTVAL size, ARGIN(SPRINTF_OBJ *obj))
 473 {
 474     ASSERT_ARGS(getint_pmc)
 475
 476     PMC * const tmp = VTABLE_get_pmc_keyed_int(interp,
 477             ((PMC *)obj->data),
 478             (obj->index++));
 479
 480     HUGEINTVAL ret  = VTABLE_get_integer(interp, tmp);
 481
 482     switch (size) {
 483       case SIZE_SHORT:
 484         ret = (short)ret;
 485         break;
 486         /* case SIZE_REG: ret=(HUGEINTVAL)(int)ret; break; */
 487       case SIZE_LONG:
 488         ret = (long)ret;
 489         break;
 490       default:
 491         /* nothing */ ;
 492     }
 493
 494     return ret;
 495 }
 496
 497 /*
 498
 499 =item C<static UHUGEINTVAL getuint_pmc(PARROT_INTERP, INTVAL size, SPRINTF_OBJ
 500 *obj)>
 501
 502 Same as C<getuint_va()> except that a vtable is used to get the value
 503 from C<obj>.
 504
 505 =cut
 506
 507 */
 508
 509 PARROT_WARN_UNUSED_RESULT
 510 static UHUGEINTVAL
 511 getuint_pmc(PARROT_INTERP, INTVAL size, ARGIN(SPRINTF_OBJ *obj))
 512 {
 513     ASSERT_ARGS(getuint_pmc)
 514
 515     PMC * const tmp = VTABLE_get_pmc_keyed_int(interp,
 516             ((PMC *)obj->data),
 517             (obj->index++));
 518
 519     UHUGEINTVAL ret = (UINTVAL)VTABLE_get_integer(interp, tmp);
 520
 521     switch (size) {
 522       case SIZE_SHORT:
 523         ret = (unsigned short)ret;
 524         break;
 525         /* case SIZE_REG: * ret=(UHUGEINTVAL)(unsigned int)ret; * break; */
 526       case SIZE_LONG:
 527         ret = (unsigned long)ret;
 528         break;
 529       default:
 530         /* nothing */ ;
 531     }
 532
 533     return ret;
 534 }
 535
 536 /*
 537
 538 =item C<static HUGEFLOATVAL getfloat_pmc(PARROT_INTERP, INTVAL size, SPRINTF_OBJ
 539 *obj)>
 540
 541 Same as C<getfloat_va()> except that a vtable is used to get the value
 542 from C<obj>.
 543
 544 =cut
 545
 546 */
 547
 548 PARROT_WARN_UNUSED_RESULT
 549 static HUGEFLOATVAL
 550 getfloat_pmc(PARROT_INTERP, INTVAL size, ARGIN(SPRINTF_OBJ *obj))
 551 {
 552     ASSERT_ARGS(getfloat_pmc)
 553     PMC * const tmp  = VTABLE_get_pmc_keyed_int(interp,
 554             ((PMC *)obj->data),
 555             (obj->index++));
 556
 557     HUGEFLOATVAL ret = (HUGEFLOATVAL)(VTABLE_get_number(interp, tmp));
 558
 559     switch (size) {
 560     case SIZE_SHORT:
 561         ret = (HUGEFLOATVAL)(float)ret;
 562         break;
 563         /* case SIZE_REG: * ret=(HUGEFLOATVAL)(double)ret; * break; */
 564     default:
 565         /* nothing */ ;
 566     }
 567
 568     return ret;
 569 }
 570
 571 /*
 572
 573 =item C<static STRING * getstring_pmc(PARROT_INTERP, INTVAL size, SPRINTF_OBJ
 574 *obj)>
 575
 576 Same as C<getstring_va()> except that a vtable is used to get the value
 577 from C<obj>.
 578
 579 =cut
 580
 581 */
 582
 583 PARROT_WARN_UNUSED_RESULT
 584 PARROT_CANNOT_RETURN_NULL
 585 static STRING *
 586 getstring_pmc(PARROT_INTERP, SHIM(INTVAL size), ARGIN(SPRINTF_OBJ *obj))
 587 {
 588     ASSERT_ARGS(getstring_pmc)
 589
 590     PMC * const tmp = VTABLE_get_pmc_keyed_int(interp,
 591             ((PMC *)obj->data),
 592             (obj->index++));
 593
 594     STRING * const str = (STRING *)(VTABLE_get_string(interp, tmp));
 595     return str;
 596 }
 597
 598 /*
 599
 600 =item C<static void * getptr_pmc(PARROT_INTERP, INTVAL size, SPRINTF_OBJ *obj)>
 601
 602 Same as C<getptr_va()> except that a vtable is used to get the value
 603 from C<obj>.
 604
 605 =cut
 606
 607 */
 608
 609 PARROT_WARN_UNUSED_RESULT
 610 PARROT_CANNOT_RETURN_NULL
 611 static void *
 612 getptr_pmc(PARROT_INTERP, SHIM(INTVAL size), ARGIN(SPRINTF_OBJ *obj))
 613 {
 614     ASSERT_ARGS(getptr_pmc)
 615     PMC * const tmp = VTABLE_get_pmc_keyed_int(interp,
 616             ((PMC *)obj->data), (obj->index++));
 617     const INTVAL i  = VTABLE_get_integer(interp, tmp);
 618
 619     /* XXX correct? */
 620     return (void *)i;
 621 }
 622
 623 SPRINTF_OBJ pmc_core = {
 624     NULL, 0, getchr_pmc, getint_pmc, getuint_pmc,
 625     getfloat_pmc, getstring_pmc, getptr_pmc
 626 };
 627
 628 /*
 629
 630 =back
 631
 632 =head1 SEE ALSO
 633
 634 F<src/misc.h>, F<src/misc.c>, F<src/spf_render.c>.
 635
 636 =head1 HISTORY
 637
 638 When I was first working on this implementation of sprintf, I ran into a
 639 problem.  I wanted to re-use the implementation for a Parrot
 640 bytecode-level sprintf, but that couldn't be done, since it used C<va_*>
 641 directly.  For a while I thought about generating two versions of the
 642 source with a Perl script, but that seemed like overkill. Eventually I
 643 came across this idea -- pass in a specialized vtable with methods for
 644 extracting things from the arglist, whatever it happened to be.  This is
 645 the result.
 646
 647 =head1 TODO
 648
 649 In the future, it may be deemed desirable to similarly vtable-ize
 650 appending things to the string, allowing for faster C<Parrot_io_printf()> &c,
 651 as well as a version that writes directly to a C string. However, at
 652 this point neither of those is needed.
 653
 654 =cut
 655
 656 */
 657
 658
 659 /*
 660  * Local variables:
 661  *   c-file-style: "parrot"
 662  * End:
 663  * vim: expandtab shiftwidth=4:
 664  */