+2011-04-18 Jim Meyering <meyering@redhat.com>
+
+ convert each use of gfc_free (p) to free (p)
+ Do that by running this command:
+ perl -pi -e 's/\bgfc_free ?\(/free (/' \
+ $(git grep -El '\bgfc_free ?\(')
+ which also corrects the few uses that lacked a space between
+ the function name and the open parenthesis.
+ Manually undo the change to the function definition itself
+ and its prototype. They'll be removed next.
+ * array.c (gfc_free_array_spec, gfc_set_array_spec): s/gfc_free/free/
+ * constructor.c (node_free): Likewise.
+ * cpp.c (dump_queued_macros): Likewise.
+ * data.c (gfc_assign_data_value): Likewise.
+ * decl.c (free_variable, free_value, gfc_free_data): Likewise.
+ (gfc_free_data_all, match_old_style_init): Likewise.
+ (gfc_set_constant_character_len, gfc_free_enum_history, NUM_DECL):
+ Likewise.
+ (gfc_match_modproc): Likewise.
+ * dependency.c (check_section_vs_section): Likewise.
+ * error.c (gfc_pop_error, gfc_free_error): Likewise.
+ * expr.c (free_expr0, gfc_free_expr, gfc_free_actual_arglist): Likewise.
+ (gfc_free_ref_list, gfc_replace_expr, gfc_copy_ref): Likewise.
+ (find_substring_ref, gfc_simplify_expr, gfc_check_assign_symbol):
+ Likewise.
+ * frontend-passes.c (gfc_run_passes, cfe_expr_0): Likewise.
+ (strip_function_call, optimize_comparison): Likewise.
+ * interface.c (gfc_free_interface, arginfo, check_interface0): Likewise.
+ (CHECK_OS_COMPARISON, gfc_extend_assign, gfc_free_formal_arglist):
+ Likewise.
+ * intrinsic.c (gfc_intrinsic_done_1, gfc_convert_type_warn): Likewise.
+ (gfc_convert_chartype): Likewise.
+ * io.c (gfc_free_open, compare_to_allowed_values, gfc_free_close):
+ Likewise.
+ (gfc_free_filepos, gfc_free_dt, gfc_free_inquire): Likewise.
+ * match.c (gfc_free_iterator, gfc_match_associate): Likewise.
+ (gfc_free_alloc_list, gfc_free_namelist, gfc_free_equiv_until):
+ Likewise.
+ (free_case, gfc_free_forall_iterator): Likewise.
+ * misc.c: Likewise.
+ * module.c (free_pi_tree, resolve_fixups, free_rename): Likewise.
+ (free_true_name, peek_atom, mio_allocated_wide_string): Likewise.
+ (mio_pool_string, mio_internal_string, mio_gmp_integer): Likewise.
+ (mio_gmp_real, mio_expr, mio_typebound_proc): Likewise.
+ (mio_full_typebound_tree, skip_list, load_equiv): Likewise.
+ (free_written_common, gfc_use_module, gfc_free_use_stmts): Likewise.
+ * openmp.c (gfc_free_omp_clauses): Likewise.
+ * options.c (gfc_post_options): Likewise.
+ * parse.c (select_type_pop, parse_omp_structured_block): Likewise.
+ * primary.c (gfc_free_structure_ctor_component): Likewise.
+ * resolve.c (resolve_structure_cons, check_host_association): Likewise.
+ (gfc_resolve_forall, resolve_equivalence): Likewise.
+ * scanner.c (gfc_scanner_done_1, gfc_release_include_path): Likewise.
+ (gfc_define_undef_line, preprocessor_line, include_line): Likewise.
+ (load_file, gfc_read_orig_filename): Likewise.
+ * simplify.c (simplify_transformation_to_array): Likewise.
+ (gfc_simplify_ibits, simplify_shift, gfc_simplify_ishftc, STRING):
+ Likewise.
+ (gfc_simplify_compiler_options): Likewise.
+ * st.c (gfc_free_statement, gfc_free_statements): Likewise.
+ (gfc_free_association_list): Likewise.
+ * symbol.c (free_components, gfc_free_st_label, free_st_labels):
+ Likewise.
+ (gfc_delete_symtree, gfc_free_symbol, gfc_undo_symbols): Likewise.
+ (free_old_symbol, gfc_commit_symbols, free_tb_tree): Likewise.
+ (free_common_tree, free_uop_tree, free_sym_tree): Likewise.
+ (gfc_free_dt_list, gfc_free_equiv_infos, gfc_free_equiv_lists):
+ Likewise.
+ (gfc_free_finalizer, gfc_free_charlen, free_entry_list): Likewise.
+ (gfc_free_namespace): Likewise.
+ * trans-array.c (gfc_free_ss, gfc_trans_array_bound_check): Likewise.
+ (gfc_conv_array_ref, gfc_conv_ss_startstride): Likewise.
+ (gfc_trans_dummy_array_bias, gfc_conv_array_parameter): Likewise.
+ * trans-common.c (get_init_field, create_common): Likewise.
+ * trans-const.c (gfc_build_wide_string_const): Likewise.
+ (gfc_conv_string_init): Likewise.
+ * trans-decl.c (gfc_generate_function_code): Likewise.
+ * trans-expr.c (gfc_conv_substring, gfc_free_interface_mapping):
+ Likewise.
+ (SCALAR_POINTER, gfc_conv_statement_function): Likewise.
+ (gfc_trans_subarray_assign): Likewise.
+ * trans-intrinsic.c (conv_generic_with_optional_char_arg): Likewise.
+ * trans-io.c (gfc_trans_io_runtime_check, set_string): Likewise.
+ (transfer_namelist_element, transfer_array_component): Likewise.
+ * trans-openmp.c (gfc_trans_omp_array_reduction): Likewise.
+ * trans-stmt.c (cleanup_forall_symtrees, gfc_trans_forall_1): Likewise.
+ * trans.c (trans_runtime_error_vararg, gfc_restore_backend_locus):
+ Likewise.
+
2011-04-15 Jim Meyering <meyering@redhat.com>
gfortran: remove cpp definition of free, ...
gfc_free_expr (as->upper[i]);
}
- gfc_free (as);
+ free (as);
}
}
}
- gfc_free (as);
+ free (as);
return SUCCESS;
}
mpz_clear (c->offset);
- gfc_free (c);
+ free (c);
}
print.src_line++;
oq = q;
q = q->next;
- gfc_free (oq->macro);
- gfc_free (oq);
+ free (oq->macro);
+ free (oq);
}
cpp_define_queue = NULL;
for (q = cpp_undefine_queue; q;)
print.src_line++;
oq = q;
q = q->next;
- gfc_free (oq->macro);
- gfc_free (oq);
+ free (oq->macro);
+ free (oq);
}
cpp_undefine_queue = NULL;
}
{
gcc_assert (ref->u.ar.as->corank > 0);
if (init == NULL)
- gfc_free (expr);
+ free (expr);
continue;
}
gfc_free_expr (p->expr);
gfc_free_iterator (&p->iter, 0);
free_variable (p->list);
- gfc_free (p);
+ free (p);
}
}
q = p->next;
mpz_clear (p->repeat);
gfc_free_expr (p->expr);
- gfc_free (p);
+ free (p);
}
}
q = p->next;
free_variable (p->var);
free_value (p->value);
- gfc_free (p);
+ free (p);
}
}
for (;ns->data;)
{
d = ns->data->next;
- gfc_free (ns->data);
+ free (ns->data);
ns->data = d;
}
}
m = top_val_list (newdata);
if (m != MATCH_YES)
{
- gfc_free (newdata);
+ free (newdata);
return m;
}
if (gfc_pure (NULL))
{
gfc_error ("Initialization at %C is not allowed in a PURE procedure");
- gfc_free (newdata);
+ free (newdata);
return MATCH_ERROR;
}
/* Mark the variable as having appeared in a data statement. */
if (gfc_add_data (&sym->attr, sym->name, &sym->declared_at) == FAILURE)
{
- gfc_free (newdata);
+ free (newdata);
return MATCH_ERROR;
}
&expr->where, slen, check_len);
s[len] = '\0';
- gfc_free (expr->value.character.string);
+ free (expr->value.character.string);
expr->value.character.string = s;
expr->value.character.length = len;
}
while (current != NULL)
{
next = current->next;
- gfc_free (current);
+ free (current);
current = next;
}
max_enum = NULL;
else if (m == MATCH_YES)
{
merge_array_spec (as, current_as, false);
- gfc_free (as);
+ free (as);
}
if (m == MATCH_NO)
while (interface != old_interface_head)
{
gfc_interface *i = interface->next;
- gfc_free (interface);
+ free (interface);
interface = i;
}
else
start_comparison = -2;
- gfc_free (one_expr);
+ free (one_expr);
/* Determine LHS upper and lower bounds. */
if (l_dir == 1)
size_t len = strlen (err->message) + 1;
gcc_assert (len <= error_buffer.allocated);
memcpy (error_buffer.message, err->message, len);
- gfc_free (err->message);
+ free (err->message);
}
}
gfc_free_error (gfc_error_buf *err)
{
if (err->flag)
- gfc_free (err->message);
+ free (err->message);
}
break;
case BT_CHARACTER:
- gfc_free (e->value.character.string);
+ free (e->value.character.string);
break;
case BT_COMPLEX:
/* Free the representation. */
if (e->representation.string)
- gfc_free (e->representation.string);
+ free (e->representation.string);
break;
break;
case EXPR_SUBSTRING:
- gfc_free (e->value.character.string);
+ free (e->value.character.string);
break;
case EXPR_NULL:
for (n = 0; n < e->rank; n++)
mpz_clear (e->shape[n]);
- gfc_free (e->shape);
+ free (e->shape);
}
gfc_free_ref_list (e->ref);
if (e == NULL)
return;
free_expr0 (e);
- gfc_free (e);
+ free (e);
}
{
a2 = a1->next;
gfc_free_expr (a1->expr);
- gfc_free (a1);
+ free (a1);
a1 = a2;
}
}
break;
}
- gfc_free (p);
+ free (p);
}
}
{
free_expr0 (dest);
*dest = *src;
- gfc_free (src);
+ free (src);
}
case REF_ARRAY:
ar = gfc_copy_array_ref (&src->u.ar);
dest->u.ar = *ar;
- gfc_free (ar);
+ free (ar);
break;
case REF_COMPONENT:
return FAILURE;
*newp = gfc_copy_expr (p);
- gfc_free ((*newp)->value.character.string);
+ free ((*newp)->value.character.string);
end = (int) mpz_get_ui (p->ref->u.ss.end->value.integer);
start = (int) mpz_get_ui (p->ref->u.ss.start->value.integer);
memcpy (s, p->value.character.string + start,
(end - start) * sizeof (gfc_char_t));
s[end - start + 1] = '\0'; /* TODO: C-style string. */
- gfc_free (p->value.character.string);
+ free (p->value.character.string);
p->value.character.string = s;
p->value.character.length = end - start;
p->ts.u.cl = gfc_new_charlen (gfc_current_ns, NULL);
else
r = gfc_check_assign (&lvalue, rvalue, 1);
- gfc_free (lvalue.symtree);
+ free (lvalue.symtree);
if (r == FAILURE)
return r;
/* FIXME: The following should be XDELETEVEC(expr_array);
but we cannot do that because it depends on free. */
- gfc_free (expr_array);
+ free (expr_array);
}
}
if (gfc_option.warn_function_elimination)
warn_function_elimination (*(expr_array[j]));
- gfc_free (*(expr_array[j]));
+ free (*(expr_array[j]));
*(expr_array[j]) = gfc_copy_expr (newvar);
}
}
/* Graft the argument expression onto the original function. */
*e = *e1;
- gfc_free (e1);
+ free (e1);
}
return false;
else
{
- gfc_free (op1_left);
- gfc_free (op2_left);
+ free (op1_left);
+ free (op2_left);
if (firstarg)
{
firstarg->expr = op1_right;
}
if (gfc_dep_compare_expr (op1_right, op2_right) == 0)
{
- gfc_free (op1_right);
- gfc_free (op2_right);
+ free (op1_right);
+ free (op2_right);
if (firstarg)
{
firstarg->expr = op1_left;
/* Replace the expression by a constant expression. The typespec
and where remains the way it is. */
- gfc_free (op1);
- gfc_free (op2);
+ free (op1);
+ free (op2);
e->expr_type = EXPR_CONSTANT;
e->value.logical = result;
return true;
for (; intr; intr = next)
{
next = intr->next;
- gfc_free (intr);
+ free (intr);
}
}
k++;
}
- gfc_free (arg);
+ free (arg);
return rc;
}
{
/* Duplicate interface. */
qlast->next = q->next;
- gfc_free (q);
+ free (q);
q = qlast->next;
}
}
/* Don't use gfc_free_actual_arglist(). */
if (actual->next != NULL)
- gfc_free (actual->next);
- gfc_free (actual);
+ free (actual->next);
+ free (actual);
return FAILURE;
}
return SUCCESS;
}
- gfc_free (actual->next);
- gfc_free (actual);
+ free (actual->next);
+ free (actual);
return FAILURE;
}
for (; p; p = q)
{
q = p->next;
- gfc_free (p);
+ free (p);
}
}
void
gfc_intrinsic_done_1 (void)
{
- gfc_free (functions);
- gfc_free (conversion);
- gfc_free (char_conversions);
+ free (functions);
+ free (conversion);
+ free (char_conversions);
gfc_free_namespace (gfc_intrinsic_namespace);
}
*expr = *new_expr;
- gfc_free (new_expr);
+ free (new_expr);
expr->ts = *ts;
if (gfc_is_constant_expr (expr->value.function.actual->expr)
*expr = *new_expr;
- gfc_free (new_expr);
+ free (new_expr);
expr->ts = *ts;
if (gfc_is_constant_expr (expr->value.function.actual->expr)
gfc_free_expr (open->convert);
gfc_free_expr (open->asynchronous);
gfc_free_expr (open->newunit);
- gfc_free (open);
+ free (open);
}
char *s = gfc_widechar_to_char (value, -1);
gfc_warning ("%s specifier in %s statement at %C has invalid value '%s'",
specifier, statement, s);
- gfc_free (s);
+ free (s);
return 1;
}
else
char *s = gfc_widechar_to_char (value, -1);
gfc_error ("%s specifier in %s statement at %C has invalid value '%s'",
specifier, statement, s);
- gfc_free (s);
+ free (s);
return 0;
}
}
-1);
warn_or_error ("The STATUS specified in OPEN statement at %C is "
"'%s' and no FILE specifier is present", s);
- gfc_free (s);
+ free (s);
}
/* F2003, 9.4.5: If the STATUS= specifier has the value SCRATCH,
gfc_free_expr (close->iomsg);
gfc_free_expr (close->iostat);
gfc_free_expr (close->status);
- gfc_free (close);
+ free (close);
}
gfc_free_expr (fp->unit);
gfc_free_expr (fp->iomsg);
gfc_free_expr (fp->iostat);
- gfc_free (fp);
+ free (fp);
}
gfc_free_expr (dt->pos);
gfc_free_expr (dt->dt_io_kind);
/* dt->extra_comma is a link to dt_io_kind if it is set. */
- gfc_free (dt);
+ free (dt);
}
gfc_free_expr (inquire->sign);
gfc_free_expr (inquire->size);
gfc_free_expr (inquire->round);
- gfc_free (inquire);
+ free (inquire);
}
gfc_free_expr (iter->step);
if (flag)
- gfc_free (iter);
+ free (iter);
}
continue;
assocListError:
- gfc_free (newAssoc);
+ free (newAssoc);
goto error;
}
if (gfc_match_char (')') != MATCH_YES)
{
q = p->next;
gfc_free_expr (p->expr);
- gfc_free (p);
+ free (p);
}
}
for (; name; name = n)
{
n = name->next;
- gfc_free (name);
+ free (name);
}
}
gfc_free_equiv (eq->eq);
gfc_free_equiv_until (eq->next, stop);
gfc_free_expr (eq->expr);
- gfc_free (eq);
+ free (eq);
}
p->high = NULL;
gfc_free_expr (p->low);
gfc_free_expr (p->high);
- gfc_free (p);
+ free (p);
}
gfc_free_expr (iter->start);
gfc_free_expr (iter->end);
gfc_free_expr (iter->stride);
- gfc_free (iter);
+ free (iter);
iter = next;
}
}
/* Miscellaneous stuff that doesn't fit anywhere else.
- Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010
+ Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011
Free Software Foundation, Inc.
Contributed by Andy Vaught
free_pi_tree (p->left);
free_pi_tree (p->right);
- gfc_free (p);
+ free (p);
}
{
next = f->next;
*(f->pointer) = gp;
- gfc_free (f);
+ free (f);
}
}
for (; gfc_rename_list; gfc_rename_list = next)
{
next = gfc_rename_list->next;
- gfc_free (gfc_rename_list);
+ free (gfc_rename_list);
}
}
free_true_name (t->left);
free_true_name (t->right);
- gfc_free (t);
+ free (t);
}
a = parse_atom ();
if (a == ATOM_STRING)
- gfc_free (atom_string);
+ free (atom_string);
set_module_locus (&m);
return a;
{
char *quoted = quote_string (s, length);
write_atom (ATOM_STRING, quoted);
- gfc_free (quoted);
+ free (quoted);
return s;
}
else
require_atom (ATOM_STRING);
unquoted = unquote_string (atom_string);
- gfc_free (atom_string);
+ free (atom_string);
return unquoted;
}
}
{
require_atom (ATOM_STRING);
*stringp = atom_string[0] == '\0' ? NULL : gfc_get_string (atom_string);
- gfc_free (atom_string);
+ free (atom_string);
}
}
{
require_atom (ATOM_STRING);
strcpy (string, atom_string);
- gfc_free (atom_string);
+ free (atom_string);
}
}
if (mpz_set_str (*integer, atom_string, 10))
bad_module ("Error converting integer");
- gfc_free (atom_string);
+ free (atom_string);
}
else
{
p = mpz_get_str (NULL, 10, *integer);
write_atom (ATOM_STRING, p);
- gfc_free (p);
+ free (p);
}
}
mpfr_init (*real);
mpfr_set_str (*real, atom_string, 16, GFC_RND_MODE);
- gfc_free (atom_string);
+ free (atom_string);
}
else
{
if (mpfr_nan_p (*real) || mpfr_inf_p (*real))
{
write_atom (ATOM_STRING, p);
- gfc_free (p);
+ free (p);
return;
}
write_atom (ATOM_STRING, atom_string);
- gfc_free (atom_string);
- gfc_free (p);
+ free (atom_string);
+ free (p);
}
}
{
require_atom (ATOM_STRING);
e->value.function.name = gfc_get_string (atom_string);
- gfc_free (atom_string);
+ free (atom_string);
mio_integer (&flag);
if (flag)
{
require_atom (ATOM_STRING);
e->value.function.isym = gfc_find_function (atom_string);
- gfc_free (atom_string);
+ free (atom_string);
}
}
require_atom (ATOM_STRING);
sym_root = ¤t_f2k_derived->tb_sym_root;
g->specific_st = gfc_get_tbp_symtree (sym_root, atom_string);
- gfc_free (atom_string);
+ free (atom_string);
g->next = (*proc)->u.generic;
(*proc)->u.generic = g;
require_atom (ATOM_STRING);
st = gfc_get_tbp_symtree (root, atom_string);
- gfc_free (atom_string);
+ free (atom_string);
mio_typebound_symtree (st);
}
break;
case ATOM_STRING:
- gfc_free (atom_string);
+ free (atom_string);
break;
case ATOM_NAME:
{
head = eq->eq;
gfc_free_expr (eq->expr);
- gfc_free (eq);
+ free (eq);
}
}
if (w->right)
free_written_common (w->right);
- gfc_free (w);
+ free (w);
}
/* Write a common block to the module -- recursive helper function. */
MOD_VERSION, filename);
}
- gfc_free (atom_string);
+ free (atom_string);
}
if (c == '\n')
for (; use_stmts->rename; use_stmts->rename = next_rename)
{
next_rename = use_stmts->rename->next;
- gfc_free (use_stmts->rename);
+ free (use_stmts->rename);
}
next = use_stmts->next;
- gfc_free (use_stmts);
+ free (use_stmts);
}
}
gfc_free_expr (c->chunk_size);
for (i = 0; i < OMP_LIST_NUM; i++)
gfc_free_namelist (c->lists[i]);
- gfc_free (c);
+ free (c);
}
/* Match a variable/common block list and construct a namelist from it. */
gfc_add_include_path (".", true, true);
if (canon_source_file != gfc_source_file)
- gfc_free (CONST_CAST (char *, canon_source_file));
+ free (CONST_CAST (char *, canon_source_file));
/* Decide which form the file will be read in as. */
{
gfc_select_type_stack *old = select_type_stack;
select_type_stack = old->prev;
- gfc_free (old);
+ free (old);
}
&& strcmp (cp->ext.omp_name, new_st.ext.omp_name) != 0))
gfc_error ("Name after !$omp critical and !$omp end critical does "
"not match at %C");
- gfc_free (CONST_CAST (char *, new_st.ext.omp_name));
+ free (CONST_CAST (char *, new_st.ext.omp_name));
break;
case EXEC_OMP_END_SINGLE:
cp->ext.omp_clauses->lists[OMP_LIST_COPYPRIVATE]
static void
gfc_free_structure_ctor_component (gfc_structure_ctor_component *comp)
{
- gfc_free (comp->name);
+ free (comp->name);
gfc_free_expr (comp->val);
- gfc_free (comp);
+ free (comp);
}
cl2->next = cl->next;
gfc_free_expr (cl->length);
- gfc_free (cl);
+ free (cl);
}
cons->expr->ts.u.cl = gfc_new_charlen (gfc_current_ns, NULL);
for (n = 0; n < e->rank; n++)
mpz_clear (e->shape[n]);
- gfc_free (e->shape);
+ free (e->shape);
}
/* Give the expression the right symtree! */
gcc_assert (forall_save == 0);
/* VAR_EXPR is not needed any more. */
- gfc_free (var_expr);
+ free (var_expr);
total_var = 0;
}
}
e->ts.u.cl = NULL;
}
ref = ref->next;
- gfc_free (mem);
+ free (mem);
}
/* Any further ref is an error. */
while(line_head != NULL)
{
lb = line_head->next;
- gfc_free(line_head);
+ free (line_head);
line_head = lb;
}
while(file_head != NULL)
{
f = file_head->next;
- gfc_free(file_head->filename);
- gfc_free(file_head);
+ free (file_head->filename);
+ free (file_head);
file_head = f;
}
}
{
p = include_dirs;
include_dirs = include_dirs->next;
- gfc_free (p->path);
- gfc_free (p);
+ free (p->path);
+ free (p);
}
while (intrinsic_modules_dirs != NULL)
{
p = intrinsic_modules_dirs;
intrinsic_modules_dirs = intrinsic_modules_dirs->next;
- gfc_free (p->path);
- gfc_free (p);
+ free (p->path);
+ free (p);
}
- gfc_free (gfc_option.module_dir);
+ free (gfc_option.module_dir);
}
tmp = gfc_widechar_to_char (&gfc_current_locus.nextc[8], -1);
(*debug_hooks->define) (gfc_linebuf_linenum (gfc_current_locus.lb),
tmp);
- gfc_free (tmp);
+ free (tmp);
}
if (wide_strncmp (gfc_current_locus.nextc, "#undef ", 7) == 0)
tmp = gfc_widechar_to_char (&gfc_current_locus.nextc[7], -1);
(*debug_hooks->undef) (gfc_linebuf_linenum (gfc_current_locus.lb),
tmp);
- gfc_free (tmp);
+ free (tmp);
}
/* Skip the rest of the line. */
current_file->filename, current_file->line,
filename);
if (unescape)
- gfc_free (wide_filename);
- gfc_free (filename);
+ free (wide_filename);
+ free (filename);
return;
}
/* Set new line number. */
current_file->line = line;
if (unescape)
- gfc_free (wide_filename);
- gfc_free (filename);
+ free (wide_filename);
+ free (filename);
return;
bad_cpp_line:
if (load_file (filename, NULL, false) == FAILURE)
exit (FATAL_EXIT_CODE);
- gfc_free (filename);
+ free (filename);
return true;
}
if (initial && gfc_src_preprocessor_lines[0])
{
preprocessor_line (gfc_src_preprocessor_lines[0]);
- gfc_free (gfc_src_preprocessor_lines[0]);
+ free (gfc_src_preprocessor_lines[0]);
gfc_src_preprocessor_lines[0] = NULL;
if (gfc_src_preprocessor_lines[1])
{
preprocessor_line (gfc_src_preprocessor_lines[1]);
- gfc_free (gfc_src_preprocessor_lines[1]);
+ free (gfc_src_preprocessor_lines[1]);
gfc_src_preprocessor_lines[1] = NULL;
}
}
gfc_char_t *new_char = gfc_get_wide_string (line_len);
wide_strcpy (new_char, &line[n]);
- gfc_free (line);
+ free (line);
line = new_char;
len -= n;
}
}
/* Release the line buffer allocated in load_line. */
- gfc_free (line);
+ free (line);
fclose (input);
tmp = gfc_widechar_to_char (&gfc_src_preprocessor_lines[0][5], -1);
filename = unescape_filename (tmp);
- gfc_free (tmp);
+ free (tmp);
if (filename == NULL)
return NULL;
tmp = gfc_widechar_to_char (&gfc_src_preprocessor_lines[1][5], -1);
dirname = unescape_filename (tmp);
- gfc_free (tmp);
+ free (tmp);
if (dirname == NULL)
return filename;
len = strlen (dirname);
if (len < 3 || dirname[len - 1] != '/' || dirname[len - 2] != '/')
{
- gfc_free (dirname);
+ free (dirname);
return filename;
}
dirname[len - 2] = '\0';
*canon_source_file = p;
}
- gfc_free (dirname);
+ free (dirname);
return filename;
}
result_ctor = gfc_constructor_next (result_ctor);
}
- gfc_free (arrayvec);
- gfc_free (resultvec);
+ free (arrayvec);
+ free (resultvec);
return result;
}
gfc_internal_error ("IBITS: Bad bit");
}
- gfc_free (bits);
+ free (bits);
convert_mpz_to_signed (result->value.integer,
gfc_integer_kinds[k].bit_size);
}
convert_mpz_to_signed (result->value.integer, bitsize);
- gfc_free (bits);
+ free (bits);
return result;
}
convert_mpz_to_signed (result->value.integer, isize);
- gfc_free (bits);
+ free (bits);
return result;
}
LENGTH(arg) - LENGTH(extremum));
STRING(extremum)[LENGTH(arg)] = '\0'; /* For debugger */
LENGTH(extremum) = LENGTH(arg);
- gfc_free (tmp);
+ free (tmp);
}
if (gfc_compare_string (arg, extremum) * sign > 0)
{
- gfc_free (STRING(extremum));
+ free (STRING(extremum));
STRING(extremum) = gfc_get_wide_string (LENGTH(extremum) + 1);
memcpy (STRING(extremum), STRING(arg),
LENGTH(arg) * sizeof (gfc_char_t));
str = gfc_get_option_string ();
result = gfc_get_character_expr (gfc_default_character_kind,
&gfc_current_locus, str, strlen (str));
- gfc_free (str);
+ free (str);
return result;
}
break;
case EXEC_OMP_CRITICAL:
- gfc_free (CONST_CAST (char *, p->ext.omp_name));
+ free (CONST_CAST (char *, p->ext.omp_name));
break;
case EXEC_OMP_FLUSH:
if (p->block)
gfc_free_statements (p->block);
gfc_free_statement (p);
- gfc_free (p);
+ free (p);
}
}
return;
gfc_free_association_list (assoc->next);
- gfc_free (assoc);
+ free (assoc);
}
gfc_free_formal_arglist (p->formal);
gfc_free_namespace (p->formal_ns);
- gfc_free (p);
+ free (p);
}
}
if (label->format != NULL)
gfc_free_expr (label->format);
- gfc_free (label);
+ free (label);
}
if (label->format != NULL)
gfc_free_expr (label->format);
- gfc_free (label);
+ free (label);
}
st.name = gfc_get_string (name);
gfc_delete_bbt (root, &st, compare_symtree);
- gfc_free (st0);
+ free (st0);
}
gfc_free_namespace (sym->f2k_derived);
- gfc_free (sym);
+ free (sym);
}
p->formal = old->formal;
}
- gfc_free (p->old_symbol);
+ free (p->old_symbol);
p->old_symbol = NULL;
p->tlink = NULL;
}
{
tbq = tbp->next;
/* Procedure is already marked `error' by default. */
- gfc_free (tbp);
+ free (tbp);
}
tentative_tbp_list = NULL;
}
if (sym->old_symbol->formal != sym->formal)
gfc_free_formal_arglist (sym->old_symbol->formal);
- gfc_free (sym->old_symbol);
+ free (sym->old_symbol);
sym->old_symbol = NULL;
}
{
tbq = tbp->next;
tbp->proc->error = 0;
- gfc_free (tbp);
+ free (tbp);
}
tentative_tbp_list = NULL;
}
/* TODO: Free type-bound procedure structs themselves; probably needs some
sort of ref-counting mechanism. */
- gfc_free (t);
+ free (t);
}
free_common_tree (common_tree->left);
free_common_tree (common_tree->right);
- gfc_free (common_tree);
+ free (common_tree);
}
free_uop_tree (uop_tree->right);
gfc_free_interface (uop_tree->n.uop->op);
- gfc_free (uop_tree->n.uop);
- gfc_free (uop_tree);
+ free (uop_tree->n.uop);
+ free (uop_tree);
}
free_sym_tree (sym_tree->right);
gfc_release_symbol (sym_tree->n.sym);
- gfc_free (sym_tree);
+ free (sym_tree);
}
for (dt = gfc_derived_types; dt; dt = n)
{
n = dt->next;
- gfc_free (dt);
+ free (dt);
}
gfc_derived_types = NULL;
if (s == NULL)
return;
gfc_free_equiv_infos (s->next);
- gfc_free (s);
+ free (s);
}
return;
gfc_free_equiv_lists (l->next);
gfc_free_equiv_infos (l->equiv);
- gfc_free (l);
+ free (l);
}
if (el)
{
gfc_release_symbol (el->proc_sym);
- gfc_free (el);
+ free (el);
}
}
cl2 = cl->next;
gfc_free_expr (cl->length);
- gfc_free (cl);
+ free (cl);
}
}
return;
next = el->next;
- gfc_free (el);
+ free (el);
free_entry_list (next);
}
gfc_free_data (ns->data);
p = ns->contained;
- gfc_free (ns);
+ free (ns);
/* Recursively free any contained namespaces. */
while (p != NULL)
break;
}
- gfc_free (ss);
+ free (ss);
}
fold_convert (long_integer_type_node, index),
fold_convert (long_integer_type_node, tmp_lo),
fold_convert (long_integer_type_node, tmp_up));
- gfc_free (msg);
+ free (msg);
}
else
{
gfc_trans_runtime_check (true, false, fault, &se->pre, where, msg,
fold_convert (long_integer_type_node, index),
fold_convert (long_integer_type_node, tmp_lo));
- gfc_free (msg);
+ free (msg);
}
return index;
fold_convert (long_integer_type_node,
indexse.expr),
fold_convert (long_integer_type_node, tmp));
- gfc_free (msg);
+ free (msg);
/* Upper bound, but not for the last dimension of assumed-size
arrays. */
fold_convert (long_integer_type_node,
indexse.expr),
fold_convert (long_integer_type_node, tmp));
- gfc_free (msg);
+ free (msg);
}
}
"of array '%s'", dim + 1, ss->expr->symtree->name);
gfc_trans_runtime_check (true, false, tmp, &inner,
&ss->expr->where, msg);
- gfc_free (msg);
+ free (msg);
desc = ss->data.info.descriptor;
fold_convert (long_integer_type_node, info->start[dim]),
fold_convert (long_integer_type_node, lbound),
fold_convert (long_integer_type_node, ubound));
- gfc_free (msg);
+ free (msg);
}
else
{
&ss->expr->where, msg,
fold_convert (long_integer_type_node, info->start[dim]),
fold_convert (long_integer_type_node, lbound));
- gfc_free (msg);
+ free (msg);
}
/* Compute the last element of the range, which is not
fold_convert (long_integer_type_node, tmp),
fold_convert (long_integer_type_node, ubound),
fold_convert (long_integer_type_node, lbound));
- gfc_free (msg);
+ free (msg);
}
else
{
&ss->expr->where, msg,
fold_convert (long_integer_type_node, tmp),
fold_convert (long_integer_type_node, lbound));
- gfc_free (msg);
+ free (msg);
}
/* Check the section sizes match. */
fold_convert (long_integer_type_node, tmp),
fold_convert (long_integer_type_node, size[n]));
- gfc_free (msg);
+ free (msg);
}
else
size[n] = gfc_evaluate_now (tmp, &inner);
fold_convert (long_integer_type_node, temp),
fold_convert (long_integer_type_node, stride2));
- gfc_free (msg);
+ free (msg);
}
}
else
gfc_trans_runtime_check (false, true, tmp, &se->pre,
&expr->where, msg);
- gfc_free (msg);
+ free (msg);
}
gfc_start_block (&block);
for (i = 0; i < length; i++)
CONSTRUCTOR_APPEND_ELT (v, NULL, build_int_cst (type, data[i]));
- gfc_free (data);
- gfc_free (chk);
+ free (data);
+ free (chk);
/* Build a char[length] array to hold the initializers. Much of what
follows is borrowed from build_field, above. */
s->sym->backend_decl = var_decl;
next_s = s->next;
- gfc_free (s);
+ free (s);
}
}
gfc_encode_character (kind, length, string, (unsigned char *) s, size);
str = build_string (size, s);
- gfc_free (s);
+ free (s);
len = build_int_cst (NULL_TREE, length);
TREE_TYPE (str) =
str = gfc_build_wide_string_const (expr->ts.kind, len, s);
if (free_s)
- gfc_free (s);
+ free (s);
return str;
}
gfc_trans_runtime_check (true, false, recurcheckvar, &init,
&sym->declared_at, msg);
gfc_add_modify (&init, recurcheckvar, boolean_true_node);
- gfc_free (msg);
+ free (msg);
}
/* Now generate the code for the body of this function. */
gfc_trans_runtime_check (true, false, fault, &se->pre, where, msg,
fold_convert (long_integer_type_node,
start.expr));
- gfc_free (msg);
+ free (msg);
/* Check upper bound. */
fault = fold_build2_loc (input_location, GT_EXPR, boolean_type_node,
fold_convert (long_integer_type_node, end.expr),
fold_convert (long_integer_type_node,
se->string_length));
- gfc_free (msg);
+ free (msg);
}
/* If the start and end expressions are equal, the length is one. */
sym->new_sym->n.sym->formal = NULL;
gfc_free_symbol (sym->new_sym->n.sym);
gfc_free_expr (sym->expr);
- gfc_free (sym->new_sym);
- gfc_free (sym);
+ free (sym->new_sym);
+ free (sym);
}
for (cl = mapping->charlens; cl; cl = nextcl)
{
nextcl = cl->next;
gfc_free_expr (cl->length);
- gfc_free (cl);
+ free (cl);
}
}
gfc_trans_runtime_check (true, false, cond, &se->pre, &e->where,
msg);
- gfc_free (msg);
+ free (msg);
}
end_pointer_check:
/* Restore the original variables. */
for (fargs = sym->formal, n = 0; fargs; fargs = fargs->next, n++)
gfc_restore_sym (fargs->sym, &saved_vars[n]);
- gfc_free (saved_vars);
+ free (saved_vars);
}
for (n = 0; n < cm->as->rank; n++)
mpz_clear (lss->shape[n]);
- gfc_free (lss->shape);
+ free (lss->shape);
gfc_cleanup_loop (&loop);
sym = gfc_get_symbol_for_expr (expr);
gfc_conv_procedure_call (se, sym, expr->value.function.actual, expr,
append_args);
- gfc_free (sym);
+ free (sym);
}
asprintf (&message, "%s", _(msgid));
arg3 = gfc_build_addr_expr (pchar_type_node,
gfc_build_localized_cstring_const (message));
- gfc_free(message);
+ free (message);
tmp = build_call_expr_loc (input_location,
gfor_fndecl_generate_error, 3, arg1, arg2, arg3);
"label", e->symtree->name);
gfc_trans_runtime_check (true, false, cond, &se.pre, &e->where, msg,
fold_convert (long_integer_type_node, tmp));
- gfc_free (msg);
+ free (msg);
gfc_add_modify (&se.pre, io,
fold_convert (TREE_TYPE (io), GFC_DECL_ASSIGN_ADDR (se.expr)));
transfer_namelist_element (block,
full_name,
NULL, cmp, expr);
- gfc_free (full_name);
+ free (full_name);
}
}
}
for (n = 0; n < cm->as->rank; n++)
mpz_clear (ss->shape[n]);
- gfc_free (ss->shape);
+ free (ss->shape);
gfc_cleanup_loop (&loop);
/* OpenMP directive translation -- generate GCC trees from gfc_code.
- Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010
+ Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
Contributed by Jakub Jelinek <jakub@redhat.com>
gfc_free_expr (e2);
gfc_free_expr (e3);
gfc_free_expr (e4);
- gfc_free (symtree1);
- gfc_free (symtree2);
- gfc_free (symtree3);
+ free (symtree1);
+ free (symtree2);
+ free (symtree3);
if (symtree4)
- gfc_free (symtree4);
+ free (symtree4);
gfc_free_array_spec (outer_sym.as);
}
{
forall_restore_symtree (c->expr1);
forall_restore_symtree (c->expr2);
- gfc_free (new_symtree->n.sym);
- gfc_free (new_symtree);
+ free (new_symtree->n.sym);
+ free (new_symtree);
}
gfc_restore_sym (fa->var->symtree->n.sym, &saved_vars[n]);
/* Free the space for var, start, end, step, varexpr. */
- gfc_free (var);
- gfc_free (start);
- gfc_free (end);
- gfc_free (step);
- gfc_free (varexpr);
- gfc_free (saved_vars);
+ free (var);
+ free (start);
+ free (end);
+ free (step);
+ free (varexpr);
+ free (saved_vars);
for (this_forall = info->this_loop; this_forall;)
{
iter_info *next = this_forall->next;
- gfc_free (this_forall);
+ free (this_forall);
this_forall = next;
}
/* Free the space for this forall_info. */
- gfc_free (info);
+ free (info);
if (pmask)
{
arg = gfc_build_addr_expr (pchar_type_node,
gfc_build_localized_cstring_const (message));
- gfc_free(message);
+ free (message);
asprintf (&message, "%s", _(msgid));
arg2 = gfc_build_addr_expr (pchar_type_node,
gfc_build_localized_cstring_const (message));
- gfc_free(message);
+ free (message);
/* Build the argument array. */
argarray = XALLOCAVEC (tree, nargs + 2);
gfc_restore_backend_locus (locus * loc)
{
gfc_set_backend_locus (loc);
- gfc_free (loc->lb);
+ free (loc->lb);
}
projects / gcc.git / commitdiff