More consistent formatting of examples in documentation

Doc/Manual/Go.html

@@ -639,12 +639,12 @@ public:
   virtual ~FooBarAbstract() {};
 
   std::string FooBar() {
-          return this->Foo() + ", " + this->Bar();
+    return this->Foo() + ", " + this->Bar();
   };
 
 protected:
   virtual std::string Foo() {
-          return "Foo";
+    return "Foo";
   };
 
   virtual std::string Bar() = 0;

Doc/Manual/SWIG.html

@@ -1043,14 +1043,14 @@ expect :</p>
 <div class="targetlang"><pre>
 # Copy a file 
 def filecopy(source, target):
-  f1 = fopen(source, "r")
+    f1 = fopen(source, "r")
-  f2 = fopen(target, "w")
+    f2 = fopen(target, "w")
-  buffer = malloc(8192)
+    buffer = malloc(8192)
-  nbytes = fread(buffer, 8192, 1, f1)
+    nbytes = fread(buffer, 8192, 1, f1)
-  while (nbytes &gt; 0):
+    while (nbytes &gt; 0):
-    fwrite(buffer, 8192, 1, f2)
+        fwrite(buffer, 8192, 1, f2)
-          nbytes = fread(buffer, 8192, 1, f1)
+            nbytes = fread(buffer, 8192, 1, f1)
-  free(buffer)
+    free(buffer)
 </pre></div>
 
 <p>

Doc/Manual/SWIGPlus.html

@@ -777,9 +777,9 @@ the normal constructor function.  For example, if you have this:
 <pre>
 class List {
 public:
-    List();    
+  List();    
-    List(const List &amp;);      // Copy constructor
+  List(const List &amp;);      // Copy constructor
-    ...
+  ...
 };
 </pre>
 </div>
@@ -803,7 +803,7 @@ through a special function like this:
 <div class="code">
 <pre>
 List *copy_List(List *f) {
-    return new List(*f);
+  return new List(*f);
 }
 </pre>
 </div>
@@ -832,7 +832,7 @@ However, copy constructor wrappers can be generated if using the <tt>copyctor</t
 
 class List {
 public:
-    List();    
+  List();    
 };
 </pre>
 </div>
@@ -851,9 +851,9 @@ could be wrapped, but they had to be renamed.  For example:
 <pre>
 class Foo {
 public:
-    Foo();
+  Foo();
   %name(CopyFoo) Foo(const Foo &amp;);
-    ...
+  ...
 };
 </pre>
 </div>
@@ -969,8 +969,8 @@ not primitive types, such as classes. For instance, if you had another class lik
 <pre>
 class Foo {
 public:
-    List items;
+  List items;
-    ...
+  ...
 </pre>
 </div>
 
@@ -982,10 +982,10 @@ For example:
 <div class="code">
 <pre>
 List *Foo_items_get(Foo *self) {
-    return &amp;self-&gt;items;
+  return &amp;self-&gt;items;
 }
 void Foo_items_set(Foo *self, List *value) {
-    self-&gt;items = *value;
+  self-&gt;items = *value;
 }
 </pre>
 </div>
@@ -1007,10 +1007,10 @@ It is the naturalvar feature and can be used to effectively change the way acces
 <div class="code">
 <pre>
 const List &amp;Foo_items_get(Foo *self) {
-    return self-&gt;items;
+  return self-&gt;items;
 }
 void Foo_items_set(Foo *self, const List &amp;value) {
-    self-&gt;items = value;
+  self-&gt;items = value;
 }
 </pre>
 </div>
@@ -1105,7 +1105,7 @@ SWIG will wrap all types of functions that have default arguments. For example m
 <pre>
 class Foo {
 public:
-    void bar(int x, int y = 3, int z = 4);
+  void bar(int x, int y = 3, int z = 4);
 };
 </pre>
 </div>
@@ -1120,9 +1120,9 @@ Thus for the example above, it is as if we had instead given the following to SW
 <pre>
 class Foo {
 public:
-    void bar(int x, int y, int z);
+  void bar(int x, int y, int z);
-    void bar(int x, int y);
+  void bar(int x, int y);
-    void bar(int x);
+  void bar(int x);
 };
 </pre>
 </div>
@@ -1158,7 +1158,7 @@ can be re-activated by using the <tt>compactdefaultargs</tt>
 %feature("compactdefaultargs") Foo::bar;
 class Foo {
 public:
-    void bar(int x, int y = 3, int z = 4);
+  void bar(int x, int y = 3, int z = 4);
 };
 </pre>
 </div>
@@ -1485,8 +1485,8 @@ class A;
 
 %feature("valuewrapper") B;
 struct B { 
-    B();
+  B();
-    // ....
+  // ....
 };   
 </pre></div>
 
@@ -3000,15 +3000,15 @@ provide an expanded version of the class directly like this:
 %rename(intList) List&lt;int&gt;;       // Rename to a suitable identifier
 class List&lt;int&gt; {
 private:
-    int *data;
+  int *data;
-    int nitems;
+  int nitems;
-    int maxitems;
+  int maxitems;
 public:
-    List(int max);
+  List(int max);
-    ~List();
+  ~List();
-    void append(int obj);
+  void append(int obj);
-    int length();
+  int length();
-    int get(int n);
+  int get(int n);
 };
 </pre>
 </div>
@@ -3244,15 +3244,15 @@ a class like this,
 <pre>
 template&lt;&gt; class List&lt;int&gt; {
 private:
-    int *data;
+  int *data;
-    int nitems;
+  int nitems;
-    int maxitems;
+  int maxitems;
 public:
-    List(int max);
+  List(int max);
-    ~List();
+  ~List();
-    void append(int obj);
+  void append(int obj);
-    int length();
+  int length();
-    int get(int n);
+  int get(int n);
 };
 </pre>
 </div>
@@ -3275,15 +3275,15 @@ code defines a template that is applied when the template argument is a pointer.
 <pre>
 template&lt;class T&gt; class List&lt;T*&gt; {
 private:
-    T *data;
+  T *data;
-    int nitems;
+  int nitems;
-    int maxitems;
+  int maxitems;
 public:
-    List(int max);
+  List(int max);
-    ~List();
+  ~List();
-    void append(int obj);
+  void append(int obj);
-    int length();
+  int length();
-    T get(int n);
+  T get(int n);
 };
 </pre>
 </div>
@@ -3587,11 +3587,11 @@ It is also possible to separate these declarations from the template class.  For
 
 ...
 template&lt;class T&gt; class List {
-    ...
+  ...
-    public:
+  public:
-    List() { }
+  List() { }
-    T get(int index);
+  T get(int index);
-    ...
+  ...
 };
 </pre>
 </div>
@@ -3609,9 +3609,9 @@ additional methods to a specific instantiation. For example:
 %template(intList) List&lt;int&gt;;
 
 %extend List&lt;int&gt; {
-    void blah() {
+  void blah() {
-          printf("Hey, I'm an List&lt;int&gt;!\n");
+    printf("Hey, I'm an List&lt;int&gt;!\n");
-    }
+  }
 };
 </pre>
 </div>
@@ -3698,7 +3698,7 @@ template &lt;class T&gt; class OuterTemplateClass {};
 // OuterTemplateClass&lt;OuterClass::InnerStruct&gt; and thus the template needs
 // to be expanded with %template before the OuterClass declaration.
 %template(OuterTemplateClass_OuterClass__InnerStruct)
-    OuterTemplateClass&lt;OuterClass::InnerStruct&gt;
+  OuterTemplateClass&lt;OuterClass::InnerStruct&gt;
 
 
 // Don't forget to use %feature("flatnested") for OuterClass::InnerStruct and
@@ -3736,7 +3736,7 @@ introduced a new class name.  This name could then be used with other directives
 <pre>
 %template(vectori) vector&lt;int&gt;;
 %extend vectori {
-    void somemethod() { }
+  void somemethod() { }
 };
 </pre>
 </div>
@@ -3750,7 +3750,7 @@ as the class name.  For example:
 <pre>
 %template(vectori) vector&lt;int&gt;;
 %extend vector&lt;int&gt; {
-    void somemethod() { }
+  void somemethod() { }
 };
 </pre>
 </div>
@@ -4011,7 +4011,7 @@ in a different namespace.  For example:
 <div class="code">
 <pre>
 namespace foo {
-    template&lt;typename T&gt; T max(T a, T b) { return a &gt; b ? a : b; }
+  template&lt;typename T&gt; T max(T a, T b) { return a &gt; b ? a : b; }
 }
 
 using foo::max;
@@ -4020,8 +4020,8 @@ using foo::max;
 %template(maxfloat) foo::max&lt;float&gt;;    // Okay (qualified name).
 
 namespace bar {
-    using namespace foo;
+  using namespace foo;
-    %template(maxdouble)  max&lt;double&gt;;    // Okay.
+  %template(maxdouble)  max&lt;double&gt;;    // Okay.
 }
 </pre>
 </div>
@@ -4445,10 +4445,10 @@ struct Error4 : EBase { };
 
 class Foo {
 public:
-    ...
+  ...
-    void bar();
+  void bar();
-    void blah() throw(Error1, Error2, Error3, Error4);
+  void blah() throw(Error1, Error2, Error3, Error4);
-    ...
+  ...
 };
 </pre>
 </div>
@@ -4545,8 +4545,8 @@ public:
 // Ordinary class
 class Foo_Impl {
 public:
-    int x;
+  int x;
-    virtual void bar();
+  virtual void bar();
     ...
 };
 
@@ -4555,13 +4555,13 @@ typedef SmartPtr&lt;Foo_Impl&gt; Foo;
 
 // Create smart pointer Foo
 Foo make_Foo() {
-    return SmartPtr&lt;Foo_Impl&gt;(new Foo_Impl());
+  return SmartPtr&lt;Foo_Impl&gt;(new Foo_Impl());
 }
 
 // Do something with smart pointer Foo
 void do_something(Foo f) {
-    printf("x = %d\n", f-&gt;x);
+  printf("x = %d\n", f-&gt;x);
-    f-&gt;bar();
+  f-&gt;bar();
 }
 
 // Call the wrapped smart pointer proxy class in the target language 'Foo'
@@ -4660,13 +4660,13 @@ example, if you have this code</p>
 <pre>
 class Foo {
 public:
-    int x;
+  int x;
 };
 
 class Bar {
 public:
-    int x;       
+  int x;       
-    Foo *operator-&gt;();
+  Foo *operator-&gt;();
 };
 </pre>
 </div>
@@ -4970,14 +4970,14 @@ you wrap this code in Python, the module works just like you would expect:
 <pre>
 class Foo {
 protected:
-    int x;
+  int x;
-    int blah(int x);
+  int blah(int x);
 };
 
 class Bar : public Foo {
 public:
-    using Foo::x;       // Make x public
+  using Foo::x;       // Make x public
-    using Foo::blah;    // Make blah public
+  using Foo::blah;    // Make blah public
 };
 </pre>
 </div>