Index: /trunk/include/VBox/com/array.h
===================================================================
--- /trunk/include/VBox/com/array.h	(revision 16741)
+++ /trunk/include/VBox/com/array.h	(revision 16742)
@@ -755,9 +755,9 @@
      * existing value to the array element, for example:
      * <tt>Bstr string; array.push_back (string);</tt>. If you create a string
-     * just to put it to the array, you may find #appendedRaw() more useful.
+     * just to put it in the array, you may find #appendedRaw() more useful.
      *
      * @param aElement Element to append.
      *
-     * @return          @c true on success and false if there is not enough
+     * @return          @c true on success and @c false if there is not enough
      *                  memory for resizing.
      */
@@ -789,6 +789,6 @@
      *
      * This method is handy for operations like
-     * <tt>Bstr ("foo").detacTo (array.appendedRaw());</tt>. Don't use it as
-     * l-value (<tt>array.appendedRaw() = SysAllocString (L"tralala");</tt>)
+     * <tt>Bstr ("foo").detachTo (array.appendedRaw());</tt>. Don't use it as
+     * an l-value (<tt>array.appendedRaw() = SysAllocString (L"tralala");</tt>)
      * since this doesn't check for a NULL condition; use #resize() and
      * #setRawAt() instead. If you need to assign a copy of the existing value
@@ -815,10 +815,10 @@
     /**
      * Resizes the array preserving its contents when possible. If the new size
-     * is larget than the old size, new elements are initialized with null
+     * is larger than the old size, new elements are initialized with null
      * values. If the new size is less than the old size, the contents of the
      * array beyond the new size is lost.
      *
      * @param aNewSize  New number of elements in the array.
-     * @return          @c true on success and false if there is not enough
+     * @return          @c true on success and @c false if there is not enough
      *                  memory for resizing.
      */
@@ -850,5 +850,5 @@
      *
      * @param aNewSize  New number of elements in the array.
-     * @return          @c true on success and false if there is not enough
+     * @return          @c true on success and @c false if there is not enough
      *                  memory for resizing.
      */
@@ -933,5 +933,5 @@
      * @note It is assumed that the ownership of the returned copy is
      * transferred to the caller of the method and he is responsible to free the
-     * array data when it is no more necessary.
+     * array data when it is no longer needed.
      *
      * @param aArg  Output method parameter to clone to.
@@ -963,5 +963,5 @@
      * @note Since the ownership of the array data is transferred to the
      * caller of the method, he is responsible to free the array data when it is
-     * no more necessary.
+     * no longer needed.
      *
      * @param aArg  Location to detach to.
@@ -1003,5 +1003,5 @@
     }
 
-    // public methods for internal purposes only
+    // Public methods for internal purposes only.
 
 #if defined (VBOX_WITH_XPCOM)
@@ -1031,8 +1031,8 @@
 
     /**
-     * Ensures that the array is big enough to contaon aNewSize elements.
+     * Ensures that the array is big enough to contain aNewSize elements.
      *
      * If the new size is greater than the current capacity, a new array is
-     * allocated and elements from the old array are copied over. The  size of
+     * allocated and elements from the old array are copied over. The size of
      * the array doesn't change, only the capacity increases (which is always
      * greater than the size). Note that the additionally allocated elements are
@@ -1062,5 +1062,5 @@
             return true;
 
-        /* allocate in 16-byte pieces */
+        /* Allocate in 16-byte pieces. */
         size_t newCapacity = RT_MAX ((aNewSize + 15) / 16 * 16, 16);
 
@@ -1074,6 +1074,6 @@
                 if (m.size > aNewSize)
                 {
-                    /* truncation takes place, uninit exceeding elements and
-                     * shrink the size */
+                    /* Truncation takes place, uninit exceeding elements and
+                     * shrink the size. */
                     for (size_t i = aNewSize; i < m.size; ++ i)
                         Uninit (m.arr [i]);
@@ -1082,5 +1082,5 @@
                 }
 
-                /* copy the old contents */
+                /* Copy the old contents. */
                 memcpy (newArr, m.arr, m.size * sizeof (T));
                 nsMemory::Free ((void *) m.arr);
@@ -1093,6 +1093,6 @@
             if (m.size > aNewSize)
             {
-                /* truncation takes place, uninit exceeding elements and
-                 * shrink the size */
+                /* Truncation takes place, uninit exceeding elements and
+                 * shrink the size. */
                 for (size_t i = aNewSize; i < m.size; ++ i)
                     Uninit (m.arr [i]);
@@ -1221,5 +1221,5 @@
  * ComSafeArrayIn* and ComSafeArrayOut*. Another important nuance is that the
  * raw() array type is different (nsID **, or GUID ** on XPCOM and GUID * on MS
- * COM) so it is recommended to use operator[] instead that always returns a
+ * COM) so it is recommended to use operator[] instead which always returns a
  * GUID by value.
  *
@@ -1277,6 +1277,6 @@
     /**
      * Array access operator that returns an array element by reference. As a
-     * special case, the return value of this operator on XPCOM is a nsID (GUID)
-     * reference, instead of a nsID pointer (the actual SafeArray template
+     * special case, the return value of this operator on XPCOM is an nsID (GUID)
+     * reference, instead of an nsID pointer (the actual SafeArray template
      * argument), for compatibility with the MS COM version.
      *
@@ -1337,5 +1337,5 @@
 private:
 
-    /* These are disabled because of const */
+    /* These are disabled because of const. */
     bool reset (size_t aNewSize) { NOREF (aNewSize); return false; }
 };
@@ -1461,6 +1461,6 @@
      *
      * Note that this constructor doesn't take the ownership of the array. In
-     * particular, it means that operations that operate on the ownership (e.g.
-     * #detachTo()) are forbidden and will assert.
+     * particular, this means that operations that operate on the ownership
+     * (e.g. #detachTo()) are forbidden and will assert.
      *
      * @param aArg  Input method parameter to attach to.
