User account creation filtered due to spam.

View | Details | Raw Unified | Return to bug 33255 | Differences between
and this patch

Collapse All | Expand All

(-)a/gcc/Makefile.in (-1 / +1 lines)
Lines 937-943 ALIAS_H = alias.h coretypes.h Link Here
937
EMIT_RTL_H = emit-rtl.h
937
EMIT_RTL_H = emit-rtl.h
938
FLAGS_H = flags.h coretypes.h flag-types.h $(OPTIONS_H)
938
FLAGS_H = flags.h coretypes.h flag-types.h $(OPTIONS_H)
939
OPTIONS_H = options.h flag-types.h $(OPTIONS_H_EXTRA)
939
OPTIONS_H = options.h flag-types.h $(OPTIONS_H_EXTRA)
940
FUNCTION_H = function.h $(TREE_H) $(HASHTAB_H) vecprim.h $(TM_H) hard-reg-set.h
940
FUNCTION_H = function.h $(TREE_H) $(HASHTAB_H) vecprim.h $(TM_H) hard-reg-set.h pointer-set.h
941
EXPR_H = expr.h insn-config.h $(FUNCTION_H) $(RTL_H) $(FLAGS_H) $(TREE_H) $(MACHMODE_H) $(EMIT_RTL_H)
941
EXPR_H = expr.h insn-config.h $(FUNCTION_H) $(RTL_H) $(FLAGS_H) $(TREE_H) $(MACHMODE_H) $(EMIT_RTL_H)
942
OPTABS_H = optabs.h insn-codes.h
942
OPTABS_H = optabs.h insn-codes.h
943
REGS_H = regs.h $(MACHMODE_H) hard-reg-set.h
943
REGS_H = regs.h $(MACHMODE_H) hard-reg-set.h
(-)a/gcc/c-family/c-common.c (+88 lines)
Lines 9604-9609 record_types_used_by_current_var_decl (tree decl) Link Here
9604
    }
9604
    }
9605
}
9605
}
9606
9606
9607
/* If DECL is a typedef that is declared in the current function,
9608
   record it in CFUN->LOCAL_TYPEDEFS.   */
9609
9610
void
9611
record_locally_defined_typedef (tree decl)
9612
{
9613
  if (!is_typedef_decl (decl))
9614
    return;
9615
9616
  if (!DECL_CONTEXT (decl)
9617
      || DECL_CONTEXT (decl) != current_function_decl)
9618
    return;
9619
9620
  VEC_safe_push (tree, gc, cfun->local_typedefs, decl);
9621
}
9622
9623
/* If T is a typedef variant type or a TYPE_DECL declared locally,
9624
   record it in CFUN->USED_LOCAL_TYPEDEFS.  Note that this function
9625
   does not record the typedefs presents in the subtypes of T.  */
9626
9627
void
9628
maybe_record_local_typedef_use (tree t)
9629
{
9630
  tree typedef_decl = NULL_TREE;
9631
9632
  /* We want T to be either a type or a TYPE_DECL.   */
9633
  if (t == NULL_TREE
9634
      || (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL))
9635
    return;
9636
9637
  if (TYPE_P (t))
9638
    {
9639
      if (typedef_variant_p (t))
9640
	typedef_decl = TYPE_NAME (t);
9641
    }
9642
  else
9643
    {
9644
      if (is_typedef_decl (t))
9645
	typedef_decl = t;
9646
    }
9647
9648
  if (typedef_decl != NULL_TREE)
9649
    {
9650
      /* We are only interested in a typedef declared locally.  */
9651
      if (DECL_CONTEXT (typedef_decl) != current_function_decl)
9652
	return;
9653
9654
      /* If this typedef is local, really record its use now.  */
9655
      if (cfun->used_local_typedefs == NULL)
9656
	cfun->used_local_typedefs = pointer_set_create ();
9657
      pointer_set_insert (cfun->used_local_typedefs, typedef_decl);
9658
    }
9659
}
9660
9661
/* Warn if there are some unused locally defined typedefs in the
9662
   current function. */
9663
9664
void
9665
maybe_warn_unused_local_typedefs (void)
9666
{
9667
  int i;
9668
  tree decl;
9669
9670
  if (cfun->used_local_typedefs != NULL)
9671
    gcc_assert (cfun->local_typedefs != NULL);
9672
9673
  if (warn_unused_local_typedefs)
9674
    {
9675
      FOR_EACH_VEC_ELT (tree, cfun->local_typedefs, i, decl)
9676
	if (cfun->used_local_typedefs == NULL
9677
	    || !pointer_set_contains (cfun->used_local_typedefs, decl))
9678
	  warning_at (DECL_SOURCE_LOCATION (decl),
9679
		      OPT_Wunused_local_typedefs,
9680
		      "typedef %qD locally defined but not used", decl);
9681
    }
9682
9683
  if (cfun->used_local_typedefs)
9684
    {
9685
      pointer_set_destroy (cfun->used_local_typedefs);
9686
      cfun->used_local_typedefs = NULL;
9687
    }
9688
  if (cfun->local_typedefs)
9689
    {
9690
      VEC_free (tree, gc, cfun->local_typedefs);
9691
      cfun->local_typedefs = NULL;
9692
    }
9693
}
9694
9607
/* The C and C++ parsers both use vectors to hold function arguments.
9695
/* The C and C++ parsers both use vectors to hold function arguments.
9608
   For efficiency, we keep a cache of unused vectors.  This is the
9696
   For efficiency, we keep a cache of unused vectors.  This is the
9609
   cache.  */
9697
   cache.  */
(-)a/gcc/c-family/c-common.h (+3 lines)
Lines 986-991 extern void warn_for_sign_compare (location_t, Link Here
986
extern void do_warn_double_promotion (tree, tree, tree, const char *, 
986
extern void do_warn_double_promotion (tree, tree, tree, const char *, 
987
				      location_t);
987
				      location_t);
988
extern void set_underlying_type (tree);
988
extern void set_underlying_type (tree);
989
extern void record_locally_defined_typedef (tree);
990
extern void maybe_record_local_typedef_use (tree);
991
extern void maybe_warn_unused_local_typedefs (void);
989
extern VEC(tree,gc) *make_tree_vector (void);
992
extern VEC(tree,gc) *make_tree_vector (void);
990
extern void release_tree_vector (VEC(tree,gc) *);
993
extern void release_tree_vector (VEC(tree,gc) *);
991
extern VEC(tree,gc) *make_tree_vector_single (tree);
994
extern VEC(tree,gc) *make_tree_vector_single (tree);
(-)a/gcc/c-family/c.opt (+4 lines)
Lines 653-658 Wunsuffixed-float-constants Link Here
653
C ObjC Var(warn_unsuffixed_float_constants) Warning
653
C ObjC Var(warn_unsuffixed_float_constants) Warning
654
Warn about unsuffixed float constants
654
Warn about unsuffixed float constants
655
655
656
Wunused-local-typedefs
657
C++ Var(warn_unused_local_typedefs) Warning
658
Warn about
659
656
Wunused-macros
660
Wunused-macros
657
C ObjC C++ ObjC++ Warning
661
C ObjC C++ ObjC++ Warning
658
Warn about macros defined in the main file that are not used
662
Warn about macros defined in the main file that are not used
(-)a/gcc/cp/cp-tree.h (-1 / +2 lines)
Lines 4955-4961 extern bool defer_mark_used_calls; Link Here
4955
extern GTY(()) VEC(tree, gc) *deferred_mark_used_calls;
4955
extern GTY(()) VEC(tree, gc) *deferred_mark_used_calls;
4956
extern tree finish_case_label			(location_t, tree, tree);
4956
extern tree finish_case_label			(location_t, tree, tree);
4957
extern tree cxx_maybe_build_cleanup		(tree, tsubst_flags_t);
4957
extern tree cxx_maybe_build_cleanup		(tree, tsubst_flags_t);
4958
4958
void cp_maybe_record_local_typedef_use          (tree);
4959
void cp_used_types_insert                       (tree);
4959
/* in decl2.c */
4960
/* in decl2.c */
4960
extern bool check_java_method			(tree);
4961
extern bool check_java_method			(tree);
4961
extern tree build_memfn_type			(tree, tree, cp_cv_quals);
4962
extern tree build_memfn_type			(tree, tree, cp_cv_quals);
(-)a/gcc/cp/decl.c (+6 lines)
Lines 10318-10323 grokdeclarator (const cp_declarator *declarator, Link Here
10318
    if (!processing_template_decl)
10318
    if (!processing_template_decl)
10319
      cp_apply_type_quals_to_decl (type_quals, decl);
10319
      cp_apply_type_quals_to_decl (type_quals, decl);
10320
10320
10321
    cp_maybe_record_local_typedef_use (TREE_TYPE (decl));
10322
10321
    return decl;
10323
    return decl;
10322
  }
10324
  }
10323
}
10325
}
Lines 13378-13383 finish_function (int flags) Link Here
13378
      unused_but_set_errorcount = errorcount;
13380
      unused_but_set_errorcount = errorcount;
13379
    }
13381
    }
13380
13382
13383
  /* Complain about locally defined typedefs that are not used in this
13384
     function.  */
13385
  maybe_warn_unused_local_typedefs ();
13386
13381
  /* Genericize before inlining.  */
13387
  /* Genericize before inlining.  */
13382
  if (!processing_template_decl)
13388
  if (!processing_template_decl)
13383
    {
13389
    {
(-)a/gcc/cp/decl2.c (+3 lines)
Lines 4175-4180 mark_used (tree decl) Link Here
4175
4175
4176
  /* Set TREE_USED for the benefit of -Wunused.  */
4176
  /* Set TREE_USED for the benefit of -Wunused.  */
4177
  TREE_USED (decl) = 1;
4177
  TREE_USED (decl) = 1;
4178
4179
  cp_maybe_record_local_typedef_use (TREE_TYPE (decl));
4180
4178
  if (DECL_CLONED_FUNCTION_P (decl))
4181
  if (DECL_CLONED_FUNCTION_P (decl))
4179
    TREE_USED (DECL_CLONED_FUNCTION (decl)) = 1;
4182
    TREE_USED (DECL_CLONED_FUNCTION (decl)) = 1;
4180
4183
(-)a/gcc/cp/init.c (+2 lines)
Lines 2612-2617 build_new (VEC(tree,gc) **placement, tree type, tree nelts, Link Here
2612
  if (type == error_mark_node)
2612
  if (type == error_mark_node)
2613
    return error_mark_node;
2613
    return error_mark_node;
2614
2614
2615
  cp_maybe_record_local_typedef_use (type);
2616
2615
  if (nelts == NULL_TREE && VEC_length (tree, *init) == 1)
2617
  if (nelts == NULL_TREE && VEC_length (tree, *init) == 1)
2616
    {
2618
    {
2617
      tree auto_node = type_uses_auto (type);
2619
      tree auto_node = type_uses_auto (type);
(-)a/gcc/cp/name-lookup.c (+7 lines)
Lines 868-873 pushdecl_maybe_friend_1 (tree x, bool is_friend) Link Here
868
	      && TYPE_NAME (type)
868
	      && TYPE_NAME (type)
869
	      && TYPE_IDENTIFIER (type))
869
	      && TYPE_IDENTIFIER (type))
870
	    set_identifier_type_value (DECL_NAME (x), x);
870
	    set_identifier_type_value (DECL_NAME (x), x);
871
872
	  /* If this is a locally defined typedef in a function that
873
	     is not a template instantation, record it to implement
874
	     -Wunused-local-typedefs.  */
875
	  if (current_instantiation () == NULL
876
	      || (current_instantiation ()->decl != current_function_decl))
877
	  record_locally_defined_typedef (x);
871
	}
878
	}
872
879
873
      /* Multiple external decls of the same identifier ought to match.
880
      /* Multiple external decls of the same identifier ought to match.
(-)a/gcc/cp/parser.c (+7 lines)
Lines 4707-4712 cp_parser_qualifying_entity (cp_parser *parser, Link Here
4707
      scope = cp_parser_namespace_name (parser);
4707
      scope = cp_parser_namespace_name (parser);
4708
    }
4708
    }
4709
4709
4710
  cp_maybe_record_local_typedef_use (scope);
4710
  return scope;
4711
  return scope;
4711
}
4712
}
4712
4713
Lines 11702-11707 cp_parser_template_id (cp_parser *parser, Link Here
11702
      template_id = lookup_template_function (templ, arguments);
11703
      template_id = lookup_template_function (templ, arguments);
11703
    }
11704
    }
11704
11705
11706
  /* Mark the possible use of a typedefs in the arguments, for the
11707
     purpose of -Wunused-local-typedefs.  */
11708
  if (arguments != NULL_TREE)
11709
    for (i = 0; i < TREE_VEC_LENGTH (arguments); ++i)
11710
      cp_maybe_record_local_typedef_use (TREE_VEC_ELT (arguments, i));
11711
11705
  /* If parsing tentatively, replace the sequence of tokens that makes
11712
  /* If parsing tentatively, replace the sequence of tokens that makes
11706
     up the template-id with a CPP_TEMPLATE_ID token.  That way,
11713
     up the template-id with a CPP_TEMPLATE_ID token.  That way,
11707
     should we re-parse the token stream, we will not have to repeat
11714
     should we re-parse the token stream, we will not have to repeat
(-)a/gcc/cp/rtti.c (-1 / +1 lines)
Lines 521-527 build_dynamic_cast_1 (tree type, tree expr, tsubst_flags_t complain) Link Here
521
  const char *errstr = NULL;
521
  const char *errstr = NULL;
522
522
523
  /* Save casted types in the function's used types hash table.  */
523
  /* Save casted types in the function's used types hash table.  */
524
  used_types_insert (type);
524
  cp_used_types_insert (type);
525
525
526
  /* T shall be a pointer or reference to a complete class type, or
526
  /* T shall be a pointer or reference to a complete class type, or
527
     `pointer to cv void''.  */
527
     `pointer to cv void''.  */
(-)a/gcc/cp/tree.c (+47 lines)
Lines 47-52 static tree build_local_temp (tree); Link Here
47
static tree handle_java_interface_attribute (tree *, tree, tree, int, bool *);
47
static tree handle_java_interface_attribute (tree *, tree, tree, int, bool *);
48
static tree handle_com_interface_attribute (tree *, tree, tree, int, bool *);
48
static tree handle_com_interface_attribute (tree *, tree, tree, int, bool *);
49
static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
49
static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
50
static tree cp_maybe_record_local_typedef_use_r (tree*, int *, void *);
50
51
51
/* If REF is an lvalue, returns the kind of lvalue that REF is.
52
/* If REF is an lvalue, returns the kind of lvalue that REF is.
52
   Otherwise, returns clk_none.  */
53
   Otherwise, returns clk_none.  */
Lines 3439-3444 cp_free_lang_data (tree t) Link Here
3439
    }
3440
    }
3440
}
3441
}
3441
3442
3443
/* Subroutine of cp_maybe_record_local_typedef_use, called from
3444
   cp_walk_tree_without_duplicate.   */
3445
3446
static tree
3447
cp_maybe_record_local_typedef_use_r (tree *tp,
3448
				     int *walk_subtrees ATTRIBUTE_UNUSED,
3449
				     void *data ATTRIBUTE_UNUSED)
3450
{
3451
  maybe_record_local_typedef_use (*tp);
3452
  return NULL_TREE;
3453
}
3454
3455
/* If T is a typedef variant type or a TYPE_DECL declared locally,
3456
   record it in CFUN->USED_LOCAL_TYPEDEFS.  This function also records
3457
   the typedefs that are direct or indirect subtypes of T.  */
3458
3459
void
3460
cp_maybe_record_local_typedef_use (tree t)
3461
{
3462
  if (!warn_unused_local_typedefs)
3463
    return;
3464
3465
  /*  If the current function is being instantiated, bail out.  */
3466
  if (current_instantiation () != NULL
3467
      && (current_instantiation ()->decl == current_function_decl))
3468
    return;
3469
3470
  maybe_record_local_typedef_use (t);
3471
3472
  /* Record the typedefs used by subtypes of TYPE.  */
3473
  cp_walk_tree_without_duplicates (&t,
3474
				   cp_maybe_record_local_typedef_use_r,
3475
				   NULL_TREE);
3476
}
3477
3478
/* Given a type, insert it into the used hash table in cfun.  If that
3479
   type is a typedef, mark it as used for the purpose implementing
3480
   -Wunused-local-typedefs.  */
3481
3482
void
3483
cp_used_types_insert (tree t)
3484
{
3485
  used_types_insert (t);
3486
  cp_maybe_record_local_typedef_use (t);
3487
}
3488
3442
/* Stub for c-common.  Please keep in sync with c-decl.c.
3489
/* Stub for c-common.  Please keep in sync with c-decl.c.
3443
   FIXME: If address space support is target specific, then this
3490
   FIXME: If address space support is target specific, then this
3444
   should be a C target hook.  But currently this is not possible,
3491
   should be a C target hook.  But currently this is not possible,
(-)a/gcc/cp/typeck.c (-3 / +5 lines)
Lines 1518-1523 cxx_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain) Link Here
1518
      value = size_one_node;
1518
      value = size_one_node;
1519
    }
1519
    }
1520
1520
1521
  maybe_record_local_typedef_use (type);
1522
1521
  dependent_p = dependent_type_p (type);
1523
  dependent_p = dependent_type_p (type);
1522
  if (!dependent_p)
1524
  if (!dependent_p)
1523
    complete_type (type);
1525
    complete_type (type);
Lines 5712-5718 build_static_cast_1 (tree type, tree expr, bool c_cast_p, Link Here
5712
  intype = TREE_TYPE (expr);
5714
  intype = TREE_TYPE (expr);
5713
5715
5714
  /* Save casted types in the function's used types hash table.  */
5716
  /* Save casted types in the function's used types hash table.  */
5715
  used_types_insert (type);
5717
  cp_used_types_insert (type);
5716
5718
5717
  /* [expr.static.cast]
5719
  /* [expr.static.cast]
5718
5720
Lines 6015-6021 build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p, Link Here
6015
  intype = TREE_TYPE (expr);
6017
  intype = TREE_TYPE (expr);
6016
6018
6017
  /* Save casted types in the function's used types hash table.  */
6019
  /* Save casted types in the function's used types hash table.  */
6018
  used_types_insert (type);
6020
  cp_used_types_insert (type);
6019
6021
6020
  /* [expr.reinterpret.cast]
6022
  /* [expr.reinterpret.cast]
6021
     An lvalue expression of type T1 can be cast to the type
6023
     An lvalue expression of type T1 can be cast to the type
Lines 6235-6241 build_const_cast_1 (tree dst_type, tree expr, tsubst_flags_t complain, Link Here
6235
    }
6237
    }
6236
6238
6237
  /* Save casted types in the function's used types hash table.  */
6239
  /* Save casted types in the function's used types hash table.  */
6238
  used_types_insert (dst_type);
6240
  cp_used_types_insert (dst_type);
6239
6241
6240
  src_type = TREE_TYPE (expr);
6242
  src_type = TREE_TYPE (expr);
6241
  /* Expressions do not really have reference types.  */
6243
  /* Expressions do not really have reference types.  */
(-)a/gcc/cp/typeck2.c (+2 lines)
Lines 1607-1612 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain) Link Here
1607
      type = error_mark_node;
1607
      type = error_mark_node;
1608
    }
1608
    }
1609
1609
1610
  cp_maybe_record_local_typedef_use (type);
1611
1610
  if (processing_template_decl)
1612
  if (processing_template_decl)
1611
    {
1613
    {
1612
      tree t;
1614
      tree t;
(-)a/gcc/doc/invoke.texi (-2 / +7 lines)
Lines 267-274 Objective-C and Objective-C++ Dialects}. Link Here
267
-Wsystem-headers  -Wtrampolines  -Wtrigraphs  -Wtype-limits  -Wundef @gol
267
-Wsystem-headers  -Wtrampolines  -Wtrigraphs  -Wtype-limits  -Wundef @gol
268
-Wuninitialized  -Wunknown-pragmas  -Wno-pragmas @gol
268
-Wuninitialized  -Wunknown-pragmas  -Wno-pragmas @gol
269
-Wunsuffixed-float-constants  -Wunused  -Wunused-function @gol
269
-Wunsuffixed-float-constants  -Wunused  -Wunused-function @gol
270
-Wunused-label  -Wunused-parameter -Wno-unused-result -Wunused-value @gol
270
-Wunused-label  -Wunused-local-typedefs -Wunused-parameter @gol
271
-Wunused-variable -Wunused-but-set-parameter -Wunused-but-set-variable @gol
271
-Wno-unused-result -Wunused-value @gol -Wunused-variable @gol
272
-Wunused-but-set-parameter -Wunused-but-set-variable @gol
272
-Wvariadic-macros -Wvla -Wvolatile-register-var  -Wwrite-strings}
273
-Wvariadic-macros -Wvla -Wvolatile-register-var  -Wwrite-strings}
273
274
274
@item C and Objective-C-only Warning Options
275
@item C and Objective-C-only Warning Options
Lines 2567-2572 C++-specific options (e.g., @option{-Wabi}). Link Here
2567
Here is a list of options that are @emph{only} for compiling Objective-C
2568
Here is a list of options that are @emph{only} for compiling Objective-C
2568
and Objective-C++ programs:
2569
and Objective-C++ programs:
2569
2570
2571
@item -Wunused-local-typedefs @r{(C++ and Objective-C++ only)}
2572
@opindex Wunused-local-typedefs
2573
Warn when a typedef locally defined in a function is not used.
2574
2570
@table @gcctabopt
2575
@table @gcctabopt
2571
@item -fconstant-string-class=@var{class-name}
2576
@item -fconstant-string-class=@var{class-name}
2572
@opindex fconstant-string-class
2577
@opindex fconstant-string-class
(-)a/gcc/function.h (+8 lines)
Lines 27-32 along with GCC; see the file COPYING3. If not see Link Here
27
#include "vecprim.h"
27
#include "vecprim.h"
28
#include "tm.h"		/* For CUMULATIVE_ARGS.  */
28
#include "tm.h"		/* For CUMULATIVE_ARGS.  */
29
#include "hard-reg-set.h"
29
#include "hard-reg-set.h"
30
#include "pointer-set.h"
30
31
31
/* Stack of pending (incomplete) sequences saved by `start_sequence'.
32
/* Stack of pending (incomplete) sequences saved by `start_sequence'.
32
   Each element describes one pending sequence.
33
   Each element describes one pending sequence.
Lines 532-537 struct GTY(()) function { Link Here
532
  /* Vector of function local variables, functions, types and constants.  */
533
  /* Vector of function local variables, functions, types and constants.  */
533
  VEC(tree,gc) *local_decls;
534
  VEC(tree,gc) *local_decls;
534
535
536
  /* Vector of locally defined typedefs, for
537
     -Wunused-local-typedefs.  */
538
  VEC(tree,gc) *local_typedefs;
539
540
  /*  Set of typedefs that are used in this function.  */
541
  struct pointer_set_t * GTY((skip)) used_local_typedefs;
542
535
  /* For md files.  */
543
  /* For md files.  */
536
544
537
  /* tm.h can use this to store whatever it likes.  */
545
  /* tm.h can use this to store whatever it likes.  */
(-)a/gcc/tree.c (+5 lines)
Lines 10323-10328 walk_type_fields (tree type, walk_tree_fn func, void *data, Link Here
10323
{
10323
{
10324
  tree result = NULL_TREE;
10324
  tree result = NULL_TREE;
10325
10325
10326
  /* If this type is a typedef variant, walk the fields of its
10327
     underlying type.  */
10328
  if (typedef_variant_p (type))
10329
    WALK_SUBTREE (DECL_ORIGINAL_TYPE (TYPE_NAME (type)));
10330
10326
  switch (TREE_CODE (type))
10331
  switch (TREE_CODE (type))
10327
    {
10332
    {
10328
    case POINTER_TYPE:
10333
    case POINTER_TYPE:
(-)a/libstdc++-v3/include/ext/bitmap_allocator.h (-2 lines)
Lines 238-245 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) Link Here
238
      __lower_bound(_ForwardIterator __first, _ForwardIterator __last,
238
      __lower_bound(_ForwardIterator __first, _ForwardIterator __last,
239
		    const _Tp& __val, _Compare __comp)
239
		    const _Tp& __val, _Compare __comp)
240
      {
240
      {
241
	typedef typename __mv_iter_traits<_ForwardIterator>::value_type
242
	  _ValueType;
243
	typedef typename __mv_iter_traits<_ForwardIterator>::difference_type
241
	typedef typename __mv_iter_traits<_ForwardIterator>::difference_type
244
	  _DistanceType;
242
	  _DistanceType;
245
243
(-)a/libstdc++-v3/src/istream.cc (-3 lines)
Lines 280-286 _GLIBCXX_BEGIN_NAMESPACE_VERSION Link Here
280
    {
280
    {
281
      typedef basic_istream<char>       	__istream_type;
281
      typedef basic_istream<char>       	__istream_type;
282
      typedef __istream_type::int_type		__int_type;
282
      typedef __istream_type::int_type		__int_type;
283
      typedef __istream_type::char_type		__char_type;
284
      typedef __istream_type::traits_type	__traits_type;
283
      typedef __istream_type::traits_type	__traits_type;
285
      typedef __istream_type::__streambuf_type  __streambuf_type;
284
      typedef __istream_type::__streambuf_type  __streambuf_type;
286
      typedef __istream_type::__ctype_type	__ctype_type;
285
      typedef __istream_type::__ctype_type	__ctype_type;
Lines 364-370 _GLIBCXX_BEGIN_NAMESPACE_VERSION Link Here
364
      typedef __istream_type::char_type		__char_type;
363
      typedef __istream_type::char_type		__char_type;
365
      typedef __istream_type::traits_type	__traits_type;
364
      typedef __istream_type::traits_type	__traits_type;
366
      typedef __istream_type::__streambuf_type  __streambuf_type;
365
      typedef __istream_type::__streambuf_type  __streambuf_type;
367
      typedef __istream_type::__ctype_type	__ctype_type;
368
      typedef basic_string<char>        	__string_type;
366
      typedef basic_string<char>        	__string_type;
369
      typedef __string_type::size_type		__size_type;
367
      typedef __string_type::size_type		__size_type;
370
368
Lines 610-616 _GLIBCXX_BEGIN_NAMESPACE_VERSION Link Here
610
      typedef __istream_type::char_type		__char_type;
608
      typedef __istream_type::char_type		__char_type;
611
      typedef __istream_type::traits_type	__traits_type;
609
      typedef __istream_type::traits_type	__traits_type;
612
      typedef __istream_type::__streambuf_type  __streambuf_type;
610
      typedef __istream_type::__streambuf_type  __streambuf_type;
613
      typedef __istream_type::__ctype_type	__ctype_type;
614
      typedef basic_string<wchar_t>        	__string_type;
611
      typedef basic_string<wchar_t>        	__string_type;
615
      typedef __string_type::size_type		__size_type;
612
      typedef __string_type::size_type		__size_type;
616
613
(-)a/libstdc++-v3/src/valarray.cc (-2 lines)
Lines 49-55 _GLIBCXX_BEGIN_NAMESPACE_VERSION Link Here
49
  inline size_t
49
  inline size_t
50
  __valarray_product(const valarray<size_t>& __a)
50
  __valarray_product(const valarray<size_t>& __a)
51
  {
51
  {
52
    typedef const size_t* __restrict__ _Tp;
53
    const size_t __n = __a.size();
52
    const size_t __n = __a.size();
54
    // XXX: This ugly cast is necessary because
53
    // XXX: This ugly cast is necessary because
55
    //      valarray::operator[]() const return a VALUE!
54
    //      valarray::operator[]() const return a VALUE!
56
- 

Return to bug 33255