From 4e267d74c66b0804e6cbcd69941d7fc778afe74c Mon Sep 17 00:00:00 2001 From: "Ralph Desir(Mav7)" Date: Fri, 11 Dec 2015 01:52:44 -0500 Subject: Added YARD docs in new mruby.h --- include/mruby.h | 431 +++++++++++++++++++++++++++++--------------------------- 1 file changed, 226 insertions(+), 205 deletions(-) (limited to 'include') diff --git a/include/mruby.h b/include/mruby.h index 9d482f35e..2f4ddac02 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -263,28 +263,22 @@ MRB_API void mrb_define_method(mrb_state *mrb, struct RClass *cla, const char *n * Defines a class method. * * Example: - * # Ruby style - * class Foo * - * def Foo.bar + * # Ruby style + * class Foo + * def Foo.bar + * end * 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()); - * - * } + * // 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. * @param [struct RClass *] RClass* The class where the class method will be defined. * @param [const char *] char* The name of the class method being defined. @@ -298,26 +292,21 @@ MRB_API void mrb_define_singleton_method(mrb_state*, struct RObject*, const char * Defines a module fuction. * * Example: - * # Ruby style - * module 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_module(mrb, "Foo"); - * - * mrb_define_module_function(mrb, foo, "bar", bar_method, MRB_ARGS_NONE()); - * - * } + * + * # Ruby style + * module 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_module(mrb, "Foo"); + * mrb_define_module_function(mrb, foo, "bar", bar_method, MRB_ARGS_NONE()); + * } * @param [mrb_state *] mrb_state* The MRuby state reference. * @param [struct RClass *] RClass* The module where the module function will be defined. * @param [const char *] char* The name of the module function being defined. @@ -330,29 +319,24 @@ MRB_API void mrb_define_module_function(mrb_state*, struct RClass*, const char*, * Defines a constant. * * Example: - * # Ruby style - * - * class ExampleClass - * - * AGE = 22 - * - * end - * - * // C style - * #include - * #include * - * void - * mrb_example_gem_init(mrb_state* mrb){ - * - * mrb_define_const(mrb, mrb->kernel_module, "AGE", mrb_fixnum_value(22)); + * # Ruby style * - * } + * class ExampleClass + * AGE = 22 + * end * - * mrb_value - * mrb_example_gem_final(mrb_state* mrb){ + * // C style + * #include + * #include + * 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. * @param [const char *] name The name of the constant being defined. @@ -364,59 +348,44 @@ MRB_API void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_ * Undefines a method. * * Example: - * # Ruby style * - * class ExampleClassA + * # Ruby style * - * def example_method - * "example" + * class ExampleClassA + * def example_method + * "example" + * end * end + * ExampleClassA.new.example_method # => example * - * end - * - * ExampleClassA.new.example_method # => example - * - * class ExampleClassB < ExampleClassA - * - * undef_method :example_method - * - * end + * class ExampleClassB < ExampleClassA + * undef_method :example_method + * end * - * ExampleClassB.new.example_method # => undefined method 'example_method' for ExampleClassB (NoMethodError) + * ExampleClassB.new.example_method # => undefined method 'example_method' for ExampleClassB (NoMethodError) * - * // C style - * #include - * #include + * // C style + * #include + * #include * - * 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_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){ - * - * } + * 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_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. * @param [const char*] constchar* The name of the method to be undefined. @@ -425,47 +394,35 @@ MRB_API void mrb_undef_method(mrb_state*, struct RClass*, const char*); /** * Undefine a class method. - * * Example: - * # Ruby style - * - * class ExampleClass - * def self.example_method - * "example" - * end * - * end + * # Ruby style + * class ExampleClass + * def self.example_method + * "example" + * end + * end * - * ExampleClass.example_method + * ExampleClass.example_method * - * // C style - * #include - * #include - * - * mrb_value - * mrb_example_method(mrb_state *mrb){ - * - * return mrb_str_new_cstr(mrb, "example"); - * - * } - * - * void - * mrb_example_gem_init(mrb_state* mrb){ + * // C style + * #include + * #include * - * 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){ - * - * } + * 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. * @param [constchar*] constchar* The name of the class method to be undefined. @@ -477,24 +434,24 @@ MRB_API void mrb_undef_class_method(mrb_state*, struct RClass*, const char*); * * Example: * - * # Ruby style - * class ExampleClass - * end + * # Ruby style + * class ExampleClass + * end * - * p ExampleClass # => # - * // C style - * #include - * #include + * p ExampleClass # => # + * // C style + * #include + * #include * - * void - * mrb_example_gem_init(mrb_state* mrb) { - * struct RClass *example_class; - * mrb_value obj; + * void + * mrb_example_gem_init(mrb_state* mrb) { + * struct RClass *example_class; + * 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 - * } + * 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. * @param [RClass*] c Reference to the class of the new object. * @param [mrb_int] argc Number of arguments in argv @@ -516,15 +473,15 @@ MRB_API mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv); * * Example: * - * void - * mrb_example_gem_init(mrb_state* mrb) { - * struct RClass *example_class; - * mrb_value obj; + * void + * mrb_example_gem_init(mrb_state* mrb) { + * struct RClass *example_class; + * mrb_value obj; * - * example_class = mrb_class_new(mrb, mrb->object_class); - * obj = mrb_obj_new(mrb, example_class, 0, NULL); // => #<#:0x9a94588> - * mrb_p(mrb, obj); // => Kernel#p - * } + * example_class = mrb_class_new(mrb, mrb->object_class); + * obj = mrb_obj_new(mrb, example_class, 0, NULL); // => #<#:0x9a94588> + * mrb_p(mrb, obj); // => Kernel#p + * } * * @param [mrb_state*] mrb The current mruby state. * @param [struct RClass *] super The super class or parent. @@ -536,12 +493,12 @@ MRB_API struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super); * Creates a new module, Module. * * Example: - * void - * mrb_example_gem_init(mrb_state* mrb) { - * struct RClass *example_module; + * void + * mrb_example_gem_init(mrb_state* mrb) { + * struct RClass *example_module; * - * example_module = mrb_module_new(mrb); - * } + * example_module = mrb_module_new(mrb); + * } * * @param [mrb_state*] mrb The current mruby state. * @return [struct RClass *] Reference to the new module. @@ -552,23 +509,23 @@ MRB_API struct RClass * mrb_module_new(mrb_state *mrb); * Returns an mrb_bool. True if class was defined, and false if the class was not defined. * * Example: - * void - * mrb_example_gem_init(mrb_state* mrb) { - * struct RClass *example_class; - * mrb_bool cd; + * void + * mrb_example_gem_init(mrb_state* mrb) { + * struct RClass *example_class; + * mrb_bool cd; * - * example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class); - * cd = mrb_class_defined(mrb, "ExampleClass"); + * example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class); + * cd = mrb_class_defined(mrb, "ExampleClass"); * - * // If mrb_class_defined returns 1 then puts "True" - * // If mrb_class_defined returns 0 then puts "False" - * if (cd == 1){ - * puts("True"); - * } - * else { - * puts("False"); + * // If mrb_class_defined returns 1 then puts "True" + * // If mrb_class_defined returns 0 then puts "False" + * if (cd == 1){ + * puts("True"); + * } + * else { + * puts("False"); + * } * } - * } * * @param [mrb_state*] mrb The current mruby state. * @param [const char *] name A string representing the name of the class. @@ -627,36 +584,36 @@ MRB_API mrb_value mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char * Returns true if obj responds to the given method. If the method was defined for that * class it returns true, it returns false otherwise. * - * Example: - * # Ruby style - * class ExampleClass - * def example_method + * Example: + * # Ruby style + * class ExampleClass + * def example_method + * end * end - * end * - * ExampleClass.new.respond_to?(:example_method) # => true + * ExampleClass.new.respond_to?(:example_method) # => true * - * // C style - * void - * mrb_example_gem_init(mrb_state* mrb) { - * struct RClass *example_class; - * mrb_sym mid; - * mrb_bool obj_resp; + * // C style + * void + * mrb_example_gem_init(mrb_state* mrb) { + * struct RClass *example_class; + * mrb_sym mid; + * 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) + * 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" - * // If mrb_obj_respond_to returns 0 then puts "False" - * if (obj_resp == 1) { - * puts("True"); - * } - * else if (obj_resp == 0) { - * puts("False"); + * // If mrb_obj_respond_to returns 1 then puts "True" + * // If mrb_obj_respond_to returns 0 then puts "False" + * if (obj_resp == 1) { + * puts("True"); + * } + * else if (obj_resp == 0) { + * puts("False"); + * } * } - * } * * @param [mrb_state*] mrb The current mruby state. * @param [struct RClass *] c A reference to a class. @@ -794,10 +751,74 @@ mrb_get_argc(mrb_state *mrb) /* get argc */ /** * Call existing ruby functions. + * + * #include + * #include + * #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. + * @param [mrb_value] mrb_value A reference to an mruby value. + * @param [const char*] const char* The name of the method. + * @param [mrb_int] mrb_int The number of arguments the method has. + * @param [...] ... Variadic values(not type safe!). + * @return [mrb_value] mrb_value mruby function value. */ MRB_API mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, mrb_int,...); +/** + * Call existing ruby functions. This is basically the type safe version of mrb_funcall. + * + * #include + * #include + * #include "mruby/compile.h" + * 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. + * @param [mrb_value] mrb_value A reference to an mruby value. + * @param [mrb_sym] mrb_sym The symbol representing the method. + * @param [mrb_int] mrb_int The number of arguments the method has. + * @param [const mrb_value*] mrb_value* Pointer to the object. + * @return [mrb_value] mrb_value mruby function value. + * @see mrb_funcall + */ MRB_API mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, mrb_int, const mrb_value*); +/** + * Call existing ruby functions with a block. + */ MRB_API mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, mrb_int, const mrb_value*, mrb_value); +/** + * Create a symbol + * + * # Ruby style: + * :pizza # => :pizza + * + * // C style: + * mrb_sym m_sym = mrb_intern_cstr(mrb, "pizza"); // => :pizza + * @param [mrb_state*] mrb_state* The current mruby state. + * @param [const char*] const char* The name of the method. + * @return [mrb_sym] mrb_sym A symbol. + */ MRB_API mrb_sym mrb_intern_cstr(mrb_state*,const char*); MRB_API mrb_sym mrb_intern(mrb_state*,const char*,size_t); MRB_API mrb_sym mrb_intern_static(mrb_state*,const char*,size_t); -- cgit v1.2.3 From e27985416fd5dc3314efebbe943e935ff997a5f8 Mon Sep 17 00:00:00 2001 From: Ralph Desir Date: Sat, 12 Dec 2015 18:28:42 -0500 Subject: One space indentation. --- include/mruby.h | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 64 insertions(+), 7 deletions(-) (limited to 'include') 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 * #include + * * 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 # => # @@ -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); // => #<#: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 * #include * #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. -- cgit v1.2.3 From af3339428140e56357f3a9a08fe0f3af3732dbef Mon Sep 17 00:00:00 2001 From: Ralph Desir Date: Sat, 12 Dec 2015 20:21:53 -0500 Subject: Undid newline and whitespace on YARD doc --- include/mruby.h | 63 ++++++--------------------------------------------------- 1 file changed, 6 insertions(+), 57 deletions(-) (limited to 'include') diff --git a/include/mruby.h b/include/mruby.h index c487126d6..1ea0156e8 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -182,7 +182,6 @@ 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); * } * @@ -245,7 +244,6 @@ 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; * } * @@ -269,21 +267,16 @@ MRB_API void mrb_define_method(mrb_state *mrb, struct RClass *cla, const char *n * * # Ruby style * class Foo - * def Foo.bar - * - * end + * 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. @@ -303,19 +296,15 @@ 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){ - * * return mrb_nil_value(); * } * void mrb_example_gem_init(mrb_state* mrb){ * 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. @@ -332,24 +321,20 @@ MRB_API void mrb_define_module_function(mrb_state*, struct RClass*, const char*, * Example: * * # Ruby style - * * class ExampleClass * AGE = 22 * end - * * // C style * #include * #include * * 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. @@ -367,7 +352,6 @@ MRB_API void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_ * * class ExampleClassA * def example_method - * * "example" * end * end @@ -375,7 +359,6 @@ 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) @@ -383,10 +366,9 @@ MRB_API void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_ * // C style * #include * #include - * + * * mrb_value * mrb_example_method(mrb_state *mrb){ - * * return mrb_str_new_cstr(mrb, "example"); * } * @@ -397,18 +379,13 @@ MRB_API void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_ * 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. @@ -423,7 +400,6 @@ MRB_API void mrb_undef_method(mrb_state*, struct RClass*, const char*); * # Ruby style * class ExampleClass * def self.example_method - * * "example" * end * end @@ -436,24 +412,19 @@ 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; - * + * 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. @@ -468,7 +439,6 @@ MRB_API void mrb_undef_class_method(mrb_state*, struct RClass*, const char*); * * # Ruby style * class ExampleClass - * * end * * p ExampleClass # => # @@ -480,11 +450,8 @@ MRB_API void mrb_undef_class_method(mrb_state*, struct RClass*, const char*); * mrb_example_gem_init(mrb_state* mrb) { * struct RClass *example_class; * 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. @@ -511,12 +478,10 @@ MRB_API mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv); * void * mrb_example_gem_init(mrb_state* mrb) { * struct RClass *example_class; + * * mrb_value obj; - * * example_class = mrb_class_new(mrb, mrb->object_class); - * * obj = mrb_obj_new(mrb, example_class, 0, NULL); // => #<#:0x9a94588> - * * mrb_p(mrb, obj); // => Kernel#p * } * @@ -533,7 +498,7 @@ MRB_API struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super); * void * mrb_example_gem_init(mrb_state* mrb) { * struct RClass *example_module; - * + * * example_module = mrb_module_new(mrb); * } * @@ -625,7 +590,6 @@ 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 * @@ -639,11 +603,8 @@ 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" @@ -801,19 +762,13 @@ mrb_get_argc(mrb_state *mrb) /* get argc */ * 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. @@ -834,21 +789,15 @@ 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. -- cgit v1.2.3