* class.c, jcf-parse.c: Fix comment typos.

From-SVN: r121372

diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog
index 79dbfc48df8a2b4826cd7a29ce9f6ac8975c1fe9..bd11ee369532b83427f5a260aa5c4732069c7912 100644 (file)
--- a/gcc/java/ChangeLog
+++ b/gcc/java/ChangeLog
@@ -1,3 +1,7 @@
+2007-01-31  Kazu Hirata  <kazu@codesourcery.com>
+
+       * class.c, jcf-parse.c: Fix comment typos.
+
 2007-01-30  Tom Tromey  <tromey@redhat.com>
 
        * gcj.texi (Strings): Fix documentation for JvNewString.

diff --git a/gcc/java/class.c b/gcc/java/class.c
index 060d871fc50f4e17b965832a4dca107ca32cac48..28b0dfe58d76f8d836ea82f334961deaec3f0804 100644 (file)
--- a/gcc/java/class.c
+++ b/gcc/java/class.c
@@ -1671,7 +1671,7 @@ make_class_data (tree type)
   /* gcj sorts fields so that static fields come first, followed by
      instance fields.  Unfortunately, by the time this takes place we
      have already generated the reflection_data for this class, and
-     that data contians indexes into the fields.  So, we generate a
+     that data contains indexes into the fields.  So, we generate a
      permutation that maps each original field index to its final
      position.  Then we pass this permutation to
      rewrite_reflection_indexes(), which fixes up the reflection

diff --git a/gcc/java/jcf-parse.c b/gcc/java/jcf-parse.c
index 8a6d6fc2499bf5d4d5fe9afc2bde6414ab8e2492..0e2ba8c167bb72dce4dd3ec251241a35ca876b10 100644 (file)
--- a/gcc/java/jcf-parse.c
+++ b/gcc/java/jcf-parse.c
@@ -91,7 +91,7 @@ static location_t file_start_location;
 /* The Java archive that provides main_class;  the main input file. */
 static GTY(()) struct JCF * main_jcf;
 
-/* The number of source files passd to us by -fsource-filename and an
+/* The number of source files passed to us by -fsource-filename and an
    array of pointers to each name.  Used by find_sourcefile().  */
 static int num_files = 0;
 static char **filenames;
@@ -381,15 +381,15 @@ set_source_filename (JCF *jcf, int index)
 /* Annotation handling.  
 
    The technique we use here is to copy the annotation data directly
-   from the input class file into the ouput file.  We don't decode the
+   from the input class file into the output file.  We don't decode the
    data at all, merely rewriting constant indexes whenever we come
-   across them: this is necessary becasue the constant pool in the
+   across them: this is necessary because the constant pool in the
    output file isn't the same as the constant pool in in the input.
 
    The main advantage of this technique is that the resulting
    annotation data is pointer-free, so it doesn't have to be relocated
    at startup time.  As a consequence of this, annotations have no
-   peformance impact unless they are used.  Also, this representation
+   performance impact unless they are used.  Also, this representation
    is very dense.  */
 
 
@@ -723,7 +723,7 @@ handle_annotation (JCF *jcf, int level)
 }
 
 /* Read an annotation count from JCF, and write the following
-   annotatons to the reflection_data field of the outgoing class.  */
+   annotations to the reflection_data field of the outgoing class.  */
 
 static void
 handle_annotations (JCF *jcf, int level)