Removed the varrays keyword. Made varsize the default and simple version.
authorMilind Bhandarkar <milind@cs.uiuc.edu>
Fri, 23 Feb 2001 22:58:35 +0000 (22:58 +0000)
committerMilind Bhandarkar <milind@cs.uiuc.edu>
Fri, 23 Feb 2001 22:58:35 +0000 (22:58 +0000)
varsize with no fields in .ci file still works as usual.

doc/charm++/messages.tex
src/xlat-i/xi-grammar.tab.C
src/xlat-i/xi-grammar.tab.h
src/xlat-i/xi-grammar.y
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 82bb746ea332fc7dabb4aa40c488bb109e433ab8..5260cc2265679e9905b6f60d376b895912e4881f 100644 (file)
@@ -31,10 +31,12 @@ A variable sized or packed message is declared as:
  message [varsize|packed] MessageType;
 \end{alltt}
 
-A simplified varsize message type called \kw{varrays} message is declared as:
+In addition, the interface translator can make using the \kw{varsize} message 
+less tedious if one specifies the list of variable length arrays that are part
+of the message in the \texttt{.ci} file.
 
 \begin{alltt}
- message [varrays] MessageType \{
+ message [varsize] MessageType \{
    type1 var_name1[];
    type2 var_name2[];
    type3 var_name3[];
@@ -59,20 +61,16 @@ is generated by the charm translator. Then message definition has the form:
 
 \begin{alltt}
  MessageType *msgptr =
-  new [((int *)sizes_array, int priobits=0)] MessageType[(constructor arguments)];
+  new [(int sz1, int sz2, ... , int priobits=0)] MessageType[(constructor arguments)];
 \end{alltt}
 
 The optional arguments to the new operator are used when allocating
-\kw{varsize} or \kw{prioritized} messages. The \uw{sizes\_array} used for
-varsize messages is an array of integer elements of which denote the size (in
+\kw{varsize} or \kw{prioritized} messages. The \uw{sz1, sz2, ...} used for
+varsize messages denote the size (in
 appropriate units) of the memory blocks that need to be allocated and assigned
 to the pointers that the message contains. The \uw{priobits} argument denotes
 the size of a bitfield that will be used to store the message priority.   
 
-The \kw{varrays} message has a \kw{new} operator similar to the \kw{varsize}
-message, except that this \kw{new} operator takes a list of integers as 
-input parameters instead of the \uw{sizes\_array}.
-
 For example, to allocate a \index{varsize message}varsize message whose 
 class declaration is:
 
@@ -81,58 +79,32 @@ class VarsizeMessage : public CMessage_VarsizeMessage \{
   int length;
   int *firstArray;
   double *secondArray;
+  // see explanation later for the following magic
+  VarsizeMessage_VARSIZE_MACROS();
 \};
 \end{alltt}
 
-assign the size array and allocate the message:
+do the following:
 
 \begin{alltt}
-int size[2];
-size[0] = 10;
-size[1] = 20;
-VarsizeMessage *msg = new (size,0) VarsizeMessage;
+VarsizeMessage *msg = new (10, 20, 0) VarsizeMessage;
 \end{alltt}
 
-This allocates a \uw{VarsizeMessage}, in which {\em typically} \uw{firstArray}
-points to an array of 10 ints and \uw{secondArray} points to an array of 20
-doubles. We say typically because the programmer has full control over how the
-sizes array is used. The meaning of this will be made clear in the section on
-variable sized messages.
+This allocates a \uw{VarsizeMessage}, in which \uw{firstArray} points to an
+array of 10 ints and \uw{secondArray} points to an array of 20 doubles.  This
+is explained in detail in later sections. The last parameter 0 specifies
+the priority bits used for this message.
 
 To add a \index{priority}priority bitfield to this message, 
 
 \begin{alltt}
-VarsizeMessage *msg = new (size, sizeof(int)*8) VarsizeMessage;
+VarsizeMessage *msg = new (10, 20, sizeof(int)*8) VarsizeMessage;
 \end{alltt}
 
 Note, you must provide number of bits which is used to store the priority as
 the \uw{priobits} parameter. The section on prioritized execution describes how
 this bitfield is used.
 
-As another example, to allocate a \index{varrays message}varrays message whose 
-class declaration is:
-
-\begin{alltt}
-class VArraysMessage : public CMessage_VArraysMessage \{
-  int length;
-  int *firstArray;
-  double *secondArray;
-  // see explanation later for the following magic
-  VArraysMessage_VARRAYS_MACROS();
-\};
-\end{alltt}
-
-do the following:
-
-\begin{alltt}
-VArraysMessage *msg = new (10, 20, 0) VArraysMessage;
-\end{alltt}
-
-This allocates a \uw{VarraysMessage}, in which \uw{firstArray} points to an
-array of 10 ints and \uw{secondArray} points to an array of 20 doubles.  This
-is explained in detail in later sections. The last parameter 0 specifies
-the priority bits used for this message.
-
 In Section~\ref{message packing} we explain how messages can contain arbitrary
 pointers, and how the validity of such pointers can be maintained across
 processors in a distributed memory machine.
@@ -304,31 +276,29 @@ message.
 A \kw{varsize} message is declared as 
 
 \begin{alltt}
-  message [varsize] mtype;
+ message [varsize] mtype \{
+   type1 var_name1[];
+   type2 var_name2[];
+   type3 var_name3[];
+ \};
 \end{alltt}
 
 in \charmpp\ interface file. The class \uw{mtype} has to inherit from
-\uw{CMessage\_mtype} AND has to provide \kw{pack}, \kw{unpack}, AND \kw{alloc}
-class methods.
-
-Thus, a varsize message is declared in the interface as: 
-
+\uw{CMessage\_mtype} AND has to include a macro generated by the interface
+translator in its public methods section.
+
+\tiny
+\hrule
+This macro provides implementation for three static methods for the message
+class that are needed internally by the \charmpp{} runtime system. These
+methods have the prototypes:
 \begin{alltt}
-message [varsize] VarsizeMessage; 
-\end{alltt}
-
-In the \CC\ header file, it has to be declared as: 
-
-\begin{alltt}
-class VarsizeMessage : public CMessage_VarsizeMessage \{ 
-  public:
-    // Other methods & data members 
     static void* alloc(int msgnum, size_t size, int* array, int priobits);
     static void* pack(VarsizeMessage*);
     static VarsizeMessage* unpack(void*);
-\}; 
 \end{alltt}
-
+One may choose not to use the translator-generated macro and may choose to code
+their own \uw{alloc}, \uw{pack} and \uw{unpack} methods.
 The \kw{alloc} method will be called when the message is allocated using the
 \CC\ \kw{new} operator. The programmer never needs to explicitly call it.  Note
 that all elements of the message are allocated when the message is created with
@@ -336,10 +306,32 @@ that all elements of the message are allocated when the message is created with
 the message.  This differs from a \kw{packed} message where each field requires
 individual allocation.     The \kw{alloc} method should actually allocate the
 message using \kw{CkAllocMsg}, whose signature is given below:
-
 \begin{alltt}
 void *CkAllocMsg(int msgnum, int size, int priobits); 
 \end{alltt}  
+\hrule
+\normalsize
+
+Thus, a varsize message is declared in the interface as: 
+
+\begin{alltt}
+ message [varsize] VarsizeMessage \{
+   Type1 arr1[];
+   Type2 arr2[];
+ \};
+\end{alltt}
+
+In the \CC\ header file, it has to be declared as: 
+
+\begin{alltt}
+class VarsizeMessage : public CMessage_VarsizeMessage \{ 
+  public:
+    // Other methods & data members 
+    // including Type1 *arr1 and Type2 *arr2
+    // and the magical macro
+    VarsizeMessage_VARSIZE_MACROS();
+\}; 
+\end{alltt}
 
 \subsubsection{An Example}
 
@@ -359,10 +351,17 @@ class VarsizeMessage: public CMessage_VarsizeMessage \{
 Then in the \texttt{.ci} file, this can be represented as: 
 
 \begin{alltt}
-message [varsize] VarsizeMessage;
+message [varsize] VarsizeMessage \{
+  int firstArray[];
+  double secondArray[];
+\};
 \end{alltt}
 
-and in the {\tt .h} or {\tt .C} file as:
+We specify the types and actual names of the fields that
+contain variable length arrays. The dimensions of these arrays are not
+specified in the interface file, since they will be specified in the
+constructor of the message when message is created. In the {\tt .h} or {\tt .C}
+file, this class is declared as:
 
 \begin{alltt} 
 
@@ -373,10 +372,25 @@ class VarsizeMessage : public CMessage_VarsizeMessage \{
     int* firstArray;
     double* secondArray;
     // other functions here
+    // and the translator-generated macro
+    VarsizeMessage_VARSIZE_MACROS();
 \};
+\end{alltt}
+
+Note the magical \texttt{VarsizeMessage\_VARRAYS\_MACROS} line at the bottom of
+the \uw{VarraysMessage} class. This is a macro defined in the \texttt{decl.h}
+file by the interface translator.
 
+\tiny
+\hrule
+This macro expands to the static methods
+\texttt{alloc}, \texttt{pack}, and \texttt{unpack} methods of the
+\uw{VarsizeMessage} class. Thus, one is spared from having to write them.
+For example, the above macro would expand to the following code:
+
+\begin{alltt}
 // allocate memory for varmessage so charm can keep track of memory
-void* VarsizeMessage::alloc(int msgnum, size_t size, int* array, int priobits)
+static void* alloc(int msgnum, size_t size, int* array, int priobits)
 \{
   int totalsize, first_start, second_start;
   // array is passed in when the message is allocated using new (see below).
@@ -389,10 +403,6 @@ void* VarsizeMessage::alloc(int msgnum, size_t size, int* array, int priobits)
   totalsize = second_start + array[1]*sizeof(double);
   VarsizeMessage* newMsg = 
     (VarsizeMessage*) CkAllocMsg(msgnum, totalsize, priobits);
-  
-  // store size of array
-  newMsg->lengthFirst = array[0];
-  newMsg->lengthSecond = array[1];
   // make firstArray point to end of newMsg in memory
   newMsg->firstArray = (int*) ((char*)newMsg + first_start);
   // make secondArray point to after end of firstArray in memory
@@ -402,7 +412,7 @@ void* VarsizeMessage::alloc(int msgnum, size_t size, int* array, int priobits)
 \}
 
 // returns pointer to memory containing packed message
-void* VarsizeMessage::pack(VarsizeMessage* in)
+static void* pack(VarsizeMessage* in)
 \{
   // set firstArray an offset from the start of in
   in->firstArray = (int*) ((char*)in->firstArray - (char*)in);
@@ -412,7 +422,7 @@ void* VarsizeMessage::pack(VarsizeMessage* in)
 \}
 
 // returns new message from raw memory
-VarsizeMessage* VarsizeMessage::unpack(void* inbuf)
+static VarsizeMessage* VarsizeMessage::unpack(void* inbuf)
 \{
   VarsizeMessage* me = (VarsizeMessage*)inbuf;
   // return first array to absolute address in memory
@@ -421,82 +431,40 @@ VarsizeMessage* VarsizeMessage::unpack(void* inbuf)
   me->secondArray = (double*) ((size_t)me->secondArray + (char*)me);
   return me;
 \}
-
-int size[2];
-size[0] = 4;               // firstArray will have 4 elements
-size[1] = 5;               // secondArray will have 5 elements 
-VarsizeMessage* p = new(size, 0) VarsizeMessage;
-p->firstArray[2] = 13;     // the arrays have already been allocated 
-p->secondArray[4] = 6.7; 
 \end{alltt}
-
 The pointers in a varsize message can exist in two states.  At creation, they
 are valid \CC\ pointers to the start of the arrays.  After packing, they become
 offsets from the address of the pointer variable to the start of the pointed-to
 data.  Unpacking restores them to pointers. 
+\hrule
+\normalsize
 
-\subsection{Varrays Messages}
-
-Almost always, one finds that one does not need full control over
-allocation, packing and unpacking in varsize messages. A simple case is where a
-\kw{varsize} message contains one or more variable-length arrays of simple
-types (as in the previous example of \kw{varsize} messages). Such messages are
-treated differently by the \charmpp{} interface translator. These are called
-\kw{varrays} messages. \kw{varrays} messages are similar in concept to
-\kw{varsize} messages. However, for \kw{varrays} messages, the translator
-generates the alloc, pack and unpack static methods automatically. For this
-purpose, the translator should be informed about the variable length arrays
-present in the message. This makes the syntax of \kw{varrays} messages
-different thank \kw{varsize} messages. We write the previous example of
-\kw{varsize} messages using \kw{varrays} message to illustrate the differences.
-
-\subsubsection{An Example}
-
-As before, a \charmpp{} message contains two varsize fields, \uw{firstArray}
-and \uw{secondArray}:
-
-\begin{alltt} 
-class VarraysMessage: public CMessage_VarraysMessage \{
-  public:
-    int* firstArray;
-    double* secondArray;
-    // other fields here
-\};
-\end{alltt}
-
-Then in the \texttt{.ci} file, this can be represented as: 
+One can allocate this \kw{varsize} message as follows:
 
 \begin{alltt}
-message [varrays] VarraysMessage \{
-  int firstArray[];
-  double secondArray[];
-\};
+// firstArray will have 4 elements
+// secondArray will have 5 elements 
+VarsizeMessage* p = new(4, 5, 0) VarsizeMessage;
+p->firstArray[2] = 13;     // the arrays have already been allocated 
+p->secondArray[4] = 6.7; 
 \end{alltt}
 
-Note the change in the message attribute. Instead of \kw{varsize}, we specify
-\kw{varrays}. Also, we specify the types and actual names of the fields that
-contain variable length arrays. The dimensions of these arrays are not
-specified in the interface file, since they will be specified in the
-constructor of the message when message is created. In the {\tt .h} or {\tt .C}
-file, this class is declared as:
-
-\begin{alltt} 
-class VarraysMessage: public CMessage_VarraysMessage \{
-  public:
-    int* firstArray;
-    double* secondArray;
-    // other fields here
-    // ...
-    // And now the magic...
-    \textbf{VarraysMessage_VARRAYS_MACROS();}
-\};
+\tiny
+\hrule
+Another way of allocating a varsize message is to pass a \uw{sizes} in an array
+instead of the parameter list. For example,
+\begin{alltt}
+int size[2];
+size[0] = 4;               // firstArray will have 4 elements
+size[1] = 5;               // secondArray will have 5 elements 
+VarsizeMessage* p = new(size, 0) VarsizeMessage;
+p->firstArray[2] = 13;     // the arrays have already been allocated 
+p->secondArray[4] = 6.7; 
 \end{alltt}
+\hrule
+\normalsize
 
-Note the magical \texttt{VarraysMessage\_VARRAYS\_MACROS} line at the bottom of
-the \uw{VarraysMessage} class. This is a macro defined in the \texttt{decl.h}
-file by the interface translator. This macro expands to the static methods
-\texttt{alloc}, \texttt{pack}, and \texttt{unpack} methods of the
-\uw{VarraysMessage} class. Thus, one is spared from having to write them.
+No special handling is needed for deleting \kw{varsize} message.
 
 \subsection{Prioritized Execution}
 \label{prioritized message passing}
index 0cfa85beb4556e28530faad3382e6c6056caa8b3..bf6a9fcf5ed0e4222026e86e7964a8470075eae4 100644 (file)
 #define        VOID    274
 #define        PACKED  275
 #define        VARSIZE 276
-#define        VARRAYS 277
-#define        ENTRY   278
-#define        MAINCHARE       279
-#define        IDENT   280
-#define        NUMBER  281
-#define        LITERAL 282
-#define        INT     283
-#define        LONG    284
-#define        SHORT   285
-#define        CHAR    286
-#define        FLOAT   287
-#define        DOUBLE  288
-#define        UNSIGNED        289
+#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
 
 #line 1 "xi-grammar.y"
 
@@ -89,26 +88,26 @@ typedef union {
 
 
 
-#define        YYFINAL         278
+#define        YYFINAL         277
 #define        YYFLAG          -32768
-#define        YYNTBASE        49
+#define        YYNTBASE        48
 
-#define YYTRANSLATE(x) ((unsigned)(x) <= 289 ? yytranslate[x] : 115)
+#define YYTRANSLATE(x) ((unsigned)(x) <= 288 ? yytranslate[x] : 114)
 
 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,    46,
-    47,    43,     2,    40,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,    37,    36,    41,
-    48,    42,     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,     2,     2,     2,
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-    44,     2,    45,     2,     2,     2,     2,     2,     2,     2,
+    43,     2,    44,     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,    38,     2,    39,     2,     2,     2,     2,     2,
+     2,     2,    37,     2,    38,     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,
@@ -124,7 +123,7 @@ 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,    35
+    27,    28,    29,    30,    31,    32,    33,    34
 };
 
 #if YYDEBUG != 0
@@ -136,64 +135,64 @@ static const short yyprhs[] = {     0,
    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,   215,   216,
-   220,   222,   226,   228,   234,   236,   239,   243,   250,   257,
-   258,   261,   263,   267,   273,   279,   285,   291,   296,   300,
-   306,   312,   318,   324,   330,   336,   341,   342,   345,   346,
-   349,   352,   356,   359,   363,   365,   369,   374,   377,   380,
-   383,   386,   389,   391,   396,   397,   400,   403,   406,   409,
-   417,   425,   430,   431,   435,   437,   441,   443,   445,   447,
-   449,   450,   452,   454,   458,   459,   463,   464
+   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
 };
 
-static const short yyrhs[] = {    50,
-     0,     0,    55,    50,     0,     0,     5,     0,     0,    36,
-     0,    26,     0,    26,     0,    54,    37,    37,    26,     0,
-     3,    53,    56,     0,     4,    53,    56,     0,    36,     0,
-    38,    57,    39,    52,     0,     0,    58,    57,     0,    51,
-    38,    57,    39,    52,     0,    51,    55,     0,    51,    75,
-    36,     0,    51,    76,    36,     0,    51,    85,    36,     0,
-    51,    88,     0,    51,    89,     0,    51,    90,     0,    51,
-    92,     0,    51,   103,     0,    71,     0,    27,     0,    28,
-     0,    59,     0,    59,    40,    60,     0,     0,    60,     0,
-     0,    41,    61,    42,     0,    29,     0,    30,     0,    31,
-     0,    32,     0,    35,    29,     0,    35,    30,     0,    35,
-    31,     0,    35,    32,     0,    30,    30,     0,    33,     0,
-    34,     0,    30,    34,     0,    20,     0,    53,    62,     0,
-    63,     0,    64,     0,    65,    43,     0,    66,    43,     0,
-    67,    43,     0,    27,     0,    53,     0,    71,    44,    68,
-    45,     0,    71,    46,    43,    53,    47,    46,    72,    47,
-     0,    65,     0,    66,     0,    67,     0,    69,     0,    70,
-     0,     0,    71,     0,    71,    40,    72,     0,    44,    68,
-    45,     0,     0,    73,    74,     0,     6,    71,    54,    74,
-     0,     6,    11,    65,    43,    53,     0,     0,    44,    78,
-    45,     0,    79,     0,    79,    40,    78,     0,    21,     0,
-    22,     0,    23,     0,     0,    44,    81,    45,     0,    82,
-     0,    82,    40,    81,     0,    15,     0,    71,    53,    44,
-    45,    36,     0,    83,     0,    83,    84,     0,    11,    77,
-    64,     0,    11,    77,    64,    38,    72,    39,     0,    11,
-    77,    64,    38,    84,    39,     0,     0,    37,    87,     0,
-    64,     0,    64,    40,    87,     0,     7,    80,    64,    86,
-   104,     0,    25,    80,    64,    86,   104,     0,     8,    80,
-    64,    86,   104,     0,     9,    80,    64,    86,   104,     0,
-    44,    27,    53,    45,     0,    44,    53,    45,     0,    10,
-    91,    64,    86,   104,     0,     7,    80,    53,    86,   104,
-     0,    25,    80,    53,    86,   104,     0,     8,    80,    53,
-    86,   104,     0,     9,    80,    53,    86,   104,     0,    10,
-    91,    53,    86,   104,     0,    11,    77,    53,    36,     0,
-     0,    48,    71,     0,     0,    48,    27,     0,    48,    28,
-     0,    12,    53,    98,     0,    70,    99,     0,    71,    53,
-    99,     0,   100,     0,   100,    40,   101,     0,    16,    41,
-   101,    42,     0,   102,    93,     0,   102,    94,     0,   102,
-    95,     0,   102,    96,     0,   102,    97,     0,    36,     0,
-    38,   105,    39,    52,     0,     0,   106,   105,     0,   107,
-    36,     0,    75,    36,     0,    76,    36,     0,    24,   108,
-    20,    53,   112,   114,   113,     0,    24,   108,    66,    53,
-   112,   114,   113,     0,    24,   108,    53,   112,     0,     0,
-    44,   109,    45,     0,   110,     0,   110,    40,   109,     0,
-    14,     0,    17,     0,    18,     0,    19,     0,     0,    20,
-     0,    66,     0,    46,   111,    47,     0,     0,    13,    48,
-    27,     0,     0,    48,    27,     0
+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
 };
 
 #endif
@@ -207,14 +206,14 @@ static const short yyrline[] = { 0,
    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,   304,   306,   310,   312,   314,   318,   320,
-   324,   326,   330,   334,   338,   340,   344,   346,   348,   352,
-   354,   358,   360,   364,   366,   370,   374,   378,   384,   388,
-   392,   394,   398,   402,   406,   410,   414,   416,   420,   422,
-   424,   428,   430,   432,   436,   438,   442,   446,   448,   450,
-   452,   454,   458,   460,   464,   466,   470,   472,   474,   478,
-   480,   482,   486,   488,   492,   494,   498,   500,   502,   504,
-   508,   510,   512,   516,   520,   522,   526,   528
+   294,   298,   300,   304,   306,   310,   312,   316,   318,   322,
+   324,   328,   332,   336,   338,   342,   344,   346,   350,   352,
+   356,   358,   362,   364,   368,   372,   376,   382,   386,   390,
+   392,   396,   400,   404,   408,   412,   414,   418,   420,   422,
+   426,   428,   430,   434,   436,   440,   444,   446,   448,   450,
+   452,   456,   458,   462,   464,   468,   470,   472,   476,   478,
+   480,   484,   486,   490,   492,   496,   498,   500,   502,   506,
+   508,   510,   514,   518,   520,   524,   526
 };
 #endif
 
@@ -224,9 +223,9 @@ static const short yyrline[] = { 0,
 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","VARRAYS","ENTRY","MAINCHARE","IDENT","NUMBER","LITERAL",
-"INT","LONG","SHORT","CHAR","FLOAT","DOUBLE","UNSIGNED","';'","':'","'{'","'}'",
-"','","'<'","'>'","'*'","'['","']'","'('","')'","'='","File","ModuleEList","OptExtern",
+"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",
@@ -240,21 +239,21 @@ static const char * const yytname[] = {   "$","error","$undefined.","MODULE",
 #endif
 
 static const short yyr1[] = {     0,
-    49,    50,    50,    51,    51,    52,    52,    53,    54,    54,
-    55,    55,    56,    56,    57,    57,    58,    58,    58,    58,
-    58,    58,    58,    58,    58,    58,    59,    59,    59,    60,
-    60,    61,    61,    62,    62,    63,    63,    63,    63,    63,
-    63,    63,    63,    63,    63,    63,    63,    63,    64,    65,
-    65,    66,    67,    67,    68,    68,    69,    70,    71,    71,
-    71,    71,    71,    72,    72,    72,    73,    74,    74,    75,
-    76,    77,    77,    78,    78,    79,    79,    79,    80,    80,
-    81,    81,    82,    83,    84,    84,    85,    85,    85,    86,
-    86,    87,    87,    88,    88,    89,    90,    91,    91,    92,
-    93,    93,    94,    95,    96,    97,    98,    98,    99,    99,
-    99,   100,   100,   100,   101,   101,   102,   103,   103,   103,
-   103,   103,   104,   104,   105,   105,   106,   106,   106,   107,
-   107,   107,   108,   108,   109,   109,   110,   110,   110,   110,
-   111,   111,   111,   112,   113,   113,   114,   114
+    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
 };
 
 static const short yyr2[] = {     0,
@@ -265,169 +264,167 @@ static const short yyr2[] = {     0,
      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,     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
+     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
 };
 
 static const short yydefact[] = {     2,
      0,     0,     1,     2,     8,     0,     0,     3,    13,     4,
-    11,    12,     5,     0,     0,     4,     0,    79,    79,    79,
-     0,    72,     0,    79,     4,    18,     0,     0,     0,    22,
+    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,    79,
-    79,    79,     0,    72,    79,   118,   119,   120,   121,   122,
+     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,    83,     0,
-    81,    90,    90,    90,     0,     0,    90,    76,    77,    78,
-     0,    74,    87,     0,    63,     0,   115,     0,    90,     6,
-     0,     0,     0,     0,     0,     0,     0,    28,    29,    30,
-    33,     0,    27,    55,    56,     0,     0,     0,     0,    68,
-    70,    80,     0,     0,     0,     0,     0,     0,    99,     0,
-    73,     0,    64,   107,     0,   113,   109,     0,   117,     0,
-    17,    90,    90,    90,    90,     0,    90,    71,     0,    35,
-    57,     0,     0,     0,    69,    82,    92,    91,   123,   125,
-    94,    96,    97,    98,   100,    75,    65,     0,    85,     0,
-     0,   112,   110,   111,   114,   116,    95,     0,     0,     0,
-     0,   106,     0,    31,     0,    10,    67,     0,   133,     0,
-     0,     0,   125,     0,    64,     0,    88,     0,    86,    89,
-   108,   101,   103,   104,   105,   102,    64,    93,     0,     0,
-   128,   129,     6,   126,   127,    65,    66,     0,     0,   137,
-   138,   139,   140,     0,   135,    48,    34,     0,     0,   124,
-     0,    58,   134,     0,     0,   141,   132,     0,    84,   136,
-   147,    48,   143,     0,   147,     0,   145,   144,   145,   148,
-     0,   130,   131,     0,   146,     0,     0,     0
+    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
 };
 
-static const short yydefgoto[] = {   276,
-     3,    14,    82,    47,    98,     4,    11,    15,    16,   130,
-   131,   132,    91,    48,    49,    50,    51,    52,   136,    53,
-    54,   116,   188,   140,   141,   210,   211,    63,   111,   112,
-    57,   100,   101,   189,   190,    29,   145,   178,    30,    31,
-    32,    61,    33,    76,    77,    78,    79,    80,   192,   156,
-   117,   118,    34,    35,   181,   212,   213,   214,   230,   244,
-   245,   264,   257,   272,   267
+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 yypact[] = {    25,
-   -11,   -11,-32768,    25,-32768,    78,    78,-32768,-32768,     9,
--32768,-32768,-32768,    36,    59,     9,   117,    10,    10,    10,
-    61,    83,    93,    10,     9,-32768,   105,   109,   123,-32768,
--32768,-32768,-32768,    16,-32768,   140,-32768,   158,-32768,-32768,
-    60,-32768,-32768,-32768,-32768,   100,   112,-32768,-32768,   136,
-   138,   139,-32768,-32768,     5,   165,   -11,   -11,   -11,    92,
-   -11,    43,   -11,    77,   -11,   144,-32768,-32768,-32768,    10,
-    10,    10,    61,    83,    10,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,   142,-32768,-32768,-32768,-32768,-32768,-32768,   137,
--32768,-32768,-32768,-32768,-32768,   135,   152,    23,-32768,   153,
-   157,   162,   162,   162,   -11,   155,   162,-32768,-32768,-32768,
-   159,   163,   177,   -11,    15,    12,   174,   186,   162,   140,
-   -11,   -11,   -11,   -11,   -11,   -11,   -11,-32768,-32768,   179,
--32768,   188,    89,-32768,-32768,   171,   -11,   194,   135,   189,
--32768,-32768,   165,   -11,   106,   106,   106,   187,-32768,   106,
--32768,    43,   158,   190,   146,-32768,   191,    77,-32768,   106,
--32768,   162,   162,   162,   162,   198,   162,-32768,   137,-32768,
--32768,   193,   209,   196,-32768,-32768,   197,-32768,-32768,    29,
--32768,-32768,-32768,-32768,-32768,-32768,   114,   203,   158,   204,
-   158,-32768,-32768,-32768,-32768,-32768,-32768,   106,   106,   106,
-   106,-32768,   106,-32768,   200,-32768,-32768,   -11,   205,   208,
-   211,   212,    29,   214,   158,   210,-32768,    12,-32768,-32768,
-    89,-32768,-32768,-32768,-32768,-32768,   158,-32768,    82,   176,
--32768,-32768,   140,-32768,-32768,    47,-32768,   207,   206,-32768,
--32768,-32768,-32768,   213,   215,   -11,    40,   136,   -11,-32768,
-   220,-32768,-32768,    82,   216,   192,-32768,   216,-32768,-32768,
-   217,   219,-32768,   221,   217,   230,   223,-32768,   223,-32768,
-   222,-32768,-32768,   232,-32768,   260,   261,-32768
+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 yypgoto[] = {-32768,
-   259,-32768,  -116,    -1,-32768,   250,   262,    -4,-32768,-32768,
-    98,-32768,-32768,-32768,   -52,   -36,  -220,-32768,   132,-32768,
-   -56,   -14,  -165,-32768,   133,   258,   263,   201,   122,-32768,
-    13,   141,-32768,-32768,    87,-32768,   -85,    70,-32768,-32768,
--32768,   218,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   124,
--32768,   121,-32768,-32768,  -130,    67,-32768,-32768,-32768,    28,
--32768,-32768,  -183,    14,    20
+   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
 };
 
 
-#define        YYLAST          291
+#define        YYLAST          290
 
 
 static const short yytable[] = {     6,
-     7,    83,    55,   161,   102,   103,   104,   115,   107,   249,
-   113,    37,   119,    13,     5,   182,   183,   146,   147,   185,
-    66,   150,    70,    71,    72,    73,    74,     1,     2,   197,
-    95,    58,    59,   160,    17,   263,    65,     5,     1,     2,
-    75,    17,    18,    19,    20,    21,    22,   -15,    96,   237,
-    97,    23,   209,    56,  -109,    96,  -109,    97,   106,   138,
-    24,   239,   155,   108,   109,   110,   139,   222,   223,   224,
-   225,   261,   226,    25,   265,   133,   198,   199,   200,   201,
-    90,   203,   121,   122,   123,   256,   215,   126,   114,    84,
-    96,   177,    97,    85,   135,   240,    39,    36,   241,   242,
-   243,   115,     5,   148,    60,    40,    41,    42,    43,    44,
-    45,    46,   154,     9,   157,    10,   250,     5,   105,   162,
-   163,   164,   165,   166,   167,   168,    62,    38,    86,    87,
-    88,    89,    96,    64,    97,   172,    39,   135,   187,     5,
-    67,   179,     5,   180,    68,    40,    41,    42,    43,    44,
-    45,    46,    90,   215,   133,   177,    39,    96,    69,    97,
-     5,   134,     5,   128,   129,    40,    41,    42,    43,    44,
-    45,    46,   193,   194,   218,    81,   221,    39,    92,    99,
-    93,    94,   120,     5,   127,   216,    40,    41,    42,    43,
-    44,    45,    46,   248,   137,   246,   143,   142,   144,   149,
-   236,     5,   152,   151,    40,    41,    42,    43,    44,    45,
-    46,   262,   236,   158,   153,   171,   216,     5,   169,   248,
-    40,    41,    42,    43,    44,    45,    46,   159,   247,   170,
-   173,   184,   139,   202,   206,   271,   208,   191,   155,   205,
-   207,   217,   220,   231,   255,   227,   232,   258,   229,   235,
-   233,   251,   252,   238,   254,   259,   270,   253,   275,   277,
-   278,   256,     8,    26,   266,  -142,   204,   268,    12,   274,
-   174,    27,   175,   186,   125,   219,    28,   228,   196,   234,
-   195,   260,   273,   176,   269,     0,     0,     0,     0,     0,
-   124
+     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
 };
 
 static const short yycheck[] = {     1,
-     2,    38,    17,   120,    57,    58,    59,    64,    61,   230,
-    63,    16,    65,     5,    26,   146,   147,   103,   104,   150,
-    25,   107,     7,     8,     9,    10,    11,     3,     4,   160,
-    26,    19,    20,   119,     6,   256,    24,    26,     3,     4,
-    25,     6,     7,     8,     9,    10,    11,    39,    44,   215,
-    46,    16,    24,    44,    40,    44,    42,    46,    60,    37,
-    25,   227,    48,    21,    22,    23,    44,   198,   199,   200,
-   201,   255,   203,    38,   258,    90,   162,   163,   164,   165,
-    41,   167,    70,    71,    72,    46,    40,    75,    12,    30,
-    44,   144,    46,    34,    96,    14,    20,    39,    17,    18,
-    19,   158,    26,   105,    44,    29,    30,    31,    32,    33,
-    34,    35,   114,    36,   116,    38,   233,    26,    27,   121,
-   122,   123,   124,   125,   126,   127,    44,    11,    29,    30,
-    31,    32,    44,    41,    46,   137,    20,   139,   153,    26,
-    36,    36,    26,    38,    36,    29,    30,    31,    32,    33,
-    34,    35,    41,    40,   169,   208,    20,    44,    36,    46,
-    26,    27,    26,    27,    28,    29,    30,    31,    32,    33,
-    34,    35,    27,    28,   189,    36,   191,    20,    43,    15,
-    43,    43,    39,    26,    43,   187,    29,    30,    31,    32,
-    33,    34,    35,   230,    43,    20,    40,    45,    37,    45,
-   215,    26,    40,    45,    29,    30,    31,    32,    33,    34,
-    35,    20,   227,    40,    38,    45,   218,    26,    40,   256,
-    29,    30,    31,    32,    33,    34,    35,    42,   230,    42,
-    37,    45,    44,    36,    26,    13,    40,    48,    48,    47,
-    45,    39,    39,    36,   246,    46,    36,   249,    44,    36,
-    39,    45,    47,    44,    40,    36,    27,    45,    27,     0,
-     0,    46,     4,    14,    48,    47,   169,    47,     7,    48,
-   139,    14,   140,   152,    74,   189,    14,   208,   158,   213,
-   157,   254,   269,   143,   265,    -1,    -1,    -1,    -1,    -1,
-    73
+     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
 };
 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
-#line 3 "/usr/lib/bison.simple"
+#line 3 "/home/csar2/bhandark/share/bison.simple"
 /* This file comes from bison-1.28.  */
 
 /* Skeleton output parser for bison,
@@ -641,7 +638,7 @@ __yy_memcpy (char *to, char *from, unsigned int count)
 #endif
 #endif
 \f
-#line 217 "/usr/lib/bison.simple"
+#line 217 "/home/csar2/bhandark/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 *.
@@ -1282,168 +1279,168 @@ case 77:
 { yyval.intval = SVARSIZE; ;
     break;}
 case 78:
-#line 315 "xi-grammar.y"
-{ yyval.intval = SVARRAYS; ;
+#line 317 "xi-grammar.y"
+{ yyval.intval = 0; ;
     break;}
 case 79:
 #line 319 "xi-grammar.y"
-{ yyval.intval = 0; ;
+{ yyval.intval = yyvsp[-1].intval; ;
     break;}
 case 80:
-#line 321 "xi-grammar.y"
-{ yyval.intval = yyvsp[-1].intval; ;
+#line 323 "xi-grammar.y"
+{ yyval.intval = yyvsp[0].intval; ;
     break;}
 case 81:
 #line 325 "xi-grammar.y"
-{ yyval.intval = yyvsp[0].intval; ;
+{ yyval.intval = yyvsp[-2].intval | yyvsp[0].intval; ;
     break;}
 case 82:
-#line 327 "xi-grammar.y"
-{ yyval.intval = yyvsp[-2].intval | yyvsp[0].intval; ;
+#line 329 "xi-grammar.y"
+{ yyval.intval = 0x01; ;
     break;}
 case 83:
-#line 331 "xi-grammar.y"
-{ yyval.intval = 0x01; ;
+#line 333 "xi-grammar.y"
+{ yyval.mv = new MsgVar(yyvsp[-4].type, yyvsp[-3].strval); ;
     break;}
 case 84:
-#line 335 "xi-grammar.y"
-{ yyval.mv = new MsgVar(yyvsp[-4].type, yyvsp[-3].strval); ;
+#line 337 "xi-grammar.y"
+{ yyval.mvlist = new MsgVarList(yyvsp[0].mv); ;
     break;}
 case 85:
 #line 339 "xi-grammar.y"
-{ yyval.mvlist = new MsgVarList(yyvsp[0].mv); ;
+{ yyval.mvlist = new MsgVarList(yyvsp[-1].mv, yyvsp[0].mvlist); ;
     break;}
 case 86:
-#line 341 "xi-grammar.y"
-{ yyval.mvlist = new MsgVarList(yyvsp[-1].mv, yyvsp[0].mvlist); ;
+#line 343 "xi-grammar.y"
+{ yyval.message = new Message(lineno, yyvsp[0].ntype, yyvsp[-1].intval); ;
     break;}
 case 87:
 #line 345 "xi-grammar.y"
-{ yyval.message = new Message(lineno, yyvsp[0].ntype, yyvsp[-1].intval); ;
+{ yyval.message = new Message(lineno, yyvsp[-3].ntype, yyvsp[-4].intval, yyvsp[-1].typelist); ;
     break;}
 case 88:
 #line 347 "xi-grammar.y"
-{ yyval.message = new Message(lineno, yyvsp[-3].ntype, yyvsp[-4].intval, yyvsp[-1].typelist); ;
+{ yyval.message = new Message(lineno, yyvsp[-3].ntype, yyvsp[-4].intval, 0, yyvsp[-1].mvlist); ;
     break;}
 case 89:
-#line 349 "xi-grammar.y"
-{ yyval.message = new Message(lineno, yyvsp[-3].ntype, yyvsp[-4].intval, 0, yyvsp[-1].mvlist); ;
+#line 351 "xi-grammar.y"
+{ yyval.typelist = 0; ;
     break;}
 case 90:
 #line 353 "xi-grammar.y"
-{ yyval.typelist = 0; ;
+{ yyval.typelist = yyvsp[0].typelist; ;
     break;}
 case 91:
-#line 355 "xi-grammar.y"
-{ yyval.typelist = yyvsp[0].typelist; ;
+#line 357 "xi-grammar.y"
+{ yyval.typelist = new TypeList(yyvsp[0].ntype); ;
     break;}
 case 92:
 #line 359 "xi-grammar.y"
-{ yyval.typelist = new TypeList(yyvsp[0].ntype); ;
+{ yyval.typelist = new TypeList(yyvsp[-2].ntype, yyvsp[0].typelist); ;
     break;}
 case 93:
-#line 361 "xi-grammar.y"
-{ yyval.typelist = new TypeList(yyvsp[-2].ntype, yyvsp[0].typelist); ;
+#line 363 "xi-grammar.y"
+{ yyval.chare = new Chare(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
     break;}
 case 94:
 #line 365 "xi-grammar.y"
-{ yyval.chare = new Chare(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
-    break;}
-case 95:
-#line 367 "xi-grammar.y"
 { yyval.chare = new MainChare(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
     break;}
-case 96:
-#line 371 "xi-grammar.y"
+case 95:
+#line 369 "xi-grammar.y"
 { yyval.chare = new Group(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
     break;}
-case 97:
-#line 375 "xi-grammar.y"
+case 96:
+#line 373 "xi-grammar.y"
 { yyval.chare = new NodeGroup(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
     break;}
-case 98:
-#line 379 "xi-grammar.y"
+case 97:
+#line 377 "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 99:
-#line 385 "xi-grammar.y"
+case 98:
+#line 383 "xi-grammar.y"
 { yyval.ntype = new NamedType(yyvsp[-1].strval); ;
     break;}
-case 100:
-#line 389 "xi-grammar.y"
+case 99:
+#line 387 "xi-grammar.y"
 { yyval.chare = new Array(lineno, yyvsp[-3].ntype, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
     break;}
+case 100:
+#line 391 "xi-grammar.y"
+{ yyval.chare = new Chare(lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval);;
+    break;}
 case 101:
 #line 393 "xi-grammar.y"
-{ yyval.chare = new Chare(lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval);;
+{ yyval.chare = new MainChare(lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
     break;}
 case 102:
-#line 395 "xi-grammar.y"
-{ yyval.chare = new MainChare(lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
+#line 397 "xi-grammar.y"
+{ yyval.chare = new Group(lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
     break;}
 case 103:
-#line 399 "xi-grammar.y"
-{ yyval.chare = new Group(lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
+#line 401 "xi-grammar.y"
+{ yyval.chare = new NodeGroup( lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
     break;}
 case 104:
-#line 403 "xi-grammar.y"
-{ yyval.chare = new NodeGroup( lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
+#line 405 "xi-grammar.y"
+{ yyval.chare = new Array( lineno, yyvsp[-3].ntype, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
     break;}
 case 105:
-#line 407 "xi-grammar.y"
-{ yyval.chare = new Array( lineno, yyvsp[-3].ntype, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
+#line 409 "xi-grammar.y"
+{ yyval.message = new Message(lineno, new NamedType(yyvsp[-1].strval), yyvsp[-2].intval); ;
     break;}
 case 106:
-#line 411 "xi-grammar.y"
-{ yyval.message = new Message(lineno, new NamedType(yyvsp[-1].strval), yyvsp[-2].intval); ;
+#line 413 "xi-grammar.y"
+{ yyval.type = 0; ;
     break;}
 case 107:
 #line 415 "xi-grammar.y"
-{ yyval.type = 0; ;
+{ yyval.type = yyvsp[0].type; ;
     break;}
 case 108:
-#line 417 "xi-grammar.y"
-{ yyval.type = yyvsp[0].type; ;
+#line 419 "xi-grammar.y"
+{ yyval.strval = 0; ;
     break;}
 case 109:
 #line 421 "xi-grammar.y"
-{ yyval.strval = 0; ;
+{ yyval.strval = yyvsp[0].strval; ;
     break;}
 case 110:
 #line 423 "xi-grammar.y"
 { yyval.strval = yyvsp[0].strval; ;
     break;}
 case 111:
-#line 425 "xi-grammar.y"
-{ yyval.strval = yyvsp[0].strval; ;
+#line 427 "xi-grammar.y"
+{ yyval.tvar = new TType(new NamedType(yyvsp[-1].strval), yyvsp[0].type); ;
     break;}
 case 112:
 #line 429 "xi-grammar.y"
-{ yyval.tvar = new TType(new NamedType(yyvsp[-1].strval), yyvsp[0].type); ;
+{ yyval.tvar = new TFunc(yyvsp[-1].ftype, yyvsp[0].strval); ;
     break;}
 case 113:
 #line 431 "xi-grammar.y"
-{ yyval.tvar = new TFunc(yyvsp[-1].ftype, yyvsp[0].strval); ;
+{ yyval.tvar = new TName(yyvsp[-2].type, yyvsp[-1].strval, yyvsp[0].strval); ;
     break;}
 case 114:
-#line 433 "xi-grammar.y"
-{ yyval.tvar = new TName(yyvsp[-2].type, yyvsp[-1].strval, yyvsp[0].strval); ;
+#line 435 "xi-grammar.y"
+{ yyval.tvarlist = new TVarList(yyvsp[0].tvar); ;
     break;}
 case 115:
 #line 437 "xi-grammar.y"
-{ yyval.tvarlist = new TVarList(yyvsp[0].tvar); ;
+{ yyval.tvarlist = new TVarList(yyvsp[-2].tvar, yyvsp[0].tvarlist); ;
     break;}
 case 116:
-#line 439 "xi-grammar.y"
-{ yyval.tvarlist = new TVarList(yyvsp[-2].tvar, yyvsp[0].tvarlist); ;
+#line 441 "xi-grammar.y"
+{ yyval.tvarlist = yyvsp[-1].tvarlist; ;
     break;}
 case 117:
-#line 443 "xi-grammar.y"
-{ yyval.tvarlist = yyvsp[-1].tvarlist; ;
+#line 445 "xi-grammar.y"
+{ yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
     break;}
 case 118:
 #line 447 "xi-grammar.y"
@@ -1459,121 +1456,117 @@ case 120:
     break;}
 case 121:
 #line 453 "xi-grammar.y"
-{ yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
+{ yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].message); yyvsp[0].message->setTemplate(yyval.templat); ;
     break;}
 case 122:
-#line 455 "xi-grammar.y"
-{ yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].message); yyvsp[0].message->setTemplate(yyval.templat); ;
+#line 457 "xi-grammar.y"
+{ yyval.mbrlist = 0; ;
     break;}
 case 123:
 #line 459 "xi-grammar.y"
-{ yyval.mbrlist = 0; ;
+{ yyval.mbrlist = yyvsp[-2].mbrlist; ;
     break;}
 case 124:
-#line 461 "xi-grammar.y"
-{ yyval.mbrlist = yyvsp[-2].mbrlist; ;
+#line 463 "xi-grammar.y"
+{ yyval.mbrlist = 0; ;
     break;}
 case 125:
 #line 465 "xi-grammar.y"
-{ yyval.mbrlist = 0; ;
+{ yyval.mbrlist = new MemberList(yyvsp[-1].member, yyvsp[0].mbrlist); ;
     break;}
 case 126:
-#line 467 "xi-grammar.y"
-{ yyval.mbrlist = new MemberList(yyvsp[-1].member, yyvsp[0].mbrlist); ;
+#line 469 "xi-grammar.y"
+{ yyval.member = yyvsp[-1].entry; ;
     break;}
 case 127:
 #line 471 "xi-grammar.y"
-{ yyval.member = yyvsp[-1].entry; ;
+{ yyval.member = yyvsp[-1].readonly; ;
     break;}
 case 128:
 #line 473 "xi-grammar.y"
 { yyval.member = yyvsp[-1].readonly; ;
     break;}
 case 129:
-#line 475 "xi-grammar.y"
-{ yyval.member = yyvsp[-1].readonly; ;
+#line 477 "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); ;
     break;}
 case 130:
 #line 479 "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.entry = new Entry(lineno, yyvsp[-5].intval|yyvsp[-1].intval, yyvsp[-4].ptype, yyvsp[-3].strval, yyvsp[-2].rtype, yyvsp[0].val); ;
     break;}
 case 131:
 #line 481 "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); ;
+{ yyval.entry = new Entry(lineno, yyvsp[-2].intval, 0, yyvsp[-1].strval, yyvsp[0].rtype, 0); ;
     break;}
 case 132:
-#line 483 "xi-grammar.y"
-{ yyval.entry = new Entry(lineno, yyvsp[-2].intval, 0, yyvsp[-1].strval, yyvsp[0].rtype, 0); ;
+#line 485 "xi-grammar.y"
+{ yyval.intval = 0; ;
     break;}
 case 133:
 #line 487 "xi-grammar.y"
-{ yyval.intval = 0; ;
+{ yyval.intval = yyvsp[-1].intval; ;
     break;}
 case 134:
-#line 489 "xi-grammar.y"
-{ yyval.intval = yyvsp[-1].intval; ;
+#line 491 "xi-grammar.y"
+{ yyval.intval = yyvsp[0].intval; ;
     break;}
 case 135:
 #line 493 "xi-grammar.y"
-{ yyval.intval = yyvsp[0].intval; ;
+{ yyval.intval = yyvsp[-2].intval | yyvsp[0].intval; ;
     break;}
 case 136:
-#line 495 "xi-grammar.y"
-{ yyval.intval = yyvsp[-2].intval | yyvsp[0].intval; ;
+#line 497 "xi-grammar.y"
+{ yyval.intval = STHREADED; ;
     break;}
 case 137:
 #line 499 "xi-grammar.y"
-{ yyval.intval = STHREADED; ;
+{ yyval.intval = SSYNC; ;
     break;}
 case 138:
 #line 501 "xi-grammar.y"
-{ yyval.intval = SSYNC; ;
+{ yyval.intval = SLOCKED; ;
     break;}
 case 139:
 #line 503 "xi-grammar.y"
-{ yyval.intval = SLOCKED; ;
+{ yyval.intval = SVIRTUAL; ;
     break;}
 case 140:
-#line 505 "xi-grammar.y"
-{ yyval.intval = SVIRTUAL; ;
+#line 507 "xi-grammar.y"
+{ yyval.rtype = 0; ;
     break;}
 case 141:
 #line 509 "xi-grammar.y"
-{ yyval.rtype = 0; ;
+{ yyval.rtype = new BuiltinType("void"); ;
     break;}
 case 142:
 #line 511 "xi-grammar.y"
-{ yyval.rtype = new BuiltinType("void"); ;
+{ yyval.rtype = yyvsp[0].ptype; ;
     break;}
 case 143:
-#line 513 "xi-grammar.y"
-{ yyval.rtype = yyvsp[0].ptype; ;
+#line 515 "xi-grammar.y"
+{ yyval.rtype = yyvsp[-1].rtype; ;
     break;}
 case 144:
-#line 517 "xi-grammar.y"
-{ yyval.rtype = yyvsp[-1].rtype; ;
+#line 519 "xi-grammar.y"
+{ yyval.val = 0; ;
     break;}
 case 145:
 #line 521 "xi-grammar.y"
-{ yyval.val = 0; ;
+{ yyval.val = new Value(yyvsp[0].strval); ;
     break;}
 case 146:
-#line 523 "xi-grammar.y"
-{ yyval.val = new Value(yyvsp[0].strval); ;
+#line 525 "xi-grammar.y"
+{ yyval.intval = 0; ;
     break;}
 case 147:
 #line 527 "xi-grammar.y"
-{ yyval.intval = 0; ;
-    break;}
-case 148:
-#line 529 "xi-grammar.y"
 { if(strcmp(yyvsp[0].strval, "0")) { yyerror("expected 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 543 "/home/csar2/bhandark/share/bison.simple"
 \f
   yyvsp -= yylen;
   yyssp -= yylen;
@@ -1793,7 +1786,7 @@ yyerrhandle:
     }
   return 1;
 }
-#line 533 "xi-grammar.y"
+#line 531 "xi-grammar.y"
 
 void yyerror(const char *mesg)
 {
index ee4f98ae6957425ce8a35af4a5c6161171a9b8c3..eee1976d766f0e2decfcd7174eaf7b54aefd8de6 100644 (file)
@@ -47,19 +47,18 @@ typedef union {
 #define        VOID    274
 #define        PACKED  275
 #define        VARSIZE 276
-#define        VARRAYS 277
-#define        ENTRY   278
-#define        MAINCHARE       279
-#define        IDENT   280
-#define        NUMBER  281
-#define        LITERAL 282
-#define        INT     283
-#define        LONG    284
-#define        SHORT   285
-#define        CHAR    286
-#define        FLOAT   287
-#define        DOUBLE  288
-#define        UNSIGNED        289
+#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
 
 
 extern YYSTYPE yylval;
index 046ba2f3494b362db2792a16ff432bb484314d19..57268bba0a12e3e00f7bbfb357faae7b6aca3674 100644 (file)
@@ -53,7 +53,7 @@ ModuleList *modlist;
 %token SYNC EXCLUSIVE VIRTUAL
 %token VOID
 %token PACKED
-%token VARSIZE VARRAYS
+%token VARSIZE
 %token ENTRY
 %token <intval> MAINCHARE
 %token <strval> IDENT NUMBER LITERAL
@@ -311,8 +311,6 @@ MAttrib             : PACKED
                { $$ = SPACKED; }
                | VARSIZE
                { $$ = SVARSIZE; }
-               | VARRAYS
-               { $$ = SVARRAYS; }
                ;
 
 CAttribs       : /* Empty */
index 7bc3b2bf73319139d155b324e965254477c01648..8971722fd5800107a3ed5e956702b870ecdf4823 100644 (file)
@@ -9,7 +9,6 @@
 #define YY_FLEX_MINOR_VERSION 5
 
 #include <stdio.h>
-#include <unistd.h>
 
 
 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
@@ -23,6 +22,7 @@
 #ifdef __cplusplus
 
 #include <stdlib.h>
+#include <unistd.h>
 
 /* Use prototypes in function declarations. */
 #define YY_USE_PROTOS
@@ -560,7 +560,7 @@ YY_MALLOC_DECL
 YY_DECL
        {
        register yy_state_type yy_current_state;
-       register char *yy_cp = NULL, *yy_bp = NULL;
+       register char *yy_cp, *yy_bp;
        register int yy_act;
 
 #line 48 "xi-scan.l"
@@ -1269,6 +1269,11 @@ YY_BUFFER_STATE b;
        }
 
 
+#ifndef YY_ALWAYS_INTERACTIVE
+#ifndef YY_NEVER_INTERACTIVE
+extern int isatty YY_PROTO(( int ));
+#endif
+#endif
 
 #ifdef YY_USE_PROTOS
 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
@@ -1616,7 +1621,6 @@ struct rwtable rwtable[] = {
   "mainchare", MAINCHARE,
   "packed",     PACKED,
   "varsize",    VARSIZE,
-  "varrays",    VARRAYS,
   "entry",      ENTRY,
   "int",        INT,
   "short",      SHORT,
index d9ca1de1e7b2f75528b1291fa43be13ddcf8b67e..44d3b563748c7418f945d8f3bfb3a7bcaecc7379 100644 (file)
@@ -87,7 +87,6 @@ struct rwtable rwtable[] = {
   "mainchare", MAINCHARE,
   "packed",     PACKED,
   "varsize",    VARSIZE,
-  "varrays",    VARRAYS,
   "entry",      ENTRY,
   "int",        INT,
   "short",      SHORT,
index 2983b11d543a433c28d98c1db7fc24a185e38418..1928d9501c78c3d7bad6ece93c19c4c65cfe0aee 100644 (file)
@@ -777,7 +777,8 @@ Message::genAllocDecl(XStr &str)
     if(compilemode==ansi)
       str << CIAllocDeclAnsi;
     else str << CIAllocDecl;
-  } else if(isVarrays()) {
+  }
+  if(isVarrays()) {
     int num = mvlist->len();
     str << "    void *operator new(size_t s,";
     int i;
@@ -801,7 +802,7 @@ Message::genVarraysMacros(XStr& str)
   MsgVarList *ml = mvlist;
   MsgVar *mv = ml->msg_var;
   int i;
-  str << "\n#define " << type << "_VARRAYS_MACROS() \\\n";
+  str << "\n#define " << type << "_VARSIZE_MACROS() \\\n";
   str << "  static void* alloc(int msgnum, int sz, int *sizes, int pb) {\\\n";
   str << "    int offsets[" << num+1 << "];\\\n";
   str << "    offsets[0] = ALIGN8(sz);\\\n";
@@ -1005,7 +1006,7 @@ Message::genReg(XStr& str)
   if(!templat && !external) {
     str << "  "<<proxyPrefix()<<type<<"::";
     str << "__register(\""<<type<<"\", sizeof("<<type<<"),";
-    if(isPacked()||isVarsize()||isVarrays()) {
+    if(isPacked()||isVarsize()) {
       str << "(CkPackFnPtr) "<<type;
       if(templat)
         templat->genVars(str);
index ca83f96b860a11493e4319316d3264f1d5c84c59..3ad593dbec5a21af9992a0a14e48af83d1325837 100644 (file)
@@ -389,7 +389,6 @@ class NodeGroup : public Group {
 
 #define SPACKED  0x01
 #define SVARSIZE 0x02
-#define SVARRAYS 0x04
 
 class Message; // forward declaration
 //  typedef map< string, Message* > MessageList;
@@ -466,7 +465,7 @@ class Message : public TEntity, public Construct {
     void genReg(XStr& str);
     int  isPacked(void) { return attrib&SPACKED; }
     int  isVarsize(void) { return attrib&SVARSIZE; }
-    int  isVarrays(void) { return attrib&SVARRAYS; }
+    int  isVarrays(void) { return (isVarsize() && (mvlist!=0)); }
     virtual char *proxyPrefix(void) {return msg_prefix();}
     TypeList *getContents(void) const { return contents; }
     void genAllocDecl(XStr& str);