size_t len;
/* By cleverly playing around with constructors, it is possible
- to get mismaching types here. */
+ to get mismatching types here. */
if (op1->ts.type != BT_CHARACTER || op2->ts.type != BT_CHARACTER
|| op1->ts.kind != op2->ts.kind)
return ARITH_WRONGCONCAT;
return false;
}
-/* Some precedures take two arguments such that both cannot be BOZ. */
+/* Some procedures take two arguments such that both cannot be BOZ. */
static bool
boz_args_check(gfc_expr *i, gfc_expr *j)
/* Generate the finalization/polymorphic freeing wrapper subroutine for the
- derived type "derived". The function first calls the approriate FINAL
+ derived type "derived". The function first calls the appropriate FINAL
subroutine, then it DEALLOCATEs (finalizes/frees) the allocatable
components (but not the inherited ones). Last, it calls the wrapper
subroutine of the parent. The generated wrapper procedure takes as argument
if (!gfc_expr_check_typed (*expr, gfc_current_ns, false))
return MATCH_ERROR;
- /* If gfortran gets an EXPR_OP, try to simplifiy it. This catches things
+ /* If gfortran gets an EXPR_OP, try to simplify it. This catches things
like CHARACTER(([1])). */
if ((*expr)->expr_type == EXPR_OP)
gfc_simplify_expr (*expr, 1);
}
/* Character strings are only C interoperable if they have a
- length of 1. However, as an argument they are also iteroperable
+ length of 1. However, as an argument they are also interoperable
when passed as descriptor (which requires len=: or len=*). */
if (sym->ts.type == BT_CHARACTER)
{
}
}
- /* The dummy arguments and result of the abreviated form of MODULE
+ /* The dummy arguments and result of the abbreviated form of MODULE
PROCEDUREs, used in SUBMODULES should not be redefined. */
if (gfc_current_ns->proc_name
&& gfc_current_ns->proc_name->abr_modproc_decl)
}
}
- /* Before adding a possible initilizer, do a simple check for compatibility
+ /* Before adding a possible initializer, do a simple check for compatibility
of lhs and rhs types. Assigning a REAL value to a derived type is not a
good thing. */
if (current_ts.type == BT_DERIVED && initializer
match m;
gfc_namespace *parent_ns, *ns, *prev_ns;
gfc_namespace **nsp;
- bool abreviated_modproc_decl = false;
+ bool abbreviated_modproc_decl = false;
bool got_matching_end = false;
old_loc = gfc_current_locus;
state = gfc_state_stack->previous->state;
block_name = gfc_state_stack->previous->sym == NULL
? NULL : gfc_state_stack->previous->sym->name;
- abreviated_modproc_decl = gfc_state_stack->previous->sym
+ abbreviated_modproc_decl = gfc_state_stack->previous->sym
&& gfc_state_stack->previous->sym->abr_modproc_decl;
break;
break;
}
- if (!abreviated_modproc_decl)
- abreviated_modproc_decl = gfc_current_block ()
+ if (!abbreviated_modproc_decl)
+ abbreviated_modproc_decl = gfc_current_block ()
&& gfc_current_block ()->abr_modproc_decl;
switch (state)
case COMP_SUBROUTINE:
*st = ST_END_SUBROUTINE;
- if (!abreviated_modproc_decl)
+ if (!abbreviated_modproc_decl)
target = " subroutine";
else
target = " procedure";
case COMP_FUNCTION:
*st = ST_END_FUNCTION;
- if (!abreviated_modproc_decl)
+ if (!abbreviated_modproc_decl)
target = " function";
else
target = " procedure";
{
if (!gfc_notify_std (GFC_STD_F2008, "END statement "
"instead of %s statement at %L",
- abreviated_modproc_decl ? "END PROCEDURE"
+ abbreviated_modproc_decl ? "END PROCEDURE"
: gfc_ascii_statement(*st), &old_loc))
goto cleanup;
}
/* Verify that we've got the sort of end-block that we're expecting. */
if (gfc_match (target) != MATCH_YES)
{
- gfc_error ("Expecting %s statement at %L", abreviated_modproc_decl
+ gfc_error ("Expecting %s statement at %L", abbreviated_modproc_decl
? "END PROCEDURE" : gfc_ascii_statement(*st), &old_loc);
goto cleanup;
}
e1 = gfc_discard_nops (e1);
e2 = gfc_discard_nops (e2);
- /* Inizialize tentatively, clear if we don't return anything. */
+ /* Initialize tentatively, clear if we don't return anything. */
mpz_init (*result);
/* Case 1: c1 - c2 = c1 - c2, trivially. */
/* Given an assignable expression and an arbitrary expression, make
sure that the assignment can take place. Only add a call to the intrinsic
conversion routines, when allow_convert is set. When this assign is a
- coarray call, then the convert is done by the coarray routine implictly and
+ coarray call, then the convert is done by the coarray routine implicitly and
adding the intrinsic conversion would do harm in most cases. */
bool
return fcn;
}
-/* Callback function for optimzation of reductions to scalars. Transform ANY
+/* Callback function for optimization of reductions to scalars. Transform ANY
([f1,f2,f3, ...]) to f1 .or. f2 .or. f3 .or. ..., with ANY, SUM and PRODUCT
- correspondingly. Handly only the simple cases without MASK and DIM. */
+ correspondingly. Handle only the simple cases without MASK and DIM. */
static int
callback_reduction (gfc_expr **e, int *walk_subtrees ATTRIBUTE_UNUSED,
}
/* Optimize a namespace, including all contained namespaces.
- flag_frontend_optimize and flag_fronend_loop_interchange are
+ flag_frontend_optimize and flag_frontend_loop_interchange are
handled separately. */
static void
= 1 if it has been resolved in resolve_symbol. */
unsigned resolve_symbol_called:2;
/* Set if this is a module function or subroutine with the
- abreviated declaration in a submodule. */
+ abbreviated declaration in a submodule. */
unsigned abr_modproc_decl:1;
/* Set if a previous error or warning has occurred and no other
should be reported. */
/* Set to 1 if namespace is an interface body with "IMPORT" used. */
unsigned has_import_set:1;
- /* Set to 1 if the namespace uses "IMPLICT NONE (export)". */
+ /* Set to 1 if the namespace uses "IMPLICIT NONE (export)". */
unsigned has_implicit_none_export:1;
/* Set to 1 if resolved has been called for this namespace.
To support legacy codes, GNU Fortran allows the comma separator
to be omitted immediately before and after character string edit
descriptors in @code{FORMAT} statements. A comma with no following format
-decriptor is permited if the @option{-fdec-blank-format-item} is given on
+descriptor is permitted if the @option{-fdec-blank-format-item} is given on
the command line. This is considered non-conforming code and is
discouraged.
caf_deregister_t;
@end verbatim
-Allows to specifiy the type of deregistration of a coarray object. The
+Allows to specify the type of deregistration of a coarray object. The
@code{CAF_DEREGTYPE_COARRAY_DEALLOCATE_ONLY} flag is only allowed for
allocatable components in derived type coarrays.
@item @emph{NOTES}
This acts like an atomic add of one to the remote image's event variable.
The statement is an image-control statement but does not imply sync memory.
-Still, all preceeding push communications of this image to the specified
+Still, all preceding push communications of this image to the specified
remote image have to be completed before @code{event_wait} on the remote
image returns.
@end table
with an increasing number of sleep time) or, if possible, a futex wait.
The statement is an image-control statement but does not imply sync memory.
-Still, all preceeding push communications of this image to the specified
+Still, all preceding push communications of this image to the specified
remote image have to be completed before @code{event_wait} on the remote
image returns.
@end table
make_generic ("loc", GFC_ISYM_LOC, GFC_STD_GNU);
- /* The next of intrinsic subprogram are the degree trignometric functions.
+ /* The next of intrinsic subprogram are the degree trigonometric functions.
These were hidden behind the -fdec-math option, but are now simply
included as extensions to the set of intrinsic subprograms. */
}
-/* Resolve the degree trignometric functions. This amounts to setting
+/* Resolve the degree trigonometric functions. This amounts to setting
the function return type-spec from its argument and building a
library function names of the form _gfortran_sind_r4. */
/* EQUIVALENCE has been matched. After gobbling any possible whitespace,
the next character needs to be '('. Check that here, and return
- MATCH_NO for a variable of the form equivalencej. */
+ MATCH_NO for a variable of the form equivalence. */
gfc_gobble_whitespace ();
c = gfc_peek_ascii_char ();
if (c != '(')
MIO_NAME (ab_attribute) (AB_OACC_ROUTINE_LOP_SEQ, attr_bits);
break;
case OACC_ROUTINE_LOP_ERROR:
- /* ... intentionally omitted here; it's only unsed internally. */
+ /* ... intentionally omitted here; it's only used internally. */
default:
gcc_unreachable ();
}
}
/* Warn about trailing digits which suggest the user added too many
- trailing digits, which may cause the appearance of higher pecision
- than the kind kan support.
+ trailing digits, which may cause the appearance of higher precision
+ than the kind can support.
This is done by replacing the rightmost non-zero digit with zero
and comparing with the original value. If these are equal, we
return false;
value = gfc_get_null_expr (&gfc_current_locus);
}
- /* ....(Preceeding sentence) If a component with default
+ /* ....(Preceding sentence) If a component with default
initialization has no corresponding component-data-source, then
the default initialization is applied to that component. */
else if (comp->initializer)
/* Because this is an associate var and the first ref either is a ref to
the _data component or not, no traversal of the ref chain is
needed. The array ref needs to be inserted after the _data ref,
- or when that is not present, which may happend for polymorphic
+ or when that is not present, which may happened for polymorphic
types, then at the first position. */
ref = e->ref;
if (!ref)
the symbol in the expression and convert the array reference
into an actual arglist if the old symbol is a variable; or
(ii) That in which an external function is typed but not declared
- explcitly to be external. Here, the old symbol is changed
+ explicitly to be external. Here, the old symbol is changed
from a variable to an external function. */
static bool
check_host_association (gfc_expr *e)
&& (rhs->expr_type != EXPR_CONSTANT || !flag_dec_char_conversions))
{
/* Use of -fdec-char-conversions allows assignment of character data
- to non-character variables. This not permited for nonconstant
+ to non-character variables. This not permitted for nonconstant
strings. */
gfc_error ("Cannot convert %s to %s at %L", gfc_typename (rhs),
gfc_typename (lhs), &rhs->where);
/* For {L,U}BOUND, the value depends on whether the array
is empty. We can nevertheless simplify if the declared bound
has the same value as that of an empty array, in which case
- the result isn't dependent on the array emptyness. */
+ the result isn't dependent on the array emptiness. */
if (mpz_cmp_si (declared_bound->value.integer, empty_bound) == 0)
mpz_set_si (result->value.integer, empty_bound);
else if (!constant_lbound || !constant_ubound)
- /* Array emptyness can't be determined, we can't simplify. */
+ /* Array emptiness can't be determined, we can't simplify. */
goto returnNull;
else if (mpz_cmp (l->value.integer, u->value.integer) > 0)
mpz_set_si (result->value.integer, empty_bound);
"Creating array temporary at %L", &expr->where);
}
- /* When optmizing, we can use gfc_conv_subref_array_arg for
+ /* When optimizing, we can use gfc_conv_subref_array_arg for
making the packing and unpacking operation visible to the
optimizers. */
}
-/* Initialize class descriptor's TKR infomation. */
+/* Initialize class descriptor's TKR information. */
void
gfc_trans_class_array (gfc_symbol * sym, gfc_wrapped_block * block)
desc = desc_p;
else if (!GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (TREE_TYPE (desc_p))))
{
- /* Character(len=*) explict-size/assumed-size array. */
+ /* Character(len=*) explicit-size/assumed-size array. */
desc = desc_p;
gfc_build_qualified_array (desc, fsym);
}
}
gfc_add_block_to_block (&block, &se.pre);
- /* Create array decriptor and set version, rank, attribute, type. */
+ /* Create array descriptor and set version, rank, attribute, type. */
cfi = gfc_create_var (gfc_get_cfi_type (e->rank < 0
? GFC_MAX_DIMENSIONS : e->rank,
false), "cfi");
if (e->ts.type == BT_ASSUMED)
{
/* Note: type(*) implies assumed-shape/assumed-rank if fsym requires
- an CFI descriptor. Use the type in the descritor as it provide
+ an CFI descriptor. Use the type in the descriptor as it provide
mode information. (Quality of implementation feature.) */
tree cond;
tree ctype = gfc_get_cfi_desc_type (cfi);
/* Wstringop-overflow appears at -O3 even though this warning is not
explicitly available in fortran nor can it be switched off. If the
source length is a constant, its negative appears as a very large
- postive number and triggers the warning in BUILTIN_MEMSET. Fixing
+ positive number and triggers the warning in BUILTIN_MEMSET. Fixing
the result of the MINUS_EXPR suppresses this spurious warning. */
tmp = fold_build2_loc (input_location, MINUS_EXPR,
TREE_TYPE(dlen), dlen, slen);
tree calc;
/* For floating point types, the question is what MAX(a, NaN) or
MIN(a, NaN) should return (where "a" is a normal number).
- There are valid usecase for returning either one, but the
+ There are valid use case for returning either one, but the
Fortran standard doesn't specify which one should be chosen.
Also, there is no consensus among other tested compilers. In
short, it's a mess. So lets just do whatever is fastest. */
/* Check whether this DECL belongs to a Fortran optional argument.
With 'for_present_check' set to false, decls which are optional parameters
- themselve are returned as tree - or a NULL_TREE otherwise. Those decls are
+ themselves are returned as tree - or a NULL_TREE otherwise. Those decls are
always pointers. With 'for_present_check' set to true, the decl for checking
whether an argument is present is returned; for arguments with value
attribute this is the hidden argument and of BOOLEAN_TYPE. If the decl is
}
if (n_firstp && n_lastp)
{
- /* For parallel do, GCC puts firstprivatee/lastprivate
+ /* For parallel do, GCC puts firstprivate/lastprivate
on the parallel. */
if (is_parallel_do)
continue;
clausesa[GFC_OMP_SPLIT_DO].nowait = true;
/* Distribute allocate clause to do, parallel, distribute, teams, target
- and taskloop. The code below itereates over variables in the
+ and taskloop. The code below iterates over variables in the
allocate list and checks if that available is also in any
privatization clause on those construct. If yes, then we add it
to the list of 'allocate'ed variables for that construct. If a
gfc_conv_ss_startstride (&loop);
/* TODO: gfc_conv_loop_setup generates a temporary for vector
subscripts. This could be prevented in the elemental case
- as temporaries are handled separatedly
+ as temporaries are handled separately
(below in gfc_conv_elemental_dependencies). */
if (code->expr1)
gfc_conv_loop_setup (&loop, &code->expr1->where);
gfc_init_se (&se, NULL);
if (e->symtree->n.sym->ts.type == BT_CHARACTER)
{
- /* Deferred strings are dealt with in the preceeding. */
+ /* Deferred strings are dealt with in the preceding. */
gcc_assert (!e->symtree->n.sym->ts.deferred);
tmp = e->symtree->n.sym->ts.u.cl->backend_decl;
}
count, build_int_cst (TREE_TYPE (count), 0));
/* PR 83064 means that we cannot use annot_expr_parallel_kind until
- the autoparallelizer can hande this. */
+ the autoparallelizer can handle this. */
if (forall_tmp->do_concurrent)
cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
build_int_cst (integer_type_node,
}
/* Create a temp variable only for component refs to prevent
having to go through the full deref-chain each time and to
- simplfy computation of array properties. */
+ simplify computation of array properties. */
temp_var_needed = TREE_CODE (se.expr) == COMPONENT_REF;
}
}
&& DECL_P (expr3) && DECL_ARTIFICIAL (expr3))
{
/* Build a temporary symtree and symbol. Do not add it to the current
- namespace to prevent accidently modifying a colliding
+ namespace to prevent accidentaly modifying a colliding
symbol's as. */
newsym = XCNEW (gfc_symtree);
/* The name of the symtree should be unique, because gfc_create_var ()
projects / thirdparty / gcc.git / commitdiff
