Fix more "allows to" and other typos

Doc/Manual/Guile.html

@@ -183,7 +183,7 @@ information by including a directive like this in the interface file:
 </div>
 
 <p>
-(The <code>%scheme</code> directive allows to insert arbitrary Scheme
+(The <code>%scheme</code> directive allows inserting arbitrary Scheme
 code into the generated file <code><var>module.scm</var></code>; it is
 placed between the <code>define-module</code> form and the
 <code>export</code> form.)

Doc/Manual/Javascript.html

@@ -406,7 +406,7 @@ the main window.</p>
 
 <p>
 As known from <code>node.js</code> one can use <code>require</code> to load javascript modules.
-Additionally, <code>node-webkit</code> provides an API that allows to manipulate the window's menu,
+Additionally, <code>node-webkit</code> provides an API that allows manipulating the window's menu,
 open new windows, and many more things.
 </p>
 

Doc/Manual/SWIG.html

@@ -2020,7 +2020,7 @@ and a more descriptive one, but the two functions are otherwise equivalent:
 <tr>
     <td><span style="white-space: nowrap;"><tt>regex:/pattern/subst/</tt></span></td>
     <td>String after (Perl-like) regex substitution operation. This function
-    allows to apply arbitrary regular expressions to the identifier names. The
+    allows applying arbitrary regular expressions to the identifier names. The
     <i>pattern</i> part is a regular expression in Perl syntax (as supported
     by the <a href="http://www.pcre.org/">Perl Compatible Regular Expressions (PCRE)</a>)
     library and the <i>subst</i> string

Lib/csharp/std_auto_ptr.i

@@ -1,5 +1,5 @@
 /*
-    The typemaps here allow to handle functions returning std::auto_ptr<>,
+    The typemaps here allow handling functions returning std::auto_ptr<>,
     which is the most common use of this type. If you have functions taking it
     as parameter, these typemaps can't be used for them and you need to do
     something else (e.g. use shared_ptr<> which SWIG supports fully).

Lib/java/std_auto_ptr.i

@@ -1,5 +1,5 @@
 /*
-    The typemaps here allow to handle functions returning std::auto_ptr<>,
+    The typemaps here allow handling functions returning std::auto_ptr<>,
     which is the most common use of this type. If you have functions taking it
     as parameter, these typemaps can't be used for them and you need to do
     something else (e.g. use shared_ptr<> which SWIG supports fully).

Lib/lua/luarun.swg

@@ -1344,14 +1344,14 @@ SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L); /*forward declaration
 
 /* The real function that resolves a metamethod.
  * Function searches given class and all it's bases(recursively) for first instance of something that is
- * not equal to SWIG_Lua_resolve_metatmethod. (Almost always this 'something' is actual metamethod implementation
+ * not equal to SWIG_Lua_resolve_metamethod. (Almost always this 'something' is actual metamethod implementation
  * and it is a SWIG-generated C function.). It returns value on the top of the L and there is no garbage below the
  * answer.
  * Returns 1 if found, 0 otherwise.
  * clss is class which metatable we will search for method
  * metamethod_name_idx is index in L where metamethod name (as string) lies
- * skip_check allows to skip searching metamethod in givel clss and immideatelly go to searching in bases. skip_check
- * is not caried to subsequent recursive calls - false is always passed. It is set to true only at first call from
+ * skip_check allows skipping searching metamethod in the given class and immediately going to searching in bases. skip_check
+ * is not carried to subsequent recursive calls - false is always passed. It is set to true only at first call from
  * SWIG_Lua_resolve_metamethod
  * */
 SWIGINTERN int SWIG_Lua_do_resolve_metamethod(lua_State *L, const swig_lua_class *clss, int metamethod_name_idx,
@@ -1497,7 +1497,7 @@ SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class
     }
   }
 
-  lua_pop(L,1); /* remove inheritable metatmethods table */
+  lua_pop(L,1); /* remove inheritable metamethods table */
 
   /* Special handling for __tostring method */
   lua_pushstring(L, "__tostring");

Lib/python/std_auto_ptr.i

@@ -1,5 +1,5 @@
 /*
-    The typemaps here allow to handle functions returning std::auto_ptr<>,
+    The typemaps here allow handling functions returning std::auto_ptr<>,
     which is the most common use of this type. If you have functions taking it
     as parameter, these typemaps can't be used for them and you need to do
     something else (e.g. use shared_ptr<> which SWIG supports fully).

Lib/ruby/std_auto_ptr.i

@@ -1,5 +1,5 @@
 /*
-    The typemaps here allow to handle functions returning std::auto_ptr<>,
+    The typemaps here allow handling functions returning std::auto_ptr<>,
     which is the most common use of this type. If you have functions taking it
     as parameter, these typemaps can't be used for them and you need to do
     something else (e.g. use shared_ptr<> which SWIG supports fully).

Source/Modules/javascript.cxx

@@ -727,7 +727,7 @@ Node *JSEmitter::getBaseClass(Node *n) {
  /* -----------------------------------------------------------------------------
   * JSEmitter::emitWrapperFunction() :  dispatches emitter functions.
   *
-  * This allows to have small sized, dedicated emitting functions.
+  * This allows having small sized, dedicated emitting functions.
   * All state dependent branching is done here.
   * ----------------------------------------------------------------------------- */