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

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@121372 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog
index 79dbfc4..bd11ee3 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 060d871..28b0dfe 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 8a6d6fc..0e2ba8c 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)