compilers/imcc/instructions.c

   1 /* $Id$ */
   2
   3 /*
   4  * Copyright (C) 2002-2008, The Perl Foundation.
   5  */
   6
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #define _PARSER
  10 #include "imc.h"
  11 #include "pbc.h"
  12 #include "optimizer.h"
  13
  14 /*
  15
  16 =head1 NAME
  17
  18 compilers/imcc/instructions.c
  19
  20 =head1 DESCRIPTION
  21
  22 When generating the code, the instructions of the program
  23 are stored in an array.
  24
  25 After the register allocation is resolved, the instructions
  26 array is flushed.
  27
  28 These functions operate over this array and its contents.
  29
  30 =head2 Functions
  31
  32 =over 4
  33
  34 =cut
  35
  36 */
  37
  38 /* Global variables , forward def */
  39
  40 #if 0
  41 static Instruction * last_ins;
  42
  43 int n_comp_units;
  44 #endif
  45
  46 /* HEADERIZER HFILE: compilers/imcc/instructions.h */
  47
  48 /* HEADERIZER BEGIN: static */
  49 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
  50
  51 static int e_file_close(PARROT_INTERP, SHIM(void *param))
  52         __attribute__nonnull__(1);
  53
  54 static int e_file_emit(PARROT_INTERP,
  55     SHIM(void *param),
  56     SHIM(const IMC_Unit *unit),
  57     ARGIN(const Instruction *ins))
  58         __attribute__nonnull__(1)
  59         __attribute__nonnull__(4);
  60
  61 static int e_file_open(SHIM_INTERP, ARGIN(void *param))
  62         __attribute__nonnull__(2);
  63
  64 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
  65 /* HEADERIZER END: static */
  66
  67 static const char types[] = "INPS";
  68
  69 static const Emitter emitters[] = {
  70     {e_file_open,
  71      e_file_emit,
  72      NULL,
  73      NULL,
  74      e_file_close},
  75
  76     {e_pbc_open,
  77      e_pbc_emit,
  78      e_pbc_new_sub,
  79      e_pbc_end_sub,
  80      e_pbc_close},
  81 };
  82
  83 static int emitter;     /* XXX */
  84
  85 /*
  86
  87 =item C<Instruction * _mk_instruction>
  88
  89 Creates a new instruction
  90
  91 =cut
  92
  93 */
  94
  95 PARROT_MALLOC
  96 PARROT_CANNOT_RETURN_NULL
  97 Instruction *
  98 _mk_instruction(ARGIN(const char *op), ARGIN(const char *fmt), int n,
  99         ARGIN(SymReg * const *r), int flags)
 100 {
 101     const size_t reg_space  = (n > 1) ? (sizeof (SymReg *) * (n - 1)) : 0;
 102     Instruction * const ins =
 103         (Instruction*)mem_sys_allocate_zeroed(sizeof (Instruction) + reg_space);
 104     int i;
 105
 106     ins->opname       = str_dup(op);
 107     ins->format       = str_dup(fmt);
 108     ins->symreg_count = n;
 109
 110     for (i = 0; i < n; i++)
 111         ins->symregs[i]  = r[i];
 112
 113     ins->flags = flags;
 114     ins->opnum = -1;
 115
 116     return ins;
 117 }
 118
 119
 120 /*
 121  * Some instructions don't have a hint in op_info that they work
 122  * on all registers or all registers of a given type (e.g., cleari)
 123  * These instructions need special handling at various points in the code.
 124  */
 125
 126 static int w_special[1+4*3];
 127
 128 /*
 129
 130 =item C<void imcc_init_tables>
 131
 132 RT#48260: Not yet documented!!!
 133
 134 =cut
 135
 136 */
 137
 138 void
 139 imcc_init_tables(PARROT_INTERP)
 140 {
 141     const char *writes[] = {
 142         "cleari", "clearn", "clearp", "clears",
 143     };
 144     /* init opnums */
 145     if (!w_special[0]) {
 146         size_t i;
 147         for (i = 0; i < N_ELEMENTS(writes); i++) {
 148             const int n = interp->op_lib->op_code(writes[i], 1);
 149             PARROT_ASSERT(n);
 150             w_special[i] = n;
 151         }
 152     }
 153 }
 154
 155 /*
 156
 157 =item C<int ins_writes2>
 158
 159 Returns TRUE if instruction ins writes to a register of type t
 160
 161 =cut
 162
 163 */
 164
 165 int
 166 ins_writes2(ARGIN(const Instruction *ins), int t)
 167 {
 168     const char *p;
 169
 170     if (ins->opnum == w_special[0])
 171         return 1;
 172
 173     p = strchr(types, t);
 174
 175     if (p) {
 176         const size_t idx = p - types;
 177         size_t i;
 178
 179         for (i = 1; i < N_ELEMENTS(w_special); i += 4)
 180             if (ins->opnum == w_special[i + idx])
 181                 return 1;
 182     }
 183
 184     return 0;
 185 }
 186
 187 /*
 188
 189 =item C<int instruction_reads>
 190
 191 next two functions are called very often, says gprof
 192 they should be fast
 193
 194 =cut
 195
 196 */
 197
 198 int
 199 instruction_reads(ARGIN(const Instruction *ins), ARGIN(const SymReg *r))
 200 {
 201     int f, i;
 202
 203     if (ins->opnum == PARROT_OP_set_args_pc
 204     ||  ins->opnum == PARROT_OP_set_returns_pc) {
 205
 206         for (i = ins->symreg_count - 1; i >= 0; --i)
 207             if (r == ins->symregs[i])
 208                 return 1;
 209
 210         return 0;
 211     }
 212     else if (ins->opnum == PARROT_OP_get_params_pc ||
 213              ins->opnum == PARROT_OP_get_results_pc) {
 214         return 0;
 215     }
 216
 217     f = ins->flags;
 218
 219     for (i = ins->symreg_count - 1; i >= 0; --i) {
 220         if (f & (1 << i)) {
 221             const SymReg * const ri = ins->symregs[i];
 222
 223             if (ri == r)
 224                 return 1;
 225
 226             /* this additional test for _kc ops seems to slow
 227              * down instruction_reads by a huge amount compared to the
 228              * _writes below
 229              */
 230             if (ri->set == 'K') {
 231                 const SymReg *key;
 232                 for (key = ri->nextkey; key; key = key->nextkey)
 233                     if (key->reg == r)
 234                         return 1;
 235             }
 236         }
 237     }
 238
 239     /* a sub call reads the previous args */
 240     if (ins->type & ITPCCSUB) {
 241         while (ins && ins->opnum != PARROT_OP_set_args_pc)
 242             ins = ins->prev;
 243
 244         if (!ins)
 245             return 0;
 246
 247         for (i = ins->symreg_count - 1; i >= 0; --i) {
 248             if (ins->symregs[i] == r)
 249                 return 1;
 250         }
 251     }
 252
 253     return 0;
 254 }
 255
 256 /*
 257
 258 =item C<int instruction_writes>
 259
 260 RT#48260: Not yet documented!!!
 261
 262 =cut
 263
 264 */
 265
 266 int
 267 instruction_writes(ARGIN(const Instruction *ins), ARGIN(const SymReg *r))
 268 {
 269     const int f = ins->flags;
 270     int i;
 271
 272     /*
 273      * a get_results opcode is before the actual sub call
 274      * but for the register allocator, the effect matters, thus
 275      * postpone the effect after the invoke
 276      */
 277     if (ins->opnum == PARROT_OP_get_results_pc) {
 278         int i;
 279
 280         /* but only if it isn't the get_results opcode of
 281          * an exception_handler, which doesn't have
 282          * a call next
 283          */
 284         if (ins->next && (ins->next->type & ITPCCSUB))
 285             return 0;
 286
 287         for (i = ins->symreg_count - 1; i >= 0; --i) {
 288             if (ins->symregs[i] == r)
 289                 return 1;
 290         }
 291
 292         return 0;
 293     }
 294     else if (ins->type & ITPCCSUB) {
 295         int i;
 296         ins = ins->prev;
 297         /* can't used pcc_sub->ret due to bug #38406
 298          * it seems that all sub SymRegs are shared
 299          * and point to the most recemt pcc_sub
 300          * structure
 301          */
 302         while (ins && ins->opnum != PARROT_OP_get_results_pc)
 303             ins = ins->prev;
 304
 305         if (!ins)
 306             return 0;
 307
 308         for (i = ins->symreg_count - 1; i >= 0; --i) {
 309             if (ins->symregs[i] == r)
 310                 return 1;
 311         }
 312
 313         return 0;
 314     }
 315
 316     if (ins->opnum == PARROT_OP_get_params_pc) {
 317         int i;
 318
 319         for (i = ins->symreg_count - 1; i >= 0; --i) {
 320             if (ins->symregs[i] == r)
 321                 return 1;
 322         }
 323
 324         return 0;
 325     }
 326     else if (ins->opnum == PARROT_OP_set_args_pc
 327          ||  ins->opnum == PARROT_OP_set_returns_pc) {
 328         return 0;
 329     }
 330
 331     for (i = 0; i < ins->symreg_count; i++)
 332         if (f & (1 << (16 + i)))
 333             if (ins->symregs[i] == r)
 334                 return 1;
 335
 336     return 0;
 337 }
 338
 339 /*
 340
 341 =item C<int get_branch_regno>
 342
 343 Get the register number of an address which is a branch target
 344
 345 =cut
 346
 347 */
 348
 349 int
 350 get_branch_regno(ARGIN(const Instruction *ins))
 351 {
 352     int j;
 353
 354     for (j = ins->opsize - 2; j >= 0 && ins->symregs[j] ; --j)
 355         if (ins->type & (1 << j))
 356             return j;
 357
 358     return -1;
 359 }
 360
 361 /*
 362
 363 =item C<SymReg * get_branch_reg>
 364
 365 Get the register corresponding to an address which is a branch target
 366
 367 =cut
 368
 369 */
 370
 371 PARROT_WARN_UNUSED_RESULT
 372 PARROT_CAN_RETURN_NULL
 373 SymReg *
 374 get_branch_reg(ARGIN(const Instruction *ins))
 375 {
 376     const int r = get_branch_regno(ins);
 377
 378     if (r >= 0)
 379         return ins->symregs[r];
 380
 381     return NULL;
 382 }
 383
 384 /* some useful instruction routines */
 385
 386 /*
 387
 388 =item C<Instruction * _delete_ins>
 389
 390 Delete instruction ins. It's up to the caller to actually free the memory
 391 of ins, if appropriate.
 392
 393 The instruction following ins is returned.
 394
 395 =cut
 396
 397 */
 398
 399 PARROT_WARN_UNUSED_RESULT
 400 PARROT_CAN_RETURN_NULL
 401 Instruction *
 402 _delete_ins(ARGMOD(struct _IMC_Unit *unit), ARGIN(Instruction *ins))
 403 {
 404     Instruction * const next = ins->next;
 405     Instruction * const prev = ins->prev;
 406
 407     if (prev)
 408         prev->next = next;
 409     else
 410         unit->instructions = next;
 411
 412     if (next)
 413         next->prev = prev;
 414     else
 415         unit->last_ins = prev;
 416
 417     return next;
 418 }
 419
 420 /*
 421
 422 =item C<Instruction * delete_ins>
 423
 424 Delete instruction ins, and then free it.
 425
 426 The instruction following ins is returned.
 427
 428 =cut
 429
 430 */
 431
 432 PARROT_WARN_UNUSED_RESULT
 433 PARROT_CAN_RETURN_NULL
 434 Instruction *
 435 delete_ins(ARGMOD(struct _IMC_Unit *unit), ARGMOD(Instruction *ins))
 436 {
 437     Instruction * next = _delete_ins(unit, ins);
 438
 439     free_ins(ins);
 440
 441     return next;
 442 }
 443
 444 /*
 445
 446 =item C<void insert_ins>
 447
 448 insert tmp after ins
 449
 450 =cut
 451
 452 */
 453
 454 void
 455 insert_ins(ARGMOD(struct _IMC_Unit *unit), ARGMOD_NULLOK(Instruction *ins),
 456         ARGMOD(Instruction *tmp))
 457 {
 458     if (!ins) {
 459         Instruction * const next = unit->instructions;
 460
 461         unit->instructions = tmp;
 462         tmp->next          = next;
 463
 464         if (next) {
 465             next->prev = tmp;
 466             tmp->line  = next->line;
 467         }
 468         else {
 469             unit->last_ins = tmp;
 470         }
 471     }
 472     else {
 473         Instruction * const next = ins->next;
 474
 475         ins->next = tmp;
 476         tmp->prev = ins;
 477         tmp->next = next;
 478
 479         if (next)
 480             next->prev = tmp;
 481         else
 482             unit->last_ins = tmp;
 483
 484         if (!tmp->line)
 485             tmp->line = ins->line;
 486     }
 487 }
 488
 489 /*
 490
 491 =item C<void prepend_ins>
 492
 493 insert tmp before ins
 494
 495 =cut
 496
 497 */
 498
 499 void
 500 prepend_ins(ARGMOD(struct _IMC_Unit *unit), ARGMOD_NULLOK(Instruction *ins),
 501         ARGMOD(Instruction *tmp))
 502 {
 503     if (!ins) {
 504         Instruction * const next = unit->instructions;
 505
 506         unit->instructions = tmp;
 507         tmp->next          = next;
 508         next->prev         = tmp;
 509         tmp->line          = next->line;
 510     }
 511     else {
 512         Instruction * const prev = ins->prev;
 513
 514         ins->prev = tmp;
 515         tmp->next = ins;
 516         tmp->prev = prev;
 517
 518         if (prev)
 519             prev->next = tmp;
 520
 521         if (!tmp->line)
 522             tmp->line = ins->line;
 523     }
 524 }
 525
 526 /*
 527
 528 =item C<void subst_ins>
 529
 530 Substitute tmp for ins. Free ins if needs_freeing is true.
 531
 532 =cut
 533
 534 */
 535
 536 void
 537 subst_ins(ARGMOD(struct _IMC_Unit *unit), ARGMOD(Instruction *ins),
 538           ARGMOD(Instruction *tmp), int needs_freeing)
 539 {
 540     Instruction * const prev = ins->prev;
 541
 542     if (prev)
 543         prev->next = tmp;
 544     else
 545         unit->instructions = tmp;
 546
 547     tmp->prev = prev;
 548     tmp->next = ins->next;
 549
 550     if (ins->next)
 551         ins->next->prev = tmp;
 552     else
 553         unit->last_ins = tmp;
 554
 555     if (tmp->line == 0)
 556         tmp->line = ins->line;
 557
 558     if (needs_freeing)
 559         free_ins(ins);
 560 }
 561
 562 /*
 563
 564 =item C<Instruction * move_ins>
 565
 566 Move instruction ins from its current position to the position
 567 following instruction to. Returns the instruction following the
 568 initial position of ins.
 569
 570 =cut
 571
 572 */
 573
 574 PARROT_CAN_RETURN_NULL
 575 Instruction *
 576 move_ins(ARGMOD(struct _IMC_Unit *unit), ARGMOD(Instruction *ins), ARGMOD(Instruction *to))
 577 {
 578     Instruction * const next = _delete_ins(unit, ins);
 579     insert_ins(unit, to, ins);
 580     return next;
 581 }
 582
 583
 584 /*
 585
 586 =item C<Instruction * emitb>
 587
 588 Emit a single instruction into the current unit buffer.
 589
 590 =cut
 591
 592 */
 593
 594 PARROT_CAN_RETURN_NULL
 595 Instruction *
 596 emitb(PARROT_INTERP, ARGMOD_NULLOK(struct _IMC_Unit *unit), ARGIN_NULLOK(Instruction *i))
 597 {
 598
 599     if (!unit || !i)
 600         return NULL;
 601
 602     if (!unit->instructions)
 603         unit->last_ins = unit->instructions = i;
 604     else {
 605         unit->last_ins->next = i;
 606         i->prev              = unit->last_ins;
 607         unit->last_ins       = i;
 608     }
 609
 610     /* lexer is in next line already */
 611     i->line = IMCC_INFO(interp)->line - 1;
 612
 613     return i;
 614 }
 615
 616 /*
 617
 618 =item C<void free_ins>
 619
 620 Free the Instruction structure ins.
 621
 622 =cut
 623
 624 */
 625
 626 void
 627 free_ins(ARGMOD(Instruction *ins))
 628 {
 629     free(ins->format);
 630     free(ins->opname);
 631     free(ins);
 632 }
 633
 634 /*
 635
 636 =item C<int ins_print>
 637
 638 Print details of instruction ins in file fd.
 639
 640 =cut
 641
 642 */
 643
 644 #define REGB_SIZE 256
 645 int
 646 ins_print(PARROT_INTERP, ARGMOD(FILE *fd), ARGIN(const Instruction *ins))
 647 {
 648     char regb[IMCC_MAX_FIX_REGS][REGB_SIZE];
 649     /* only long key constants can overflow */
 650     char *regstr[IMCC_MAX_FIX_REGS];
 651     int i;
 652     int len;
 653
 654 #if IMC_TRACE
 655     PIO_eprintf(NULL, "ins_print\n");
 656 #endif
 657
 658     /* comments, labels and such */
 659     if (!ins->symregs[0] || !strchr(ins->format, '%'))
 660         return fprintf(fd, "%s", ins->format);
 661
 662     for (i = 0; i < ins->symreg_count; i++) {
 663         const SymReg *p = ins->symregs[i];
 664         if (!p)
 665             continue;
 666
 667         if (p->type & VT_CONSTP)
 668             p = p->reg;
 669
 670         if (p->color >= 0 && REG_NEEDS_ALLOC(p)) {
 671             snprintf(regb[i], REGB_SIZE, "%c%d", p->set, (int)p->color);
 672             regstr[i] = regb[i];
 673         }
 674         else if (IMCC_INFO(interp)->allocated
 675              && (IMCC_INFO(interp)->optimizer_level & OPT_J)
 676              &&  p->set != 'K'
 677              &&  p->color < 0
 678              && REG_NEEDS_ALLOC(p)) {
 679                     snprintf(regb[i], REGB_SIZE,
 680                         "r%c%d", tolower((unsigned char)p->set),
 681                         -1 -(int)p->color);
 682                     regstr[i] = regb[i];
 683         }
 684         else if (p->type & VTREGKEY) {
 685             const SymReg *k = p;
 686
 687             *regb[i] = '\0';
 688
 689             while ((k = k->nextkey) != NULL) {
 690                 const size_t used = strlen(regb[i]);
 691
 692                 if (k->reg && k->reg->color >= 0)
 693                     snprintf(regb[i]+used, REGB_SIZE - used, "%c%d",
 694                             k->reg->set, (int)k->reg->color);
 695                 else if (IMCC_INFO(interp)->allocated
 696                      && (IMCC_INFO(interp)->optimizer_level & OPT_J)
 697                      && k->reg
 698                      && k->reg->color < 0)
 699                         snprintf(regb[i]+used, REGB_SIZE - used, "r%c%d",
 700                             tolower((unsigned char)k->reg->set),
 701                             -1 -(int)k->reg->color);
 702                 else
 703                     strncat(regb[i], k->name, REGB_SIZE - used - 1);
 704
 705                 if (k->nextkey)
 706                     strncat(regb[i], ";", REGB_SIZE - strlen(regb[i]) - 1);
 707             }
 708
 709             regstr[i] = regb[i];
 710         }
 711         else if (p->type == VTCONST
 712              &&  p->set  == 'S'
 713              && *p->name != '"'
 714              && *p->name != '\'') {
 715             /* unquoted string const */
 716             snprintf(regb[i], REGB_SIZE, "\"%s\"", p->name);
 717             regstr[i] = regb[i];
 718         }
 719         else
 720             regstr[i] = p->name;
 721     }
 722
 723     switch (ins->opsize-1) {
 724         case -1:        /* labels */
 725         case 1:
 726             len = fprintf(fd, ins->format, regstr[0]);
 727             break;
 728         case 2:
 729             len = fprintf(fd, ins->format, regstr[0], regstr[1]);
 730             break;
 731         case 3:
 732             len = fprintf(fd, ins->format, regstr[0], regstr[1], regstr[2]);
 733             break;
 734         case 4:
 735             len = fprintf(fd, ins->format, regstr[0], regstr[1], regstr[2],
 736                     regstr[3]);
 737             break;
 738         case 5:
 739             len = fprintf(fd, ins->format, regstr[0], regstr[1], regstr[2],
 740                     regstr[3], regstr[4]);
 741             break;
 742         case 6:
 743             len = fprintf(fd, ins->format, regstr[0], regstr[1], regstr[2],
 744                     regstr[3], regstr[4], regstr[5]);
 745             break;
 746         default:
 747             fprintf(stderr, "unhandled: opsize (%d), op %s, fmt %s\n",
 748                     ins->opsize, ins->opname, ins->format);
 749             exit(EXIT_FAILURE);
 750             break;
 751     }
 752
 753     return len;
 754 }
 755
 756 /* for debug */
 757 static char *output;
 758
 759 /*
 760
 761 =item C<static int e_file_open>
 762
 763 RT#48260: Not yet documented!!!
 764
 765 =cut
 766
 767 */
 768
 769 static int
 770 e_file_open(SHIM_INTERP, ARGIN(void *param))
 771 {
 772     char * const file = (char *) param;
 773
 774     if (!STREQ(file, "-"))
 775         freopen(file, "w", stdout);
 776     output = file;
 777     printf("# IMCC does produce b0rken PASM files\n");
 778     printf("# see http://guest@rt.perl.org/rt3/Ticket/Display.html?id=32392\n");
 779     return 1;
 780 }
 781
 782 /*
 783
 784 =item C<static int e_file_close>
 785
 786 RT#48260: Not yet documented!!!
 787
 788 =cut
 789
 790 */
 791
 792 static int
 793 e_file_close(PARROT_INTERP, SHIM(void *param))
 794 {
 795     printf("\n\n");
 796     fclose(stdout);
 797     IMCC_info(interp, 1, "assembly module %s written.\n", output);
 798     return 0;
 799 }
 800
 801 /*
 802
 803 =item C<static int e_file_emit>
 804
 805 RT#48260: Not yet documented!!!
 806
 807 =cut
 808
 809 */
 810
 811 static int
 812 e_file_emit(PARROT_INTERP,
 813         SHIM(void *param),
 814         SHIM(const IMC_Unit *unit),
 815         ARGIN(const Instruction *ins))
 816 {
 817 #if IMC_TRACE
 818     PIO_eprintf(NULL, "e_file_emit\n");
 819 #endif
 820     if ((ins->type & ITLABEL) || ! *ins->opname)
 821         ins_print(interp, stdout, ins);
 822     else {
 823         imcc_fprintf(interp, stdout, "\t%I ", ins);
 824     }
 825     printf("\n");
 826     return 0;
 827 }
 828
 829 /*
 830
 831 =item C<int emit_open>
 832
 833 RT#48260: Not yet documented!!!
 834
 835 =cut
 836
 837 */
 838
 839 PARROT_API
 840 int
 841 emit_open(PARROT_INTERP, int type, ARGIN_NULLOK(void *param))
 842 {
 843     emitter                          = type;
 844     IMCC_INFO(interp)->has_compile   = 0;
 845     IMCC_INFO(interp)->dont_optimize = 0;
 846
 847     return (emitters[emitter]).open(interp, param);
 848 }
 849
 850 /*
 851
 852 =item C<int emit_flush>
 853
 854 RT#48260: Not yet documented!!!
 855
 856 =cut
 857
 858 */
 859
 860 PARROT_API
 861 int
 862 emit_flush(PARROT_INTERP, ARGIN_NULLOK(void *param), ARGIN(struct _IMC_Unit *unit))
 863 {
 864     Instruction * ins;
 865
 866     if (emitters[emitter].new_sub)
 867         (emitters[emitter]).new_sub(interp, param, unit);
 868
 869     for (ins = unit->instructions; ins; ins = ins->next) {
 870         IMCC_debug(interp, DEBUG_IMC, "emit %I\n", ins);
 871         (emitters[emitter]).emit(interp, param, unit, ins);
 872     }
 873
 874     if (emitters[emitter].end_sub)
 875         (emitters[emitter]).end_sub(interp, param, unit);
 876
 877     return 0;
 878 }
 879
 880 /*
 881
 882 =item C<int emit_close>
 883
 884 RT#48260: Not yet documented!!!
 885
 886 =cut
 887
 888 */
 889
 890 PARROT_API
 891 int
 892 emit_close(PARROT_INTERP, ARGIN_NULLOK(void *param))
 893 {
 894     return (emitters[emitter]).close(interp, param);
 895 }
 896
 897 /*
 898
 899 =back
 900
 901 =cut
 902
 903 */
 904
 905 /*
 906  * Local variables:
 907  *   c-file-style: "parrot"
 908  * End:
 909  * vim: expandtab shiftwidth=4:
 910  */