static tree c_parser_transaction_cancel (c_parser *);
static struct c_expr c_parser_expression (c_parser *);
static struct c_expr c_parser_expression_conv (c_parser *);
-static VEC(tree,gc) *c_parser_expr_list (c_parser *, bool, bool,
- VEC(tree,gc) **, location_t *,
- tree *);
+static vec<tree, va_gc> *c_parser_expr_list (c_parser *, bool, bool,
+ vec<tree, va_gc> **, location_t *,
+ tree *);
static void c_parser_omp_construct (c_parser *);
static void c_parser_omp_threadprivate (c_parser *);
static void c_parser_omp_barrier (c_parser *);
|| c_parser_next_token_is (parser, CPP_KEYWORD))
{
tree attr, attr_name, attr_args;
- VEC(tree,gc) *expr_list;
+ vec<tree, va_gc> *expr_list;
if (c_parser_next_token_is (parser, CPP_COMMA))
{
c_parser_consume_token (parser);
stores the arguments in CEXPR_LIST. */
static bool
c_parser_get_builtin_args (c_parser *parser, const char *bname,
- VEC(c_expr_t,gc) **ret_cexpr_list)
+ vec<c_expr_t, va_gc> **ret_cexpr_list)
{
location_t loc = c_parser_peek_token (parser)->location;
- VEC (c_expr_t,gc) *cexpr_list;
+ vec<c_expr_t, va_gc> *cexpr_list;
c_expr_t expr;
*ret_cexpr_list = NULL;
}
expr = c_parser_expr_no_commas (parser, NULL);
- cexpr_list = VEC_alloc (c_expr_t, gc, 1);
+ vec_alloc (cexpr_list, 1);
C_EXPR_APPEND (cexpr_list, expr);
while (c_parser_next_token_is (parser, CPP_COMMA))
{
break;
case RID_CHOOSE_EXPR:
{
- VEC (c_expr_t, gc) *cexpr_list;
+ vec<c_expr_t, va_gc> *cexpr_list;
c_expr_t *e1_p, *e2_p, *e3_p;
tree c;
break;
}
- if (VEC_length (c_expr_t, cexpr_list) != 3)
+ if (vec_safe_length (cexpr_list) != 3)
{
error_at (loc, "wrong number of arguments to "
"%<__builtin_choose_expr%>");
break;
}
- e1_p = &VEC_index (c_expr_t, cexpr_list, 0);
- e2_p = &VEC_index (c_expr_t, cexpr_list, 1);
- e3_p = &VEC_index (c_expr_t, cexpr_list, 2);
+ e1_p = &(*cexpr_list)[0];
+ e2_p = &(*cexpr_list)[1];
+ e3_p = &(*cexpr_list)[2];
c = e1_p->value;
mark_exp_read (e2_p->value);
break;
case RID_BUILTIN_COMPLEX:
{
- VEC(c_expr_t, gc) *cexpr_list;
+ vec<c_expr_t, va_gc> *cexpr_list;
c_expr_t *e1_p, *e2_p;
c_parser_consume_token (parser);
break;
}
- if (VEC_length (c_expr_t, cexpr_list) != 2)
+ if (vec_safe_length (cexpr_list) != 2)
{
error_at (loc, "wrong number of arguments to "
"%<__builtin_complex%>");
break;
}
- e1_p = &VEC_index (c_expr_t, cexpr_list, 0);
- e2_p = &VEC_index (c_expr_t, cexpr_list, 1);
+ e1_p = &(*cexpr_list)[0];
+ e2_p = &(*cexpr_list)[1];
mark_exp_read (e1_p->value);
if (TREE_CODE (e1_p->value) == EXCESS_PRECISION_EXPR)
}
case RID_BUILTIN_SHUFFLE:
{
- VEC(c_expr_t,gc) *cexpr_list;
+ vec<c_expr_t, va_gc> *cexpr_list;
unsigned int i;
c_expr_t *p;
break;
}
- FOR_EACH_VEC_ELT (c_expr_t, cexpr_list, i, p)
+ FOR_EACH_VEC_SAFE_ELT (cexpr_list, i, p)
mark_exp_read (p->value);
- if (VEC_length (c_expr_t, cexpr_list) == 2)
+ if (vec_safe_length (cexpr_list) == 2)
expr.value =
c_build_vec_perm_expr
- (loc, VEC_index (c_expr_t, cexpr_list, 0).value,
- NULL_TREE, VEC_index (c_expr_t, cexpr_list, 1).value);
+ (loc, (*cexpr_list)[0].value,
+ NULL_TREE, (*cexpr_list)[1].value);
- else if (VEC_length (c_expr_t, cexpr_list) == 3)
+ else if (vec_safe_length (cexpr_list) == 3)
expr.value =
c_build_vec_perm_expr
- (loc, VEC_index (c_expr_t, cexpr_list, 0).value,
- VEC_index (c_expr_t, cexpr_list, 1).value,
- VEC_index (c_expr_t, cexpr_list, 2).value);
+ (loc, (*cexpr_list)[0].value,
+ (*cexpr_list)[1].value,
+ (*cexpr_list)[2].value);
else
{
error_at (loc, "wrong number of arguments to "
location_t sizeof_arg_loc[3];
tree sizeof_arg[3];
unsigned int i;
- VEC(tree,gc) *exprlist;
- VEC(tree,gc) *origtypes;
+ vec<tree, va_gc> *exprlist;
+ vec<tree, va_gc> *origtypes;
while (true)
{
location_t op_loc = c_parser_peek_token (parser)->location;
&& DECL_FUNCTION_CODE (orig_expr.value) == BUILT_IN_CONSTANT_P)
expr.original_code = C_MAYBE_CONST_EXPR;
expr.original_type = NULL;
- if (exprlist != NULL)
+ if (exprlist)
{
release_tree_vector (exprlist);
release_tree_vector (origtypes);
nonempty-expr-list , assignment-expression
*/
-static VEC(tree,gc) *
+static vec<tree, va_gc> *
c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
- VEC(tree,gc) **p_orig_types, location_t *sizeof_arg_loc,
- tree *sizeof_arg)
+ vec<tree, va_gc> **p_orig_types,
+ location_t *sizeof_arg_loc, tree *sizeof_arg)
{
- VEC(tree,gc) *ret;
- VEC(tree,gc) *orig_types;
+ vec<tree, va_gc> *ret;
+ vec<tree, va_gc> *orig_types;
struct c_expr expr;
location_t loc = c_parser_peek_token (parser)->location;
location_t cur_sizeof_arg_loc = UNKNOWN_LOCATION;
expr = default_function_array_read_conversion (loc, expr);
if (fold_p)
expr.value = c_fully_fold (expr.value, false, NULL);
- VEC_quick_push (tree, ret, expr.value);
- if (orig_types != NULL)
- VEC_quick_push (tree, orig_types, expr.original_type);
+ ret->quick_push (expr.value);
+ if (orig_types)
+ orig_types->quick_push (expr.original_type);
if (sizeof_arg != NULL
&& cur_sizeof_arg_loc != UNKNOWN_LOCATION
&& expr.original_code == SIZEOF_EXPR)
expr = default_function_array_read_conversion (loc, expr);
if (fold_p)
expr.value = c_fully_fold (expr.value, false, NULL);
- VEC_safe_push (tree, gc, ret, expr.value);
- if (orig_types != NULL)
- VEC_safe_push (tree, gc, orig_types, expr.original_type);
+ vec_safe_push (ret, expr.value);
+ if (orig_types)
+ vec_safe_push (orig_types, expr.original_type);
if (++idx < 3
&& sizeof_arg != NULL
&& cur_sizeof_arg_loc != UNKNOWN_LOCATION
sizeof_arg_loc[idx] = cur_sizeof_arg_loc;
}
}
- if (orig_types != NULL)
+ if (orig_types)
*p_orig_types = orig_types;
return ret;
}
c_parser_objc_keywordexpr (c_parser *parser)
{
tree ret;
- VEC(tree,gc) *expr_list = c_parser_expr_list (parser, true, true,
+ vec<tree, va_gc> *expr_list = c_parser_expr_list (parser, true, true,
NULL, NULL, NULL);
- if (VEC_length (tree, expr_list) == 1)
+ if (vec_safe_length (expr_list) == 1)
{
/* Just return the expression, remove a level of
indirection. */
- ret = VEC_index (tree, expr_list, 0);
+ ret = (*expr_list)[0];
}
else
{
bool fail = false, open_brace_parsed = false;
int i, collapse = 1, nbraces = 0;
location_t for_loc;
- VEC(tree,gc) *for_block = make_tree_vector ();
+ vec<tree, va_gc> *for_block = make_tree_vector ();
for (cl = clauses; cl; cl = OMP_CLAUSE_CHAIN (cl))
if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_COLLAPSE)
if (c_parser_next_tokens_start_declaration (parser))
{
if (i > 0)
- VEC_safe_push (tree, gc, for_block, c_begin_compound_stmt (true));
+ vec_safe_push (for_block, c_begin_compound_stmt (true));
c_parser_declaration_or_fndef (parser, true, true, true, true, true, NULL);
decl = check_for_loop_decls (for_loc, flag_isoc99);
if (decl == NULL)
ret = stmt;
}
pop_scopes:
- while (!VEC_empty (tree, for_block))
+ while (!for_block->is_empty ())
{
/* FIXME diagnostics: LOC below should be the actual location of
this particular for block. We need to build a list of
locations to go along with FOR_BLOCK. */
- stmt = c_end_compound_stmt (loc, VEC_pop (tree, for_block), true);
+ stmt = c_end_compound_stmt (loc, for_block->pop (), true);
add_stmt (stmt);
}
release_tree_vector (for_block);
projects / thirdparty / gcc.git / blobdiff