CbC/CbC_gcc: gcc/c-family/c-pretty-print.c comparison

comparison gcc/c-family/c-pretty-print.c @ 132:d34655255c78

update gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 10:21:07 +0900
parents	367f9f4f266e 84e7813d76e9
children	351920fa3827

comparison

equal deleted inserted replaced

-:e108057fa461
+:d34655255c78
 /* Subroutines common to both C and C++ pretty-printers.
-Copyright (C) 2002-2017 Free Software Foundation, Inc.
+Copyright (C) 2002-2018 Free Software Foundation, Inc.
 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #include "stor-layout.h"
 #include "stringpool.h"
 #include "attribs.h"
 #include "intl.h"
 #include "tree-pretty-print.h"
+#include "selftest.h"
 #ifndef noCbC
 #include "../c/cbc-tree.h"
 #endif
 /* The pretty-printer code is primarily designed to closely follow
 			 ? "restrict" : "__restrict__"));
 }
 /* Pretty-print T using the type-cast notation '( type-name )'.  */
-static void
+void
 pp_c_type_cast (c_pretty_printer *pp, tree t)
 {
 pp_c_left_paren (pp);
 pp->type_id (t);
 pp_c_right_paren (pp);
 pp_string (pp, "0");
 }
 /* Pretty-print an INTEGER literal.  */
-static void
+void
 pp_c_integer_constant (c_pretty_printer *pp, tree i)
 {
 if (tree_fits_shwi_p (i))
 pp_wide_integer (pp, tree_to_shwi (i));
 else if (tree_fits_uhwi_p (i))
 pp_c_integer_constant (pp, b);
 else
 pp_unsupported_tree (pp, b);
 }
-/* Attempt to print out an ENUMERATOR.  Return true on success.  Else return
+/* Given a value e of ENUMERAL_TYPE:
-false; that means the value was obtained by a cast, in which case
+Print out the first ENUMERATOR id with value e, if one is found,
-print out the type-id part of the cast-expression -- the casted value
+else print out the value as a C-style cast (type-id)value.  */
-is then printed by pp_c_integer_literal.  */
+static void
-static bool
 pp_c_enumeration_constant (c_pretty_printer *pp, tree e)
 {
-bool value_is_named = true;
 tree type = TREE_TYPE (e);
 tree value;
 /* Find the name of this constant.  */
 for (value = TYPE_VALUES (type);
-value != NULL_TREE && !tree_int_cst_equal (TREE_VALUE (value), e);
+value != NULL_TREE
+	&& !tree_int_cst_equal (DECL_INITIAL (TREE_VALUE (value)), e);
 value = TREE_CHAIN (value))
 ;
 if (value != NULL_TREE)
 pp->id_expression (TREE_PURPOSE (value));
 else
 {
 /* Value must have been cast.  */
 pp_c_type_cast (pp, type);
-value_is_named = false;
+pp_c_integer_constant (pp, e);
 }
-return value_is_named;
 }
 /* Print out a REAL value as a decimal-floating-constant.  */
 static void
 	tree type = TREE_TYPE (e);
 	if (type == boolean_type_node)
 	  pp_c_bool_constant (this, e);
 	else if (type == char_type_node)
 	  pp_c_character_constant (this, e);
-	else if (TREE_CODE (type) == ENUMERAL_TYPE
+	else if (TREE_CODE (type) == ENUMERAL_TYPE)
-		 && pp_c_enumeration_constant (this, e))
+	  pp_c_enumeration_constant (this, e);
-	  ;
 	else
 	  pp_c_integer_constant (this, e);
 }
 break;
 return;
 case VECTOR_TYPE:
 if (TREE_CODE (e) == VECTOR_CST)
 	{
-	  unsigned i;
+	  /* We don't create variable-length VECTOR_CSTs.  */
-	  for (i = 0; i < VECTOR_CST_NELTS (e); ++i)
+	  unsigned int nunits = VECTOR_CST_NELTS (e).to_constant ();
+	  for (unsigned int i = 0; i < nunits; ++i)
 	    {
 	      if (i > 0)
 		pp_separate_with (pp, ',');
 	      pp->expression (VECTOR_CST_ELT (e, i));
 	    }
 pp_c_left_bracket (this);
 expression (TREE_OPERAND (e, 1));
 pp_c_right_bracket (this);
 break;
-case ARRAY_NOTATION_REF:
-postfix_expression (ARRAY_NOTATION_ARRAY (e));
-pp_c_left_bracket (this);
-expression (ARRAY_NOTATION_START (e));
-pp_colon (this);
-expression (ARRAY_NOTATION_LENGTH (e));
-pp_colon (this);
-expression (ARRAY_NOTATION_STRIDE (e));
-pp_c_right_bracket (this);
-break;
 case CALL_EXPR:
 {
 	call_expr_arg_iterator iter;
 	tree arg;
 	postfix_expression (CALL_EXPR_FN (e));
 {
 case FLOAT_EXPR:
 case FIX_TRUNC_EXPR:
 CASE_CONVERT:
 case VIEW_CONVERT_EXPR:
-pp_c_type_cast (pp, TREE_TYPE (e));
+if (!location_wrapper_p (e))
+	pp_c_type_cast (pp, TREE_TYPE (e));
 pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
 break;
 default:
 pp->unary_expression (e);
 case RDIV_EXPR:
 multiplicative_expression (TREE_OPERAND (e, 0));
 pp_c_whitespace (this);
 if (code == MULT_EXPR)
 	pp_c_star (this);
-else if (code == TRUNC_DIV_EXPR)
+else if (code != TRUNC_MOD_EXPR)
 	pp_slash (this);
 else
 	pp_modulo (this);
 pp_c_whitespace (this);
 pp_c_cast_expression (this, TREE_OPERAND (e, 1));
 enum tree_code code = TREE_CODE (e);
 switch (code)
 {
 case POINTER_PLUS_EXPR:
 case PLUS_EXPR:
+case POINTER_DIFF_EXPR:
 case MINUS_EXPR:
 pp_c_additive_expression (pp, TREE_OPERAND (e, 0));
 pp_c_whitespace (pp);
 if (code == PLUS_EXPR || code == POINTER_PLUS_EXPR)
 	pp_plus (pp);
 break;
 case POSTINCREMENT_EXPR:
 case POSTDECREMENT_EXPR:
 case ARRAY_REF:
-case ARRAY_NOTATION_REF:
 case CALL_EXPR:
 case COMPONENT_REF:
 case BIT_FIELD_REF:
 case COMPLEX_CST:
 case COMPLEX_EXPR:
 conditional_expression (e);
 break;
 case POINTER_PLUS_EXPR:
 case PLUS_EXPR:
+case POINTER_DIFF_EXPR:
 case MINUS_EXPR:
 pp_c_additive_expression (this, e);
 break;
 case MODIFY_EXPR:
 return;
 if (pp_needs_newline (this))
 pp_newline_and_indent (this, 0);
-dump_generic_node (this, stmt, pp_indentation (this), 0, true);
+dump_generic_node (this, stmt, pp_indentation (this), TDF_NONE, true);
 }
 /* Initialize the PRETTY-PRINTER for handling C codes.  */
 name = xname;
 }
 pp_c_identifier (pp, name);
 }
+#if CHECKING_P
+namespace selftest {
+/* Selftests for pretty-printing trees.  */
+/* Verify that EXPR printed by c_pretty_printer is EXPECTED, using
+LOC as the effective location for any failures.  */
+static void
+assert_c_pretty_printer_output (const location &loc, const char *expected,
+				tree expr)
+{
+c_pretty_printer pp;
+pp.expression (expr);
+ASSERT_STREQ_AT (loc, expected, pp_formatted_text (&pp));
+}
+/* Helper function for calling assert_c_pretty_printer_output.
+This is to avoid having to write SELFTEST_LOCATION.  */
+#define ASSERT_C_PRETTY_PRINTER_OUTPUT(EXPECTED, EXPR) \
+SELFTEST_BEGIN_STMT						\
+assert_c_pretty_printer_output ((SELFTEST_LOCATION),	\
+				    (EXPECTED),		\
+				    (EXPR));			\
+SELFTEST_END_STMT
+/* Verify that location wrappers don't show up in pretty-printed output.  */
+static void
+test_location_wrappers ()
+{
+/* VAR_DECL.  */
+tree id = get_identifier ("foo");
+tree decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, id,
+			  integer_type_node);
+tree wrapped_decl = maybe_wrap_with_location (decl, BUILTINS_LOCATION);
+ASSERT_NE (wrapped_decl, decl);
+ASSERT_C_PRETTY_PRINTER_OUTPUT ("foo", decl);
+ASSERT_C_PRETTY_PRINTER_OUTPUT ("foo", wrapped_decl);
+/* INTEGER_CST.  */
+tree int_cst = build_int_cst (integer_type_node, 42);
+tree wrapped_cst = maybe_wrap_with_location (int_cst, BUILTINS_LOCATION);
+ASSERT_NE (wrapped_cst, int_cst);
+ASSERT_C_PRETTY_PRINTER_OUTPUT ("42", int_cst);
+ASSERT_C_PRETTY_PRINTER_OUTPUT ("42", wrapped_cst);
+}
+/* Run all of the selftests within this file.  */
+void
+c_pretty_print_c_tests ()
+{
+test_location_wrappers ();
+}
+} // namespace selftest
+#endif /* CHECKING_P */

Mercurial > hg > CbC > CbC_gcc

comparison gcc/c-family/c-pretty-print.c @ 132:d34655255c78