This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH] compiling gcc with a C++ compiler 2/n


Hi,

the attached patch fixed various small C front end issues when compiling
with a C++ compiler. Nothing special, the only non-obvious part is
fixing some omp enum types.

Thomas

* c-lex.c: Incrementing an enum requires a cast.
* c-format.c: Use enum constants instead of int literals.
* c-format.h: Likewise.
* c-pch.c: Include space for the terminating null.
* c-decl.c (build_compound_literal): Cast from c_tree_code to tree_code.
* c-common.c: Avoid conflicts with builtin_type by using c_builtin_type.
* c-common.c (def_fn_type): Vararg enum must be retrieved as int.
* c-common.h: Cast rid_code to enum, provide macro for writing.
* c-parser.c: Cast as needed, use the correct parameter type.
* c-parser.c: Use the rid_code write macro, avoid C++ keywords.

Index: gcc/c-lex.c
===================================================================
--- gcc/c-lex.c	(revision 124656)
+++ gcc/c-lex.c	(working copy)
@@ -509,7 +509,8 @@ narrowest_unsigned_type (unsigned HOST_W
   else
     itk = itk_unsigned_long_long;
 
-  for (; itk < itk_none; itk += 2 /* skip unsigned types */)
+  for (; itk < itk_none; itk = (enum integer_type_kind) (itk + 2) )
+			 /* skip unsigned types */
     {
       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 
@@ -537,7 +538,8 @@ narrowest_signed_type (unsigned HOST_WID
     itk = itk_long_long;
 
 
-  for (; itk < itk_none; itk += 2 /* skip signed types */)
+  for (; itk < itk_none; itk = (enum integer_type_kind) (itk + 2) )
+			 /* skip signed types */
     {
       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 
Index: gcc/c-format.c
===================================================================
--- gcc/c-format.c	(revision 124656)
+++ gcc/c-format.c	(working copy)
@@ -281,36 +281,38 @@ typedef struct format_wanted_type
   struct format_wanted_type *next;
 } format_wanted_type;
 
+#define FMT_LEN_0 ((enum format_lengths) 0)
+#define STD_0 ((enum format_std_version) 0)
 
 static const format_length_info printf_length_specs[] =
 {
   { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L },
-  { "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
-  { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
-  { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
-  { "Z", FMT_LEN_z, STD_EXT, NULL, 0, 0 },
-  { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
-  { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
-  { "H", FMT_LEN_H, STD_EXT, NULL, 0, 0 },
+  { "q", FMT_LEN_ll, STD_EXT, NULL, FMT_LEN_0, STD_0 },
+  { "L", FMT_LEN_L, STD_C89, NULL, FMT_LEN_0, STD_0 },
+  { "z", FMT_LEN_z, STD_C99, NULL, FMT_LEN_0, STD_0 },
+  { "Z", FMT_LEN_z, STD_EXT, NULL, FMT_LEN_0, STD_0 },
+  { "t", FMT_LEN_t, STD_C99, NULL, FMT_LEN_0, STD_0 },
+  { "j", FMT_LEN_j, STD_C99, NULL, FMT_LEN_0, STD_0 },
+  { "H", FMT_LEN_H, STD_EXT, NULL, FMT_LEN_0, STD_0 },
   { "D", FMT_LEN_D, STD_EXT, "DD", FMT_LEN_DD, STD_EXT },
-  { NULL, 0, 0, NULL, 0, 0 }
+  { NULL, FMT_LEN_0, STD_0, NULL, FMT_LEN_0, STD_0 }
 };
 
 /* Length specifiers valid for asm_fprintf.  */
 static const format_length_info asm_fprintf_length_specs[] =
 {
   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89 },
-  { "w", FMT_LEN_none, STD_C89, NULL, 0, 0 },
-  { NULL, 0, 0, NULL, 0, 0 }
+  { "w", FMT_LEN_none, STD_C89, NULL, FMT_LEN_0, STD_0 },
+  { NULL, FMT_LEN_0, STD_0, NULL, FMT_LEN_0, STD_0 }
 };
 
 /* Length specifiers valid for GCC diagnostics.  */
 static const format_length_info gcc_diag_length_specs[] =
 {
   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89 },
-  { "w", FMT_LEN_none, STD_C89, NULL, 0, 0 },
-  { NULL, 0, 0, NULL, 0, 0 }
+  { "w", FMT_LEN_none, STD_C89, NULL, FMT_LEN_0, STD_0 },
+  { NULL, FMT_LEN_0, STD_0, NULL, FMT_LEN_0, STD_0 }
 };
 
 /* The custom diagnostics all accept the same length specifiers.  */
@@ -323,14 +325,14 @@ static const format_length_info scanf_le
 {
   { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L },
-  { "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
-  { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
-  { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
-  { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
-  { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
-  { "H", FMT_LEN_H, STD_EXT, NULL, 0, 0 },
+  { "q", FMT_LEN_ll, STD_EXT, NULL, FMT_LEN_0, STD_0 },
+  { "L", FMT_LEN_L, STD_C89, NULL, FMT_LEN_0, STD_0 },
+  { "z", FMT_LEN_z, STD_C99, NULL, FMT_LEN_0, STD_0 },
+  { "t", FMT_LEN_t, STD_C99, NULL, FMT_LEN_0, STD_0 },
+  { "j", FMT_LEN_j, STD_C99, NULL, FMT_LEN_0, STD_0 },
+  { "H", FMT_LEN_H, STD_EXT, NULL, FMT_LEN_0, STD_0 },
   { "D", FMT_LEN_D, STD_EXT, "DD", FMT_LEN_DD, STD_EXT },
-  { NULL, 0, 0, NULL, 0, 0 }
+  { NULL, FMT_LEN_0, STD_0, NULL, FMT_LEN_0, STD_0 }
 };
 
 
@@ -339,8 +341,8 @@ static const format_length_info scanf_le
 static const format_length_info strfmon_length_specs[] =
 {
   /* A GNU extension.  */
-  { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
-  { NULL, 0, 0, NULL, 0, 0 }
+  { "L", FMT_LEN_L, STD_C89, NULL, FMT_LEN_0, STD_0 },
+  { NULL, FMT_LEN_0, STD_0, NULL, FMT_LEN_0, STD_0 }
 };
 
 static const format_flag_spec printf_flag_specs[] =
@@ -355,7 +357,7 @@ static const format_flag_spec printf_fla
   { 'w',  0, 0, N_("field width"),     N_("field width in printf format"),     STD_C89 },
   { 'p',  0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
   { 'L',  0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
-  { 0, 0, 0, NULL, NULL, 0 }
+  { 0, 0, 0, NULL, NULL, STD_0 }
 };
 
 
@@ -377,7 +379,7 @@ static const format_flag_spec asm_fprint
   { 'w',  0, 0, N_("field width"),     N_("field width in printf format"),     STD_C89 },
   { 'p',  0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
   { 'L',  0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
-  { 0, 0, 0, NULL, NULL, 0 }
+  { 0, 0, 0, NULL, NULL, STD_0 }
 };
 
 static const format_flag_pair asm_fprintf_flag_pairs[] =
@@ -408,7 +410,7 @@ static const format_flag_spec gcc_diag_f
   { 'q',  0, 0, N_("'q' flag"),        N_("the 'q' diagnostic flag"),          STD_C89 },
   { 'p',  0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
   { 'L',  0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
-  { 0, 0, 0, NULL, NULL, 0 }
+  { 0, 0, 0, NULL, NULL, STD_0 }
 };
 
 #define gcc_tdiag_flag_specs gcc_diag_flag_specs
@@ -421,7 +423,7 @@ static const format_flag_spec gcc_cxxdia
   { 'q',  0, 0, N_("'q' flag"),        N_("the 'q' diagnostic flag"),          STD_C89 },
   { 'p',  0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
   { 'L',  0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
-  { 0, 0, 0, NULL, NULL, 0 }
+  { 0, 0, 0, NULL, NULL, STD_0 }
 };
 
 static const format_flag_spec scanf_flag_specs[] =
@@ -432,7 +434,7 @@ static const format_flag_spec scanf_flag
   { 'L',  0, 0, N_("length modifier"),        N_("length modifier in scanf format"),          STD_C89 },
   { '\'', 0, 0, N_("''' flag"),               N_("the ''' scanf flag"),                       STD_EXT },
   { 'I',  0, 0, N_("'I' flag"),               N_("the 'I' scanf flag"),                       STD_EXT },
-  { 0, 0, 0, NULL, NULL, 0 }
+  { 0, 0, 0, NULL, NULL, STD_0 }
 };
 
 
@@ -454,7 +456,7 @@ static const format_flag_spec strftime_f
   { 'E', 0,   0, N_("'E' modifier"), N_("the 'E' strftime modifier"),      STD_C99 },
   { 'O', 0,   0, N_("'O' modifier"), N_("the 'O' strftime modifier"),      STD_C99 },
   { 'O', 'o', 0, NULL,               N_("the 'O' modifier"),               STD_EXT },
-  { 0, 0, 0, NULL, NULL, 0 }
+  { 0, 0, 0, NULL, NULL, STD_0 }
 };
 
 
@@ -481,7 +483,7 @@ static const format_flag_spec strfmon_fl
   { '#',  0, 0, N_("left precision"),  N_("left precision in strfmon format"),  STD_C89 },
   { 'p',  0, 0, N_("right precision"), N_("right precision in strfmon format"), STD_C89 },
   { 'L',  0, 0, N_("length modifier"), N_("length modifier in strfmon format"), STD_C89 },
-  { 0, 0, 0, NULL, NULL, 0 }
+  { 0, 0, 0, NULL, NULL, STD_0 }
 };
 
 static const format_flag_pair strfmon_flag_pairs[] =
@@ -511,7 +513,7 @@ static const format_char_info print_char
   { "S",   1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "-wp",       "R",  NULL },
   /* GNU conversion specifiers.  */
   { "m",   0, STD_EXT, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "-wp",       "",   NULL },
-  { NULL,  0, 0, NOLENGTHS, NULL, NULL, NULL }
+  { NULL,  0, STD_0, NOLENGTHS, NULL, NULL, NULL }
 };
 
 static const format_char_info asm_fprintf_char_table[] =
@@ -531,7 +533,7 @@ static const format_char_info asm_fprint
   { "U",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
   { "r",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",  "", NULL },
   { "@",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
-  { NULL,  0, 0, NOLENGTHS, NULL, NULL, NULL }
+  { NULL,  0, STD_0, NOLENGTHS, NULL, NULL, NULL }
 };
 
 static const format_char_info gcc_diag_char_table[] =
@@ -554,7 +556,7 @@ static const format_char_info gcc_diag_c
 
   { "<>'", 0, STD_C89, NOARGUMENTS, "",      "",   NULL },
   { "m",   0, STD_C89, NOARGUMENTS, "q",     "",   NULL },
-  { NULL,  0, 0, NOLENGTHS, NULL, NULL, NULL }
+  { NULL,  0, STD_0, NOLENGTHS, NULL, NULL, NULL }
 };
 
 static const format_char_info gcc_tdiag_char_table[] =
@@ -577,7 +579,7 @@ static const format_char_info gcc_tdiag_
 
   { "<>'", 0, STD_C89, NOARGUMENTS, "",      "",   NULL },
   { "m",   0, STD_C89, NOARGUMENTS, "q",     "",   NULL },
-  { NULL,  0, 0, NOLENGTHS, NULL, NULL, NULL }
+  { NULL,  0, STD_0, NOLENGTHS, NULL, NULL, NULL }
 };
 
 static const format_char_info gcc_cdiag_char_table[] =
@@ -600,7 +602,7 @@ static const format_char_info gcc_cdiag_
 
   { "<>'", 0, STD_C89, NOARGUMENTS, "",      "",   NULL },
   { "m",   0, STD_C89, NOARGUMENTS, "q",     "",   NULL },
-  { NULL,  0, 0, NOLENGTHS, NULL, NULL, NULL }
+  { NULL,  0, STD_0, NOLENGTHS, NULL, NULL, NULL }
 };
 
 static const format_char_info gcc_cxxdiag_char_table[] =
@@ -626,7 +628,7 @@ static const format_char_info gcc_cxxdia
 
   { "<>'", 0, STD_C89, NOARGUMENTS, "",      "",   NULL },
   { "m",   0, STD_C89, NOARGUMENTS, "q",     "",   NULL },
-  { NULL,  0, 0, NOLENGTHS, NULL, NULL, NULL }
+  { NULL,  0, STD_0, NOLENGTHS, NULL, NULL, NULL }
 };
 
 static const format_char_info gcc_gfc_char_table[] =
@@ -643,7 +645,7 @@ static const format_char_info gcc_gfc_ch
   /* This will require a "locus" at runtime.  */
   { "L",   0, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "", "R", NULL },
 
-  { NULL,  0, 0, NOLENGTHS, NULL, NULL, NULL }
+  { NULL,  0, STD_0, NOLENGTHS, NULL, NULL, NULL }
 };
 
 static const format_char_info scan_char_table[] =
@@ -664,7 +666,7 @@ static const format_char_info scan_char_
   /* X/Open conversion specifiers.  */
   { "C",     1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "*w",   "W",   NULL },
   { "S",     1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "*aw",  "W",   NULL },
-  { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
+  { NULL, 0, STD_0, NOLENGTHS, NULL, NULL, NULL }
 };
 
 static const format_char_info time_char_table[] =
@@ -691,13 +693,13 @@ static const format_char_info time_char_
   /* GNU conversion specifiers.  */
   { "kls",		0, STD_EXT, NOLENGTHS, "-_0Ow",  "",   NULL },
   { "P",		0, STD_EXT, NOLENGTHS, "",       "",   NULL },
-  { NULL,		0, 0, NOLENGTHS, NULL, NULL, NULL }
+  { NULL,		0, STD_0, NOLENGTHS, NULL, NULL, NULL }
 };
 
 static const format_char_info monetary_char_table[] =
 {
   { "in", 0, STD_C89, { T89_D, BADLEN, BADLEN, BADLEN, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "=^+(!-w#p", "", NULL },
-  { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
+  { NULL, 0, STD_0, NOLENGTHS, NULL, NULL, NULL }
 };
 
 /* This must be in the same order as enum format_type.  */
Index: gcc/c-format.h
===================================================================
--- gcc/c-format.h	(revision 124656)
+++ gcc/c-format.h	(working copy)
@@ -117,7 +117,7 @@ typedef struct
 
 /* Macros to fill out tables of these.  */
 #define NOARGUMENTS	{ T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }
-#define BADLEN	{ 0, NULL, NULL }
+#define BADLEN	{ (enum format_std_version) 0, NULL, NULL }
 #define NOLENGTHS	{ BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }
 
 
Index: gcc/c-pch.c
===================================================================
--- gcc/c-pch.c	(revision 124656)
+++ gcc/c-pch.c	(working copy)
@@ -93,10 +93,10 @@ static const char *
 get_ident (void)
 {
   static char result[IDENT_LENGTH];
-  static const char template[IDENT_LENGTH] = "gpch.013";
+  static const char pattern[IDENT_LENGTH+1] = "gpch.013";
   static const char c_language_chars[] = "Co+O";
 
-  memcpy (result, template, IDENT_LENGTH);
+  memcpy (result, pattern, IDENT_LENGTH);
   result[4] = c_language_chars[c_language];
 
   return result;
@@ -113,7 +113,7 @@ pch_init (void)
   FILE *f;
   struct c_pch_validity v;
   void *target_validity;
-  static const char partial_pch[IDENT_LENGTH] = "gpcWrite";
+  static const char partial_pch[IDENT_LENGTH+1] = "gpcWrite";
 
 #ifdef ASM_COMMENT_START
   if (flag_verbose_asm)
Index: gcc/c-decl.c
===================================================================
--- gcc/c-decl.c	(revision 124656)
+++ gcc/c-decl.c	(working copy)
@@ -3765,7 +3765,7 @@ build_compound_literal (tree type, tree 
     return error_mark_node;
 
   stmt = build_stmt (DECL_EXPR, decl);
-  complit = build1 (COMPOUND_LITERAL_EXPR, type, stmt);
+  complit = build1 ((enum tree_code) COMPOUND_LITERAL_EXPR, type, stmt);
   TREE_SIDE_EFFECTS (complit) = 1;
 
   layout_decl (decl, 0);
Index: gcc/c-common.c
===================================================================
--- gcc/c-common.c	(revision 124656)
+++ gcc/c-common.c	(working copy)
@@ -3355,7 +3355,7 @@ enum c_builtin_type
   BT_LAST
 };
 
-typedef enum c_builtin_type builtin_type;
+typedef enum c_builtin_type c_builtin_type;
 
 /* A temporary array for c_common_nodes_and_builtins.  Used in
    communication with def_fn_type.  */
@@ -3371,7 +3371,7 @@ static tree builtin_types[(int) BT_LAST 
    should be error_mark_node.  */
 
 static void
-def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
+def_fn_type (c_builtin_type def, c_builtin_type ret, bool var, int n, ...)
 {
   tree args = NULL, t;
   va_list list;
@@ -3380,7 +3380,8 @@ def_fn_type (builtin_type def, builtin_t
   va_start (list, n);
   for (i = 0; i < n; ++i)
     {
-      builtin_type a = va_arg (list, builtin_type);
+      /* enums are passed as int, so use va_arg (list, int) and cast */
+      c_builtin_type a = (c_builtin_type) va_arg (list, int);
       t = builtin_types[a];
       if (t == error_mark_node)
 	goto egress;
@@ -4317,7 +4318,8 @@ c_expand_expr (tree exp, rtx target, enu
 	   literal, then return the variable.  */
 	tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
 	emit_local_var (decl);
-	return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
+	return expand_expr_real (decl, target, tmode,
+ 				 (enum expand_modifier) modifier, alt_rtl);
       }
 
     default:
Index: gcc/c-common.h
===================================================================
--- gcc/c-common.h	(revision 124656)
+++ gcc/c-common.h	(working copy)
@@ -180,7 +180,10 @@ enum c_tree_index
     CTI_MAX
 };
 
-#define C_RID_CODE(id)	(((struct c_common_identifier *) (id))->node.rid_code)
+#define C_RID_CODE(id)								\
+	((enum rid)(((struct c_common_identifier *) (id))->node.rid_code))
+#define SET_C_RID_CODE(id,v)							\
+	((struct c_common_identifier *) (id))->node.rid_code = (enum rid) (v)
 
 /* Identifier part common to the C front ends.  Inherits from
    tree_identifier, despite appearances.  */
Index: gcc/c-parser.c
===================================================================
--- gcc/c-parser.c	(revision 124656)
+++ gcc/c-parser.c	(working copy)
@@ -220,7 +220,7 @@ c_parse_init (void)
 	continue;
 
       id = get_identifier (reswords[i].word);
-      C_RID_CODE (id) = reswords[i].rid;
+      SET_C_RID_CODE (id, reswords[i].rid);
       C_IS_RESERVED_WORD (id) = 1;
       ridpointers [(int) reswords[i].rid] = id;
     }
@@ -392,7 +392,7 @@ c_lex_one_token (c_token *token)
       break;
     case CPP_PRAGMA:
       /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST.  */
-      token->pragma_kind = TREE_INT_CST_LOW (token->value);
+      token->pragma_kind = (pragma_kind) TREE_INT_CST_LOW (token->value);
       token->value = NULL;
       break;
     default:
@@ -6156,7 +6156,7 @@ static tree
 c_parser_objc_type_name (c_parser *parser)
 {
   tree quals = NULL_TREE;
-  struct c_type_name *typename = NULL;
+  struct c_type_name *type_name = NULL;
   tree type = NULL_TREE;
   while (true)
     {
@@ -6176,9 +6176,9 @@ c_parser_objc_type_name (c_parser *parse
 	break;
     }
   if (c_parser_next_token_starts_typename (parser))
-    typename = c_parser_type_name (parser);
-  if (typename)
-    type = groktypename (typename);
+    type_name = c_parser_type_name (parser);
+  if (type_name)
+    type = groktypename (type_name);
   return build_tree_list (quals, type);
 }
 
@@ -6674,7 +6674,7 @@ c_parser_omp_clause_name (c_parser *pars
 /* Validate that a clause of the given type does not already exist.  */
 
 static void
-check_no_duplicate_clause (tree clauses, enum tree_code code, const char *name)
+check_no_duplicate_clause (tree clauses, enum omp_clause_code code, const char *name)
 {
   tree c;
 
@@ -6740,7 +6740,7 @@ c_parser_omp_variable_list (c_parser *pa
    common case for omp clauses.  */
 
 static tree
-c_parser_omp_var_list_parens (c_parser *parser, enum tree_code kind, tree list)
+c_parser_omp_var_list_parens (c_parser *parser, enum omp_clause_code kind, tree list)
 {
   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
     {
@@ -7343,7 +7343,7 @@ c_parser_omp_flush (c_parser *parser)
 {
   c_parser_consume_pragma (parser);
   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
-    c_parser_omp_var_list_parens (parser, 0, NULL);
+    c_parser_omp_var_list_parens (parser, (enum omp_clause_code) 0, NULL);
   else if (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
     c_parser_error (parser, "expected %<(%> or end of line");
   c_parser_skip_to_pragma_eol (parser);
@@ -7784,7 +7784,7 @@ c_parser_omp_threadprivate (c_parser *pa
   tree vars, t;
 
   c_parser_consume_pragma (parser);
-  vars = c_parser_omp_var_list_parens (parser, 0, NULL);
+  vars = c_parser_omp_var_list_parens (parser, (enum omp_clause_code) 0, NULL);
 
   /* Mark every variable in VARS to be assigned thread local storage.  */
   for (t = vars; t; t = TREE_CHAIN (t))

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]