+2005-04-01 Kazu Hirata <kazu@cs.umass.edu>
+
+ * adaint.c, cal.c, decl.c, gigi.h, gmem.c, init.c, link.c,
+ raise.c, tracebak.c, trans.c, utils2.c, utils.c: Fix comment
+ typos.
+
2005-03-30 Tom Tromey <tromey@redhat.com>
* decl.c (gnat_substitute_in_type): Don't handle FILE_TYPE.
}
/* Make newfd be the copy of oldfd, closing newfd first if necessary.
- Return -1 if an error occured. */
+ Return -1 if an error occurred. */
int
__gnat_dup2 (int oldfd, int newfd)
****************************************************************************/
/* This file contains those routines named by Import pragmas in package */
-/* GNAT.Calendar. It is used to to Duration to timeval convertion. */
+/* GNAT.Calendar. It is used to do Duration to timeval conversion. */
/* These are simple wrappers function to abstarct the fact that the C */
/* struct timeval fields type are not normalized (they are generaly */
/* defined as int or long values). */
void
__gnat_duration_to_timeval (long sec, long usec, struct timeval *t)
{
- /* here we are doing implicit convertion from a long to the struct timeval
+ /* here we are doing implicit conversion from a long to the struct timeval
fields types. */
t->tv_sec = sec;
gnu_ext_name = create_concat_name (gnat_entity, 0);
/* If this is constant initialized to a static constant and the
- object has an aggregrate type, force it to be statically
+ object has an aggregate type, force it to be statically
allocated. */
if (const_flag && gnu_expr && TREE_CONSTANT (gnu_expr)
&& host_integerp (TYPE_SIZE_UNIT (gnu_type), 1)
/* If we are pointing to an incomplete type whose completion is an
unconstrained array, make a fat pointer type instead of a pointer
to VOID. The two types in our fields will be pointers to VOID and
- will be replaced in update_pointer_to. Similiarly, if the type
+ will be replaced in update_pointer_to. Similarly, if the type
itself is a dummy type or an unconstrained array. Also make
a dummy TYPE_OBJECT_RECORD_TYPE in case we have any thin
pointers to it. */
post_error ("unsupported mechanism for&", gnat_param);
/* If this is either a foreign function or if the
- underlying type won't be passed by refererence, strip off
+ underlying type won't be passed by reference, strip off
possible padding type. */
if (TREE_CODE (gnu_param_type) == RECORD_TYPE
&& TYPE_IS_PADDING_P (gnu_param_type)
/* Return a TREE_LIST describing the substitutions needed to reflect
discriminant substitutions from GNAT_SUBTYPE to GNAT_TYPE and add
them to GNU_LIST. If GNAT_TYPE is not specified, use the base type
- of GNAT_SUBTYPE. The substitions can be in any order. TREE_PURPOSE
+ of GNAT_SUBTYPE. The substitutions can be in any order. TREE_PURPOSE
gives the tree for the discriminant and TREE_VALUES is the replacement
value. They are in the form of operands to substitute_in_expr.
DEFINITION is as in gnat_to_gnu_entity. */
&& Ekind (Entity (gnat_expr)) == E_Discriminant)))
return 0;
- /* Otherwise, convert this tree to its GCC equivalant. */
+ /* Otherwise, convert this tree to its GCC equivalent. */
gnu_expr
= elaborate_expression_1 (gnat_expr, gnat_entity, gnat_to_gnu (gnat_expr),
gnu_name, definition, need_debug);
}
/* If Aliased, the size must match exactly the rounded size. We
- used to be more accomodating here and accept greater sizes, but
+ used to be more accommodating here and accept greater sizes, but
fully supporting this case on big-endian platforms would require
switching to a more involved layout for the field. */
else if (Is_Aliased (gnat_field)
/* For negative values, use NEGATE_EXPR of the supplied value. */
if (tree_int_cst_sgn (gnu_size) < 0)
{
- /* The rediculous code below is to handle the case of the largest
+ /* The ridiculous code below is to handle the case of the largest
negative integer. */
tree negative_size = size_diffop (bitsize_zero_node, gnu_size);
bool adjust = false;
/* Do the processing for the declaration of a GNAT_ENTITY, a type. If
a separate Freeze node exists, delay the bulk of the processing. Otherwise
- make a GCC type for GNAT_ENTITY and set up the correspondance. */
+ make a GCC type for GNAT_ENTITY and set up the correspondence. */
extern void process_type (Entity_Id gnat_entity);
/* Convert Sloc into *LOCUS (a location_t). Return true if this Sloc
likewise return an expression pointing to the underlying array. */
extern tree maybe_unconstrained_array (tree exp);
-/* Return an expression that does an unchecked converstion of EXPR to TYPE.
+/* Return an expression that does an unchecked conversion of EXPR to TYPE.
If NOTRUNC_P is true, truncation operations should be suppressed. */
extern tree unchecked_convert (tree type, tree expr, bool notrunc_p);
}
/* initialize gmem feature from the dumpname file. It returns 1 if the
- dumpname has beed generated by GMEM (instrumented malloc/free) and 0 if not
+ dumpname has been generated by GMEM (instrumented malloc/free) and 0 if not
(i.e. probably a GDB generated file).
*/
as the faulting instruction address in the corresponding signal context
pushed by the kernel. Leaving this address untouched may loose, because if
the triggering instruction happens to be the very first of a region, the
- later adjustements performed by the unwinder would yield an address outside
+ later adjustments performed by the unwinder would yield an address outside
that region. We need to compensate for those adjustments at some point,
which we currently do in the GCC unwinding fallback macro.
/* Define macro symbols for the VMS conditions that become Ada exceptions.
Most of these are also defined in the header file ssdef.h which has not
- yet been converted to be recoginized by Gnu C. Some, which couldn't be
+ yet been converted to be recognized by Gnu C. Some, which couldn't be
located, are assigned names based on the DEC test suite tests which
raise them. */
??? This is not a perfect solution to deal with the possible
interactions between the GNAT and the DECAda exception handling
models and better (more general) schemes are studied. This is so
- just provided as a conveniency workaround in the meantime, and
+ just provided as a convenient workaround in the meantime, and
should be use with caution since the implementation has been kept
very simple. */
asm ("mtfsb0 26");
#endif
- /* Similarily for sparc64. Achieved by masking bits in the Trap Enable Mask
+ /* Similarly for sparc64. Achieved by masking bits in the Trap Enable Mask
field of the Floating-point Status Register (see the Sparc Architecture
Manual Version 9, p 48). */
#if defined (sparc64)
* *
****************************************************************************/
-/* This file contains host-specific parameters describing the behaviour */
+/* This file contains host-specific parameters describing the behavior */
/* of the linker. It is used by gnatlink as well as all tools that use */
/* Mlib. */
/* This is an incomplete "proxy" of the structure of exception objects as
built by the GNAT runtime library. Accesses to other fields than the common
- header are performed through subprogram calls to aleviate the need of an
+ header are performed through subprogram calls to alleviate the need of an
exact counterpart here and potential alignment/size issues for the common
header. See a-exexpr.adb. */
/* Base matching rules: An exception data (id) matches itself, "when
all_others" matches anything and "when others" matches anything unless
- explicitely stated otherwise in the propagated occurrence. */
+ explicitly stated otherwise in the propagated occurrence. */
bool is_handled =
choice == E
/* Setup in UW_CONTEXT the eh return target IP and data registers, which will
be restored with the others and retrieved by the landing pad once the jump
- occured. */
+ occurred. */
static void
setup_to_install (_Unwind_Context *uw_context,
libgcc, and the stage1 compiler is unlikely to be linked against a post 3.3
library. It actually disables the support for backtraces in this compiler
for targets defining USE_GCC_UNWINDER, which is OK since we don't use the
- traceback capablity in the compiler anyway.
+ traceback capability in the compiler anyway.
The condition is expressed the way above because we cannot reliably rely on
any other macro from the base compiler when compiling stage1. */
}
else
{
- /* Expand the type of this identitier first, in case it is an enumeral
+ /* Expand the type of this identifier first, in case it is an enumeral
literal, which only get made when the type is expanded. There is no
order-of-elaboration issue here. We want to use the Actual_Subtype if
it has already been elaborated, otherwise the Etype. Avoid using
/* Save debug output mode in case it is reset. */
enum debug_info_type save_write_symbols = write_symbols;
const struct gcc_debug_hooks *const save_debug_hooks = debug_hooks;
- /* Definining identifier of a parameter to the subprogram. */
+ /* Defining identifier of a parameter to the subprogram. */
Entity_Id gnat_param;
/* The defining identifier for the subprogram body. Note that if a
specification has appeared before for this body, then the identifier
case N_Defining_Program_Unit_Name:
/* For a child unit identifier go up a level to get the
- specificaton. We get this when we try to find the spec of
+ specification. We get this when we try to find the spec of
a child unit package that is the compilation unit being compiled. */
gnu_result = gnat_to_gnu (Parent (gnat_node));
break;
/* If the result is a pointer type, see if we are either converting
from a non-pointer or from a pointer to a type with a different
alias set and warn if so. If the result defined in the same unit as
- this unchecked convertion, we can allow this because we can know to
+ this unchecked conversion, we can allow this because we can know to
make that type have alias set 0. */
{
tree gnu_source_type = gnat_to_gnu_type (Source_Type (gnat_node));
\f
/* Do the processing for the declaration of a GNAT_ENTITY, a type. If
a separate Freeze node exists, delay the bulk of the processing. Otherwise
- make a GCC type for GNAT_ENTITY and set up the correspondance. */
+ make a GCC type for GNAT_ENTITY and set up the correspondence. */
void
process_type (Entity_Id gnat_entity)
/* Given 2 consecutive field decls PREV_FIELD and CURR_FIELD, return true
unless we can prove these 2 fields are laid out in such a way that no gap
- exist between the end of PREV_FIELD and the begining of CURR_FIELD. OFFSET
+ exist between the end of PREV_FIELD and the beginning of CURR_FIELD. OFFSET
is the distance in bits between the end of PREV_FIELD and the starting
position of CURR_FIELD. It is ignored if null. */
if (TREE_CODE (TREE_TYPE (prev_field)) == QUAL_UNION_TYPE)
return false;
- /* If the distance between the end of prev_field and the begining of
+ /* If the distance between the end of prev_field and the beginning of
curr_field is constant, then there is a gap if the value of this
constant is not null. */
if (offset && host_integerp (offset, 1))
/* If the result type is a padded type with a self-referentially-sized
field and the expression type is a record, do this as an
- unchecked converstion. */
+ unchecked conversion. */
else if (TREE_CODE (etype) == RECORD_TYPE
&& CONTAINS_PLACEHOLDER_P (DECL_SIZE (TYPE_FIELDS (type))))
return unchecked_convert (type, expr, false);
return exp;
}
\f
-/* Return an expression that does an unchecked converstion of EXPR to TYPE.
+/* Return an expression that does an unchecked conversion of EXPR to TYPE.
If NOTRUNC_P is true, truncation operations should be suppressed. */
tree
rhs = fold (build2 (MINUS_EXPR, type, modulus, rhs)), op_code = MINUS_EXPR;
/* For the logical operations, we only need PRECISION bits. For
- addition and subraction, we need one more and for multiplication we
+ addition and subtraction, we need one more and for multiplication we
need twice as many. But we never want to make a size smaller than
our size. */
if (op_code == PLUS_EXPR || op_code == MINUS_EXPR)
projects / gcc.git / commitdiff