+2012-05-30 Tobias Burnus <burnus@net-b.de>
+
+ * decl.c: Fix comment typos.
+ * expr.c: Ditto.
+ * frontend-passes.c: Ditto.
+ * match.c: Ditto.
+ * resolve.c: Ditto.
+ * trans-array.c: Ditto.
+ * trans-common.c: Ditto.
+ * trans-intrinsic.c: Ditto.
+ * trans-types.c: Ditto.
+
2012-05-23 Tobias Burnus <burnus@net-b.de>
PR fortran/51055
/************************ Declaration statements *********************/
-/* Auxilliary function to merge DIMENSION and CODIMENSION array specs. */
+/* Auxiliary function to merge DIMENSION and CODIMENSION array specs. */
static void
merge_array_spec (gfc_array_spec *from, gfc_array_spec *to, bool copy)
return MATCH_ERROR;
}
- /* Match NULL() initilization. */
+ /* Match NULL() initialization. */
m = gfc_match_null (init);
if (m != MATCH_NO)
return m;
C interoperable kind (and store the fact). */
if (e->ts.is_c_interop == 1)
{
- /* Mark this as c interoperable if being declared with one
+ /* Mark this as C interoperable if being declared with one
of the named constants from iso_c_binding. */
ts->is_c_interop = e->ts.is_iso_c;
ts->f90_type = e->ts.f90_type;
ts->kind = kind == 0 ? gfc_default_character_kind : kind;
ts->deferred = deferred;
- /* We have to know if it was a c interoperable kind so we can
+ /* We have to know if it was a C interoperable kind so we can
do accurate type checking of bind(c) procs, etc. */
if (kind != 0)
- /* Mark this as c interoperable if being declared with one
+ /* Mark this as C interoperable if being declared with one
of the named constants from iso_c_binding. */
ts->is_c_interop = is_iso_c;
else if (len != NULL)
/* Search for the name but allow the components to be defined later. If
type = -1, this typespec has been seen in a function declaration but
the type could not be accessed at that point. The actual derived type is
- stored in a symtree with the first letter of the name captialized; the
+ stored in a symtree with the first letter of the name capitalized; the
symtree with the all lower-case name contains the associated
generic function. */
dt_name = gfc_get_string ("%c%s",
if (sym->attr.generic && (sym = gfc_find_dt_in_generic (sym)))
{
/* The actual derived type is stored in a symtree with the first
- letter of the name captialized; the symtree with the all
+ letter of the name capitalized; the symtree with the all
lower-case name contains the associated generic function. */
st = gfc_new_symtree (&gfc_current_ns->sym_root,
gfc_get_string ("%c%s",
}
if (curr_binding_label)
- /* Binding label given; store in temp holder til have sym. */
+ /* Binding label given; store in temp holder till have sym. */
*dest_label = curr_binding_label;
else
{
bool seen_ptr = false;
match m = MATCH_YES;
- /* Intialize to defaults. Do so even before the MATCH_NO check so that in
+ /* Initialize to defaults. Do so even before the MATCH_NO check so that in
this case the defaults are in there. */
ba->access = ACCESS_UNKNOWN;
ba->pass_arg = NULL;
/* Copy a shape array excluding dimension N, where N is an integer
- constant expression. Dimensions are numbered in fortran style --
+ constant expression. Dimensions are numbered in Fortran style --
starting with ONE.
So, if the original shape array contains R elements
/* Check whether an expression is "simply contiguous", cf. F2008, 6.5.4.
Note: A scalar is not regarded as "simply contiguous" by the standard.
- if bool is not strict, some futher checks are done - for instance,
+ if bool is not strict, some further checks are done - for instance,
a "(::1)" is accepted. */
bool
return false;
/* Following the standard, "(::1)" or - if known at compile time -
- "(lbound:ubound)" are not simply contigous; if strict
+ "(lbound:ubound)" are not simply contiguous; if strict
is false, they are regarded as simply contiguous. */
if (ar->stride[i] && (strict || ar->stride[i]->expr_type != EXPR_CONSTANT
|| ar->stride[i]->ts.type != BT_INTEGER
}
/* Returns a new expression (a variable) to be used in place of the old one,
- with an an assignment statement before the current statement to set
+ with an assignment statement before the current statement to set
the value of the variable. Creates a new BLOCK for the statement if
that hasn't already been done and puts the statement, plus the
newly created variables, in that block. */
{
gfc_intrinsic_op op = e->value.op.op;
- /* Only use new-style comparisions. */
+ /* Only use new-style comparisons. */
switch(op)
{
case INTRINSIC_EQ_OS:
}
else if (e->expr_type == EXPR_FUNCTION)
{
- /* One of the lexical comparision functions. */
+ /* One of the lexical comparison functions. */
firstarg = e->value.function.actual;
secondarg = firstarg->next;
op1 = firstarg->expr;
c = gfc_next_char_literal (INSTRING_WARN);
/* If the user put nothing expect spaces between the quotes, it is valid
- and simply means there is no name= specifier and the name is the fortran
+ and simply means there is no name= specifier and the name is the Fortran
symbol name, all lowercase. */
if (c == '"' || c == '\'')
{
array, which can have a reference, from other expressions that
have references, such as derived type components, and are not
allowed by the standard.
- TODO; see is it is sufficent to exclude component and substring
+ TODO; see is it is sufficient to exclude component and substring
references. */
class_array = expr1->expr_type == EXPR_VARIABLE
&& expr1->ts.type != BT_UNKNOWN
/* See if a call to sym could possibly be a not allowed RECURSION because of
- a missing RECURIVE declaration. This means that either sym is the current
+ a missing RECURSIVE declaration. This means that either sym is the current
context itself, or sym is the parent of a contained procedure calling its
non-RECURSIVE containing procedure.
This also works if sym is an ENTRY. */
derived = e->value.compcall.base_object->ts.u.derived;
st = NULL;
- /* If necessary, go throught the inheritance chain. */
+ /* If necessary, go through the inheritance chain. */
while (!st && derived)
{
/* Look for the typebound procedure 'name'. */
gfc_component *c;
gfc_try t;
- /* Mark the ultimost array component as being in allocate to allow DIMEN_STAR
+ /* Mark the utmost array component as being in allocate to allow DIMEN_STAR
checking of coarrays. */
for (ref = e->ref; ref; ref = ref->next)
if (ref->next == NULL)
if (dimension == 0 && codimension == 0)
goto success;
- /* Make sure the last reference node is an array specifiction. */
+ /* Make sure the last reference node is an array specification. */
if (!ref2 || ref2->type != REF_ARRAY || ref2->u.ar.type == AR_FULL
|| (dimension && ref2->u.ar.dimen == 0))
/* Chain in the new list only if it is marked as dangling. Otherwise
there is a CASE label overlap and this is already used. Just ignore,
- the error is diagonsed elsewhere. */
+ the error is diagnosed elsewhere. */
if (st->n.sym->assoc->dangling)
{
new_st->ext.block.assoc = st->n.sym->assoc;
case EXEC_OMP_WORKSHARE:
omp_workshare_save = omp_workshare_flag;
omp_workshare_flag = 1;
- /* FALLTHROUGH */
+ /* FALL THROUGH */
default:
gfc_resolve_blocks (code->block, ns);
break;
descriptors and data pointers are also translated.
If the expression is an assignment, we must then resolve any dependencies.
- In fortran all the rhs values of an assignment must be evaluated before
+ In Fortran all the rhs values of an assignment must be evaluated before
any assignments take place. This can require a temporary array to store the
values. We also require a temporary when we are passing array expressions
or vector subscripts as procedure parameters.
'eltype' == NULL signals that the temporary should be a class object.
The 'initial' expression is used to obtain the size of the dynamic
- type; otehrwise the allocation and initialisation proceeds as for any
+ type; otherwise the allocation and initialisation proceeds as for any
other expression
PRE, POST, INITIAL, DYNAMIC and DEALLOC are as for
tmp = build1_v (LABEL_EXPR, exit_label);
gfc_add_expr_to_block (&implied_do_block, tmp);
- /* Finishe the implied-do loop. */
+ /* Finish the implied-do loop. */
tmp = gfc_finish_block(&implied_do_block);
gfc_add_expr_to_block(pblock, tmp);
}
-/* A catch-all to obtain the string length for anything that is not a
+/* A catch-all to obtain the string length for anything that is not
a substring of non-constant length, a constant, array or variable. */
static void
/* Browse through each array's information from the scalarizer and set the loop
bounds according to the "best" one (per dimension), i.e. the one which
- provides the most information (constant bounds, shape, etc). */
+ provides the most information (constant bounds, shape, etc.). */
static void
set_loop_bounds (gfc_loopinfo *loop)
}
else
{
- /* Silence unitialized warnings. */
+ /* Silence uninitialized warnings. */
specinfo = NULL;
spec_dim = 0;
}
}
/* The stride is the number of elements in the array, so multiply by the
- size of an element to get the total size. Obviously, if there ia a
+ size of an element to get the total size. Obviously, if there is a
SOURCE expression (expr3) we must use its element size. */
if (expr3_elem_size != NULL_TREE)
tmp = expr3_elem_size;
/* A transformational function return value will be a temporary
array descriptor. We still need to go through the scalarizer
- to create the descriptor. Elemental functions ar handled as
+ to create the descriptor. Elemental functions are handled as
arbitrary expressions, i.e. copy to a temporary. */
if (se->direct_byref)
case DEALLOCATE_ALLOC_COMP:
/* gfc_deallocate_scalar_with_status calls gfc_deallocate_alloc_comp
- (ie. this function) so generate all the calls and suppress the
+ (i.e. this function) so generate all the calls and suppress the
recursion from here, if necessary. */
called_dealloc_with_status = false;
gfc_init_block (&tmpblock);
}
-/* Given an expression refering to a procedure, return the symbol of its
+/* Given an expression referring to a procedure, return the symbol of its
interface. We can't get the procedure symbol directly as we have to handle
the case of (deferred) type-bound procedures. */
Each segment is described by a chain of segment_info structures. Each
segment_info structure describes the extents of a single variable within
the segment. This list is maintained in the order the elements are
- positioned withing the segment. If two elements have the same starting
+ positioned within the segment. If two elements have the same starting
offset the smaller will come first. If they also have the same size their
ordering is undefined.
/* Only for gfc_trans_assign and gfc_trans_pointer_assign. */
#include "trans-stmt.h"
-/* This maps fortran intrinsic math functions to external library or GCC
+/* This maps Fortran intrinsic math functions to external library or GCC
builtin functions. */
typedef struct GTY(()) gfc_intrinsic_map_t {
/* The explicit enum is required to work around inadequacies in the
}
- /* Substract 1 to get to zero based and add dimensions. */
+ /* Subtract 1 to get to zero based and add dimensions. */
switch (arg->expr->rank)
{
case 0:
{
tree ret = t;
- /* If the type isn't layed out yet, don't copy it. If something
+ /* If the type isn't laid out yet, don't copy it. If something
needs it for real it should wait until the type got finished. */
if (!TYPE_SIZE (t))
return t;
+2012-05-30 Tobias Burnus <burnus@net-b.de>
+
+ * io/io.h: Fix comment typos.
+ * io/list_read.c: Ditto.
+
2012-05-27 Janne Blomqvist <jb@gcc.gnu.org>
* intrinsics/time_1.h (gf_cputime): Don't reevaluate HZ expression
/* Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
- 2011
+ 2011, 2012
Free Software Foundation, Inc.
Contributed by Andy Vaught
F2003 I/O support contributed by Jerry DeLisle
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
}
array_loop_spec;
-/* A stucture to build a hash table for format data. */
+/* A structure to build a hash table for format data. */
#define FORMAT_HASH_SIZE 16
unsigned at_eol : 1;
unsigned comma_flag : 1;
/* A namelist specific flag used in the list directed library
- to flag that calls are being made from namelist read (eg. to
+ to flag that calls are being made from namelist read (e.g. to
ignore comments or to treat '/' as a terminator) */
unsigned namelist_mode : 1;
/* A namelist specific flag used in the list directed library
if (dtp->u.p.nml_read_error)
goto find_nml_name;
- /* A trailing space is required, we give a little lattitude here, 10.9.1. */
+ /* A trailing space is required, we give a little latitude here, 10.9.1. */
c = next_char (dtp);
if (!is_separator(c) && c != '!')
{
OSDN Git Service
