Major changes:
authorOrion Lawlor <olawlor@acm.org>
Thu, 22 Mar 2001 19:53:55 +0000 (19:53 +0000)
committerOrion Lawlor <olawlor@acm.org>
Thu, 22 Mar 2001 19:53:55 +0000 (19:53 +0000)
-Added parameter marshalling to translator
-Removed old Fortran90 marshalling (new messageless
way should work much better).
-Cleaned up and simplified inheritance heirarchy
-Beginning of SDAG support-- can parse curly brace to
curly brace now.

src/xlat-i/xi-grammar.tab.C
src/xlat-i/xi-grammar.tab.h
src/xlat-i/xi-grammar.y
src/xlat-i/xi-main.C
src/xlat-i/xi-scan.C
src/xlat-i/xi-scan.l
src/xlat-i/xi-symbol.C
src/xlat-i/xi-symbol.h

index edf16316996502a9852c00b86597e4c680ca4ffb..d26c4aafbdf619d158f53f8221fd2b6b42260956 100644 (file)
@@ -1,6 +1,7 @@
 
 /*  A Bison parser, made from xi-grammar.y
-    by GNU Bison version 1.28  */
+ by  GNU Bison version 1.27
+  */
 
 #define YYBISON 1  /* Identify Bison output.  */
 
 #define        EXTERN  259
 #define        READONLY        260
 #define        CHARE   261
-#define        GROUP   262
-#define        NODEGROUP       263
-#define        ARRAY   264
-#define        MESSAGE 265
-#define        CLASS   266
-#define        STACKSIZE       267
-#define        THREADED        268
-#define        MIGRATABLE      269
+#define        MAINCHARE       262
+#define        GROUP   263
+#define        NODEGROUP       264
+#define        ARRAY   265
+#define        MESSAGE 266
+#define        CLASS   267
+#define        STACKSIZE       268
+#define        THREADED        269
 #define        TEMPLATE        270
 #define        SYNC    271
 #define        EXCLUSIVE       272
 #define        VIRTUAL 273
-#define        VOID    274
-#define        PACKED  275
-#define        VARSIZE 276
-#define        ENTRY   277
-#define        MAINCHARE       278
-#define        IDENT   279
-#define        NUMBER  280
-#define        LITERAL 281
-#define        INT     282
-#define        LONG    283
-#define        SHORT   284
-#define        CHAR    285
-#define        FLOAT   286
-#define        DOUBLE  287
-#define        UNSIGNED        288
+#define        MIGRATABLE      274
+#define        CREATEHERE      275
+#define        CREATEHOME      276
+#define        VOID    277
+#define        CONST   278
+#define        PACKED  279
+#define        VARSIZE 280
+#define        ENTRY   281
+#define        IDENT   282
+#define        NUMBER  283
+#define        LITERAL 284
+#define        CPROGRAM        285
+#define        INT     286
+#define        LONG    287
+#define        SHORT   288
+#define        CHAR    289
+#define        FLOAT   290
+#define        DOUBLE  291
+#define        UNSIGNED        292
 
 #line 1 "xi-grammar.y"
 
 extern int yylex (void) ;
 void yyerror(const char *);
 extern unsigned int lineno;
+extern int in_bracket,in_braces;
 ModuleList *modlist;
 
 
-#line 12 "xi-grammar.y"
+#line 13 "xi-grammar.y"
 typedef union {
   ModuleList *modlist;
   Module *module;
@@ -57,7 +63,6 @@ typedef union {
   TParam *tparam;
   TParamList *tparlist;
   Type *type;
-  EnType *rtype;
   PtrType *ptype;
   NamedType *ntype;
   FuncType *ftype;
@@ -65,6 +70,8 @@ typedef union {
   Message *message;
   Chare *chare;
   Entry *entry;
+  Parameter *pname;
+  ParamList *plist;
   Template *templat;
   TypeList *typelist;
   MemberList *mbrlist;
@@ -77,6 +84,7 @@ typedef union {
   MsgVarList *mvlist;
   char *strval;
   int intval;
+  Chare::attrib_t cattr;
 } YYSTYPE;
 #include <stdio.h>
 
@@ -88,26 +96,26 @@ typedef union {
 
 
 
-#define        YYFINAL         277
+#define        YYFINAL         295
 #define        YYFLAG          -32768
-#define        YYNTBASE        48
+#define        YYNTBASE        53
 
-#define YYTRANSLATE(x) ((unsigned)(x) <= 288 ? yytranslate[x] : 114)
+#define YYTRANSLATE(x) ((unsigned)(x) <= 292 ? yytranslate[x] : 123)
 
 static const char yytranslate[] = {     0,
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,    45,
-    46,    42,     2,    39,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,    36,    35,    40,
-    47,    41,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,    51,     2,    47,
+    48,    46,     2,    43,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,    40,    39,    44,
+    52,    45,     2,     2,     2,     2,     2,     2,     2,     2,
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-    43,     2,    44,     2,     2,     2,     2,     2,     2,     2,
+    49,     2,    50,     2,     2,     2,     2,     2,     2,     2,
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,    37,     2,    38,     2,     2,     2,     2,     2,
+     2,     2,    41,     2,    42,     2,     2,     2,     2,     2,
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
@@ -123,7 +131,8 @@ static const char yytranslate[] = {     0,
      2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
     17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-    27,    28,    29,    30,    31,    32,    33,    34
+    27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+    37,    38
 };
 
 #if YYDEBUG != 0
@@ -133,87 +142,92 @@ static const short yyprhs[] = {     0,
     57,    61,    64,    67,    70,    73,    76,    78,    80,    82,
     84,    88,    89,    91,    92,    96,    98,   100,   102,   104,
    107,   110,   113,   116,   119,   121,   123,   126,   128,   131,
-   133,   135,   138,   141,   144,   146,   148,   153,   162,   164,
-   166,   168,   170,   172,   173,   175,   179,   183,   184,   187,
-   192,   198,   199,   203,   205,   209,   211,   213,   214,   218,
-   220,   224,   226,   232,   234,   237,   241,   248,   255,   256,
-   259,   261,   265,   271,   277,   283,   289,   294,   298,   304,
-   310,   316,   322,   328,   334,   339,   340,   343,   344,   347,
-   350,   354,   357,   361,   363,   367,   372,   375,   378,   381,
-   384,   387,   389,   394,   395,   398,   401,   404,   407,   415,
-   423,   428,   429,   433,   435,   439,   441,   443,   445,   447,
-   448,   450,   452,   456,   457,   461,   462
+   134,   136,   138,   141,   144,   147,   156,   158,   160,   162,
+   164,   169,   172,   174,   176,   180,   181,   184,   189,   195,
+   196,   200,   202,   206,   208,   210,   211,   215,   217,   221,
+   223,   229,   231,   234,   238,   245,   246,   249,   251,   255,
+   261,   267,   273,   279,   284,   288,   294,   300,   306,   312,
+   318,   324,   329,   330,   333,   334,   337,   340,   344,   347,
+   351,   353,   357,   362,   365,   368,   371,   374,   377,   379,
+   384,   385,   388,   391,   394,   397,   405,   410,   412,   414,
+   415,   419,   421,   425,   427,   429,   431,   433,   435,   437,
+   439,   441,   443,   445,   451,   457,   461,   463,   466,   471,
+   475,   477,   481,   485,   488,   489,   493,   494
 };
 
-static const short yyrhs[] = {    49,
-     0,     0,    54,    49,     0,     0,     5,     0,     0,    35,
-     0,    25,     0,    25,     0,    53,    36,    36,    25,     0,
-     3,    52,    55,     0,     4,    52,    55,     0,    35,     0,
-    37,    56,    38,    51,     0,     0,    57,    56,     0,    50,
-    37,    56,    38,    51,     0,    50,    54,     0,    50,    74,
-    35,     0,    50,    75,    35,     0,    50,    84,    35,     0,
-    50,    87,     0,    50,    88,     0,    50,    89,     0,    50,
-    91,     0,    50,   102,     0,    70,     0,    26,     0,    27,
-     0,    58,     0,    58,    39,    59,     0,     0,    59,     0,
-     0,    40,    60,    41,     0,    28,     0,    29,     0,    30,
-     0,    31,     0,    34,    28,     0,    34,    29,     0,    34,
-    30,     0,    34,    31,     0,    29,    29,     0,    32,     0,
-    33,     0,    29,    33,     0,    20,     0,    52,    61,     0,
-    62,     0,    63,     0,    64,    42,     0,    65,    42,     0,
-    66,    42,     0,    26,     0,    52,     0,    70,    43,    67,
-    44,     0,    70,    45,    42,    52,    46,    45,    71,    46,
-     0,    64,     0,    65,     0,    66,     0,    68,     0,    69,
-     0,     0,    70,     0,    70,    39,    71,     0,    43,    67,
-    44,     0,     0,    72,    73,     0,     6,    70,    53,    73,
-     0,     6,    11,    64,    42,    52,     0,     0,    43,    77,
-    44,     0,    78,     0,    78,    39,    77,     0,    21,     0,
-    22,     0,     0,    43,    80,    44,     0,    81,     0,    81,
-    39,    80,     0,    15,     0,    70,    52,    43,    44,    35,
-     0,    82,     0,    82,    83,     0,    11,    76,    63,     0,
-    11,    76,    63,    37,    71,    38,     0,    11,    76,    63,
-    37,    83,    38,     0,     0,    36,    86,     0,    63,     0,
-    63,    39,    86,     0,     7,    79,    63,    85,   103,     0,
-    24,    79,    63,    85,   103,     0,     8,    79,    63,    85,
-   103,     0,     9,    79,    63,    85,   103,     0,    43,    26,
-    52,    44,     0,    43,    52,    44,     0,    10,    90,    63,
-    85,   103,     0,     7,    79,    52,    85,   103,     0,    24,
-    79,    52,    85,   103,     0,     8,    79,    52,    85,   103,
-     0,     9,    79,    52,    85,   103,     0,    10,    90,    52,
-    85,   103,     0,    11,    76,    52,    35,     0,     0,    47,
-    70,     0,     0,    47,    26,     0,    47,    27,     0,    12,
-    52,    97,     0,    69,    98,     0,    70,    52,    98,     0,
-    99,     0,    99,    39,   100,     0,    16,    40,   100,    41,
-     0,   101,    92,     0,   101,    93,     0,   101,    94,     0,
-   101,    95,     0,   101,    96,     0,    35,     0,    37,   104,
-    38,    51,     0,     0,   105,   104,     0,   106,    35,     0,
-    74,    35,     0,    75,    35,     0,    23,   107,    20,    52,
-   111,   113,   112,     0,    23,   107,    65,    52,   111,   113,
-   112,     0,    23,   107,    52,   111,     0,     0,    43,   108,
-    44,     0,   109,     0,   109,    39,   108,     0,    14,     0,
-    17,     0,    18,     0,    19,     0,     0,    20,     0,    65,
-     0,    45,   110,    46,     0,     0,    13,    47,    26,     0,
-     0,    47,    26,     0
+static const short yyrhs[] = {    54,
+     0,     0,    59,    54,     0,     0,     5,     0,     0,    39,
+     0,    28,     0,    28,     0,    58,    40,    40,    28,     0,
+     3,    57,    60,     0,     4,    57,    60,     0,    39,     0,
+    41,    61,    42,    56,     0,     0,    62,    61,     0,    55,
+    41,    61,    42,    56,     0,    55,    59,     0,    55,    78,
+    39,     0,    55,    79,    39,     0,    55,    88,    39,     0,
+    55,    91,     0,    55,    92,     0,    55,    93,     0,    55,
+    95,     0,    55,   106,     0,    74,     0,    29,     0,    30,
+     0,    63,     0,    63,    43,    64,     0,     0,    64,     0,
+     0,    44,    65,    45,     0,    32,     0,    33,     0,    34,
+     0,    35,     0,    38,    32,     0,    38,    33,     0,    38,
+    34,     0,    38,    35,     0,    33,    33,     0,    36,     0,
+    37,     0,    33,    37,     0,    23,     0,    57,    66,     0,
+    58,    66,     0,    67,     0,    69,     0,    70,    46,     0,
+    71,    46,     0,    72,    46,     0,    74,    47,    46,    57,
+    48,    47,   119,    48,     0,    70,     0,    71,     0,    72,
+     0,    73,     0,    74,    49,    75,    50,     0,    74,    51,
+     0,    29,     0,    58,     0,    49,    75,    50,     0,     0,
+    76,    77,     0,     6,    74,    58,    77,     0,     6,    12,
+    70,    46,    57,     0,     0,    49,    81,    50,     0,    82,
+     0,    82,    43,    81,     0,    25,     0,    26,     0,     0,
+    49,    84,    50,     0,    85,     0,    85,    43,    84,     0,
+    20,     0,    74,    57,    49,    50,    39,     0,    86,     0,
+    86,    87,     0,    12,    80,    68,     0,    12,    80,    68,
+    41,    87,    42,     0,     0,    40,    90,     0,    68,     0,
+    68,    43,    90,     0,     7,    83,    68,    89,   107,     0,
+     8,    83,    68,    89,   107,     0,     9,    83,    68,    89,
+   107,     0,    10,    83,    68,    89,   107,     0,    49,    29,
+    57,    50,     0,    49,    57,    50,     0,    11,    94,    68,
+    89,   107,     0,     7,    83,    57,    89,   107,     0,     8,
+    83,    57,    89,   107,     0,     9,    83,    57,    89,   107,
+     0,    10,    83,    57,    89,   107,     0,    11,    94,    57,
+    89,   107,     0,    12,    80,    57,    39,     0,     0,    52,
+    74,     0,     0,    52,    29,     0,    52,    30,     0,    13,
+    57,   101,     0,    73,   102,     0,    74,    57,   102,     0,
+   103,     0,   103,    43,   104,     0,    16,    44,   104,    45,
+     0,   105,    96,     0,   105,    97,     0,   105,    98,     0,
+   105,    99,     0,   105,   100,     0,    39,     0,    41,   108,
+    42,    56,     0,     0,   109,   108,     0,   110,    39,     0,
+    78,    39,     0,    79,    39,     0,    27,   112,   111,    57,
+   120,   122,   121,     0,    27,   112,    57,   120,     0,    23,
+     0,    71,     0,     0,    49,   113,    50,     0,   114,     0,
+   114,    43,   113,     0,    15,     0,    17,     0,    18,     0,
+    19,     0,    21,     0,    22,     0,    30,     0,    29,     0,
+    58,     0,    31,     0,    31,    49,    31,    50,    31,     0,
+    31,    41,    31,    42,    31,     0,    74,    57,    49,     0,
+    74,     0,    74,    57,     0,    74,    57,    52,   115,     0,
+   117,   116,    50,     0,   118,     0,   118,    43,   119,     0,
+    47,   119,    48,     0,    47,    48,     0,     0,    14,    52,
+    29,     0,     0,    52,    29,     0
 };
 
 #endif
 
 #if YYDEBUG != 0
 static const short yyrline[] = { 0,
-    96,   100,   102,   106,   108,   112,   114,   118,   122,   124,
-   132,   134,   138,   140,   144,   146,   150,   152,   154,   156,
-   158,   160,   162,   164,   166,   168,   172,   174,   176,   180,
-   182,   186,   188,   192,   194,   198,   200,   202,   204,   206,
-   208,   210,   212,   214,   216,   218,   220,   222,   226,   230,
-   232,   236,   240,   242,   246,   248,   252,   256,   260,   262,
-   264,   266,   268,   272,   274,   276,   280,   284,   286,   290,
-   294,   298,   300,   310,   312,   316,   318,   322,   324,   328,
-   330,   334,   338,   342,   344,   348,   350,   352,   356,   358,
-   362,   364,   368,   370,   374,   378,   382,   388,   392,   396,
-   398,   402,   406,   410,   414,   418,   420,   424,   426,   428,
-   432,   434,   436,   440,   442,   446,   450,   452,   454,   456,
-   458,   462,   464,   468,   470,   474,   476,   478,   482,   484,
-   486,   490,   492,   496,   498,   502,   504,   506,   508,   512,
-   514,   516,   520,   524,   526,   530,   532
+    99,   103,   105,   109,   111,   115,   117,   121,   125,   127,
+   135,   137,   141,   143,   147,   149,   153,   155,   157,   159,
+   161,   163,   165,   167,   169,   171,   175,   177,   179,   183,
+   185,   189,   191,   195,   197,   201,   203,   205,   207,   209,
+   211,   213,   215,   217,   219,   221,   223,   225,   229,   230,
+   232,   234,   238,   242,   244,   248,   252,   254,   256,   258,
+   260,   262,   268,   270,   274,   278,   280,   284,   288,   292,
+   294,   304,   306,   310,   312,   316,   318,   322,   324,   328,
+   332,   336,   338,   342,   344,   348,   350,   354,   356,   360,
+   362,   366,   370,   374,   380,   384,   388,   390,   394,   398,
+   402,   406,   410,   412,   416,   418,   420,   424,   426,   428,
+   432,   434,   438,   442,   444,   446,   448,   450,   454,   456,
+   460,   462,   466,   468,   470,   474,   476,   480,   482,   486,
+   488,   492,   494,   498,   500,   502,   504,   506,   508,   512,
+   514,   516,   520,   522,   528,   536,   543,   545,   547,   549,
+   556,   558,   562,   564,   568,   570,   574,   576
 };
 #endif
 
@@ -221,39 +235,42 @@ static const short yyrline[] = { 0,
 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
 
 static const char * const yytname[] = {   "$","error","$undefined.","MODULE",
-"MAINMODULE","EXTERN","READONLY","CHARE","GROUP","NODEGROUP","ARRAY","MESSAGE",
-"CLASS","STACKSIZE","THREADED","MIGRATABLE","TEMPLATE","SYNC","EXCLUSIVE","VIRTUAL",
-"VOID","PACKED","VARSIZE","ENTRY","MAINCHARE","IDENT","NUMBER","LITERAL","INT",
-"LONG","SHORT","CHAR","FLOAT","DOUBLE","UNSIGNED","';'","':'","'{'","'}'","','",
-"'<'","'>'","'*'","'['","']'","'('","')'","'='","File","ModuleEList","OptExtern",
-"OptSemiColon","Name","QualName","Module","ConstructEList","ConstructList","Construct",
-"TParam","TParamList","TParamEList","OptTParams","BuiltinType","NamedType","SimpleType",
-"OnePtrType","PtrType","ArrayDim","ArrayType","FuncType","Type","TypeList","Dim",
-"DimList","Readonly","ReadonlyMsg","MAttribs","MAttribList","MAttrib","CAttribs",
-"CAttribList","CAttrib","Var","VarList","Message","OptBaseList","BaseList","Chare",
-"Group","NodeGroup","ArrayIndexType","Array","TChare","TGroup","TNodeGroup",
-"TArray","TMessage","OptTypeInit","OptNameInit","TVar","TVarList","TemplateSpec",
-"Template","MemberEList","MemberList","Member","Entry","EAttribs","EAttribList",
-"EAttrib","OptType","EParam","OptStackSize","OptPure", NULL
+"MAINMODULE","EXTERN","READONLY","CHARE","MAINCHARE","GROUP","NODEGROUP","ARRAY",
+"MESSAGE","CLASS","STACKSIZE","THREADED","TEMPLATE","SYNC","EXCLUSIVE","VIRTUAL",
+"MIGRATABLE","CREATEHERE","CREATEHOME","VOID","CONST","PACKED","VARSIZE","ENTRY",
+"IDENT","NUMBER","LITERAL","CPROGRAM","INT","LONG","SHORT","CHAR","FLOAT","DOUBLE",
+"UNSIGNED","';'","':'","'{'","'}'","','","'<'","'>'","'*'","'('","')'","'['",
+"']'","'&'","'='","File","ModuleEList","OptExtern","OptSemiColon","Name","QualName",
+"Module","ConstructEList","ConstructList","Construct","TParam","TParamList",
+"TParamEList","OptTParams","BuiltinType","NamedType","QualNamedType","SimpleType",
+"OnePtrType","PtrType","FuncType","Type","ArrayDim","Dim","DimList","Readonly",
+"ReadonlyMsg","MAttribs","MAttribList","MAttrib","CAttribs","CAttribList","CAttrib",
+"Var","VarList","Message","OptBaseList","BaseList","Chare","Group","NodeGroup",
+"ArrayIndexType","Array","TChare","TGroup","TNodeGroup","TArray","TMessage",
+"OptTypeInit","OptNameInit","TVar","TVarList","TemplateSpec","Template","MemberEList",
+"MemberList","Member","Entry","EReturn","EAttribs","EAttribList","EAttrib","DefaultParameter",
+"CCode","ParamBracketStart","Parameter","ParamList","EParameters","OptStackSize",
+"OptPure", NULL
 };
 #endif
 
 static const short yyr1[] = {     0,
-    48,    49,    49,    50,    50,    51,    51,    52,    53,    53,
-    54,    54,    55,    55,    56,    56,    57,    57,    57,    57,
-    57,    57,    57,    57,    57,    57,    58,    58,    58,    59,
-    59,    60,    60,    61,    61,    62,    62,    62,    62,    62,
-    62,    62,    62,    62,    62,    62,    62,    62,    63,    64,
-    64,    65,    66,    66,    67,    67,    68,    69,    70,    70,
-    70,    70,    70,    71,    71,    71,    72,    73,    73,    74,
-    75,    76,    76,    77,    77,    78,    78,    79,    79,    80,
-    80,    81,    82,    83,    83,    84,    84,    84,    85,    85,
-    86,    86,    87,    87,    88,    89,    90,    90,    91,    92,
-    92,    93,    94,    95,    96,    97,    97,    98,    98,    98,
-    99,    99,    99,   100,   100,   101,   102,   102,   102,   102,
-   102,   103,   103,   104,   104,   105,   105,   105,   106,   106,
-   106,   107,   107,   108,   108,   109,   109,   109,   109,   110,
-   110,   110,   111,   112,   112,   113,   113
+    53,    54,    54,    55,    55,    56,    56,    57,    58,    58,
+    59,    59,    60,    60,    61,    61,    62,    62,    62,    62,
+    62,    62,    62,    62,    62,    62,    63,    63,    63,    64,
+    64,    65,    65,    66,    66,    67,    67,    67,    67,    67,
+    67,    67,    67,    67,    67,    67,    67,    67,    68,    69,
+    70,    70,    71,    72,    72,    73,    74,    74,    74,    74,
+    74,    74,    75,    75,    76,    77,    77,    78,    79,    80,
+    80,    81,    81,    82,    82,    83,    83,    84,    84,    85,
+    86,    87,    87,    88,    88,    89,    89,    90,    90,    91,
+    91,    92,    93,    94,    94,    95,    96,    96,    97,    98,
+    99,   100,   101,   101,   102,   102,   102,   103,   103,   103,
+   104,   104,   105,   106,   106,   106,   106,   106,   107,   107,
+   108,   108,   109,   109,   109,   110,   110,   111,   111,   112,
+   112,   113,   113,   114,   114,   114,   114,   114,   114,   115,
+   115,   115,   116,   116,   116,   117,   118,   118,   118,   118,
+   119,   119,   120,   120,   121,   121,   122,   122
 };
 
 static const short yyr2[] = {     0,
@@ -261,171 +278,178 @@ static const short yyr2[] = {     0,
      3,     3,     1,     4,     0,     2,     5,     2,     3,     3,
      3,     2,     2,     2,     2,     2,     1,     1,     1,     1,
      3,     0,     1,     0,     3,     1,     1,     1,     1,     2,
-     2,     2,     2,     2,     1,     1,     2,     1,     2,     1,
-     1,     2,     2,     2,     1,     1,     4,     8,     1,     1,
-     1,     1,     1,     0,     1,     3,     3,     0,     2,     4,
-     5,     0,     3,     1,     3,     1,     1,     0,     3,     1,
-     3,     1,     5,     1,     2,     3,     6,     6,     0,     2,
-     1,     3,     5,     5,     5,     5,     4,     3,     5,     5,
-     5,     5,     5,     5,     4,     0,     2,     0,     2,     2,
-     3,     2,     3,     1,     3,     4,     2,     2,     2,     2,
-     2,     1,     4,     0,     2,     2,     2,     2,     7,     7,
-     4,     0,     3,     1,     3,     1,     1,     1,     1,     0,
-     1,     1,     3,     0,     3,     0,     2
+     2,     2,     2,     2,     1,     1,     2,     1,     2,     2,
+     1,     1,     2,     2,     2,     8,     1,     1,     1,     1,
+     4,     2,     1,     1,     3,     0,     2,     4,     5,     0,
+     3,     1,     3,     1,     1,     0,     3,     1,     3,     1,
+     5,     1,     2,     3,     6,     0,     2,     1,     3,     5,
+     5,     5,     5,     4,     3,     5,     5,     5,     5,     5,
+     5,     4,     0,     2,     0,     2,     2,     3,     2,     3,
+     1,     3,     4,     2,     2,     2,     2,     2,     1,     4,
+     0,     2,     2,     2,     2,     7,     4,     1,     1,     0,
+     3,     1,     3,     1,     1,     1,     1,     1,     1,     1,
+     1,     1,     1,     5,     5,     3,     1,     2,     4,     3,
+     1,     3,     3,     2,     0,     3,     0,     2
 };
 
 static const short yydefact[] = {     2,
      0,     0,     1,     2,     8,     0,     0,     3,    13,     4,
-    11,    12,     5,     0,     0,     4,     0,    78,    78,    78,
-     0,    72,     0,    78,     4,    18,     0,     0,     0,    22,
-    23,    24,    25,     0,    26,     6,    16,     0,    48,    36,
-    37,    38,    39,    45,    46,     0,    34,    50,    51,    59,
-    60,    61,    62,    63,     0,     0,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,    19,    20,    21,    78,
-    78,    78,     0,    72,    78,   117,   118,   119,   120,   121,
-     7,    14,     0,    44,    47,    40,    41,    42,    43,    32,
-    49,    52,    53,    54,     9,     0,     0,    68,    82,     0,
-    80,    89,    89,    89,     0,     0,    89,    76,    77,     0,
-    74,    86,     0,    63,     0,   114,     0,    89,     6,     0,
-     0,     0,     0,     0,     0,     0,    28,    29,    30,    33,
-     0,    27,    55,    56,     0,     0,     0,     0,    68,    70,
-    79,     0,     0,     0,     0,     0,     0,    98,     0,    73,
-     0,    64,   106,     0,   112,   108,     0,   116,     0,    17,
-    89,    89,    89,    89,     0,    89,    71,     0,    35,    57,
-     0,     0,     0,    69,    81,    91,    90,   122,   124,    93,
-    95,    96,    97,    99,    75,    65,     0,    84,     0,     0,
-   111,   109,   110,   113,   115,    94,     0,     0,     0,     0,
-   105,     0,    31,     0,    10,    67,     0,   132,     0,     0,
-     0,   124,     0,    64,     0,    87,     0,    85,    88,   107,
-   100,   102,   103,   104,   101,    64,    92,     0,     0,   127,
-   128,     6,   125,   126,    65,    66,     0,     0,   136,   137,
-   138,   139,     0,   134,    48,    34,     0,     0,   123,     0,
-    58,   133,     0,     0,   140,   131,     0,    83,   135,   146,
-    48,   142,     0,   146,     0,   144,   143,   144,   147,     0,
-   129,   130,     0,   145,     0,     0,     0
+    11,    12,     5,     0,     0,     4,     0,    76,    76,    76,
+    76,     0,    70,     0,     4,    18,     0,     0,     0,    22,
+    23,    24,    25,     0,    26,     6,    16,     0,    48,     9,
+    36,    37,    38,    39,    45,    46,     0,    34,    51,    52,
+    57,    58,    59,    60,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,    19,    20,    21,    76,
+    76,    76,    76,     0,    70,   114,   115,   116,   117,   118,
+     7,    14,     0,    44,    47,    40,    41,    42,    43,     0,
+    32,    50,    53,    54,    55,     0,     0,    62,    66,    80,
+     0,    78,    34,    86,    86,    86,    86,     0,     0,    86,
+    74,    75,     0,    72,    84,     0,    60,     0,   111,     0,
+     6,     0,     0,     0,     0,     0,     0,     0,     0,    28,
+    29,    30,    33,     0,    27,     0,    63,    64,     0,     0,
+    66,    68,    77,     0,    49,     0,     0,     0,     0,     0,
+     0,    95,     0,    71,     0,     0,   103,     0,   109,   105,
+     0,   113,    17,    86,    86,    86,    86,    86,     0,    69,
+    10,     0,    35,     0,    61,     0,    67,    79,    88,    87,
+   119,   121,    90,    91,    92,    93,    94,    96,    73,     0,
+    82,     0,     0,   108,   106,   107,   110,   112,     0,     0,
+     0,     0,     0,   102,    31,     0,    65,     0,   130,     0,
+     0,     0,   121,     0,     0,    83,    85,   104,    97,    98,
+    99,   100,   101,     0,    89,     0,     0,   124,   125,     6,
+   122,   123,     0,   147,     0,   151,     0,   134,   135,   136,
+   137,   138,   139,     0,   132,    48,     9,     0,     0,   129,
+     0,   120,     0,   148,   143,     0,     0,    56,   131,     0,
+     0,   127,     0,    81,   146,     0,     0,     0,   150,   152,
+   133,   154,     0,   157,   141,   140,   142,   149,     0,     0,
+   153,     0,   155,     0,     0,   158,     0,   126,   145,   144,
+     0,   156,     0,     0,     0
 };
 
-static const short yydefgoto[] = {   275,
-     3,    14,    82,    47,    98,     4,    11,    15,    16,   129,
-   130,   131,    91,    48,    49,    50,    51,    52,   135,    53,
-    54,   115,   187,   139,   140,   209,   210,    63,   110,   111,
-    57,   100,   101,   188,   189,    29,   144,   177,    30,    31,
-    32,    61,    33,    76,    77,    78,    79,    80,   191,   155,
-   116,   117,    34,    35,   180,   211,   212,   213,   229,   243,
-   244,   263,   256,   271,   266
+static const short yydefgoto[] = {   293,
+     3,    14,    82,   103,    48,     4,    11,    15,    16,   132,
+   133,   134,    92,    49,   179,    50,    51,    52,    53,    54,
+   234,   139,   141,   142,   210,   211,    64,   113,   114,    57,
+   101,   102,   191,   192,    29,   147,   180,    30,    31,    32,
+    62,    33,    76,    77,    78,    79,    80,   194,   159,   119,
+   120,    34,    35,   183,   212,   213,   214,   251,   227,   244,
+   245,   278,   256,   235,   236,   237,   262,   288,   283
 };
 
-static const short yypact[] = {    67,
-     0,     0,-32768,    67,-32768,    10,    10,-32768,-32768,     5,
--32768,-32768,-32768,    45,    61,     5,    77,    50,    50,    50,
-    60,    73,    93,    50,     5,-32768,    83,   101,   123,-32768,
--32768,-32768,-32768,   142,-32768,   127,-32768,   139,-32768,-32768,
-    17,-32768,-32768,-32768,-32768,    99,   125,-32768,-32768,   121,
-   133,   135,-32768,-32768,    -4,   164,     0,     0,     0,   106,
-     0,   119,     0,   114,     0,   143,-32768,-32768,-32768,    50,
-    50,    50,    60,    73,    50,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,   138,-32768,-32768,-32768,-32768,-32768,-32768,   176,
--32768,-32768,-32768,-32768,-32768,   131,   140,    22,-32768,   150,
-   145,   159,   159,   159,     0,   153,   159,-32768,-32768,   154,
-   160,   174,     0,   -19,    19,   175,   179,   159,   127,     0,
-     0,     0,     0,     0,     0,     0,-32768,-32768,   178,-32768,
-   188,    55,-32768,-32768,   171,     0,   194,   131,   189,-32768,
--32768,   164,     0,    78,    78,    78,   187,-32768,    78,-32768,
-   119,   139,   186,   134,-32768,   190,   114,-32768,    78,-32768,
-   159,   159,   159,   159,   199,   159,-32768,   176,-32768,-32768,
-   192,   210,   195,-32768,-32768,   197,-32768,-32768,    13,-32768,
--32768,-32768,-32768,-32768,-32768,    -8,   202,   139,   203,   139,
--32768,-32768,-32768,-32768,-32768,-32768,    78,    78,    78,    78,
--32768,    78,-32768,   198,-32768,-32768,     0,   205,   207,   211,
-   212,    13,   214,   139,   208,-32768,    19,-32768,-32768,    55,
--32768,-32768,-32768,-32768,-32768,   139,-32768,    49,   158,-32768,
--32768,   127,-32768,-32768,    51,-32768,   201,   206,-32768,-32768,
--32768,-32768,   209,   215,     0,    47,   121,     0,-32768,   220,
--32768,-32768,    49,   213,   193,-32768,   213,-32768,-32768,   216,
-   218,-32768,   219,   216,   230,   244,-32768,   244,-32768,   221,
--32768,-32768,   233,-32768,   260,   261,-32768
+static const short yypact[] = {   143,
+    15,    15,-32768,   143,-32768,    71,    71,-32768,-32768,    19,
+-32768,-32768,-32768,     7,   -15,    19,   117,   -17,   -17,   -17,
+   -17,    -4,    28,    45,    19,-32768,    55,    66,    70,-32768,
+-32768,-32768,-32768,   207,-32768,    74,-32768,   149,-32768,-32768,
+-32768,    25,-32768,-32768,-32768,-32768,   141,     2,-32768,-32768,
+    73,    82,    85,-32768,     6,   118,    15,    15,    15,    15,
+   129,    15,   169,    15,    63,   102,-32768,-32768,-32768,   -17,
+   -17,   -17,   -17,    -4,    28,-32768,-32768,-32768,-32768,-32768,
+-32768,-32768,    96,-32768,-32768,-32768,-32768,-32768,-32768,   120,
+   133,-32768,-32768,-32768,-32768,   150,   162,-32768,    10,-32768,
+   114,   136,   164,   170,   170,   170,   170,    15,   172,   170,
+-32768,-32768,   173,   181,   171,    15,     4,    57,   182,   183,
+    74,    15,    15,    15,    15,    15,    15,    15,   199,-32768,
+-32768,   186,-32768,   185,    69,    15,-32768,   192,   184,   162,
+   187,-32768,-32768,   118,-32768,    15,   100,   100,   100,   100,
+   188,-32768,   100,-32768,   169,   149,   179,   191,-32768,   189,
+    63,-32768,-32768,   170,   170,   170,   170,   170,   196,-32768,
+-32768,   133,-32768,   194,-32768,   190,-32768,-32768,   200,-32768,
+-32768,    27,-32768,-32768,-32768,-32768,-32768,-32768,-32768,    57,
+   149,   195,   149,-32768,-32768,-32768,-32768,-32768,   100,   100,
+   100,   100,   100,-32768,-32768,   197,-32768,    15,   198,   206,
+   209,   204,    27,   210,   202,-32768,-32768,    69,-32768,-32768,
+-32768,-32768,-32768,   149,-32768,   115,   165,-32768,-32768,    74,
+-32768,-32768,   203,    57,   208,   211,   212,-32768,-32768,-32768,
+-32768,-32768,-32768,   205,   213,   224,   214,   215,    73,-32768,
+    15,-32768,   218,    41,    62,   216,   149,-32768,-32768,   115,
+     3,-32768,   215,-32768,-32768,    35,   227,   228,-32768,-32768,
+-32768,-32768,   217,   219,-32768,-32768,   192,-32768,   221,   220,
+-32768,   235,   253,   237,   238,-32768,   222,-32768,-32768,-32768,
+   243,-32768,   273,   275,-32768
 };
 
 static const short yypgoto[] = {-32768,
-   258,-32768,  -115,    -1,-32768,   252,   262,     7,-32768,-32768,
-   102,-32768,-32768,-32768,   -52,   -36,  -213,-32768,   129,-32768,
-   -56,   -14,  -202,-32768,   132,   259,   263,   200,   124,-32768,
-    14,   130,-32768,-32768,    88,-32768,   -89,    71,-32768,-32768,
--32768,   217,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   126,
--32768,   122,-32768,-32768,  -119,    68,-32768,-32768,-32768,    28,
--32768,-32768,  -197,    15,    20
+   272,-32768,  -116,    -1,   -53,   263,   271,    67,-32768,-32768,
+   107,-32768,   177,-32768,   147,-32768,   -35,    54,-32768,   -59,
+   -13,   142,-32768,   144,   269,   270,   223,   131,-32768,     9,
+   145,-32768,-32768,    97,-32768,   -98,    79,-32768,-32768,-32768,
+   225,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   130,-32768,
+   132,-32768,-32768,  -128,    78,-32768,-32768,-32768,-32768,    32,
+-32768,-32768,-32768,-32768,-32768,  -173,    31,-32768,-32768
 };
 
 
-#define        YYLAST          290
+#define        YYLAST          299
 
 
 static const short yytable[] = {     6,
-     7,    83,    55,   160,   102,   103,   104,   114,   107,    13,
-   112,   236,   118,   145,   146,   248,     5,   149,    17,  -108,
-    95,  -108,    37,   238,     5,   181,   182,   154,   159,   184,
-   214,    66,    58,    59,    96,   208,    97,    65,    96,   196,
-    97,   262,   -15,     5,     9,    84,    10,     1,     2,    85,
-    17,    18,    19,    20,    21,    22,   260,   137,   106,   264,
-    23,    96,   239,    97,   138,   240,   241,   242,    24,     1,
-     2,   197,   198,   199,   200,   132,   202,   221,   222,   223,
-   224,    25,   225,   120,   121,   122,    90,    38,   125,   214,
-   176,   255,    56,    96,   134,    97,    39,    96,    36,    97,
-   114,     5,    60,   147,    40,    41,    42,    43,    44,    45,
-    46,   153,   178,   156,   179,    62,   249,    67,   161,   162,
-   163,   164,   165,   166,   167,   113,    86,    87,    88,    89,
-     5,   105,    64,    39,   171,    68,   134,   186,     5,   108,
-   109,    40,    41,    42,    43,    44,    45,    46,    70,    71,
-    72,    73,    74,   132,   176,     5,   133,    69,    39,   192,
-   193,    81,    92,     5,    90,    75,    40,    41,    42,    43,
-    44,    45,    46,   217,    93,   220,    94,   245,    99,   126,
-   119,   136,     5,   142,   215,    40,    41,    42,    43,    44,
-    45,    46,   247,   141,   143,    39,   148,   150,   151,   235,
-     5,   127,   128,    40,    41,    42,    43,    44,    45,    46,
-   152,   235,   261,   157,   170,   215,   168,     5,   247,   158,
-    40,    41,    42,    43,    44,    45,    46,   246,   169,   172,
-   183,   138,   190,   201,   205,   207,   154,   204,   206,   216,
-   219,   230,   226,   254,   250,   231,   257,   228,   234,   232,
-   237,   251,   252,   253,   258,   269,   270,   255,   274,   276,
-   277,     8,   265,  -141,   267,    26,   173,   273,    12,   203,
-   174,   175,    27,   124,   185,   218,    28,   227,   195,   233,
-   259,   194,   272,   268,     0,     0,     0,     0,     0,   123
+     7,    99,    83,    55,   163,   117,   148,   149,   150,     1,
+     2,   153,    17,    18,    19,    20,    21,    22,    23,   184,
+   185,   186,    24,    13,   188,    39,    36,    58,    59,    60,
+    40,    56,    17,    40,    41,    42,    43,    44,    45,    46,
+    47,    90,     5,   138,    61,    91,  -105,    25,  -105,    90,
+   272,   118,    96,   209,    97,   158,    98,    84,   140,   109,
+   -15,    85,    40,   275,   276,   199,   200,   201,   202,   203,
+   219,   220,   221,   222,   223,   116,    63,   135,   122,   123,
+   124,   125,    37,   270,     5,    39,   138,   273,    65,   265,
+    40,    66,   266,    67,    41,    42,    43,    44,    45,    46,
+    47,   117,   267,    96,    68,    97,   151,    98,    69,     9,
+   268,    10,    81,   252,   157,    96,   160,    97,    93,    98,
+   164,   165,   166,   167,   168,   169,   170,    94,    38,   238,
+    95,   239,   240,   241,   174,   242,   243,   100,   181,    39,
+   182,   128,   190,   121,    40,     1,     2,   118,    41,    42,
+    43,    44,    45,    46,    47,    39,     5,   108,   135,   129,
+    40,   130,   131,   143,    41,    42,    43,    44,    45,    46,
+    47,    39,    86,    87,    88,    89,    40,   190,   144,   218,
+    41,    42,    43,    44,    45,    46,    47,   246,   215,    40,
+   137,   249,   247,   111,   112,   136,    41,    42,    43,    44,
+    45,    46,    47,   104,   105,   106,   107,    91,   110,   146,
+   115,   156,   277,    70,    71,    72,    73,    74,    75,   195,
+   196,   152,   154,   155,   161,   248,   171,   162,   172,   173,
+   193,    90,   254,   175,   204,   140,   217,   187,   255,   207,
+   158,   206,   208,   224,   228,   230,   226,   229,   232,   263,
+   233,  -128,   253,   257,   259,   260,   264,   279,   280,   258,
+    -8,   261,   284,   286,   281,   269,   287,   289,   290,   285,
+   282,   292,   294,   291,   295,     8,    26,    12,   205,   145,
+   250,   176,    27,    28,   177,   189,   225,   216,   178,   197,
+   231,   271,   198,   274,     0,     0,     0,   127,   126
 };
 
 static const short yycheck[] = {     1,
-     2,    38,    17,   119,    57,    58,    59,    64,    61,     5,
-    63,   214,    65,   103,   104,   229,    25,   107,     6,    39,
-    25,    41,    16,   226,    25,   145,   146,    47,   118,   149,
-    39,    25,    19,    20,    43,    23,    45,    24,    43,   159,
-    45,   255,    38,    25,    35,    29,    37,     3,     4,    33,
-     6,     7,     8,     9,    10,    11,   254,    36,    60,   257,
-    16,    43,    14,    45,    43,    17,    18,    19,    24,     3,
-     4,   161,   162,   163,   164,    90,   166,   197,   198,   199,
-   200,    37,   202,    70,    71,    72,    40,    11,    75,    39,
-   143,    45,    43,    43,    96,    45,    20,    43,    38,    45,
-   157,    25,    43,   105,    28,    29,    30,    31,    32,    33,
-    34,   113,    35,   115,    37,    43,   232,    35,   120,   121,
-   122,   123,   124,   125,   126,    12,    28,    29,    30,    31,
-    25,    26,    40,    20,   136,    35,   138,   152,    25,    21,
-    22,    28,    29,    30,    31,    32,    33,    34,     7,     8,
-     9,    10,    11,   168,   207,    25,    26,    35,    20,    26,
-    27,    35,    42,    25,    40,    24,    28,    29,    30,    31,
-    32,    33,    34,   188,    42,   190,    42,    20,    15,    42,
-    38,    42,    25,    39,   186,    28,    29,    30,    31,    32,
-    33,    34,   229,    44,    36,    20,    44,    44,    39,   214,
-    25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-    37,   226,    20,    39,    44,   217,    39,    25,   255,    41,
-    28,    29,    30,    31,    32,    33,    34,   229,    41,    36,
-    44,    43,    47,    35,    25,    39,    47,    46,    44,    38,
-    38,    35,    45,   245,    44,    35,   248,    43,    35,    38,
-    43,    46,    44,    39,    35,    26,    13,    45,    26,     0,
-     0,     4,    47,    46,    46,    14,   138,    47,     7,   168,
-   139,   142,    14,    74,   151,   188,    14,   207,   157,   212,
-   253,   156,   268,   264,    -1,    -1,    -1,    -1,    -1,    73
+     2,    55,    38,    17,   121,    65,   105,   106,   107,     3,
+     4,   110,     6,     7,     8,     9,    10,    11,    12,   148,
+   149,   150,    16,     5,   153,    23,    42,    19,    20,    21,
+    28,    49,     6,    28,    32,    33,    34,    35,    36,    37,
+    38,    40,    28,    97,    49,    44,    43,    41,    45,    40,
+    48,    65,    47,    27,    49,    52,    51,    33,    49,    61,
+    42,    37,    28,    29,    30,   164,   165,   166,   167,   168,
+   199,   200,   201,   202,   203,    13,    49,    91,    70,    71,
+    72,    73,    16,   257,    28,    23,   140,   261,    44,    49,
+    28,    25,    52,    39,    32,    33,    34,    35,    36,    37,
+    38,   161,    41,    47,    39,    49,   108,    51,    39,    39,
+    49,    41,    39,   230,   116,    47,   118,    49,    46,    51,
+   122,   123,   124,   125,   126,   127,   128,    46,    12,    15,
+    46,    17,    18,    19,   136,    21,    22,    20,    39,    23,
+    41,    46,   156,    42,    28,     3,     4,   161,    32,    33,
+    34,    35,    36,    37,    38,    23,    28,    29,   172,    40,
+    28,    29,    30,    50,    32,    33,    34,    35,    36,    37,
+    38,    23,    32,    33,    34,    35,    28,   191,    43,   193,
+    32,    33,    34,    35,    36,    37,    38,    23,   190,    28,
+    29,   227,    28,    25,    26,    46,    32,    33,    34,    35,
+    36,    37,    38,    57,    58,    59,    60,    44,    62,    40,
+    64,    41,   266,     7,     8,     9,    10,    11,    12,    29,
+    30,    50,    50,    43,    43,   227,    28,    45,    43,    45,
+    52,    40,   234,    50,    39,    49,    42,    50,    31,    50,
+    52,    48,    43,    47,    39,    42,    49,    39,    39,   251,
+    49,    28,    50,    43,    50,    43,    39,    31,    31,    48,
+    47,    47,    42,    29,    48,    50,    14,    31,    31,    50,
+    52,    29,     0,    52,     0,     4,    14,     7,   172,   103,
+   227,   140,    14,    14,   141,   155,   208,   191,   144,   160,
+   213,   260,   161,   263,    -1,    -1,    -1,    75,    74
 };
 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
-#line 3 "/usr/lib/bison.simple"
-/* This file comes from bison-1.28.  */
+#line 3 "/usr/share/bison.simple"
+/* This file comes from bison-1.27.  */
 
 /* Skeleton output parser for bison,
    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
@@ -638,7 +662,7 @@ __yy_memcpy (char *to, char *from, unsigned int count)
 #endif
 #endif
 \f
-#line 217 "/usr/lib/bison.simple"
+#line 216 "/usr/share/bison.simple"
 
 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
    into yyparse.  The argument should have type void *.
@@ -967,43 +991,43 @@ yyreduce:
   switch (yyn) {
 
 case 1:
-#line 97 "xi-grammar.y"
+#line 100 "xi-grammar.y"
 { yyval.modlist = yyvsp[0].modlist; modlist = yyvsp[0].modlist; ;
     break;}
 case 2:
-#line 101 "xi-grammar.y"
+#line 104 "xi-grammar.y"
 { yyval.modlist = 0; ;
     break;}
 case 3:
-#line 103 "xi-grammar.y"
+#line 106 "xi-grammar.y"
 { yyval.modlist = new ModuleList(lineno, yyvsp[-1].module, yyvsp[0].modlist); ;
     break;}
 case 4:
-#line 107 "xi-grammar.y"
+#line 110 "xi-grammar.y"
 { yyval.intval = 0; ;
     break;}
 case 5:
-#line 109 "xi-grammar.y"
+#line 112 "xi-grammar.y"
 { yyval.intval = 1; ;
     break;}
 case 6:
-#line 113 "xi-grammar.y"
+#line 116 "xi-grammar.y"
 { yyval.intval = 0; ;
     break;}
 case 7:
-#line 115 "xi-grammar.y"
+#line 118 "xi-grammar.y"
 { yyval.intval = 1; ;
     break;}
 case 8:
-#line 119 "xi-grammar.y"
+#line 122 "xi-grammar.y"
 { yyval.strval = yyvsp[0].strval; ;
     break;}
 case 9:
-#line 123 "xi-grammar.y"
+#line 126 "xi-grammar.y"
 { yyval.strval = yyvsp[0].strval; ;
     break;}
 case 10:
-#line 125 "xi-grammar.y"
+#line 128 "xi-grammar.y"
 {
                  char *tmp = new char[strlen(yyvsp[-3].strval)+strlen(yyvsp[0].strval)+3];
                  sprintf(tmp,"%s::%s", yyvsp[-3].strval, yyvsp[0].strval);
@@ -1011,255 +1035,247 @@ case 10:
                ;
     break;}
 case 11:
-#line 133 "xi-grammar.y"
+#line 136 "xi-grammar.y"
 { yyval.module = new Module(lineno, yyvsp[-1].strval, yyvsp[0].conslist); ;
     break;}
 case 12:
-#line 135 "xi-grammar.y"
+#line 138 "xi-grammar.y"
 { yyval.module = new Module(lineno, yyvsp[-1].strval, yyvsp[0].conslist); yyval.module->setMain(); ;
     break;}
 case 13:
-#line 139 "xi-grammar.y"
+#line 142 "xi-grammar.y"
 { yyval.conslist = 0; ;
     break;}
 case 14:
-#line 141 "xi-grammar.y"
+#line 144 "xi-grammar.y"
 { yyval.conslist = yyvsp[-2].conslist; ;
     break;}
 case 15:
-#line 145 "xi-grammar.y"
+#line 148 "xi-grammar.y"
 { yyval.conslist = 0; ;
     break;}
 case 16:
-#line 147 "xi-grammar.y"
+#line 150 "xi-grammar.y"
 { yyval.conslist = new ConstructList(lineno, yyvsp[-1].construct, yyvsp[0].conslist); ;
     break;}
 case 17:
-#line 151 "xi-grammar.y"
+#line 154 "xi-grammar.y"
 { if(yyvsp[-2].conslist) yyvsp[-2].conslist->setExtern(yyvsp[-4].intval); yyval.construct = yyvsp[-2].conslist; ;
     break;}
 case 18:
-#line 153 "xi-grammar.y"
+#line 156 "xi-grammar.y"
 { yyvsp[0].module->setExtern(yyvsp[-1].intval); yyval.construct = yyvsp[0].module; ;
     break;}
 case 19:
-#line 155 "xi-grammar.y"
+#line 158 "xi-grammar.y"
 { yyvsp[-1].readonly->setExtern(yyvsp[-2].intval); yyval.construct = yyvsp[-1].readonly; ;
     break;}
 case 20:
-#line 157 "xi-grammar.y"
+#line 160 "xi-grammar.y"
 { yyvsp[-1].readonly->setExtern(yyvsp[-2].intval); yyval.construct = yyvsp[-1].readonly; ;
     break;}
 case 21:
-#line 159 "xi-grammar.y"
+#line 162 "xi-grammar.y"
 { yyvsp[-1].message->setExtern(yyvsp[-2].intval); yyval.construct = yyvsp[-1].message; ;
     break;}
 case 22:
-#line 161 "xi-grammar.y"
+#line 164 "xi-grammar.y"
 { yyvsp[0].chare->setExtern(yyvsp[-1].intval); yyval.construct = yyvsp[0].chare; ;
     break;}
 case 23:
-#line 163 "xi-grammar.y"
+#line 166 "xi-grammar.y"
 { yyvsp[0].chare->setExtern(yyvsp[-1].intval); yyval.construct = yyvsp[0].chare; ;
     break;}
 case 24:
-#line 165 "xi-grammar.y"
+#line 168 "xi-grammar.y"
 { yyvsp[0].chare->setExtern(yyvsp[-1].intval); yyval.construct = yyvsp[0].chare; ;
     break;}
 case 25:
-#line 167 "xi-grammar.y"
+#line 170 "xi-grammar.y"
 { yyvsp[0].chare->setExtern(yyvsp[-1].intval); yyval.construct = yyvsp[0].chare; ;
     break;}
 case 26:
-#line 169 "xi-grammar.y"
+#line 172 "xi-grammar.y"
 { yyvsp[0].templat->setExtern(yyvsp[-1].intval); yyval.construct = yyvsp[0].templat; ;
     break;}
 case 27:
-#line 173 "xi-grammar.y"
+#line 176 "xi-grammar.y"
 { yyval.tparam = new TParamType(yyvsp[0].type); ;
     break;}
 case 28:
-#line 175 "xi-grammar.y"
+#line 178 "xi-grammar.y"
 { yyval.tparam = new TParamVal(yyvsp[0].strval); ;
     break;}
 case 29:
-#line 177 "xi-grammar.y"
+#line 180 "xi-grammar.y"
 { yyval.tparam = new TParamVal(yyvsp[0].strval); ;
     break;}
 case 30:
-#line 181 "xi-grammar.y"
+#line 184 "xi-grammar.y"
 { yyval.tparlist = new TParamList(yyvsp[0].tparam); ;
     break;}
 case 31:
-#line 183 "xi-grammar.y"
+#line 186 "xi-grammar.y"
 { yyval.tparlist = new TParamList(yyvsp[-2].tparam, yyvsp[0].tparlist); ;
     break;}
 case 32:
-#line 187 "xi-grammar.y"
+#line 190 "xi-grammar.y"
 { yyval.tparlist = 0; ;
     break;}
 case 33:
-#line 189 "xi-grammar.y"
+#line 192 "xi-grammar.y"
 { yyval.tparlist = yyvsp[0].tparlist; ;
     break;}
 case 34:
-#line 193 "xi-grammar.y"
+#line 196 "xi-grammar.y"
 { yyval.tparlist = 0; ;
     break;}
 case 35:
-#line 195 "xi-grammar.y"
+#line 198 "xi-grammar.y"
 { yyval.tparlist = yyvsp[-1].tparlist; ;
     break;}
 case 36:
-#line 199 "xi-grammar.y"
+#line 202 "xi-grammar.y"
 { yyval.type = new BuiltinType("int"); ;
     break;}
 case 37:
-#line 201 "xi-grammar.y"
+#line 204 "xi-grammar.y"
 { yyval.type = new BuiltinType("long"); ;
     break;}
 case 38:
-#line 203 "xi-grammar.y"
+#line 206 "xi-grammar.y"
 { yyval.type = new BuiltinType("short"); ;
     break;}
 case 39:
-#line 205 "xi-grammar.y"
+#line 208 "xi-grammar.y"
 { yyval.type = new BuiltinType("char"); ;
     break;}
 case 40:
-#line 207 "xi-grammar.y"
+#line 210 "xi-grammar.y"
 { yyval.type = new BuiltinType("unsigned int"); ;
     break;}
 case 41:
-#line 209 "xi-grammar.y"
-{ yyval.type = new BuiltinType("long"); ;
+#line 212 "xi-grammar.y"
+{ yyval.type = new BuiltinType("unsigned long"); ;
     break;}
 case 42:
-#line 211 "xi-grammar.y"
-{ yyval.type = new BuiltinType("short"); ;
+#line 214 "xi-grammar.y"
+{ yyval.type = new BuiltinType("unsigned short"); ;
     break;}
 case 43:
-#line 213 "xi-grammar.y"
-{ yyval.type = new BuiltinType("char"); ;
+#line 216 "xi-grammar.y"
+{ yyval.type = new BuiltinType("unsigned char"); ;
     break;}
 case 44:
-#line 215 "xi-grammar.y"
+#line 218 "xi-grammar.y"
 { yyval.type = new BuiltinType("long long"); ;
     break;}
 case 45:
-#line 217 "xi-grammar.y"
+#line 220 "xi-grammar.y"
 { yyval.type = new BuiltinType("float"); ;
     break;}
 case 46:
-#line 219 "xi-grammar.y"
+#line 222 "xi-grammar.y"
 { yyval.type = new BuiltinType("double"); ;
     break;}
 case 47:
-#line 221 "xi-grammar.y"
+#line 224 "xi-grammar.y"
 { yyval.type = new BuiltinType("long double"); ;
     break;}
 case 48:
-#line 223 "xi-grammar.y"
+#line 226 "xi-grammar.y"
 { yyval.type = new BuiltinType("void"); ;
     break;}
 case 49:
-#line 227 "xi-grammar.y"
-{ yyval.ntype = new NamedType(yyvsp[-1].strval, yyvsp[0].tparlist); ;
+#line 229 "xi-grammar.y"
+{ yyval.ntype = new NamedType(yyvsp[-1].strval,yyvsp[0].tparlist); ;
     break;}
 case 50:
-#line 231 "xi-grammar.y"
-{ yyval.type = yyvsp[0].type; ;
+#line 230 "xi-grammar.y"
+{ yyval.ntype = new NamedType(yyvsp[-1].strval,yyvsp[0].tparlist); ;
     break;}
 case 51:
 #line 233 "xi-grammar.y"
-{ yyval.type = yyvsp[0].ntype; ;
+{ yyval.type = yyvsp[0].type; ;
     break;}
 case 52:
-#line 237 "xi-grammar.y"
-{ yyval.ptype = new PtrType(yyvsp[-1].type); ;
+#line 235 "xi-grammar.y"
+{ yyval.type = yyvsp[0].ntype; ;
     break;}
 case 53:
-#line 241 "xi-grammar.y"
-{ yyvsp[-1].ptype->indirect(); yyval.ptype = yyvsp[-1].ptype; ;
+#line 239 "xi-grammar.y"
+{ yyval.ptype = new PtrType(yyvsp[-1].type); ;
     break;}
 case 54:
 #line 243 "xi-grammar.y"
 { yyvsp[-1].ptype->indirect(); yyval.ptype = yyvsp[-1].ptype; ;
     break;}
 case 55:
-#line 247 "xi-grammar.y"
-{ yyval.val = new Value(yyvsp[0].strval); ;
+#line 245 "xi-grammar.y"
+{ yyvsp[-1].ptype->indirect(); yyval.ptype = yyvsp[-1].ptype; ;
     break;}
 case 56:
 #line 249 "xi-grammar.y"
-{ yyval.val = new Value(yyvsp[0].strval); ;
+{ yyval.ftype = new FuncType(yyvsp[-7].type, yyvsp[-4].strval, yyvsp[-1].plist); ;
     break;}
 case 57:
 #line 253 "xi-grammar.y"
-{ yyval.type = new ArrayType(yyvsp[-3].type, yyvsp[-1].val); ;
+{ yyval.type = yyvsp[0].type; ;
     break;}
 case 58:
-#line 257 "xi-grammar.y"
-{ yyval.ftype = new FuncType(yyvsp[-7].type, yyvsp[-4].strval, yyvsp[-1].typelist); ;
+#line 255 "xi-grammar.y"
+{ yyval.type = yyvsp[0].ptype; ;
     break;}
 case 59:
-#line 261 "xi-grammar.y"
-{ yyval.type = yyvsp[0].type; ;
+#line 257 "xi-grammar.y"
+{ yyval.type = yyvsp[0].ptype; ;
     break;}
 case 60:
-#line 263 "xi-grammar.y"
-{ yyval.type = (Type*) yyvsp[0].ptype; ;
+#line 259 "xi-grammar.y"
+{ yyval.type = yyvsp[0].ftype; ;
     break;}
 case 61:
-#line 265 "xi-grammar.y"
-{ yyval.type = (Type*) yyvsp[0].ptype; ;
+#line 261 "xi-grammar.y"
+{ yyval.type = new ArrayType(yyvsp[-3].type,yyvsp[-1].val); ;
     break;}
 case 62:
-#line 267 "xi-grammar.y"
-{ yyval.type = yyvsp[0].type; ;
+#line 263 "xi-grammar.y"
+{ yyval.type = new ReferenceType(yyvsp[-1].type); ;
     break;}
 case 63:
 #line 269 "xi-grammar.y"
-{ yyval.type = yyvsp[0].ftype; ;
+{ yyval.val = new Value(yyvsp[0].strval); ;
     break;}
 case 64:
-#line 273 "xi-grammar.y"
-{ yyval.typelist = 0; ;
+#line 271 "xi-grammar.y"
+{ yyval.val = new Value(yyvsp[0].strval); ;
     break;}
 case 65:
 #line 275 "xi-grammar.y"
-{ yyval.typelist = new TypeList(yyvsp[0].type); ;
+{ yyval.val = yyvsp[-1].val; ;
     break;}
 case 66:
-#line 277 "xi-grammar.y"
-{ yyval.typelist = new TypeList(yyvsp[-2].type, yyvsp[0].typelist); ;
+#line 279 "xi-grammar.y"
+{ yyval.vallist = 0; ;
     break;}
 case 67:
 #line 281 "xi-grammar.y"
-{ yyval.val = yyvsp[-1].val; ;
+{ yyval.vallist = new ValueList(yyvsp[-1].val, yyvsp[0].vallist); ;
     break;}
 case 68:
 #line 285 "xi-grammar.y"
-{ yyval.vallist = 0; ;
+{ yyval.readonly = new Readonly(lineno, yyvsp[-2].type, yyvsp[-1].strval, yyvsp[0].vallist); ;
     break;}
 case 69:
-#line 287 "xi-grammar.y"
-{ yyval.vallist = new ValueList(yyvsp[-1].val, yyvsp[0].vallist); ;
+#line 289 "xi-grammar.y"
+{ yyval.readonly = new Readonly(lineno, yyvsp[-2].type, yyvsp[0].strval, 0, 1); ;
     break;}
 case 70:
-#line 291 "xi-grammar.y"
-{ yyval.readonly = new Readonly(lineno, yyvsp[-2].type, yyvsp[-1].strval, yyvsp[0].vallist); ;
+#line 293 "xi-grammar.y"
+{ yyval.intval = 0; ;
     break;}
 case 71:
 #line 295 "xi-grammar.y"
-{ yyval.readonly = new Readonly(lineno, yyvsp[-2].type, yyvsp[0].strval, 0, 1); ;
-    break;}
-case 72:
-#line 299 "xi-grammar.y"
-{ yyval.intval = 0; ;
-    break;}
-case 73:
-#line 301 "xi-grammar.y"
 { 
                  /*
                  printf("Warning: Message attributes are being phased out.\n");
@@ -1268,311 +1284,377 @@ case 73:
                  yyval.intval = yyvsp[-1].intval; 
                ;
     break;}
+case 72:
+#line 305 "xi-grammar.y"
+{ yyval.intval = yyvsp[0].intval; ;
+    break;}
+case 73:
+#line 307 "xi-grammar.y"
+{ yyval.intval = yyvsp[-2].intval | yyvsp[0].intval; ;
+    break;}
 case 74:
 #line 311 "xi-grammar.y"
-{ yyval.intval = yyvsp[0].intval; ;
+{ yyval.intval = 0; ;
     break;}
 case 75:
 #line 313 "xi-grammar.y"
-{ yyval.intval = yyvsp[-2].intval | yyvsp[0].intval; ;
+{ yyval.intval = 0; ;
     break;}
 case 76:
 #line 317 "xi-grammar.y"
-{ yyval.intval = 0; ;
+{ yyval.cattr = 0; ;
     break;}
 case 77:
 #line 319 "xi-grammar.y"
-{ yyval.intval = 0; ;
+{ yyval.cattr = yyvsp[-1].cattr; ;
     break;}
 case 78:
 #line 323 "xi-grammar.y"
-{ yyval.intval = 0; ;
+{ yyval.cattr = yyvsp[0].cattr; ;
     break;}
 case 79:
 #line 325 "xi-grammar.y"
-{ yyval.intval = yyvsp[-1].intval; ;
+{ yyval.cattr = yyvsp[-2].cattr | yyvsp[0].cattr; ;
     break;}
 case 80:
 #line 329 "xi-grammar.y"
-{ yyval.intval = yyvsp[0].intval; ;
+{ yyval.cattr = Chare::CMIGRATABLE; ;
     break;}
 case 81:
-#line 331 "xi-grammar.y"
-{ yyval.intval = yyvsp[-2].intval | yyvsp[0].intval; ;
+#line 333 "xi-grammar.y"
+{ yyval.mv = new MsgVar(yyvsp[-4].type, yyvsp[-3].strval); ;
     break;}
 case 82:
-#line 335 "xi-grammar.y"
-{ yyval.intval = 0x01; ;
+#line 337 "xi-grammar.y"
+{ yyval.mvlist = new MsgVarList(yyvsp[0].mv); ;
     break;}
 case 83:
 #line 339 "xi-grammar.y"
-{ yyval.mv = new MsgVar(yyvsp[-4].type, yyvsp[-3].strval); ;
+{ yyval.mvlist = new MsgVarList(yyvsp[-1].mv, yyvsp[0].mvlist); ;
     break;}
 case 84:
 #line 343 "xi-grammar.y"
-{ yyval.mvlist = new MsgVarList(yyvsp[0].mv); ;
+{ yyval.message = new Message(lineno, yyvsp[0].ntype); ;
     break;}
 case 85:
 #line 345 "xi-grammar.y"
-{ yyval.mvlist = new MsgVarList(yyvsp[-1].mv, yyvsp[0].mvlist); ;
+{ yyval.message = new Message(lineno, yyvsp[-3].ntype, yyvsp[-1].mvlist); ;
     break;}
 case 86:
 #line 349 "xi-grammar.y"
-{ yyval.message = new Message(lineno, yyvsp[0].ntype); ;
+{ yyval.typelist = 0; ;
     break;}
 case 87:
 #line 351 "xi-grammar.y"
-{ yyval.message = new Message(lineno, yyvsp[-3].ntype, yyvsp[-1].typelist); ;
+{ yyval.typelist = yyvsp[0].typelist; ;
     break;}
 case 88:
-#line 353 "xi-grammar.y"
-{ yyval.message = new Message(lineno, yyvsp[-3].ntype, 0, yyvsp[-1].mvlist); ;
+#line 355 "xi-grammar.y"
+{ yyval.typelist = new TypeList(yyvsp[0].ntype); ;
     break;}
 case 89:
 #line 357 "xi-grammar.y"
-{ yyval.typelist = 0; ;
+{ yyval.typelist = new TypeList(yyvsp[-2].ntype, yyvsp[0].typelist); ;
     break;}
 case 90:
-#line 359 "xi-grammar.y"
-{ yyval.typelist = yyvsp[0].typelist; ;
+#line 361 "xi-grammar.y"
+{ yyval.chare = new Chare(lineno, yyvsp[-3].cattr, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
     break;}
 case 91:
 #line 363 "xi-grammar.y"
-{ yyval.typelist = new TypeList(yyvsp[0].ntype); ;
+{ yyval.chare = new MainChare(lineno, yyvsp[-3].cattr, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
     break;}
 case 92:
-#line 365 "xi-grammar.y"
-{ yyval.typelist = new TypeList(yyvsp[-2].ntype, yyvsp[0].typelist); ;
+#line 367 "xi-grammar.y"
+{ yyval.chare = new Group(lineno, yyvsp[-3].cattr, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
     break;}
 case 93:
-#line 369 "xi-grammar.y"
-{ yyval.chare = new Chare(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
-    break;}
-case 94:
 #line 371 "xi-grammar.y"
-{ yyval.chare = new MainChare(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
+{ yyval.chare = new NodeGroup(lineno, yyvsp[-3].cattr, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
     break;}
-case 95:
+case 94:
 #line 375 "xi-grammar.y"
-{ yyval.chare = new Group(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
-    break;}
-case 96:
-#line 379 "xi-grammar.y"
-{ yyval.chare = new NodeGroup(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
-    break;}
-case 97:
-#line 383 "xi-grammar.y"
 {/*Stupid special case for [1D] indices*/
                        char *buf=new char[40];
                        sprintf(buf,"%sD",yyvsp[-2].strval);
                        yyval.ntype = new NamedType(buf); 
                ;
     break;}
-case 98:
-#line 389 "xi-grammar.y"
+case 95:
+#line 381 "xi-grammar.y"
 { yyval.ntype = new NamedType(yyvsp[-1].strval); ;
     break;}
+case 96:
+#line 385 "xi-grammar.y"
+{ yyval.chare = new Array(lineno, 0, yyvsp[-3].ntype, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
+    break;}
+case 97:
+#line 389 "xi-grammar.y"
+{ yyval.chare = new Chare(lineno, yyvsp[-3].cattr, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist);;
+    break;}
+case 98:
+#line 391 "xi-grammar.y"
+{ yyval.chare = new MainChare(lineno, yyvsp[-3].cattr, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
+    break;}
 case 99:
-#line 393 "xi-grammar.y"
-{ yyval.chare = new Array(lineno, yyvsp[-3].ntype, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
+#line 395 "xi-grammar.y"
+{ yyval.chare = new Group(lineno, yyvsp[-3].cattr, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
     break;}
 case 100:
-#line 397 "xi-grammar.y"
-{ yyval.chare = new Chare(lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval);;
+#line 399 "xi-grammar.y"
+{ yyval.chare = new NodeGroup( lineno, yyvsp[-3].cattr, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
     break;}
 case 101:
-#line 399 "xi-grammar.y"
-{ yyval.chare = new MainChare(lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
+#line 403 "xi-grammar.y"
+{ yyval.chare = new Array( lineno, 0, yyvsp[-3].ntype, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
     break;}
 case 102:
-#line 403 "xi-grammar.y"
-{ yyval.chare = new Group(lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
+#line 407 "xi-grammar.y"
+{ yyval.message = new Message(lineno, new NamedType(yyvsp[-1].strval)); ;
     break;}
 case 103:
-#line 407 "xi-grammar.y"
-{ yyval.chare = new NodeGroup( lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
+#line 411 "xi-grammar.y"
+{ yyval.type = 0; ;
     break;}
 case 104:
-#line 411 "xi-grammar.y"
-{ yyval.chare = new Array( lineno, yyvsp[-3].ntype, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
+#line 413 "xi-grammar.y"
+{ yyval.type = yyvsp[0].type; ;
     break;}
 case 105:
-#line 415 "xi-grammar.y"
-{ yyval.message = new Message(lineno, new NamedType(yyvsp[-1].strval)); ;
+#line 417 "xi-grammar.y"
+{ yyval.strval = 0; ;
     break;}
 case 106:
 #line 419 "xi-grammar.y"
-{ yyval.type = 0; ;
+{ yyval.strval = yyvsp[0].strval; ;
     break;}
 case 107:
 #line 421 "xi-grammar.y"
-{ yyval.type = yyvsp[0].type; ;
+{ yyval.strval = yyvsp[0].strval; ;
     break;}
 case 108:
 #line 425 "xi-grammar.y"
-{ yyval.strval = 0; ;
+{ yyval.tvar = new TType(new NamedType(yyvsp[-1].strval), yyvsp[0].type); ;
     break;}
 case 109:
 #line 427 "xi-grammar.y"
-{ yyval.strval = yyvsp[0].strval; ;
+{ yyval.tvar = new TFunc(yyvsp[-1].ftype, yyvsp[0].strval); ;
     break;}
 case 110:
 #line 429 "xi-grammar.y"
-{ yyval.strval = yyvsp[0].strval; ;
+{ yyval.tvar = new TName(yyvsp[-2].type, yyvsp[-1].strval, yyvsp[0].strval); ;
     break;}
 case 111:
 #line 433 "xi-grammar.y"
-{ yyval.tvar = new TType(new NamedType(yyvsp[-1].strval), yyvsp[0].type); ;
+{ yyval.tvarlist = new TVarList(yyvsp[0].tvar); ;
     break;}
 case 112:
 #line 435 "xi-grammar.y"
-{ yyval.tvar = new TFunc(yyvsp[-1].ftype, yyvsp[0].strval); ;
+{ yyval.tvarlist = new TVarList(yyvsp[-2].tvar, yyvsp[0].tvarlist); ;
     break;}
 case 113:
-#line 437 "xi-grammar.y"
-{ yyval.tvar = new TName(yyvsp[-2].type, yyvsp[-1].strval, yyvsp[0].strval); ;
+#line 439 "xi-grammar.y"
+{ yyval.tvarlist = yyvsp[-1].tvarlist; ;
     break;}
 case 114:
-#line 441 "xi-grammar.y"
-{ yyval.tvarlist = new TVarList(yyvsp[0].tvar); ;
+#line 443 "xi-grammar.y"
+{ yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
     break;}
 case 115:
-#line 443 "xi-grammar.y"
-{ yyval.tvarlist = new TVarList(yyvsp[-2].tvar, yyvsp[0].tvarlist); ;
+#line 445 "xi-grammar.y"
+{ yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
     break;}
 case 116:
 #line 447 "xi-grammar.y"
-{ yyval.tvarlist = yyvsp[-1].tvarlist; ;
+{ yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
     break;}
 case 117:
-#line 451 "xi-grammar.y"
+#line 449 "xi-grammar.y"
 { yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
     break;}
 case 118:
-#line 453 "xi-grammar.y"
-{ yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
+#line 451 "xi-grammar.y"
+{ yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].message); yyvsp[0].message->setTemplate(yyval.templat); ;
     break;}
 case 119:
 #line 455 "xi-grammar.y"
-{ yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
+{ yyval.mbrlist = 0; ;
     break;}
 case 120:
 #line 457 "xi-grammar.y"
-{ yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
+{ yyval.mbrlist = yyvsp[-2].mbrlist; ;
     break;}
 case 121:
-#line 459 "xi-grammar.y"
-{ yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].message); yyvsp[0].message->setTemplate(yyval.templat); ;
+#line 461 "xi-grammar.y"
+{ yyval.mbrlist = 0; ;
     break;}
 case 122:
 #line 463 "xi-grammar.y"
-{ yyval.mbrlist = 0; ;
+{ yyval.mbrlist = new MemberList(yyvsp[-1].member, yyvsp[0].mbrlist); ;
     break;}
 case 123:
-#line 465 "xi-grammar.y"
-{ yyval.mbrlist = yyvsp[-2].mbrlist; ;
+#line 467 "xi-grammar.y"
+{ yyval.member = yyvsp[-1].entry; ;
     break;}
 case 124:
 #line 469 "xi-grammar.y"
-{ yyval.mbrlist = 0; ;
+{ yyval.member = yyvsp[-1].readonly; ;
     break;}
 case 125:
 #line 471 "xi-grammar.y"
-{ yyval.mbrlist = new MemberList(yyvsp[-1].member, yyvsp[0].mbrlist); ;
+{ yyval.member = yyvsp[-1].readonly; ;
     break;}
 case 126:
 #line 475 "xi-grammar.y"
-{ yyval.member = yyvsp[-1].entry; ;
+{ yyval.entry = new Entry(lineno, yyvsp[-5].intval|yyvsp[-1].intval, yyvsp[-4].type, yyvsp[-3].strval, yyvsp[-2].plist, yyvsp[0].val); ;
     break;}
 case 127:
 #line 477 "xi-grammar.y"
-{ yyval.member = yyvsp[-1].readonly; ;
+{ yyval.entry = new Entry(lineno, yyvsp[-2].intval,     0, yyvsp[-1].strval, yyvsp[0].plist,  0); ;
     break;}
 case 128:
-#line 479 "xi-grammar.y"
-{ yyval.member = yyvsp[-1].readonly; ;
+#line 481 "xi-grammar.y"
+{ yyval.type = new BuiltinType("void"); ;
     break;}
 case 129:
 #line 483 "xi-grammar.y"
-{ yyval.entry = new Entry(lineno, yyvsp[-5].intval|yyvsp[-1].intval, new BuiltinType("void"), yyvsp[-3].strval, yyvsp[-2].rtype, yyvsp[0].val); ;
+{ yyval.type = yyvsp[0].ptype; ;
     break;}
 case 130:
-#line 485 "xi-grammar.y"
-{ yyval.entry = new Entry(lineno, yyvsp[-5].intval|yyvsp[-1].intval, yyvsp[-4].ptype, yyvsp[-3].strval, yyvsp[-2].rtype, yyvsp[0].val); ;
+#line 487 "xi-grammar.y"
+{ yyval.intval = 0; ;
     break;}
 case 131:
-#line 487 "xi-grammar.y"
-{ yyval.entry = new Entry(lineno, yyvsp[-2].intval, 0, yyvsp[-1].strval, yyvsp[0].rtype, 0); ;
+#line 489 "xi-grammar.y"
+{ yyval.intval = yyvsp[-1].intval; ;
     break;}
 case 132:
-#line 491 "xi-grammar.y"
-{ yyval.intval = 0; ;
+#line 493 "xi-grammar.y"
+{ yyval.intval = yyvsp[0].intval; ;
     break;}
 case 133:
-#line 493 "xi-grammar.y"
-{ yyval.intval = yyvsp[-1].intval; ;
+#line 495 "xi-grammar.y"
+{ yyval.intval = yyvsp[-2].intval | yyvsp[0].intval; ;
     break;}
 case 134:
-#line 497 "xi-grammar.y"
-{ yyval.intval = yyvsp[0].intval; ;
+#line 499 "xi-grammar.y"
+{ yyval.intval = STHREADED; ;
     break;}
 case 135:
-#line 499 "xi-grammar.y"
-{ yyval.intval = yyvsp[-2].intval | yyvsp[0].intval; ;
+#line 501 "xi-grammar.y"
+{ yyval.intval = SSYNC; ;
     break;}
 case 136:
 #line 503 "xi-grammar.y"
-{ yyval.intval = STHREADED; ;
+{ yyval.intval = SLOCKED; ;
     break;}
 case 137:
 #line 505 "xi-grammar.y"
-{ yyval.intval = SSYNC; ;
+{ yyval.intval = SVIRTUAL; ;
     break;}
 case 138:
 #line 507 "xi-grammar.y"
-{ yyval.intval = SLOCKED; ;
+{ yyval.intval = SCREATEHERE; ;
     break;}
 case 139:
 #line 509 "xi-grammar.y"
-{ yyval.intval = SVIRTUAL; ;
+{ yyval.intval = SCREATEHOME; ;
     break;}
 case 140:
 #line 513 "xi-grammar.y"
-{ yyval.rtype = 0; ;
+{ yyval.val = new Value(yyvsp[0].strval); ;
     break;}
 case 141:
 #line 515 "xi-grammar.y"
-{ yyval.rtype = new BuiltinType("void"); ;
+{ yyval.val = new Value(yyvsp[0].strval); ;
     break;}
 case 142:
 #line 517 "xi-grammar.y"
-{ yyval.rtype = yyvsp[0].ptype; ;
+{ yyval.val = new Value(yyvsp[0].strval); ;
     break;}
 case 143:
 #line 521 "xi-grammar.y"
-{ yyval.rtype = yyvsp[-1].rtype; ;
+{ yyval.strval = yyvsp[0].strval; ;
     break;}
 case 144:
-#line 525 "xi-grammar.y"
-{ yyval.val = 0; ;
+#line 523 "xi-grammar.y"
+{  /*Returned only when in_bracket*/
+                       char *tmp = new char[strlen(yyvsp[-4].strval)+strlen(yyvsp[-2].strval)+strlen(yyvsp[0].strval)+3];
+                       sprintf(tmp,"%s[%s]%s", yyvsp[-4].strval, yyvsp[-2].strval, yyvsp[0].strval);
+                       yyval.strval = tmp;
+               ;
     break;}
 case 145:
-#line 527 "xi-grammar.y"
-{ yyval.val = new Value(yyvsp[0].strval); ;
+#line 529 "xi-grammar.y"
+{ /*Returned only when in_braces*/
+                       char *tmp = new char[strlen(yyvsp[-4].strval)+strlen(yyvsp[-2].strval)+strlen(yyvsp[0].strval)+3];
+                       sprintf(tmp,"%s{%s}%s", yyvsp[-4].strval, yyvsp[-2].strval, yyvsp[0].strval);
+                       yyval.strval = tmp;
+               ;
     break;}
 case 146:
-#line 531 "xi-grammar.y"
-{ yyval.intval = 0; ;
+#line 537 "xi-grammar.y"
+{  /*Start grabbing CPROGRAM segments*/
+                       in_bracket=1;
+                       yyval.pname = new Parameter(lineno, yyvsp[-2].type,yyvsp[-1].strval);
+               ;
     break;}
 case 147:
-#line 533 "xi-grammar.y"
-{ if(strcmp(yyvsp[0].strval, "0")) { yyerror("expected 0"); exit(1); }
+#line 544 "xi-grammar.y"
+{ yyval.pname = new Parameter(lineno, yyvsp[0].type);;
+    break;}
+case 148:
+#line 546 "xi-grammar.y"
+{ yyval.pname = new Parameter(lineno, yyvsp[-1].type,yyvsp[0].strval);;
+    break;}
+case 149:
+#line 548 "xi-grammar.y"
+{ yyval.pname = new Parameter(lineno, yyvsp[-3].type,yyvsp[-2].strval,0,yyvsp[0].val);;
+    break;}
+case 150:
+#line 550 "xi-grammar.y"
+{ /*Stop grabbing CPROGRAM segments*/
+                       in_bracket=0;
+                       yyval.pname = new Parameter(lineno, yyvsp[-2].pname->getType(), yyvsp[-2].pname->getName() ,yyvsp[-1].strval);
+               ;
+    break;}
+case 151:
+#line 557 "xi-grammar.y"
+{ yyval.plist = new ParamList(yyvsp[0].pname); ;
+    break;}
+case 152:
+#line 559 "xi-grammar.y"
+{ yyval.plist = new ParamList(yyvsp[-2].pname,yyvsp[0].plist); ;
+    break;}
+case 153:
+#line 563 "xi-grammar.y"
+{ yyval.plist = yyvsp[-1].plist; ;
+    break;}
+case 154:
+#line 565 "xi-grammar.y"
+{ yyval.plist = 0; ;
+    break;}
+case 155:
+#line 569 "xi-grammar.y"
+{ yyval.val = 0; ;
+    break;}
+case 156:
+#line 571 "xi-grammar.y"
+{ yyval.val = new Value(yyvsp[0].strval); ;
+    break;}
+case 157:
+#line 575 "xi-grammar.y"
+{ yyval.intval = 0; ;
+    break;}
+case 158:
+#line 577 "xi-grammar.y"
+{ if(strcmp(yyvsp[0].strval, "0")) { yyerror("pure virtual must '=0'"); exit(1); }
                  yyval.intval = SPURE; 
                ;
     break;}
 }
    /* the action file gets copied in in place of this dollarsign */
-#line 543 "/usr/lib/bison.simple"
+#line 542 "/usr/share/bison.simple"
 \f
   yyvsp -= yylen;
   yyssp -= yylen;
@@ -1792,10 +1874,10 @@ yyerrhandle:
     }
   return 1;
 }
-#line 537 "xi-grammar.y"
+#line 581 "xi-grammar.y"
 
 void yyerror(const char *mesg)
 {
-  cout << "Syntax error at line " << lineno << ": " << mesg << endl;
+  cout << cur_file<<":"<<lineno<<": Charmxi syntax error> " << mesg << endl;
   // return 0;
 }
index eee1976d766f0e2decfcd7174eaf7b54aefd8de6..691349b732d9fe49e65342ed42b1ff1a0d5abf5c 100644 (file)
@@ -6,7 +6,6 @@ typedef union {
   TParam *tparam;
   TParamList *tparlist;
   Type *type;
-  EnType *rtype;
   PtrType *ptype;
   NamedType *ntype;
   FuncType *ftype;
@@ -14,6 +13,8 @@ typedef union {
   Message *message;
   Chare *chare;
   Entry *entry;
+  Parameter *pname;
+  ParamList *plist;
   Template *templat;
   TypeList *typelist;
   MemberList *mbrlist;
@@ -26,39 +27,44 @@ typedef union {
   MsgVarList *mvlist;
   char *strval;
   int intval;
+  Chare::attrib_t cattr;
 } YYSTYPE;
 #define        MODULE  257
 #define        MAINMODULE      258
 #define        EXTERN  259
 #define        READONLY        260
 #define        CHARE   261
-#define        GROUP   262
-#define        NODEGROUP       263
-#define        ARRAY   264
-#define        MESSAGE 265
-#define        CLASS   266
-#define        STACKSIZE       267
-#define        THREADED        268
-#define        MIGRATABLE      269
+#define        MAINCHARE       262
+#define        GROUP   263
+#define        NODEGROUP       264
+#define        ARRAY   265
+#define        MESSAGE 266
+#define        CLASS   267
+#define        STACKSIZE       268
+#define        THREADED        269
 #define        TEMPLATE        270
 #define        SYNC    271
 #define        EXCLUSIVE       272
 #define        VIRTUAL 273
-#define        VOID    274
-#define        PACKED  275
-#define        VARSIZE 276
-#define        ENTRY   277
-#define        MAINCHARE       278
-#define        IDENT   279
-#define        NUMBER  280
-#define        LITERAL 281
-#define        INT     282
-#define        LONG    283
-#define        SHORT   284
-#define        CHAR    285
-#define        FLOAT   286
-#define        DOUBLE  287
-#define        UNSIGNED        288
+#define        MIGRATABLE      274
+#define        CREATEHERE      275
+#define        CREATEHOME      276
+#define        VOID    277
+#define        CONST   278
+#define        PACKED  279
+#define        VARSIZE 280
+#define        ENTRY   281
+#define        IDENT   282
+#define        NUMBER  283
+#define        LITERAL 284
+#define        CPROGRAM        285
+#define        INT     286
+#define        LONG    287
+#define        SHORT   288
+#define        CHAR    289
+#define        FLOAT   290
+#define        DOUBLE  291
+#define        UNSIGNED        292
 
 
 extern YYSTYPE yylval;
index 387cf543ab5666fb60fef0e1c94f19c7fde95f4c..57de2fba847712c13d64c08569db1ecbdb293a20 100644 (file)
@@ -5,6 +5,7 @@
 extern int yylex (void) ;
 void yyerror(const char *);
 extern unsigned int lineno;
+extern int in_bracket,in_braces;
 ModuleList *modlist;
 
 %}
@@ -17,7 +18,6 @@ ModuleList *modlist;
   TParam *tparam;
   TParamList *tparlist;
   Type *type;
-  EnType *rtype;
   PtrType *ptype;
   NamedType *ntype;
   FuncType *ftype;
@@ -25,6 +25,8 @@ ModuleList *modlist;
   Message *message;
   Chare *chare;
   Entry *entry;
+  Parameter *pname;
+  ParamList *plist;
   Template *templat;
   TypeList *typelist;
   MemberList *mbrlist;
@@ -37,56 +39,57 @@ ModuleList *modlist;
   MsgVarList *mvlist;
   char *strval;
   int intval;
+  Chare::attrib_t cattr;
 }
 
 %token MODULE
 %token MAINMODULE
 %token EXTERN
 %token READONLY
-%token <intval> CHARE GROUP NODEGROUP ARRAY
+%token <intval> CHARE MAINCHARE GROUP NODEGROUP ARRAY
 %token MESSAGE
 %token CLASS
 %token STACKSIZE
 %token THREADED
-%token MIGRATABLE
 %token TEMPLATE
-%token SYNC EXCLUSIVE VIRTUAL
+%token SYNC EXCLUSIVE VIRTUAL MIGRATABLE CREATEHERE CREATEHOME
 %token VOID
+%token CONST
 %token PACKED
 %token VARSIZE
 %token ENTRY
-%token <intval> MAINCHARE
-%token <strval> IDENT NUMBER LITERAL
+%token <strval> IDENT NUMBER LITERAL CPROGRAM
 %token <intval> INT LONG SHORT CHAR FLOAT DOUBLE UNSIGNED
 
 %type <modlist>                ModuleEList File
 %type <module>         Module
 %type <conslist>       ConstructEList ConstructList
 %type <construct>      Construct
-%type <strval>         Name QualName OptNameInit
+%type <strval>         Name QualName CCode OptNameInit
 %type <val>            OptStackSize
 %type <intval>         OptExtern OptSemiColon MAttribs MAttribList MAttrib
 %type <intval>         EAttribs EAttribList EAttrib OptPure
-%type <intval>         CAttribs CAttribList CAttrib
+%type <cattr>          CAttribs CAttribList CAttrib
 %type <tparam>         TParam
 %type <tparlist>       TParamList TParamEList OptTParams
-%type <type>           Type SimpleType OptTypeInit 
-%type <rtype>          OptType EParam
-%type <type>           BuiltinType ArrayType
+%type <type>           Type SimpleType OptTypeInit EReturn
+%type <type>           BuiltinType
 %type <ftype>          FuncType
-%type <ntype>          NamedType ArrayIndexType
+%type <ntype>          NamedType QualNamedType ArrayIndexType
 %type <ptype>          PtrType OnePtrType
 %type <readonly>       Readonly ReadonlyMsg
 %type <message>                Message TMessage
 %type <chare>          Chare Group NodeGroup Array TChare TGroup TNodeGroup TArray
 %type <entry>          Entry
 %type <templat>                Template
-%type <typelist>       BaseList OptBaseList TypeList
+%type <pname>           Parameter ParamBracketStart
+%type <plist>           ParamList EParameters
+%type <typelist>       BaseList OptBaseList
 %type <mbrlist>                MemberEList MemberList
 %type <member>         Member
 %type <tvar>           TVar
 %type <tvarlist>       TVarList TemplateSpec
-%type <val>            ArrayDim Dim
+%type <val>            ArrayDim Dim DefaultParameter
 %type <vallist>                DimList
 %type <mv>             Var
 %type <mvlist>         VarList
@@ -189,11 +192,11 @@ TParamEList       : /* Empty */
                { $$ = $1; }
                ;
 
-OptTParams     : /* Empty */
-               { $$ = 0; }
-               | '<' TParamEList '>'
-               { $$ = $2; }
-               ;
+OptTParams     :  /* Empty */
+                { $$ = 0; }
+                | '<' TParamEList '>'
+                { $$ = $2; }
+                ;
 
 BuiltinType    : INT
                { $$ = new BuiltinType("int"); }
@@ -206,11 +209,11 @@ BuiltinType       : INT
                | UNSIGNED INT
                { $$ = new BuiltinType("unsigned int"); }
                | UNSIGNED LONG
-               { $$ = new BuiltinType("long"); }
+               { $$ = new BuiltinType("unsigned long"); }
                | UNSIGNED SHORT
-               { $$ = new BuiltinType("short"); }
+               { $$ = new BuiltinType("unsigned short"); }
                | UNSIGNED CHAR
-               { $$ = new BuiltinType("char"); }
+               { $$ = new BuiltinType("unsigned char"); }
                | LONG LONG
                { $$ = new BuiltinType("long long"); }
                | FLOAT
@@ -223,13 +226,12 @@ BuiltinType       : INT
                { $$ = new BuiltinType("void"); }
                ;
 
-NamedType      : Name OptTParams
-               { $$ = new NamedType($1, $2); }
-               ;
+NamedType      : Name OptTParams { $$ = new NamedType($1,$2); };
+QualNamedType  : QualName OptTParams { $$ = new NamedType($1,$2); };
 
 SimpleType     : BuiltinType
                { $$ = $1; }
-               | NamedType
+               | QualNamedType
                { $$ = $1; }
                ;
 
@@ -243,38 +245,30 @@ PtrType           : OnePtrType '*'
                { $1->indirect(); $$ = $1; }
                ;
 
-ArrayDim       : NUMBER
-               { $$ = new Value($1); }
-               | Name
-               { $$ = new Value($1); }
-               ;
-
-ArrayType      : Type '[' ArrayDim ']'
-               { $$ = new ArrayType($1, $3); }
-               ;
-
-FuncType       : Type '(' '*' Name ')' '(' TypeList ')'
+FuncType       : Type '(' '*' Name ')' '(' ParamList ')'
                { $$ = new FuncType($1, $4, $7); }
                ;
 
 Type           : SimpleType
                { $$ = $1; }
                | OnePtrType
-               { $$ = (Type*) $1; }
+               { $$ = $1; }
                | PtrType
-               { $$ = (Type*) $1; }
-               | ArrayType
                { $$ = $1; }
                | FuncType
                { $$ = $1; }
-               ;
-
-TypeList       : /* Empty */
-               { $$ = 0; }
-               | Type
-               { $$ = new TypeList($1); }
-               | Type ',' TypeList
-               { $$ = new TypeList($1, $3); }
+               | Type '[' ArrayDim ']'
+               { $$ = new ArrayType($1,$3); }
+               | Type '&'
+               { $$ = new ReferenceType($1); }
+/*             | CONST Type   ...Causes ambiguity somehow...
+               { $$ = new ConstType($2); }  */
+               ;
+               
+ArrayDim       : NUMBER
+               { $$ = new Value($1); }
+               | QualName
+               { $$ = new Value($1); }
                ;
 
 Dim            : '[' ArrayDim ']'
@@ -332,7 +326,7 @@ CAttribList : CAttrib
                ;
 
 CAttrib                : MIGRATABLE
-               { $$ = 0x01; }
+               { $$ = Chare::CMIGRATABLE; }
                ;
 
 Var            : Type Name '[' ']' ';'
@@ -347,10 +341,8 @@ VarList            : Var
 
 Message                : MESSAGE MAttribs NamedType
                { $$ = new Message(lineno, $3); }
-               | MESSAGE MAttribs NamedType '{' TypeList '}'
-               { $$ = new Message(lineno, $3, $5); }
                | MESSAGE MAttribs NamedType '{' VarList '}'
-               { $$ = new Message(lineno, $3, 0, $5); }
+               { $$ = new Message(lineno, $3, $5); }
                ;
 
 OptBaseList    : /* Empty */
@@ -366,17 +358,17 @@ BaseList  : NamedType
                ;
 
 Chare          : CHARE CAttribs NamedType OptBaseList MemberEList
-               { $$ = new Chare(lineno, $3, $4, $5, $2); }
+               { $$ = new Chare(lineno, $2, $3, $4, $5); }
                | MAINCHARE CAttribs NamedType OptBaseList MemberEList
-               { $$ = new MainChare(lineno, $3, $4, $5, $2); }
+               { $$ = new MainChare(lineno, $2, $3, $4, $5); }
                ;
 
 Group          : GROUP CAttribs NamedType OptBaseList MemberEList
-               { $$ = new Group(lineno, $3, $4, $5, $2); }
+               { $$ = new Group(lineno, $2, $3, $4, $5); }
                ;
 
 NodeGroup      : NODEGROUP CAttribs NamedType OptBaseList MemberEList
-               { $$ = new NodeGroup(lineno, $3, $4, $5, $2); }
+               { $$ = new NodeGroup(lineno, $2, $3, $4, $5); }
                ;
 
 ArrayIndexType : '[' NUMBER Name ']'
@@ -390,25 +382,25 @@ ArrayIndexType    : '[' NUMBER Name ']'
                ;
 
 Array          : ARRAY ArrayIndexType NamedType OptBaseList MemberEList
-               { $$ = new Array(lineno, $2, $3, $4, $5); }
+               { $$ = new Array(lineno, 0, $2, $3, $4, $5); }
                ;
 
 TChare         : CHARE CAttribs Name OptBaseList MemberEList
-               { $$ = new Chare(lineno, new NamedType($3), $4, $5, $2);}
+               { $$ = new Chare(lineno, $2, new NamedType($3), $4, $5);}
                | MAINCHARE CAttribs Name OptBaseList MemberEList
-               { $$ = new MainChare(lineno, new NamedType($3), $4, $5, $2); }
+               { $$ = new MainChare(lineno, $2, new NamedType($3), $4, $5); }
                ;
 
 TGroup         : GROUP CAttribs Name OptBaseList MemberEList
-               { $$ = new Group(lineno, new NamedType($3), $4, $5, $2); }
+               { $$ = new Group(lineno, $2, new NamedType($3), $4, $5); }
                ;
 
 TNodeGroup     : NODEGROUP CAttribs Name OptBaseList MemberEList
-               { $$ = new NodeGroup( lineno, new NamedType($3), $4, $5, $2); }
+               { $$ = new NodeGroup( lineno, $2, new NamedType($3), $4, $5); }
                ;
 
 TArray         : ARRAY ArrayIndexType Name OptBaseList MemberEList
-               { $$ = new Array( lineno, $2, new NamedType($3), $4, $5); }
+               { $$ = new Array( lineno, 0, $2, new NamedType($3), $4, $5); }
                ;
 
 TMessage       : MESSAGE MAttribs Name ';'
@@ -479,12 +471,16 @@ Member            : Entry ';'
                { $$ = $1; }
                ;
 
-Entry          : ENTRY EAttribs VOID Name EParam OptPure OptStackSize
-               { $$ = new Entry(lineno, $2|$6, new BuiltinType("void"), $4, $5, $7); }
-               | ENTRY EAttribs OnePtrType Name EParam OptPure OptStackSize
+Entry          : ENTRY EAttribs EReturn Name EParameters OptPure OptStackSize
                { $$ = new Entry(lineno, $2|$6, $3, $4, $5, $7); }
-               | ENTRY EAttribs Name EParam
-               { $$ = new Entry(lineno, $2, 0, $3, $4, 0); }
+               | ENTRY EAttribs Name EParameters /*Constructor*/
+               { $$ = new Entry(lineno, $2,     0, $3, $4,  0); }
+               ;
+
+EReturn                : VOID
+               { $$ = new BuiltinType("void"); }
+               | OnePtrType
+               { $$ = $1; }
                ;
 
 EAttribs       : /* Empty */
@@ -507,18 +503,66 @@ EAttrib           : THREADED
                { $$ = SLOCKED; }
                | VIRTUAL
                { $$ = SVIRTUAL; }
+               | CREATEHERE
+               { $$ = SCREATEHERE; }
+               | CREATEHOME
+               { $$ = SCREATEHOME; }
                ;
 
-OptType                : /* Empty */
-               { $$ = 0; }
-               | VOID
-               { $$ = new BuiltinType("void"); }
-               | OnePtrType
+DefaultParameter: LITERAL
+               { $$ = new Value($1); }
+               | NUMBER
+               { $$ = new Value($1); }
+               | QualName
+               { $$ = new Value($1); }
+               ;
+
+CCode          : CPROGRAM
                { $$ = $1; }
+               | CPROGRAM '[' CPROGRAM ']' CPROGRAM
+               {  /*Returned only when in_bracket*/
+                       char *tmp = new char[strlen($1)+strlen($3)+strlen($5)+3];
+                       sprintf(tmp,"%s[%s]%s", $1, $3, $5);
+                       $$ = tmp;
+               }
+               | CPROGRAM '{' CPROGRAM '}' CPROGRAM
+               { /*Returned only when in_braces*/
+                       char *tmp = new char[strlen($1)+strlen($3)+strlen($5)+3];
+                       sprintf(tmp,"%s{%s}%s", $1, $3, $5);
+                       $$ = tmp;
+               }
+               ;
+
+ParamBracketStart : Type Name '['
+               {  /*Start grabbing CPROGRAM segments*/
+                       in_bracket=1;
+                       $$ = new Parameter(lineno, $1,$2);
+               }
+               ;
+
+Parameter      : Type
+               { $$ = new Parameter(lineno, $1);}
+               | Type Name
+               { $$ = new Parameter(lineno, $1,$2);}
+               | Type Name '=' DefaultParameter
+               { $$ = new Parameter(lineno, $1,$2,0,$4);} 
+               | ParamBracketStart CCode ']'
+               { /*Stop grabbing CPROGRAM segments*/
+                       in_bracket=0;
+                       $$ = new Parameter(lineno, $1->getType(), $1->getName() ,$2);
+               } 
                ;
 
-EParam         : '(' OptType ')'
+ParamList      : Parameter
+               { $$ = new ParamList($1); }
+               | Parameter ',' ParamList
+               { $$ = new ParamList($1,$3); }
+               ;
+
+EParameters    : '(' ParamList ')'
                { $$ = $2; }
+               | '(' ')'
+               { $$ = 0; }
                ;
 
 OptStackSize   : /* Empty */
@@ -530,13 +574,13 @@ OptStackSize      : /* Empty */
 OptPure                : /* Empty */
                { $$ = 0; }
                | '=' NUMBER
-               { if(strcmp($2, "0")) { yyerror("expected 0"); exit(1); }
+               { if(strcmp($2, "0")) { yyerror("pure virtual must '=0'"); exit(1); }
                  $$ = SPURE; 
                }
                ;
 %%
 void yyerror(const char *mesg)
 {
-  cout << "Syntax error at line " << lineno << ": " << mesg << endl;
+  cout << cur_file<<":"<<lineno<<": Charmxi syntax error> " << mesg << endl;
   // return 0;
 }
index ee36edfc5e6c2395cd1441beda23c669a5abdaf1..eb112a8b316e0c10bca883fc44901fdf9c1bbfd1 100644 (file)
@@ -19,6 +19,7 @@ extern ModuleList *modlist;
 
 ModuleList *Parse(char *interfacefile)
 {
+  cur_file=interfacefile;
   FILE * fp = fopen (interfacefile, "r") ;
   if (fp) {
     yyin = fp ;
@@ -42,7 +43,6 @@ main(int argc, char *argv[])
   char *fname;
   char *option=0;
 
-  compilemode = original;
   fortranMode = 0;
 
   switch (argc) {
@@ -63,9 +63,6 @@ main(int argc, char *argv[])
   default:
     abortxi(argv[0]);
   }
-  
-  if (option != 0 && strcmp(option,"-ansi")==0)
-    compilemode = ansi;
 
   if (option != 0 && strcmp(option,"-f90")==0)
     fortranMode = 1;
index 1281a959897e5b9316df5ec1c68d527fb32075f8..baf2514875d2b8eb66b0b0a55054727799a52714 100644 (file)
@@ -22,7 +22,7 @@
 #ifdef __cplusplus
 
 #include <stdlib.h>
-#ifndef WIN32
+#ifndef WIN32 /*MANUALLY ADDED LINE*/
 #include <unistd.h>
 #endif
 
@@ -263,6 +263,8 @@ static void yy_flex_free YY_PROTO(( void * ));
 
 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
 
+
+#define YY_USES_REJECT
 typedef unsigned char YY_CHAR;
 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 typedef int yy_state_type;
@@ -284,15 +286,42 @@ static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
        *yy_cp = '\0'; \
        yy_c_buf_p = yy_cp;
 
-#define YY_NUM_RULES 11
-#define YY_END_OF_BUFFER 12
-static yyconst short int yy_accept[46] =
+#define YY_NUM_RULES 13
+#define YY_END_OF_BUFFER 14
+static yyconst short int yy_acclist[178] =
+    {   0,
+        1,    2,    1,    2,   14,    1,    2,   12,   13,    1,
+        2,    7,   12,   13,    1,    2,    8,   13,    1,    2,
+        4,   12,   13,    1,    2,   12,   13,    1,    2,   12,
+       13,    1,    2,   12,   13,    1,    2,   12,   13,    1,
+        2,   12,   13,    1,    2,   12,   13,    1,    2,    9,
+       10,   12,   13,    1,    2,   11,   12,   13,    2,   12,
+       13,    1,   12,   13,    1,    2,    2,    1,    1,    2,
+        7,    1,    2,    1,    2,   10,    2,    1,    1,    2,
+        1,    2,   10,    2,    1,    1,    2,    6,    1,    2,
+        1,    2,    9,   10,    1,    2,   10,    1,    2,    5,
+
+        1,    2,    3,    1,    2,   10,    1,    2,    1,    2,
+        9,   10,    1,    2,   11,    1,    2,    1,    2,    1,
+        2,    2,   10,    1,   10,    1,    2,    1,    2,    1,
+        2,    2,   10,    1,   10,    1,    2,    1,    2,    3,
+        2,    3,    1,    3,    1,    2,    1,    2,   10,    1,
+        2,    2,    1,    2,    2,    2,   10,    1,    1,    1,
+        1,    2,    2,    1,    2,    2,    2,   10,    1,    1,
+        1,    1,    2,    1,    2,   10,    3
+    } ;
+
+static yyconst short int yy_accept[91] =
     {   0,
-        0,    0,   12,   10,    5,    6,    2,   10,   10,   10,
-       10,   10,   10,    7,    9,    5,    0,    8,    0,    8,
-        4,    0,    7,    8,    3,    1,    8,    0,    7,    9,
-        0,    0,    0,    0,    0,    0,    0,    1,    0,    8,
-        0,    0,    0,    8,    0
+        1,    3,    5,    6,   10,   15,   19,   24,   28,   32,
+       36,   40,   44,   48,   54,   59,   62,   65,   67,   68,
+       69,   72,   74,   77,   78,   79,   81,   84,   85,   86,
+       89,   91,   95,   98,  101,  104,  107,  109,  113,  116,
+      118,  120,  122,  124,  124,  126,  128,  130,  132,  134,
+      134,  136,  138,  141,  143,  145,  147,  150,  152,  153,
+      154,  155,  156,  157,  158,  159,  160,  161,  163,  164,
+      165,  166,  167,  168,  169,  170,  171,  172,  174,  177,
+      178,  178,  178,  178,  178,  178,  178,  178,  178,  178
     } ;
 
 static yyconst int yy_ec[256] =
@@ -306,11 +335,11 @@ static yyconst int yy_ec[256] =
         1,    1,    1,    1,   12,   12,   12,   12,   13,   12,
        12,   12,   12,   12,   14,   12,   14,   12,   12,   12,
        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
-        1,    1,    1,    1,   15,    1,   12,   12,   12,   12,
+       15,    1,   15,    1,   16,    1,   12,   12,   12,   12,
 
        13,   12,   12,   12,   12,   12,   14,   12,   14,   12,
        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
-       12,   12,    1,    1,    1,    1,    1,    1,    1,    1,
+       12,   12,   17,    1,   17,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -327,65 +356,200 @@ static yyconst int yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static yyconst int yy_meta[16] =
+static yyconst int yy_meta[18] =
     {   0,
         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
-        3,    3,    3,    3,    3
+        1,    1,    1,    1,    3,    1,    4
     } ;
 
-static yyconst short int yy_base[52] =
+static yyconst short int yy_base[113] =
     {   0,
-        0,    0,   66,   67,   63,   67,   67,   59,   57,   52,
-        7,   50,   10,   12,    0,   58,   54,   25,   52,   29,
-       67,   46,    0,   11,   67,    0,   23,   29,   67,    0,
-        0,    0,   50,    0,    0,   46,   30,    0,   38,   35,
-       38,   33,   22,   18,   67,   41,   44,   16,   47,   50,
-       53
+        0,    0,   63,    3,   19,    7,    8,   34,   49,   57,
+       66,   17,   77,   80,   86,    0,    0,   18,    0,    0,
+      101,  110,  126,  135,  150,  163,  179,  183,  198,   21,
+       22,  205,  211,   29,  222,  231,  237,   32,    0,    0,
+        0,  246,  262,   57,  266,    0,    0,  269,  285,   55,
+      290,  289,  298,   39,   32,   35,   39,  313,  328,  343,
+      357,  361,  364,  380,  384,  388,  391,  404,  419,  434,
+      448,  453,  457,  473,  478,  483,  487,   48,   49,    0,
+       49,    0,    0,   48,   39,    0,    0,   13,  594,  502,
+      506,  510,  514,  517,  521,  525,  529,  533,  537,  541,
+
+      545,  549,  553,  557,  561,  565,  569,  573,  577,  581,
+      585,  589
     } ;
 
-static yyconst short int yy_def[52] =
+static yyconst short int yy_def[113] =
     {   0,
-       45,    1,   45,   45,   45,   45,   45,   46,   47,   45,
-       45,   45,   45,   45,   48,   45,   46,   45,   47,   45,
-       45,   45,   14,   45,   45,   49,   45,   45,   45,   48,
-       18,   18,   50,   20,   20,   51,   45,   49,   45,   45,
-       50,   51,   45,   45,    0,   45,   45,   45,   45,   45,
-       45
+       89,    1,   89,   90,   90,   90,   90,   91,   92,   90,
+       90,   11,   11,   11,   11,   93,   94,   11,   93,   94,
+       11,   91,   11,   95,   96,   92,   23,   97,   98,   11,
+       11,   11,   11,   11,   99,   11,   11,   11,   15,   23,
+       23,  100,   93,  101,   94,   27,   27,  102,   93,  103,
+       94,   11,   99,  104,  105,   11,   11,  100,  106,  107,
+       93,   93,  106,   89,   94,   94,  107,  102,  108,  109,
+       93,   93,  108,   89,   94,   94,  109,   11,   11,  110,
+      111,   64,   64,  111,  112,   74,   74,  112,    0,   89,
+       89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
+
+       89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
+       89,   89
     } ;
 
-static yyconst short int yy_nxt[83] =
+static yyconst short int yy_nxt[612] =
     {   0,
         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
-       14,   15,   15,   15,   15,   22,   25,   23,   30,   26,
-       27,   24,   23,   37,   28,   29,   31,   32,   44,   33,
-       34,   35,   44,   24,   36,   28,   39,   43,   20,   40,
-       44,   17,   18,   17,   19,   40,   19,   38,   40,   38,
-       41,   20,   41,   42,   18,   42,   24,   20,   18,   16,
-       24,   21,   20,   18,   16,   45,    3,   45,   45,   45,
-       45,   45,   45,   45,   45,   45,   45,   45,   45,   45,
-       45,   45
+       14,   15,   15,   15,   16,   15,   17,   19,   74,   20,
+       21,   19,   19,   20,   20,   18,   18,   33,   18,   18,
+       18,   18,   33,   19,   20,   20,   18,   18,   23,   18,
+       18,   19,   18,   18,   74,   57,   80,   18,   24,   57,
+       25,   18,   64,   64,   27,   80,   18,   18,   79,   79,
+       74,   64,   89,   28,   89,   29,   30,   89,   89,   89,
+       89,   19,   89,   20,   31,   89,   32,   89,   89,   89,
+       19,   89,   20,   34,   89,   18,   35,   18,   36,   89,
+       89,   89,   37,   38,   18,   89,   39,   39,   39,   39,
+
+       89,   39,   21,   89,   89,   89,   89,   89,   89,   18,
+       89,   18,   18,   89,   23,   89,   89,   89,   89,   89,
+       89,   89,   89,   89,   24,   89,   25,   40,   41,   89,
+       42,   89,   89,   89,   18,   89,   18,   19,   89,   43,
+       89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
+       89,   44,   20,   89,   45,   89,   89,   89,   89,   89,
+       89,   89,   89,   89,   44,   18,   89,   89,   27,   89,
+       89,   89,   89,   89,   89,   89,   89,   28,   89,   29,
+       46,   47,   89,   18,   48,   19,   89,   89,   49,   89,
+       89,   89,   89,   89,   89,   89,   89,   89,   89,   50,
+
+       20,   89,   89,   51,   89,   89,   89,   89,   89,   89,
+       89,   89,   50,   36,   89,   89,   89,   37,   38,   18,
+       89,   33,   89,   52,   18,   89,   89,   89,   89,   89,
+       89,   89,   89,   89,   89,   89,   54,   89,   55,   18,
+       89,   33,   89,   37,   56,   18,   89,   57,   18,   89,
+       23,   89,   89,   89,   89,   89,   89,   89,   89,   89,
+       59,   89,   60,   61,   62,   89,   63,   65,   66,   89,
+       67,   18,   89,   89,   27,   89,   89,   89,   89,   89,
+       89,   89,   89,   69,   89,   70,   71,   72,   89,   89,
+       73,   75,   76,   89,   89,   77,   78,   18,   89,   79,
+
+       18,   89,   89,   89,   89,   89,   89,   89,   89,   89,
+       89,   89,   54,   89,   55,   18,   89,   23,   89,   89,
+       89,   89,   89,   89,   89,   89,   89,   59,   89,   60,
+       19,   89,   43,   89,   89,   89,   89,   89,   89,   89,
+       89,   89,   89,   89,   81,   20,   89,   45,   89,   89,
+       89,   89,   89,   89,   89,   89,   89,   81,   61,   62,
+       89,   63,   61,   62,   89,   63,   19,   89,   43,   89,
+       89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
+       81,   82,   83,   89,   84,   65,   66,   89,   67,   65,
+       66,   89,   67,   20,   89,   45,   89,   89,   89,   89,
+
+       89,   89,   89,   89,   89,   81,   18,   89,   89,   27,
+       89,   89,   89,   89,   89,   89,   89,   89,   69,   89,
+       70,   19,   89,   89,   49,   89,   89,   89,   89,   89,
+       89,   89,   89,   89,   89,   85,   20,   89,   89,   51,
+       89,   89,   89,   89,   89,   89,   89,   89,   85,   71,
+       72,   89,   89,   73,   71,   72,   89,   89,   73,   19,
+       89,   89,   49,   89,   89,   89,   89,   89,   89,   89,
+       89,   89,   89,   85,   86,   87,   89,   89,   88,   75,
+       76,   89,   89,   77,   75,   76,   89,   89,   77,   20,
+       89,   89,   51,   89,   89,   89,   89,   89,   89,   89,
+
+       89,   85,   18,   18,   18,   18,   22,   22,   22,   22,
+       26,   26,   26,   26,   19,   19,   19,   20,   20,   89,
+       20,   24,   24,   24,   24,   25,   25,   25,   25,   28,
+       28,   28,   28,   29,   29,   29,   29,   53,   53,   53,
+       53,   58,   58,   58,   58,   44,   89,   44,   44,   68,
+       68,   68,   68,   50,   89,   50,   50,   54,   54,   54,
+       54,   55,   55,   55,   55,   59,   59,   59,   59,   60,
+       60,   60,   60,   69,   69,   69,   69,   70,   70,   70,
+       70,   80,   89,   80,   80,   81,   89,   81,   81,   85,
+       89,   85,   85,    3,   89,   89,   89,   89,   89,   89,
+
+       89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
+       89
     } ;
 
-static yyconst short int yy_chk[83] =
+static yyconst short int yy_chk[612] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,   11,   13,   11,   48,   13,
-       14,   24,   14,   24,   14,   14,   18,   18,   44,   18,
-       20,   20,   43,   27,   20,   27,   28,   37,   42,   28,
-       37,   46,   41,   46,   47,   40,   47,   49,   39,   49,
-       50,   36,   50,   51,   33,   51,   22,   19,   17,   16,
-       12,   10,    9,    8,    5,    3,   45,   45,   45,   45,
-       45,   45,   45,   45,   45,   45,   45,   45,   45,   45,
-       45,   45
+        1,    1,    1,    1,    1,    1,    1,    4,   88,    4,
+        5,    6,    7,    6,    7,   12,   18,   12,   18,   30,
+       31,   30,   31,    5,   55,    5,    8,   34,    8,   34,
+       38,   54,   38,   56,   85,   56,   55,   57,    8,   57,
+        8,    9,   84,   81,    9,   54,   78,   79,   78,   79,
+       50,   44,    3,    9,    0,    9,   10,    0,    0,    0,
+        0,   10,    0,   10,   11,    0,   11,    0,    0,    0,
+       11,    0,   11,   13,    0,   13,   13,   13,   14,    0,
+        0,    0,   14,   14,   15,    0,   15,   15,   15,   15,
+
+        0,   15,   21,    0,    0,    0,    0,    0,    0,   21,
+        0,   21,   22,    0,   22,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,   22,    0,   22,   23,   23,    0,
+       23,    0,    0,    0,   23,    0,   23,   24,    0,   24,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,   24,   25,    0,   25,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,   25,   26,    0,    0,   26,    0,
+        0,    0,    0,    0,    0,    0,    0,   26,    0,   26,
+       27,   27,    0,   27,   27,   28,    0,    0,   28,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,   28,
+
+       29,    0,    0,   29,    0,    0,    0,    0,    0,    0,
+        0,    0,   29,   32,    0,    0,    0,   32,   32,   33,
+        0,   33,    0,   33,   35,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,   35,    0,   35,   36,
+        0,   36,    0,   36,   37,   37,    0,   37,   42,    0,
+       42,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+       42,    0,   42,   43,   43,    0,   43,   45,   45,    0,
+       45,   48,    0,    0,   48,    0,    0,    0,    0,    0,
+        0,    0,    0,   48,    0,   48,   49,   49,    0,    0,
+       49,   51,   51,    0,    0,   51,   52,   52,    0,   52,
+
+       53,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,   53,    0,   53,   58,    0,   58,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,   58,    0,   58,
+       59,    0,   59,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,   59,   60,    0,   60,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,   60,   61,   61,
+        0,   61,   62,   62,    0,   62,   63,    0,   63,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+       63,   64,   64,    0,   64,   65,   65,    0,   65,   66,
+       66,    0,   66,   67,    0,   67,    0,    0,    0,    0,
+
+        0,    0,    0,    0,    0,   67,   68,    0,    0,   68,
+        0,    0,    0,    0,    0,    0,    0,    0,   68,    0,
+       68,   69,    0,    0,   69,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,   69,   70,    0,    0,   70,
+        0,    0,    0,    0,    0,    0,    0,    0,   70,   71,
+       71,    0,    0,   71,   72,   72,    0,    0,   72,   73,
+        0,    0,   73,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,   73,   74,   74,    0,    0,   74,   75,
+       75,    0,    0,   75,   76,   76,    0,    0,   76,   77,
+        0,    0,   77,    0,    0,    0,    0,    0,    0,    0,
+
+        0,   77,   90,   90,   90,   90,   91,   91,   91,   91,
+       92,   92,   92,   92,   93,   93,   93,   94,   94,    0,
+       94,   95,   95,   95,   95,   96,   96,   96,   96,   97,
+       97,   97,   97,   98,   98,   98,   98,   99,   99,   99,
+       99,  100,  100,  100,  100,  101,    0,  101,  101,  102,
+      102,  102,  102,  103,    0,  103,  103,  104,  104,  104,
+      104,  105,  105,  105,  105,  106,  106,  106,  106,  107,
+      107,  107,  107,  108,  108,  108,  108,  109,  109,  109,
+      109,  110,    0,  110,  110,  111,    0,  111,  111,  112,
+        0,  112,  112,   89,   89,   89,   89,   89,   89,   89,
+
+       89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
+       89
     } ;
 
-static yy_state_type yy_last_accepting_state;
-static char *yy_last_accepting_cpos;
-
-/* The intent behind this definition is that it'll catch
- * any uses of REJECT which flex missed.
- */
-#define REJECT reject_used_but_not_detected
+static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
+static char *yy_full_match;
+static int yy_lp;
+#define REJECT \
+{ \
+*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
+yy_cp = yy_full_match; /* restore poss. backed-over text */ \
+++yy_lp; \
+goto find_rule; \
+}
 #define yymore() yymore_used_but_not_detected
 #define YY_MORE_ADJ 0
 #define YY_RESTORE_YY_MORE_OFFSET
@@ -400,21 +564,23 @@ char *yytext;
 
 /* Global Variables and Functions - used in grammar.y */
 unsigned int lineno = 1;
+int in_bracket=0; /*Horrific hack to get "array length" code snippets (between []'s)*/
+int in_braces=0; /*Horrific hack to get SDAG entry code snippets (between {}'s)*/
 
 /* Local to file */
 static unsigned char in_comment=0;
 int search(char *s);
 
 /* We return Tokens only when not in a comment. */
-
 #define Return if (!in_comment) return
 #define        Token(x) x
+#define Yval yylval.strval = strcpy(new char[yyleng+1], yytext)
 
 #ifdef yywrap
 #undef yywrap
 #endif
 
-#line 416 "lex.yy.c"
+#line 582 "lex.yy.c"
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
@@ -565,9 +731,9 @@ YY_DECL
        register char *yy_cp, *yy_bp;
        register int yy_act;
 
-#line 48 "xi-scan.l"
+#line 53 "xi-scan.l"
 
-#line 569 "lex.yy.c"
+#line 735 "lex.yy.c"
 
        if ( yy_init )
                {
@@ -606,33 +772,41 @@ YY_DECL
                yy_bp = yy_cp;
 
                yy_current_state = yy_start;
+               yy_state_ptr = yy_state_buf;
+               *yy_state_ptr++ = yy_current_state;
 yy_match:
                do
                        {
                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
-                       if ( yy_accept[yy_current_state] )
-                               {
-                               yy_last_accepting_state = yy_current_state;
-                               yy_last_accepting_cpos = yy_cp;
-                               }
                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                                {
                                yy_current_state = (int) yy_def[yy_current_state];
-                               if ( yy_current_state >= 46 )
+                               if ( yy_current_state >= 90 )
                                        yy_c = yy_meta[(unsigned int) yy_c];
                                }
                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+                       *yy_state_ptr++ = yy_current_state;
                        ++yy_cp;
                        }
-               while ( yy_base[yy_current_state] != 67 );
+               while ( yy_base[yy_current_state] != 594 );
 
 yy_find_action:
-               yy_act = yy_accept[yy_current_state];
-               if ( yy_act == 0 )
-                       { /* have to back up */
-                       yy_cp = yy_last_accepting_cpos;
-                       yy_current_state = yy_last_accepting_state;
-                       yy_act = yy_accept[yy_current_state];
+               yy_current_state = *--yy_state_ptr;
+               yy_lp = yy_accept[yy_current_state];
+find_rule: /* we branch to this label when backing up */
+               for ( ; ; ) /* until we find what rule we matched */
+                       {
+                       if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
+                               {
+                               yy_act = yy_acclist[yy_lp];
+                                       {
+                                       yy_full_match = yy_cp;
+                                       break;
+                                       }
+                               }
+                       --yy_cp;
+                       yy_current_state = *--yy_state_ptr;
+                       yy_lp = yy_accept[yy_current_state];
                        }
 
                YY_DO_BEFORE_ACTION;
@@ -643,73 +817,74 @@ do_action:        /* This label is used only to access EOF actions. */
 
                switch ( yy_act )
        { /* beginning of action switch */
-                       case 0: /* must back up */
-                       /* undo the effects of YY_DO_BEFORE_ACTION */
-                       *yy_cp = yy_hold_char;
-                       yy_cp = yy_last_accepting_cpos;
-                       yy_current_state = yy_last_accepting_state;
-                       goto yy_find_action;
-
 case 1:
 YY_RULE_SETUP
-#line 49 "xi-scan.l"
-{ /* ignore single line comments */ }
+#line 54 "xi-scan.l"
+{ if (in_bracket) {Yval;return Token(CPROGRAM);} else REJECT;}
        YY_BREAK
 case 2:
 YY_RULE_SETUP
-#line 50 "xi-scan.l"
-{ /* ignore ^M characters for dos-unix compat */ }
+#line 55 "xi-scan.l"
+{ if (in_braces) {Yval;return Token(CPROGRAM);} else REJECT;}
        YY_BREAK
 case 3:
 YY_RULE_SETUP
-#line 51 "xi-scan.l"
-{ in_comment = 1; /* Single line C-style comments */ }
+#line 56 "xi-scan.l"
+{ /* ignore single line comments */ }
        YY_BREAK
 case 4:
 YY_RULE_SETUP
-#line 52 "xi-scan.l"
-{ in_comment = 0; }
+#line 57 "xi-scan.l"
+{ /* ignore ^M characters for dos-unix compat */ }
        YY_BREAK
 case 5:
 YY_RULE_SETUP
-#line 53 "xi-scan.l"
-{ /* ignore white space */ }
+#line 58 "xi-scan.l"
+{ in_comment = 1; /* Single line C-style comments */ }
        YY_BREAK
 case 6:
 YY_RULE_SETUP
-#line 54 "xi-scan.l"
-{ lineno++;}
+#line 59 "xi-scan.l"
+{ in_comment = 0; }
        YY_BREAK
 case 7:
 YY_RULE_SETUP
-#line 55 "xi-scan.l"
-{ yylval.strval = strcpy(new char[yyleng+1], yytext); 
-                 Return Token(NUMBER); }
+#line 60 "xi-scan.l"
+{ /* ignore white space */ }
        YY_BREAK
 case 8:
 YY_RULE_SETUP
-#line 57 "xi-scan.l"
-{ yylval.strval = strcpy(new char[yyleng+1], yytext); 
-                 Return Token(LITERAL); }
+#line 61 "xi-scan.l"
+{ lineno++;}
        YY_BREAK
 case 9:
 YY_RULE_SETUP
-#line 59 "xi-scan.l"
-{ Return Token(search(yytext)); }
+#line 62 "xi-scan.l"
+{ Yval; Return Token(NUMBER); }
        YY_BREAK
 case 10:
 YY_RULE_SETUP
-#line 60 "xi-scan.l"
-{ Return Token(yytext[0]); }
+#line 63 "xi-scan.l"
+{ Yval; Return Token(LITERAL); }
        YY_BREAK
 case 11:
 YY_RULE_SETUP
-#line 61 "xi-scan.l"
+#line 64 "xi-scan.l"
+{ Return Token(search(yytext)); }
+       YY_BREAK
+case 12:
+YY_RULE_SETUP
+#line 65 "xi-scan.l"
+{ Return Token(yytext[0]); }
+       YY_BREAK
+case 13:
+YY_RULE_SETUP
+#line 66 "xi-scan.l"
 ECHO;
        YY_BREAK
-#line 709 "lex.yy.c"
-case YY_STATE_EOF(INITIAL):
-       yyterminate();
+#line 884 "lex.yy.c"
+                       case YY_STATE_EOF(INITIAL):
+                               yyterminate();
 
        case YY_END_OF_BUFFER:
                {
@@ -987,22 +1162,20 @@ static yy_state_type yy_get_previous_state()
        register char *yy_cp;
 
        yy_current_state = yy_start;
+       yy_state_ptr = yy_state_buf;
+       *yy_state_ptr++ = yy_current_state;
 
        for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
                {
                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
-               if ( yy_accept[yy_current_state] )
-                       {
-                       yy_last_accepting_state = yy_current_state;
-                       yy_last_accepting_cpos = yy_cp;
-                       }
                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                        {
                        yy_current_state = (int) yy_def[yy_current_state];
-                       if ( yy_current_state >= 46 )
+                       if ( yy_current_state >= 90 )
                                yy_c = yy_meta[(unsigned int) yy_c];
                        }
                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+               *yy_state_ptr++ = yy_current_state;
                }
 
        return yy_current_state;
@@ -1023,22 +1196,18 @@ yy_state_type yy_current_state;
 #endif
        {
        register int yy_is_jam;
-       register char *yy_cp = yy_c_buf_p;
 
        register YY_CHAR yy_c = 1;
-       if ( yy_accept[yy_current_state] )
-               {
-               yy_last_accepting_state = yy_current_state;
-               yy_last_accepting_cpos = yy_cp;
-               }
        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                {
                yy_current_state = (int) yy_def[yy_current_state];
-               if ( yy_current_state >= 46 )
+               if ( yy_current_state >= 90 )
                        yy_c = yy_meta[(unsigned int) yy_c];
                }
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-       yy_is_jam = (yy_current_state == 45);
+       yy_is_jam = (yy_current_state == 89);
+       if ( ! yy_is_jam )
+               *yy_state_ptr++ = yy_current_state;
 
        return yy_is_jam ? 0 : yy_current_state;
        }
@@ -1593,7 +1762,7 @@ int main()
        return 0;
        }
 #endif
-#line 61 "xi-scan.l"
+#line 66 "xi-scan.l"
 
 
 struct rwtable {
@@ -1614,12 +1783,15 @@ struct rwtable rwtable[] = {
   "stacksize", STACKSIZE,
   "threaded",  THREADED,
   "migratable",        MIGRATABLE,
+  "createhere",        CREATEHERE,
+  "createhome",        CREATEHOME,
   "template",  TEMPLATE,
   "class",     CLASS,
   "sync",      SYNC,
   "exclusive", EXCLUSIVE,
   "virtual",    VIRTUAL,
   "void",      VOID,
+  "const",     CONST,
   "mainchare", MAINCHARE,
   "packed",     PACKED,
   "varsize",    VARSIZE,
index 44d3b563748c7418f945d8f3bfb3a7bcaecc7379..58e87a9937915f05d6c40bbf2f321f94b04ba88d 100644 (file)
@@ -6,15 +6,17 @@
 
 /* Global Variables and Functions - used in grammar.y */
 unsigned int lineno = 1;
+int in_bracket=0; /*Horrific hack to get "array length" code snippets (between []'s)*/
+int in_braces=0; /*Horrific hack to get SDAG entry code snippets (between {}'s)*/
 
 /* Local to file */
 static unsigned char in_comment=0;
 int search(char *s);
 
 /* We return Tokens only when not in a comment. */
-
 #define Return if (!in_comment) return
 #define        Token(x) x
+#define Yval yylval.strval = strcpy(new char[yyleng+1], yytext)
 
 #ifdef yywrap
 #undef yywrap
@@ -45,17 +47,20 @@ real        {real1}|{real2}
 
 literal        {number}|{real}|{string}
 
+nonBracket [^][]*
+nonBraces [^{}]*
+
 %%
+{nonBracket}   { if (in_bracket) {Yval;return Token(CPROGRAM);} else REJECT;}
+{nonBraces}    { if (in_braces) {Yval;return Token(CPROGRAM);} else REJECT;}
 "//".*         { /* ignore single line comments */ }
 "\r"           { /* ignore ^M characters for dos-unix compat */ }
 "/*"           { in_comment = 1; /* Single line C-style comments */ }
 "*/"           { in_comment = 0; }
 {ws}           { /* ignore white space */ }
 {nl}           { lineno++;}
-{number}       { yylval.strval = strcpy(new char[yyleng+1], yytext); 
-                 Return Token(NUMBER); }
-{literal}      { yylval.strval = strcpy(new char[yyleng+1], yytext); 
-                 Return Token(LITERAL); }
+{number}       { Yval; Return Token(NUMBER); }
+{literal}      { Yval; Return Token(LITERAL); }
 {name}         { Return Token(search(yytext)); }
 .              { Return Token(yytext[0]); }
 %%
@@ -78,12 +83,15 @@ struct rwtable rwtable[] = {
   "stacksize", STACKSIZE,
   "threaded",  THREADED,
   "migratable",        MIGRATABLE,
+  "createhere",        CREATEHERE,
+  "createhome",        CREATEHOME,
   "template",  TEMPLATE,
   "class",     CLASS,
   "sync",      SYNC,
   "exclusive", EXCLUSIVE,
   "virtual",    VIRTUAL,
   "void",      VOID,
+  "const",     CONST,
   "mainchare", MAINCHARE,
   "packed",     PACKED,
   "varsize",    VARSIZE,
index 46eec6030b4b76256a11149841bf808c1732755c..33f734813fa90e98c801a5f1569ba5cd059f6b06 100644 (file)
@@ -7,14 +7,22 @@
 
 #include <iostream.h>
 #include <fstream.h>
-//  #include <string>
 #include <stdlib.h>
 #include "xi-symbol.h"
 #include <ctype.h> // for tolower()
 
-CompileMode compilemode;
-MessageList message_list;
 int fortranMode;
+const char *cur_file;
+
+//Fatal error function
+void die(const char *why,int line)
+{
+       if (line==-1)
+               fprintf(stderr,"%s: Charmxi fatal error> %s\n",cur_file,why);
+       else
+               fprintf(stderr,"%s:%d: Charmxi fatal error> %s\n",cur_file,line,why);
+       exit(1);
+}
 
 // Make the name lower case
 char* fortranify(const char *s)
@@ -86,8 +94,12 @@ TParamList::print(XStr& str)
 void 
 Type::genProxyName(XStr &str) 
 {
-  cerr<< getBaseName() << " type has no proxy!!\n";
-  exit(1);
+  die("type::genProxyName called (INTERNAL ERROR)");
+}
+void 
+Type::genMsgProxyName(XStr &str) 
+{
+  die("type::genMsgProxyName called (INTERNAL ERROR)");
 }
     
 void 
@@ -115,6 +127,35 @@ TypeList::print(XStr& str)
     str << ", ";
     next->print(str);
   }
+}void TypeList::genProxyNames(XStr& str, const char *prefix, 
+                             const char *suffix, const char *sep)
+{
+  if(type) {
+    str << prefix;
+    type->genProxyName(str);
+    str << suffix;
+  }
+  if(next) {
+    str << sep;
+    next->genProxyNames(str, prefix, suffix, sep);
+  }
+}
+
+void TypeList::genProxyNames2(XStr& str, const char *prefix, 
+                             const char *middle, const char *suffix, 
+                             const char *sep)
+{
+  if(type) {
+    str << prefix;
+    type->genProxyName(str);
+    str << middle;
+    type->genProxyName(str);
+    str << suffix;
+  }
+  if(next) {
+    str << sep;
+    next->genProxyNames2(str, prefix, middle, suffix, sep);
+  }
 }
 
 void 
@@ -279,7 +320,7 @@ Module::generate()
   if(!decl || !def) {
     cerr<<"Cannot open "<<topname.get_string()<<"or "
        <<botname.get_string()<<" for writing!!\n";
-    exit(1);
+    die("cannot create output files (check directory permissions)\n");
   }
   decl<<declstr.get_string();
   def<<defstr.get_string();
@@ -381,22 +422,24 @@ static const char *CIChareEnd =
 "};\n"
 ;
 
-Chare::Chare(int ln, NamedType *t, TypeList *b, MemberList *l, int mig)
-        : type(t), list(l), bases(b), migratable(mig) 
+Chare::Chare(int ln, attrib_t Nattr, NamedType *t, TypeList *b, MemberList *l)
+        : attrib(Nattr), type(t), list(l), bases(b)
 {
        line = ln;
+       entryCount=1;
        setTemplate(0); 
-       abstract=0;
        if (list)
        {
                list->setChare(this);
-               if (list->isPure()) abstract=1;
+               if (list->isPure()) setAbstract(1);
                else /*not at abstract class--*/
                //Add migration constructor to MemberList
-                 if(!t->isTemplated() && migratable) {
+                 if(!t->isTemplated() && isMigratable()) {
                        Entry *e=new Entry(ln,SMIGRATE,NULL,
-                       (char *)type->getBaseName(),
-                       new PtrType(new NamedType("CkMigrateMessage")));
+                         (char *)type->getBaseName(),
+                         new ParamList(new Parameter(line,
+                               new PtrType(new NamedType("CkMigrateMessage"))
+                         )));
                        e->setChare(this);
                        list=new MemberList(e,list);
                  }
@@ -431,10 +474,6 @@ Chare::genRegisterMethodDef(XStr& str)
     bases->genProxyNames(str, "  _REGISTER_BASE(__idx, ", "::__idx);\n", "");
   if(list)
     list->genReg(str);
-  if(migratable) {
-    str << "      CkRegisterMigCtor(__idx, " << 
-                   "__idx_"<<type->getBaseName()<<"_CkMigrateMessage);\n";
-  }
   str << "    }\n";
   str << "#endif\n";
 }
@@ -553,9 +592,9 @@ Group::genSubDecls(XStr& str)
 
 
 //Array Constructor
-Array::Array(int ln, NamedType *index,
+Array::Array(int ln, attrib_t Nattr, NamedType *index,
        NamedType *t, TypeList *b, MemberList *l)  
-    : Chare(ln,t,b,l,0x01
+    : Chare(ln,Nattr|CARRAY|CMIGRATABLE,t,b,l
 {
        index->print(indexSuffix);
        if (indexSuffix!=(const char*)"none")
@@ -623,7 +662,7 @@ Array::genSubDecls(XStr& str)
   if (indexSuffix!=(const char*)"none")
   {
     str <<
-    "//Generalized array indexing: (these KEEP the index you pass in!)\n"
+    "//Generalized array indexing:\n"
     "    "<<ptype<<" operator [] (const "<<indexType<<" &idx) const\n"
     "        {return "<<ptype<<"(_aid, idx);}\n"
     "    "<<ptype<<" operator() (const "<<indexType<<" &idx) const\n"
@@ -658,42 +697,6 @@ void
 Chare::genDefs(XStr& str)
 {
   str << "/* DEFS: "; print(str); str << " */\n";
-  if (fortranMode) { // For Fortran90
-    if (!isArray()) { // Currently, only arrays are supported
-      cerr << (char *)baseName() << ": only chare arrays are currently supported\n";
-      exit(1);
-    }
-    // We have to generate the chare array itself
-    str << "/* FORTRAN */\n";
-    str << "extern \"C\" void " << fortranify(baseName()) << "_allocate_(char **, void *, int *);\n";
-    str << "\n";
-    str << "class " << baseName() << " : public ArrayElement1D\n";
-    str << "{\n";
-    str << "public:\n";
-    str << "  char user_data[64];\n";
-    str << "public:\n";
-    str << "  " << baseName() << "()\n";
-    str << "  {\n";
-//    str << "    CkPrintf(\"" << baseName() << " %d created\\n\",thisIndex);\n";
-    str << "    CkArrayID *aid = &thisArrayID;\n";
-    str << "    " << fortranify(baseName()) << "_allocate_((char **)&user_data, &aid, &thisIndex);\n";
-    str << "  }\n";
-    str << "\n";
-    str << "  " << baseName() << "(CkMigrateMessage *m)\n";
-    str << "  {\n";
-    str << "    CkPrintf(\"" << baseName() << " %d migrating\\n\",thisIndex);\n";
-    str << "  }\n";
-    str << "\n";
-    str << "};\n";
-    str << "\n";
-    str << "extern \"C\" void " << fortranify(baseName()) << "_cknew_(int *numElem, long *aindex)\n";
-    str << "{\n";
-    str << "    CkArrayID *aid = new CkArrayID;\n";
-    str << "    *aid = CProxy_" << baseName() << "::ckNew(*numElem); \n";
-    str << "    *aindex = (long)aid;\n";
-    str << "}\n";
-
-  }
   if(!type->isTemplated()) {
     if(!templat) {
       str << "#ifndef CK_TEMPLATES_ONLY\n";
@@ -731,19 +734,6 @@ Chare::genReg(XStr& str)
   str << type<<"::__register(\""<<type<<"\", sizeof("<<type<<"));\n";
 }
 
-static const char *CIMsgClass =
-"{\n"
-"  public:\n"
-"    static int __idx;\n"
-"    void* operator new(size_t, const int);\n"
-"    void* operator new(size_t);\n"
-"    void operator delete(void *p){CkFreeMsg(p);}\n"
-"    void* operator new(size_t, void*p) {return p;}\n"
-"    void* operator new(size_t, int*, const int);\n"
-"    void* operator new(size_t, int*);\n"
-"    static void*alloc(int,size_t,int*,int);\n"
-;
-
 static const char *CIMsgClassAnsi =
 "{\n"
 "  public:\n"
@@ -768,9 +758,7 @@ Message::genAllocDecl(XStr &str)
   XStr mtype;
   mtype << type;
   if(templat) templat->genVars(mtype);
-  if(compilemode==ansi)
-    str << CIMsgClassAnsi;
-  else str << CIMsgClass;
+  str << CIMsgClassAnsi;
   str << "    CMessage_" << mtype << "() {};\n";
   str << "    static void *pack(" << mtype << " *p);\n";
   str << "    static " << mtype << "* unpack(void* p);\n";
@@ -780,12 +768,10 @@ Message::genAllocDecl(XStr &str)
     for(i=0;i<num;i++)
       str << "int, ";
     str << "const int);\n";
-    if(compilemode==ansi) {
-      str << "    void operator delete(void *p,";
-      for(i=0;i<num;i++)
+    str << "    void operator delete(void *p,";
+    for(i=0;i<num;i++)
         str << "int, ";
-      str << "const int){CkFreeMsg(p);}\n";
-    }
+    str << "const int){CkFreeMsg(p);}\n";
   }
 }
 
@@ -846,17 +832,6 @@ Message::genDefs(XStr& str)
   }
   if(!(external||type->isTemplated())) {
 
-    // Define the Marshalling message for Fortran
-    if (fortranMode)
-    {
-      str << "/* FORTRAN message */\n";
-      str << "class " << type 
-          << " : public CMessage_" << type << "\n";
-      str << "{\npublic:\n";
-      contents->genUnmarshalList2(str);
-      str << "};\n\n";
-    }
-
     // new (size_t)
     str << tspec << "void *" << ptype << "::operator new(size_t s){\n";
     str << "  return " << mtype << "::alloc(__idx, s, 0, 0);\n}\n";
@@ -1069,19 +1044,6 @@ void
 Readonly::genDecls(XStr& str)
 {
   str << "/* DECLS: "; print(str); str << " */\n";
-  /*
-  if(container) { // local static var
-  } else { // global var
-    str << "extern ";
-    type->print(str);
-    if(msg)
-      str << "*";
-    str << " "<<name;
-    if(dims)
-      dims->print(str);
-    str << ";";
-  }
-  */
 }
 
 void
@@ -1114,10 +1076,7 @@ Readonly::genReg(XStr& str)
   if(external)
     return;
   if(msg) {
-    if(dims) {
-      cerr<<"line "<<line<<":Readonly Message cannot be an array!!\n";
-      exit(1);
-    }
+    if(dims) die("readonly Message cannot be an array",line);
     str << "  CkRegisterReadonlyMsg((void **) &";
     if(container) {
       str << container->baseName()<<"::";
@@ -1146,106 +1105,6 @@ void TParamList::genSpec(XStr& str)
   }
 }
 
-void TypeList::genProxyNames(XStr& str, const char *prefix, 
-                             const char *suffix, const char *sep)
-{
-  if(type) {
-    str << prefix;
-    type->genProxyName(str);
-    str << suffix;
-  }
-  if(next) {
-    str << sep;
-    next->genProxyNames(str, prefix, suffix, sep);
-  }
-}
-
-void TypeList::genProxyNames2(XStr& str, const char *prefix, 
-                             const char *middle, const char *suffix, 
-                             const char *sep)
-{
-  if(type) {
-    str << prefix;
-    type->genProxyName(str);
-    str << middle;
-    type->genProxyName(str);
-    str << suffix;
-  }
-  if(next) {
-    str << sep;
-    next->genProxyNames2(str, prefix, middle, suffix, sep);
-  }
-}
-
-void TypeList::genUnmarshalList0(XStr& str, int depth)
-{
-  if(type) {
-//    type->print(str);
-    str << type->getBaseName();
-    str << "*";
-  }
-  if(next) {
-    str << ", ";
-    next->genUnmarshalList0(str, depth+1);
-  }
-}
-
-void TypeList::genUnmarshalList1(XStr& str, const char* message_name, int depth)
-{
-  if(type) {
-    if (type->typeName() != arrayType)
-      str << "&((" << message_name << "*)msg)->p" << depth;
-    else
-      str << "((" << message_name << "*)msg)->p" << depth;
-  }
-  if(next) {
-    str << ", ";
-    next->genUnmarshalList1(str, message_name, depth+1);
-  }
-}
-
-void TypeList::genUnmarshalList2(XStr& str, int depth)
-{
-  if(type) {
-//    str << "  " << type->getBaseName() << " p" << depth << ";\n";
-    char p[10];
-    sprintf(p, "p%d", depth);
-    type->printVar(str, p);
-    str<<";\n";
-  }
-  if(next) {
-    next->genUnmarshalList2(str, depth+1);
-  }
-}
-
-void TypeList::genUnmarshalList3(XStr& str, int depth)
-{
-  if(type) {
-    str << type->getBaseName() << " *p" << depth;
-  }
-  if(next) {
-    str << ", ";
-    next->genUnmarshalList3(str, depth+1);
-  }
-}
-
-void TypeList::genUnmarshalList4(XStr& str, int depth)
-{
-  if(type) {
-    if (type->typeName() != arrayType) 
-      str << "  msg->p" << depth << " = *p" << depth << ";\n";
-    else {
-      ArrayType *atype = (ArrayType *)type;
-      str << "  memcpy(msg->p" << depth << ", p" << depth << ", ";
-      atype->printDim(str);
-      str << "*sizeof(" << atype->getBaseName() << "));\n";
-    }
-  }
-  if(next) {
-    next->genUnmarshalList4(str, depth+1);
-  }
-}
-
 void MemberList::genDecls(XStr& str)
 {
   if(member)
@@ -1279,64 +1138,67 @@ void MemberList::genReg(XStr& str)
 ///////////////////////////// ENTRY ////////////////////////////
 
 
-Entry::Entry(int l, int a, EnType *r, char *n, EnType *p, Value *sz) :
+Entry::Entry(int l, int a, Type *r, char *n, ParamList *p, Value *sz) :
       attribs(a), retType(r), name(n), param(p), stacksize(sz)
 { 
-  line=l; setChare(0); 
-  if(!isVirtual() && isPure()) {
-    cerr << "Line "<<line<<": Non-virtual methods cannot be pure virtual!!\n";
-    abort();
-  }
-  if(!isThreaded() && stacksize) {
-    cerr << "Line "<<line<<": Non-Threaded methods cannot have stacksize spec.!!\n";
-    abort();
-  }
-  if(retType && !isSync() && !retType->isVoid()) {
-    cerr << "Line "<<line<<": Async methods cannot have non-void return type!!\n";
-    abort();
-  }
+  line=l; container=NULL; 
+  entryCount=-1;
+  if(!isVirtual() && isPure()) die("Non-virtual methods cannot be pure virtual",line);
+  if(!isThreaded() && stacksize) die("Non-Threaded methods cannot have stacksize",line);
+  if(retType && !isSync() && !retType->isVoid()) 
+    die("Async methods cannot have non-void return type",line);
+}
+void Entry::setChare(Chare *c) {
+       Member::setChare(c);
+       if (param==NULL) 
+       {//Fake a parameter list of the appropriate type
+               Type *t;
+               if (isConstructor()&&container->isMainChare())
+                       //Main chare always magically takes CkArgMsg
+                       t=new PtrType(new NamedType("CkArgMsg"));
+               else
+                       t=new BuiltinType("void");
+               param=new ParamList(new Parameter(line,t));
+       }
+       entryCount=c->nextEntry();
 }
 
-
 // "parameterType *msg" or "void".
 // Suitable for use as the only parameter
-XStr Entry::paramType(void)
+XStr Entry::paramType(int withDefaultVals)
 {
   XStr str;
-  if(param) {
-    str << param;
-    if(!param->isVoid())  
-       str << "msg";
-  }
+  param->print(str,withDefaultVals);
   return str;
 }
 
 // "parameterType *msg," if there is a non-void parameter, 
 // else empty.  Suitable for use with another parameter following.
-XStr Entry::paramComma(void)
+XStr Entry::paramComma(int withDefaultVals)
 {
   XStr str;
-  if(param&&!param->isVoid())  
-       str << param<<"msg, ";
+  if (!param->isVoid()) {
+       param->print(str,withDefaultVals);
+       str << ", ";
+  }
   return str;
 }
 
-// Returns a dummy message declaration if the current
-// parameter type is void.
-XStr Entry::voidParamDecl(void)
+XStr Entry::marshallMsg(int orMakeVoid)
 {
-  if((!param) || param->isVoid())
-    return "      void *msg = CkAllocSysMsg();\n";
-  else
-    return "";
+  XStr ret;
+  param->marshall(ret,orMakeVoid);
+  return ret;
 }
 
 XStr Entry::epIdx(int include__idx_)
 {
   XStr str;
   if(include__idx_) str << "__idx_";
-  str << name;
-  if(param) str << "_"<<param->getBaseName();
+  str << name << "_";
+  if (param->isMessage()) str<<param->getBaseName();
+  else if (param->isVoid()) str<<"void";
+  else str<<"marshall"<<entryCount;
   return str;
 }
 
@@ -1362,10 +1224,10 @@ void Entry::genChareDecl(XStr& str)
     genChareStaticConstructorDecl(str);
   } else {
     // entry method declaration
-    str << "    "<<Virtual()<<retType<<" "<<name<<"("<<paramType()<<");\n";
+    str << "    "<<Virtual()<<retType<<" "<<name<<"("<<paramType(1)<<");\n";
     // entry method declaration with future
     if(isSync()) {
-      str << "    "<<Virtual()<<" void "<<name<<"("<<paramComma()<<"CkFutureID*);\n";
+      str << "    "<<Virtual()<<" void "<<name<<"("<<paramComma(1)<<"CkFutureID*);\n";
     }
   }
 }
@@ -1377,25 +1239,23 @@ void Entry::genChareDefs(XStr& str)
   } else {
     // entry method definition
     container->genTSpec(str);
-    str << retType<<" "<<container->proxyName()<<"::"<<name<<"("<<paramType()<<")\n";
-    str << "{\n";
-    if(param->isVoid())
-      str << "  void *msg = CkAllocSysMsg();\n";
+    str << retType<<" "<<container->proxyName()<<"::"<<name<<"("<<paramType(0)<<")\n";
+    str << "{\n"<<marshallMsg();
     if(isSync()) {
       if(retType->isVoid()) {
-        str << "  CkFreeSysMsg(CkRemoteCall("<<epIdx()<<", msg, &_ck_cid));\n";
+        str << "  CkFreeSysMsg(CkRemoteCall("<<epIdx()<<", impl_msg, &_ck_cid));\n";
       } else {
-        str << "  return ("<<retType<<") CkRemoteCall("<<epIdx()<<", msg, &_ck_cid);\n";
+        str << "  return ("<<retType<<") CkRemoteCall("<<epIdx()<<", impl_msg, &_ck_cid);\n";
       }
     } else {
-      str << "  CkSendMsg("<<epIdx()<<", msg, &_ck_cid);\n";
+      str << "  CkSendMsg("<<epIdx()<<", impl_msg, &_ck_cid);\n";
     }
     str << "}\n";
     // entry method definition with future
     if(isSync()) {
-      str << makeDecl(" void")<<"::"<<name<<"("<<paramComma()<<"CkFutureID *fut)\n";
-      str << "{\n"<<voidParamDecl();
-      str << "  *fut = CkRemoteCallAsync("<<epIdx()<<", msg, &_ck_cid);\n";
+      str << makeDecl(" void")<<"::"<<name<<"("<<paramComma(0)<<"CkFutureID *fut)\n";
+      str << "{\n"<<marshallMsg();
+      str << "  *fut = CkRemoteCallAsync("<<epIdx()<<", impl_msg, &_ck_cid);\n";
       str << "}\n";
     }
   }
@@ -1405,28 +1265,27 @@ void Entry::genChareStaticConstructorDecl(XStr& str)
 {
   if(container->isAbstract()) return;
 
-  str << "    static void ckNew("<<paramComma()<<"int onPE=CK_PE_ANY);\n";
-  str << "    static void ckNew("<<paramComma()<<"CkChareID* pcid, int onPE=CK_PE_ANY);\n";
-  str << "    "<<container->proxyName(0)<<"("<<paramComma()<<"int onPE=CK_PE_ANY);\n";
-    
+  str << "    static void ckNew("<<paramComma(1)<<"int onPE=CK_PE_ANY);\n";
+  str << "    static void ckNew("<<paramComma(1)<<"CkChareID* pcid, int onPE=CK_PE_ANY);\n";
+  str << "    "<<container->proxyName(0)<<"("<<paramComma(1)<<"int onPE=CK_PE_ANY);\n";
 }
 
 void Entry::genChareStaticConstructorDefs(XStr& str)
 {
   if(container->isAbstract()) return;
   
-  str << makeDecl("void")<<"::ckNew("<<paramComma()<<"int onPE)\n";
-  str << "{\n"<<voidParamDecl();
-  str << "  CkCreateChare(__idx, "<<epIdx()<<", msg, 0, onPE);\n";
+  str << makeDecl("void")<<"::ckNew("<<paramComma(0)<<"int onPE)\n";
+  str << "{\n"<<marshallMsg();
+  str << "  CkCreateChare(__idx, "<<epIdx()<<", impl_msg, 0, onPE);\n";
   str << "}\n";
 
-  str << makeDecl("void")<<"::ckNew("<<paramComma()<<"CkChareID* pcid, int onPE)\n";
-  str << "{\n"<<voidParamDecl();
-  str << "  CkCreateChare(__idx, "<<epIdx()<<", msg, pcid, onPE);\n";
+  str << makeDecl("void")<<"::ckNew("<<paramComma(0)<<"CkChareID* pcid, int onPE)\n";
+  str << "{\n"<<marshallMsg();
+  str << "  CkCreateChare(__idx, "<<epIdx()<<", impl_msg, pcid, onPE);\n";
   str << "}\n";
-  str << makeDecl(" ")<<"::"<<container->proxyName(0)<<"("<<paramComma()<<"int onPE)\n";
-  str << "{\n"<<voidParamDecl();
-  str << "  CkCreateChare(__idx, "<<epIdx()<<", msg, &_ck_cid, onPE);\n";
+  str << makeDecl(" ")<<"::"<<container->proxyName(0)<<"("<<paramComma(0)<<"int onPE)\n";
+  str << "{\n"<<marshallMsg();
+  str << "  CkCreateChare(__idx, "<<epIdx()<<", impl_msg, &_ck_cid, onPE);\n";
   str << "}\n";
 }
 
@@ -1438,7 +1297,7 @@ void Entry::genArrayDecl(XStr& str)
     genArrayStaticConstructorDecl(str);
   } else {
     // entry method broadcast declaration
-    str << "    "<<Virtual()<<retType<<" "<<name<<"("<<paramType()<<") const;\n";
+    str << "    "<<Virtual()<<retType<<" "<<name<<"("<<paramType(1)<<") const;\n";
   }
 }
 
@@ -1448,15 +1307,19 @@ void Entry::genArrayDefs(XStr& str)
     genArrayStaticConstructorDefs(str);
   else
   {//Define array entry method
+    const char *ifNot="CkArray_IfNotThere_buffer";
+    if (isCreateHere()) ifNot="CkArray_IfNotThere_createhere";
+    if (isCreateHome()) ifNot="CkArray_IfNotThere_createhome";
     container->genTSpec(str);
-    str<<retType<<" "<<container->proxyName()<<"::"<<name<<"("<<paramType()<<") const\n";
-    str<< "{\n";
-    if (!param||param->isVoid())
-      str << "      CkArrayMessage *msg=(CkArrayMessage*)CkAllocMsg(0, sizeof(CkArrayMessage),0);\n";
-    str << "      if(_idx.nInts==-1) \n";
-    str << "        base_broadcast(msg, "<<epIdx()<<");\n";
-    str << "      else\n";
-    str << "        base_send(msg, "<<epIdx()<<");\n";
+    str<<retType<<" "<<container->proxyName()<<
+               "::"<<name<<"("<<paramType(0)<<") const\n";
+    str << "{\n"<<marshallMsg();
+    str << "  if(_idx.nInts==-1) \n";
+    str << "    base_broadcast((CkArrayMessage *)impl_msg, "
+               <<epIdx()<<", "<<ifNot<<");\n";
+    str << "  else\n";
+    str << "    base_send((CkArrayMessage *)impl_msg, "
+               <<epIdx()<<", "<<ifNot<<");\n";
     str << "}\n";
   }
 }
@@ -1467,28 +1330,30 @@ void Entry::genArrayStaticConstructorDecl(XStr& str)
   
   if ( ((Array *)container) ->is1D())
       str<< //With numInitial
-      "    static CkArrayID ckNew("<<paramComma()<<"int numInitial,CkGroupID mapID=_RRMapID);\n";
+      "    static CkArrayID ckNew("<<paramComma(1)<<"int numInitial,CkGroupID mapID=_RRMapID);\n";
     
   str<<
-    "    void insert("<<paramComma()<<"int onPE=-1);";
+    "    void insert("<<paramComma(1)<<"int onPE=-1);";
 }
 
 void Entry::genArrayStaticConstructorDefs(XStr& str)
 {
     if(container->isAbstract()) return;
     
-    const char *callMsg;//"msg" or "NULL"
-    if (!param||param->isVoid()) callMsg="NULL"; else callMsg="msg";
+    const char *callMsg;//"impl_msg" or "NULL"
+    if (param->isVoid()) callMsg="NULL"; else callMsg="(CkArrayMessage *)impl_msg";
     
     //Add user-callable array constructors--
     if (((Array *)container)->is1D())
     //1D element constructors can take a number of initial elements
        str<< //With numInitial
-       makeDecl("CkArrayID")<<"::ckNew("<<paramComma()<<"int numElements,CkGroupID mapID)\n"
-       "{ return CkArrayID(buildArrayGroup("<<epIdx()<<",numElements,mapID,"<<callMsg<<"));}\n";
+       makeDecl("CkArrayID")<<"::ckNew("<<paramComma(0)<<"int numElements,CkGroupID mapID)\n"
+       "{ \n"<<marshallMsg(0)<<
+       "   return CkArrayID(buildArrayGroup("<<epIdx()<<",numElements,mapID,"<<callMsg<<"));\n}\n";
     str<<
-    makeDecl("void")<<"::insert("<<paramComma()<<"int onPE)\n"
-    "{ base_insert("<<epIdx()<<",onPE,"<<callMsg<<");}\n";
+    makeDecl("void")<<"::insert("<<paramComma(0)<<"int onPE)\n"
+    "{ \n"<<marshallMsg(0)<<
+    "   base_insert("<<epIdx()<<",onPE,"<<callMsg<<");\n}\n";
 }
 
 
@@ -1504,51 +1369,51 @@ void Entry::genGroupDecl(XStr& str)
   } else {
     // entry method broadcast declaration
     if(!isSync()) {
-      str << "    "<<Virtual()<<retType<<" "<<name<<"("<<paramType()<<")";
-      str << "{\n"<<voidParamDecl();
+      str << "    "<<Virtual()<<retType<<" "<<name<<"("<<paramType(1)<<")";
+      str << "{\n"<<marshallMsg();
       str << "      if(_isChare())\n";
-      str << "        CkSendMsg("<<epIdx()<<", msg, &_ck_cid);\n";
+      str << "        CkSendMsg("<<epIdx()<<", impl_msg, &_ck_cid);\n";
       str << "      else\n";
-      str << "        CkBroadcastMsg"<<node<<"Branch("<<epIdx()<<", msg, _ck_gid);\n";
+      str << "        CkBroadcastMsg"<<node<<"Branch("<<epIdx()<<", impl_msg, _ck_gid);\n";
       str << "    }\n";
     }
     // entry method onPE declaration
-    str << "    "<<Virtual()<<retType<<" "<<name<<"("<<paramComma()<<"int onPE)";
-    str << " {\n"<<voidParamDecl();
+    str << "    "<<Virtual()<<retType<<" "<<name<<"("<<paramComma(1)<<"int onPE)";
+    str << " {\n"<<marshallMsg();
     if(isSync()) {
       if(retType->isVoid()) {
         str << "    CkFreeSysMsg(";
       } else {
         str << "    return ("<<retType<<") ";
       }
-      str << "(CkRemote"<<node<<"BranchCall("<<epIdx()<<", "<<paramComma()<<"_ck_gid, onPE));\n";
+      str << "(CkRemote"<<node<<"BranchCall("<<epIdx()<<", "<<paramComma(1)<<"_ck_gid, onPE));\n";
       str << "    }\n";
     } else {
-      str << "      CkSendMsg"<<node<<"Branch("<<epIdx()<<", msg, onPE, _ck_gid);\n";
+      str << "      CkSendMsg"<<node<<"Branch("<<epIdx()<<", impl_msg, onPE, _ck_gid);\n";
       str << "    }\n";
     }
     // entry method on multi PEs declaration
     if(!isSync() && !container->isNodeGroup()) {
-      str << "    "<<Virtual()<<retType<<" "<<name<<"("<<paramComma();
+      str << "    "<<Virtual()<<retType<<" "<<name<<"("<<paramComma(1);
       str << "int npes, int *pes)";
-      str << " {\n"<<voidParamDecl();
+      str << " {\n"<<marshallMsg();
       str << "      CkSendMsg"<<node<<"BranchMulti(";
-      str <<epIdx()<<", msg, npes, pes, _ck_gid);\n";
+      str <<epIdx()<<", impl_msg, npes, pes, _ck_gid);\n";
       str << "    }\n";
     }
     // entry method onPE declaration with future
     if(isSync()) {
-      str << "    "<<Virtual()<<"void "<<name<<"("<<paramComma()<<"int onPE, CkFutureID *fut)";
-      str << " {\n"<<voidParamDecl();
+      str << "    "<<Virtual()<<"void "<<name<<"("<<paramComma(1)<<"int onPE, CkFutureID *fut)";
+      str << " {\n"<<marshallMsg();
       str << "      *fut = ";
-      str << "CkRemote"<<node<<"BranchCallAsync("<<epIdx()<<", msg, _ck_gid, onPE);\n";
+      str << "CkRemote"<<node<<"BranchCallAsync("<<epIdx()<<", impl_msg, _ck_gid, onPE);\n";
       str << "    }\n";
     }
     // entry method forChare declaration with future
     if(isSync()) {
-      str << "    "<<Virtual()<<"void "<<name<<"("<<paramComma()<<"CkFutureID *fut)";
-      str << " {\n"<<voidParamDecl();
-      str << "      *fut = CkRemoteCallAsync("<<epIdx()<<", msg, &_ck_cid);\n";
+      str << "    "<<Virtual()<<"void "<<name<<"("<<paramComma(1)<<"CkFutureID *fut)";
+      str << " {\n"<<marshallMsg();
+      str << "      *fut = CkRemoteCallAsync("<<epIdx()<<", impl_msg, &_ck_cid);\n";
       str << "    }\n";
     }
   }
@@ -1565,10 +1430,10 @@ void Entry::genGroupStaticConstructorDecl(XStr& str)
 {
   if(container->isAbstract()) return;
 
-  str << "    static CkGroupID ckNew("<<paramType()<<");\n";
-  str << "    static CkGroupID ckNewSync("<<paramType()<<");\n";
-  str << "    "<<container->proxyName(0)<<"("<<paramComma()<<"int retEP, CkChareID *cid);\n";
-  str << "    "<<container->proxyName(0)<<"("<<paramType()<<");\n";
+  str << "    static CkGroupID ckNew("<<paramType(1)<<");\n";
+  str << "    static CkGroupID ckNewSync("<<paramType(1)<<");\n";
+  str << "    "<<container->proxyName(0)<<"("<<paramComma(1)<<"int retEP, CkChareID *cid);\n";
+  str << "    "<<container->proxyName(0)<<"("<<paramType(1)<<");\n";
 }
 
 void Entry::genGroupStaticConstructorDefs(XStr& str)
@@ -1577,26 +1442,26 @@ void Entry::genGroupStaticConstructorDefs(XStr& str)
   
   //Selects between NodeGroup and Group
   char *node = (char *)(container->isNodeGroup()?"Node":"");
-  str << makeDecl("CkGroupID")<<"::ckNew("<<paramType()<<")\n";
-  str << "{\n"<<voidParamDecl();
-  str << "  return CkCreate"<<node<<"Group(__idx, "<<epIdx()<<", msg, 0, 0);\n";
+  str << makeDecl("CkGroupID")<<"::ckNew("<<paramType(0)<<")\n";
+  str << "{\n"<<marshallMsg();
+  str << "  return CkCreate"<<node<<"Group(__idx, "<<epIdx()<<", impl_msg, 0, 0);\n";
   str << "}\n";
 
-  str << makeDecl("CkGroupID")<<"::ckNewSync("<<paramType()<<")\n";
-  str << "{\n"<<voidParamDecl();
-  str << "  return CkCreate"<<node<<"GroupSync(__idx, "<<epIdx()<<", msg);\n";
+  str << makeDecl("CkGroupID")<<"::ckNewSync("<<paramType(0)<<")\n";
+  str << "{\n"<<marshallMsg();
+  str << "  return CkCreate"<<node<<"GroupSync(__idx, "<<epIdx()<<", impl_msg);\n";
   str << "}\n";
 
   str << makeDecl(" ")<<"::"<<container->proxyName(0)<<
-         "("<<paramComma()<<"int retEP, CkChareID *cid)\n";
-  str << "{\n"<<voidParamDecl();
-  str << "  _ck_gid = CkCreate"<<node<<"Group(__idx, "<<epIdx()<<", msg, retEP, cid);\n";
+         "("<<paramComma(0)<<"int retEP, CkChareID *cid)\n";
+  str << "{\n"<<marshallMsg();
+  str << "  _ck_gid = CkCreate"<<node<<"Group(__idx, "<<epIdx()<<", impl_msg, retEP, cid);\n";
   str << "  _setChare(0);\n";
   str << "}\n";
 
-  str << makeDecl(" ")<<"::"<<container->proxyName(0)<<"("<<paramType()<<")\n";
-  str << "{\n"<<voidParamDecl();
-  str << "  _ck_gid = CkCreate"<<node<<"Group(__idx, "<<epIdx()<<", msg, 0, 0);\n";
+  str << makeDecl(" ")<<"::"<<container->proxyName(0)<<"("<<paramType(0)<<")\n";
+  str << "{\n"<<marshallMsg();
+  str << "  _ck_gid = CkCreate"<<node<<"Group(__idx, "<<epIdx()<<", impl_msg, 0, 0);\n";
   str << "  _setChare(0);\n";
   str << "}\n";
 }
@@ -1605,18 +1470,13 @@ void Entry::genGroupStaticConstructorDefs(XStr& str)
 
 void Entry::genDecls(XStr& str)
 {
-  if(container->isArray()&&param==NULL) {param=new BuiltinType("void");}
-  if(isConstructor() && retType && !retType->isVoid()) {
-    cerr << "Line "<<line<<": Constructors cannot return a value!!\n";
-    abort();
-  }
+  if(isConstructor() && retType && !retType->isVoid())
+    die("Constructors cannot return a value",line);
   
   str << "/* DECLS: "; print(str); str << " */\n";
-  if(retType==0 && !isConstructor()) {
-      cerr<<"line "<<line<<":Entry methods must specify a return type. ";
-      cerr<<"use void if necessary\n";
-      exit(1);
-  }  
+  if(retType==0 && !isConstructor())
+      die("Entry methods must specify a return type-- \n"
+       "use void if necessary",line);
   
   if (attribs&SMIGRATE) 
     {} //User cannot call the migration constructor
@@ -1632,31 +1492,20 @@ void Entry::genDecls(XStr& str)
   str << "    static int  "<<epIdx()<<";\n";
   
   // ckIdx, so user can find the entry point number
-  str << "    static int  ckIdx_"<<name<<"("<<paramType()<<") { return "<<epIdx()<<"; }\n"; 
+  str << "    static int  ckIdx_"<<name<<"("<<paramType(1)<<") { return "<<epIdx()<<"; }\n"; 
 
   // call function declaration
   if(isConstructor() && container->isAbstract())
     return;
   else {
-    str << "    static void _call_"<<epIdx(0)<<"(";
-    if(param) {
-      str << "void* msg, ";
-    } else {
-      if(!isConstructor()) {
-        cerr <<"line "<<line<<" Only constructors allowed to have empty parameter list\n";
-        exit(1);
-      }
-      str << "CkArgMsg* msg, ";
-    }
-    str << container->baseName()<< "* obj);\n";
+    str << "    static void _call_"<<epIdx(0)<<"(void* impl_msg, ";
+    str << container->baseName()<< "* impl_obj);\n";
     if(isThreaded()) {
       str << "    static void _callthr_"<<epIdx(0)<<"(CkThrCallArg *);\n";
     }
   }
 }
 
-
-
 //This routine is only used in Entry::genDefs.
 // It ends the current procedure with a call to awaken another thread,
 // and defines the thread function to handle that call.
@@ -1668,32 +1517,19 @@ XStr Entry::callThread(const XStr &procName,int prependEntryName)
   procFull<<procName;
   
   str << "  CthAwaken(CthCreate((CthVoidFn)"<<procFull
-   <<", new CkThrCallArg(msg,obj), "<<getStackSize()<<"));\n}\n";
-  str << makeDecl("void")<<"::"<<procFull<<"(CkThrCallArg *arg)\n";
+   <<", new CkThrCallArg(impl_msg,impl_obj), "<<getStackSize()<<"));\n}\n";
+  str << makeDecl("void")<<"::"<<procFull<<"(CkThrCallArg *impl_arg)\n";
   str << "{\n";\
-  str << "  void *msg = arg->msg;\n";
-  str << "  "<<container->baseName()<<" *obj = ("<<container->baseName()<<" *) arg->obj;\n";
-  str << "  delete arg;\n";
+  str << "  void *impl_msg = impl_arg->msg;\n";
+  str << "  "<<container->baseName()<<" *impl_obj = ("<<container->baseName()<<" *) impl_arg->obj;\n";
+  str << "  delete impl_arg;\n";
   return str;
 }
 
 void Entry::genDefs(XStr& str)
 {
   XStr containerType=container->baseName();
-  XStr cpType,cpComma;
-  char *freeMsgVoid=(char*) "";
-  if((!param)||(param->isVoid()))
-  {
-    if(container->isArray())
-      freeMsgVoid=(char*) "  CkFreeMsg(msg);\n";
-    else
-      freeMsgVoid=(char*) "  CkFreeSysMsg(msg);\n";
-  }
-  if(param&&!param->isVoid())
-  {//Add type casts for the message parameter
-     cpType<<"("<<param<<")msg";
-     cpComma<<"("<<param<<")msg,";
-  }
+  XStr preCall,postCall;
   
   str << "/* DEFS: "; print(str); str << " */\n";
   
@@ -1710,135 +1546,47 @@ void Entry::genDefs(XStr& str)
   } else
     genChareDefs(str);
   
-  // call function
+  // Add special pre- and post- call code
   if(isConstructor() && container->isAbstract())
     return; // no call function for a constructor of an abstract chare
   else if(isSync()) {
   //A synchronous method can return a value, and must finish before
   // the caller can proceed.
-    if(isConstructor()) {
-      cerr<<"line "<<line<<":Constructors cannot be sync methods."<<endl;
-      exit(1);
-    }
-    str << makeDecl("void")<<"::_call_"<<epIdx(0)<<"(void* msg, "<<containerType<<"* obj)\n";
-    str << "{\n";
-    if(isThreaded()) str << callThread(epIdx(0));
-    str << "  int ref = CkGetRefNum(msg), src = CkGetSrcPe(msg);\n";
-    str << "  void *retMsg=";
+    if(isConstructor()) die("Constructors cannot be [sync]",line);
+    preCall<< "  int impl_ref = CkGetRefNum(impl_msg), impl_src = CkGetSrcPe(impl_msg);\n";
+    preCall << "  void *impl_retMsg=";
     if(retType->isVoid()) {
-      str << "CkAllocSysMsg();\n  ";
+      preCall << "CkAllocSysMsg();\n  ";
     } else {
-      str << "(void *) ";
+      preCall << "(void *) ";
     }
-    str << "obj->"<<name<<"("<<cpType<<");\n"<<freeMsgVoid;
-    str << "  CkSendToFuture(ref, retMsg, src);\n";
-    str << "}\n";
+    
+    postCall << "  CkSendToFuture(impl_ref, impl_retMsg, impl_src);\n";
   } else if(isExclusive()) {
   //An exclusive method 
-    if(!container->isNodeGroup()) {
-      cerr<<"line "<<line<<":Only entry methods of a nodegroup can be exclusive."<<endl;
-      exit(1);
-    }
-    if(isConstructor()) {
-      cerr<<"line "<<line<<":Constructors cannot be exclusive methods."<<endl;
-      exit(1);
-    }
-    if(param==0) {
-      cerr<<"line "<<line<<":Entry methods must specify a message parameter. ";
-      cerr<<"use void if necessary\n";
-      exit(1);
-    }
-    str << makeDecl("void")<<"::_call_"<<epIdx(0)<<"(void* msg, "<<containerType<<"* obj)\n";
-    str << "{\n";
-    if(isThreaded()) str << callThread(epIdx(0));
-    str << "  if(CmiTryLock(obj->__nodelock)) {\n";
-    str << "    "<<container->proxyName()<<" pobj(CkGetNodeGroupID());\n";
-    str << "    pobj."<<name<<"("<<cpComma<<"CkMyNode());\n"<<freeMsgVoid;
-    str << "    return;\n";
-    str << "  }\n";
-    str << "  obj->"<<name<<"("<<cpType<<");\n"<<freeMsgVoid;
-    str << "  CmiUnlock(obj->__nodelock);\n";
-    str << "}\n";
-  } else {//Not sync, exclusive, or an array constructor-- just a regular method
-
-    if (!isConstructor() && fortranMode) { // Fortran90
-      const char* msg_name = param->getBaseName();
-      TypeList *msg_contents = (message_list.find(msg_name))->getContents();
-
-      str << "/* FORTRAN SECTION */\n";
-
-      // Declare the Fortran Entry Function
-      // This is called from C++
-      str << "extern \"C\" void " << fortranify(name) << "_(char **, int*, ";
-      msg_contents->genUnmarshalList0(str);
-      str << ");\n";
-
-/*
-      // Define the Marshalling message
-      str << "class " << msg_name 
-          << " : public CMessage_" << msg_name << "\n";
-      str << "{\npublic:\n";
-      msg_contents->genUnmarshalList2(str);
-      str << "};\n";
-*/
-
-      // Define the Fortran interface function
-      // This is called from Fortran to send the message to a chare.
-      str << "extern \"C\" void "
-        //<< container->proxyName() << "_" 
-          << fortranify("SendTo_")
-         << fortranify(container->baseName())
-          << "_" << fortranify(name)
-          << "_(long* aindex, int *index, ";
-      msg_contents->genUnmarshalList3(str);
-      str << ")\n";
-      str << "{\n";
-      str << "  CkArrayID *aid = (CkArrayID *)*aindex;\n";
-      str << "\n";
-      str << "  // marshalling\n";
-      str << "  " << container->proxyName() << " h(*aid);\n";
-      str << "  " << msg_name <<" *msg = new " << msg_name <<";\n";
-      //      str << "    msg->data = *data;\n";
-      msg_contents->genUnmarshalList4(str);
-      str << "  h[*index]." << name << "(msg);\n";
-      str << "}\n";
-    }
-
-    str << makeDecl("void")<<"::_call_"<<epIdx(0)
-      <<"("<<((param)?"void":"CkArgMsg")<<"* msg, "<<containerType<<"* obj)\n";
-    str << "{\n";
-    if(isThreaded()) str << callThread(epIdx(0));
-    if(isConstructor()) {
-      str << "  new (obj) "<<containerType;
-      if(param) {
-        if(!param->isVoid()) {
-          str << "(("<<param<<")msg);\n";
-        } else {//Constructor takes no msg-- must blow away old parameter
-          str << "();\n";
-          if (container->isArray()) str << "  CkFreeMsg(msg);\n";
-          else str << "  CkFreeSysMsg(msg);\n";
-        }
-      } else {//For main chare--
-        str << "((CkArgMsg*)msg);\n";
-      }
-    } else {//Not a constructor
-      if (fortranMode) { // Fortran90
-        str << "  int index = obj->getIndex();\n";
-        str << "  " << fortranify(name)
-            << "_((char **)(obj->user_data), &index, ";
-        const char* msg_name = param->getBaseName();
-        TypeList *msg_contents = (message_list.find(msg_name))->getContents();
-        msg_contents->genUnmarshalList1(str, param->getBaseName());
-        str << ");\n";
-      } else {
-        if(isThreaded()&&(param->isVoid()))
-          str << freeMsgVoid<<"  obj->"<<name<<"("<<cpType<<");\n";
-       else
-          str << "  obj->"<<name<<"("<<cpType<<");\n"<<freeMsgVoid;
-      }
-    }
-    str << "}\n";
+    if(!container->isNodeGroup()) die("only nodegroup methods can be exclusive",line);
+    if(isConstructor()) die("Constructors cannot be [exclusive]",line);
+    preCall << "  if(CmiTryLock(impl_obj->__nodelock)) {\n"; /*Resend msg. if lock busy*/
+    /******* DANGER-- RESEND CODE UNTESTED **********/
+    preCall << "    CkSendMsgNodeBranch("<<epIdx(1)<<",impl_msg,CkMyNode(),CkGetNodeGroupID());\n";
+    preCall << "    return;\n";
+    preCall << "  }\n";
+    
+    postCall << "  CmiUnlock(impl_obj->__nodelock);\n";
   }
+  
+  //Generate the call-method body
+  str << makeDecl("void")<<"::_call_"<<epIdx(0)<<"(void* impl_msg, "<<containerType<<"* impl_obj)\n";
+  str << "{\n";
+  if(isThreaded()) str << callThread(epIdx(0));
+  str << preCall;
+  param->beginUnmarshall(str);
+  if(isConstructor()) str << "  new (impl_obj) "<<containerType;
+  else str << "  impl_obj->"<<name;
+  str<<"("; param->unmarshall(str); str<<");\n";
+  param->endUnmarshall(str);
+  str << postCall;
+  str << "}\n";
 }
 
 void Entry::genReg(XStr& str)
@@ -1846,30 +1594,199 @@ void Entry::genReg(XStr& str)
   str << "    /* REG: "<<*this << "*/\n";
   if(isConstructor() && container->isAbstract())
     return;
-    
-  str << "      "<<epIdx()<<" = CkRegisterEp(\""<<name 
- <<"\", (CkCallFnPtr)_call_"<<epIdx(0)<<", ";
-  if(param && !param->isVoid() && !(attribs&SMIGRATE)) {
+  
+  str << "      "<<epIdx()<<" = CkRegisterEp(\""<<name<<"("<<paramType(0)
+       <<")\", (CkCallFnPtr)_call_"<<epIdx(0)<<", ";
+  if (param->isMarshalled()) {
+    str<<"CkMarshallMsg::__idx";
+  } else if(!param->isVoid() && !(attribs&SMIGRATE)) {
     param->genMsgProxyName(str);
-    str << "::__idx, ";
+    str <<"::__idx";
   } else {
-    str << "0, ";
-  }
-  str << "__idx);\n";
-  if(container->isMainChare() && isConstructor()) {
-    str << "      CkRegisterMainChare(__idx, "<<epIdx()<<");\n";
+    str << "0";
   }
+  str << ", __idx);\n";
+  if (isConstructor()) {
+    if(container->isMainChare())
+      str << "      CkRegisterMainChare(__idx, "<<epIdx()<<");\n";
+    if(param->isVoid())
+      str << "      CkRegisterDefaultCtor(__idx, "<<epIdx()<<");\n";
+    if(attribs&SMIGRATE)
+      str << "      CkRegisterMigCtor(__idx, "<<epIdx()<<");\n";
+  }
+}
+
+
+/******************* C/C++ Parameter Marshalling ******************
+For entry methods like:
+       entry void foo(int nx,double xarr[nx],complex<float> yarr[ny],long ny);
+
+We generate code on the call-side (in the proxy entry method) to 
+create a message and copy the user's parameters into it.  Scalar
+fields are PUP'd, arrays are just memcpy'd.
+
+The message looks like this:
+
+messagestart>--------- PUP'd data ----------------
+       |  PUP'd nx
+       |  PUP'd offset-to-xarr (from array start, int byte count)
+       |  PUP'd offset-to-yarr
+       |  PUP'd ny
+       +-------------------------------------------
+       |  alignment gap (to multiple of 16 bytes)
+arraystart>------- xarr data ----------
+       | xarr[0]
+       | xarr[1]
+       | ...
+       | xarr[nx-1]
+       +------------------------------
+       |  alignment gap (for yarr-elements)
+       +--------- yarr data ----------
+       | yarr[0]
+       | yarr[1]
+       | ...
+       | yarr[ny-1]
+       +------------------------------
+
+On the recieve side, all the scalar fields are PUP'd to fresh
+stack copies, and the arrays are passed to the user as pointers
+into the message data-- so there's no copy on the receive side.
+
+The message is freed after the user entry returns.
+*/
+Parameter::Parameter(int Nline,Type *Ntype,const char *Nname,
+       const char *NarrLen,Value *Nvalue)
+       :type(Ntype), name(Nname), arrLen(NarrLen), val(Nvalue),line(Nline)
+{
+       if (isMessage())
+               name="impl_msg";
+       if (name==NULL && !isVoid()) 
+       {/*Fabricate a unique name for this marshalled param.*/
+               static int unnamedCount=0;
+               name=new char[50];
+               sprintf((char *)name,"impl_noname_%x",unnamedCount++);
+       }
 }
 
+void ParamList::print(XStr &str,int withDefaultValues)
+{
+       param->print(str,withDefaultValues);
+       if (next) {
+               str<<", ";
+               next->print(str,withDefaultValues);
+       }
+}
+void Parameter::print(XStr &str,int withDefaultValues) 
+{
+       type->print(str);
+       if (arrLen!=NULL)
+               str<<"*";
+       if (name!=NULL)
+               str<<" "<<name;
+       if (withDefaultValues)
+               if (val!=NULL) {str<<" = ";val->print(str);}
+}
 
+void ParamList::callEach(fn_t f,XStr &str)
+{
+       ParamList *cur=this;
+       do { 
+               ((cur->param)->*f)(str);
+       } while (NULL!=(cur=cur->next));
+}
 
+/** marshalling: pack fields into flat byte buffer **/
+void ParamList::marshall(XStr &str,int makeVoid)
+{
+       if (isVoid() && makeVoid)
+               str<<"  void *impl_msg = CkAllocSysMsg();\n";
+       else if (isMarshalled()) 
+       {
+               str<<"  //Marshall: ";print(str,0);str<<"\n";
+               //First pass: find sizes
+               str<<"  int impl_off=0, impl_arrstart=0;\n";
+               callEach(&Parameter::marshallArraySizes,str);
+               str<<"  { //Find the size of the PUP'd data\n";
+               str<<"    PUP::sizer p;\n";
+               callEach(&Parameter::pup,str);
+               str<<"    impl_off+=(impl_arrstart=CK_ALIGN(p.size(),16));\n";
+               str<<"  }\n";
+               //Now that we know the size, allocate the packing buffer
+               str<<"  CkMarshallMsg *impl_msg=new (impl_off,0)CkMarshallMsg();\n";
+               //Second pass: write the data
+               str<<"  { //Copy over the PUP'd data\n";
+               str<<"    PUP::toMem p((void *)impl_msg->msgBuf);\n";
+               callEach(&Parameter::pup,str);
+               str<<"  }\n";
+               str<<"  char *impl_buf=impl_msg->msgBuf+impl_arrstart;\n";
+               callEach(&Parameter::marshallArrayData,str);
+       }
+}
+void Parameter::marshallArraySizes(XStr &str)
+{
+       Type *dt=type->deref();//Type, without &
+       if (dt->isPointer()) 
+               die("can't pass pointers across processors--\n"
+                   "Indicate the array length with []'s, or pass a reference",line);
+       if (isArray()) {
+               str<<"  int impl_off_"<<name<<", impl_cnt_"<<name<<";\n";
+               str<<"  impl_off_"<<name<<"=impl_off=CK_ALIGN(impl_off,sizeof("<<dt<<"));\n";
+               str<<"  impl_off+=(impl_cnt_"<<name<<"=sizeof("<<dt<<")*("<<arrLen<<"));\n";
+       }
+}
+void Parameter::pup(XStr &str) {
+       if (isArray())  str<<"    p|impl_off_"<<name<<";\n";
+       else  str<<"    p|"<<name<<";\n";
+}
+void Parameter::marshallArrayData(XStr &str)
+{
+       if (isArray())
+               str<<"  memcpy(impl_buf+impl_off_"<<name<<
+                       ","<<name<<",impl_cnt_"<<name<<");\n";
+}
 
-
-
-
-
-
-
-
-
-
+/** unmarshalling: unpack fields from flat buffer **/
+void ParamList::beginUnmarshall(XStr &str) 
+{
+       if (isMarshalled()) 
+       {
+               str<<"  //Unmarshall: ";print(str,0);str<<"\n";
+               str<<"  char *impl_buf=((CkMarshallMsg *)impl_msg)->msgBuf;\n";
+               str<<"  PUP::fromMem p(impl_buf);\n";
+               callEach(&Parameter::beginUnmarshall,str);
+               str<<"  impl_buf+=CK_ALIGN(p.size(),16);\n";
+       }
+}
+void Parameter::beginUnmarshall(XStr &str) 
+{
+       Type *dt=type->deref();//Type, without &
+       if (isArray())
+               str<<"  int impl_off_"<<name<<"; p|impl_off_"<<name<<";\n";
+       else
+               str<<"  "<<dt<<" "<<name<<"; p|"<<name<<";\n";
+}
+void ParamList::unmarshall(XStr &str) 
+{
+       if (isMessage()) str<<"("<<param->type<<")impl_msg";
+       else if (isMarshalled()) {
+               param->unmarshall(str);
+               if (next) {
+                       str<<", ";
+                       next->unmarshall(str);
+               }
+       }
+}
+void Parameter::unmarshall(XStr &str)
+{
+       if (isArray())
+               str<<"("<<type->deref()<<" *)(impl_buf+impl_off_"<<name<<")";
+       else
+               str<<name;
+}
+void ParamList::endUnmarshall(XStr &str) 
+{
+       if (isVoid()) {str<<"  CkFreeSysMsg(impl_msg);\n";}
+       else if (isMarshalled()) {
+               str<<"  delete (CkMarshallMsg *)impl_msg;\n";
+       }
+}
index 307b9c853dfbb7c07413a00fbf379fc333797303..d3bcd326164bcd2c1e70894b61b5981b554f5cd9 100644 (file)
 
 #include "xi-util.h"
 
-typedef enum { original, ansi } CompileMode;
-typedef enum { baseType, arrayType } TypeName;
-extern CompileMode compilemode;
+
+/******************* Utilities ****************/
+
+class Chare;//Forward declaration
+class Message;
+class TParamList;
 extern int fortranMode;
+extern const char *cur_file;
+void die(const char *why,int line=-1);
+
+static char *msg_prefix(void) {return (char *) "CMessage_";}
+static char *chare_prefix(void) {return (char *) "CProxy_";}
 
 class Value : public Printable {
   private:
@@ -72,112 +80,64 @@ class ConstructList : public Construct {
     void genReg(XStr& str);
 };
 
-/* Template Instantiation Parameter */
-
-class TParam : public Printable {
-  public:
-    virtual void genSpec(XStr& str)=0;
-};
-
-/* List of Template Instantiation parameters */
-
-class TParamList : public Printable {
-    TParam *tparam;
-    TParamList *next;
-  public:
-    TParamList(TParam *t, TParamList *n=0) : tparam(t), next(n) {}
-    void print(XStr& str);
-    void genSpec(XStr& str);
-};
-class Message;
+/*********************** Type System **********************/
 class Type : public Printable {
-  protected:
-    TypeName name;
   public:
-    Type(): name(baseType) {};
-    TypeName typeName() {return name;}
     virtual void print(XStr&) = 0;
-    virtual int isVoid(void) = 0;
+    virtual int isVoid(void) const {return 0;}
+    virtual int isBuiltin(void) const { return 0; }
+    virtual int isMessage(void) const {return 0;}
+    virtual int isTemplated(void) const { return 0; }
+    virtual int isPointer(void) const {return 0;}
+    virtual int isArray(void) const {return 0;}
+    virtual int isReference(void) const {return 0;}
+    virtual int isConst(void) const {return 0;}
+    virtual Type *deref(void) {return this;}
     virtual const char *getBaseName(void) = 0;
     virtual void genProxyName(XStr &str);
+    virtual void genMsgProxyName(XStr& str);
     virtual void printVar(XStr &str, char *var) {print(str); str<<" "; str<<var;}
 };
 
-class TypeList : public Printable {
-    Type *type;
-    TypeList *next;
-  public:
-    TypeList(Type *t, TypeList *n=0) : type(t), next(n) {}
-    void print(XStr& str);
-    void genProxyNames(XStr& str, const char*, const char*, const char*);
-    void genProxyNames2(XStr& str, const char*, const char*, 
-                        const char*, const char*);
-    void genUnmarshalList0(XStr& str, int depth = 1);
-    void genUnmarshalList1(XStr& str, const char* message_name, int depth = 1);
-    void genUnmarshalList2(XStr& str, int depth=1);
-    void genUnmarshalList3(XStr& str, int depth=1);
-    void genUnmarshalList4(XStr& str, int depth=1);
-};
-
-/* EnType is the type of an entry method parameter, 
-   or return type of an entry method
-*/
-
-class EnType : virtual public Type {
-  public:
-    virtual void print(XStr&) = 0;
-    virtual void genMsgProxyName(XStr& str) { 
-      cerr << "Illegal genMsgProxy call?\n"; 
-      abort(); 
-    }
-};
-
-class SimpleType : virtual public Type {
-};
-
-class BuiltinType : public SimpleType , public EnType {
+class BuiltinType : public Type {
   private:
     const char *name;
   public:
     BuiltinType(const char *n) : name(n) {}
+    int isBuiltin(void) const {return 1;}
     void print(XStr& str) { str << name; }
-    int isVoid(void) { return !strcmp(name, "void"); }
+    int isVoid(void) const { return !strcmp(name, "void"); }
     const char *getBaseName(void) { return name; }
 };
 
-class Chare;//Forward declaration
-static char *msg_prefix(void) {return (char *) "CMessage_";}
-static char *chare_prefix(void) {return (char *) "CProxy_";}
-
-class NamedType : public SimpleType {
+class NamedType : public Type {
   private:
     const char *name;
     TParamList *tparams;
   public:
     NamedType(const char* n, TParamList* t=0)
        : name(n), tparams(t) {}
+    int isTemplated(void) const { return (tparams!=0); }
     void print(XStr& str);
-    int isVoid(void) { return 0; }
     const char *getBaseName(void) { return name; }
-    int isTemplated(void) { return (tparams!=0); }
     virtual void genProxyName(XStr& str) { str << chare_prefix(); print(str);}
     virtual void genMsgProxyName(XStr& str) { str << msg_prefix(); print(str);}
 };
 
-class PtrType : public EnType {
+class PtrType : public Type {
   private:
     Type *type;
     int numstars; // level of indirection
   public:
     PtrType(Type *t) : type(t), numstars(1) {}
+    int isPointer(void) const {return 1;}
+    int isMessage(void) const {return numstars==1 && !type->isBuiltin();}
     void indirect(void) { numstars++; }
     void print(XStr& str);
-    int isVoid(void) { return 0; }
     const char *getBaseName(void) { return type->getBaseName(); }
     virtual void genMsgProxyName(XStr& str) { 
       if(numstars != 1) {
-        cerr << "Illegal Entry Param ?\n"; 
-        abort(); 
+        die("too many stars-- entry parameter must have form 'MTYPE *msg'"); 
       } else {
         str << msg_prefix();
         type->print(str);
@@ -188,35 +148,136 @@ class PtrType : public EnType {
 class ArrayType : public Type {
   private:
     Type *type;
-    Value* dim;
+    Value *dim; // Array length (a constant)
   public:
-    ArrayType(Type* t, Value* d) : type(t), dim(d) {name = arrayType;}
-    void print(XStr& str){type->print(str);str<<"[";dim->print(str);str<<"]";}
-    void printVar(XStr& str, char *var){type->print(str);str<<" ";str<<var;str<<"[";dim->print(str);str<<"]";}
-    void printDim(XStr& str) { dim->print(str); }
-    int isVoid(void) { return 0; }
+    ArrayType(Type *t,Value *d) : type(t), dim(d) {}
+    int isArray(void) const {return 1;}
+    void print(XStr& str) {str<<type<<"["<<dim<<"]";}
     const char *getBaseName(void) { return type->getBaseName(); }
 };
 
+class ReferenceType : public Type {
+  private:
+    Type *referant;
+  public:
+    ReferenceType(Type *t) : referant(t) {}
+    int isReference(void) const {return 1;}
+    void print(XStr& str) {str<<referant<<" &";}
+    virtual Type *deref(void) {return referant;}
+    const char *getBaseName(void) { return referant->getBaseName(); }
+};
+
+class ConstType : public Type {
+  private:
+    Type *type;
+  public:
+    ConstType(Type *t) : type(t) {}
+    int isConst(void) const {return 1;}
+    void print(XStr& str) {str<<"const "<<type;}
+    const char *getBaseName(void) { return type->getBaseName(); }
+};
+
+class TypeList : public Printable {
+    Type *type;
+    TypeList *next;
+  public:
+    TypeList(Type *t, TypeList *n=0) : type(t), next(n) {}
+    void print(XStr& str);
+    void genProxyNames(XStr& str, const char*, const char*, const char*);
+    void genProxyNames2(XStr& str, const char*, const char*, 
+                        const char*, const char*);
+};
+
+/**************** Parameter types & lists (for marshalling) ************/
+class Parameter {
+    Type *type;
+    const char *name; /*The name of the variable, if any*/
+    const char *arrLen; /*The expression for the length of the array;
+                        NULL if not an array*/
+    Value *val; /*Initial value, if any*/
+    int line;
+    friend class ParamList;
+    void pup(XStr &str);
+    void marshallArraySizes(XStr &str);
+    void marshallArrayData(XStr &str);
+    void beginUnmarshall(XStr &str);
+    void unmarshall(XStr &str);
+    void endUnmarshall(XStr &str);
+  public:
+    Parameter(int Nline,Type *Ntype,const char *Nname=0,
+       const char *NarrLen=0,Value *Nvalue=0);
+    void print(XStr &str,int withDefaultValues=0);
+    int isMessage(void) const {return type->isMessage();}
+    int isVoid(void) const {return type->isVoid();}
+    int isArray(void) const {return arrLen!=NULL;}
+    Type *getType(void) {return type;}
+    const char *getName(void) {return name;}
+};
+class ParamList {
+    Parameter *param;
+    ParamList *next;
+    typedef void (Parameter::*fn_t)(XStr &str);
+    void callEach(fn_t f,XStr &str);
+  public:
+    ParamList(Parameter *Nparam,ParamList *Nnext=NULL)
+       :param(Nparam), next(Nnext) {}
+    void print(XStr &str,int withDefaultValues=0);
+    int isMessage(void) const {
+       return (next==NULL) && param->isMessage();
+    }
+    int isVoid(void) const {
+       return (next==NULL) && param->isVoid();
+    }
+    int isMarshalled(void) const {
+       return !isVoid() && !isMessage();
+    }
+    const char *getBaseName(void) {
+       return param->type->getBaseName();
+    }
+    void genMsgProxyName(XStr &str) {
+       param->type->genMsgProxyName(str);
+    }
+    void marshall(XStr &str,int orMakeVoid);
+    void beginUnmarshall(XStr &str);
+    void unmarshall(XStr &str);
+    void endUnmarshall(XStr &str);
+};
+
 class FuncType : public Type {
   private:
     Type *rtype;
     const char *name;
-    TypeList *tlist;
+    ParamList *params;
   public:
-    FuncType(Type* r, const char* n, TypeList* t) :rtype(r),name(n),tlist(t) {}
+    FuncType(Type* r, const char* n, ParamList* p) 
+       :rtype(r),name(n),params(p) {}
     void print(XStr& str) { 
       rtype->print(str);
       str << "(*" << name << ")(";
-      if(tlist)
-        tlist->print(str);
+      if(params)
+        params->print(str);
     }
-    int isVoid(void) { return 0; }
     const char *getBaseName(void) { return name; }
 };
 
-/* A type instantiation parameter */
+/****************** Template Support **************/
+/* Template Instantiation Parameter */
+class TParam : public Printable {
+  public:
+    virtual void genSpec(XStr& str)=0;
+};
 
+/* List of Template Instantiation parameters */
+class TParamList : public Printable {
+    TParam *tparam;
+    TParamList *next;
+  public:
+    TParamList(TParam *t, TParamList *n=0) : tparam(t), next(n) {}
+    void print(XStr& str);
+    void genSpec(XStr& str);
+};
+
+/* A type instantiation parameter */
 class TParamType : public TParam {
   Type *type;
   public:
@@ -226,7 +287,6 @@ class TParamType : public TParam {
 };
 
 /* A Value instantiation parameter */
-
 class TParamVal : public TParam {
     char *val;
   public:
@@ -234,40 +294,7 @@ class TParamVal : public TParam {
     void print(XStr& str) { str << val; }
     void genSpec(XStr& str) { str << val; }
 };
-
-class Chare;
-
-/* Member of a chare or group, i.e. entry, RO or ROM */
-
-class Member : public Printable {
-  protected:
-    Chare *container;
-  public:
-    void setChare(Chare *c) { container = c; }
-    virtual int isPure(void) { return 0; }
-    virtual void genDecls(XStr& str) = 0;
-    virtual void genDefs(XStr& str) = 0;
-    virtual void genReg(XStr& str) = 0;
-    XStr makeDecl(const char *returnType);
-};
-
-/* List of members of a chare or group */
-
-class MemberList : public Printable {
-    Member *member;
-    MemberList *next;
-  public:
-    MemberList(Member *m, MemberList *n=0) : member(m), next(n) {}
-    void print(XStr& str);
-    void setChare(Chare *c);
-    int isPure(void);
-    void genDecls(XStr& str);
-    void genDefs(XStr& str);
-    void genReg(XStr& str);
-};
-
 /* A template construct */
-
 class TVarList;
 class TEntity;
 
@@ -284,35 +311,118 @@ class Template : public Construct {
     void genVars(XStr& str);
 };
 
-
 /* An entity that could be templated, i.e. chare, group or a message */
-
-class TEntity : public Printable {
+class TEntity : public Construct {
   protected:
     Template *templat;
   public:
     void setTemplate(Template *t) { templat = t; }
-    virtual void genDecls(XStr& str) = 0;
-    virtual void genDefs(XStr& str) = 0;
-    virtual void genReg(XStr& str) = 0;
     virtual void genTSpec(XStr& str) { if (templat) templat->genSpec(str); }
     virtual void genTVars(XStr& str) { if (templat) templat->genVars(str); }
 };
+/* A formal argument of a template */
+class TVar : public Printable {
+  public:
+    virtual void genLong(XStr& str) = 0;
+    virtual void genShort(XStr& str) = 0;
+};
 
-/* Chare or group is a templated entity */
+/* a formal type argument */
+class TType : public TVar {
+    Type *type;
+    Type *init;
+  public:
+    TType(Type *t, Type *i=0) : type(t), init(i) {}
+    void print(XStr& str);
+    void genLong(XStr& str);
+    void genShort(XStr& str);
+};
 
-class Chare : public TEntity, public Construct {
+/* a formal function argument */
+class TFunc : public TVar {
+    FuncType *type;
+    char *init;
+  public:
+    TFunc(FuncType *t, char *v=0) : type(t), init(v) {}
+    void print(XStr& str) { type->print(str); if(init) str << "=" << init; }
+    void genLong(XStr& str){ type->print(str); if(init) str << "=" << init; }
+    void genShort(XStr& str) {str << type->getBaseName(); }
+};
+
+/* A formal variable argument */
+class TName : public TVar {
+    Type *type;
+    char *name;
+    char *val;
+  public:
+    TName(Type *t, char *n, char *v=0) : type(t), name(n), val(v) {}
+    void print(XStr& str);
+    void genLong(XStr& str);
+    void genShort(XStr& str);
+};
+
+/* A list of formal arguments to a template */
+class TVarList : public Printable {
+    TVar *tvar;
+    TVarList *next;
+  public:
+    TVarList(TVar *v, TVarList *n=0) : tvar(v), next(n) {}
+    void print(XStr& str);
+    void genLong(XStr& str);
+    void genShort(XStr& str);
+};
+
+/******************* Chares, Arrays, Groups ***********/
+
+/* Member of a chare or group, i.e. entry, RO or ROM */
+class Member : public Construct {
+  protected:
+    Chare *container;
+  public:
+    virtual void setChare(Chare *c) { container = c; }
+    virtual int isPure(void) { return 0; }
+    XStr makeDecl(const char *returnType);
+};
+
+/* List of members of a chare or group */
+class MemberList : public Printable {
+    Member *member;
+    MemberList *next;
+  public:
+    MemberList(Member *m, MemberList *n=0) : member(m), next(n) {}
+    void print(XStr& str);
+    void setChare(Chare *c);
+    int isPure(void);
+    void genDecls(XStr& str);
+    void genDefs(XStr& str);
+    void genReg(XStr& str);
+};
+
+/* Chare or group is a templated entity */
+class Chare : public TEntity {
+  public:
+    enum { //Set these attribute bits in "attrib"
+       CABSTRACT=1<<1, 
+       CMIGRATABLE=1<<2,
+       CMAINCHARE=1<<10,
+       CARRAY=1<<11,
+       CGROUP=1<<12,
+       CNODEGROUP=1<<13
+    };
+    typedef unsigned int attrib_t;
   protected:
+    attrib_t attrib;
+       
     NamedType *type;
     MemberList *list;
     TypeList *bases;
-    int abstract;
-    int migratable;
+    int entryCount;
 
     void genRegisterMethodDecl(XStr& str);
     void genRegisterMethodDef(XStr& str);
   public:
-    Chare(int ln, NamedType *t, TypeList *b=0, MemberList *l=0, int mig=0);
+    Chare(int ln, attrib_t Nattr,
+       NamedType *t, TypeList *b=0, MemberList *l=0);
     void genProxyBases(XStr& str,const char* p,const char* s,const char* sep) {
       bases->genProxyNames(str, p, s, sep);
     }
@@ -332,17 +442,18 @@ class Chare : public TEntity, public Construct {
     }
     int  isTemplated(void) { return (templat!=0); }
     int  isDerived(void) { return (bases!=0); }
-    int  isAbstract(void) { return abstract; }
-    int  isMigratable(void) { return migratable; }
-    virtual int isMainChare(void) {return 0;}
-    virtual int isArray(void) {return 0;}
-    virtual int isGroup(void) {return 0;}
-    virtual int isNodeGroup(void) {return 0;}
-    void setAbstract(int a) { abstract = a; }
+    int  isAbstract(void) { return attrib&CABSTRACT; }
+    int  isMigratable(void) { return attrib&CMIGRATABLE; }
+    int  isMainChare(void) {return attrib&CMAINCHARE;}
+    int  isArray(void) {return attrib&CARRAY;}
+    int  isGroup(void) {return attrib&CGROUP;}
+    int  isNodeGroup(void) {return attrib&CNODEGROUP;}
+    void setAbstract(int a) { if (a) attrib|=CABSTRACT; else attrib&=~CABSTRACT; }
     void print(XStr& str);
     void genDefs(XStr& str);
     void genReg(XStr& str);
     void genDecls(XStr &str);
+    int nextEntry(void) {return entryCount++;}
     virtual void genSubDecls(XStr& str);
     virtual char *chareTypeName(void) {return (char *)"chare";}
     virtual char *proxyPrefix(void) {return (char *) "CProxy_";}
@@ -350,9 +461,9 @@ class Chare : public TEntity, public Construct {
 
 class MainChare : public Chare {
   public:
-    MainChare(int ln, NamedType *t, TypeList *b=0, MemberList *l=0, int mig=0):
-           Chare(ln, t,b,l,mig) {}
-    virtual int isMainChare(void) {return 1;}
+    MainChare(int ln, attrib_t Nattr, 
+       NamedType *t, TypeList *b=0, MemberList *l=0):
+           Chare(ln, Nattr|CMAINCHARE, t,b,l) {}
     virtual char *chareTypeName(void) {return (char *) "mainchare";}
 };
 
@@ -361,9 +472,8 @@ class Array : public Chare {
     XStr indexSuffix;
     XStr indexType;//"CkArrayIndex"+indexSuffix;
   public:
-    Array(int ln, NamedType *index,
+    Array(int ln, attrib_t Nattr, NamedType *index,
        NamedType *t, TypeList *b=0, MemberList *l=0);
-    virtual int isArray(void) {return 1;}
     virtual int is1D(void) {return indexSuffix==(const char*)"1D";}
     virtual void genSubDecls(XStr& str);
     virtual char *chareTypeName(void) {return (char *) "array";}
@@ -371,57 +481,24 @@ class Array : public Chare {
 
 class Group : public Chare {
   public:
-    Group(int ln, NamedType *t, TypeList *b=0, MemberList *l=0, int mig=0):
-           Chare(ln,t,b,l,mig) {}
-    virtual int isGroup(void) {return 1;}
+    Group(int ln, attrib_t Nattr,
+       NamedType *t, TypeList *b=0, MemberList *l=0):
+           Chare(ln,Nattr|CGROUP,t,b,l) {}
     virtual void genSubDecls(XStr& str);
     virtual char *chareTypeName(void) {return (char *) "group";}
 };
 
 class NodeGroup : public Group {
   public:
-    NodeGroup(int ln, NamedType *t, TypeList *b=0, MemberList *l=0,int mig=0):
-           Group(ln,t,b,l,mig) {}
-    virtual int isNodeGroup(void) {return 1;}
+    NodeGroup(int ln, attrib_t Nattr,
+       NamedType *t, TypeList *b=0, MemberList *l=0):
+           Group(ln,Nattr|CNODEGROUP,t,b,l) {}
     virtual char *chareTypeName(void) {return (char *) "nodegroup";}
 };
 
 
+/****************** Messages ***************/
 class Message; // forward declaration
-//  typedef map< string, Message* > MessageList;
-class MessageList {
-  char *messageName;
-  Message *message;
-  MessageList *next;
-public:
-  MessageList():messageName(0), message(0), next(0) {};
-  void add(const char *n, Message *m)
-  {
-    MessageList *item = new MessageList;
-    item->next = next;
-    item->messageName = new char[1+strlen(n)];
-    strcpy(item->messageName, n);
-    item->message = m;
-    next = item;
-  }
-  Message * find(const char *n) const
-  {
-    if (messageName == 0) // first item is a dummy
-      return next->find(n);
-
-    if (strncmp(messageName, n, strlen(n)) == 0)
-      return message;
-    else if (next != 0)
-      return next->find(n);
-    else {
-      cerr << "Unable to find message: " << n << endl;
-      exit(1);
-      return(0);
-    }
-  }
-};
-
-extern MessageList message_list;
 
 class MsgVar {
  public:
@@ -446,9 +523,8 @@ class MsgVarList : public Printable {
   int len(void) { return (next==0)?1:(next->len()+1); }
 };
 
-class Message : public TEntity, public Construct {
+class Message : public TEntity {
     NamedType *type;
-    TypeList *contents;
     MsgVarList *mvlist;
     void printVars(XStr& str) {
       if(mvlist!=0) {
@@ -458,92 +534,37 @@ class Message : public TEntity, public Construct {
       }
     }
   public:
-    Message(int l, NamedType *t, TypeList *c=0, MsgVarList *mv=0)
-      : type(t), contents(c), mvlist(mv) 
-      { line=l; setTemplate(0); message_list.add(type->getBaseName(), this); }
+    Message(int l, NamedType *t, MsgVarList *mv=0)
+      : type(t), mvlist(mv) 
+      { line=l; setTemplate(0); }
     void print(XStr& str);
     void genDecls(XStr& str);
     void genDefs(XStr& str);
     void genReg(XStr& str);
     virtual char *proxyPrefix(void) {return msg_prefix();}
-    TypeList *getContents(void) const { return contents; }
     void genAllocDecl(XStr& str);
     int numVars(void) { return ((mvlist==0) ? 0 : mvlist->len()); }
 };
 
-/* A formal argument of a template */
-
-class TVar : public Printable {
-  public:
-    virtual void genLong(XStr& str) = 0;
-    virtual void genShort(XStr& str) = 0;
-};
-
-/* a formal type argument */
-
-class TType : public TVar {
-    Type *type;
-    Type *init;
-  public:
-    TType(Type *t, Type *i=0) : type(t), init(i) {}
-    void print(XStr& str);
-    void genLong(XStr& str);
-    void genShort(XStr& str);
-};
-
-/* a formal function argument */
-
-class TFunc : public TVar {
-    FuncType *type;
-    char *init;
-  public:
-    TFunc(FuncType *t, char *v=0) : type(t), init(v) {}
-    void print(XStr& str) { type->print(str); if(init) str << "=" << init; }
-    void genLong(XStr& str){ type->print(str); if(init) str << "=" << init; }
-    void genShort(XStr& str) {str << type->getBaseName(); }
-};
-
-/* A formal variable argument */
-
-class TName : public TVar {
-    Type *type;
-    char *name;
-    char *val;
-  public:
-    TName(Type *t, char *n, char *v=0) : type(t), name(n), val(v) {}
-    void print(XStr& str);
-    void genLong(XStr& str);
-    void genShort(XStr& str);
-};
-
-/* A list of formal arguments to a template */
-
-class TVarList : public Printable {
-    TVar *tvar;
-    TVarList *next;
-  public:
-    TVarList(TVar *v, TVarList *n=0) : tvar(v), next(n) {}
-    void print(XStr& str);
-    void genLong(XStr& str);
-    void genShort(XStr& str);
-};
-
-/* An entry construct */
-
+/******************* Entry Point ****************/
+// Entry attributes
 #define STHREADED 0x01
 #define SSYNC     0x02
 #define SLOCKED   0x04
 #define SVIRTUAL  0x08
 #define SPURE     0x10
-#define SMIGRATE 0x20 //<- is magic migration constructor
+#define SMIGRATE  0x20 //<- is magic migration constructor
+#define SCREATEHERE   0x40 //<- is a create-here-if-nonexistant
+#define SCREATEHOME   0x80 //<- is a create-at-home-if-nonexistant
 
+/* An entry construct */
 class Entry : public Member {
   private:
-    int line;
+    int line,entryCount;
     int attribs;
-    EnType *retType;
+    Type *retType;
     char *name;
-    EnType *param;
+    ParamList *param;
     Value *stacksize;
     XStr epIdx(int include__idx_=1);
     void genEpIdxDecl(XStr& str);
@@ -564,18 +585,22 @@ class Entry : public Member {
     void genGroupStaticConstructorDefs(XStr& str);
     void genGroupDefs(XStr& str);
     
-    XStr paramType(void);
-    XStr paramComma(void);
-    XStr voidParamDecl(void);
+    XStr paramType(int withDefaultVals);
+    XStr paramComma(int withDefaultVals);
+    XStr marshallMsg(int orMakeVoid=1);
     XStr callThread(const XStr &procName,int prependEntryName=0);
   public:
-    Entry(int l, int a, EnType *r, char *n, EnType *p, Value *sz=0);
+    Entry(int l, int a, Type *r, char *n, ParamList *p, Value *sz=0);
+    void setChare(Chare *c);
     int getStackSize(void) { return (stacksize ? stacksize->getIntVal() : 0); }
     int isThreaded(void) { return (attribs & STHREADED); }
     int isSync(void) { return (attribs & SSYNC); }
     int isConstructor(void) { return !strcmp(name, container->baseName(0).get_string());}
     int isExclusive(void) { return (attribs & SLOCKED); }
     int isVirtual(void) { return (attribs & SVIRTUAL); }
+    int isCreate(void) { return (attribs & SCREATEHERE)||(attribs & SCREATEHOME); }
+    int isCreateHome(void) { return (attribs & SCREATEHOME); }
+    int isCreateHere(void) { return (attribs & SCREATEHERE); }
     const char *Virtual(void) {return isVirtual()?"virtual ":"";}
     int isPure(void) { return (attribs & SPURE); }
     void print(XStr& str);
@@ -584,6 +609,8 @@ class Entry : public Member {
     void genReg(XStr& str);
 };
 
+
+/****************** Modules, etc. ****************/
 class Module : public Construct {
     int _isMain;
     char *name;
@@ -612,7 +639,7 @@ class ModuleList : public Printable {
     void generate();
 };
 
-class Readonly : public Construct, public Member {
+class Readonly : public Member {
     int msg; // is it a readonly var(0) or msg(1) ?
     Type *type;
     char *name;