Eliminate spurious space at eol, and spurious word.

c.texi

@@ -279,7 +279,7 @@ Order of Execution
 * Reordering of Operands::       Operations in C are not necessarily computed
                                    in the order they are written.
 * Associativity and Ordering::   Some associative operations are performed
-                                   in a particular order; others are not.     
+                                   in a particular order; others are not.
 * Sequence Points::              Some guarantees about the order of operations.
 * Postincrement and Ordering::   Ambiguous execution order with postincrement.
 * Ordering of Operands::         Evaluation order of operands
@@ -297,7 +297,7 @@ Primitive Data Types
 
 Constants
 
-* Integer Constants::            Literal integer values.                   
+* Integer Constants::            Literal integer values.
 * Integer Const Type::           Types of literal integer values.
 * Floating Constants::           Literal floating-point values.
 * Imaginary Constants::          Literal imaginary number values.
@@ -344,7 +344,7 @@ Structures
 * const Fields::                 Making structure fields immutable.
 * Zero Length::                  Zero-length array as a variable-length object.
 * Flexible Array Fields::        Another approach to variable-length objects.
-* Overlaying Structures::        Casting one structure type 
+* Overlaying Structures::        Casting one structure type
                                    over an object of another structure type.
 * Structure Assignment::         Assigning values to structure objects.
 * Unions::                       Viewing the same object in different types.
@@ -487,7 +487,7 @@ Floating Point in Depth
 Directing Compilation
 
 * Pragmas::                      Controlling compilation of some constructs.
-* Static Assertions::            Compile-time tests for conditions.    
+* Static Assertions::            Compile-time tests for conditions.
 
 @end detailmenu
 @end menu
@@ -3404,7 +3404,7 @@ necessarily predictable.  This chapter describes what you can count on.
 * Reordering of Operands::       Operations in C are not necessarily computed
                                    in the order they are written.
 * Associativity and Ordering::   Some associative operations are performed
-                                   in a particular order; others are not.     
+                                   in a particular order; others are not.
 * Sequence Points::              Some guarantees about the order of operations.
 * Postincrement and Ordering::   Ambiguous execution order with postincrement.
 * Ordering of Operands::         Evaluation order of operands
@@ -3920,7 +3920,7 @@ C has three floating-point data types:
 ``Double-precision'' floating point, which uses 64 bits.  This is the
 normal floating-point type, and modern computers normally do
 their floating-point computations in this type, or some wider type.
-Except when there is a special reason to do otherwise, this is the 
+Except when there is a special reason to do otherwise, this is the
 type to use for floating-point values.
 
 @item float
@@ -3931,7 +3931,7 @@ addition, single-precision arithmetic is faster on some computers, and
 occasionally that is useful.  But not often---most programs don't use
 the type @code{float}.
 
-C would be cleaner if @code{float} were the name of the type we 
+C would be cleaner if @code{float} were the name of the type we
 use for most floating-point values; however, for historical reasons,
 that's not so.
 
@@ -4680,7 +4680,7 @@ constant.  Their types are, respectively, @code{char16_t} and
 inconvenient without including it to declare those type names.
 
 The character represented in a wide character constant can be an
-ordinary ASCII character.  @code{L'a'}, @code{u'a'} and @code{U'a'} 
+ordinary ASCII character.  @code{L'a'}, @code{u'a'} and @code{U'a'}
 are all valid, and they are all equal to @code{'a'}.
 
 In all three kinds of wide character constants, you can write a
@@ -5020,7 +5020,7 @@ them later.  Here's a simple example to illustrate the practice:
   i = 5;
 
   @r{@dots{}}
-  
+
   return *ptr;   /* @r{Returns 5, fetched from @code{i}.}  */
 @}
 @end example
@@ -5195,7 +5195,7 @@ extract_int_or_double (void *ptr, bool its_an_int)
 @{
   if (its_an_int)
     handle_an_int (*(int *)ptr);
-  else 
+  else
     handle_a_double (*(double *)ptr);
 @}
 @end example
@@ -5765,7 +5765,7 @@ GNU C does not require this.
 * const Fields::                 Making structure fields immutable.
 * Zero Length::                  Zero-length array as a variable-length object.
 * Flexible Array Fields::        Another approach to variable-length objects.
-* Overlaying Structures::        Casting one structure type 
+* Overlaying Structures::        Casting one structure type
                                    over an object of another structure type.
 * Structure Assignment::         Assigning values to structure objects.
 * Unions::                       Viewing the same object in different types.
@@ -6703,7 +6703,7 @@ definition for the structure type.
 
 When several structure types contain pointers to each other, you can
 define the types in any order because pointers to types that come
-later are incomplete types.  Thus, 
+later are incomplete types.  Thus,
 Here is an example.
 
 @example
@@ -6723,7 +6723,7 @@ struct employee_list
   struct employee_list *next;  /* @r{incomplete type.}  */
   @r{@dots{}}
 @};
-  
+
 /* @r{A group points to one employee_list.}  */
 struct group
 @{
@@ -7161,7 +7161,7 @@ pointer to the array's element at index zero.  The code can operate
 on the pointer, and through that on individual elements of the array,
 but it can't get and operate on the array as a unit.
 
-There are three exceptions to this conversion rule, but none of them 
+There are three exceptions to this conversion rule, but none of them
 offers a way to operate on the array as a whole.
 
 First, @samp{&} applied to an expression with array type gives you the
@@ -11316,13 +11316,13 @@ struct list
 inline struct list *
 list_first (struct list *p)
 @{
-  return p->first;  
+  return p->first;
 @}
 
 inline struct list *
 list_second (struct list *p)
 @{
-  return p->second;  
+  return p->second;
 @}
 @end example
 
@@ -11896,7 +11896,7 @@ blocks could have their own variables, also named @code{x}, without
 any conflict between those variables.
 
 A variable declared inside a subblock has a scope limited to
-that subblock, 
+that subblock,
 
 @example
 @group
@@ -11970,7 +11970,7 @@ foo (int x)
 
 @noindent
 This prints the value of @code{x} the function parameter, rather than
-the value of the file-scope variable @code{x}.  However, 
+the value of the file-scope variable @code{x}.
 
 Labels (@pxref{goto Statement}) have @dfn{function} scope: each label
 is visible for the whole of the containing function body, both before
@@ -12896,7 +12896,7 @@ d[2]; int i[4]; @} u; int i; @};} because there's a @code{double}
 inside it somewhere.
 
 @item
-A character type.                                                            
+A character type.
 @end itemize
 
 What do these rules say about the example in this subsection?