[DOCPATCH] @example -> @smallexample

[ja2morri at csclub dot uwaterloo dot ca (James Morrison)]

 Hi,

  The patch changes the few remaining @example's to use @smallexample and
uses @r{} in any c++ style comments I was able to find in gcc/doc .

Bootstrapped and ran make info, ok for mainline?

Jim

2004-09-17  James Morrison  <phython@gcc.gnu.org>

	* doc/cfg.texi: Use @smallexample.
	* doc/md.texi: Likewise.
	* doc/tree-ssa.texi: Likewise.
	* doc/extend.texi: Likewise.  Use @r{} in comments.
	* doc/trouble.texi: Use @r{} in comments.

Index: doc/cfg.texi
===================================================================
RCS file: /cvsroot/gcc/gcc/gcc/doc/cfg.texi,v
retrieving revision 1.5
diff -u -p -r1.5 cfg.texi
--- doc/cfg.texi	11 Sep 2004 08:34:18 -0000	1.5
+++ doc/cfg.texi	17 Sep 2004 13:00:40 -0000
@@ -120,7 +120,7 @@ in the various @file{tree-*} files.
 The following snippet will pretty-print all the statements of the
 program in the GIMPLE representation.
 
-@example
+@smallexample
 FOR_EACH_BB (bb)
   @{
      block_stmt_iterator si;
@@ -131,7 +131,7 @@ FOR_EACH_BB (bb)
           print_generic_stmt (stderr, stmt, 0);
        @}
   @}
-@end example
+@end smallexample
 
 
 @node Edges
@@ -231,7 +231,7 @@ stages of the compilation process, GCC t
 graphs by factoring computed jumps.  For example, given the following
 series of jumps, 
 
-@example
+@smallexample
   goto *x;
   [ ... ]
 
@@ -240,13 +240,13 @@ series of jumps, 
 
   goto *x;
   [ ... ]
-@end example
+@end smallexample
 
 @noindent
 factoring the computed jumps results in the following code sequence
 which has a much simpler flow graph:
 
-@example
+@smallexample
   goto y;
   [ ... ]
 
@@ -258,7 +258,7 @@ which has a much simpler flow graph:
 
 y:
   goto *x;
-@end example
+@end smallexample
 
 However, the classic problem with this transformation is that it has a
 runtime cost in there resulting code: An extra jump.  Therefore, the
Index: doc/extend.texi
===================================================================
RCS file: /cvsroot/gcc/gcc/gcc/doc/extend.texi,v
retrieving revision 1.215
diff -u -p -r1.215 extend.texi
--- doc/extend.texi	10 Sep 2004 11:26:20 -0000	1.215
+++ doc/extend.texi	17 Sep 2004 13:00:45 -0000
@@ -3610,13 +3610,13 @@ it as input or output but if this is not
 @samp{memory}.  As an example, if you access ten bytes of a string, you
 can use a memory input like:
 
-@example
+@smallexample
 @{"m"( (@{ struct @{ char x[10]; @} *p = (void *)ptr ; *p; @}) )@}.
-@end example
+@end smallexample
 
 Note that in the following example the memory input is necessary,
 otherwise GCC might optimize the store to @code{x} away:
-@example
+@smallexample
 int foo ()
 @{
   int x = 42;
@@ -3626,7 +3626,7 @@ int foo ()
         "=&d" (r) : "a" (y), "m" (*y));
   return result;     
 @}
-@end example
+@end smallexample
 
 You can put multiple assembler instructions together in a single
 @code{asm} template, separated by the characters normally used in assembly
@@ -9246,14 +9246,14 @@ namespace std @{
     template <class T> struct A @{ @};
   @}
   using namespace debug __attribute ((__strong__));
-  template <> struct A<int> @{ @};   // ok to specialize
+  template <> struct A<int> @{ @};   // @r{ok to specialize}
 
   template <class T> void f (A<T>);
 @}
 
 int main()
 @{
-  f (std::A<float>());             // lookup finds std::f
+  f (std::A<float>());             // @r{lookup finds std::f}
   f (std::A<int>());
 @}
 @end smallexample
@@ -9270,7 +9270,7 @@ Sample problematic code is:
 
 @smallexample
   struct S @{ ~S(); @};
-  extern void bar();    // is written in Java, and may throw exceptions
+  extern void bar();    // @r{is written in Java, and may throw exceptions}
   void foo()
   @{
     S s;
Index: doc/md.texi
===================================================================
RCS file: /cvsroot/gcc/gcc/gcc/doc/md.texi,v
retrieving revision 1.110
diff -u -p -r1.110 md.texi
--- doc/md.texi	11 Sep 2004 08:34:23 -0000	1.110
+++ doc/md.texi	17 Sep 2004 13:00:48 -0000
@@ -771,16 +771,16 @@ instruction operands on a RISC machine.
 This is a slight variant on @code{register_operand} which works around
 a limitation in the machine-description reader.
 
-@example
+@smallexample
 (match_operand @var{n} "pmode_register_operand" @var{constraint})
-@end example
+@end smallexample
 
 @noindent
 means exactly what
 
-@example
+@smallexample
 (match_operand:P @var{n} "register_operand" @var{constraint})
-@end example
+@end smallexample
 
 @noindent
 would mean, if the machine-description reader accepted @samp{:P}
Index: doc/tree-ssa.texi
===================================================================
RCS file: /cvsroot/gcc/gcc/gcc/doc/tree-ssa.texi,v
retrieving revision 1.9
diff -u -p -r1.9 tree-ssa.texi
--- doc/tree-ssa.texi	11 Sep 2004 08:34:26 -0000	1.9
+++ doc/tree-ssa.texi	17 Sep 2004 13:00:49 -0000
@@ -1193,7 +1193,7 @@ marked as an alias tag and added to the 
 
 For instance, consider the following function:
 
-@example
+@smallexample
 foo (int i)
 @{
   int *p, *q, a, b;
@@ -1208,7 +1208,7 @@ foo (int i)
   a = b + 2;
   return *p;
 @}
-@end example
+@end smallexample
 
 After aliasing analysis has finished, the type memory tag for
 pointer @code{p} will have two aliases, namely variables @code{a} and
@@ -1216,7 +1216,7 @@ pointer @code{p} will have two aliases, 
 Every time pointer @code{p} is dereferenced, we want to mark the
 operation as a potential reference to @code{a} and @code{b}.
 
-@example
+@smallexample
 foo (int i)
 @{
   int *p, a, b;
@@ -1239,7 +1239,7 @@ foo (int i)
   # VUSE <b_8>;
   return *p_1;
 @}
-@end example
+@end smallexample
 
 In certain cases, the list of may aliases for a pointer may grow
 too large.  This may cause an explosion in the number of virtual
Index: doc/trouble.texi
===================================================================
RCS file: /cvsroot/gcc/gcc/gcc/doc/trouble.texi,v
retrieving revision 1.25
diff -u -p -r1.25 trouble.texi
--- doc/trouble.texi	24 Aug 2004 08:46:15 -0000	1.25
+++ doc/trouble.texi	17 Sep 2004 13:00:49 -0000
@@ -910,11 +910,11 @@ of instantiation.  For example, consider
   struct A @{
     template <typename T>
     void f () @{
-      foo (1);        // 1
-      int i = N;      // 2
+      foo (1);        // @r{1}
+      int i = N;      // @r{2}
       T t;
-      t.bar();        // 3
-      foo (t);        // 4
+      t.bar();        // @r{3}
+      foo (t);        // @r{4}
     @}
 
     static const int N;