develooper Front page | perl.cvs.parrot | Postings from December 2008

[svn:parrot] r34568 - trunk/compilers/pirc/new

From:
kjs
Date:
December 29, 2008 05:18
Subject:
[svn:parrot] r34568 - trunk/compilers/pirc/new
Message ID:
20081229131807.33C97CB9FA@x12.develooper.com
Author: kjs
Date: Mon Dec 29 05:18:05 2008
New Revision: 34568

Modified:
   trunk/compilers/pirc/new/bcgen.c
   trunk/compilers/pirc/new/bcgen.h
   trunk/compilers/pirc/new/pir.y
   trunk/compilers/pirc/new/pircompunit.c
   trunk/compilers/pirc/new/pircompunit.h
   trunk/compilers/pirc/new/pirparser.c
   trunk/compilers/pirc/new/pirsymbol.c

Log:
[pirc] work on lexical registering.

Modified: trunk/compilers/pirc/new/bcgen.c
==============================================================================
--- trunk/compilers/pirc/new/bcgen.c	(original)
+++ trunk/compilers/pirc/new/bcgen.c	Mon Dec 29 05:18:05 2008
@@ -9,6 +9,7 @@
 
 #include "bcgen.h" /* XXX future maybe parrot/bcgen.h */
 
+#include "pirsymbol.h" /* XXX remove this dependency somehow. */
 
 /*
 
@@ -61,7 +62,7 @@
 };
 
 
-static int new_const(bytecode * const bc);
+static int new_pbc_const(bytecode * const bc);
 
 
 /*
@@ -78,7 +79,7 @@
 /*
 
 =item C<static int
-new_const(bytecode * const bc)>
+new_pbc_const(bytecode * const bc)>
 
 Add a new constant to the constant table.
 
@@ -89,16 +90,16 @@
 
 */
 static int
-new_const(bytecode * const bc) {
+new_pbc_const(bytecode * const bc) {
     Interp *interp = bc->interp;
     size_t oldcount;
     size_t newcount;
-    PackFile_Constant *new_constant;
+    PackFile_Constant *new_pbc_constant;
 
     oldcount = interp->code->const_table->const_count;
     newcount = oldcount + 1;
 
-    new_constant = PackFile_Constant_new(interp);
+    new_pbc_constant = PackFile_Constant_new(interp);
 
     /* Update the constant count and reallocate */
     if (interp->code->const_table->constants)
@@ -109,7 +110,7 @@
         interp->code->const_table->constants =
             mem_allocate_n_typed(newcount, PackFile_Constant *);
 
-    interp->code->const_table->constants[oldcount] = new_constant;
+    interp->code->const_table->constants[oldcount] = new_pbc_constant;
     interp->code->const_table->const_count         = newcount;
 
     return oldcount;
@@ -129,7 +130,7 @@
 */
 int
 add_pmc_const(bytecode * const bc, PMC * pmc) {
-    int index                   = new_const(bc);
+    int index                   = new_pbc_const(bc);
     PackFile_Constant *constant = bc->interp->code->const_table->constants[index];
     constant->type              = PFC_PMC;
     constant->u.key             = pmc;
@@ -152,7 +153,7 @@
 */
 int
 add_string_const(bytecode * const bc, char const * const str) {
-    int                index    = new_const(bc);
+    int                index    = new_pbc_const(bc);
     PackFile_Constant *constant = bc->interp->code->const_table->constants[index];
 
     constant->type     = PFC_STRING;
@@ -176,7 +177,7 @@
 */
 int
 add_num_const(bytecode * const bc, double f) {
-    int index                   = new_const(bc);
+    int index                   = new_pbc_const(bc);
     PackFile_Constant *constant = bc->interp->code->const_table->constants[index];
     constant->type              = PFC_NUMBER;
     constant->u.number          = f;
@@ -195,7 +196,7 @@
 */
 int
 add_key_const(bytecode * const bc, PMC *key) {
-    int index                   = new_const(bc);
+    int index                   = new_pbc_const(bc);
     PackFile_Constant *constant = bc->interp->code->const_table->constants[index];
     constant->type              = PFC_KEY;
     constant->u.key             = key;
@@ -418,11 +419,15 @@
 */
 static PMC *
 generate_multi_signature(bytecode * const bc, multi_type * const types, unsigned type_count) {
-    unsigned    i;
-    multi_type *iter;
+    unsigned     i;
+    multi_type * iter;
+    PMC        * multi_signature;
+
+    if (type_count == 0)
+        return NULL;
 
     /* create a FixedPMCArray to store all multi types */
-    PMC * const multi_signature = pmc_new(bc->interp, enum_class_FixedPMCArray);
+    multi_signature = pmc_new(bc->interp, enum_class_FixedPMCArray);
     /* set its size as specified in type_count */
     VTABLE_set_integer_native(bc->interp, multi_signature, type_count);
 
@@ -445,7 +450,7 @@
 
     /* add all multi types to the PMC array */
     for (i = 0; i < type_count; ++i) {
-        PMC *sig_pmc;
+        PMC *sig_pmc = NULL;
 
         switch (iter->entry_type) {
             case MULTI_TYPE_IDENT: {
@@ -459,6 +464,7 @@
             }
             case MULTI_TYPE_KEYED:
                 /* XXX implement this */
+
                 break;
             default:
                 fprintf(stderr, "invalid multi entry type");
@@ -486,24 +492,28 @@
 
 */
 static PMC *
-create_lexinfo(bytecode * const bc, PMC * sub, int lexflag) {
+create_lexinfo(bytecode * const bc, PMC * sub, lexical * const lexicals, int lexflag) {
+    lexical *lexiter;
 
-    STRING *lex_name;
-    int outer; /* change type of this */
+    int      outer = 0; /* change type of this */
 
-    const INTVAL lex_info_id = Parrot_get_ctx_HLL_type(bc->interp, enum_class_LexInfo);
 
-    PMC * lex_info = pmc_new_noinit(bc->interp, lex_info_id);
+    INTVAL const lex_info_id      = Parrot_get_ctx_HLL_type(bc->interp, enum_class_LexInfo);
 
-    STRING * const declare_method = string_from_literal(bc->interp, "declare_lex_preg");
+    STRING * const method         = string_from_literal(bc->interp, "declare_lex_preg");
 
+    PMC * lex_info                = pmc_new_noinit(bc->interp, lex_info_id);
     VTABLE_init_pmc(bc->interp, lex_info, sub);
 
-/* for ... { */
-    Parrot_PCCINVOKE(bc->interp, lex_info, declare_method, "SI->", lex_name, 0 /* color */);
+    lexiter = lexicals;
+    while (lexiter) {
+        STRING *lexname = string_from_cstring(bc->interp, lexiter->name, strlen(lexiter->name));
 
+        /* declare the .lex as such */
+        Parrot_PCCINVOKE(bc->interp, lex_info, method, "SI->", lexname, lexiter->info->color);
 
-/* ... } */
+        lexiter = lexiter->next;
+    }
 
     /* if lex_info is still NULL, that means that the sub has no .lexicals,
      * and doesn't need a lex_info. If the sub has an :outer or a :lex flag,
@@ -522,7 +532,7 @@
 /*
 
 =item C<void
-add_sub_pmc(bytecode * const bc, sub_info * const info)>
+add_sub_pmc(bytecode * const bc, sub_info * const info, int needlex)>
 
 Add a sub PMC to the constant table. This function initializes the sub PMC.
 The index where the PMC is stored in the constant table is returned.
@@ -531,7 +541,7 @@
 
 */
 int
-add_sub_pmc(bytecode * const bc, sub_info * const info) {
+add_sub_pmc(bytecode * const bc, sub_info * const info, int needlex) {
     PMC               *sub_pmc;
     Parrot_sub        *sub;
     int                subconst_index;
@@ -560,8 +570,7 @@
     /* XXX does this work properly? is "current_HLL" really "current"? */
     sub->HLL_id           = CONTEXT(bc->interp)->current_HLL;
 
-    /* XXX fix lex stuff */
-    sub->lex_info         = NULL;
+    sub->lex_info         = create_lexinfo(bc, sub_pmc, info->lexicals, needlex);
 
     /* XXX fix outer stuff */
     sub->outer_sub        = NULL;
@@ -571,7 +580,6 @@
      */
     sub->vtable_index     = info->vtable_index;
 
-    /* XXX fix multi stuff */
     sub->multi_signature  = generate_multi_signature(bc, info->multi_types, info->num_multi_types);
 
     /* store register usage of this sub. */

Modified: trunk/compilers/pirc/new/bcgen.h
==============================================================================
--- trunk/compilers/pirc/new/bcgen.h	(original)
+++ trunk/compilers/pirc/new/bcgen.h	Mon Dec 29 05:18:05 2008
@@ -41,6 +41,12 @@
 } multi_type;
 
 
+typedef struct lexical {
+    char const     * name;
+    struct syminfo * info;
+    struct lexical * next;
+
+} lexical;
 
 
 /* sub info structure, containing all info about a sub that a bytecode
@@ -56,6 +62,7 @@
     int                  endoffset;
     unsigned             num_multi_types;
     multi_type         * multi_types;   /* data types of parameters if this is a multi sub */
+    lexical            * lexicals;
 
 } sub_info;
 
@@ -106,7 +113,7 @@
 */
 
 
-int add_sub_pmc(bytecode * const bc, sub_info * const info);
+int add_sub_pmc(bytecode * const bc, sub_info * const info, int needlex);
 
 
 #endif /* PARROT_BCGEN_H_GUARD */

Modified: trunk/compilers/pirc/new/pir.y
==============================================================================
--- trunk/compilers/pirc/new/pir.y	(original)
+++ trunk/compilers/pirc/new/pir.y	Mon Dec 29 05:18:05 2008
@@ -1615,7 +1615,7 @@
                                   yypirerror(yyscanner, lexer, "lexical '%s' must be of type 'pmc'",
                                              $4->info->id.name);
                           }
-                          set_lex_flag($4, $2);
+                          set_lex_flag(lexer, $4, $2);
                         }
                   ;
 

Modified: trunk/compilers/pirc/new/pircompunit.c
==============================================================================
--- trunk/compilers/pirc/new/pircompunit.c	(original)
+++ trunk/compilers/pirc/new/pircompunit.c	Mon Dec 29 05:18:05 2008
@@ -332,6 +332,8 @@
     newsub->flags            = 0;
     newsub->info.startoffset = lexer->codesize; /* start offset in bytecode */
 
+
+
     /* initialize hashtables for .local and label identifiers */
     init_hashtable(lexer, &newsub->symbols, HASHTABLE_SIZE_INIT);
     init_hashtable(lexer, &newsub->labels, HASHTABLE_SIZE_INIT);
@@ -1685,15 +1687,24 @@
 /*
 
 =item C<void
-set_lex_flag(target * const t, char const * const name)>
+set_lex_flag(lexer_state * const lexer, target * const t, char const * const name)>
 
-Set the lexical name C<name> on target C<t>.
+Set the lexical name C<name> on target C<t>, and store it
+as a lexical in the sub_info struct.
 
 =cut
 
 */
 void
-set_lex_flag(target * const t, char const * const name) {
+set_lex_flag(lexer_state * const lexer, target * const t, char const * const name) {
+    lexical *lex = (lexical *)pir_mem_allocate(lexer, sizeof (lexical));
+    lex->name    = name;
+    lex->info    = t->info;
+
+    /* link this lex node in the list of lexicals */
+    lex->next = CURRENT_SUB(lexer)->info.lexicals;
+    CURRENT_SUB(lexer)->info.lexicals = lex;
+
     t->lex_name = name;
 }
 
@@ -2809,7 +2820,8 @@
         linear_scan_register_allocation(lexer->lsr);
 
     /* store the subroutine in the bytecode constant table. */
-    sub_const_table_index = add_sub_pmc(lexer->bc, &CURRENT_SUB(lexer)->info);
+    sub_const_table_index = add_sub_pmc(lexer->bc, &CURRENT_SUB(lexer)->info,
+                                        TEST_FLAG(CURRENT_SUB(lexer)->flags, SUB_FLAG_LEX));
 
     /* store the sub PMC index in the constant table with the global label,
      * so that invoking ops can find this index.

Modified: trunk/compilers/pirc/new/pircompunit.h
==============================================================================
--- trunk/compilers/pirc/new/pircompunit.h	(original)
+++ trunk/compilers/pirc/new/pircompunit.h	Mon Dec 29 05:18:05 2008
@@ -293,6 +293,7 @@
 
 } hashtable;
 
+
 /* forward declaration of structs */
 struct symbol;
 struct label;
@@ -424,7 +425,7 @@
 void remove_all_operands(struct lexer_state * const lexer);
 
 
-void set_lex_flag(target * const t, char const * const lexname);
+void set_lex_flag(struct lexer_state * const lexer, target * const t, char const * const lexname);
 char const *get_inverse(char const * const instr);
 void invert_instr(struct lexer_state * const lexer);
 

Modified: trunk/compilers/pirc/new/pirparser.c
==============================================================================
--- trunk/compilers/pirc/new/pirparser.c	(original)
+++ trunk/compilers/pirc/new/pirparser.c	Mon Dec 29 05:18:05 2008
@@ -1056,42 +1056,42 @@
      653,   658,   662,   666,   671,   672,   676,   678,   682,   686,
      692,   696,   700,   701,   704,   705,   708,   710,   712,   714,
      716,   718,   720,   722,   724,   726,   728,   730,   732,   734,
-     738,   743,   747,   751,   760,   768,   770,   772,   776,   785,
-     786,   790,   794,   799,   800,   804,   805,   806,   809,   816,
-     822,   823,   833,   835,   838,   839,   840,   841,   842,   843,
-     844,   845,   846,   847,   848,   849,   850,   851,   852,   858,
-     861,   866,   867,   872,   873,   876,   878,   886,   894,   895,
-     897,   900,   906,   907,   916,   917,   918,   919,   927,   931,
-     935,   944,   951,   958,   961,   962,   965,   974,   981,   984,
-     985,   988,   989,   992,  1028,  1030,  1037,  1039,  1044,  1046,
-    1050,  1073,  1077,  1079,  1088,  1099,  1111,  1121,  1124,  1125,
-    1128,  1137,  1146,  1151,  1156,  1177,  1182,  1223,  1241,  1248,
-    1253,  1264,  1275,  1286,  1297,  1302,  1307,  1312,  1322,  1341,
-    1375,  1377,  1379,  1381,  1383,  1385,  1387,  1389,  1394,  1403,
-    1405,  1407,  1409,  1411,  1413,  1415,  1417,  1419,  1421,  1433,
-    1438,  1440,  1442,  1444,  1446,  1448,  1450,  1452,  1454,  1456,
-    1458,  1460,  1462,  1493,  1519,  1527,  1536,  1545,  1547,  1549,
-    1551,  1553,  1557,  1562,  1564,  1569,  1570,  1573,  1574,  1577,
-    1578,  1581,  1589,  1593,  1595,  1599,  1603,  1604,  1607,  1622,
-    1626,  1627,  1630,  1642,  1643,  1647,  1649,  1653,  1657,  1659,
-    1661,  1667,  1668,  1673,  1674,  1678,  1680,  1689,  1691,  1695,
-    1699,  1701,  1703,  1707,  1708,  1711,  1731,  1738,  1740,  1750,
-    1767,  1769,  1771,  1775,  1784,  1789,  1794,  1795,  1799,  1801,
-    1805,  1810,  1811,  1815,  1817,  1819,  1821,  1831,  1835,  1836,
-    1837,  1838,  1841,  1846,  1857,  1864,  1869,  1870,  1874,  1876,
-    1880,  1881,  1884,  1888,  1892,  1896,  1905,  1915,  1916,  1921,
-    1923,  1928,  1933,  1934,  1938,  1940,  1944,  1950,  1951,  1955,
-    1957,  1965,  1966,  1970,  1974,  1977,  1978,  1981,  1985,  1989,
-    1991,  1993,  1995,  2003,  2004,  2008,  2009,  2010,  2011,  2014,
-    2015,  2016,  2017,  2018,  2019,  2022,  2023,  2024,  2025,  2033,
-    2036,  2037,  2048,  2049,  2050,  2051,  2055,  2056,  2059,  2060,
-    2061,  2062,  2063,  2064,  2065,  2066,  2069,  2070,  2071,  2074,
-    2075,  2076,  2077,  2078,  2079,  2080,  2081,  2082,  2083,  2084,
-    2085,  2086,  2087,  2088,  2089,  2090,  2091,  2092,  2093,  2094,
-    2095,  2096,  2102,  2103,  2104,  2105,  2106,  2107,  2108,  2109,
-    2110,  2111,  2112,  2113,  2125,  2133,  2137,  2138,  2141,  2142,
-    2143,  2144,  2145,  2146,  2149,  2151,  2152,  2155,  2156,  2159,
-    2163,  2168
+     738,   743,   747,   751,   760,   771,   773,   775,   779,   788,
+     789,   793,   797,   802,   803,   807,   808,   809,   812,   819,
+     825,   826,   836,   838,   841,   842,   843,   844,   845,   846,
+     847,   848,   849,   850,   851,   852,   853,   854,   855,   861,
+     864,   869,   870,   875,   876,   879,   881,   889,   897,   898,
+     900,   903,   909,   910,   919,   920,   921,   922,   930,   934,
+     938,   947,   954,   961,   964,   965,   968,   977,   984,   987,
+     988,   991,   992,   995,  1031,  1033,  1040,  1042,  1047,  1049,
+    1053,  1076,  1080,  1082,  1091,  1102,  1114,  1124,  1127,  1128,
+    1131,  1140,  1149,  1154,  1159,  1180,  1185,  1226,  1244,  1251,
+    1256,  1267,  1278,  1289,  1300,  1305,  1310,  1315,  1325,  1344,
+    1378,  1380,  1382,  1384,  1386,  1388,  1390,  1392,  1397,  1406,
+    1408,  1410,  1412,  1414,  1416,  1418,  1420,  1422,  1424,  1436,
+    1441,  1443,  1445,  1447,  1449,  1451,  1453,  1455,  1457,  1459,
+    1461,  1463,  1465,  1496,  1522,  1530,  1539,  1548,  1550,  1552,
+    1554,  1556,  1560,  1565,  1567,  1572,  1573,  1576,  1577,  1580,
+    1581,  1584,  1592,  1596,  1598,  1602,  1606,  1607,  1610,  1625,
+    1629,  1630,  1633,  1645,  1646,  1650,  1652,  1656,  1660,  1662,
+    1664,  1670,  1671,  1676,  1677,  1681,  1683,  1692,  1694,  1698,
+    1702,  1704,  1706,  1710,  1711,  1714,  1734,  1741,  1743,  1753,
+    1770,  1772,  1774,  1778,  1787,  1792,  1797,  1798,  1802,  1804,
+    1808,  1813,  1814,  1818,  1820,  1822,  1824,  1834,  1838,  1839,
+    1840,  1841,  1844,  1849,  1860,  1867,  1872,  1873,  1877,  1879,
+    1883,  1884,  1887,  1891,  1895,  1899,  1908,  1918,  1919,  1924,
+    1926,  1931,  1936,  1937,  1941,  1943,  1947,  1953,  1954,  1958,
+    1960,  1968,  1969,  1973,  1977,  1980,  1981,  1984,  1988,  1992,
+    1994,  1996,  1998,  2006,  2007,  2011,  2012,  2013,  2014,  2017,
+    2018,  2019,  2020,  2021,  2022,  2025,  2026,  2027,  2028,  2036,
+    2039,  2040,  2051,  2052,  2053,  2054,  2058,  2059,  2062,  2063,
+    2064,  2065,  2066,  2067,  2068,  2069,  2072,  2073,  2074,  2077,
+    2078,  2079,  2080,  2081,  2082,  2083,  2084,  2085,  2086,  2087,
+    2088,  2089,  2090,  2091,  2092,  2093,  2094,  2095,  2096,  2097,
+    2098,  2099,  2105,  2106,  2107,  2108,  2109,  2110,  2111,  2112,
+    2113,  2114,  2115,  2116,  2128,  2136,  2140,  2141,  2144,  2145,
+    2146,  2147,  2148,  2149,  2152,  2154,  2155,  2158,  2159,  2162,
+    2166,  2171
 };
 #endif
 
@@ -2815,28 +2815,31 @@
 #line 761 "pir.y"
     {
                           ++CURRENT_SUB(lexer)->info.num_multi_types;
+                          /* link the multi types in reverse other. That's fine,
+                           * as long as you remember that it's reversed.
+                           */
                           (yyvsp[(3) - (3)].expr)->next = (yyvsp[(1) - (3)].expr);
                           (yyval.expr) = (yyvsp[(3) - (3)].expr);
                         ;}
     break;
 
   case 75:
-#line 769 "pir.y"
+#line 772 "pir.y"
     { (yyval.expr) = expr_from_ident(lexer, (yyvsp[(1) - (1)].sval)); ;}
     break;
 
   case 76:
-#line 771 "pir.y"
+#line 774 "pir.y"
     { (yyval.expr) = expr_from_string(lexer, (yyvsp[(1) - (1)].sval)); ;}
     break;
 
   case 77:
-#line 773 "pir.y"
+#line 776 "pir.y"
     { (yyval.expr) = expr_from_key(lexer, (yyvsp[(1) - (1)].key)); ;}
     break;
 
   case 78:
-#line 777 "pir.y"
+#line 780 "pir.y"
     {
                            /* if there are parameters, then emit a get_params instruction. */
                            if ((yyvsp[(1) - (1)].uval) > 0)
@@ -2845,37 +2848,37 @@
     break;
 
   case 79:
-#line 785 "pir.y"
+#line 788 "pir.y"
     { (yyval.uval) = 0; ;}
     break;
 
   case 80:
-#line 787 "pir.y"
+#line 790 "pir.y"
     { ++(yyval.uval); /* count number of parameters */ ;}
     break;
 
   case 81:
-#line 791 "pir.y"
+#line 794 "pir.y"
     { set_param_flag(lexer, (yyvsp[(2) - (4)].targ), (yyvsp[(3) - (4)].ival)); ;}
     break;
 
   case 82:
-#line 795 "pir.y"
+#line 798 "pir.y"
     { (yyval.targ) = add_param(lexer, (yyvsp[(1) - (2)].ival), (yyvsp[(2) - (2)].sval)); ;}
     break;
 
   case 83:
-#line 799 "pir.y"
+#line 802 "pir.y"
     { (yyval.ival) = 0; ;}
     break;
 
   case 84:
-#line 801 "pir.y"
+#line 804 "pir.y"
     { SET_FLAG((yyval.ival), (yyvsp[(2) - (2)].ival)); ;}
     break;
 
   case 88:
-#line 810 "pir.y"
+#line 813 "pir.y"
     { (yyval.ival) = TARGET_FLAG_INVOCANT;
                            /* XXX handle multi_type */
 
@@ -2883,12 +2886,12 @@
     break;
 
   case 89:
-#line 817 "pir.y"
+#line 820 "pir.y"
     { (yyval.ival) = TARGET_FLAG_UNIQUE_REG; ;}
     break;
 
   case 91:
-#line 824 "pir.y"
+#line 827 "pir.y"
     {
                          ++lexer->stmt_counter;
                          /* increment the logical statement counter; a statement can be
@@ -2899,37 +2902,37 @@
     break;
 
   case 92:
-#line 834 "pir.y"
+#line 837 "pir.y"
     { set_label(lexer, (yyvsp[(1) - (2)].sval)); ;}
     break;
 
   case 110:
-#line 862 "pir.y"
+#line 865 "pir.y"
     { (yyval.sval) = expand_macro(yyscanner, (yyvsp[(1) - (3)].mval), (yyvsp[(2) - (3)].pval)); ;}
     break;
 
   case 111:
-#line 866 "pir.y"
+#line 869 "pir.y"
     { (yyval.pval) = NULL; ;}
     break;
 
   case 112:
-#line 868 "pir.y"
+#line 871 "pir.y"
     { (yyval.pval) = (yyvsp[(2) - (3)].pval); ;}
     break;
 
   case 113:
-#line 872 "pir.y"
+#line 875 "pir.y"
     { (yyval.pval) = NULL; ;}
     break;
 
   case 115:
-#line 877 "pir.y"
+#line 880 "pir.y"
     { (yyval.pval) = new_macro_param((yyvsp[(1) - (1)].sval)); ;}
     break;
 
   case 116:
-#line 879 "pir.y"
+#line 882 "pir.y"
     {
                           macro_param *param = new_macro_param((yyvsp[(3) - (3)].sval));
                           param->next = (yyvsp[(1) - (3)].pval);
@@ -2938,7 +2941,7 @@
     break;
 
   case 117:
-#line 887 "pir.y"
+#line 890 "pir.y"
     {
                           symbol *sym = find_symbol(lexer, (yyvsp[(1) - (1)].sval));
                           if (sym == NULL) {
@@ -2949,22 +2952,22 @@
     break;
 
   case 119:
-#line 896 "pir.y"
+#line 899 "pir.y"
     { (yyval.sval) = expand_macro(yyscanner, (yyvsp[(1) - (2)].mval), (yyvsp[(2) - (2)].pval)); ;}
     break;
 
   case 121:
-#line 901 "pir.y"
+#line 904 "pir.y"
     { (yyval.sval) = (yyvsp[(2) - (3)].sval); ;}
     break;
 
   case 122:
-#line 906 "pir.y"
+#line 909 "pir.y"
     { (yyval.sval) = ""; ;}
     break;
 
   case 123:
-#line 908 "pir.y"
+#line 911 "pir.y"
     { /* XXX cleanup memory stuff */
                           char *newbuff = (char *)mem_sys_allocate((strlen((yyvsp[(1) - (2)].sval)) + strlen((yyvsp[(2) - (2)].sval)) + 2)
                                                                    * sizeof (char));
@@ -2974,17 +2977,17 @@
     break;
 
   case 127:
-#line 920 "pir.y"
+#line 923 "pir.y"
     { (yyval.sval) = expand_macro(yyscanner, (yyvsp[(1) - (2)].mval), (yyvsp[(2) - (2)].pval)); ;}
     break;
 
   case 128:
-#line 928 "pir.y"
+#line 931 "pir.y"
     { set_instr(lexer, NULL); ;}
     break;
 
   case 130:
-#line 936 "pir.y"
+#line 939 "pir.y"
     {
                            if (lexer->parse_errors > MAX_NUM_ERRORS)
                                panic(lexer, "Too many errors. Compilation aborted.\n");
@@ -2994,7 +2997,7 @@
     break;
 
   case 131:
-#line 945 "pir.y"
+#line 948 "pir.y"
     {
                            set_instrf(lexer, "null", "%T", (yyvsp[(2) - (3)].targ));
                            get_opinfo(yyscanner);
@@ -3002,7 +3005,7 @@
     break;
 
   case 132:
-#line 952 "pir.y"
+#line 955 "pir.y"
     {
                            set_instrf(lexer, "get_results", "%T", (yyvsp[(2) - (3)].targ));
                            get_opinfo(yyscanner);
@@ -3010,7 +3013,7 @@
     break;
 
   case 136:
-#line 966 "pir.y"
+#line 969 "pir.y"
     { /* at this point, TK_IDENT may in fact be a symbol identifier,
                             * not an op, so don't do any checks like is_parrot_op() just yet.
                             */
@@ -3020,7 +3023,7 @@
     break;
 
   case 137:
-#line 975 "pir.y"
+#line 978 "pir.y"
     { /* when this rule is activated, the initial identifier must
                            * be a parrot op.
                            */
@@ -3030,7 +3033,7 @@
     break;
 
   case 143:
-#line 993 "pir.y"
+#line 996 "pir.y"
     {
                          /* the "instruction" that was set now appears to be
                           * an identifier; get the name, and check its type.
@@ -3067,22 +3070,22 @@
     break;
 
   case 144:
-#line 1029 "pir.y"
+#line 1032 "pir.y"
     { push_operand(lexer, (yyvsp[(1) - (1)].expr)); ;}
     break;
 
   case 145:
-#line 1034 "pir.y"
+#line 1037 "pir.y"
     { push_operand(lexer, expr_from_key(lexer, (yyvsp[(1) - (1)].key))); ;}
     break;
 
   case 146:
-#line 1038 "pir.y"
+#line 1041 "pir.y"
     { (yyval.expr) = expr_from_const(lexer, (yyvsp[(1) - (1)].cval)); ;}
     break;
 
   case 147:
-#line 1040 "pir.y"
+#line 1043 "pir.y"
     { /* this is either a LABEL or a symbol; in the latter case, the type
                             * will be filled in later. */
                            (yyval.expr) = expr_from_ident(lexer, (yyvsp[(1) - (1)].sval));
@@ -3090,17 +3093,17 @@
     break;
 
   case 148:
-#line 1045 "pir.y"
+#line 1048 "pir.y"
     { (yyval.expr) = expr_from_target(lexer, (yyvsp[(1) - (1)].targ)); ;}
     break;
 
   case 149:
-#line 1047 "pir.y"
+#line 1050 "pir.y"
     { (yyval.expr) = expr_from_target(lexer, (yyvsp[(1) - (1)].targ)); ;}
     break;
 
   case 150:
-#line 1051 "pir.y"
+#line 1054 "pir.y"
     {
                            /* if $1 is a register, just return that */
                            if (TEST_FLAG((yyvsp[(1) - (2)].targ)->flags, TARGET_FLAG_IS_REG))
@@ -3124,22 +3127,22 @@
     break;
 
   case 151:
-#line 1074 "pir.y"
+#line 1077 "pir.y"
     { (yyval.key) = (yyvsp[(2) - (3)].key); ;}
     break;
 
   case 152:
-#line 1078 "pir.y"
+#line 1081 "pir.y"
     { (yyval.key) = new_key(lexer, (yyvsp[(1) - (1)].expr)); ;}
     break;
 
   case 153:
-#line 1080 "pir.y"
+#line 1083 "pir.y"
     { (yyval.key) = add_key(lexer, (yyvsp[(1) - (3)].key), (yyvsp[(3) - (3)].expr)); ;}
     break;
 
   case 154:
-#line 1089 "pir.y"
+#line 1092 "pir.y"
     {
                           /* the instruction is already set in parrot_op rule */
                           unshift_operand(lexer, (yyvsp[(4) - (6)].expr));
@@ -3153,7 +3156,7 @@
     break;
 
   case 155:
-#line 1100 "pir.y"
+#line 1103 "pir.y"
     {
                           /* the instruction is already set in parrot_op rule */
                           unshift_operand(lexer, (yyvsp[(4) - (4)].expr));
@@ -3168,7 +3171,7 @@
     break;
 
   case 156:
-#line 1112 "pir.y"
+#line 1115 "pir.y"
     { /* XXX create a PMC const for $4 */
                           unshift_operand(lexer, expr_from_key(lexer, (yyvsp[(4) - (6)].key)));
                           unshift_operand(lexer, expr_from_target(lexer, (yyvsp[(1) - (6)].targ)));
@@ -3179,7 +3182,7 @@
     break;
 
   case 160:
-#line 1129 "pir.y"
+#line 1132 "pir.y"
     {
                           if ((yyvsp[(3) - (3)].ival) == 0)
                               set_instrf(lexer, "null", "%T", (yyvsp[(1) - (3)].targ));
@@ -3191,7 +3194,7 @@
     break;
 
   case 161:
-#line 1138 "pir.y"
+#line 1141 "pir.y"
     {
                           if ((yyvsp[(3) - (3)].dval) == 0.0)
                               set_instrf(lexer, "null", "%T", (yyvsp[(1) - (3)].targ));
@@ -3203,7 +3206,7 @@
     break;
 
   case 162:
-#line 1147 "pir.y"
+#line 1150 "pir.y"
     {
                           set_instrf(lexer, "set", "%T%s", (yyvsp[(1) - (3)].targ), (yyvsp[(3) - (3)].sval));
                           get_opinfo(yyscanner);
@@ -3211,7 +3214,7 @@
     break;
 
   case 163:
-#line 1152 "pir.y"
+#line 1155 "pir.y"
     {
                           set_instrf(lexer, "set", "%T%T", (yyvsp[(1) - (3)].targ), (yyvsp[(3) - (3)].targ));
                           get_opinfo(yyscanner);
@@ -3219,7 +3222,7 @@
     break;
 
   case 164:
-#line 1157 "pir.y"
+#line 1160 "pir.y"
     {
                           symbol *sym = find_symbol(lexer, (yyvsp[(3) - (3)].sval));
                           if (sym) {
@@ -3243,7 +3246,7 @@
     break;
 
   case 165:
-#line 1178 "pir.y"
+#line 1181 "pir.y"
     {
                           unshift_operand(lexer, expr_from_target(lexer, (yyvsp[(1) - (3)].targ)));
                           get_opinfo(yyscanner);
@@ -3251,7 +3254,7 @@
     break;
 
   case 166:
-#line 1183 "pir.y"
+#line 1186 "pir.y"
     {
                           /*   $P0 = foo ["bar"]
                            *
@@ -3295,7 +3298,7 @@
     break;
 
   case 167:
-#line 1224 "pir.y"
+#line 1227 "pir.y"
     {
                           symbol *sym = find_symbol(lexer, (yyvsp[(3) - (4)].sval));
                           target *t;
@@ -3316,7 +3319,7 @@
     break;
 
   case 168:
-#line 1242 "pir.y"
+#line 1245 "pir.y"
     {
                           target *preg = new_reg(lexer, PMC_TYPE, (yyvsp[(3) - (4)].ival));
                           set_target_key(preg, (yyvsp[(4) - (4)].key));
@@ -3326,7 +3329,7 @@
     break;
 
   case 169:
-#line 1249 "pir.y"
+#line 1252 "pir.y"
     {
                           set_instrf(lexer, opnames[(yyvsp[(2) - (3)].ival)], "%T%E", (yyvsp[(1) - (3)].targ), (yyvsp[(3) - (3)].expr));
                           get_opinfo(yyscanner);
@@ -3334,7 +3337,7 @@
     break;
 
   case 170:
-#line 1254 "pir.y"
+#line 1257 "pir.y"
     {
                           if ((yyvsp[(3) - (3)].ival) == 1)
                               set_instrf(lexer, "inc", "%T", (yyvsp[(1) - (3)].targ));
@@ -3348,7 +3351,7 @@
     break;
 
   case 171:
-#line 1265 "pir.y"
+#line 1268 "pir.y"
     {
                           if ((yyvsp[(3) - (3)].dval) == 1.0)
                               set_instrf(lexer, "inc", "%T", (yyvsp[(1) - (3)].targ));
@@ -3362,7 +3365,7 @@
     break;
 
   case 172:
-#line 1276 "pir.y"
+#line 1279 "pir.y"
     {
                           if ((yyvsp[(3) - (3)].ival) == 1)
                               set_instrf(lexer, "dec", "%T", (yyvsp[(1) - (3)].targ));
@@ -3376,7 +3379,7 @@
     break;
 
   case 173:
-#line 1287 "pir.y"
+#line 1290 "pir.y"
     {
                           if ((yyvsp[(3) - (3)].dval) == 1.0)
                               set_instrf(lexer, "dec", "%T", (yyvsp[(1) - (3)].targ));
@@ -3390,7 +3393,7 @@
     break;
 
   case 174:
-#line 1298 "pir.y"
+#line 1301 "pir.y"
     {
                           set_instrf(lexer, "add", "%T%T", (yyvsp[(1) - (3)].targ), (yyvsp[(3) - (3)].targ));
                           get_opinfo(yyscanner);
@@ -3398,7 +3401,7 @@
     break;
 
   case 175:
-#line 1303 "pir.y"
+#line 1306 "pir.y"
     {
                           set_instrf(lexer, "sub", "%T%T", (yyvsp[(1) - (3)].targ), (yyvsp[(3) - (3)].targ));
                           get_opinfo(yyscanner);
@@ -3406,7 +3409,7 @@
     break;
 
   case 176:
-#line 1308 "pir.y"
+#line 1311 "pir.y"
     {
                           set_instrf(lexer, (yyvsp[(3) - (4)].sval), "%T%E", (yyvsp[(1) - (4)].targ), (yyvsp[(4) - (4)].expr));
                           get_opinfo(yyscanner);
@@ -3414,7 +3417,7 @@
     break;
 
   case 177:
-#line 1313 "pir.y"
+#line 1316 "pir.y"
     {
                           if (targets_equal((yyvsp[(1) - (5)].targ), (yyvsp[(3) - (5)].targ))) /* $P0 = $P0 + $P1 ==> $P0 += $P1 */
                               set_instrf(lexer, opnames[(yyvsp[(4) - (5)].ival)], "%T%E", (yyvsp[(1) - (5)].targ), (yyvsp[(5) - (5)].expr));
@@ -3427,7 +3430,7 @@
     break;
 
   case 178:
-#line 1323 "pir.y"
+#line 1326 "pir.y"
     {
                           symbol *sym = find_symbol(lexer, (yyvsp[(1) - (4)].sval));
                           target *t;
@@ -3449,7 +3452,7 @@
     break;
 
   case 179:
-#line 1342 "pir.y"
+#line 1345 "pir.y"
     {
                           target *preg = new_reg(lexer, PMC_TYPE, (yyvsp[(1) - (4)].ival));
                           set_target_key(preg, (yyvsp[(2) - (4)].key));
@@ -3459,97 +3462,97 @@
     break;
 
   case 180:
-#line 1376 "pir.y"
+#line 1379 "pir.y"
     { set_instrf(lexer, opnames[(yyvsp[(2) - (3)].ival)], "%i%T", (yyvsp[(1) - (3)].ival), (yyvsp[(3) - (3)].targ)); ;}
     break;
 
   case 181:
-#line 1378 "pir.y"
+#line 1381 "pir.y"
     { set_instrf(lexer, opnames[(yyvsp[(2) - (3)].ival)], "%n%T", (yyvsp[(1) - (3)].dval), (yyvsp[(3) - (3)].targ)); ;}
     break;
 
   case 182:
-#line 1380 "pir.y"
+#line 1383 "pir.y"
     { set_instrf(lexer, opnames[(yyvsp[(2) - (3)].ival)], "%s%T", (yyvsp[(1) - (3)].sval), (yyvsp[(3) - (3)].targ)); ;}
     break;
 
   case 183:
-#line 1382 "pir.y"
+#line 1385 "pir.y"
     { set_instrf(lexer, "set", "%C", fold_s_s(yyscanner, (yyvsp[(1) - (3)].sval), (yyvsp[(2) - (3)].ival), (yyvsp[(3) - (3)].sval))); ;}
     break;
 
   case 184:
-#line 1384 "pir.y"
+#line 1387 "pir.y"
     { set_instrf(lexer, "set", "%C", fold_i_i(yyscanner, (yyvsp[(1) - (3)].ival), (yyvsp[(2) - (3)].ival), (yyvsp[(3) - (3)].ival))); ;}
     break;
 
   case 185:
-#line 1386 "pir.y"
+#line 1389 "pir.y"
     { set_instrf(lexer, "set", "%C", fold_n_n(yyscanner, (yyvsp[(1) - (3)].dval), (yyvsp[(2) - (3)].ival), (yyvsp[(3) - (3)].dval))); ;}
     break;
 
   case 186:
-#line 1388 "pir.y"
+#line 1391 "pir.y"
     { set_instrf(lexer, "set", "%C", fold_i_n(yyscanner, (yyvsp[(1) - (3)].ival), (yyvsp[(2) - (3)].ival), (yyvsp[(3) - (3)].dval))); ;}
     break;
 
   case 187:
-#line 1390 "pir.y"
+#line 1393 "pir.y"
     { set_instrf(lexer, "set", "%C", fold_n_i(yyscanner, (yyvsp[(1) - (3)].dval), (yyvsp[(2) - (3)].ival), (yyvsp[(3) - (3)].ival))); ;}
     break;
 
   case 188:
-#line 1395 "pir.y"
+#line 1398 "pir.y"
     { get_opinfo(yyscanner); ;}
     break;
 
   case 189:
-#line 1404 "pir.y"
+#line 1407 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (5)].ival), 1, (yyvsp[(3) - (5)].sval), (yyvsp[(5) - (5)].sval)); ;}
     break;
 
   case 190:
-#line 1406 "pir.y"
+#line 1409 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (5)].ival), 1, "int", (yyvsp[(5) - (5)].sval)); ;}
     break;
 
   case 191:
-#line 1408 "pir.y"
+#line 1411 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (5)].ival), 1, "num", (yyvsp[(5) - (5)].sval)); ;}
     break;
 
   case 192:
-#line 1410 "pir.y"
+#line 1413 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (5)].ival), 1, "pmc", (yyvsp[(5) - (5)].sval)); ;}
     break;
 
   case 193:
-#line 1412 "pir.y"
+#line 1415 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (5)].ival), 1, "string", (yyvsp[(5) - (5)].sval)); ;}
     break;
 
   case 194:
-#line 1414 "pir.y"
+#line 1417 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (5)].ival), 1, "if", (yyvsp[(5) - (5)].sval)); ;}
     break;
 
   case 195:
-#line 1416 "pir.y"
+#line 1419 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (5)].ival), 1, "unless", (yyvsp[(5) - (5)].sval)); ;}
     break;
 
   case 196:
-#line 1418 "pir.y"
+#line 1421 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (5)].ival), 1, "goto", (yyvsp[(5) - (5)].sval)); ;}
     break;
 
   case 197:
-#line 1420 "pir.y"
+#line 1423 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (5)].ival), 1, "null", (yyvsp[(5) - (5)].sval)); ;}
     break;
 
   case 198:
-#line 1422 "pir.y"
+#line 1425 "pir.y"
     {
                           int istrue = evaluate_c(lexer, (yyvsp[(2) - (4)].cval));
                           /* if "unless", invert the true-ness */
@@ -3564,7 +3567,7 @@
     break;
 
   case 199:
-#line 1434 "pir.y"
+#line 1437 "pir.y"
     {
                           set_instrf(lexer, (yyvsp[(1) - (5)].ival) ? "unless_null" : "if_null", "%T%I",
                                      new_reg(lexer, PMC_TYPE, (yyvsp[(3) - (5)].ival)), (yyvsp[(5) - (5)].sval));
@@ -3572,67 +3575,67 @@
     break;
 
   case 200:
-#line 1439 "pir.y"
+#line 1442 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (4)].ival), 0, (yyvsp[(2) - (4)].sval), (yyvsp[(4) - (4)].sval)); ;}
     break;
 
   case 201:
-#line 1441 "pir.y"
+#line 1444 "pir.y"
     { set_instrf(lexer, (yyvsp[(1) - (4)].ival) ? "unless" : "if", "%T%I", (yyvsp[(2) - (4)].targ), (yyvsp[(4) - (4)].sval)); ;}
     break;
 
   case 202:
-#line 1443 "pir.y"
+#line 1446 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (4)].ival), 0, "int", (yyvsp[(4) - (4)].sval)); ;}
     break;
 
   case 203:
-#line 1445 "pir.y"
+#line 1448 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (4)].ival), 0, "num", (yyvsp[(4) - (4)].sval)); ;}
     break;
 
   case 204:
-#line 1447 "pir.y"
+#line 1450 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (4)].ival), 0, "pmc", (yyvsp[(4) - (4)].sval)); ;}
     break;
 
   case 205:
-#line 1449 "pir.y"
+#line 1452 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (4)].ival), 0, "string", (yyvsp[(4) - (4)].sval)); ;}
     break;
 
   case 206:
-#line 1451 "pir.y"
+#line 1454 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (4)].ival), 0, "if", (yyvsp[(4) - (4)].sval)); ;}
     break;
 
   case 207:
-#line 1453 "pir.y"
+#line 1456 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (4)].ival), 0, "unless", (yyvsp[(4) - (4)].sval)); ;}
     break;
 
   case 208:
-#line 1455 "pir.y"
+#line 1458 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (4)].ival), 0, "goto", (yyvsp[(4) - (4)].sval)); ;}
     break;
 
   case 209:
-#line 1457 "pir.y"
+#line 1460 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (4)].ival), 0, "goto", (yyvsp[(4) - (4)].sval)); ;}
     break;
 
   case 210:
-#line 1459 "pir.y"
+#line 1462 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (4)].ival), 0, "null", (yyvsp[(4) - (4)].sval)); ;}
     break;
 
   case 211:
-#line 1461 "pir.y"
+#line 1464 "pir.y"
     { create_if_instr(yyscanner, lexer, (yyvsp[(1) - (4)].ival), 0, "null", (yyvsp[(4) - (4)].sval)); ;}
     break;
 
   case 212:
-#line 1463 "pir.y"
+#line 1466 "pir.y"
     {
                           if ((yyvsp[(2) - (4)].ival) == COMPUTE_DURING_RUNTIME) {
                              if ((yyvsp[(1) - (4)].ival) == NEED_INVERT_OPNAME) /* "unless" */
@@ -3660,7 +3663,7 @@
     break;
 
   case 213:
-#line 1494 "pir.y"
+#line 1497 "pir.y"
     {
                           /* the instructions "gt" and "ge" are converted to "lt" and "le".
                            * if so, then the arguments must be reversed as well. "lt" and
@@ -3689,7 +3692,7 @@
     break;
 
   case 214:
-#line 1520 "pir.y"
+#line 1523 "pir.y"
     {
                           if (((yyvsp[(0) - (3)].ival) != NEED_INVERT_OPNAME) && ((yyvsp[(2) - (3)].ival) == OP_GE || (yyvsp[(2) - (3)].ival) == OP_GT))
                               set_instrf(lexer, opnames[(yyvsp[(2) - (3)].ival) + 1], "%T%i", (yyvsp[(3) - (3)].targ), (yyvsp[(1) - (3)].ival));
@@ -3700,7 +3703,7 @@
     break;
 
   case 215:
-#line 1528 "pir.y"
+#line 1531 "pir.y"
     {
                           if (((yyvsp[(0) - (3)].ival) != NEED_INVERT_OPNAME) && ((yyvsp[(2) - (3)].ival) == OP_GE || (yyvsp[(2) - (3)].ival) == OP_GT))
                               set_instrf(lexer, opnames[(yyvsp[(2) - (3)].ival) + 1], "%T%n", (yyvsp[(3) - (3)].targ), (yyvsp[(1) - (3)].dval));
@@ -3712,7 +3715,7 @@
     break;
 
   case 216:
-#line 1537 "pir.y"
+#line 1540 "pir.y"
     {
                           if (((yyvsp[(0) - (3)].ival) != NEED_INVERT_OPNAME) && ((yyvsp[(2) - (3)].ival) == OP_GE || (yyvsp[(2) - (3)].ival) == OP_GT))
                               set_instrf(lexer, opnames[(yyvsp[(2) - (3)].ival)], "%T%s", (yyvsp[(3) - (3)].targ), (yyvsp[(1) - (3)].sval));
@@ -3724,32 +3727,32 @@
     break;
 
   case 217:
-#line 1546 "pir.y"
+#line 1549 "pir.y"
     { (yyval.ival) = evaluate_i_i((yyvsp[(1) - (3)].ival), (yyvsp[(2) - (3)].ival), (yyvsp[(3) - (3)].ival)); ;}
     break;
 
   case 218:
-#line 1548 "pir.y"
+#line 1551 "pir.y"
     { (yyval.ival) = evaluate_i_n((yyvsp[(1) - (3)].ival), (yyvsp[(2) - (3)].ival), (yyvsp[(3) - (3)].dval)); ;}
     break;
 
   case 219:
-#line 1550 "pir.y"
+#line 1553 "pir.y"
     { (yyval.ival) = evaluate_n_i((yyvsp[(1) - (3)].dval), (yyvsp[(2) - (3)].ival), (yyvsp[(3) - (3)].ival)); ;}
     break;
 
   case 220:
-#line 1552 "pir.y"
+#line 1555 "pir.y"
     { (yyval.ival) = evaluate_n_n((yyvsp[(1) - (3)].dval), (yyvsp[(2) - (3)].ival), (yyvsp[(3) - (3)].dval)); ;}
     break;
 
   case 221:
-#line 1554 "pir.y"
+#line 1557 "pir.y"
     { (yyval.ival) = evaluate_s_s((yyvsp[(1) - (3)].sval), (yyvsp[(2) - (3)].ival), (yyvsp[(3) - (3)].sval)); ;}
     break;
 
   case 222:
-#line 1558 "pir.y"
+#line 1561 "pir.y"
     {
                           yypirerror(yyscanner, lexer, "cannot compare string to %s",
                                      (yyvsp[(3) - (3)].ival) == INT_TYPE ? "integer" : "number");
@@ -3757,37 +3760,37 @@
     break;
 
   case 223:
-#line 1563 "pir.y"
+#line 1566 "pir.y"
     { yypirerror(yyscanner, lexer, "cannot compare integer to string"); ;}
     break;
 
   case 224:
-#line 1565 "pir.y"
+#line 1568 "pir.y"
     { yypirerror(yyscanner, lexer, "cannot compare number to string"); ;}
     break;
 
   case 225:
-#line 1569 "pir.y"
+#line 1572 "pir.y"
     { (yyval.ival) = INT_TYPE; ;}
     break;
 
   case 226:
-#line 1570 "pir.y"
+#line 1573 "pir.y"
     { (yyval.ival) = NUM_TYPE; ;}
     break;
 
   case 227:
-#line 1573 "pir.y"
+#line 1576 "pir.y"
     { (yyval.ival) = DONT_INVERT_OPNAME; /* no need to invert */ ;}
     break;
 
   case 228:
-#line 1574 "pir.y"
+#line 1577 "pir.y"
     { (yyval.ival) = NEED_INVERT_OPNAME; /* yes, invert opname */ ;}
     break;
 
   case 231:
-#line 1582 "pir.y"
+#line 1585 "pir.y"
     {
                           set_instrf(lexer, "branch", "%I", (yyvsp[(2) - (3)].sval));
                           set_op_labelflag(lexer, BIT(0)); /* bit 0 means: "1 << 0" */
@@ -3796,37 +3799,37 @@
     break;
 
   case 232:
-#line 1590 "pir.y"
+#line 1593 "pir.y"
     { declare_local(lexer, (yyvsp[(2) - (4)].ival), (yyvsp[(3) - (4)].symb)); ;}
     break;
 
   case 233:
-#line 1594 "pir.y"
+#line 1597 "pir.y"
     { (yyval.symb) = (yyvsp[(1) - (1)].symb); ;}
     break;
 
   case 234:
-#line 1596 "pir.y"
+#line 1599 "pir.y"
     { (yyval.symb) = add_local((yyvsp[(1) - (3)].symb), (yyvsp[(3) - (3)].symb)); ;}
     break;
 
   case 235:
-#line 1600 "pir.y"
+#line 1603 "pir.y"
     { (yyval.symb) = new_local(lexer, (yyvsp[(1) - (2)].sval), (yyvsp[(2) - (2)].ival)); ;}
     break;
 
   case 236:
-#line 1603 "pir.y"
+#line 1606 "pir.y"
     { (yyval.ival) = 0; ;}
     break;
 
   case 237:
-#line 1604 "pir.y"
+#line 1607 "pir.y"
     { (yyval.ival) = 1; ;}
     break;
 
   case 238:
-#line 1608 "pir.y"
+#line 1611 "pir.y"
     { /* if $4 is not a register, it must be a declared symbol */
                           if (!TEST_FLAG((yyvsp[(4) - (5)].targ)->flags, TARGET_FLAG_IS_REG)) {
 
@@ -3834,17 +3837,17 @@
                                   yypirerror(yyscanner, lexer, "lexical '%s' must be of type 'pmc'",
                                              (yyvsp[(4) - (5)].targ)->info->id.name);
                           }
-                          set_lex_flag((yyvsp[(4) - (5)].targ), (yyvsp[(2) - (5)].sval));
+                          set_lex_flag(lexer, (yyvsp[(4) - (5)].targ), (yyvsp[(2) - (5)].sval));
                         ;}
     break;
 
   case 239:
-#line 1623 "pir.y"
+#line 1626 "pir.y"
     { convert_inv_to_instr(lexer, (yyvsp[(1) - (1)].invo)); ;}
     break;
 
   case 242:
-#line 1635 "pir.y"
+#line 1638 "pir.y"
     { /* $4 contains an invocation object */
                               set_invocation_args((yyvsp[(4) - (8)].invo), (yyvsp[(3) - (8)].argm));
                               (yyval.invo) = set_invocation_results((yyvsp[(4) - (8)].invo), (yyvsp[(6) - (8)].targ));
@@ -3852,72 +3855,72 @@
     break;
 
   case 243:
-#line 1642 "pir.y"
+#line 1645 "pir.y"
     { (yyval.argm) = NULL; ;}
     break;
 
   case 244:
-#line 1644 "pir.y"
+#line 1647 "pir.y"
     { (yyval.argm) = (yyvsp[(1) - (1)].argm); ;}
     break;
 
   case 245:
-#line 1648 "pir.y"
+#line 1651 "pir.y"
     { (yyval.argm) = (yyvsp[(1) - (1)].argm); ;}
     break;
 
   case 246:
-#line 1650 "pir.y"
+#line 1653 "pir.y"
     { (yyval.argm) = add_arg((yyvsp[(1) - (2)].argm), (yyvsp[(2) - (2)].argm)); ;}
     break;
 
   case 247:
-#line 1654 "pir.y"
+#line 1657 "pir.y"
     { (yyval.argm) = (yyvsp[(2) - (3)].argm); ;}
     break;
 
   case 248:
-#line 1658 "pir.y"
+#line 1661 "pir.y"
     { (yyval.invo) = invoke(lexer, CALL_PCC, (yyvsp[(2) - (3)].targ), (yyvsp[(3) - (3)].targ)); ;}
     break;
 
   case 249:
-#line 1660 "pir.y"
+#line 1663 "pir.y"
     { (yyval.invo) = invoke(lexer, CALL_NCI, (yyvsp[(2) - (2)].targ)); ;}
     break;
 
   case 250:
-#line 1663 "pir.y"
+#line 1666 "pir.y"
     { (yyval.invo) = invoke(lexer, CALL_METHOD, (yyvsp[(2) - (5)].targ), (yyvsp[(5) - (5)].expr)); ;}
     break;
 
   case 251:
-#line 1667 "pir.y"
+#line 1670 "pir.y"
     { (yyval.targ) = NULL; ;}
     break;
 
   case 252:
-#line 1669 "pir.y"
+#line 1672 "pir.y"
     { (yyval.targ) = (yyvsp[(2) - (2)].targ); ;}
     break;
 
   case 253:
-#line 1673 "pir.y"
+#line 1676 "pir.y"
     { (yyval.targ) = NULL; ;}
     break;
 
   case 254:
-#line 1675 "pir.y"
+#line 1678 "pir.y"
     { (yyval.targ) = (yyvsp[(1) - (1)].targ); ;}
     break;
 
   case 255:
-#line 1679 "pir.y"
+#line 1682 "pir.y"
     { (yyval.targ) = (yyvsp[(1) - (1)].targ); ;}
     break;
 
   case 256:
-#line 1681 "pir.y"
+#line 1684 "pir.y"
     {
                              if ((yyvsp[(2) - (2)].targ))
                                  (yyval.targ) = add_target(lexer, (yyvsp[(1) - (2)].targ), (yyvsp[(2) - (2)].targ));
@@ -3927,32 +3930,32 @@
     break;
 
   case 257:
-#line 1690 "pir.y"
+#line 1693 "pir.y"
     { (yyval.targ) = (yyvsp[(2) - (3)].targ); ;}
     break;
 
   case 258:
-#line 1692 "pir.y"
+#line 1695 "pir.y"
     { (yyval.targ) = NULL; ;}
     break;
 
   case 260:
-#line 1700 "pir.y"
+#line 1703 "pir.y"
     { (yyval.invo) = set_invocation_results((yyvsp[(3) - (3)].invo), (yyvsp[(1) - (3)].targ)); ;}
     break;
 
   case 261:
-#line 1702 "pir.y"
+#line 1705 "pir.y"
     { (yyval.invo) = set_invocation_results((yyvsp[(3) - (3)].invo), (yyvsp[(1) - (3)].targ)); ;}
     break;
 
   case 262:
-#line 1704 "pir.y"
+#line 1707 "pir.y"
     {  (yyval.invo) = set_invocation_results((yyvsp[(1) - (1)].invo), NULL); ;}
     break;
 
   case 265:
-#line 1712 "pir.y"
+#line 1715 "pir.y"
     {
                              /* if $1 is not a register, check whether the symbol was declared */
                              if (!TEST_FLAG((yyvsp[(1) - (4)].targ)->flags, TARGET_FLAG_IS_REG)) {
@@ -3973,7 +3976,7 @@
     break;
 
   case 266:
-#line 1732 "pir.y"
+#line 1735 "pir.y"
     {
                              (yyval.invo) = invoke(lexer, CALL_PCC, (yyvsp[(1) - (2)].targ), NULL);
                              set_invocation_args((yyval.invo), (yyvsp[(2) - (2)].argm));
@@ -3981,12 +3984,12 @@
     break;
 
   case 267:
-#line 1739 "pir.y"
+#line 1742 "pir.y"
     { (yyval.targ) = (yyvsp[(1) - (1)].targ); ;}
     break;
 
   case 268:
-#line 1741 "pir.y"
+#line 1744 "pir.y"
     {
                              symbol *sym = find_symbol(lexer, (yyvsp[(1) - (1)].sval));
                              if (sym == NULL)
@@ -3997,7 +4000,7 @@
     break;
 
   case 269:
-#line 1751 "pir.y"
+#line 1754 "pir.y"
     { /* check that this identifier was declared */
                              symbol *sym = find_symbol(lexer, (yyvsp[(1) - (1)].sval));
 
@@ -4017,22 +4020,22 @@
     break;
 
   case 270:
-#line 1768 "pir.y"
+#line 1771 "pir.y"
     { (yyval.expr) = expr_from_target(lexer, new_reg(lexer, PMC_TYPE, (yyvsp[(1) - (1)].ival))); ;}
     break;
 
   case 271:
-#line 1770 "pir.y"
+#line 1773 "pir.y"
     { (yyval.expr) = expr_from_target(lexer, new_reg(lexer, STRING_TYPE, (yyvsp[(1) - (1)].ival))); ;}
     break;
 
   case 272:
-#line 1772 "pir.y"
+#line 1775 "pir.y"
     { (yyval.expr) = expr_from_const(lexer, new_const(lexer, STRING_TYPE, (yyvsp[(1) - (1)].sval))); ;}
     break;
 
   case 273:
-#line 1776 "pir.y"
+#line 1779 "pir.y"
     {
                              symbol *sym = find_symbol(lexer, (yyvsp[(1) - (1)].sval));
                              if (sym == NULL)
@@ -4044,67 +4047,67 @@
     break;
 
   case 274:
-#line 1785 "pir.y"
+#line 1788 "pir.y"
     { (yyval.targ) = new_reg(lexer, PMC_TYPE, (yyvsp[(1) - (1)].ival)); ;}
     break;
 
   case 275:
-#line 1790 "pir.y"
+#line 1793 "pir.y"
     { (yyval.targ) = (yyvsp[(2) - (3)].targ); ;}
     break;
 
   case 276:
-#line 1794 "pir.y"
+#line 1797 "pir.y"
     { (yyval.targ) = NULL; ;}
     break;
 
   case 277:
-#line 1796 "pir.y"
+#line 1799 "pir.y"
     { (yyval.targ) = (yyvsp[(1) - (1)].targ); ;}
     break;
 
   case 278:
-#line 1800 "pir.y"
+#line 1803 "pir.y"
     { (yyval.targ) = (yyvsp[(1) - (1)].targ); ;}
     break;
 
   case 279:
-#line 1802 "pir.y"
+#line 1805 "pir.y"
     { (yyval.targ) = add_target(lexer, (yyvsp[(1) - (3)].targ), (yyvsp[(3) - (3)].targ)); ;}
     break;
 
   case 280:
-#line 1806 "pir.y"
+#line 1809 "pir.y"
     { (yyval.targ) = set_param_flag(lexer, (yyvsp[(1) - (2)].targ), (yyvsp[(2) - (2)].ival)); ;}
     break;
 
   case 281:
-#line 1810 "pir.y"
+#line 1813 "pir.y"
     { (yyval.ival) = 0; ;}
     break;
 
   case 282:
-#line 1812 "pir.y"
+#line 1815 "pir.y"
     { SET_FLAG((yyval.ival), (yyvsp[(2) - (2)].ival)); ;}
     break;
 
   case 283:
-#line 1816 "pir.y"
+#line 1819 "pir.y"
     { (yyval.ival) = TARGET_FLAG_OPTIONAL; ;}
     break;
 
   case 284:
-#line 1818 "pir.y"
+#line 1821 "pir.y"
     { (yyval.ival) = TARGET_FLAG_OPT_FLAG; ;}
     break;
 
   case 285:
-#line 1820 "pir.y"
+#line 1823 "pir.y"
     { (yyval.ival) = TARGET_FLAG_SLURPY; ;}
     break;
 
   case 286:
-#line 1822 "pir.y"
+#line 1825 "pir.y"
     {
                              (yyval.ival) = TARGET_FLAG_NAMED;
                              set_param_alias(lexer, (yyvsp[(2) - (2)].sval));
@@ -4112,12 +4115,12 @@
     break;
 
   case 287:
-#line 1832 "pir.y"
+#line 1835 "pir.y"
     { convert_inv_to_instr(lexer, (yyvsp[(1) - (1)].invo)); ;}
     break;
 
   case 292:
-#line 1842 "pir.y"
+#line 1845 "pir.y"
     {
                               (yyval.invo) = invoke(lexer, CALL_RETURN);
                               set_invocation_args((yyval.invo), (yyvsp[(2) - (3)].argm));
@@ -4125,7 +4128,7 @@
     break;
 
   case 293:
-#line 1847 "pir.y"
+#line 1850 "pir.y"
     { /* was the invocation a method call? then it becomes a method tail
                                * call, otherwise it's just a normal (sub) tail call.
                                */
@@ -4137,7 +4140,7 @@
     break;
 
   case 294:
-#line 1858 "pir.y"
+#line 1861 "pir.y"
     {
                               (yyval.invo) = invoke(lexer, CALL_YIELD);
                               set_invocation_args((yyval.invo), (yyvsp[(2) - (3)].argm));
@@ -4145,47 +4148,47 @@
     break;
 
   case 295:
-#line 1865 "pir.y"
+#line 1868 "pir.y"
     { (yyval.argm) = (yyvsp[(2) - (3)].argm); ;}
     break;
 
   case 296:
-#line 1869 "pir.y"
+#line 1872 "pir.y"
     { (yyval.argm) = NULL; ;}
     break;
 
   case 297:
-#line 1871 "pir.y"
+#line 1874 "pir.y"
     { (yyval.argm) = (yyvsp[(1) - (1)].argm); ;}
     break;
 
   case 298:
-#line 1875 "pir.y"
+#line 1878 "pir.y"
     { (yyval.argm) = (yyvsp[(1) - (1)].argm); ;}
     break;
 
   case 299:
-#line 1877 "pir.y"
+#line 1880 "pir.y"
     { (yyval.argm) = add_arg((yyvsp[(1) - (3)].argm), (yyvsp[(3) - (3)].argm)); ;}
     break;
 
   case 302:
-#line 1885 "pir.y"
+#line 1888 "pir.y"
     { (yyval.argm) = set_arg_alias(lexer, (yyvsp[(1) - (3)].sval)); ;}
     break;
 
   case 303:
-#line 1889 "pir.y"
+#line 1892 "pir.y"
     { (yyval.argm) = set_arg_flag((yyval.argm), (yyvsp[(2) - (2)].ival)); ;}
     break;
 
   case 304:
-#line 1893 "pir.y"
+#line 1896 "pir.y"
     { (yyval.argm) = set_curarg(lexer, new_argument(lexer, (yyvsp[(1) - (1)].expr)));  ;}
     break;
 
   case 305:
-#line 1899 "pir.y"
+#line 1902 "pir.y"
     {
                               (yyval.invo) = invoke(lexer, CALL_RETURN);
                               set_invocation_args((yyval.invo), (yyvsp[(3) - (5)].argm));
@@ -4193,7 +4196,7 @@
     break;
 
   case 306:
-#line 1908 "pir.y"
+#line 1911 "pir.y"
     {
                               (yyval.invo) = invoke(lexer, CALL_YIELD);
                               set_invocation_args((yyval.invo), (yyvsp[(3) - (5)].argm));
@@ -4201,72 +4204,72 @@
     break;
 
   case 307:
-#line 1915 "pir.y"
+#line 1918 "pir.y"
     { (yyval.argm) = NULL; ;}
     break;
 
   case 308:
-#line 1917 "pir.y"
+#line 1920 "pir.y"
     { (yyval.argm) = (yyvsp[(1) - (1)].argm); ;}
     break;
 
   case 309:
-#line 1922 "pir.y"
+#line 1925 "pir.y"
     { (yyval.argm) = (yyvsp[(1) - (1)].argm); ;}
     break;
 
   case 310:
-#line 1924 "pir.y"
+#line 1927 "pir.y"
     { (yyval.argm) = add_arg((yyvsp[(1) - (2)].argm), (yyvsp[(2) - (2)].argm)); ;}
     break;
 
   case 311:
-#line 1929 "pir.y"
+#line 1932 "pir.y"
     { (yyval.argm) = (yyvsp[(2) - (3)].argm); ;}
     break;
 
   case 312:
-#line 1933 "pir.y"
+#line 1936 "pir.y"
     { (yyval.argm) = NULL; ;}
     break;
 
   case 313:
-#line 1935 "pir.y"
+#line 1938 "pir.y"
     { (yyval.argm) = (yyvsp[(1) - (1)].argm); ;}
     break;
 
   case 314:
-#line 1939 "pir.y"
+#line 1942 "pir.y"
     { (yyval.argm) = (yyvsp[(1) - (1)].argm); ;}
     break;
 
   case 315:
-#line 1941 "pir.y"
+#line 1944 "pir.y"
     { (yyval.argm) = add_arg((yyvsp[(1) - (2)].argm), (yyvsp[(2) - (2)].argm)); ;}
     break;
 
   case 316:
-#line 1945 "pir.y"
+#line 1948 "pir.y"
     { (yyval.argm) = (yyvsp[(2) - (3)].argm); ;}
     break;
 
   case 317:
-#line 1950 "pir.y"
+#line 1953 "pir.y"
     { (yyval.ival) = 0; ;}
     break;
 
   case 318:
-#line 1952 "pir.y"
+#line 1955 "pir.y"
     { SET_FLAG((yyval.ival), (yyvsp[(2) - (2)].ival)); ;}
     break;
 
   case 319:
-#line 1956 "pir.y"
+#line 1959 "pir.y"
     { (yyval.ival) = ARG_FLAG_FLAT; ;}
     break;
 
   case 320:
-#line 1958 "pir.y"
+#line 1961 "pir.y"
     {
                                (yyval.ival) = ARG_FLAG_NAMED;
                                set_arg_alias(lexer, (yyvsp[(2) - (2)].sval));
@@ -4274,137 +4277,137 @@
     break;
 
   case 321:
-#line 1965 "pir.y"
+#line 1968 "pir.y"
     { (yyval.sval) = NULL; ;}
     break;
 
   case 322:
-#line 1967 "pir.y"
+#line 1970 "pir.y"
     { (yyval.sval) = (yyvsp[(1) - (1)].sval); ;}
     break;
 
   case 323:
-#line 1971 "pir.y"
+#line 1974 "pir.y"
     { (yyval.sval) = (yyvsp[(2) - (3)].sval); ;}
     break;
 
   case 327:
-#line 1982 "pir.y"
+#line 1985 "pir.y"
     { store_global_constant(lexer, (yyvsp[(2) - (2)].cval)); ;}
     break;
 
   case 328:
-#line 1986 "pir.y"
+#line 1989 "pir.y"
     { /* XXX is .globalconst to be kept? */ ;}
     break;
 
   case 329:
-#line 1990 "pir.y"
+#line 1993 "pir.y"
     { (yyval.cval) = new_named_const(lexer, INT_TYPE, (yyvsp[(2) - (4)].sval), (yyvsp[(4) - (4)].ival)); ;}
     break;
 
   case 330:
-#line 1992 "pir.y"
+#line 1995 "pir.y"
     { (yyval.cval) = new_named_const(lexer, NUM_TYPE, (yyvsp[(2) - (4)].sval), (yyvsp[(4) - (4)].dval)); ;}
     break;
 
   case 331:
-#line 1994 "pir.y"
+#line 1997 "pir.y"
     { (yyval.cval) = new_named_const(lexer, STRING_TYPE, (yyvsp[(2) - (4)].sval), (yyvsp[(4) - (4)].sval)); ;}
     break;
 
   case 332:
-#line 1996 "pir.y"
+#line 1999 "pir.y"
     { (yyval.cval) = new_pmc_const((yyvsp[(1) - (4)].sval), (yyvsp[(2) - (4)].sval), (yyvsp[(4) - (4)].cval)); ;}
     break;
 
   case 333:
-#line 2003 "pir.y"
+#line 2006 "pir.y"
     { (yyval.expr) = expr_from_target(lexer, (yyvsp[(1) - (1)].targ)); ;}
     break;
 
   case 334:
-#line 2004 "pir.y"
+#line 2007 "pir.y"
     { (yyval.expr) = expr_from_const(lexer, (yyvsp[(1) - (1)].cval)); ;}
     break;
 
   case 335:
-#line 2008 "pir.y"
+#line 2011 "pir.y"
     { (yyval.cval) = new_const(lexer, STRING_TYPE, (yyvsp[(1) - (1)].sval)); ;}
     break;
 
   case 336:
-#line 2009 "pir.y"
+#line 2012 "pir.y"
     { (yyval.cval) = new_const(lexer, INT_TYPE, (yyvsp[(1) - (1)].ival)); ;}
     break;
 
   case 337:
-#line 2010 "pir.y"
+#line 2013 "pir.y"
     { (yyval.cval) = new_const(lexer, NUM_TYPE, (yyvsp[(1) - (1)].dval)); ;}
     break;
 
   case 338:
-#line 2011 "pir.y"
+#line 2014 "pir.y"
     { (yyval.cval) = (yyvsp[(1) - (1)].cval); ;}
     break;
 
   case 339:
-#line 2014 "pir.y"
+#line 2017 "pir.y"
     { (yyval.ival) = OP_NE; ;}
     break;
 
   case 340:
-#line 2015 "pir.y"
+#line 2018 "pir.y"
     { (yyval.ival) = OP_EQ; ;}
     break;
 
   case 341:
-#line 2016 "pir.y"
+#line 2019 "pir.y"
     { (yyval.ival) = OP_LT; ;}
     break;
 
   case 342:
-#line 2017 "pir.y"
+#line 2020 "pir.y"
     { (yyval.ival) = OP_LE; ;}
     break;
 
   case 343:
-#line 2018 "pir.y"
+#line 2021 "pir.y"
     { (yyval.ival) = OP_GE; ;}
     break;
 
   case 344:
-#line 2019 "pir.y"
+#line 2022 "pir.y"
     { (yyval.ival) = OP_GT; ;}
     break;
 
   case 345:
-#line 2022 "pir.y"
+#line 2025 "pir.y"
     { (yyval.ival) = INT_TYPE; ;}
     break;
 
   case 346:
-#line 2023 "pir.y"
+#line 2026 "pir.y"
     { (yyval.ival) = NUM_TYPE; ;}
     break;
 
   case 347:
-#line 2024 "pir.y"
+#line 2027 "pir.y"
     { (yyval.ival) = PMC_TYPE; ;}
     break;
 
   case 348:
-#line 2025 "pir.y"
+#line 2028 "pir.y"
     { (yyval.ival) = STRING_TYPE; ;}
     break;
 
   case 349:
-#line 2033 "pir.y"
+#line 2036 "pir.y"
     { set_curtarget(lexer, (yyvsp[(1) - (1)].targ));  ;}
     break;
 
   case 351:
-#line 2037 "pir.y"
+#line 2040 "pir.y"
     { /* a symbol must have been declared; check that at this point. */
                            symbol * sym = find_symbol(lexer, (yyvsp[(1) - (1)].sval));
                            if (sym == NULL) {
@@ -4417,277 +4420,277 @@
     break;
 
   case 352:
-#line 2048 "pir.y"
+#line 2051 "pir.y"
     { (yyval.targ) = new_reg(lexer, PMC_TYPE, (yyvsp[(1) - (1)].ival));    ;}
     break;
 
   case 353:
-#line 2049 "pir.y"
+#line 2052 "pir.y"
     { (yyval.targ) = new_reg(lexer, NUM_TYPE, (yyvsp[(1) - (1)].ival));    ;}
     break;
 
   case 354:
-#line 2050 "pir.y"
+#line 2053 "pir.y"
     { (yyval.targ) = new_reg(lexer, INT_TYPE, (yyvsp[(1) - (1)].ival));    ;}
     break;
 
   case 355:
-#line 2051 "pir.y"
+#line 2054 "pir.y"
     { (yyval.targ) = new_reg(lexer, STRING_TYPE, (yyvsp[(1) - (1)].ival)); ;}
     break;
 
   case 358:
-#line 2059 "pir.y"
+#line 2062 "pir.y"
     { (yyval.sval) = "if"; ;}
     break;
 
   case 359:
-#line 2060 "pir.y"
+#line 2063 "pir.y"
     { (yyval.sval) = "unless"; ;}
     break;
 
   case 360:
-#line 2061 "pir.y"
+#line 2064 "pir.y"
     { (yyval.sval) = "goto"; ;}
     break;
 
   case 361:
-#line 2062 "pir.y"
+#line 2065 "pir.y"
     { (yyval.sval) = "int"; ;}
     break;
 
   case 362:
-#line 2063 "pir.y"
+#line 2066 "pir.y"
     { (yyval.sval) = "num"; ;}
     break;
 
   case 363:
-#line 2064 "pir.y"
+#line 2067 "pir.y"
     { (yyval.sval) = "string"; ;}
     break;
 
   case 364:
-#line 2065 "pir.y"
+#line 2068 "pir.y"
     { (yyval.sval) = "pmc"; ;}
     break;
 
   case 365:
-#line 2066 "pir.y"
+#line 2069 "pir.y"
     { (yyval.sval) = "null"; ;}
     break;
 
   case 366:
-#line 2069 "pir.y"
+#line 2072 "pir.y"
     { (yyval.sval) = "neg"; ;}
     break;
 
   case 367:
-#line 2070 "pir.y"
+#line 2073 "pir.y"
     { (yyval.sval) = "not"; ;}
     break;
 
   case 368:
-#line 2071 "pir.y"
+#line 2074 "pir.y"
     { (yyval.sval) = "bnot"; ;}
     break;
 
   case 369:
-#line 2074 "pir.y"
+#line 2077 "pir.y"
     { (yyval.ival) = OP_ADD; ;}
     break;
 
   case 370:
-#line 2075 "pir.y"
+#line 2078 "pir.y"
     { (yyval.ival) = OP_SUB; ;}
     break;
 
   case 371:
-#line 2076 "pir.y"
+#line 2079 "pir.y"
     { (yyval.ival) = OP_DIV; ;}
     break;
 
   case 372:
-#line 2077 "pir.y"
+#line 2080 "pir.y"
     { (yyval.ival) = OP_MUL; ;}
     break;
 
   case 373:
-#line 2078 "pir.y"
+#line 2081 "pir.y"
     { (yyval.ival) = OP_MOD; ;}
     break;
 
   case 374:
-#line 2079 "pir.y"
+#line 2082 "pir.y"
     { (yyval.ival) = OP_BOR; ;}
     break;
 
   case 375:
-#line 2080 "pir.y"
+#line 2083 "pir.y"
     { (yyval.ival) = OP_BAND; ;}
     break;
 
   case 376:
-#line 2081 "pir.y"
+#line 2084 "pir.y"
     { (yyval.ival) = OP_BXOR; ;}
     break;
 
   case 377:
-#line 2082 "pir.y"
+#line 2085 "pir.y"
     { (yyval.ival) = OP_POW; ;}
     break;
 
   case 378:
-#line 2083 "pir.y"
+#line 2086 "pir.y"
     { (yyval.ival) = OP_CONCAT; ;}
     break;
 
   case 379:
-#line 2084 "pir.y"
+#line 2087 "pir.y"
     { (yyval.ival) = OP_LSR; ;}
     break;
 
   case 380:
-#line 2085 "pir.y"
+#line 2088 "pir.y"
     { (yyval.ival) = OP_SHR; ;}
     break;
 
   case 381:
-#line 2086 "pir.y"
+#line 2089 "pir.y"
     { (yyval.ival) = OP_SHL; ;}
     break;
 
   case 382:
-#line 2087 "pir.y"
+#line 2090 "pir.y"
     { (yyval.ival) = OP_OR; ;}
     break;
 
   case 383:
-#line 2088 "pir.y"
+#line 2091 "pir.y"
     { (yyval.ival) = OP_AND; ;}
     break;
 
   case 384:
-#line 2089 "pir.y"
+#line 2092 "pir.y"
     { (yyval.ival) = OP_FDIV; ;}
     break;
 
   case 385:
-#line 2090 "pir.y"
+#line 2093 "pir.y"
     { (yyval.ival) = OP_XOR; ;}
     break;
 
   case 386:
-#line 2091 "pir.y"
+#line 2094 "pir.y"
     { (yyval.ival) = OP_ISEQ; ;}
     break;
 
   case 387:
-#line 2092 "pir.y"
+#line 2095 "pir.y"
     { (yyval.ival) = OP_ISLE; ;}
     break;
 
   case 388:
-#line 2093 "pir.y"
+#line 2096 "pir.y"
     { (yyval.ival) = OP_ISLT; ;}
     break;
 
   case 389:
-#line 2094 "pir.y"
+#line 2097 "pir.y"
     { (yyval.ival) = OP_ISGE; ;}
     break;
 
   case 390:
-#line 2095 "pir.y"
+#line 2098 "pir.y"
     { (yyval.ival) = OP_ISGT; ;}
     break;
 
   case 391:
-#line 2096 "pir.y"
+#line 2099 "pir.y"
     { (yyval.ival) = OP_ISNE; ;}
     break;
 
   case 392:
-#line 2102 "pir.y"
+#line 2105 "pir.y"
     { (yyval.ival) = OP_MUL; ;}
     break;
 
   case 393:
-#line 2103 "pir.y"
+#line 2106 "pir.y"
     { (yyval.ival) = OP_MOD; ;}
     break;
 
   case 394:
-#line 2104 "pir.y"
+#line 2107 "pir.y"
     { (yyval.ival) = OP_POW; ;}
     break;
 
   case 395:
-#line 2105 "pir.y"
+#line 2108 "pir.y"
     { (yyval.ival) = OP_DIV; ;}
     break;
 
   case 396:
-#line 2106 "pir.y"
+#line 2109 "pir.y"
     { (yyval.ival) = OP_FDIV; ;}
     break;
 
   case 397:
-#line 2107 "pir.y"
+#line 2110 "pir.y"
     { (yyval.ival) = OP_BOR; ;}
     break;
 
   case 398:
-#line 2108 "pir.y"
+#line 2111 "pir.y"
     { (yyval.ival) = OP_BAND; ;}
     break;
 
   case 399:
-#line 2109 "pir.y"
+#line 2112 "pir.y"
     { (yyval.ival) = OP_BXOR; ;}
     break;
 
   case 400:
-#line 2110 "pir.y"
+#line 2113 "pir.y"
     { (yyval.ival) = OP_CONCAT; ;}
     break;
 
   case 401:
-#line 2111 "pir.y"
+#line 2114 "pir.y"
     { (yyval.ival) = OP_SHR; ;}
     break;
 
   case 402:
-#line 2112 "pir.y"
+#line 2115 "pir.y"
     { (yyval.ival) = OP_SHL; ;}
     break;
 
   case 403:
-#line 2113 "pir.y"
+#line 2116 "pir.y"
     { (yyval.ival) = OP_LSR; ;}
     break;
 
   case 405:
-#line 2134 "pir.y"
+#line 2137 "pir.y"
     { new_subr(lexer, "@start"); ;}
     break;
 
   case 414:
-#line 2150 "pir.y"
+#line 2153 "pir.y"
     { set_label(lexer, (yyvsp[(1) - (2)].sval)); ;}
     break;
 
   case 419:
-#line 2160 "pir.y"
+#line 2163 "pir.y"
     { set_sub_name(lexer, (yyvsp[(3) - (3)].sval)); ;}
     break;
 
   case 420:
-#line 2164 "pir.y"
+#line 2167 "pir.y"
     { new_subr(lexer, NULL); ;}
     break;
 
   case 421:
-#line 2169 "pir.y"
+#line 2172 "pir.y"
     {
                                   if (is_parrot_op(lexer, (yyvsp[(1) - (3)].sval)))
                                       get_opinfo(yyscanner);
@@ -4699,7 +4702,7 @@
 
 
 /* Line 1267 of yacc.c.  */
-#line 4703 "pirparser.c"
+#line 4706 "pirparser.c"
       default: break;
     }
   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
@@ -4913,7 +4916,7 @@
 }
 
 
-#line 2180 "pir.y"
+#line 2183 "pir.y"
 
 
 

Modified: trunk/compilers/pirc/new/pirsymbol.c
==============================================================================
--- trunk/compilers/pirc/new/pirsymbol.c	(original)
+++ trunk/compilers/pirc/new/pirsymbol.c	Mon Dec 29 05:18:05 2008
@@ -229,7 +229,6 @@
             iter->info.type  = type;
         }
 
-
         iter = iter->next;
     }
 



nntp.perl.org: Perl Programming lists via nntp and http.
Comments to Ask Bjørn Hansen at ask@perl.org | Group listing | About