# HG changeset patch
# User Andrew Janke <floss@apjanke.net>
# Date 1571457941 25200
#      Fri Oct 18 21:05:41 2019 -0700
# Branch fix-typos
# Node ID 283a0cf179ea69ad9d7a39b3d97faad82f18a44d
# Parent  a31d3856885102cd7c28481511a2fcce189201f4
Typo and style fixes in helptext and code comments.

No functional changes.

diff --git a/inst/chk_spreadsheet_support.m b/inst/chk_spreadsheet_support.m
--- a/inst/chk_spreadsheet_support.m
+++ b/inst/chk_spreadsheet_support.m
@@ -66,34 +66,34 @@
 ## @indent
 ## @item 0
 ## No debug output is generated.
 ##
 ## @item 1 
 ## Only proper operation of main interface groups (COM, Java) is shown.
 ## If @var{path_to_jars} and/or @var{path_to_ooo} was supplied,
 ## chk_spreadsheet_support indicates whether it could find the required
-## Java class libs for all interfaces
+## Java class libs for all interfaces.
 ##
 ## @item 2
 ## Like 1, proper working of individual implemented Java-based interfaces is
 ## shown as well. If @var{path_to_jars} and/or @var{path_to_ooo} was supplied,
 ## chk_spreadsheet_support indicates for each individual Java-based interface
 ## whether it could add the required Java class libs.
 ##
 ## @item 3
 ## Like 2, also presence of individual javaclass libs in javaclasspath is
 ## indicated. If @var{path_to_jars} and/or @var{path_to_ooo} was supplied,
 ## chk_spreadsheet_support reports for each individual Java-based interface
 ## which required Java class libs it could find and add to the javaclasspath.
 ##
 ## @item -1 (or any negative number)
 ## Remove all directories and Java class libs that chk_spreadsheet_support
 ## added to the javaclasspath. If @var{debug_level} < 1 report number of 
-## removed javclasspath entries; if @var{debug_level} < 2 report each
+## removed javaclasspath entries; if @var{debug_level} < 2 report each
 ## individual removed entry.
 ## @noindent
 ## @end table
 ##
 ## Output:
 ## @var{retval} = 0: only spreadsheet support for OOXML & ODS 1.2
 ## and read support for gnumeric present through OCT interface, or
 ## @var{retval} <> 0: At least one read/write spreadsheet I/O
@@ -365,17 +365,17 @@ function  [ retval, s_interfaces, jars_l
       printf ("Trying to add missing java class libs to javaclasspath...\n");
     endif
     if (! ischar (path_to_jars))
       printf ("Path expected for arg # 1\n");
       return;
     endif
     ## First combine all entries
     targt = numel (missing);
-    ## For each interface, search tru list of missing entries
+    ## For each interface, search thru list of missing entries
     for ii=1:6   ## Adapt number in case of future new interfaces
       tmpm = eval ([ "missing" char(ii + "0") ]);
       tmpmcnt = numel (tmpm);
       if (tmpmcnt)
         for jj=1:numel (tmpm)
           if (iscellstr (tmpm{jj}))
             rtval = 0; kk = 1;
             while (kk <= numel (tmpm{jj}) && isnumeric (rtval))
diff --git a/inst/dbfwrite.m b/inst/dbfwrite.m
--- a/inst/dbfwrite.m
+++ b/inst/dbfwrite.m
@@ -14,17 +14,18 @@
 ## You should have received a copy of the GNU General Public License
 ## along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 ## -*- texinfo -*-
 ## @deftypefn  {Function File} [@var{status}] = dbfwrite (@var{fname}, @var{data})
 ## Write data in a cell array to a dbf (xBase) file, provisionally dBase III+.
 ##
 ## @var{fname} must be a valid file name, optionally with '.dbf' suffix.
-## @var{data} should be a cell array of which the top row contains column
+##
+## @var{data} must be a cell array of which the top row contains column
 ## names (character strings, each max. 10 characters).  Each column must
 ## contain only one class of data, except of course the top entry (the column
 ## header).  Integers interspersed in double type colums will be written as
 ## doubles.  Data types that can be written are character (text string),
 ## numeric (integer and float, the latter with 6 decimal places), and logical.
 ##
 ## Output argument @var{status} is 1 if the file was written successfully, 0
 ## otherwise.
diff --git a/inst/fexist.m b/inst/fexist.m
--- a/inst/fexist.m
+++ b/inst/fexist.m
@@ -26,17 +26,17 @@
 ## @item S: socket
 ## @end itemize
 ##
 ## The query is true if the actual file type matches any of 
 ## the specified options.
 ##
 ## @var{aspec} is a combination of letters r,w,x, corresponding
 ## to queried access privileges to the file. The query is true
-## if the current user has all the spefied types of access, either
+## if the current user has all the specified types of access, either
 ## through "user", "group" or "other" specs.
 ##
 ## @seealso{stat, lstat}
 ## @end deftypefn
 
 function ex = fexist (file, tspec, aspec)
 s = stat (file);
 if (isempty (s))
diff --git a/inst/object2json.m b/inst/object2json.m
--- a/inst/object2json.m
+++ b/inst/object2json.m
@@ -8,49 +8,49 @@
 %% This program is distributed in the hope that it will be useful, but WITHOUT
 %% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 %% FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 %% details.
 %%
 %% You should have received a copy of the GNU General Public License along with
 %% this program; if not, see <http://www.gnu.org/licenses/>.
 
-%% Returns a valid json string that will describe object; the string will
+%% Returns a valid JSON string that will describe object; the string will
 %% be in a compact form (no spaces or line breaks).
 %%
 %% It will map simple octave values this way:
 %%   function handles: string with the name of the function
 %%   double (numbers): depends:
 %%     If it's real it will map to a string representing that number
 %%     If it's complex it will map to an object with the next properties:
 %%       real: real part of the number
 %%       imag: imaginary part of the number
 %%   char: A string enclosed by double quotes representing that character
 %%   logical: text sring "true" or "false" (w/o double quotes)
 %% And will map more complex octave values this other way:
 %%   struct: an object with properties equal to the struct's field names
 %%     and value equal to the json counterpart of that field
 %%   cell: it will be mapped depending on the value of the cell (for
 %%     example {i} will be mapped to an object with real=0 and imag=1)
-%%   vectors or cell arrays: it will map them to a corresponding js
-%%     array (same size) with the values transformed to their json
-%%     counterpart (Note: that in javascript all arrays are like octave's
-%%     cells ,i.e. they can store different type and size variables)
+%%   vectors or cell arrays: it will map them to a corresponding JSON
+%%     array (same size) with the values transformed to their JSON
+%%     counterpart (Note: that in JavaScript, all arrays are like octave's
+%%     cells, i.e. they can store different type and size variables)
 %%   strings or char vectors: they will be mapped to the same string
 %%     enclosed by double quotes
 %% Other octave values will be mapped to a string enclosed by double
-%% quotes with the value that the class() function returns
+%% quotes with the value that the class() function returns.
 %% It can handle escape sequences and special chars automatically.
-%% If they're valid in JSON it will keep them if not they'll be
-%% escaped so they can become valid
+%% If they're valid in JSON it will keep them; if not they'll be
+%% escaped so they can become valid.
 
 %% object2json.m
 %% Created: 2010-12-06
 %% Updates:
-%% 2011-01-23 Added support for especial chars and escaped sequences
+%% 2011-01-23 Added support for special chars and escaped sequences
 %% 2011-04-01 Fixed error: Column vectors not working correctly
 %% 2011-09-08 (Philip Nienhuis) layout & style changes cf. Octave coding style
 %% 2011-08-13 (Keith Sheppard) Added logical types to object2json (bug #39429)
 
 function json = object2json (object)
   
   s = size (object);
   if (all (s==1))
@@ -121,17 +121,17 @@ function json = object2json (object)
         json = [ json, sep, object2json(reshape(object(tmp, :), s(2:end))) ];
         sep = ',';
       endfor
       json(end+1) = ']';
 
     else
       % We can have three cases here:
       % Object is a row -> array with all the elements
-      % Object is a column -> each element is an array in it's own
+      % Object is a column -> each element is an array in its own
       % Object is a 2D matrix -> separate each row
       if (s(1) == 1)
         % Object is a row
         if (ischar (object))
           % If it's a row of chars we will take it as a string
           % JSON only admits the next escape sequences:
           % \", \\, \/, \b, \f, \n, \r, \t and \u four-hex-digits
           % so we must be sure that every other sequence gets replaced
@@ -170,19 +170,19 @@ function json = object2json (object)
   endif
 
 endfunction
 
 
 % JSON only admits the next escape sequences:
 % \", \\, \/, \b, \f, \n, \r, \t and \u four-hex-digits
 % This function replace every escaped sequence that isn't on that list
-% with a compatible version
+% with a compatible version.
 % Note that this function uses typeinfo so it may need to be updated
-% with each octave release
+% with each octave release.
 
 function object = replace_non_JSON_escapes (object)
 
   if (strcmp (typeinfo (object), 'string'))
     % It's a double quoted string so newlines and other chars need
     % to be converted back into escape sequences before anything
     object = undo_string_escapes (object);
   endif
diff --git a/inst/oct2ods.m b/inst/oct2ods.m
--- a/inst/oct2ods.m
+++ b/inst/oct2ods.m
@@ -46,29 +46,29 @@
 ##
 ## If @var{range} is omitted, the top left cell where the data will be
 ## put is supposed to be 'A1'; only a top left cell address can be
 ## specified as well.  In these cases the actual range to be used is
 ## determined by the size of @var{arr}.  If defined in the spreadsheet
 ## file, a "Named range" can also be specified.  In that case @var{wsh}
 ## will be ignored and the worksheet associated with the specified
 ## Named range will be used.
-## Be aware that large data array sizes may exhaust the java shared
+## Be aware that large data array sizes may exhaust the Java shared
 ## memory space.  For larger arrays, appropriate memory settings are
 ## needed in the file java.opts; then the maximum array size for the
-## java-based spreadsheet options can be in the order of perhaps 10^6
+## Java-based spreadsheet options can be in the order of perhaps 10^6
 ## elements.
 ##
 ## Optional argument @var{options}, a structure, can be used to specify
 ## various write modes.
 ## @table @asis
 ## @item "formulas_as_text"
-## If set to 1 or TRUE formula strings ( i.e., text strings (assumed to
-## start with "=" and end in a ")" ) are to be written as litteral
-## text strings rather than as spreadsheet formulas (the latter is the
+## If set to 1 or TRUE formula strings (i.e., text strings (assumed to
+## start with "=" and end in a ")") are to be written as literal
+## text strings rather than as spreadsheet formulas. (The latter is the
 ## default).  As jOpenDocument doesn't support formula I/O at all yet,
 ## this option is ignored for the JOD interface.
 ##
 ## @item 'convert_utf'
 ## If set to 1 or TRUE, oct2ods converts one-byte characters outside the
 ## range [32:127] to UTF-8 so that they are properly entered as UTF-8
 ## encoded text in spreadsheets.  The default value is 0.
 ## @end table
@@ -188,43 +188,43 @@ function [ ods, rstatus ] = oct2ods (c_a
       conv_fcn = @(str) unicode2native (native2unicode (uint8 (str)), "UTF-8");
     else
       conv_fcn = @unicode2utf8;
     endif
     c_arr = tidyxml (c_arr, conv_fcn);
   endif
 
   if (strcmp (ods.xtype, "OTK"))
-    ## Write ods file tru Java & ODF toolkit.
+    ## Write ods file thru Java & ODF toolkit.
     switch ods.odfvsn
       case "0.7.5"
         [ ods, rstatus ] = __OTK_oct2ods__ (c_arr, ods, wsh, crange, spsh_opts);
       case {"0.8.6", "0.8.7", "0.8.8"}
         [ ods, rstatus ] = __OTK_oct2spsh__ (c_arr, ods, wsh, crange, spsh_opts);
       otherwise
         error ("oct2ods: unsupported odfdom version\n");
     endswitch
 
   elseif (strcmp (ods.xtype, "JOD"))
-    ## Write ods file tru Java & jOpenDocument. API still leaves lots to be wished...
+    ## Write ods file thru Java & jOpenDocument. API still leaves lots to be wished...
     [ ods, rstatus ] = __JOD_oct2spsh__ (c_arr, ods, wsh, crange);
 
   elseif (strcmp (ods.xtype, "UNO"))
-    ## Write ods file tru UNO
+    ## Write ods file thru UNO
     [ ods, rstatus ] = __UNO_oct2spsh__ (c_arr, ods, wsh, crange, spsh_opts);
 
   elseif (strcmp (ods.xtype, "OCT"))
     ## Replace illegal XML characters by XML escape sequences
     idx = cellfun (@ischar, c_arr);
     c_arr(idx) = strrep (c_arr(idx), "&", "&amp;" );
     c_arr(idx) = strrep (c_arr(idx), "<", "&lt;"  );
     c_arr(idx) = strrep (c_arr(idx), ">", "&gt;"  );
     c_arr(idx) = strrep (c_arr(idx), "'", "&apos;");
     c_arr(idx) = strrep (c_arr(idx), '"', "&quot;");
-    ## Write ods or gnumeric file tru native Octave
+    ## Write ods or gnumeric file thru native Octave
     [ ods, rstatus ] = __OCT_oct2spsh__ (c_arr, ods, wsh, crange, spsh_opts);
 
   ##elseif 
     ##---- < Other interfaces here >
 
   else
     error (sprintf ("ods2oct: unknown OpenOffice.org .ods interface - %s.\n",...
                     ods.xtype));
diff --git a/inst/oct2xls.m b/inst/oct2xls.m
--- a/inst/oct2xls.m
+++ b/inst/oct2xls.m
@@ -62,34 +62,34 @@
 ## corresponding to the top or left Excel cells of those merged cells
 ## will be written, other array cells corresponding to that cell will be
 ## ignored.
 ##
 ## Optional argument @var{options}, a structure, can be used to specify
 ## various write modes.
 ## @table @asis
 ## @item "formulas_as_text"
-## If set to 1 or TRUE formula strings ( i.e., text strings (assumed to
-## start with "=" and end in a ")" ) are to be written as litteral
-## text strings rather than as spreadsheet formulas (the latter is the
+## If set to 1 or TRUE formula strings (i.e., text strings (assumed to
+## start with "=" and end in a ")") are to be written as literal
+## text strings rather than as spreadsheet formulas. (The latter is the
 ## default).
 ##
 ## @item 'convert_utf'
 ## If set to 1 or TRUE, oct2xls converts one-byte characters outside the
 ## range [32:127] to UTF-8 so that they are properly entered as UTF-8
 ## encoded text in spreadsheets.  The default value is 0.
 ## This setting has no effect for the COM interface as that does the
 ## encoding automatically using libraries outside Octave.
 ## @end table
 ##
 ## Beware that -if invoked- Excel invocations may be left running silently
 ## in case of COM errors.  Invoke xlsclose with proper pointer struct to
 ## close them.
 ## When using Java, note that large data array sizes elements may exhaust
-## the Java shared memory space for the default java memory settings.
+## the Java shared memory space for the default Java memory settings.
 ## For larger arrays, appropriate memory settings are needed in the file
 ## java.opts; then the maximum array size for the Java-based spreadsheet
 ## options may be in the order of 10^6 elements.  In caso of UNO this
 ## limit is not applicable and spreadsheets may be much larger.
 ##
 ## Examples:
 ##
 ## @example
diff --git a/inst/ods2oct.m b/inst/ods2oct.m
--- a/inst/ods2oct.m
+++ b/inst/ods2oct.m
@@ -160,40 +160,40 @@ function [ rawarr, ods, rstatus ] = ods2
         spsh_opts.convert_utf = 0;
     endif
     ## Future options:
 
   endif
 
   ## Select the proper interfaces
   if (strcmp (ods.xtype, "OTK"))
-    ## Read ods file tru Java & ODF toolkit
+    ## Read ods file thru Java & ODF toolkit
     switch ods.odfvsn
       case "0.7.5"
         [rawarr, ods, rstatus] = __OTK_ods2oct__ (ods, wsh, datrange, spsh_opts);
       case {"0.8.6", "0.8.7", "0.8.8"}
         [rawarr, ods, rstatus] = __OTK_spsh2oct__ (ods, wsh, datrange, spsh_opts);
       otherwise
         error ("Unsupported odfdom version or invalid ods file pointer.\n");
     endswitch
   elseif (strcmp (ods.xtype, "JOD"))
-    ## Read ods file tru Java & jOpenDocument. First check for formula support
+    ## Read ods file thru Java & jOpenDocument. First check for formula support
     if ((ods.odfvsn < 4) && spsh_opts.formulas_as_text)
       ## Not supported in jOpenDucument < 1.3
       warning (["ods2oct.m: option 'formulas_as_text' not supported\n", ...
                 "in jOpenDocument < 1.3; please upgrade. Option ignored.\n"]);
       spsh_opts.formulas_as_text = 0;
     endif
     [rawarr, ods, rstatus] = __JOD_spsh2oct__ (ods, wsh, datrange, spsh_opts);
   elseif (strcmp (ods.xtype, "UNO"))
-    ## Read ods file tru Java & UNO
+    ## Read ods file thru Java & UNO
     [rawarr, ods, rstatus] = __UNO_spsh2oct__ (ods, wsh, datrange, spsh_opts);
   elseif (strcmp (ods.xtype, "OCT"))
     if (strcmpi (ods.app, "ods"))
-      ## Read ods file tru native Octave
+      ## Read ods file thru native Octave
       [rawarr, ods, rstatus] = __OCT_ods2oct__ (ods, wsh, datrange, spsh_opts);
     elseif (strcmpi (ods.app, "gnumeric"))
       ## Read gnumeric. Gnumeric does not support formula evaluation nor supports
       ## cached values. Stripping output is processed below, spsh_opts is ignored
       [rawarr, ods, rstatus] = __OCT_gnm2oct__ (ods, wsh, datrange);
     endif
     ## Replace XML escape sequences by regular characters
     idx = cellfun (@ischar, rawarr);
diff --git a/inst/odsclose.m b/inst/odsclose.m
--- a/inst/odsclose.m
+++ b/inst/odsclose.m
@@ -13,23 +13,23 @@
 ## You should have received a copy of the GNU General Public License along with
 ## this program; if not, see <http://www.gnu.org/licenses/>.
 
 ## -*- texinfo -*-
 ## @deftypefn {Function File} [@var{ods}] = odsclose (@var{ods})
 ## @deftypefnx {Function File} [@var{ods}] = odsclose (@var{ods}, @var{filename})
 ## @deftypefnx {Function File} [@var{ods}] = odsclose (@var{ods}, "FORCE")
 ## Close the OpenOffice_org Calc / Gnumeric spreadsheet pointed to in struct
-## @var{ods}, if needed write the file to disk.
+## @var{ods}, and if needed write the file to disk.
 ##
 ## odsclose will determine if the file must be written to disk based on
 ## information contained in @var{ods}.
 ## An empty pointer struct will be returned if no errors occurred. 
 ## Optional argument @var{filename} can be used to write changed spreadsheet
-## files to an other file than opened by odsopen().
+## files to a file other than that opened by odsopen().
 ## Optional string argument "FORCE" can be specified to force resetting the
 ## file pointer struct.  However, in case of UNO, a hidden OOo invocation
 ## may linger on in memory then, preventing proper closing of Octave.
 ##
 ## @var{ods} must be a valid pointer struct made by odsopen() in the same
 ## octave session.
 ##
 ## Examples:
diff --git a/inst/odsopen.m b/inst/odsopen.m
--- a/inst/odsopen.m
+++ b/inst/odsopen.m
@@ -28,36 +28,36 @@
 ## XML, in principle no external SW is required, this "interface" is called
 ## 'OCT'.  For more flexibility and better performance, you need a Java JRE
 ## or JDK plus one or more of (ODFtoolkit (version 0.7.5 or 0.8.6 - 0.8.8) &
 ## xercesImpl v.2.9.1), jOpenDocument, or OpenOffice.org (or clones) installed
 ## on your computer + proper javaclasspath set.  These interfaces are referred
 ## to as OTK, JOD, and UNO resp., and are preferred in that order by default
 ## (depending on their presence; the OCT interface has lowest priority).
 ## The relevant Java class libs for spreadsheet I/O had best be added to the
-## javaclasspath by utility function chk_spreadsheet_support().
+## javaclasspath by the utility function chk_spreadsheet_support().
 ##
 ## @var{filename} must be a valid .ods OpenOffice.org Calc, or Gnumeric, file
 ## name including .ods or .gnumeric suffix.  If @var{filename} does not contain
 ## any directory path, the file is saved in the current directory.  For UNO
 ## bridge, filenames need to be in the form "file:///<path_to_file>/filename";
 ## a URL will also work. If a plain file name is given (absolute or relative),
 ## odsopen() will try to transform it into a proper form.
 ##
 ## @var{readwrite} must be set to true or numerical 1 if writing to spreadsheet
 ## is desired immediately after calling odsopen().  It merely serves proper
 ## handling of file errors (e.g., "file not found" or "new file created").
 ##
 ## Optional input argument @var{reqintf} can be used to override the ODS
 ## interface automatically selected by odsopen.  Currently implemented
 ## interfaces are 'OTK' (Java/ODF Toolkit), 'JOD' (Java/jOpenDocument), 'UNO'
-## (Java/OpenOffice.org UNO bridge), and 'OCT' (native Octave, for Gnumeric.
+## (Java/OpenOffice.org UNO bridge), and 'OCT' (native Octave), for Gnumeric.
 ## In most situations this parameter is unneeded as odsopen
 ## automatically selects the most useful interface present ("default
-## interface").  Depending on file type, odsopen.m can invoke other detected
+## interface").  Depending on file type, odsopen can invoke other detected
 ## interfaces than the default one.
 ##
 ## Beware:
 ## The UNO interface is still experimental.  While in itself reliable, it may
 ## have undesired side effects on Open-/LibreOffice windows outside Octave.
 ##
 ## Examples:
 ##
@@ -146,17 +146,17 @@ function [ ods ] = odsopen (filename, rw
         endif
       endfor
 
       printf ("Checking requested interface(s):\n");
       odsinterfaces = getodsinterfaces (odsinterfaces);
       ## Well, is/are the requested interface(s) supported on the system?
       for ii=1:numel (reqinterface)
         if (! odsinterfaces.(toupper (reqinterface{ii})))
-          ## No it aint
+          ## No it ain't
           printf ("%s is not supported.\n", toupper (reqinterface{ii}));
         else
           ++odsintf_cnt;
         endif
       endfor
       ## Reset interface check indicator if no requested support found
       if (! odsintf_cnt)
         chkintf = [];
@@ -280,15 +280,15 @@ function [ ods ] = odsopen (filename, rw
   else
     # From here on rw is tracked via ods.changed in the various lower
     # level r/w routines and it is only used to determine if an informative
     # message is to be given when saving a newly created ods file.
     ods.changed = rw;
 
     # ods.changed = 0 (existing/only read from), 1 (existing/data added), 2 (new,
     # data added) or 3 (pristine, no data added).
-    # Until something was written to existing files we keep status "unchanged".
+    # Until something is written to existing files we keep status "unchanged".
     if (ods.changed == 1);
       ods.changed = 0;
     endif
   endif
 
 endfunction
diff --git a/inst/odsread.m b/inst/odsread.m
--- a/inst/odsread.m
+++ b/inst/odsread.m
@@ -20,17 +20,17 @@
 ## @deftypefnx {Function File} [@var{numarr}, @var{txtarr}, @var{rawarr}, @var{limits}, @var{extout}] = odsread (@var{filename}, @var{wsh}, @var{range}, @var{OPTS}, @dots{})
 ##
 ## Read data contained in cell range @var{range} in worksheet @var{wsh}
 ## in OpenOffice_org Calc spreadsheet file @var{filename}.  Reading
 ## Gnumeric xml files is also supported.
 ##
 ## @var{filename} should include the filename extension (e.g., .ods).
 ##
-## @var{wsh} is either numerical or text, in the latter case it is 
+## @var{wsh} is either numerical or text. If text, it is 
 ## case-sensitive and it should conform to OpenOffice.org Calc or
 ## Gnumeric sheet name requirements.
 ## Note that in case of a numerical @var{wsh} this number refers to the
 ## position in the worksheet stack, counted from the left in a Calc
 ## window.  The default is numerical 1, i.e. the leftmost worksheet
 ## in the Calc file.
 ##
 ## @var{range} is expected to be a regular spreadsheet range format,
@@ -55,18 +55,18 @@
 ## supplied in any desired order:
 ##
 ## @table @asis
 ## @item @var{Interface}
 ## @var{Interface} (a three-character text sting) can be used to
 ## override the automatic interface selection by odsread out of the
 ## supported ones: Java/ODFtoolkit ('OTK'), Java/jOpenDocument ('JOD'),
 ## Java/UNO bridge ('UNO'), or native Octave (OCT).  Octave selects one
-## of these, preferrably in the order above, based on presence of
-## support software and the file at hand.  In addition the OCT interface
+## of these, preferably in the order above, based on presence of
+## support software and the file at hand.  In addition, the OCT interface
 ## offers .gnumeric read support.
 ## @end item
 ##
 ## @item Function handle
 ## If a function handle is specified, the pertinent function (having at
 ## most two output arrays) will be applied to the numeric output data of
 ## odsread.  Any second output of the function will be in a 5th output
 ## argument @var{extout} of odsread.
@@ -109,17 +109,17 @@
 ## experimental; it offers .gnumeric read support as well.
 ## For ODS only the supported Java-based interfaces offer more flexibility
 ## and better speed.  For those you need a Java JRE or JDK and one or both
 ## of jopendocument-<version>.jar or preferrably: (odfdom.jar (versions
 ## 0.7.5 or 0.8.6-0.8.8) & xercesImpl.jar v. 2.9.1) in your javaclasspath.
 ## There is also experimental support invoking OpenOffice.org/LibreOffice
 ## or clones through a Java/UNO bridge.
 ##
-## odsread.m is just a wrapper for a collection of scripts that find out
+## odsread is just a wrapper for a collection of functions that find out
 ## the interface to be used and do the actual reading.  For each call
 ## to odsread the interface must be started and the spreadsheet file read into
 ## memory.  When reading multiple ranges (in optionally multiple worksheets)
 ## a significant speed boost can be obtained by invoking those scripts
 ## directly (odsopen / ods2oct [/ parsecell] / ... / odsclose).  This also 
 ## offers more flexibility (e.g. formula results or the formulas
 ## themselves; stripping output arrays from empty enveloping rows/columns).
 ##
diff --git a/inst/odswrite.m b/inst/odswrite.m
--- a/inst/odswrite.m
+++ b/inst/odswrite.m
@@ -52,17 +52,17 @@
 ## with the specified Named range will be used.
 ## Array @var{arr} will be clipped at the right and/or bottom if its size
 ## is bigger than can be accommodated in @var{range}.
 ## If @var{arr} is smaller than the @var{range} allows, it is placed
 ## in the top left rectangle of @var{range} and cell values outside that
 ## rectangle will be untouched.
 ## If the third argument is a sheet name and @var{range} is specified as
 ## just one cell, it is taken as the topleft cell and the bottomright
-## cell range address is determinded form the data.
+## cell range address is determined form the data.
 ##
 ## If @var{range} contains merged cells, only the elements of @var{arr}
 ## corresponding to the top or left Calc cells of those merged cells
 ## will be written, other array cells corresponding to that cell will be
 ## ignored.
 ##
 ## The optional last argument @var{reqintf} can be used to override 
 ## the automatic selection by odswrite of one interface out of the
@@ -73,25 +73,25 @@
 ##
 ## odswrite is a mere wrapper for various scripts which find out what
 ## ODS interface to use (ODF toolkit, jOpenDocument, Open/LibreOffice or
 ## native Octave) plus code to mimic the other brand's xlswrite syntax
 ## (and quirks).
 ## For each call to odswrite such an interface must be started and
 ## possibly an ODS file loaded.  When writing to multiple ranges and/or
 ## worksheets in the same ODS file, a speed bonus can be obtained by
-## invoking those scripts (odsopen / octods / .... / odsclose) directly.
+## invoking those scripts (odsopen / oct2ods / .... / odsclose) directly.
 ##
 ## Example:
 ##
 ## @example
 ##   status = odswrite ('test4.ods', 'arr', 'Eight_sheet', 'C3:AB40');
 ##   (which adds the contents of array arr (any type) to range C3:AB40 
 ##   in sheet 'Eight_sheet' in file test4.ods and returns a logical 
-##   True (= numerical 1) in status if al went well) 
+##   True (= numerical 1) in status if all went well) 
 ## @end example
 ##
 ## @seealso {odsread, oct2ods, ods2oct, odsopen, odsclose, odsfinfo}
 ##
 ## @end deftypefn
 
 ## Author: Philip Nienhuis <pr.nienhuis at users.sf.net>
 ## Created: 2009-12-14
diff --git a/inst/parsecell.m b/inst/parsecell.m
--- a/inst/parsecell.m
+++ b/inst/parsecell.m
@@ -18,17 +18,17 @@
 ## @deftypefnx {Function File} [ @var{numarr}, @var{txtarr}, @var{lim} ] = parsecell (@var{rawarr}, @var{limits})
 ##
 ## Divide a heterogeneous 2D cell array into a 2D numeric array and a
 ## 2D cell array containing only strings. Both returned arrays are
 ## trimmed from empty outer rows and columns.
 ## This function is particularly useful for parsing cell arrays returned
 ## by functions reading spreadsheets (e.g., xlsread, odsread).
 ##
-## Optional return argument @var{lim} contains two field with the outer
+## Optional return argument @var{lim} contains two fields with the outer
 ## column and row numbers of @var{numarr} and @var{txtarr} in the
 ## original array @var{rawarr}.
 ## Optional input argument @var{limits} can either be the spreadsheet
 ## data limits returned in the spreadsheet file pointer struct
 ## (field xls.limits or ods.limits), or the file ptr struct itself.
 ## If one of these is specified, optional return argument @var{lim}
 ## will contain the real spreadsheet row & column numbers enclosing
 ## the origins of the numerical and text data returned in @var{numarr}
@@ -88,17 +88,17 @@ function [ numarr, txtarr, lim ] = parse
  
     ## Find text entries in raw data cell array
     txtptr = cellfun ("isclass", rawarr, "char");
     if (~no_txt)
       ## Prepare text array. Create placeholder for text cells
       txtarr = cell (size (rawarr));
       txtarr(:) = {""};
       if (any (any (txtptr)))
-        ## Copy any text cells found into place holder
+        ## Copy any text cells found into placeholder
         txtarr(txtptr) = rawarr(txtptr);
         ## Clean up text array (find leading / trailing empty
         ## rows & columns)
         irowt = 1;
         while (! any (txtptr(irowt, :))); irowt++; endwhile
         irowb = nrows;
         while (! any (txtptr(irowb, :))); irowb--; endwhile
         icoll = 1;
diff --git a/inst/pch2mat.m b/inst/pch2mat.m
--- a/inst/pch2mat.m
+++ b/inst/pch2mat.m
@@ -21,19 +21,19 @@
 %% OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 %% OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 %% -*- texinfo -*-
 %% @deftypefn {Function File} {@var{data} =} pch2mat (@var{filename})
 %% Converts NASTRAN PCH file (SORT2) to a data structure and frequency vector. A
 %% filename as a string is the only needed input.
 %%
-%% The output is in the form of struct. containing a freq vector n x 1 called
+%% The output is in the form of struct containing a freq vector n x 1 called
 %% data.f, and the remaining data are in the form of subcases, point ids
-%% and directions respectively. for ex. data.S1.p254686.x and they are n x 2
+%% and directions respectively. E.g. data.S1.p254686.x and they are n x 2.
 %%
 %% @end deftypefn
 
 function [data] = pch2mat(filename);
 
     %% Open the file and read the file line by line to form a line character array
     fid = fopen(filename);
     l = 1;
diff --git a/inst/xls2oct.m b/inst/xls2oct.m
--- a/inst/xls2oct.m
+++ b/inst/xls2oct.m
@@ -24,17 +24,17 @@
 ## files can be read as well.
 ##
 ## @var{xls} is supposed to have been created earlier by xlsopen in the
 ## same octave session.
 ##
 ## @var{wsh} is either numerical or text, in the latter case it is 
 ## case-sensitive and it may be max. 31 characters long.
 ## Note that in case of a numerical @var{wsh} this number refers to the
-## position in the total sheet stack, counted from the left in an spreadsheet
+## position in the total sheet stack, counted from the left in a spreadsheet
 ## program window.  The default is numerical 1, i.e. corresponding to the
 ## leftmost sheet tab in the spreadsheet file.
 ##
 ## @var{range} is expected to be either a regular spreadsheet range
 ## format, "" (empty string, indicating all data in a worksheet), or a
 ## "Named range" defined in the spreadsheet file.  In case of a Named
 ## range, the worksheet associated with that Named range will be used
 ## instead of the one specified in @var{wsh}.
@@ -49,24 +49,24 @@
 ## to true (1) or false (0).  Currently recognized option fields are:
 ##
 ## @table @asis
 ## @item "formulas_as_text"
 ## If set to TRUE or 1, spreadsheet formulas (if at all present)
 ## are read as formula strings rather than the evaluated formula
 ## result values.  The default value is 0 (FALSE).
 ##
-## @item 'strip_array'
+## @item "strip_array"
 ## Set the value of this field set to TRUE or 1 to strip the returned
 ## output array @var{rawarr} from empty outer columns and rows. The
 ## spreadsheet cell rectangle limits from where the data actually
 ## came will be updated.  The default value is FALSE or 0 (no cropping).
 ## When using the COM interface, the output array is always cropped.
 ##
-## @item 'convert_utf'
+## @item "convert_utf"
 ## If set to 1 or TRUE, xls2oct tries to do a best job of converting
 ## UTF-8 characters to one-byte characters so that they display
 ## properly in Octave if that uses a terminal that does not support
 ## UTF-8 encoding (e.g., Windows 7 and below).
 ## For the COM interface this conversion is done by libraries
 ## outside Octave so for COM this option has no effect.
 ## @end table
 ##
@@ -178,32 +178,32 @@ function [ rawarr, xls, rstatus ] = xls2
     ## Future options:
 
   else
     error ("Structure expected for arg # 4 (options)\n");
   endif
 
   ## Select the proper interfaces
   if (strcmp (xls.xtype, "COM"))
-    ## Call Excel tru COM / ActiveX server
+    ## Call Excel thru COM / ActiveX server
     [rawarr, xls, rstatus] = __COM_spsh2oct__ (xls, wsh, datrange, spsh_opts);
   elseif (strcmp (xls.xtype, "POI"))
-    ## Read xls file tru Java POI
+    ## Read xls file thru Java POI
     [rawarr, xls, rstatus] = __POI_spsh2oct__ (xls, wsh, datrange, spsh_opts);
   elseif (strcmp (xls.xtype, "JXL"))
-    ## Read xls file tru JExcelAPI
+    ## Read xls file thru JExcelAPI
     [rawarr, xls, rstatus] = __JXL_spsh2oct__ (xls, wsh, datrange, spsh_opts);
   elseif (strcmp (xls.xtype, "OXS"))
-    ## Read xls file tru OpenXLS
+    ## Read xls file thru OpenXLS
     [rawarr, xls, rstatus] = __OXS_spsh2oct__ (xls, wsh, datrange, spsh_opts);
   elseif (strcmp (xls.xtype, "UNO"))
-    ## Read xls file tru OpenOffice.org UNO (Java) bridge
+    ## Read xls file thru OpenOffice.org UNO (Java) bridge
     [rawarr, xls, rstatus] = __UNO_spsh2oct__ (xls, wsh, datrange, spsh_opts);
   elseif (strcmp (xls.xtype, "OCT"))
-    ## Read xls file tru native Octave
+    ## Read xls file thru native Octave
     if (strcmpi (xls.app, "xlsx"))
       [rawarr, xls, rstatus] = __OCT_xlsx2oct__ (xls, wsh, datrange, spsh_opts);
     elseif (strcmpi (xls.app, "gnumeric"))
       [rawarr, xls, rstatus] = __OCT_gnm2oct__ (xls, wsh, datrange);
     elseif (strcmpi (xls.app, "ods"))
       [rawarr, xls, rstatus] = __OCT_ods2oct__ (xls, wsh, datrange, spsh_opts);
     else
       error ("xls2oct.m: file format not supported for OCT interface\n");
diff --git a/inst/xlsclose.m b/inst/xlsclose.m
--- a/inst/xlsclose.m
+++ b/inst/xlsclose.m
@@ -12,34 +12,34 @@
 ##
 ## You should have received a copy of the GNU General Public License along with
 ## this program; if not, see <http://www.gnu.org/licenses/>.
 
 ## -*- texinfo -*-
 ## @deftypefn {Function File} [@var{xls}] = xlsclose (@var{xls})
 ## @deftypefnx {Function File} [@var{xls}] = xlsclose (@var{xls}, @var{filename})
 ## @deftypefnx {Function File} [@var{xls}] = xlsclose (@var{xls}, "FORCE")
-## Close the Excel spreadsheet pointed to in struct @var{xls}, if needed
+## Close the Excel spreadsheet pointed to in struct @var{xls}, and if needed
 ## write the file to disk.  Based on information contained in @var{xls},
 ## xlsclose will determine if the file should be written to disk.
 ##
 ## If no errors occured during writing, the xls file pointer struct will be
-## reset and -if COM interface was used- ActiveX/Excel will be closed.
-## However if errors occurred, the file pointer will be untouched so you can
+## reset and - if COM interface was used - ActiveX/Excel will be closed.
+## However, if errors occurred, the file pointer will be untouched so you can
 ## clean up before a next try with xlsclose().
 ## Be warned that until xlsopen is called again with the same @var{xls} pointer
 ## struct, hidden Excel or Java applications with associated (possibly large)
 ## memory chunks are kept in memory, taking up resources.
 ## If (string) argument "FORCE" is supplied, the file pointer will be reset 
 ## regardless, whether the possibly modified file has been saved successfully
 ## or not.  Hidden Excel (COM) or OpenOffice.org (UNO) invocations may live on,
 ## possibly even impeding proper shutdown of Octave.
 ##
 ## @var{filename} can be used to write changed spreadsheet files to
-## an other file than opened with xlsopen(); unfortunately this doesn't work
+## a file other than that opened with xlsopen(); unfortunately this doesn't work
 ## with JXL (JExcelAPI) interface.
 ##
 ## For other file formats than OOXML, ODS or gnumeric, you need MS-Excel
 ## and windows pkg loaded, and/or Apache POI > 3.5 and/or JExcelAPI and/or
 ## OpenXLS and/or OpenOffice.org or clones installed on your computer + proper
 ## javaclasspath set, to make this function work at all.
 ##
 ## @var{xls} must be a valid pointer struct made by xlsopen() in the same
diff --git a/inst/xlsfinfo.m b/inst/xlsfinfo.m
--- a/inst/xlsfinfo.m
+++ b/inst/xlsfinfo.m
@@ -21,30 +21,30 @@
 ## Query Excel spreadsheet file @var{filename} for some info about its
 ## contents.
 ##
 ## If @var{filename} is a recognizable Excel spreadsheet file,
 ## @var{filetype} returns the string "Microsoft Excel Spreadsheet", or
 ## @'' (empty string) otherwise.
 ## 
 ## If @var{filename} is a recognizable Excel spreadsheet file, optional
-## argument @var{sh_names} contains a Nx2 list (cell array) of sheet
+## return argument @var{sh_names} contains a Nx2 list (cell array) of sheet
 ## names (and in case Excel is installed: sheet types) and total used data
 ## range for each worksheet contained in @var{filename}, in the order
 ## (from left to right) in which they occur in the worksheet stack.
 ##
 ## Optional return value @var{fformat} currently returns @'' (empty
 ## string) unless @var{filename} is a readable Excel 97-2003 .xls file or
 ## an Excel 2007 .xlsx / .xlsb file in which case @var{fformat} is set to
 ## "xlWorkbookNormal".  Excel 95 .xls files can only be read through the JXL
 ## (JExcelAPI) or UNO (OpenOffice.org) Java-based interfaces.
 ##
 ## Optional return argument @var{nmranges} is a cell array containing all
 ## named data ranges in the file in the first column, the relevant sheet and
-## the cell range in the second and third column and if appropriate the
+## the cell range in the second and third column and, if appropriate, the
 ## scope of the range in the fourth column. For named ranges defined for
 ## the entire workbook the fourth column entry is empty.
 ## Named ranges only work for the COM, POI, OXS, UNO and OCT interfaces.
 ##
 ## If no return arguments are specified the sheet names are echoed to the 
 ## terminal screen; in case of Java interfaces for each sheet the actual
 ## occupied data range is echoed as well.  The occupied cell range will have
 ## to be determined behind the scenes first; this can take some time for the
@@ -67,18 +67,18 @@
 ##
 ## @example
 ##   exist = xlsfinfo ('test4.xls');
 ##   (Just checks if file test4.xls is a readable Excel file) 
 ## @end example
 ##
 ## @example
 ##   [exist, names] = xlsfinfo ('test4.xls');
-##   (Checks if file test4.xls is a readable Excel file and return a 
-##    list of sheet names and -types) 
+##   (Checks if file test4.xls is a readable Excel file and returns a 
+##    list of sheet names and types) 
 ## @end example
 ##
 ## @seealso {oct2xls, xlsread, xls2oct, xlswrite}
 ##
 ## @end deftypefn
 
 ## Author: Philip Nienhuis <prnienhuis at users.sourceforge.net>
 ## Created: 2009-10-27
diff --git a/inst/xlsread.m b/inst/xlsread.m
--- a/inst/xlsread.m
+++ b/inst/xlsread.m
@@ -81,18 +81,18 @@
 ## @item @var{Interface}
 ## @var{Interface} (a three-character text sting) can be used to override
 ## the automatic interface selection by xlsread out of the supported
 ## ones: COM/Excel, Java/Apache POI, Java/JExcelAPI, Java/OpenXLS,
 ## Java/UNO (OpenOffice.org), or native Octave (in that -built in-
 ## order of preference).
 ## For I/O to/from .xlsx files a value of 'com', 'poi', 'uno', or 'oct'
 ## must be specified for @var{reqintf} (see help for xlsopen).  For
-## Excel'95 files use 'com', or if Excel is not installed use 'jxl',
-## 'basic' or 'uno'. POI can't read Excel'95 but will try to fall back
+## Excel '95 files use 'com', or if Excel is not installed use 'jxl',
+## 'basic' or 'uno'. POI can't read Excel '95 but will try to fall back
 ## to JXL.  As @var{reqintf} can also be a cell array of strings, one
 ## can select or exclude one or more interfaces.
 ## In addition the OCT interface offers .gnumeric read support.
 ## @end item
 ##
 ## @item Function handle
 ## If a function handle is specified, the pertinent function (having at
 ## most two output arrays) will be applied to the numeric output data of
@@ -119,23 +119,23 @@
 ## so any returned array may turn out to be smaller than requested in
 ## @var{range}.  Use the fourth return argument @var{LIMS} for info on the
 ## cell ranges your date came from.
 ##
 ## When reading from merged cells, all array elements NOT corresponding 
 ## to the leftmost or upper Excel cell will be treated as if the
 ## "corresponding" Excel cells are empty.
 ##
-## xlsread is just a wrapper for a collection of scripts that find out
+## xlsread is just a wrapper for a collection of functions that find out
 ## the interface to be used (COM, Java/POI, Java/JXL Java/OXS, Java/UNO,
 ## OCT) and do the actual reading.  For each call to xlsread the interface
 ## must be started and the Excel file read into memory.  When reading
 ## multiple ranges (in optionally multiple worksheets) a significant speed
-## boost can be obtained by invoking those scripts directly as in:
-## xlsopen / xls2oct [/ parsecell] / ... / xlsclose
+## boost can be obtained by invoking those functions directly as in:
+## xlsopen / xls2oct [/ parsecell] / ... / xlsclose.
 ##
 ## Beware: when using the COM interface, hidden Excel invocations may be
 ## kept running silently if not closed explicitly.
 ##
 ## Examples:
 ##
 ## @example
 ##   A = xlsread ('test4.xls', '2nd_sheet', 'C3:AB40');
diff --git a/inst/xlswrite.m b/inst/xlswrite.m
--- a/inst/xlswrite.m
+++ b/inst/xlswrite.m
@@ -33,47 +33,47 @@
 ## @var{arr} can be any 1D or 2D array containing numerical, logical and/or
 ## character data (cellstr) except complex.  Mixed numeric/text arrays can
 ## only be cell arrays.
 ##
 ## If only 3 arguments are given, the 3rd is assumed to be a spreadsheet
 ## range if it contains a ":" or is a completely empty string (interpreted
 ## as A1:IV65336 for regular .xls or A1:XFD1048576 for OOXML .xlsx).  The
 ## 3rd argument is assumed to refer to a sheet if it is a numeric value
-## or a non-empty text string not containing ":"
+## or a non-empty text string not containing ":".
 ##
 ## @var{wsh} can be a number or string (max. 31 chars).
 ## In case of a not yet existing Excel file, the first worksheet will be
 ## used & named according to @var{wsh} - the extra worksheets that Excel
 ## usually creates by default are deleted (COM) or simply not created.
 ## In case of existing files, some checks are made for existing worksheet
 ## names or numbers, or whether @var{wsh} refers to an existing sheet with
 ## a type other than worksheet (e.g., chart).
 ## When new worksheets are to be added to the Excel file, they are
 ## inserted to the right of all existing sheets. The pointer to the
 ## "active" sheet (shown when Excel opens the file) remains untouched.
 ## If @var{wsh} is enetered as numeric value, it refers to the position in
-## the total number of visible sheets in the spreadsheet window, incl. e.g., 
-## chartsheets.
+## the total number of visible sheets in the spreadsheet window, including
+## e.g. chartsheets.
 ##
 ## @var{range} is expected to be a regular spreadsheet range.
 ## Data is added to the worksheet; existing data in the requested
 ## range will be overwritten.  Instead of a spreadsheet range a Named
 ## range defined in the spreadsheet file can be used as well. In that
 ## case the Named range should be specified as 4th argument and the value
 ## of 3rd argument @var{wsh} doesn't matter as the worksheet associated
 ## with the specified Named range will be used.
 ## Array @var{arr} will be clipped at the right and/or bottom if its size
 ## is bigger than can be accommodated in @var{range}.
 ## If @var{arr} is smaller than the @var{range} allows, it is placed
 ## in the top left rectangle of @var{range} and remaining cell values
 ## outside the rectangle will be retained.
 ## If the third argument is a sheet name and @var{range} is specified as
 ## just one cell, it is taken as the topleft cell and the bottomright
-## cell range address is determinded form the data.
+## cell range address is determinded from the data.
 ##
 ## If @var{range} contains merged cells, only the elements of @var{arr}
 ## corresponding to the top or left Excel cells of those merged cells
 ## will be written, other array cells corresponding to that merged cell
 ## will be ignored. In other words, merged spreadsheet cells won't be
 ## "unmerged".
 ##
 ## As to the optional last argument @var{reqintf}: 
@@ -101,17 +101,17 @@
 ## xlswrite is a mere wrapper for various scripts which find out what
 ## Excel interface to use (COM, POI, etc) plus code to mimic the other
 ## brand's syntax. For each call to xlswrite such an interface must be
 ## started and possibly an Excel file loaded. When writing to multiple
 ## ranges and/or worksheets in the same Excel file, a speed bonus can be
 ## obtained by invoking those scripts directly with multiple calls to
 ## oct2xls (one for each sheet or range) surrounded by one call to
 ## xlsopen and xlsclose:
-## (xlsopen / octxls / oct2xls / .... / xlsclose)
+## (xlsopen / oct2xls / .... / xlsclose).
 ##
 ## Examples:
 ##
 ## @example
 ##   status = xlswrite ...
 ##            ('test4.xls', 'arr', 'Third_sheet', 'C3:AB40');
 ##   (which adds the contents of array arr (any type) to
 ##    rangeC3:AB40 in worksheet 'Third_sheet' in file
diff --git a/inst/xmlread.m b/inst/xmlread.m
--- a/inst/xmlread.m
+++ b/inst/xmlread.m
@@ -12,17 +12,17 @@
 ## 
 ## You should have received a copy of the GNU General Public License
 ## along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 ## -*- texinfo -*- 
 ## @deftypefn {Function File} {@var{node} =} xmlread (@var{fname})
 ##
 ## Parse an xml file @var{fname} using Xerces Java library and return
-## a Java object representing an xml DOM document.
+## a Java object representing an XML DOM document.
 ##
 ## Octave does not ship with a Xerces library so you should take care
 ## of adding the required .jar files to your java_path, e.g:
 ## 
 ## @example
 ## @code{javaaddpath ("/path/to/xerces-2_11_0/xercesImpl.jar");}
 ## @code{javaaddpath ("/path/to/xerces-2_11_0/xml-apis.jar");}
 ## @end example
diff --git a/inst/xmlwrite.m b/inst/xmlwrite.m
--- a/inst/xmlwrite.m
+++ b/inst/xmlwrite.m
@@ -12,17 +12,17 @@
 ## 
 ## You should have received a copy of the GNU General Public License
 ## along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 ## -*- texinfo -*- 
 ## @deftypefn {Function File} {} xmlwrite (@var{fname}, @var{dom})
 ## @deftypefnx {Function File} {@var{str} =} xmlwrite (@var{dom})
 ##
-## Write an xml DOM document to file @var{fname} or to ouput string
+## Write an XML DOM document to file @var{fname} or to output string
 ## @var{str}.
 ## 
 ## The @var{dom} argument must be a DOM document object as returned by
 ## @code{xmlread} function.
 ##
 ## Octave does not ship with the necessary Xerces library so you
 ## should take care of adding the required .jar files to your
 ## javaclasspath, e.g:
diff --git a/src/csv2cell.cc b/src/csv2cell.cc
--- a/src/csv2cell.cc
+++ b/src/csv2cell.cc
@@ -207,17 +207,17 @@ array.\n\
 two fields. The default value is a comma (@code{,}).\n\
 \n\
 @var{prot} (a character value) changes the character used to protect \
 a string. The default is a double quote (@code{\"}).\n\
 \n\
 Optional argument @var{hl} (a numeric value >= 0) is the number of \
 headerlines to skip; negative values are ignored. If @var{hl} is \
 equal to or larger than the total number of lines in the file, no \
-data are read and an empty cell array is returned.\n\
+data is read and an empty cell array is returned.\n\
 \n\
 Alternatively, optional argument @var{range} can be specified as a \
 spreadsheet-style cell range to specify a block of fields to be \
 returned in @var{c}.  If the specified column range reaches beyond \
 the number of fields on a line, the output cell array is padded with \
 empty string values.  If the specified row range exceeds the number \
 of lines in the \
 file, the range is silently truncated to match the number of lines \
