charmxi: Fix most warnings and simplify code
authorPhil Miller <mille121@illinois.edu>
Tue, 3 May 2011 01:25:31 +0000 (20:25 -0500)
committerPhil Miller <mille121@illinois.edu>
Tue, 3 May 2011 01:25:31 +0000 (20:25 -0500)
Silence nearly all warnings generated by g++ -Wall -Wextra.

src/xlat-i/sdag/CSdagConstruct.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
src/xlat-i/xi-util.C

index f5f8815c9752daa620bcab67cb392014a9b92207..056e3b14e4a626251dd4322b3455021c9acd5f3b 100644 (file)
@@ -240,7 +240,6 @@ void SdagConstruct::generateConnectEntries(XStr& op){
    op << "  void " <<connectEntry->charstar() <<'(';
    ParamList *pl = param;
    XStr msgParams;
-   int i, numStars;
    int count;
    if (pl->isVoid() == 1) {
      op << "void) {\n"; 
@@ -338,7 +337,6 @@ void SdagConstruct::propagateState(int uniqueVarNum)
 void SdagConstruct::propagateState(TList<CStateVar*>& list, TList<CStateVar*>& wlist, TList<SdagConstruct*>& publist, int uniqueVarNum)
 {
   CStateVar *sv;
-  int i;
   TList <CStateVar*> *olistTempStateVars;
   TList<CStateVar*> *whensEntryMethodStateVars; 
   olistTempStateVars = new TList<CStateVar*>();
@@ -1424,7 +1422,6 @@ void SdagConstruct::generateAtomic(XStr& op)
 #if CMK_BLUEGENE_CHARM
   generateEndExec(op);
 #endif
-  SdagConstruct *cn;
   if(nextBeginOrEnd == 1)
     op << "    " << next->label->charstar() << "(";
   else
@@ -1595,7 +1592,7 @@ void SdagConstruct::generateTrace()
     if (traceName) {
       sprintf(text, "%s_%s", CParsedFile::className->charstar(), traceName->charstar());
       // remove blanks
-      for (int i=0; i<strlen(text); i++)
+      for (unsigned int i=0; i<strlen(text); i++)
         if (text[i]==' '||text[i]=='\t') text[i]='_';
     }
     else {
@@ -1664,6 +1661,7 @@ void SdagConstruct::generateEndSeq(XStr& op)
 
 void SdagConstruct::generateEventBracket(XStr& op, int eventType)
 {
+  (void) eventType;
   //Trace this event
   op << "     _TRACE_BG_USER_EVENT_BRACKET(\"" << nameStr
      << "\", __begintime, CkVTimer(),&_bgParentLog); \n";
@@ -1671,6 +1669,7 @@ void SdagConstruct::generateEventBracket(XStr& op, int eventType)
 
 void SdagConstruct::generateListEventBracket(XStr& op, int eventType)
 {
+  (void) eventType;
   op << "    _TRACE_BGLIST_USER_EVENT_BRACKET(\"" << nameStr
      << "\",__begintime,CkVTimer(),&_bgParentLog, " << label->charstar()
      << "_bgLogList);\n";
@@ -1728,7 +1727,7 @@ void SdagConstruct::generateTraceEpDef(XStr& op)          // for trace
 void RemoveSdagComments(char *str)
 {
   char *ptr = str;
-  while (ptr = strstr(ptr, "//")) {
+  while ((ptr = strstr(ptr, "//"))) {
     char *lend = strstr(ptr, "\n");
     if (lend==NULL) break;
     while (ptr != lend) *ptr++=' ';
index 8d13af598c56325e2f56039be9154787b8f824a0..cdf7fb121c240991bb09f170d7baf07ae11e44d8 100644 (file)
@@ -8,7 +8,7 @@
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 33
+#define YY_FLEX_SUBMINOR_VERSION 35
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
@@ -30,7 +30,7 @@
 
 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
 
-#if __STDC_VERSION__ >= 199901L
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
 
 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  * if you want the limit (max/min) macros for int types. 
@@ -53,7 +53,6 @@ typedef int flex_int32_t;
 typedef unsigned char flex_uint8_t; 
 typedef unsigned short int flex_uint16_t;
 typedef unsigned int flex_uint32_t;
-#endif /* ! C99 */
 
 /* Limits of integral types. */
 #ifndef INT8_MIN
@@ -84,6 +83,8 @@ typedef unsigned int flex_uint32_t;
 #define UINT32_MAX             (4294967295U)
 #endif
 
+#endif /* ! C99 */
+
 #endif /* ! FLEXINT_H */
 
 #ifdef __cplusplus
@@ -93,11 +94,12 @@ typedef unsigned int flex_uint32_t;
 
 #else  /* ! __cplusplus */
 
-#if __STDC__
+/* C99 requires __STDC__ to be defined as 1. */
+#if defined (__STDC__)
 
 #define YY_USE_CONST
 
-#endif /* __STDC__ */
+#endif /* defined (__STDC__) */
 #endif /* ! __cplusplus */
 
 #ifdef YY_USE_CONST
@@ -139,7 +141,15 @@ typedef unsigned int flex_uint32_t;
 
 /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
 #define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
 #endif
 
 /* The state buf must be large enough to hold one state per character in the main buffer.
@@ -177,14 +187,9 @@ extern FILE *yyin, *yyout;
 
 #define unput(c) yyunput( c, (yytext_ptr)  )
 
-/* The following is because we cannot portably get our hands on size_t
- * (without autoconf's help, which isn't available because we want
- * flex-generated scanners to compile on their own).
- */
-
 #ifndef YY_TYPEDEF_YY_SIZE_T
 #define YY_TYPEDEF_YY_SIZE_T
-typedef unsigned int yy_size_t;
+typedef size_t yy_size_t;
 #endif
 
 #ifndef YY_STRUCT_YY_BUFFER_STATE
@@ -839,7 +844,7 @@ int search(char *s);
 #undef yywrap
 #endif
 
-#line 843 "lex.yy.c"
+#line 848 "lex.yy.c"
 
 #define INITIAL 0
 
@@ -857,6 +862,35 @@ int search(char *s);
 
 static int yy_init_globals (void );
 
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy (void );
+
+int yyget_debug (void );
+
+void yyset_debug (int debug_flag  );
+
+YY_EXTRA_TYPE yyget_extra (void );
+
+void yyset_extra (YY_EXTRA_TYPE user_defined  );
+
+FILE *yyget_in (void );
+
+void yyset_in  (FILE * in_str  );
+
+FILE *yyget_out (void );
+
+void yyset_out  (FILE * out_str  );
+
+int yyget_leng (void );
+
+char *yyget_text (void );
+
+int yyget_lineno (void );
+
+void yyset_lineno (int line_number  );
+
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
  */
@@ -891,7 +925,12 @@ static int input (void );
 
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
 #define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
 #endif
 
 /* Copy whatever the last rule matched to the standard output. */
@@ -899,7 +938,7 @@ static int input (void );
 /* This used to be an fputs(), but since the string might contain NUL's,
  * we now use fwrite().
  */
-#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
+#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
 #endif
 
 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
@@ -994,7 +1033,7 @@ YY_DECL
     
 #line 57 "xi-scan.l"
 
-#line 998 "lex.yy.c"
+#line 1037 "lex.yy.c"
 
        if ( !(yy_init) )
                {
@@ -1007,6 +1046,8 @@ YY_DECL
         /* Create the reject buffer large enough to save one state per allowed character. */
         if ( ! (yy_state_buf) )
             (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  );
+            if ( ! (yy_state_buf) )
+                YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
 
                if ( ! (yy_start) )
                        (yy_start) = 1; /* first start state */
@@ -1174,7 +1215,7 @@ YY_RULE_SETUP
 #line 74 "xi-scan.l"
 ECHO;
        YY_BREAK
-#line 1178 "lex.yy.c"
+#line 1219 "lex.yy.c"
                        case YY_STATE_EOF(INITIAL):
                                yyterminate();
 
@@ -1376,7 +1417,7 @@ static int yy_get_next_buffer (void)
 
                /* Read in more data. */
                YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-                       (yy_n_chars), num_to_read );
+                       (yy_n_chars), (size_t) num_to_read );
 
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }
@@ -1400,6 +1441,14 @@ static int yy_get_next_buffer (void)
        else
                ret_val = EOB_ACT_CONTINUE_SCAN;
 
+       if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+               /* Extend the array by 50%, plus the number we really need. */
+               yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
+               YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
+               if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+                       YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+       }
+
        (yy_n_chars) += number_to_move;
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
@@ -1546,7 +1595,7 @@ static int yy_get_next_buffer (void)
                                case EOB_ACT_END_OF_FILE:
                                        {
                                        if ( yywrap( ) )
-                                               return 0;
+                                               return EOF;
 
                                        if ( ! (yy_did_buffer_switch_on_eof) )
                                                YY_NEW_FILE;
@@ -1810,7 +1859,9 @@ static void yyensure_buffer_stack (void)
                (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
                                                                );
-               
+               if ( ! (yy_buffer_stack) )
+                       YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+                                                                 
                memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
                                
                (yy_buffer_stack_max) = num_to_alloc;
@@ -1828,6 +1879,8 @@ static void yyensure_buffer_stack (void)
                                                                ((yy_buffer_stack),
                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
                                                                );
+               if ( ! (yy_buffer_stack) )
+                       YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
 
                /* zero only the new slots.*/
                memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
@@ -1872,7 +1925,7 @@ YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
 
 /** Setup the input buffer state to scan a string. The next call to yylex() will
  * scan from a @e copy of @a str.
- * @param str a NUL-terminated string to scan
+ * @param yystr a NUL-terminated string to scan
  * 
  * @return the newly allocated buffer state object.
  * @note If you want to scan bytes that may contain NUL values, then use
@@ -1886,8 +1939,8 @@ YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
 
 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
  * scan from a @e copy of @a bytes.
- * @param bytes the byte buffer to scan
- * @param len the number of bytes in the buffer pointed to by @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
  * 
  * @return the newly allocated buffer state object.
  */
@@ -2144,73 +2197,73 @@ struct rwtable {
 
 /* Reserved word table */
 struct rwtable rwtable[] = {
-  "module",    MODULE,
-  "mainmodule",        MAINMODULE,
-  "chare",     CHARE,
-  "group",     GROUP,
-  "nodegroup",  NODEGROUP,
-  "array",     ARRAY,
-  "message",   MESSAGE,
-  "conditional",CONDITIONAL,
-  "extern",    EXTERN,
-  "initcall",  INITCALL,
-  "initnode",  INITNODE,
-  "initproc",  INITPROC,
-  "readonly",  READONLY,
-  "stacksize", STACKSIZE,
-  "threaded",  THREADED,
-  "migratable",        MIGRATABLE,
-  "PUPable",   PUPABLE,
-  "pupable",   PUPABLE,
-  "createhere",        CREATEHERE,
-  "createhome",        CREATEHOME,
-  "nokeep",    NOKEEP,
-  "notrace",   NOTRACE,
-  "template",  TEMPLATE,
-  "class",     CLASS,
-  "include",   INCLUDE,
-  "sync",      SYNC,
-  "iget",       IGET,
-  "exclusive", EXCLUSIVE,
-  "immediate",  IMMEDIATE,
-  "expedited",  SKIPSCHED,
-  "inline",    INLINE,
-  "local",      LOCAL,
-  "virtual",    VIRTUAL,
-  "mainchare", MAINCHARE,
-  "packed",     PACKED,
-  "varsize",    VARSIZE,
-  "entry",      ENTRY,
-  "int",        INT,
-  "short",      SHORT,
-  "long",       LONG,
-  "char",       CHAR,
-  "float",      FLOAT,
-  "double",     DOUBLE,
-  "unsigned",   UNSIGNED,
-  "void",      VOID,
-  "const",     CONST,
-  "atomic",    ATOMIC,
-  "forward",   FORWARD,
-  "when",      WHEN, 
-  "while",     WHILE,
-  "for",       FOR,
-  "forall",    FORALL, 
-  "if",        IF, 
-  "else",      ELSE,
-  "overlap",   OVERLAP,
-  "connect",    CONNECT,
-  "publishes",  PUBLISHES,
-  "python",     PYTHON,
-  "namespace",  NAMESPACE,
-  "using",      USING,
-  "accel",      ACCEL,
-  "readwrite",  READWRITE,
-  "writeonly",  WRITEONLY,
-  "accelblock", ACCELBLOCK,
-  "memcritical", MEMCRITICAL,
-  "reductiontarget", REDUCTIONTARGET,
-  "",          0
+{  "module",   MODULE },
+{  "mainmodule",       MAINMODULE },
+{  "chare",    CHARE },
+{  "group",    GROUP },
+{  "nodegroup",  NODEGROUP },
+{  "array",    ARRAY },
+{  "message",  MESSAGE },
+{  "conditional",CONDITIONAL },
+{  "extern",   EXTERN },
+{  "initcall", INITCALL },
+{  "initnode", INITNODE },
+{  "initproc", INITPROC },
+{  "readonly", READONLY },
+{  "stacksize",        STACKSIZE },
+{  "threaded", THREADED },
+{  "migratable",       MIGRATABLE },
+{  "PUPable",  PUPABLE },
+{  "pupable",  PUPABLE },
+{  "createhere",       CREATEHERE },
+{  "createhome",       CREATEHOME },
+{  "nokeep",   NOKEEP },
+{  "notrace",  NOTRACE },
+{  "template", TEMPLATE },
+{  "class",    CLASS },
+{  "include",  INCLUDE },
+{  "sync",     SYNC },
+{  "iget",       IGET },
+{  "exclusive",        EXCLUSIVE },
+{  "immediate",  IMMEDIATE },
+{  "expedited",  SKIPSCHED },
+{  "inline",   INLINE },
+{  "local",      LOCAL },
+{  "virtual",    VIRTUAL },
+{  "mainchare",        MAINCHARE },
+{  "packed",     PACKED },
+{  "varsize",    VARSIZE },
+{  "entry",      ENTRY },
+{  "int",        INT },
+{  "short",      SHORT },
+{  "long",       LONG },
+{  "char",       CHAR },
+{  "float",      FLOAT },
+{  "double",     DOUBLE },
+{  "unsigned",   UNSIGNED },
+{  "void",     VOID },
+{  "const",    CONST },
+{  "atomic",   ATOMIC },
+{  "forward",  FORWARD },
+{  "when",     WHEN },
+{  "while",    WHILE },
+{  "for",      FOR },
+{  "forall",   FORALL },
+{  "if",       IF },
+{  "else",     ELSE },
+{  "overlap",  OVERLAP },
+{  "connect",    CONNECT },
+{  "publishes",  PUBLISHES },
+{  "python",     PYTHON },
+{  "namespace",  NAMESPACE },
+{  "using",      USING },
+{  "accel",      ACCEL },
+{  "readwrite",  READWRITE },
+{  "writeonly",  WRITEONLY },
+{  "accelblock", ACCELBLOCK },
+{  "memcritical", MEMCRITICAL },
+{  "reductiontarget", REDUCTIONTARGET },
+{  "",         0 }
 };
 
 int search(char *s)
index ba8cd20f140a0447fc68e49c41dc3d681c41d18e..7fa04436864b8b5bbdcfc66f1b33ea561f349592 100644 (file)
@@ -79,73 +79,73 @@ struct rwtable {
 
 /* Reserved word table */
 struct rwtable rwtable[] = {
-  "module",    MODULE,
-  "mainmodule",        MAINMODULE,
-  "chare",     CHARE,
-  "group",     GROUP,
-  "nodegroup",  NODEGROUP,
-  "array",     ARRAY,
-  "message",   MESSAGE,
-  "conditional",CONDITIONAL,
-  "extern",    EXTERN,
-  "initcall",  INITCALL,
-  "initnode",  INITNODE,
-  "initproc",  INITPROC,
-  "readonly",  READONLY,
-  "stacksize", STACKSIZE,
-  "threaded",  THREADED,
-  "migratable",        MIGRATABLE,
-  "PUPable",   PUPABLE,
-  "pupable",   PUPABLE,
-  "createhere",        CREATEHERE,
-  "createhome",        CREATEHOME,
-  "nokeep",    NOKEEP,
-  "notrace",   NOTRACE,
-  "template",  TEMPLATE,
-  "class",     CLASS,
-  "include",   INCLUDE,
-  "sync",      SYNC,
-  "iget",       IGET,
-  "exclusive", EXCLUSIVE,
-  "immediate",  IMMEDIATE,
-  "expedited",  SKIPSCHED,
-  "inline",    INLINE,
-  "local",      LOCAL,
-  "virtual",    VIRTUAL,
-  "mainchare", MAINCHARE,
-  "packed",     PACKED,
-  "varsize",    VARSIZE,
-  "entry",      ENTRY,
-  "int",        INT,
-  "short",      SHORT,
-  "long",       LONG,
-  "char",       CHAR,
-  "float",      FLOAT,
-  "double",     DOUBLE,
-  "unsigned",   UNSIGNED,
-  "void",      VOID,
-  "const",     CONST,
-  "atomic",    ATOMIC,
-  "forward",   FORWARD,
-  "when",      WHEN, 
-  "while",     WHILE,
-  "for",       FOR,
-  "forall",    FORALL, 
-  "if",        IF, 
-  "else",      ELSE,
-  "overlap",   OVERLAP,
-  "connect",    CONNECT,
-  "publishes",  PUBLISHES,
-  "python",     PYTHON,
-  "namespace",  NAMESPACE,
-  "using",      USING,
-  "accel",      ACCEL,
-  "readwrite",  READWRITE,
-  "writeonly",  WRITEONLY,
-  "accelblock", ACCELBLOCK,
-  "memcritical", MEMCRITICAL,
-  "reductiontarget", REDUCTIONTARGET,
-  "",          0
+{  "module",   MODULE },
+{  "mainmodule",       MAINMODULE },
+{  "chare",    CHARE },
+{  "group",    GROUP },
+{  "nodegroup",  NODEGROUP },
+{  "array",    ARRAY },
+{  "message",  MESSAGE },
+{  "conditional",CONDITIONAL },
+{  "extern",   EXTERN },
+{  "initcall", INITCALL },
+{  "initnode", INITNODE },
+{  "initproc", INITPROC },
+{  "readonly", READONLY },
+{  "stacksize",        STACKSIZE },
+{  "threaded", THREADED },
+{  "migratable",       MIGRATABLE },
+{  "PUPable",  PUPABLE },
+{  "pupable",  PUPABLE },
+{  "createhere",       CREATEHERE },
+{  "createhome",       CREATEHOME },
+{  "nokeep",   NOKEEP },
+{  "notrace",  NOTRACE },
+{  "template", TEMPLATE },
+{  "class",    CLASS },
+{  "include",  INCLUDE },
+{  "sync",     SYNC },
+{  "iget",       IGET },
+{  "exclusive",        EXCLUSIVE },
+{  "immediate",  IMMEDIATE },
+{  "expedited",  SKIPSCHED },
+{  "inline",   INLINE },
+{  "local",      LOCAL },
+{  "virtual",    VIRTUAL },
+{  "mainchare",        MAINCHARE },
+{  "packed",     PACKED },
+{  "varsize",    VARSIZE },
+{  "entry",      ENTRY },
+{  "int",        INT },
+{  "short",      SHORT },
+{  "long",       LONG },
+{  "char",       CHAR },
+{  "float",      FLOAT },
+{  "double",     DOUBLE },
+{  "unsigned",   UNSIGNED },
+{  "void",     VOID },
+{  "const",    CONST },
+{  "atomic",   ATOMIC },
+{  "forward",  FORWARD },
+{  "when",     WHEN },
+{  "while",    WHILE },
+{  "for",      FOR },
+{  "forall",   FORALL },
+{  "if",       IF },
+{  "else",     ELSE },
+{  "overlap",  OVERLAP },
+{  "connect",    CONNECT },
+{  "publishes",  PUBLISHES },
+{  "python",     PYTHON },
+{  "namespace",  NAMESPACE },
+{  "using",      USING },
+{  "accel",      ACCEL },
+{  "readwrite",  READWRITE },
+{  "writeonly",  WRITEONLY },
+{  "accelblock", ACCELBLOCK },
+{  "memcritical", MEMCRITICAL },
+{  "reductiontarget", REDUCTIONTARGET },
+{  "",         0 }
 };
 
 int search(char *s)
index edde5b07c6da2acdcf789dc4690ab16c96d6ce2c..3758304f6b494413f9553396cfda90c436d04003 100644 (file)
@@ -126,9 +126,6 @@ public:
        }
 };
 
-static void (*nbp)(void*) = NULL;
-static void (*nbi)(int&) = NULL;
-
 template<typename T, typename U, typename A>
 void perElemGen(list<T*> &l, A& arg_, void (U::*fn_)(A&),
 // Sun Studio 7 (C++ compiler version 5.4) can't handle this
@@ -238,16 +235,19 @@ std::string TParamList::to_string()
 void
 Type::genProxyName(XStr &str,forWhom forElement)
 {
+  (void)str; (void)forElement;
   die("type::genProxyName called (INTERNAL ERROR)");
 }
 void
 Type::genIndexName(XStr &str)
 {
+  (void)str;
   die("type::genIndexName called (INTERNAL ERROR)");
 }
 void
 Type::genMsgProxyName(XStr &str)
 {
+  (void)str;
   die("type::genMsgProxyName called (INTERNAL ERROR)");
 }
 
@@ -795,6 +795,7 @@ char *Chare::proxyPrefix(void)
 //Common multiple inheritance disambiguation code
 void Chare::sharedDisambiguation(XStr &str,const XStr &super)
 {
+    (void)super;
     str<<"    void ckDelegate(CkDelegateMgr *dTo,CkDelegateData *dPtr=NULL) {\n";
     genProxyNames(str,"      ",NULL,"::ckDelegate(dTo,dPtr);\n","");
     str<<"    }\n";
@@ -887,11 +888,6 @@ Chare::genRegisterMethodDef(XStr& str)
   str << "#endif\n";
 }
 
-//extern void sdag_trans(XStr& classname, CParsedFile *input, XStr& output);
-
-
-
-
 void
 Chare::genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent)
 {
@@ -904,10 +900,6 @@ Chare::genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent)
   }
 }
 
-void
-Chare::genSubRegisterMethodDef(XStr& str) {
-}
-
 void
 Chare::genDecls(XStr& str)
 {
@@ -987,7 +979,6 @@ Chare::genDecls(XStr& str)
       classname << baseName(0);
       resetNumbers();
       myParsedFile->doProcess(classname, sdag_output);
-     // sdag_trans(classname, myParsedFile, sdag_output);
       str << sdag_output;
     }
   }
@@ -2233,11 +2224,6 @@ Template::genDefs(XStr& str)
     entity->genDefs(str);
 }
 
-void
-Template::genReg(XStr& str)
-{
-}
-
 int Template::genAccels_spe_c_funcBodies(XStr& str) {
   int rtn = 0;
   if (!external && entity) { rtn += entity->genAccels_spe_c_funcBodies(str); }
@@ -2932,7 +2918,7 @@ void ParamList::checkParamList(){
 }
 
 Entry::Entry(int l, int a, Type *r, const char *n, ParamList *p, Value *sz, SdagConstruct *sc, const char *e, int connect, ParamList *connectPList) :
-      attribs(a), retType(r), name((char *)n), param(p), stacksize(sz), sdagCon(sc), intExpr(e), isConnect(connect), connectParam(connectPList)
+      attribs(a), retType(r), stacksize(sz), sdagCon(sc), name((char *)n), intExpr(e), param(p), connectParam(connectPList), isConnect(connect)
 {
   line=l; container=NULL;
   entryCount=-1;
@@ -3283,7 +3269,7 @@ void Entry::genArrayStaticConstructorDecl(XStr& str)
         }
       }
   }
-  else if (container->getForWhom()==forSection);
+  else if (container->getForWhom()==forSection) { }
 }
 
 void Entry::genArrayStaticConstructorDefs(XStr& str)
@@ -4590,8 +4576,6 @@ void Entry::genDefs(XStr& str)
   }
 
   if (!isConstructor() && fortranMode) { // Fortran90
-      const char* msg_name = param->getBaseName();
-
       str << "/* FORTRAN SECTION */\n";
 
       XStr dim; dim << ((Array*)container)->dim();
@@ -5186,7 +5170,7 @@ void Parameter::pupAllValues(XStr &str) {
          else str<<"  implDestP|"<<name<<";\n";
        }
 }
-void ParamList::endUnmarshall(XStr &str)
+void ParamList::endUnmarshall(XStr &)
 {
        /* Marshalled entry points now have the "SNOKEEP" attribute...
        if (isMarshalled()) {
@@ -5208,10 +5192,6 @@ void InitCall::print(XStr& str)
 {
        str<<"  initcall void "<<name<<"(void);\n";
 }
-void InitCall::genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent) {}
-void InitCall::genDecls(XStr& str) {}
-void InitCall::genIndexDecls(XStr& str) {}
-void InitCall::genDefs(XStr& str) {}
 void InitCall::genReg(XStr& str)
 {
        str<<"      _registerInitCall(";
@@ -5239,9 +5219,6 @@ void PUPableClass::print(XStr& str)
        str << "  PUPable " << type <<";\n";
        if (next) next->print(str);
 }
-void PUPableClass::genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent) {}
-void PUPableClass::genDecls(XStr& str) {}
-void PUPableClass::genIndexDecls(XStr& str) {}
 void PUPableClass::genDefs(XStr& str)
 {
         if (type->isTemplated()) {
@@ -5278,13 +5255,9 @@ void IncludeFile::print(XStr& str)
 {
        str<<"  include "<<name<<";\n";
 }
-void IncludeFile::genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent) {}
 void IncludeFile::genDecls(XStr& str) {
        str<<"#include "<<name<<"\n";
 }
-void IncludeFile::genIndexDecls(XStr& str) {}
-void IncludeFile::genDefs(XStr& str) {}
-void IncludeFile::genReg(XStr& str) {}
 
 
 /***************** normal extern C Class support **************/
@@ -5297,13 +5270,9 @@ void ClassDeclaration::print(XStr& str)
 {
        str<<"  class "<<name<<";\n";
 }
-void ClassDeclaration::genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent) {}
 void ClassDeclaration::genDecls(XStr& str) {
        str<<"class "<<name<<";\n";
 }
-void ClassDeclaration::genIndexDecls(XStr& str) {}
-void ClassDeclaration::genDefs(XStr& str) {}
-void ClassDeclaration::genReg(XStr& str) {}
 
 
 /****************** Registration *****************/
index 0b26732babfcfcab1fd50781462e2777d9209b30..20e9478e17abd2f60f36959a1e44a7b76655b55e 100644 (file)
@@ -86,19 +86,22 @@ class Construct : public Printable {
     Construct() {external=0;line=-1;}
     void setExtern(int &e) { external = e; }
     void setModule(Module *m) { containerModule = m; }
-    virtual void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent) = 0;
-    virtual void genDecls(XStr& str) = 0;
-    virtual void genDefs(XStr& str) = 0;
-    virtual void genReg(XStr& str) = 0;
+    virtual void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent)
+    {
+      (void)declstr; (void)defstr; (void)defconstr; (void)connectPresent;
+    }
+    virtual void genDecls(XStr& str) { (void)str; }
+    virtual void genDefs(XStr& str) { (void)str; }
+    virtual void genReg(XStr& str) { (void)str; }
     virtual void preprocess() { }
 
     // DMK - Accel Support
-    virtual int genAccels_spe_c_funcBodies(XStr& str) = 0;
-    virtual void genAccels_spe_c_regFuncs(XStr& str) = 0;
-    virtual void genAccels_spe_c_callInits(XStr& str) = 0;
-    virtual void genAccels_spe_h_includes(XStr& str) = 0;
-    virtual void genAccels_spe_h_fiCountDefs(XStr& str) = 0;
-    virtual void genAccels_ppe_c_regFuncs(XStr& str) = 0;
+    virtual int genAccels_spe_c_funcBodies(XStr& str) { (void)str; return 0; }
+    virtual void genAccels_spe_c_regFuncs(XStr& str) { (void)str; }
+    virtual void genAccels_spe_c_callInits(XStr& str) { (void)str; }
+    virtual void genAccels_spe_h_includes(XStr& str) { (void)str; }
+    virtual void genAccels_spe_h_fiCountDefs(XStr& str) { (void)str; }
+    virtual void genAccels_ppe_c_regFuncs(XStr& str) { (void)str; }
 };
 
 class ConstructList : public Construct {
@@ -177,7 +180,7 @@ class NamedType : public Type {
     TParamList *tparams;
   public:
     NamedType(const char* n, TParamList* t=0, const char* scope_=NULL)
-       : name(n), tparams(t), scope(scope_) {}
+       : name(n), scope(scope_), tparams(t) {}
     int isTemplated(void) const { return (tparams!=0); }
     int isCkArgMsg(void) const {return 0==strcmp(name,"CkArgMsg");}
     int isCkMigMsg(void) const {return 0==strcmp(name,"CkMigrateMessage");}
@@ -317,7 +320,7 @@ class ParamList {
   public:
     Parameter *param;
     ParamList *next;
-    ParamList(ParamList *pl) :param(pl->param), next(pl->next), manyPointers(false) {}
+    ParamList(ParamList *pl) : manyPointers(false), param(pl->param), next(pl->next) {}
     ParamList(Parameter *Nparam,ParamList *Nnext=NULL)
        :param(Nparam), next(Nnext) { 
           manyPointers = false;
@@ -445,7 +448,7 @@ class Scope : public Construct {
     const char* name_;
     ConstructList* contents_;
   public:
-    Scope(const char* name, ConstructList* contents) : contents_(contents), name_(name) {}
+    Scope(const char* name, ConstructList* contents) : name_(name), contents_(contents) {}
     virtual void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent) {
         contents_->genPub(declstr, defstr, defconstr, connectPresent);
     }
@@ -499,28 +502,16 @@ class UsingScope : public Construct {
     bool symbol_;
   public:
     UsingScope(const char* name, bool symbol=false) : name_(name), symbol_(symbol) {}
-    virtual void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent) {}
     virtual void genDecls(XStr& str) {
         str << "using ";
         if (!symbol_) str << "namespace ";
         str << name_ << ";\n";
     }
-    virtual void genDefs(XStr& str) {}
-    virtual void genReg(XStr& str) {}
-    virtual void preprocess() {}
     virtual void print(XStr& str) {
         str << "using ";
         if (!symbol_) str << "namespace ";
         str << name_ << ";\n";
     }
-
-    // DMK - Accel Support
-    virtual int genAccels_spe_c_funcBodies(XStr& str) { return 0; }
-    virtual void genAccels_spe_c_regFuncs(XStr& str) { }
-    virtual void genAccels_spe_c_callInits(XStr& str) { }
-    virtual void genAccels_spe_h_includes(XStr& str) { }
-    virtual void genAccels_spe_h_fiCountDefs(XStr& str) { }
-    virtual void genAccels_ppe_c_regFuncs(XStr& str) { }
 };
 
 
@@ -538,7 +529,6 @@ class Template : public Construct {
     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
     void genDecls(XStr& str);
     void genDefs(XStr& str);
-    void genReg(XStr& str);
     void genSpec(XStr& str);
     void genVars(XStr& str);
 
@@ -630,14 +620,14 @@ class Member : public Construct {
   public:
     virtual void setChare(Chare *c) { container = c; }
     virtual int isSdag(void) { return 0; }
-    virtual void collectSdagCode(CParsedFile *pf, int& sdagPresent) { return; }
+    virtual void collectSdagCode(CParsedFile *, int&) { return; }
     XStr makeDecl(const XStr &returnType,int forProxy=0);
-    virtual void genPythonDecls(XStr& str) {}
-    virtual void genIndexDecls(XStr& str)=0;
-    virtual void genPythonDefs(XStr& str) {}
-    virtual void genPythonStaticDefs(XStr& str) {}
-    virtual void genPythonStaticDocs(XStr& str) {}
-    virtual void lookforCEntry(CEntry *centry)  {}
+    virtual void genPythonDecls(XStr& ) {}
+    virtual void genIndexDecls(XStr& ) {}
+    virtual void genPythonDefs(XStr& ) {}
+    virtual void genPythonStaticDefs(XStr&) {}
+    virtual void genPythonStaticDocs(XStr&) {}
+    virtual void lookforCEntry(CEntry *)  {}
 };
 
 /* List of members of a chare or group */
@@ -766,7 +756,7 @@ class Chare : public TEntity {
     void genPythonDefs(XStr& str);
     virtual char *chareTypeName(void) {return (char *)"chare";}
     virtual char *proxyPrefix(void);
-    virtual void genSubRegisterMethodDef(XStr& str);
+    virtual void genSubRegisterMethodDef(XStr& str) { (void)str; }
     void lookforCEntry(CEntry *centry);
 };
 
@@ -854,19 +844,10 @@ class Message : public TEntity {
       : type(t), mvlist(mv) 
       { line=l; setTemplate(0); }
     void print(XStr& str);
-    void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent) {}
     void genDecls(XStr& str);
     void genDefs(XStr& str);
     void genReg(XStr& str);
 
-    // DMK - Accel Support
-    int genAccels_spe_c_funcBodies(XStr& str) { return 0; }
-    void genAccels_spe_c_regFuncs(XStr& str) { }
-    void genAccels_spe_c_callInits(XStr& str) { }
-    void genAccels_spe_h_includes(XStr& str) { }
-    void genAccels_spe_h_fiCountDefs(XStr& str) { }
-    void genAccels_ppe_c_regFuncs(XStr& str) { }
-
     virtual const char *proxyPrefix(void) {return Prefix::Message;}
     void genAllocDecl(XStr& str);
     int numArrays(void) {
@@ -962,9 +943,6 @@ class Entry : public Member {
     void genAccelIndexWrapperDef_spe(XStr& str);
     int genAccels_spe_c_funcBodies(XStr& str);
     void genAccels_spe_c_regFuncs(XStr& str);
-    void genAccels_spe_c_callInits(XStr& str) { }
-    void genAccels_spe_h_includes(XStr& str) { }
-    void genAccels_spe_h_fiCountDefs(XStr& str) { }
     void genAccels_ppe_c_regFuncs(XStr& str);
 
     XStr paramType(int withDefaultVals,int withEO=0,int useConst=1);
@@ -1081,22 +1059,13 @@ class AccelBlock : public Construct {
   ~AccelBlock() { delete code; }
 
   /// Printable Methods ///
-  void print(XStr& str) { }
+  void print(XStr& str) { (void)str; }
 
   /// Construct Methods ///
-  void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent) { }
-  void genDecls(XStr& str) { }
   void genDefs(XStr& str) { outputCode(str); }
-  void genReg(XStr& str) { }
-  void preprocess() { }
 
   /// Construct Accel Support Methods ///
   int genAccels_spe_c_funcBodies(XStr& str) { outputCode(str); return 0; }
-  void genAccels_spe_c_regFuncs(XStr& str) { }
-  void genAccels_spe_c_callInits(XStr& str) { }
-  void genAccels_spe_h_includes(XStr& str) { }
-  void genAccels_spe_h_fiCountDefs(XStr& str) { }
-  void genAccels_ppe_c_regFuncs(XStr& str) { }
 };
 
 
@@ -1167,19 +1136,10 @@ class Readonly : public Member {
            : msg(m), type(t), name(n)
             { line=l; dims=d; setChare(0); }
     void print(XStr& str);
-    void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent) {}
     void genDecls(XStr& str);
     void genIndexDecls(XStr& str);
     void genDefs(XStr& str);
     void genReg(XStr& str);
-
-    // DMK - Accel Support
-    int genAccels_spe_c_funcBodies(XStr& str) { return 0; }
-    void genAccels_spe_c_regFuncs(XStr& str) { }
-    void genAccels_spe_c_callInits(XStr& str) { }
-    void genAccels_spe_h_includes(XStr& str) { }
-    void genAccels_spe_h_fiCountDefs(XStr& str) { }
-    void genAccels_ppe_c_regFuncs(XStr& str) { }
 };
 
 class InitCall : public Member {
@@ -1194,19 +1154,10 @@ public:
 
     InitCall(int l, const char *n, int nodeCall);
     void print(XStr& str);
-    void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
-    void genDecls(XStr& str);
-    void genIndexDecls(XStr& str);
-    void genDefs(XStr& str);
     void genReg(XStr& str);
 
     // DMK - Accel Support
-    int genAccels_spe_c_funcBodies(XStr& str) { return 0; }
-    void genAccels_spe_c_regFuncs(XStr& str) { }
     void genAccels_spe_c_callInits(XStr& str);
-    void genAccels_spe_h_includes(XStr& str) { }
-    void genAccels_spe_h_fiCountDefs(XStr& str) { }
-    void genAccels_ppe_c_regFuncs(XStr& str) { }
 
     void setAccel() { isAccelFlag = 1; }
     void clearAccel() { isAccelFlag = 0; }
@@ -1219,9 +1170,6 @@ class PUPableClass : public Member {
 public:
     PUPableClass(int l, NamedType* type_, PUPableClass *next_);
     void print(XStr& str);
-    void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
-    void genDecls(XStr& str);
-    void genIndexDecls(XStr& str);
     void genDefs(XStr& str);
     void genReg(XStr& str);
 
@@ -1253,19 +1201,7 @@ class IncludeFile : public Member {
 public:
     IncludeFile(int l, const char *name_);
     void print(XStr& str);
-    void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
     void genDecls(XStr& str);
-    void genIndexDecls(XStr& str);
-    void genDefs(XStr& str);
-    void genReg(XStr& str);
-
-    // DMK - Accel Support
-    int genAccels_spe_c_funcBodies(XStr& str) { return 0; }
-    void genAccels_spe_c_regFuncs(XStr& str) { }
-    void genAccels_spe_c_callInits(XStr& str) { }
-    void genAccels_spe_h_includes(XStr& str) { }
-    void genAccels_spe_h_fiCountDefs(XStr& str) { }
-    void genAccels_ppe_c_regFuncs(XStr& str) { }
 };
 
 class ClassDeclaration : public Member {
@@ -1273,19 +1209,7 @@ class ClassDeclaration : public Member {
 public:
     ClassDeclaration(int l, const char *name_);
     void print(XStr& str);
-    void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
     void genDecls(XStr& str);
-    void genIndexDecls(XStr& str);
-    void genDefs(XStr& str);
-    void genReg(XStr& str);
-
-    // DMK - Accel Support
-    int genAccels_spe_c_funcBodies(XStr& str) { return 0; }
-    void genAccels_spe_c_regFuncs(XStr& str) { }
-    void genAccels_spe_c_callInits(XStr& str) { }
-    void genAccels_spe_h_includes(XStr& str) { }
-    void genAccels_spe_h_fiCountDefs(XStr& str) { }
-    void genAccels_ppe_c_regFuncs(XStr& str) { }
 };
 
 
index 2f31984ca1219c5d4e2b044624f9c5f72310b765..da1d13d8b97b6b83d7ec6ea0a62c653df22781d2 100644 (file)
@@ -1,10 +1,3 @@
-/*****************************************************************************
- * $Source$
- * $Author$
- * $Date$
- * $Revision$
- *****************************************************************************/
-
 #include "xi-util.h"
 
 namespace xi {
@@ -59,7 +52,7 @@ XStr& XStr::operator << (int i) {
 void XStr::line_append(const char c)
 {
   XStr xs;
-  for(int i=0; i<len; i++) {
+  for(unsigned int i=0; i<len; i++) {
     if(s[i] == '\n')
       xs << c << "\n";
     else
@@ -74,7 +67,7 @@ void XStr::line_append_padding(const char c, int lineWidth)
   XStr xs;
   int count = 0;
 
-  for(int i=0; i<len; i++) {
+  for(unsigned int i=0; i<len; i++) {
     if(s[i] == '\n'){
       // found line ending
       while(count++ < lineWidth-1)
@@ -122,7 +115,7 @@ XStr::spew(const char*b, const char *a1, const char *a2, const char *a3,
 }
 
 void XStr::replace (const char a, const char b) {
-  for(int i=0; i<len; i++) {
+  for(unsigned int i=0; i<len; i++) {
     if (s[i] == a) s[i] = b;
   }
 }