--- a/doc/interpreter/container.txi	Sat Mar 21 08:29:37 2009 -0700
+++ b/doc/interpreter/container.txi	Sat Mar 21 15:52:41 2009 -0700
@@ -21,7 +21,7 @@
 @cindex containers
 
 Octave includes support for two different mechanisms to contain
-arbitrary data types in the same variable. Structures, which are C-like,
+arbitrary data types in the same variable.  Structures, which are C-like,
 and are indexed with named fields, and cell arrays, where each element
 of the array can have a different data type and or shape.
 
@@ -221,8 +221,8 @@
 @subsection Structure Arrays
 
 A structure array is a particular instance of a structure, where each of
-the fields of the structure is represented by a cell array. Each of
-these cell arrays has the same dimensions. An example of the creation of
+the fields of the structure is represented by a cell array.  Each of
+these cell arrays has the same dimensions.  An example of the creation of
 a structure array is
 
 @example
@@ -235,7 +235,7 @@
 @end example
 
 @noindent
-which creates a 2-by-1 structure array with two fields. As previously,
+which creates a 2-by-1 structure array with two fields.  As previously,
 to print the value of the structure array, you can type its name:
 
 @example
@@ -268,7 +268,7 @@
 
 Furthermore, the structure array can return a comma separated list
 (@pxref{Comma Separated Lists}), if indexed by one of its own field
-names. For example
+names.  For example
 
 @example
 @group
@@ -305,7 +305,7 @@
 @end group
 @end example
 
-The function @code{size} will return the size of the structure. For
+The function @code{size} will return the size of the structure.  For
 the example above
 
 @example
@@ -318,7 +318,7 @@
 @end example
 
 Elements can be deleted from a structure array in a similar manner to a
-numerical array, by assigning the elements to an empty matrix. For
+numerical array, by assigning the elements to an empty matrix.  For
 example
 
 @example
@@ -350,10 +350,10 @@
 @subsection Creating Structures
 
 As well as indexing a structure with ".", Octave can create a structure
-with the @code{struct} command. @code{struct} takes pairs of arguments,
+with the @code{struct} command.  @code{struct} takes pairs of arguments,
 where the first argument in the pair is the fieldname to include in the
 structure and the second is a scalar or cell array, representing the
-values to include in the structure or structure array. For example
+values to include in the structure or structure array.  For example
 
 @example
 @group
@@ -368,7 +368,7 @@
 
 If the values passed to @code{struct} are a mix of scalar and cell
 arrays, then the scalar arguments are expanded to create a 
-structure array with a consistent dimension. For example
+structure array with a consistent dimension.  For example
 
 @example
 @group
@@ -431,7 +431,7 @@
 @subsection Processing Data in Structures
 
 The simplest way to process data in a structure is within a @code{for}
-loop (@pxref{Looping Over Structure Elements}). A similar effect can be
+loop (@pxref{Looping Over Structure Elements}).  A similar effect can be
 achieved with the @code{structfun} function, where a user defined
 function is applied to each field of the structure.
 
@@ -447,8 +447,8 @@
 @cindex cell arrays
 
 It can be both necessary and convenient to store several variables of
-different size or type in one variable. A cell array is a container
-class able to do just that. In general cell arrays work just like
+different size or type in one variable.  A cell array is a container
+class able to do just that.  In general cell arrays work just like
 @math{N}-dimensional arrays, with the exception of the use of @samp{@{}
 and @samp{@}} as allocation and indexing operators.
 
@@ -491,7 +491,7 @@
 @end example
 
 The indexing operators can also be used to insert or overwrite elements
-of a cell array. The following code inserts the scalar 3 on the
+of a cell array.  The following code inserts the scalar 3 on the
 third place of the previously created cell array
 
 @example
@@ -511,7 +511,7 @@
 @end group
 @end example
 
-In general nested cell arrays are displayed hierarchically as above. In
+In general nested cell arrays are displayed hierarchically as above.  In
 some circumstances it makes sense to reference them by their index, and
 this can be performed by the @code{celldisp} function.
 
@@ -528,12 +528,12 @@
 @subsection Creating Cell Array
 
 The introductory example showed how to create a cell array containing
-currently available variables. In many situations, however, it is useful
+currently available variables.  In many situations, however, it is useful
 to create a cell array and then fill it with data.
 
 The @code{cell} function returns a cell array of a given size, containing
-empty matrices. This function is similar to the @code{zeros}
-function for creating new numerical arrays. The following example creates
+empty matrices.  This function is similar to the @code{zeros}
+function for creating new numerical arrays.  The following example creates
 a 2-by-2 cell array containing empty matrices
 
 @example
@@ -550,10 +550,10 @@
 @end group
 @end example
 
-Just like numerical arrays, cell arrays can be multidimensional. The
+Just like numerical arrays, cell arrays can be multidimensional.  The
 @code{cell} function accepts any number of positive integers to describe
-the size of the returned cell array. It is also possible to set the size
-of the cell array through a vector of positive integers. In the
+the size of the returned cell array.  It is also possible to set the size
+of the cell array through a vector of positive integers.  In the
 following example two cell arrays of equal size are created, and the size
 of the first one is displayed
 
@@ -566,7 +566,7 @@
 @end example
 
 @noindent
-As can be seen, the @code{size} function also works for cell arrays. As
+As can be seen, the @code{size} function also works for cell arrays.  As
 do the other functions describing the size of an object, such as
 @code{length}, @code{numel}, @code{rows}, and @code{columns}.
 
@@ -586,7 +586,7 @@
 @subsection Indexing Cell Arrays
 
 As shown in the introductory example elements can be inserted from cell
-arrays using the @samp{@{} and @samp{@}} operators. Besides the change
+arrays using the @samp{@{} and @samp{@}} operators.  Besides the change
 of operators, indexing works for cell arrays like for multidimensional
 arrays.  As an example, all the rows of the first and third column of a
 cell array can be set to @code{0} with the following code
@@ -596,7 +596,7 @@
 @end example
 
 Accessing values in a cell array is, however, different from the same
-operation for numerical arrays. Accessing a single element of a cell
+operation for numerical arrays.  Accessing a single element of a cell
 array is very similar to numerical arrays, for example
 
 @example
@@ -613,10 +613,10 @@
 Separated Lists}) of all the requested elements as discussed later. 
 
 One distinction between @samp{@{} and @samp{(} to index cell arrays is
-in the deletion of elements from the cell array. In a similar manner to
+in the deletion of elements from the cell array.  In a similar manner to
 a numerical array the @samp{()} operator can be used to delete elements
-from the cell array. The @samp{@{@}} operator however will remove the
-elements of the cell array, but not delete the space for them. For example
+from the cell array.  The @samp{@{@}} operator however will remove the
+elements of the cell array, but not delete the space for them.  For example
 
 @example
 @group
@@ -643,10 +643,10 @@
 @subsection Cell Arrays of Strings
 
 One common use of cell arrays is to store multiple strings in the same
-variable. It is possible to store multiple strings in a character matrix
-by letting each row be a string. This, however, introduces the problem
-that all strings must be of equal length. Therefore it is recommended to
-use cell arrays to store multiple strings. If, however, the character
+variable.  It is possible to store multiple strings in a character matrix
+by letting each row be a string.  This, however, introduces the problem
+that all strings must be of equal length.  Therefore it is recommended to
+use cell arrays to store multiple strings.  If, however, the character
 matrix representation is required for an operation, it can be converted
 to a cell array of strings using the @code{cellstr} function
 
@@ -662,8 +662,8 @@
 
 One further advantage of using cell arrays to store multiple strings is
 that most functions for string manipulations included with Octave
-support this representation. As an example, it is possible to compare
-one string with many others using the @code{strcmp} function. If one of
+support this representation.  As an example, it is possible to compare
+one string with many others using the @code{strcmp} function.  If one of
 the arguments to this function is a string and the other is a cell array
 of strings, each element of the cell array will be compared the string
 argument,
@@ -691,8 +691,8 @@
 @subsection Processing Data in Cell Arrays
 
 Data that is stored in a cell array can be processed in several ways
-depending on the actual data. The simplest way to process that data
-is to iterate through it using one or more @code{for} loops. The same
+depending on the actual data.  The simplest way to process that data
+is to iterate through it using one or more @code{for} loops.  The same
 idea can be implemented more easily through the use of the @code{cellfun}
 function that calls a user-specified function on all elements of a cell
 array.
@@ -714,15 +714,15 @@
 
 Comma separated lists@footnote{Comma-separated lists are also sometimes
 informally referred to as @dfn{cs-lists}.} are the basic argument type
-to all Octave functions. In the example
+to all Octave functions.  In the example
 
 @example
 max (@var{a}, @var{b})
 @end example
 
 @noindent
-@code{@var{a}, @var{b}} is a comma separated list. Comma separated lists
-can appear on both the right and left hand side of an equation. For
+@code{@var{a}, @var{b}} is a comma separated list.  Comma separated lists
+can appear on both the right and left hand side of an equation.  For
 example
 
 @example
@@ -730,12 +730,12 @@
 @end example
 
 @noindent
-where @code{@var{i}, @var{j}} is equally a comma separated list. Comma
-separated lists cannot be directly manipulated by the user. However,
+where @code{@var{i}, @var{j}} is equally a comma separated list.  Comma
+separated lists cannot be directly manipulated by the user.  However,
 both structures and cell arrays can be converted into comma
 separated lists, which makes them useful to keep the input arguments and
-return values of functions organized. Another example of where a comma
-separated list can be used is in the creation of a new array. If all the
+return values of functions organized.  Another example of where a comma
+separated list can be used is in the creation of a new array.  If all the
 accessed elements of a cell array are scalars or column vectors, they
 can be concatenated into a new column vector containing the elements, by
 surrounding the list with @code{[} and @code{]} as in the following
@@ -764,7 +764,7 @@
 
 Just like it is possible to create a numerical array from selected
 elements of a cell array, it is possible to create a new cell array
-containing the selected elements. By surrounding the list with 
+containing the selected elements.  By surrounding the list with 
 @samp{@{} and @samp{@}} a new cell array will be created, as the
 following example illustrates
 
@@ -781,9 +781,9 @@
 @noindent
 This syntax is however a bit cumbersome, and since this is a common
 operation, it is possible to achieve the same using the @samp{(}
-and @samp{)} operators for indexing. When a cell array is indexed
+and @samp{)} operators for indexing.  When a cell array is indexed
 using the @samp{(} and @samp{)} operators a new cell array containing
-the selected elements will be created. Using this syntax, the previous 
+the selected elements will be created.  Using this syntax, the previous 
 example can be simplified into the following
 
 @example
@@ -797,7 +797,7 @@
 @end example
 
 A comma separated list can equally appear on the left-hand side of an
-assignment. An example is 
+assignment.  An example is 
 
 @example
 @group
@@ -812,8 +812,8 @@
 @end example
 
 Structure arrays can equally be used to create comma separated
-lists. This is done by addressing one of the fields of a structure
-array. For example
+lists.  This is done by addressing one of the fields of a structure
+array.  For example
 
 @example
 @group

--- a/doc/interpreter/data.txi	Sat Mar 21 08:29:37 2009 -0700
+++ b/doc/interpreter/data.txi	Sat Mar 21 15:52:41 2009 -0700
@@ -47,7 +47,7 @@
 
 The standard built-in data types are real and complex scalars and
 matrices, ranges, character strings, a data structure type, and cell
-arrays. Additional built-in data types may be added in future versions.
+arrays.  Additional built-in data types may be added in future versions.
 If you need a specialized data type that is not currently provided as a
 built-in type, you are encouraged to write your own user-defined data
 type and contribute it for distribution in a future release of Octave.
@@ -113,8 +113,8 @@
 @cindex missing data
 
 It is possible to represent missing data explicitly in Octave using
-@code{NA} (short for ``Not Available''). Missing data can only be
-represented when data is represented as floating point numbers. In this
+@code{NA} (short for ``Not Available'').  Missing data can only be
+represented when data is represented as floating point numbers.  In this
 case missing data is represented as a special case of the representation
 of @code{NaN}.
 

--- a/doc/interpreter/numbers.txi	Sat Mar 21 08:29:37 2009 -0700
+++ b/doc/interpreter/numbers.txi	Sat Mar 21 15:52:41 2009 -0700
@@ -306,7 +306,7 @@
 
 A matrix may have one or both dimensions zero, and operations on empty
 matrices are handled as described by Carl de Boor in @cite{An Empty
-Exercise}, SIGNUM, Volume 25, pages 2--6, 1990 and C. N. Nett and W. M.
+Exercise}, SIGNUM, Volume 25, pages 2-6, 1990 and C. N. Nett and W. M.
 Haddad, in @cite{A System-Theoretic Appropriate Realization of the Empty
 Matrix Concept}, IEEE Transactions on Automatic Control, Volume 38,
 Number 5, May 1993.
@@ -412,7 +412,7 @@
 
 Octave includes support for single precision data types, and most of the
 functions in Octave accept single precision values and return single
-precion answers. A single precision variable is created with the
+precision answers.  A single precision variable is created with the
 @code{single} function.
 
 @DOCSTRING(single)
@@ -428,7 +428,7 @@
     @result{} single
 @end example
 
-Many functions can also return single precision values directly. For
+Many functions can also return single precision values directly.  For
 example
 
 @example
@@ -448,15 +448,15 @@
 @section Integer Data Types
 
 Octave supports integer matrices as an alternative to using double
-precision. It is possible to use both signed and unsigned integers
-represented by 8, 16, 32, or 64 bits. It should be noted that most
+precision.  It is possible to use both signed and unsigned integers
+represented by 8, 16, 32, or 64 bits.  It should be noted that most
 computations require floating point data, meaning that integers will
-often change type when involved in numeric computations. For this
+often change type when involved in numeric computations.  For this
 reason integers are most often used to store data, and not for
 calculations.
 
 In general most integer matrices are created by casting
-existing matrices to integers. The following example shows how to cast
+existing matrices to integers.  The following example shows how to cast
 a matrix into 32 bit integers.
 
 @example
@@ -505,28 +505,28 @@
 
 While many numerical computations can't be carried out in integers,
 Octave does support basic operations like addition and multiplication
-on integers. The operators @code{+}, @code{-}, @code{.*}, and @code{./}
-work on integers of the same type. So, it is possible to add two 32 bit
+on integers.  The operators @code{+}, @code{-}, @code{.*}, and @code{./}
+work on integers of the same type.  So, it is possible to add two 32 bit
 integers, but not to add a 32 bit integer and a 16 bit integer.
 
 The arithmetic operations on integers are performed by casting the
 integer values to double precision values, performing the operation, and
-then re-casting the values back to the original integer type. As the
+then re-casting the values back to the original integer type.  As the
 double precision type of Octave is only capable of representing integers
 with up to 53 bits of precision, it is not possible to perform
 arithmetic with 64 bit integer types.
 
 When doing integer arithmetic one should consider the possibility of
-underflow and overflow. This happens when the result of the computation
-can't be represented using the chosen integer type. As an example it is
+underflow and overflow.  This happens when the result of the computation
+can't be represented using the chosen integer type.  As an example it is
 not possible to represent the result of @math{10 - 20} when using
-unsigned integers. Octave makes sure that the result of integer
-computations is the integer that is closest to the true result. So, the
+unsigned integers.  Octave makes sure that the result of integer
+computations is the integer that is closest to the true result.  So, the
 result of @math{10 - 20} when using unsigned integers is zero.
 
 When doing integer division Octave will round the result to the nearest
-integer. This is different from most programming languages, where the
-result is often floored to the nearest integer. So, the result of
+integer.  This is different from most programming languages, where the
+result is often floored to the nearest integer.  So, the result of
 @code{int32(5)./int32(8)} is @code{1}.
 
 @DOCSTRING(idivide)
@@ -535,7 +535,7 @@
 @section Bit Manipulations
 
 Octave provides a number of functions for the manipulation of numeric
-values on a bit by bit basis. The basic functions to set and obtain the
+values on a bit by bit basis.  The basic functions to set and obtain the
 values of individual bits are @code{bitset} and @code{bitget}.
 
 @DOCSTRING(bitset)
@@ -544,11 +544,11 @@
 
 The arguments to all of Octave's bitwise operations can be scalar or
 arrays, except for @code{bitcmp}, whose @var{k} argument must a
-scalar. In the case where more than one argument is an array, then all
+scalar.  In the case where more than one argument is an array, then all
 arguments must have the same shape, and the bitwise operator is applied
-to each of the elements of the argument individually. If at least one
+to each of the elements of the argument individually.  If at least one
 argument is a scalar and one an array, then the scalar argument is
-duplicated. Therefore
+duplicated.  Therefore
 
 @example
 bitget (100, 8:-1:1)
@@ -561,7 +561,7 @@
 @end example
 
 It should be noted that all values passed to the bit manipulation
-functions of Octave are treated as integers. Therefore, even though the
+functions of Octave are treated as integers.  Therefore, even though the
 example for @code{bitset} above passes the floating point value
 @code{10}, it is treated as the bits @code{[1, 0, 1, 0]} rather than the
 bits of the native floating point format representation of @code{10}.
@@ -585,8 +585,8 @@
 @DOCSTRING(bitxor)
 
 The bitwise 'not' operator is a unary operator that performs a logical
-negation of each of the bits of the value. For this to make sense, the
-mask against which the value is negated must be defined. Octave's
+negation of each of the bits of the value.  For this to make sense, the
+mask against which the value is negated must be defined.  Octave's
 bitwise 'not' operator is @code{bitcmp}.
 
 @DOCSTRING(bitcmp)
@@ -595,9 +595,9 @@
 
 @DOCSTRING(bitshift)
 
-Bits that are shifted out of either end of the value are lost. Octave
+Bits that are shifted out of either end of the value are lost.  Octave
 also uses arithmetic shifts, where the sign bit of the value is kept
-during a right shift. For example
+during a right shift.  For example
 
 @example
 @group
@@ -615,19 +615,19 @@
 @node Logical Values
 @section Logical Values
 
-Octave has built-in support for logical values, i.e. variables that
-are either @code{true} or @code{false}. When comparing two variables,
+Octave has built-in support for logical values, i.e., variables that
+are either @code{true} or @code{false}.  When comparing two variables,
 the result will be a logical value whose value depends on whether or
 not the comparison is true.
 
 The basic logical operations are @code{&}, @code{|}, and @code{!},
 which correspond to ``Logical And'', ``Logical Or'', and ``Logical
-Negation''. These operations all follow the usual rules of logic.
+Negation''.  These operations all follow the usual rules of logic.
 
 It is also possible to use logical values as part of standard numerical
-calculations. In this case @code{true} is converted to @code{1}, and
+calculations.  In this case @code{true} is converted to @code{1}, and
 @code{false} to 0, both represented using double precision floating
-point numbers. So, the result of @code{true*22 - false/6} is @code{22}.
+point numbers.  So, the result of @code{true*22 - false/6} is @code{22}.
 
 Logical values can also be used to index matrices and cell arrays.
 When indexing with a logical array the result will be a vector containing
@@ -658,7 +658,7 @@
 @node Promotion and Demotion of Data Types
 @section Promotion and Demotion of Data Types
 
-Many operators and functions can work with mixed data types. For example
+Many operators and functions can work with mixed data types.  For example
 
 @example
 uint8 (1) + 1
@@ -667,11 +667,11 @@
 
 @noindent
 where the above operator works with an 8-bit integer and a double precision
-value and returns an 8-bit integer value. Note that the type is demoted
+value and returns an 8-bit integer value.  Note that the type is demoted
 to an 8-bit integer, rather than promoted to a double precision value as
-might be expected. The reason is that if Octave promoted values in
+might be expected.  The reason is that if Octave promoted values in
 expressions like the above with all numerical constants would need to be
-explicitly cast to the appropriate data type type like
+explicitly cast to the appropriate data type like
 
 @example
 uint8 (1) + uint8 (1)
@@ -680,7 +680,7 @@
 
 @noindent
 which becomes difficult for the user to apply uniformly and might allow
-hard to find bugs to be introduced. The same applies to single precision
+hard to find bugs to be introduced.  The same applies to single precision
 values where a mixed operation such as
 
 @example
@@ -689,7 +689,7 @@
 @end example
 
 @noindent
-returns a single precision value. The mixed operations that are valid
+returns a single precision value.  The mixed operations that are valid
 and their returned data types are
 
 @multitable @columnfractions .2 .3 .3 .2
@@ -714,7 +714,7 @@
 where the returned value is single precision.
 
 In the case of mixed type indexed assignments, the type is not
-changed. For example
+changed.  For example
 
 @example
 x = ones (2, 2);
@@ -730,9 +730,9 @@
 @section Predicates for Numeric Objects
 
 Since the type of a variable may change during the execution of a
-program, it can be necessary to do type checking at run-time. Doing this
-also allows you to change the behaviour of a function depending on the
-type of the input. As an example, this naive implementation of @code{abs}
+program, it can be necessary to do type checking at run-time.  Doing this
+also allows you to change the behavior of a function depending on the
+type of the input.  As an example, this naive implementation of @code{abs}
 returns the absolute value of the input if it is a real number, and the
 length of the input if it is a complex number.
 

--- a/doc/interpreter/strings.txi	Sat Mar 21 08:29:37 2009 -0700
+++ b/doc/interpreter/strings.txi	Sat Mar 21 15:52:41 2009 -0700
@@ -314,7 +314,7 @@
 
 @item @code{strcat} removes trailing white space in the arguments (except
 within cell arrays), while @code{cstrcat} leaves white space untouched.  Both
-kinds of behaviour can be useful as can be seen in the examples:
+kinds of behavior can be useful as can be seen in the examples:
 
 @example
 @group
@@ -377,7 +377,7 @@
 
 @noindent To determine if two strings are identical it is necessary to use the
 @code{strcmp} function.  It compares complete strings and is case
-sensistive.  @code{strncmp} compares only the first @code{N} characters (with
+sensitive.  @code{strncmp} compares only the first @code{N} characters (with
 @code{N} given as a parameter).  @code{strcmpi} and @code{strncmpi} are the
 corresponding functions for case-insensitive comparison.
 
@@ -396,15 +396,17 @@
 
 Octave supports a wide range of functions for manipulating strings.
 Since a string is just a matrix, simple manipulations can be accomplished
-using standard operators. The following example shows how to replace
+using standard operators.  The following example shows how to replace
 all blank characters with underscores.
 
 @example
-quote = ...
+@group
+quote = @dots{}
   "First things first, but not necessarily in that order";
 quote( quote == " " ) = "_"
 @result{} quote = 
     First_things_first,_but_not_necessarily_in_that_order
+@end group
 @end example
 
 For more complex manipulations, such as searching, replacing, and

--- a/scripts/general/celldisp.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/general/celldisp.m	Sat Mar 21 15:52:41 2009 -0700
@@ -18,8 +18,8 @@
 
 ## -*- texinfo -*-
 ## @deftypefn {Function File} {} celldisp (@var{c}, @var{name})
-## Recursively display the contents of a cell array. By default the values
-## are displayed with the name of the variable @var{c}. However, this name
+## Recursively display the contents of a cell array.  By default the values
+## are displayed with the name of the variable @var{c}.  However, this name
 ## can be replaced with the variable @var{name}.
 ## @seealso{disp}
 ## @end deftypefn

--- a/scripts/general/idivide.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/general/idivide.m	Sat Mar 21 15:52:41 2009 -0700
@@ -18,12 +18,12 @@
 
 ## -*- texinfo -*-
 ## @deftypefn {Function File} {} idivide (@var{x}, @var{y}, @var{op})
-## Integer division with different round rules. The standard behavior of
+## Integer division with different round rules.  The standard behavior of
 ## the an integer division such as @code{@var{a} ./ @var{b}} is to round
-## the result to the nearest integer. This is not always the desired
+## the result to the nearest integer.  This is not always the desired
 ## behavior and @code{idivide} permits integer element-by-element
 ## division to be performed with different treatment for the fractional
-## part of the division as determined by the @var{op} flag. @var{op} is
+## part of the division as determined by the @var{op} flag.  @var{op} is
 ## a string with one of the values: 
 ##
 ## @table @asis

--- a/scripts/general/structfun.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/general/structfun.m	Sat Mar 21 15:52:41 2009 -0700
@@ -23,19 +23,19 @@
 ## @deftypefnx {Function File} {} structfun (@dots{}, "UniformOutput", @var{val})
 ## 
 ## Evaluate the function named @var{name} on the fields of the structure
-## @var{s}. The fields of @var{s} are passed to the function @var{func}
+## @var{s}.  The fields of @var{s} are passed to the function @var{func}
 ## individually.
 ##
 ## @code{structfun} accepts an arbitrary function @var{func} in the form of 
 ## an inline function, function handle, or the name of a function (in a 
-## character string). In the case of a character string argument, the 
+## character string).  In the case of a character string argument, the 
 ## function must accept a single argument named @var{x}, and it must return 
-## a string value. If the function returns more than one argument, they are
+## a string value.  If the function returns more than one argument, they are
 ## returned as separate output variables.
 ##
 ## If the parameter "UniformOutput" is set to true (the default), then the function
 ## must return a single element which will be concatenated into the
-## return value. If "UniformOutput" is false, the outputs placed in a structure
+## return value.  If "UniformOutput" is false, the outputs placed in a structure
 ## with the same fieldnames as the input structure.
 ## 
 ## @example
@@ -48,14 +48,14 @@
 ## @end example
 ## 
 ## Given the parameter "ErrorHandler", then @var{errfunc} defines a function to
-## call in case @var{func} generates an error. The form of the function is
+## call in case @var{func} generates an error.  The form of the function is
 ## 
 ## @example
 ## function [@dots{}] = errfunc (@var{se}, @dots{})
 ## @end example
 ## 
 ## where there is an additional input argument to @var{errfunc} relative to
-## @var{func}, given by @var{se}. This is a structure with the elements
+## @var{func}, given by @var{se}.  This is a structure with the elements
 ## "identifier", "message" and "index", giving respectively the error
 ## identifier, the error message, and the index into the input arguments
 ## of the element that caused the error.

--- a/scripts/miscellaneous/getfield.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/miscellaneous/getfield.m	Sat Mar 21 15:52:41 2009 -0700
@@ -18,7 +18,7 @@
 
 ## -*- texinfo -*-
 ## @deftypefn {Function File} {[@var{v1}, @dots{}] =} getfield (@var{s}, @var{key}, @dots{}) 
-## Extract fields from a structure. For example
+## Extract fields from a structure.  For example
 ##
 ## @example
 ## @group

--- a/scripts/miscellaneous/intwarning.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/miscellaneous/intwarning.m	Sat Mar 21 15:52:41 2009 -0700
@@ -26,7 +26,7 @@
 ## @table @asis
 ## @item "query"
 ## The state of the Octave integer conversion and math warnings is
-## queried. If there is no output argument, then the state is printed.
+## queried.  If there is no output argument, then the state is printed.
 ## Otherwise it is returned in a structure with the fields "identifier"
 ## and "state".
 ##
@@ -41,21 +41,21 @@
 ## @end smallexample 
 ##
 ## @item "on"
-## Turn integer conversion and math warnings "on". If there is no output
-## argument, then nothing is printed. Otherwise the original state of
+## Turn integer conversion and math warnings "on".  If there is no output
+## argument, then nothing is printed.  Otherwise the original state of
 ## the state of the integer conversion and math warnings is returned in
 ## a structure array.
 ##
 ## @item "off"
-## Turn integer conversion and math warnings "on". If there is no output
-## argument, then nothing is printed. Otherwise the original state of
+## Turn integer conversion and math warnings "on".  If there is no output
+## argument, then nothing is printed.  Otherwise the original state of
 ## the state of the integer conversion and math warnings is returned in
 ## a structure array.
 ## @end table
 ##
 ## The original state of the integer warnings can be restored by passing
 ## the structure array returned by @code{intwarning} to a later call to
-## @code{intwarning}. For example
+## @code{intwarning}.  For example
 ##
 ## @example
 ## s = intwarning ("off");

--- a/scripts/miscellaneous/swapbytes.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/miscellaneous/swapbytes.m	Sat Mar 21 15:52:41 2009 -0700
@@ -19,7 +19,7 @@
 ## -*- texinfo -*-
 ## @deftypefn {Function File} {} swapbytes (@var{x})
 ## Swaps the byte order on values, converting from little endian to big 
-## endian and visa-versa. For example
+## endian and vice versa.  For example
 ##
 ## @example
 ## @group

--- a/scripts/strings/base2dec.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/strings/base2dec.m	Sat Mar 21 15:52:41 2009 -0700
@@ -32,7 +32,7 @@
 ## converting so that trailing spaces are ignored.
 ##
 ## If @var{b} is a string, the characters of @var{b} are used as the
-## symbols for the digits of @var{s}. Space (' ') may not be used as a
+## symbols for the digits of @var{s}.  Space (' ') may not be used as a
 ## symbol.
 ##
 ## @example
@@ -86,4 +86,4 @@
 %!error <Invalid call to base2dec.*> base2dec("11120");
 %!error <Invalid call to base2dec.*> base2dec("11120", 3, 4);
 %!assert(base2dec ("11120", 3), 123);
-%!assert(base2dec ("yyyzx", "xyz"), 123);
\ No newline at end of file
+%!assert(base2dec ("yyyzx", "xyz"), 123);

--- a/scripts/strings/cstrcat.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/strings/cstrcat.m	Sat Mar 21 15:52:41 2009 -0700
@@ -20,7 +20,7 @@
 ## -*- texinfo -*-
 ## @deftypefn {Function File} {} cstrcat (@var{s1}, @var{s2}, @dots{})
 ## Return a string containing all the arguments concatenated
-## horizontally. Trailing white space is preserved. For example,
+## horizontally.  Trailing white space is preserved.  For example,
 ##
 ## @example
 ## @group

--- a/scripts/strings/mat2str.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/strings/mat2str.m	Sat Mar 21 15:52:41 2009 -0700
@@ -20,15 +20,15 @@
 ## @deftypefn {Function File} {@var{s} =} mat2str (@var{x}, @var{n})
 ## @deftypefnx {Function File} {@var{s} =} mat2str (@dots{}, 'class')
 ##
-## Format real/complex numerical matrices as strings. This function
+## Format real/complex numerical matrices as strings.  This function
 ## returns values that are suitable for the use of the @code{eval}
 ## function.
 ##
-## The precision of the values is given by @var{n}. If @var{n} is a
+## The precision of the values is given by @var{n}.  If @var{n} is a
 ## scalar then both real and imaginary parts of the matrix are printed
-## to the same precision. Otherwise @code{@var{n} (1)} defines the
+## to the same precision.  Otherwise @code{@var{n} (1)} defines the
 ## precision of the real part and @code{@var{n} (2)} defines the
-## precision of the imaginary part. The default for @var{n} is 17.
+## precision of the imaginary part.  The default for @var{n} is 17.
 ##
 ## If the argument 'class' is given, then the class of @var{x} is
 ## included in the string in such a way that the eval will result in the

--- a/scripts/strings/regexptranslate.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/strings/regexptranslate.m	Sat Mar 21 15:52:41 2009 -0700
@@ -18,7 +18,7 @@
 
 ## -*- texinfo -*-
 ## @deftypefn {Function File} {} regexptranslate (@var{op}, @var{s})
-## Translate a string for use in a regular expression. This might
+## Translate a string for use in a regular expression.  This might
 ## include either wildcard replacement or special character escaping.
 ## The behavior can be controlled by the @var{op} that can have the
 ## values
@@ -26,7 +26,8 @@
 ## @table @asis
 ## @item "wildcard"
 ## The wildcard characters @code{.}, @code{*} and @code{?} are replaced
-## with wildcards that are appropriate for a regular expression. For example:
+## with wildcards that are appropriate for a regular expression. 
+## For example:
 ## @example
 ## @group
 ## regexptranslate ("wildcard", "*.m")
@@ -36,7 +37,7 @@
 ## 
 ## @item "escape"
 ## The characters @code{$.?[]}, that have special meaning for regular
-## expressions are escaped so that they are treated literally. For example:
+## expressions are escaped so that they are treated literally.  For example:
 ## @example
 ## @group
 ## regexptranslate ("escape", "12.5")

--- a/scripts/strings/str2num.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/strings/str2num.m	Sat Mar 21 15:52:41 2009 -0700
@@ -19,7 +19,7 @@
 ## -*- texinfo -*-
 ## @deftypefn {Function File} {} str2num (@var{s})
 ## Convert the string (or character array) @var{s} to a number (or an
-## array). Examples:  
+## array).  Examples:  
 ##
 ## @example
 ## @group

--- a/scripts/strings/strcat.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/strings/strcat.m	Sat Mar 21 15:52:41 2009 -0700
@@ -23,7 +23,7 @@
 ## horizontally.  If the arguments are cells strings,  @code{strcat}
 ## returns a cell string with the individual cells concatenated.
 ## For numerical input, each element is converted to the
-## corresponding ASCII character. Trailing white space is eliminated.
+## corresponding ASCII character.  Trailing white space is eliminated.
 ## For example,
 ##
 ## @example

--- a/scripts/strings/strchr.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/strings/strchr.m	Sat Mar 21 15:52:41 2009 -0700
@@ -20,7 +20,7 @@
 ## @deftypefn {Function File} {@var{idx} =} strchr (@var{str}, @var{chars})
 ## @deftypefnx {Function File} {@var{idx} =} strchr (@var{str}, @var{chars}, @var{n})
 ## @deftypefnx {Function File} {@var{idx} =} strchr (@var{str}, @var{chars}, @var{n}, @var{direction})
-## Search for the string @var{str} for occurences of characters from the set @var{chars}.
+## Search for the string @var{str} for occurrences of characters from the set @var{chars}.
 ## The return value, as well as the @var{n} and @var{direction} arguments behave
 ## identically as in @code{find}.
 ##

--- a/scripts/strings/strcmpi.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/strings/strcmpi.m	Sat Mar 21 15:52:41 2009 -0700
@@ -23,7 +23,7 @@
 ##
 ## If either @var{s1} or @var{s2} is a cell array of strings, then an array
 ## of the same size is returned, containing the values described above for
-## every member of the cell array. The other argument may also be a cell
+## every member of the cell array.  The other argument may also be a cell
 ## array of strings (of the same size or with only one element), char matrix
 ## or character string.
 ##

--- a/scripts/strings/strfind.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/strings/strfind.m	Sat Mar 21 15:52:41 2009 -0700
@@ -26,7 +26,7 @@
 ##
 ## If the cell array of strings @var{cellstr} is specified instead of the
 ## string @var{str}, then @var{idx} is a cell array of vectors, as specified
-## above. Examples:
+## above.  Examples:
 ##
 ## @example
 ## @group

--- a/scripts/strings/strjust.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/strings/strjust.m	Sat Mar 21 15:52:41 2009 -0700
@@ -21,7 +21,7 @@
 ## Shift the non-blank text of @var{s} to the left, right or center of
 ## the string.  If @var{s} is a string array, justify each string in the
 ## array.  Null characters are replaced by blanks.  If no justification
-## is specified, then all rows are right-justified. For example:
+## is specified, then all rows are right-justified.  For example:
 ##
 ## @example
 ## @group

--- a/scripts/strings/strtok.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/strings/strtok.m	Sat Mar 21 15:52:41 2009 -0700
@@ -21,7 +21,7 @@
 ## 
 ## Find all characters up to but not including the first character which
 ## is in the string delim.  If @var{rem} is requested, it contains the
-## remainder of the string, starting at the first deliminator. Leading
+## remainder of the string, starting at the first delimiter.  Leading
 ## delimiters are ignored.  If @var{delim} is not specified, space is
 ## assumed.  For example: 
 ##

--- a/scripts/strings/strtrim.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/strings/strtrim.m	Sat Mar 21 15:52:41 2009 -0700
@@ -21,7 +21,7 @@
 ## Remove leading and trailing blanks and nulls from @var{s}.  If
 ## @var{s} is a matrix, @var{strtrim} trims each row to the length of
 ## longest string.  If @var{s} is a cell array, operate recursively on
-## each element of the cell array. For example:
+## each element of the cell array.  For example:
 ##
 ## @example
 ## @group

--- a/scripts/strings/strtrunc.m	Sat Mar 21 08:29:37 2009 -0700
+++ b/scripts/strings/strtrunc.m	Sat Mar 21 15:52:41 2009 -0700
@@ -18,7 +18,7 @@
 
 ## -*- texinfo -*-
 ## @deftypefn {Function File} {} strtrunc (@var{s}, @var{n})
-## Truncate the character string @var{s} to length @var{n}. If @var{s}
+## Truncate the character string @var{s} to length @var{n}.  If @var{s}
 ## is a char matrix, then the number of columns is adjusted.
 ##
 ## If @var{s} is a cell array of strings, then the operation is performed

--- a/src/DLD-FUNCTIONS/cellfun.cc	Sat Mar 21 08:29:37 2009 -0700
+++ b/src/DLD-FUNCTIONS/cellfun.cc	Sat Mar 21 15:52:41 2009 -0700
@@ -75,11 +75,11 @@
 \n\
 Additionally, @code{cellfun} accepts an arbitrary function @var{func}\n\
 in the form of an inline function, function handle, or the name of a\n\
-function (in a character string). In the case of a character string\n\
+function (in a character string).  In the case of a character string\n\
 argument, the function must accept a single argument named @var{x}, and\n\
-it must return a string value. The function can take one or more arguments,\n\
-with the inputs args given by @var{c}, @var{d}, etc. Equally the function\n\
-can return one or more output arguments. For example\n\
+it must return a string value.  The function can take one or more arguments,\n\
+with the inputs args given by @var{c}, @var{d}, etc.  Equally the function\n\
+can return one or more output arguments.  For example\n\
 \n\
 @example\n\
 @group\n\
@@ -93,8 +93,8 @@
 \n\
 If the parameter 'UniformOutput' is set to true (the default), then the function\n\
 must return a single element which will be concatenated into the\n\
-return value. If 'UniformOutput' is false, the outputs are concatenated in\n\
-a cell array. For example\n\
+return value.  If 'UniformOutput' is false, the outputs are concatenated in\n\
+a cell array.  For example\n\
 \n\
 @example\n\
 @group\n\
@@ -105,17 +105,17 @@
 @end example\n\
 \n\
 Given the parameter 'ErrorHandler', then @var{errfunc} defines a function to\n\
-call in case @var{func} generates an error. The form of the function is\n\
+call in case @var{func} generates an error.  The form of the function is\n\
 \n\
 @example\n\
 function [@dots{}] = errfunc (@var{s}, @dots{})\n\
 @end example\n\
 \n\
 where there is an additional input argument to @var{errfunc} relative to\n\
-@var{func}, given by @var{s}. This is a structure with the elements\n\
+@var{func}, given by @var{s}.  This is a structure with the elements\n\
 'identifier', 'message' and 'index', giving respectively the error\n\
 identifier, the error message, and the index into the input arguments\n\
-of the element that caused the error. For example\n\
+of the element that caused the error.  For example\n\
 \n\
 @example\n\
 @group\n\
@@ -754,7 +754,7 @@
   "-*- texinfo -*-\n\
 @deftypefn {Loadable Function} {@var{c} =} num2cell (@var{m})\n\
 @deftypefnx {Loadable Function} {@var{c} =} num2cell (@var{m}, @var{dim})\n\
-Convert the matrix @var{m} into a cell array. If @var{dim} is defined, the\n\
+Convert the matrix @var{m} into a cell array.  If @var{dim} is defined, the\n\
 value @var{c} is of dimension 1 in this dimension and the elements of\n\
 @var{m} are placed in slices in @var{c}.\n\
 @seealso{mat2cell}\n\
@@ -851,9 +851,9 @@
 @deftypefn {Loadable Function} {@var{b} =} mat2cell (@var{a}, @var{m}, @var{n})\n\
 @deftypefnx {Loadable Function} {@var{b} =} mat2cell (@var{a}, @var{d1}, @var{d2}, @dots{})\n\
 @deftypefnx {Loadable Function} {@var{b} =} mat2cell (@var{a}, @var{r})\n\
-Convert the matrix @var{a} to a cell array. If @var{a} is 2-D, then\n\
+Convert the matrix @var{a} to a cell array.  If @var{a} is 2-D, then\n\
 it is required that @code{sum (@var{m}) == size (@var{a}, 1)} and\n\
-@code{sum (@var{n}) == size (@var{a}, 2)}. Similarly, if @var{a} is\n\
+@code{sum (@var{n}) == size (@var{a}, 2)}.  Similarly, if @var{a} is\n\
 a multi-dimensional and the number of dimensional arguments is equal\n\
 to the dimensions of @var{a}, then it is required that @code{sum (@var{di})\n\
 == size (@var{a}, i)}.\n\

--- a/src/DLD-FUNCTIONS/hex2num.cc	Sat Mar 21 08:29:37 2009 -0700
+++ b/src/DLD-FUNCTIONS/hex2num.cc	Sat Mar 21 15:52:41 2009 -0700
@@ -36,7 +36,7 @@
   "-*- texinfo -*-\n\
 @deftypefn {Loadable Function} {@var{n} =} hex2num (@var{s})\n\
 Typecast the 16 character hexadecimal character matrix to an IEEE 754\n\
-double precision number. If fewer than 16 characters are given the\n\
+double precision number.  If fewer than 16 characters are given the\n\
 strings are right padded with '0' characters.\n\
 \n\
 Given a string matrix, @code{hex2num} treats each row as a separate\n\
@@ -122,7 +122,7 @@
   "-*- texinfo -*-\n\
 @deftypefn {Loadable Function} {@var{s} =} num2hex (@var{n})\n\
 Typecast a double precision number or vector to a 16 character hexadecimal\n\
-string of the IEEE 754 representation of the number. For example\n\
+string of the IEEE 754 representation of the number.  For example\n\
 \n\
 @example\n\
 num2hex ([-1, 1, e, Inf, NaN, NA]);\n\

--- a/src/DLD-FUNCTIONS/regexp.cc	Sat Mar 21 08:29:37 2009 -0700
+++ b/src/DLD-FUNCTIONS/regexp.cc	Sat Mar 21 15:52:41 2009 -0700
@@ -876,7 +876,7 @@
 @deftypefn {Loadable Function} {[@var{s}, @var{e}, @var{te}, @var{m}, @var{t}, @var{nm}] =} regexp (@var{str}, @var{pat})\n\
 @deftypefnx {Loadable Function} {[@dots{}] =} regexp (@var{str}, @var{pat}, @var{opts}, @dots{})\n\
 \n\
-Regular expression string matching. Matches @var{pat} in @var{str} and\n\
+Regular expression string matching.  Matches @var{pat} in @var{str} and\n\
 returns the position and matching substrings or empty values if there are\n\
 none.\n\
 \n\
@@ -905,14 +905,14 @@
 @item ()\n\
 Grouping operator\n\
 @item |\n\
-Alternation operator. Match one of a choice of regular expressions. The\n\
+Alternation operator.  Match one of a choice of regular expressions.  The\n\
 alternatives must be delimited by the grouping operator @code{()} above\n\
 @item ^ $\n\
-Anchoring operator. @code{^} matches the start of the string @var{str} and\n\
+Anchoring operator.  @code{^} matches the start of the string @var{str} and\n\
 @code{$} the end\n\
 @end table\n\
 \n\
-In addition the following escaped characters have special meaning. It should\n\
+In addition the following escaped characters have special meaning.  It should\n\
 be noted that it is recommended to quote @var{pat} in single quotes rather\n\
 than double quotes, to avoid the escape sequences being interpreted by Octave\n\
 before being passed to @code{regexp}.\n\
@@ -961,12 +961,12 @@
 \n\
 @item @var{nm}\n\
 A structure containing the text of each matched named token, with the name\n\
-being used as the fieldname. A named token is denoted as\n\
+being used as the fieldname.  A named token is denoted as\n\
 @code{(?<name>@dots{})}\n\
 @end table\n\
 \n\
 Particular output arguments or the order of the output arguments can be\n\
-selected by additional @var{opts} arguments. These are strings and the\n\
+selected by additional @var{opts} arguments.  These are strings and the\n\
 correspondence between the output arguments and the optional argument\n\
 are\n\
 \n\
@@ -980,7 +980,7 @@
 @end multitable\n\
 \n\
 A further optional argument is 'once', that limits the number of returned\n\
-matches to the first match. Additional arguments are\n\
+matches to the first match.  Additional arguments are\n\
 \n\
 @table @asis\n\
 @item matchcase\n\
@@ -1192,7 +1192,7 @@
 @deftypefn {Loadable Function} {[@var{s}, @var{e}, @var{te}, @var{m}, @var{t}, @var{nm}] =} regexpi (@var{str}, @var{pat})\n\
 @deftypefnx {Loadable Function} {[@dots{}] =} regexpi (@var{str}, @var{pat}, @var{opts}, @dots{})\n\
 \n\
-Case insensitive regular expression string matching. Matches @var{pat} in\n\
+Case insensitive regular expression string matching.  Matches @var{pat} in\n\
 @var{str} and returns the position and matching substrings or empty values\n\
 if there are none.  @xref{doc-regexp,,regexp}, for more details\n\
 @end deftypefn")

--- a/src/DLD-FUNCTIONS/typecast.cc	Sat Mar 21 08:29:37 2009 -0700
+++ b/src/DLD-FUNCTIONS/typecast.cc	Sat Mar 21 15:52:41 2009 -0700
@@ -132,7 +132,7 @@
   "-*- texinfo -*-\n\
 @deftypefn {Loadable Function} {} typecast (@var{x}, @var{type})\n\
 Convert from one datatype to another without changing the underlying\n\
-data. The argument @var{type} defines the type of the return argument\n\
+data.  The argument @var{type} defines the type of the return argument\n\
 and must be one of 'uint8', 'uint16', 'uint32', 'uint64', 'int8', 'int16',\n\
 'int32', 'int64', 'single' or 'double'.\n\
 \n\

--- a/src/ov-struct.cc	Sat Mar 21 08:29:37 2009 -0700
+++ b/src/ov-struct.cc	Sat Mar 21 15:52:41 2009 -0700
@@ -964,7 +964,7 @@
 DEFUN (cell2struct, args, ,
        "-*- texinfo -*-\n\
 @deftypefn {Built-in Function} {} cell2struct (@var{cell}, @var{fields}, @var{dim})\n\
-Convert @var{cell} to a structure. The number of fields in @var{fields}\n\
+Convert @var{cell} to a structure.  The number of fields in @var{fields}\n\
 must match the number of elements in @var{cell} along dimension @var{dim},\n\
 that is @code{numel (@var{fields}) == size (@var{cell}, @var{dim})}.\n\
 \n\

--- a/src/strfns.cc	Sat Mar 21 08:29:37 2009 -0700
+++ b/src/strfns.cc	Sat Mar 21 15:52:41 2009 -0700
@@ -315,7 +315,7 @@
 \n\
 If either @var{s1} or @var{s2} is a cell array of strings, then an array\n\
 of the same size is returned, containing the values described above for\n\
-every member of the cell array. The other argument may also be a cell\n\
+every member of the cell array.  The other argument may also be a cell\n\
 array of strings (of the same size or with only one element), char matrix\n\
 or character string.\n\
 \n\
@@ -622,7 +622,7 @@
 \n\
 If either @var{s1} or @var{s2} is a cell array of strings, then an array\n\
 of the same size is returned, containing the values described above for\n\
-every member of the cell array. The other argument may also be a cell\n\
+every member of the cell array.  The other argument may also be a cell\n\
 array of strings (of the same size or with only one element), char matrix\n\
 or character string.\n\
 \n\