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] Remove BOUNDED macros


Hi,
thi spatch removes the BOUNDED macros in tree.h, that are not used anywhere.
AFAICT the bounded pointers work ceased back in 2000-05-03 when this
patch went in. googling 'Greg McGary' shows the most recent posting
being early 2002, but that did not concern bounded pointers. I can't
find anything more recent than 2000 for the pointer work.

booted & tested on i686-pc-linux-gnu, ok?

nathan
--
Nathan Sidwell    ::   http://www.codesourcery.com   ::     CodeSourcery LLC
         The voices in my head said this was stupid too
nathan@codesourcery.com    ::     http://www.planetfall.pwp.blueyonder.co.uk

2003-05-19  Nathan Sidwell  <nathan@codesourcery.com>

	* c-common.h (enum rid): Remove RID_BOUNDED, RID_UNBOUNDED.
	* c-parse.in (reswords): Remove __bounded__ and __unbounded__.
	(rid_to_yy): Remove RID_BOUNDED, RID_UNBOUNDED slots.
	* print-tree.c (print_node): Remove ambient-boundedness.
	* tree.h (tree_common): Remove bounded_flag.
	(BOUNDED_INDIRECT_YPE_P, BOUNDED_POINTER_TYPE_P,
	BOUNDED_REFERENCE_TYPE_P, MAYBE_BOUNDED_INDIRECT_TYPE_P,
	MAYBE_BOUNDED_POINTER_TYPE_P, MAYBE_BOUNDED_REFERENCE_TYPE_P,
	TREE_BOUNDED, TYPE_MAIN_VARIANTS_PHYSICALLY_EQUAL_P,
	TYPE_MAIN_PHYSICAL_VARIANT, TYPE_BOUNDED, TYPE_QUAL_BOUNDED):
	Remove.
	(TYPE_QUALS): Remove BOUNDED.
	(TREE_EXPR_QUALS, TREE_FUNC_QUALS): Remove.
	(TYPE_BOUNDED_VALUE, TYPE_BOUNDED_BASE, TYPE_BOUNDED_EXTENT,
	TYPE_BOUNDED_SUBTYPE, TYPE_UNBOUNDED_VARIANT, TYPE_POINTER_DEPTH,
	TYPE_AMBIENT_BOUNDEDNESS, MAX_POINTER_DEPT,
	VA_LIST_POINTER_DEPTH): Remove.
	(struct tree_type): Remove pointer_depth.

	* treelang/treetree.c (reswords): Remove __bounded__, __unbounded__.
	
Index: c-common.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-common.h,v
retrieving revision 1.179
diff -c -3 -p -r1.179 c-common.h
*** c-common.h	17 May 2003 20:29:29 -0000	1.179
--- c-common.h	19 May 2003 13:38:53 -0000
*************** enum rid
*** 58,64 ****
    RID_VOLATILE, RID_SIGNED,  RID_AUTO,  RID_RESTRICT,
  
    /* C extensions */
!   RID_BOUNDED, RID_UNBOUNDED, RID_COMPLEX, RID_THREAD,
  
    /* C++ */
    RID_FRIEND, RID_VIRTUAL, RID_EXPLICIT, RID_EXPORT, RID_MUTABLE,
--- 58,64 ----
    RID_VOLATILE, RID_SIGNED,  RID_AUTO,  RID_RESTRICT,
  
    /* C extensions */
!   RID_COMPLEX, RID_THREAD,
  
    /* C++ */
    RID_FRIEND, RID_VIRTUAL, RID_EXPLICIT, RID_EXPORT, RID_MUTABLE,
Index: c-parse.in
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-parse.in,v
retrieving revision 1.159
diff -c -3 -p -r1.159 c-parse.in
*** c-parse.in	12 May 2003 03:25:37 -0000	1.159
--- c-parse.in	19 May 2003 13:39:00 -0000
*************** static const struct resword reswords[] =
*** 3325,3332 ****
    { "__asm__",		RID_ASM,	0 },
    { "__attribute",	RID_ATTRIBUTE,	0 },
    { "__attribute__",	RID_ATTRIBUTE,	0 },
-   { "__bounded",	RID_BOUNDED,	0 },
-   { "__bounded__",	RID_BOUNDED,	0 },
    { "__builtin_choose_expr", RID_CHOOSE_EXPR, 0 },
    { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, 0 },
    { "__builtin_va_arg",	RID_VA_ARG,	0 },
--- 3325,3330 ----
*************** static const struct resword reswords[] =
*** 3356,3363 ****
    { "__thread",		RID_THREAD,	0 },
    { "__typeof",		RID_TYPEOF,	0 },
    { "__typeof__",	RID_TYPEOF,	0 },
-   { "__unbounded",	RID_UNBOUNDED,	0 },
-   { "__unbounded__",	RID_UNBOUNDED,	0 },
    { "__volatile",	RID_VOLATILE,	0 },
    { "__volatile__",	RID_VOLATILE,	0 },
    { "asm",		RID_ASM,	D_EXT },
--- 3354,3359 ----
*************** static const short rid_to_yy[RID_MAX] =
*** 3446,3453 ****
    /* RID_RESTRICT */	TYPE_QUAL,
  
    /* C extensions */
-   /* RID_BOUNDED */	TYPE_QUAL,
-   /* RID_UNBOUNDED */	TYPE_QUAL,
    /* RID_COMPLEX */	TYPESPEC,
    /* RID_THREAD */	SCSPEC,
  
--- 3442,3447 ----
Index: print-tree.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/print-tree.c,v
retrieving revision 1.70
diff -c -3 -p -r1.70 print-tree.c
*** print-tree.c	17 May 2003 01:40:41 -0000	1.70
--- print-tree.c	19 May 2003 13:39:03 -0000
*************** print_node (file, prefix, node, indent)
*** 494,502 ****
        else if (TREE_CODE (node) == ARRAY_TYPE
  	       && TYPE_NONALIASED_COMPONENT (node))
  	fputs (" nonaliased-component", file);
-       else if (TREE_CODE (node) == FUNCTION_TYPE
- 	       && TYPE_AMBIENT_BOUNDEDNESS (node))
- 	fputs (" ambient-boundedness", file);
  
        if (TYPE_PACKED (node))
  	fputs (" packed", file);
--- 494,499 ----
Index: tree.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree.h,v
retrieving revision 1.402
diff -c -3 -p -r1.402 tree.h
*** tree.h	18 May 2003 13:40:47 -0000	1.402
--- tree.h	19 May 2003 13:39:16 -0000
*************** struct tree_common GTY(())
*** 145,152 ****
    unsigned public_flag : 1;
    unsigned private_flag : 1;
    unsigned protected_flag : 1;
-   unsigned bounded_flag : 1;
    unsigned deprecated_flag : 1;
  
    unsigned lang_flag_0 : 1;
    unsigned lang_flag_1 : 1;
--- 145,152 ----
    unsigned public_flag : 1;
    unsigned private_flag : 1;
    unsigned protected_flag : 1;
    unsigned deprecated_flag : 1;
+   unsigned unused_1 : 1;
  
    unsigned lang_flag_0 : 1;
    unsigned lang_flag_1 : 1;
*************** struct tree_common GTY(())
*** 155,161 ****
    unsigned lang_flag_4 : 1;
    unsigned lang_flag_5 : 1;
    unsigned lang_flag_6 : 1;
!   unsigned unused_1 : 1;
  };
  
  /* The following table lists the uses of each of the above flags and
--- 155,161 ----
    unsigned lang_flag_4 : 1;
    unsigned lang_flag_5 : 1;
    unsigned lang_flag_6 : 1;
!   unsigned unused_2 : 1;
  };
  
  /* The following table lists the uses of each of the above flags and
*************** struct tree_common GTY(())
*** 255,268 ****
         TREE_NOTHROW in
             CALL_EXPR, FUNCTION_DECL
  
-    bounded_flag:
- 
-        TREE_BOUNDED in
- 	   expressions, VAR_DECL, PARM_DECL, FIELD_DECL, FUNCTION_DECL,
- 	   IDENTIFIER_NODE
-        TYPE_BOUNDED in
- 	   ..._TYPE
- 
     deprecated_flag:
  
  	TREE_DEPRECATED in
--- 255,260 ----
*************** extern void tree_operand_check_failed PA
*** 471,526 ****
     || TREE_CODE (TYPE) == UNION_TYPE || TREE_CODE (TYPE) == QUAL_UNION_TYPE \
     || TREE_CODE (TYPE) == SET_TYPE)
  
! /* Nonzero if TYPE represents an unbounded pointer or unbounded
!    reference type.  (It should be renamed to INDIRECT_TYPE_P.)  */
  
  #define POINTER_TYPE_P(TYPE) \
    (TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE)
  
- /* Nonzero if TYPE represents a bounded pointer or bounded reference type.  */
- 
- #define BOUNDED_INDIRECT_TYPE_P(TYPE) \
-   (TREE_CODE (TYPE) == RECORD_TYPE && TREE_TYPE (TYPE))
- 
- /* Nonzero if TYPE represents a bounded pointer type.  */
- 
- #define BOUNDED_POINTER_TYPE_P(TYPE) \
-   (BOUNDED_INDIRECT_TYPE_P (TYPE) \
-    && TREE_CODE (TYPE_BOUNDED_SUBTYPE (TYPE)) == POINTER_TYPE)
- 
- /* Nonzero if TYPE represents a bounded reference type.  Bounded
-    reference types have two specific uses: (1) When a reference is
-    seated to a variable-length RECORD_TYPE that has an array of
-    indeterminate length as its final field.  For all other objects, it
-    is sufficient to check bounds at the time the reference is seated,
-    and assume that all future uses of the reference are safe, since
-    the address of references cannot change.  (2) When a reference
-    supertype is seated to a subtype object.  The bounds "remember"
-    the true size of the complete object, so that subsequent upcasts of
-    the address of the reference will be checked properly (is such a
-    thing valid C++?).  */
- 
- #define BOUNDED_REFERENCE_TYPE_P(TYPE) \
-   (BOUNDED_INDIRECT_TYPE_P (TYPE) \
-    && TREE_CODE (TYPE_BOUNDED_SUBTYPE (TYPE)) == REFERENCE_TYPE)
- 
- /* Nonzero if TYPE represents a pointer or reference type, either
-    bounded or unbounded.  */
- 
- #define MAYBE_BOUNDED_INDIRECT_TYPE_P(TYPE) \
-   (POINTER_TYPE_P (TYPE) || BOUNDED_INDIRECT_TYPE_P (TYPE))
- 
- /* Nonzero if TYPE represents a pointer type, either bounded or unbounded.  */
- 
- #define MAYBE_BOUNDED_POINTER_TYPE_P(TYPE) \
-   (TREE_CODE (TYPE) == POINTER_TYPE || BOUNDED_POINTER_TYPE_P (TYPE))
- 
- /* Nonzero if TYPE represents a reference type, either bounded or
-    unbounded.  */
- 
- #define MAYBE_BOUNDED_REFERENCE_TYPE_P(TYPE) \
-   (TREE_CODE (TYPE) == REFERENCE_TYPE || BOUNDED_REFERENCE_TYPE_P (TYPE))
- 
  /* Nonzero if this type is a complete type.  */
  #define COMPLETE_TYPE_P(NODE) (TYPE_SIZE (NODE) != NULL_TREE)
  
--- 463,474 ----
     || TREE_CODE (TYPE) == UNION_TYPE || TREE_CODE (TYPE) == QUAL_UNION_TYPE \
     || TREE_CODE (TYPE) == SET_TYPE)
  
! /* Nonzero if TYPE represents a pointer or reference type.
!    (It should be renamed to INDIRECT_TYPE_P.)  */
  
  #define POINTER_TYPE_P(TYPE) \
    (TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE)
  
  /* Nonzero if this type is a complete type.  */
  #define COMPLETE_TYPE_P(NODE) (TYPE_SIZE (NODE) != NULL_TREE)
  
*************** extern void tree_operand_check_failed PA
*** 679,718 ****
     In a BLOCK node, this is BLOCK_HANDLER_BLOCK.  */
  #define TREE_PROTECTED(NODE) ((NODE)->common.protected_flag)
  
- /* In a ..._TYPE node, nonzero means that the type's size and layout,
-    (or the size and layout of its arguments and/or return value in the
-    case of a FUNCTION_TYPE or METHOD_TYPE) was changed by the presence
-    of pointer bounds.  Use TYPE_BOUNDED instead of this macro when the
-    node is a type, because eventually we may make that a different
-    bit.  TYPE_BOUNDED doesn't mean that this type is a bounded indirect
-    type--use BOUNDED_POINTER_TYPE_P, BOUNDED_REFERENCE_TYPE_P,
-    BOUNDED_INDIRECT_TYPE_P to test for that.
- 
-    In a FUNCTION_DECL, nonzero means that the size and layout of one
-    of its arguments and/or return value was changed by the presence of
-    pointer bounds.  This value can differ from the value of
-    TYPE_BOUNDED (TREE_TYPE (fundecl)) if the function was implicitly
-    declared, then later called with pointer args, or was declared with
-    a variable argument list and is later called with pointer values in
-    the variable argument list.
- 
-    In a VAR_DECL, PARM_DECL or FIELD_DECL, TREE_BOUNDED matches the value
-    of the decl's type's BOUNDED_POINTER_TYPE_P.
- 
-    In a CONSTRUCTOR or other expression, nonzero means the value is a
-    bounded pointer.  It is insufficient to determine the boundedness
-    of an expression EXP with BOUNDED_POINTER_TYPE_P (TREE_TYPE (EXP)),
-    since we allow pointer to be temporarily cast to integer for
-    rounding up to an alignment boundary in a way that preserves the
-    pointer's bounds.
- 
-    In an IDENTIFIER_NODE, nonzero means that the name is prefixed with
-    BP_PREFIX (see varasm.c).  This occurs for the DECL_ASSEMBLER_NAME
-    of a function that has bounded pointer(s) for its return type and/or
-    argument type(s).  */
- 
- #define TREE_BOUNDED(NODE) ((NODE)->common.bounded_flag)
- 
  /* Nonzero in an IDENTIFIER_NODE if the use of the name is defined as a
     deprecated feature by __attribute__((deprecated)).  */
  #define TREE_DEPRECATED(NODE) ((NODE)->common.deprecated_flag)
--- 627,632 ----
*************** struct tree_block GTY(())
*** 1023,1048 ****
     structure containing an array.  */
  #define TYPE_DEBUG_REPRESENTATION_TYPE(NODE) (TYPE_CHECK (NODE)->type.values)
  
- /* Indirect types present difficulties because they may be represented
-    as either POINTER_TYPE/REFERENCE_TYPE nodes (unbounded) or as
-    RECORD_TYPE nodes (bounded).  Bounded and unbounded pointers might
-    be logically equivalent, but physically different.  Simple
-    comparison of the main variant only tells if the types are
-    logically equivalent.  Use this predicate to compare for physical
-    equivalency.  */
- 
- /* Types have the same main variant, and have the same boundedness.  */
- #define TYPE_MAIN_VARIANTS_PHYSICALLY_EQUAL_P(TYPE1, TYPE2)	\
-   (TYPE_MAIN_VARIANT (TYPE1) == TYPE_MAIN_VARIANT (TYPE2)	\
-    && TREE_CODE (TYPE1) == TREE_CODE (TYPE2))
- 
- /* Return the type variant that has no qualifiers (i.e., the main variant),
-    except that the boundedness qualifier is preserved.  */
- #define TYPE_MAIN_PHYSICAL_VARIANT(TYPE)		\
-   (BOUNDED_POINTER_TYPE_P (TYPE)			\
-    ? build_qualified_type (TYPE, TYPE_QUAL_BOUNDED)	\
-    : TYPE_MAIN_VARIANT (TYPE))
- 
  /* For aggregate types, information about this type, as a base type
     for itself.  Used in a language-dependent way for types that are
     neither a RECORD_TYPE, QUAL_UNION_TYPE, nor a UNION_TYPE.  */
--- 937,942 ----
*************** struct tree_block GTY(())
*** 1114,1124 ****
     the term.  */
  #define TYPE_RESTRICT(NODE) (TYPE_CHECK (NODE)->type.restrict_flag)
  
- /* If nonzero, this type's size and layout, (or the size and layout of
-    its arguments and/or return value in the case of a FUNCTION_TYPE or
-    METHOD_TYPE) was changed by the presence of pointer bounds.  */
- #define TYPE_BOUNDED(NODE) (TYPE_CHECK (NODE)->common.bounded_flag)
- 
  /* There is a TYPE_QUAL value for each type qualifier.  They can be
     combined by bitwise-or to form the complete set of qualifiers for a
     type.  */
--- 1008,1013 ----
*************** struct tree_block GTY(())
*** 1127,1151 ****
  #define TYPE_QUAL_CONST    0x1
  #define TYPE_QUAL_VOLATILE 0x2
  #define TYPE_QUAL_RESTRICT 0x4
- #define TYPE_QUAL_BOUNDED  0x8
  
  /* The set of type qualifiers for this type.  */
  #define TYPE_QUALS(NODE)					\
    ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)			\
     | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)		\
!    | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)		\
!    | (BOUNDED_INDIRECT_TYPE_P (NODE) * TYPE_QUAL_BOUNDED))
! 
! /* The set of qualifiers pertinent to an expression node.  */
! #define TREE_EXPR_QUALS(NODE)				\
!   ((TREE_READONLY (NODE) * TYPE_QUAL_CONST)		\
!    | (TREE_THIS_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)	\
!    | (TREE_BOUNDED (NODE) * TYPE_QUAL_BOUNDED))
! 
! /* The set of qualifiers pertinent to a FUNCTION_DECL node.  */
! #define TREE_FUNC_QUALS(NODE)				\
!   ((TREE_READONLY (NODE) * TYPE_QUAL_CONST)		\
!    | (TREE_THIS_VOLATILE (NODE) * TYPE_QUAL_VOLATILE))
  
  /* These flags are available for each language front end to use internally.  */
  #define TYPE_LANG_FLAG_0(NODE) (TYPE_CHECK (NODE)->type.lang_flag_0)
--- 1016,1027 ----
  #define TYPE_QUAL_CONST    0x1
  #define TYPE_QUAL_VOLATILE 0x2
  #define TYPE_QUAL_RESTRICT 0x4
  
  /* The set of type qualifiers for this type.  */
  #define TYPE_QUALS(NODE)					\
    ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)			\
     | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)		\
!    | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT))
  
  /* These flags are available for each language front end to use internally.  */
  #define TYPE_LANG_FLAG_0(NODE) (TYPE_CHECK (NODE)->type.lang_flag_0)
*************** struct tree_block GTY(())
*** 1190,1254 ****
     compact a way as possible.  */
  #define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->type.packed_flag)
  
- /* A bounded pointer or bounded reference type (collectively called
-    indirect types) is represented as a RECORD_TYPE node containing
-    three pointer fields whose type is the corresponding unbounded
-    POINTER_TYPE or REFERENCE_TYPE.  A RECORD_TYPE node that represents
-    a bounded indirect type differs from a normal RECORD_TYPE node in
-    that its TREE_TYPE is non-NULL and has the pointed-to type just as
-    a POINTER_TYPE or REFERENCE_TYPE node has.  The bounded RECORD_TYPE
-    nodes are stored on the same type variant chain alongside the
-    variants of the underlaying indirect types nodes.  The main variant
-    of such chains is always the unbounded type.  */
- 
- /* Access the field decls of a bounded-pointer type.  */
- #define TYPE_BOUNDED_VALUE(TYPE) TYPE_FIELDS (TYPE)
- #define TYPE_BOUNDED_BASE(TYPE) TREE_CHAIN (TYPE_BOUNDED_VALUE (TYPE))
- #define TYPE_BOUNDED_EXTENT(TYPE) TREE_CHAIN (TYPE_BOUNDED_BASE (TYPE))
- 
- /* Access the simple-pointer subtype of a bounded-pointer type.  */
- #define TYPE_BOUNDED_SUBTYPE(TYPE) TREE_TYPE (TYPE_BOUNDED_VALUE (TYPE))
- 
- /* Find the unbounded counterpart to a type, or return TYPE if it is
-    already unbounded.  */
- #define TYPE_UNBOUNDED_VARIANT(TYPE) \
-   (BOUNDED_POINTER_TYPE_P (TYPE) ? TYPE_BOUNDED_SUBTYPE (TYPE) : (TYPE))
- 
- /* This field comprises two bits, for values in the range 0..3:
- 
-    depth=0 means that type is a scalar, or an aggregate that contains
-    only depth=0 types, or a function that has only depth=0 types for
-    its return value and argument types.
- 
-    depth=1 means that type is a pointer to a depth=0 type, or an
-    aggregate that contains only depth=0 and depth=1 types, or a
-    function that has only depth=0 and depth=1 types for its return
-    value and argument types.
- 
-    The meanings of depth=2 and depth=3 are obvious by induction.
-    Varargs functions are depth=3.  The type `va_list' is depth=3.
- 
-    The purpose of measuring pointer depth of a type is to determine
-    the eligibility of a function for an automatically-generated
-    bounded-pointer thunk.  A depth=0 functions needs no thunk.  A
-    depth=1 function is eligible for an automatic thunk.  Functions
-    with depth 2 or more are too complex to get automatic thunks.
- 
-    Function decls also have a pointer_depth field, since we also
-    consider the actual argument types for functions.  */
- 
- #define TYPE_POINTER_DEPTH(TYPE) (TYPE_CHECK (TYPE)->type.pointer_depth)
- 
- /* In a FUNCTION_TYPE node, this bit stores the value of
-    default_pointer_boundedness at the time TYPE was created.  It is
-    useful for choosing default boundedness of function arguments for
-    non-prototype function decls and for varargs/stdarg lists.  */
- #define TYPE_AMBIENT_BOUNDEDNESS(TYPE) \
-   (FUNCTION_TYPE_CHECK (TYPE)->type.transparent_union_flag)
- 
- #define MAX_POINTER_DEPTH 2
- #define VA_LIST_POINTER_DEPTH 3
- 
  struct die_struct;
  
  struct tree_type GTY(())
--- 1066,1071 ----
*************** struct tree_type GTY(())
*** 1269,1275 ****
    unsigned transparent_union_flag : 1;
    unsigned packed_flag : 1;
    unsigned restrict_flag : 1;
!   unsigned pointer_depth : 2;
  
    unsigned lang_flag_0 : 1;
    unsigned lang_flag_1 : 1;
--- 1086,1092 ----
    unsigned transparent_union_flag : 1;
    unsigned packed_flag : 1;
    unsigned restrict_flag : 1;
!   unsigned spare : 2;
  
    unsigned lang_flag_0 : 1;
    unsigned lang_flag_1 : 1;
Index: treelang/treetree.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/treelang/treetree.c,v
retrieving revision 1.21
diff -c -3 -p -r1.21 treetree.c
*** treelang/treetree.c	9 May 2003 21:43:54 -0000	1.21
--- treelang/treetree.c	19 May 2003 13:43:49 -0000
*************** static const struct resword reswords[] =
*** 1145,1152 ****
    { "__asm__",		RID_ASM,	0 },
    { "__attribute",	RID_ATTRIBUTE,	0 },
    { "__attribute__",	RID_ATTRIBUTE,	0 },
-   { "__bounded",	RID_BOUNDED,	0 },
-   { "__bounded__",	RID_BOUNDED,	0 },
    { "__builtin_choose_expr", RID_CHOOSE_EXPR, 0 },
    { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, 0 },
    { "__builtin_va_arg",	RID_VA_ARG,	0 },
--- 1145,1150 ----
*************** static const struct resword reswords[] =
*** 1175,1182 ****
    { "__signed__",	RID_SIGNED,	0 },
    { "__typeof",		RID_TYPEOF,	0 },
    { "__typeof__",	RID_TYPEOF,	0 },
-   { "__unbounded",	RID_UNBOUNDED,	0 },
-   { "__unbounded__",	RID_UNBOUNDED,	0 },
    { "__volatile",	RID_VOLATILE,	0 },
    { "__volatile__",	RID_VOLATILE,	0 },
    { "asm",		RID_ASM,	0 },
--- 1173,1178 ----

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