One space indentation.

1 files changed, 64 insertions, 7 deletions

diff --git a/include/mruby.h b/include/mruby.h
index 2f4ddac02..c487126d6 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -181,12 +181,13 @@ typedef mrb_value (*mrb_func_t)(mrb_state *mrb, mrb_value);
  *
  *      !!!c
  *      void mrb_example_gem_init(mrb_state* mrb) {
- *              struct RClass *example_class;
- *              example_class = mrb_define_class(mrb, "Example_Class", mrb->object_class);
+ *          struct RClass *example_class;
+ * 
+ *          example_class = mrb_define_class(mrb, "Example_Class", mrb->object_class);
  *      }
  *
  *      void mrb_example_gem_final(mrb_state* mrb) {
- *              //free(TheAnimals);
+ *          //free(TheAnimals);
  *      }
  *
  * @param [mrb_state *] mrb The current mruby state.
@@ -199,6 +200,7 @@ MRB_API struct RClass *mrb_define_class(mrb_state *mrb, const char *name, struct
 
 /**
  * Defines a new module.
+ * 
  * @param [mrb_state *] mrb_state* The current mruby state.
  * @param [const char *] char* The name of the module.
  * @return [struct RClass *] Reference to the newly defined module.
@@ -211,7 +213,7 @@ MRB_API mrb_value mrb_singleton_class(mrb_state*, mrb_value);
  * Equivalent to: 
  *
  *   module B                                                                                                         
- *     include A                                                                                                      
+ *     include A                                                                                                    
  *   end 
  * @param [mrb_state *] mrb_state* The current mruby state.
  * @param [struct RClass *] RClass* A reference to module or a class.
@@ -243,6 +245,7 @@ MRB_API void mrb_prepend_module(mrb_state*, struct RClass*, struct RClass*);
  *     mrb_value example_method(mrb_state* mrb, mrb_value self)
  *     {
  *          puts("Executing example command!");
+ * 
  *          return self;
  *     }
  *
@@ -267,16 +270,20 @@ MRB_API void mrb_define_method(mrb_state *mrb, struct RClass *cla, const char *n
  *     # Ruby style
  *     class Foo
  *      def Foo.bar
+ * 
  *      end
  *     end
  *
  *     // C style
  *     mrb_value bar_method(mrb_state* mrb, mrb_value self){
+ * 
  *       return mrb_nil_value();
  *     }
  *     void mrb_example_gem_init(mrb_state* mrb){
  *       struct RClass *foo;
+ * 
  *       foo = mrb_define_class(mrb, "Foo", mrb->object_class);
+ * 
  *       mrb_define_class_method(mrb, foo, "bar", bar_method, MRB_ARGS_NONE());
  *     }
  * @param [mrb_state *] mrb_state* The MRuby state reference. 
@@ -296,15 +303,19 @@ MRB_API void mrb_define_singleton_method(mrb_state*, struct RObject*, const char
  *        # Ruby style
  *        module Foo                                                                                                  
  *          def Foo.bar
+ * 
  *          end                                                                                                 
  *        end                                                                                                             
  *        // C style                                                                                                      
- *        mrb_value bar_method(mrb_state* mrb, mrb_value self){                                                          
+ *        mrb_value bar_method(mrb_state* mrb, mrb_value self){
+ * 
  *          return mrb_nil_value();                                                                                                     
  *        }                                                                                                               
  *        void mrb_example_gem_init(mrb_state* mrb){                                                                     
- *          struct RClass *foo;                                                                                           
- *          foo = mrb_define_module(mrb, "Foo");                                             
+ *          struct RClass *foo;
+ * 
+ *          foo = mrb_define_module(mrb, "Foo");  
+ * 
  *          mrb_define_module_function(mrb, foo, "bar", bar_method, MRB_ARGS_NONE());
  *        }    
  *  @param [mrb_state *] mrb_state* The MRuby state reference.
@@ -329,13 +340,16 @@ MRB_API void mrb_define_module_function(mrb_state*, struct RClass*, const char*,
  *          // C style
  *          #include <stdio.h> 
  *          #include <mruby.h>
+ * 
  *          void
  *          mrb_example_gem_init(mrb_state* mrb){
+ * 
  *            mrb_define_const(mrb, mrb->kernel_module, "AGE", mrb_fixnum_value(22));
  *          }
  *
  *          mrb_value
  *          mrb_example_gem_final(mrb_state* mrb){
+ * 
  *          }
  *  @param [mrb_state *] mrb_state* The MRuby state reference.
  *  @param [struct RClass *] RClass* A class or module the constant is defined in.
@@ -353,6 +367,7 @@ MRB_API void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_
  *
  *     class ExampleClassA
  *       def example_method
+ * 
  *         "example"
  *       end
  *     end
@@ -360,6 +375,7 @@ MRB_API void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_
  *
  *     class ExampleClassB < ExampleClassA
  *       undef_method :example_method
+ * 
  *     end
  *
  *     ExampleClassB.new.example_method # => undefined method 'example_method' for ExampleClassB (NoMethodError)
@@ -370,6 +386,7 @@ MRB_API void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_
  *  
  *     mrb_value
  *     mrb_example_method(mrb_state *mrb){
+ * 
  *       return mrb_str_new_cstr(mrb, "example");
  *     }
  *
@@ -378,13 +395,20 @@ MRB_API void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_
  *       struct RClass *example_class_a;
  *       struct RClass *example_class_b;
  *       struct RClass *example_class_c;
+ * 
  *       example_class_a = mrb_define_class(mrb, "ExampleClassA", mrb->object_class);
+ * 
  *       mrb_define_method(mrb, example_class_a, "example_method", mrb_example_method, MRB_ARGS_NONE());
+ * 
  *       example_class_b = mrb_define_class(mrb, "ExampleClassB", example_class_a);
+ * 
  *       example_class_c = mrb_define_class(mrb, "ExampleClassC", example_class_b);
+ * 
  *       mrb_undef_method(mrb, example_class_c, "example_method");
  *     }
+ * 
  *     mrb_example_gem_final(mrb_state* mrb){
+ * 
  *     }
  * @param [mrb_state*] mrb_state* The mruby state reference.
  * @param [struct RClass*] RClass* A class the method will be undefined from.
@@ -399,6 +423,7 @@ MRB_API void mrb_undef_method(mrb_state*, struct RClass*, const char*);
  *      # Ruby style
  *      class ExampleClass
  *        def self.example_method
+ * 
  *          "example"
  *        end
  *      end
@@ -411,17 +436,24 @@ MRB_API void mrb_undef_method(mrb_state*, struct RClass*, const char*);
  *
  *     mrb_value
  *     mrb_example_method(mrb_state *mrb){
+ * 
  *       return mrb_str_new_cstr(mrb, "example");     
  *     }
+ * 
  *     void
  *     mrb_example_gem_init(mrb_state* mrb){
  *       struct RClass *example_class;     
+ * 
  *       example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class);
+ * 
  *       mrb_define_class_method(mrb, example_class, "example_method", mrb_example_method, MRB_ARGS_NONE());
+ * 
  *       mrb_undef_class_method(mrb, example_class, "example_method");
  *      }
+ * 
  *      void
  *      mrb_example_gem_final(mrb_state* mrb){
+ * 
  *      }
  * @param [mrb_state*] mrb_state* The mruby state reference.
  * @param [RClass*] RClass* A class the class method will be undefined from.
@@ -436,6 +468,7 @@ MRB_API void mrb_undef_class_method(mrb_state*, struct RClass*, const char*);
  *
  *     # Ruby style
  *     class ExampleClass
+ * 
  *     end
  *
  *     p ExampleClass # => #<ExampleClass:0x9958588>
@@ -449,7 +482,9 @@ MRB_API void mrb_undef_class_method(mrb_state*, struct RClass*, const char*);
  *       mrb_value obj;
  *
  *       example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class); # => class ExampleClass; end
+ * 
  *       obj = mrb_obj_new(mrb, example_class, 0, NULL); # => ExampleClass.new
+ * 
  *       mrb_p(mrb, obj); // => Kernel#p
  *      }  
  * @param [mrb_state*] mrb The current mruby state.
@@ -479,7 +514,9 @@ MRB_API mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv);
  *        mrb_value obj;
  *
  *        example_class = mrb_class_new(mrb, mrb->object_class);
+ * 
  *        obj = mrb_obj_new(mrb, example_class, 0, NULL); // => #<#<Class:0x9a945b8>:0x9a94588>
+ * 
  *        mrb_p(mrb, obj); // => Kernel#p
  *       }
  *
@@ -588,6 +625,7 @@ MRB_API mrb_value mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char
  *      # Ruby style
  *      class ExampleClass
  *        def example_method
+ * 
  *        end
  *      end
  *
@@ -601,8 +639,11 @@ MRB_API mrb_value mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char
  *        mrb_bool obj_resp;
  *
  *        example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class);
+ * 
  *        mrb_define_method(mrb, example_class, "example_method", exampleMethod, MRB_ARGS_NONE());
+ * 
  *        mid = mrb_intern_str(mrb, mrb_str_new_cstr(mrb, "example_method" ));
+ * 
  *        obj_resp = mrb_obj_respond_to(mrb, example_class, mid); // => 1(true in Ruby world)
  *      
  *        // If mrb_obj_respond_to returns 1 then puts "True"
@@ -755,16 +796,24 @@ mrb_get_argc(mrb_state *mrb) /* get argc */
  *      #include <stdio.h>
  *      #include <mruby.h>
  *      #include "mruby/compile.h"
+ * 
  *      int
  *      main()
  *      {
  *        mrb_int i = 99;
+ * 
  *        mrb_state *mrb = mrb_open();
+ * 
  *        if (!mrb) { }
+ * 
  *        FILE *fp = fopen("test.rb","r");
+ * 
  *        mrb_value obj = mrb_load_file(mrb,fp);
+ * 
  *        mrb_funcall(mrb, obj, "method_name", 1, mrb_fixnum_value(i));
+ * 
  *        fclose(fp);
+ * 
  *        mrb_close(mrb);
  *       }
  * @param [mrb_state*] mrb_state* The current mruby state.
@@ -785,13 +834,21 @@ MRB_API mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, mrb_int,...);
  *      main()
  *      {
  *        mrb_int i = 99;
+ * 
  *        mrb_state *mrb = mrb_open();
+ * 
  *        if (!mrb) { }
+ * 
  *        mrb_sym m_sym = mrb_intern_cstr(mrb, "method_name"); // Symbol for method.
+ * 
  *        FILE *fp = fopen("test.rb","r");
+ * 
  *        mrb_value obj = mrb_load_file(mrb,fp);
+ * 
  *        mrb_funcall_argv(mrb, obj, m_sym, 1, &obj); // Calling ruby function from test.rb.
+ * 
  *        fclose(fp);
+ * 
  *        mrb_close(mrb);
  *       }
  * @param [mrb_state*] mrb_state* The current mruby state.