Ignore:
Timestamp:
Jan 21, 2018, 12:10:09 AM (6 years ago)
Author:
coas-nagasima
Message:

prototoolに関連するプロジェクトをnewlibからmuslを使うよう変更・更新
ntshellをnewlibの下位の実装から、muslのsyscallの実装に変更・更新
以下のOSSをアップデート
・mruby-1.3.0
・musl-1.1.18
・onigmo-6.1.3
・tcc-0.9.27
以下のOSSを追加
・openssl-1.1.0e
・curl-7.57.0
・zlib-1.2.11
以下のmrbgemsを追加
・iij/mruby-digest
・iij/mruby-env
・iij/mruby-errno
・iij/mruby-iijson
・iij/mruby-ipaddr
・iij/mruby-mock
・iij/mruby-require
・iij/mruby-tls-openssl

Location:
EcnlProtoTool/trunk/mruby-1.3.0
Files:
1 edited
1 moved

Legend:

Unmodified
Added
Removed

  • EcnlProtoTool/trunk/mruby-1.3.0/include/mruby.h

    r321 r331  
    22** mruby - An embeddable Ruby implementation
    33**
    4 ** Copyright (c) mruby developers 2010-2015
     4** Copyright (c) mruby developers 2010-2017
    55**
    66** Permission is hereby granted, free of charge, to any person obtaining
    … …  
    2929#define MRUBY_H
    3030
     31#ifdef __cplusplus
     32#define __STDC_LIMIT_MACROS
     33#define __STDC_CONSTANT_MACROS
     34#define __STDC_FORMAT_MACROS
     35#endif
     36
    3137#include <stdint.h>
    3238#include <stddef.h>
    3339#include <limits.h>
    3440
     41#ifdef __cplusplus
     42#ifndef SIZE_MAX
     43#ifdef __SIZE_MAX__
     44#define SIZE_MAX __SIZE_MAX__
     45#else
     46#define SIZE_MAX std::numeric_limits<size_t>::max()
     47#endif
     48#endif
     49#endif
     50
     51#ifdef MRB_DEBUG
     52#include <assert.h>
     53#define mrb_assert(p) assert(p)
     54#define mrb_assert_int_fit(t1,n,t2,max) assert((n)>=0 && ((sizeof(n)<=sizeof(t2))||(n<=(t1)(max))))
     55#else
     56#define mrb_assert(p) ((void)0)
     57#define mrb_assert_int_fit(t1,n,t2,max) ((void)0)
     58#endif
     59
     60#if __STDC_VERSION__ >= 201112L
     61#define mrb_static_assert(exp, str) _Static_assert(exp, str)
     62#else
     63#define mrb_static_assert(exp, str) mrb_assert(exp)
     64#endif
     65
    3566#include "mrbconf.h"
     67
     68#ifdef MRB_USE_FLOAT
     69#define MRB_FLOAT_EPSILON FLT_EPSILON
     70#else
     71#define MRB_FLOAT_EPSILON DBL_EPSILON
     72#endif
     73
    3674#include "mruby/common.h"
    37 #include "mruby/value.h"
    38 #include "mruby/gc.h"
    39 #include "mruby/version.h"
     75#include <mruby/value.h>
     76#include <mruby/gc.h>
     77#include <mruby/version.h>
    4078
    4179/**
    … …  
    76114  int nregs;
    77115  int ridx;
    78   int eidx;
     116  int epos;
    79117  struct REnv *env;
    80118  mrb_code *pc;                 /* return address */
    … …  
    88126  MRB_FIBER_CREATED = 0,
    89127  MRB_FIBER_RUNNING,
    90   MRB_FIBER_RESUMING,
     128  MRB_FIBER_RESUMED,
    91129  MRB_FIBER_SUSPENDED,
    92130  MRB_FIBER_TRANSFERRED,
    … …  
    106144  int rsize;
    107145  struct RProc **ensure;                  /* ensure handler stack */
    108   int esize;
     146  int esize, eidx;
    109147
    110148  enum mrb_fiber_state status;
     149  mrb_bool vmexec;
    111150  struct RFiber *fib;
    112151};
    … …  
    116155typedef void (*mrb_atexit_func)(struct mrb_state*);
    117156
     157#define MRB_STATE_NO_REGEXP 1
     158#define MRB_STATE_REGEXP    2
     159
    118160typedef struct mrb_state {
    119161  struct mrb_jmpbuf *jmp;
    120162
     163  uint32_t flags;
    121164  mrb_allocf allocf;                      /* memory allocation function */
    122165  void *allocf_ud;                        /* auxiliary data of allocf */
    … …  
    124167  struct mrb_context *c;
    125168  struct mrb_context *root_c;
     169  struct iv_tbl *globals;                 /* global variable table */
    126170
    127171  struct RObject *exc;                    /* exception */
    128   struct iv_tbl *globals;                 /* global variable table */
    129172
    130173  struct RObject *top_self;
    … …  
    158201#endif
    159202
     203#ifdef MRB_BYTECODE_DECODE_OPTION
     204  mrb_code (*bytecode_decoder)(struct mrb_state* mrb, mrb_code code);
     205#endif
     206
    160207  struct RClass *eException_class;
    161208  struct RClass *eStandardError_class;
    162209  struct RObject *nomem_err;              /* pre-allocated NoMemoryError */
     210  struct RObject *stack_err;              /* pre-allocated SysStackError */
     211#ifdef MRB_GC_FIXED_ARENA
     212  struct RObject *arena_err;              /* pre-allocated arena overfow error */
     213#endif
    163214
    164215  void *ud; /* auxiliary data */
    … …  
    182233 *      !!!c
    183234 *      void mrb_example_gem_init(mrb_state* mrb) {
    184  *              struct RClass *example_class;
    185  *              example_class = mrb_define_class(mrb, "Example_Class", mrb->object_class);
     235 *          struct RClass *example_class;
     236 *          example_class = mrb_define_class(mrb, "Example_Class", mrb->object_class);
    186237 *      }
    187238 *
    188239 *      void mrb_example_gem_final(mrb_state* mrb) {
    189  *              //free(TheAnimals);
     240 *          //free(TheAnimals);
    190241 *      }
    191242 *
    … …  
    200251/**
    201252 * Defines a new module.
     253 *
    202254 * @param [mrb_state *] mrb_state* The current mruby state.
    203255 * @param [const char *] char* The name of the module.
    … …  
    209261/**
    210262 * Include a module in another class or module.
    211  * Equivalent to: 
    212  *
    213  *   module B                                                                                                         
    214  *     include A                                                                                                     
    215  *   end 
     263 * Equivalent to:
     264 *
     265 *   module B
     266 *     include A
     267 *   end
    216268 * @param [mrb_state *] mrb_state* The current mruby state.
    217269 * @param [struct RClass *] RClass* A reference to module or a class.
    … …  
    230282 * @param [struct RClass *] RClass* A reference to module or a class.
    231283 * @param [struct RClass *] RClass* A reference to the module to be prepended.
    232  */ 
     284 */
    233285MRB_API void mrb_prepend_module(mrb_state*, struct RClass*, struct RClass*);
    234286
    … …  
    264316 *
    265317 * Example:
    266  *   # Ruby style
    267  *   class Foo
    268  *
    269  *     def Foo.bar
     318 *
     319 *     # Ruby style
     320 *     class Foo
     321 *       def Foo.bar
     322 *       end
    270323 *     end
    271  *
    272  *   end
    273  *   // C style
    274  *   mrb_value bar_method(mrb_state* mrb, mrb_value self){
    275  *
    276  *     return mrb_nil_value();
    277  *
    278  *   }
    279  *   void mrb_example_gem_init(mrb_state* mrb){
    280  *
    281  *     struct RClass *foo;
    282  *
    283  *     foo = mrb_define_class(mrb, "Foo", mrb->object_class);
    284  *
    285  *     mrb_define_class_method(mrb, foo, "bar", bar_method, MRB_ARGS_NONE());
    286  *
    287  *   }
    288  * @param [mrb_state *] mrb_state* The MRuby state reference.
     324 *     // C style
     325 *     mrb_value bar_method(mrb_state* mrb, mrb_value self){
     326 *       return mrb_nil_value();
     327 *     }
     328 *     void mrb_example_gem_init(mrb_state* mrb){
     329 *       struct RClass *foo;
     330 *       foo = mrb_define_class(mrb, "Foo", mrb->object_class);
     331 *       mrb_define_class_method(mrb, foo, "bar", bar_method, MRB_ARGS_NONE());
     332 *     }
     333 * @param [mrb_state *] mrb_state* The MRuby state reference.
    289334 * @param [struct RClass *] RClass* The class where the class method will be defined.
    290335 * @param [const char *] char* The name of the class method being defined.
    … …  
    299344 *
    300345 * Example:
    301  *   # Ruby style
    302  *   module Foo
    303  *                                                                                                     
    304  *     def Foo.bar                                                                                                    *     end
    305  *
    306  *   end                                                                                                             
    307  *   // C style                                                                                                     
    308  *   mrb_value bar_method(mrb_state* mrb, mrb_value self){
    309  *                                                         
    310  *     return mrb_nil_value();                                                                                        *               
    311  *   }                                                                                                               
    312  *   void mrb_example_gem_init(mrb_state* mrb){
    313  *                                                                     
    314  *     struct RClass *foo;
    315  *                                                                                           
    316  *     foo = mrb_define_module(mrb, "Foo");
    317  *                                                       
    318  *     mrb_define_module_function(mrb, foo, "bar", bar_method, MRB_ARGS_NONE());
    319  *
    320  *   }   
     346 *
     347 *        # Ruby style
     348 *        module Foo
     349 *          def Foo.bar
     350 *          end
     351 *        end
     352 *        // C style
     353 *        mrb_value bar_method(mrb_state* mrb, mrb_value self){
     354 *          return mrb_nil_value();
     355 *        }
     356 *        void mrb_example_gem_init(mrb_state* mrb){
     357 *          struct RClass *foo;
     358 *          foo = mrb_define_module(mrb, "Foo");
     359 *          mrb_define_module_function(mrb, foo, "bar", bar_method, MRB_ARGS_NONE());
     360 *        }
    321361 *  @param [mrb_state *] mrb_state* The MRuby state reference.
    322362 *  @param [struct RClass *] RClass* The module where the module function will be defined.
    323363 *  @param [const char *] char* The name of the module function being defined.
    324  *  @param [mrb_func_t] mrb_func_t The function pointer to the module function definition. 
     364 *  @param [mrb_func_t] mrb_func_t The function pointer to the module function definition.
    325365 *  @param [mrb_aspec] mrb_aspec The method parameters declaration.
    326366 */
    … …  
    331371 *
    332372 * Example:
    333  *    # Ruby style
    334  *
    335  *    class ExampleClass
    336  *   
    337  *    AGE = 22
    338  *
    339  *    end
    340  *
    341  *    // C style
    342  *    #include <stdio.h>
    343  *    #include <mruby.h>
    344  *
    345  *    void
    346  *    mrb_example_gem_init(mrb_state* mrb){
    347  *
    348  *      mrb_define_const(mrb, mrb->kernel_module, "AGE", mrb_fixnum_value(22));
    349  *
    350  *    }
    351  *
    352  *    mrb_value
    353  *    mrb_example_gem_final(mrb_state* mrb){
    354  *
    355  *    }
     373 *
     374 *          # Ruby style
     375 *          class ExampleClass
     376 *            AGE = 22
     377 *          end
     378 *          // C style
     379 *          #include <stdio.h>
     380 *          #include <mruby.h>
     381 *
     382 *          void
     383 *          mrb_example_gem_init(mrb_state* mrb){
     384 *            mrb_define_const(mrb, mrb->kernel_module, "AGE", mrb_fixnum_value(22));
     385 *          }
     386 *
     387 *          mrb_value
     388 *          mrb_example_gem_final(mrb_state* mrb){
     389 *          }
    356390 *  @param [mrb_state *] mrb_state* The MRuby state reference.
    357391 *  @param [struct RClass *] RClass* A class or module the constant is defined in.
    … …  
    365399 *
    366400 * Example:
    367  *   # Ruby style
    368  *
    369  *   class ExampleClassA
    370  *
    371  *     def example_method
    372  *       "example"
     401 *
     402 *     # Ruby style
     403 *
     404 *     class ExampleClassA
     405 *       def example_method
     406 *         "example"
     407 *       end
    373408 *     end
    374  *
    375  *   end
    376  *
    377  *   ExampleClassA.new.example_method # => example
    378  *
    379  *   class ExampleClassB < ExampleClassA
    380  *
    381  *     undef_method :example_method
    382  *
    383  *   end
    384  *
    385  *   ExampleClassB.new.example_method # => undefined method 'example_method' for ExampleClassB (NoMethodError)
    386  *
    387  *   // C style
    388  *   #include <stdio.h>
    389  *   #include <mruby.h>
    390  * 
    391  *   mrb_value
    392  *   mrb_example_method(mrb_state *mrb){
    393  *
    394  *     return mrb_str_new_cstr(mrb, "example");
    395  *
    396  *   }
    397  *
    398  *   void
    399  *   mrb_example_gem_init(mrb_state* mrb){
    400  *     struct RClass *example_class_a;
    401  *     struct RClass *example_class_b;
    402  *     struct RClass *example_class_c;
    403  *
    404  *     example_class_a = mrb_define_class(mrb, "ExampleClassA", mrb->object_class);
    405  *
    406  *     mrb_define_method(mrb, example_class_a, "example_method", mrb_example_method, MRB_ARGS_NONE());
    407  *
    408  *     example_class_b = mrb_define_class(mrb, "ExampleClassB", example_class_a);
    409  *
    410  *     example_class_c = mrb_define_class(mrb, "ExampleClassC", example_class_b);
    411  *
    412  *     mrb_undef_method(mrb, example_class_c, "example_method");
    413  *
    414  *   }
    415  *
    416  *   mrb_example_gem_final(mrb_state* mrb){
    417  *
    418  *   }
    419  *
     409 *     ExampleClassA.new.example_method # => example
     410 *
     411 *     class ExampleClassB < ExampleClassA
     412 *       undef_method :example_method
     413 *     end
     414 *
     415 *     ExampleClassB.new.example_method # => undefined method 'example_method' for ExampleClassB (NoMethodError)
     416 *
     417 *     // C style
     418 *     #include <stdio.h>
     419 *     #include <mruby.h>
     420 *
     421 *     mrb_value
     422 *     mrb_example_method(mrb_state *mrb){
     423 *       return mrb_str_new_lit(mrb, "example");
     424 *     }
     425 *
     426 *     void
     427 *     mrb_example_gem_init(mrb_state* mrb){
     428 *       struct RClass *example_class_a;
     429 *       struct RClass *example_class_b;
     430 *       struct RClass *example_class_c;
     431 *
     432 *       example_class_a = mrb_define_class(mrb, "ExampleClassA", mrb->object_class);
     433 *       mrb_define_method(mrb, example_class_a, "example_method", mrb_example_method, MRB_ARGS_NONE());
     434 *       example_class_b = mrb_define_class(mrb, "ExampleClassB", example_class_a);
     435 *       example_class_c = mrb_define_class(mrb, "ExampleClassC", example_class_b);
     436 *       mrb_undef_method(mrb, example_class_c, "example_method");
     437 *     }
     438 *
     439 *     mrb_example_gem_final(mrb_state* mrb){
     440 *     }
    420441 * @param [mrb_state*] mrb_state* The mruby state reference.
    421442 * @param [struct RClass*] RClass* A class the method will be undefined from.
    … …  
    426447/**
    427448 * Undefine a class method.
    428  *
    429449 * Example:
    430  *   # Ruby style
    431  *
    432  *   class ExampleClass
    433  *     def self.example_method
    434  *       "example"
    435  *     end
    436  *
    437  *   end
    438  *
    439  *   ExampleClass.example_method
    440  *   
    441  *   // C style
    442  *   #include <stdio.h>
    443  *   #include <mruby.h>
    444  *
    445  *   mrb_value
    446  *   mrb_example_method(mrb_state *mrb){
    447  *
    448  *     return mrb_str_new_cstr(mrb, "example");
    449  *     
    450  *   }
    451  *
    452  *   void
    453  *   mrb_example_gem_init(mrb_state* mrb){
    454  *
    455  *     struct RClass *example_class;
    456  *     
    457  *     example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class);
    458  *
    459  *     mrb_define_class_method(mrb, example_class, "example_method", mrb_example_method, MRB_ARGS_NONE());
    460  *
    461  *     mrb_undef_class_method(mrb, example_class, "example_method");
    462  *
    463  *   }
    464  *
    465  *   void
    466  *   mrb_example_gem_final(mrb_state* mrb){
    467  *
    468  *   }
     450 *
     451 *      # Ruby style
     452 *      class ExampleClass
     453 *        def self.example_method
     454 *          "example"
     455 *        end
     456 *      end
     457 *
     458 *     ExampleClass.example_method
     459 *
     460 *     // C style
     461 *     #include <stdio.h>
     462 *     #include <mruby.h>
     463 *
     464 *     mrb_value
     465 *     mrb_example_method(mrb_state *mrb){
     466 *       return mrb_str_new_lit(mrb, "example");
     467 *     }
     468 *
     469 *     void
     470 *     mrb_example_gem_init(mrb_state* mrb){
     471 *       struct RClass *example_class;
     472 *       example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class);
     473 *       mrb_define_class_method(mrb, example_class, "example_method", mrb_example_method, MRB_ARGS_NONE());
     474 *       mrb_undef_class_method(mrb, example_class, "example_method");
     475 *      }
     476 *
     477 *      void
     478 *      mrb_example_gem_final(mrb_state* mrb){
     479 *      }
    469480 * @param [mrb_state*] mrb_state* The mruby state reference.
    470481 * @param [RClass*] RClass* A class the class method will be undefined from.
    … …  
    478489 * Example:
    479490 *
    480  *   # Ruby style
    481  *   class ExampleClass
    482  *   end
    483  *
    484  *   p ExampleClass # => #<ExampleClass:0x9958588>
    485  *   // C style
    486  *   #include <stdio.h>
    487  *   #include <mruby.h>
    488  *
    489  *   void
    490  *   mrb_example_gem_init(mrb_state* mrb) {
    491  *     struct RClass *example_class;
    492  *     mrb_value obj;
    493  *
    494  *     example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class); # => class ExampleClass; end
    495  *     obj = mrb_obj_new(mrb, example_class, 0, NULL); # => ExampleClass.new
    496  *     mrb_p(mrb, obj); // => Kernel#p
    497  *   } 
     491 *     # Ruby style
     492 *     class ExampleClass
     493 *     end
     494 *
     495 *     p ExampleClass # => #<ExampleClass:0x9958588>
     496 *     // C style
     497 *     #include <stdio.h>
     498 *     #include <mruby.h>
     499 *
     500 *     void
     501 *     mrb_example_gem_init(mrb_state* mrb) {
     502 *       struct RClass *example_class;
     503 *       mrb_value obj;
     504 *       example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class); # => class ExampleClass; end
     505 *       obj = mrb_obj_new(mrb, example_class, 0, NULL); # => ExampleClass.new
     506 *       mrb_p(mrb, obj); // => Kernel#p
     507 *      }
    498508 * @param [mrb_state*] mrb The current mruby state.
    499509 * @param [RClass*] c Reference to the class of the new object.
    … …  
    517527 * Example:
    518528 *
    519  *   void
    520  *   mrb_example_gem_init(mrb_state* mrb) {
    521  *      struct RClass *example_class;
    522  *      mrb_value obj;
    523  *
    524  *      example_class = mrb_class_new(mrb, mrb->object_class);
    525  *      obj = mrb_obj_new(mrb, example_class, 0, NULL); // => #<#<Class:0x9a945b8>:0x9a94588>
    526  *      mrb_p(mrb, obj); // => Kernel#p
    527  *   }
     529 *      void
     530 *      mrb_example_gem_init(mrb_state* mrb) {
     531 *        struct RClass *example_class;
     532 *
     533 *        mrb_value obj;
     534 *        example_class = mrb_class_new(mrb, mrb->object_class);
     535 *        obj = mrb_obj_new(mrb, example_class, 0, NULL); // => #<#<Class:0x9a945b8>:0x9a94588>
     536 *        mrb_p(mrb, obj); // => Kernel#p
     537 *       }
    528538 *
    529539 * @param [mrb_state*] mrb The current mruby state.
    … …  
    537547 *
    538548 * Example:
    539  *   void
    540  *   mrb_example_gem_init(mrb_state* mrb) {
    541  *      struct RClass *example_module;
    542  *
    543  *      example_module = mrb_module_new(mrb);
    544  *   }
     549 *      void
     550 *      mrb_example_gem_init(mrb_state* mrb) {
     551 *        struct RClass *example_module;
     552 *
     553 *        example_module = mrb_module_new(mrb);
     554 *      }
    545555 *
    546556 * @param [mrb_state*] mrb The current mruby state.
    … …  
    553563 *
    554564 * Example:
    555  *   void
    556  *   mrb_example_gem_init(mrb_state* mrb) {
    557  *      struct RClass *example_class;
    558  *      mrb_bool cd;
    559  *
    560  *      example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class);
    561  *      cd = mrb_class_defined(mrb, "ExampleClass");
    562  *     
    563  *      // If mrb_class_defined returns 1 then puts "True"
    564  *      // If mrb_class_defined returns 0 then puts "False"
    565  *      if (cd == 1){
    566  *        puts("True");
     565 *     void
     566 *     mrb_example_gem_init(mrb_state* mrb) {
     567 *       struct RClass *example_class;
     568 *       mrb_bool cd;
     569 *
     570 *       example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class);
     571 *       cd = mrb_class_defined(mrb, "ExampleClass");
     572 *
     573 *       // If mrb_class_defined returns 1 then puts "True"
     574 *       // If mrb_class_defined returns 0 then puts "False"
     575 *       if (cd == 1){
     576 *         puts("True");
     577 *       }
     578 *       else {
     579 *         puts("False");
     580 *       }
    567581 *      }
    568  *      else {
    569  *        puts("False");
    570  *      }
    571  *   }
    572582 *
    573583 * @param [mrb_state*] mrb The current mruby state.
    … …  
    584594*/
    585595MRB_API struct RClass * mrb_class_get(mrb_state *mrb, const char *name);
     596
     597/**
     598 * Gets a exception class.
     599 * @param [mrb_state*] mrb The current mruby state.
     600 * @param [const char *] name The name of the class.
     601 * @return [struct RClass *] A reference to the class.
     602*/
     603MRB_API struct RClass * mrb_exc_get(mrb_state *mrb, const char *name);
     604
     605/**
     606 * Returns an mrb_bool. True if inner class was defined, and false if the inner class was not defined.
     607 *
     608 * Example:
     609 *     void
     610 *     mrb_example_gem_init(mrb_state* mrb) {
     611 *       struct RClass *example_outer, *example_inner;
     612 *       mrb_bool cd;
     613 *
     614 *       example_outer = mrb_define_module(mrb, "ExampleOuter");
     615 *
     616 *       example_inner = mrb_define_class_under(mrb, example_outer, "ExampleInner", mrb->object_class);
     617 *       cd = mrb_class_defined_under(mrb, example_outer, "ExampleInner");
     618 *
     619 *       // If mrb_class_defined_under returns 1 then puts "True"
     620 *       // If mrb_class_defined_under returns 0 then puts "False"
     621 *       if (cd == 1){
     622 *         puts("True");
     623 *       }
     624 *       else {
     625 *         puts("False");
     626 *       }
     627 *      }
     628 *
     629 * @param [mrb_state*] mrb The current mruby state.
     630 * @param [struct RClass *] outer The name of the outer class.
     631 * @param [const char *] name A string representing the name of the inner class.
     632 * @return [mrb_bool] A boolean value.
     633 */
     634MRB_API mrb_bool mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, const char *name);
    586635
    587636/**
    … …  
    616665 *
    617666 * Equivalent to:
    618  *   Object#dup   
     667 *   Object#dup
    619668 * @param [mrb_state*] mrb The current mruby state.
    620669 * @param [mrb_value] obj Object to be duplicate.
    … …  
    628677 * class it returns true, it returns false otherwise.
    629678 *
    630  * Example:
    631  *   # Ruby style
    632  *   class ExampleClass
    633  *      def example_method
     679 *      Example:
     680 *      # Ruby style
     681 *      class ExampleClass
     682 *        def example_method
     683 *        end
    634684 *      end
    635  *   end
    636  *
    637  *   ExampleClass.new.respond_to?(:example_method) # => true
    638  *
    639  *   // C style
    640  *   void
    641  *   mrb_example_gem_init(mrb_state* mrb) {
    642  *      struct RClass *example_class;
    643  *      mrb_sym mid;
    644  *      mrb_bool obj_resp;
    645  *
    646  *      example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class);
    647  *      mrb_define_method(mrb, example_class, "example_method", exampleMethod, MRB_ARGS_NONE());
    648  *      mid = mrb_intern_str(mrb, mrb_str_new_cstr(mrb, "example_method" ));
    649  *      obj_resp = mrb_obj_respond_to(mrb, example_class, mid); // => 1(true in Ruby world)
    650  *     
    651  *      // If mrb_obj_respond_to returns 1 then puts "True"
    652  *      // If mrb_obj_respond_to returns 0 then puts "False"
    653  *      if (obj_resp == 1) {
    654  *        puts("True");
     685 *
     686 *      ExampleClass.new.respond_to?(:example_method) # => true
     687 *
     688 *      // C style
     689 *      void
     690 *      mrb_example_gem_init(mrb_state* mrb) {
     691 *        struct RClass *example_class;
     692 *        mrb_sym mid;
     693 *        mrb_bool obj_resp;
     694 *
     695 *        example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class);
     696 *        mrb_define_method(mrb, example_class, "example_method", exampleMethod, MRB_ARGS_NONE());
     697 *        mid = mrb_intern_str(mrb, mrb_str_new_lit(mrb, "example_method" ));
     698 *        obj_resp = mrb_obj_respond_to(mrb, example_class, mid); // => 1(true in Ruby world)
     699 *
     700 *        // If mrb_obj_respond_to returns 1 then puts "True"
     701 *        // If mrb_obj_respond_to returns 0 then puts "False"
     702 *        if (obj_resp == 1) {
     703 *          puts("True");
     704 *        }
     705 *        else if (obj_resp == 0) {
     706 *          puts("False");
     707 *        }
    655708 *      }
    656  *      else if (obj_resp == 0) {
    657  *        puts("False");
    658  *      }
    659  *   }
    660709 *
    661710 * @param [mrb_state*] mrb The current mruby state.
    … …  
    795844/**
    796845 * Call existing ruby functions.
     846 *
     847 *      #include <stdio.h>
     848 *      #include <mruby.h>
     849 *      #include "mruby/compile.h"
     850 *
     851 *      int
     852 *      main()
     853 *      {
     854 *        mrb_int i = 99;
     855 *        mrb_state *mrb = mrb_open();
     856 *
     857 *        if (!mrb) { }
     858 *        FILE *fp = fopen("test.rb","r");
     859 *        mrb_value obj = mrb_load_file(mrb,fp);
     860 *        mrb_funcall(mrb, obj, "method_name", 1, mrb_fixnum_value(i));
     861 *        fclose(fp);
     862 *        mrb_close(mrb);
     863 *       }
     864 * @param [mrb_state*] mrb_state* The current mruby state.
     865 * @param [mrb_value] mrb_value A reference to an mruby value.
     866 * @param [const char*] const char* The name of the method.
     867 * @param [mrb_int] mrb_int The number of arguments the method has.
     868 * @param [...] ... Variadic values(not type safe!).
     869 * @return [mrb_value] mrb_value mruby function value.
    797870 */
    798871MRB_API mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, mrb_int,...);
     872/**
     873 * Call existing ruby functions. This is basically the type safe version of mrb_funcall.
     874 *
     875 *      #include <stdio.h>
     876 *      #include <mruby.h>
     877 *      #include "mruby/compile.h"
     878 *      int
     879 *      main()
     880 *      {
     881 *        mrb_int i = 99;
     882 *        mrb_state *mrb = mrb_open();
     883 *
     884 *        if (!mrb) { }
     885 *        mrb_sym m_sym = mrb_intern_lit(mrb, "method_name"); // Symbol for method.
     886 *
     887 *        FILE *fp = fopen("test.rb","r");
     888 *        mrb_value obj = mrb_load_file(mrb,fp);
     889 *        mrb_funcall_argv(mrb, obj, m_sym, 1, &obj); // Calling ruby function from test.rb.
     890 *        fclose(fp);
     891 *        mrb_close(mrb);
     892 *       }
     893 * @param [mrb_state*] mrb_state* The current mruby state.
     894 * @param [mrb_value] mrb_value A reference to an mruby value.
     895 * @param [mrb_sym] mrb_sym The symbol representing the method.
     896 * @param [mrb_int] mrb_int The number of arguments the method has.
     897 * @param [const mrb_value*] mrb_value* Pointer to the object.
     898 * @return [mrb_value] mrb_value mruby function value.
     899 * @see mrb_funcall
     900 */
    799901MRB_API mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, mrb_int, const mrb_value*);
     902/**
     903 * Call existing ruby functions with a block.
     904 */
    800905MRB_API mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, mrb_int, const mrb_value*, mrb_value);
     906/**
     907 * Create a symbol
     908 *
     909 *     # Ruby style:
     910 *     :pizza # => :pizza
     911 *
     912 *     // C style:
     913 *     mrb_sym m_sym = mrb_intern_lit(mrb, "pizza"); //  => :pizza
     914 * @param [mrb_state*] mrb_state* The current mruby state.
     915 * @param [const char*] const char* The name of the method.
     916 * @return [mrb_sym] mrb_sym A symbol.
     917 */
    801918MRB_API mrb_sym mrb_intern_cstr(mrb_state*,const char*);
    802919MRB_API mrb_sym mrb_intern(mrb_state*,const char*,size_t);
    … …  
    8921009MRB_API mrb_value mrb_top_self(mrb_state *);
    8931010MRB_API mrb_value mrb_run(mrb_state*, struct RProc*, mrb_value);
    894 MRB_API mrb_value mrb_toplevel_run(mrb_state*, struct RProc*);
    895 MRB_API mrb_value mrb_context_run(mrb_state*, struct RProc*, mrb_value, unsigned int);
     1011MRB_API mrb_value mrb_top_run(mrb_state*, struct RProc*, mrb_value, unsigned int);
     1012MRB_API mrb_value mrb_vm_run(mrb_state*, struct RProc*, mrb_value, unsigned int);
     1013MRB_API mrb_value mrb_vm_exec(mrb_state*, struct RProc*, mrb_code*);
     1014/* compatibility macros */
     1015#define mrb_toplevel_run_keep(m,p,k) mrb_top_run((m),(p),mrb_top_self(m),(k))
     1016#define mrb_toplevel_run(m,p) mrb_toplevel_run_keep((m),(p),0)
     1017#define mrb_context_run(m,p,s,k) mrb_vm_run((m),(p),(s),(k))
    8961018
    8971019MRB_API void mrb_p(mrb_state*, mrb_value);
    … …  
    9651087   + exception objects obtained from those macros are local to mrb
    9661088*/
    967 #define E_RUNTIME_ERROR             (mrb_class_get(mrb, "RuntimeError"))
    968 #define E_TYPE_ERROR                (mrb_class_get(mrb, "TypeError"))
    969 #define E_ARGUMENT_ERROR            (mrb_class_get(mrb, "ArgumentError"))
    970 #define E_INDEX_ERROR               (mrb_class_get(mrb, "IndexError"))
    971 #define E_RANGE_ERROR               (mrb_class_get(mrb, "RangeError"))
    972 #define E_NAME_ERROR                (mrb_class_get(mrb, "NameError"))
    973 #define E_NOMETHOD_ERROR            (mrb_class_get(mrb, "NoMethodError"))
    974 #define E_SCRIPT_ERROR              (mrb_class_get(mrb, "ScriptError"))
    975 #define E_SYNTAX_ERROR              (mrb_class_get(mrb, "SyntaxError"))
    976 #define E_LOCALJUMP_ERROR           (mrb_class_get(mrb, "LocalJumpError"))
    977 #define E_REGEXP_ERROR              (mrb_class_get(mrb, "RegexpError"))
    978 #define E_SYSSTACK_ERROR            (mrb_class_get(mrb, "SystemStackError"))
    979 
    980 #define E_NOTIMP_ERROR              (mrb_class_get(mrb, "NotImplementedError"))
    981 #define E_FLOATDOMAIN_ERROR         (mrb_class_get(mrb, "FloatDomainError"))
    982 
    983 #define E_KEY_ERROR                 (mrb_class_get(mrb, "KeyError"))
     1089#define E_RUNTIME_ERROR             (mrb_exc_get(mrb, "RuntimeError"))
     1090#define E_TYPE_ERROR                (mrb_exc_get(mrb, "TypeError"))
     1091#define E_ARGUMENT_ERROR            (mrb_exc_get(mrb, "ArgumentError"))
     1092#define E_INDEX_ERROR               (mrb_exc_get(mrb, "IndexError"))
     1093#define E_RANGE_ERROR               (mrb_exc_get(mrb, "RangeError"))
     1094#define E_NAME_ERROR                (mrb_exc_get(mrb, "NameError"))
     1095#define E_NOMETHOD_ERROR            (mrb_exc_get(mrb, "NoMethodError"))
     1096#define E_SCRIPT_ERROR              (mrb_exc_get(mrb, "ScriptError"))
     1097#define E_SYNTAX_ERROR              (mrb_exc_get(mrb, "SyntaxError"))
     1098#define E_LOCALJUMP_ERROR           (mrb_exc_get(mrb, "LocalJumpError"))
     1099#define E_REGEXP_ERROR              (mrb_exc_get(mrb, "RegexpError"))
     1100
     1101#define E_NOTIMP_ERROR              (mrb_exc_get(mrb, "NotImplementedError"))
     1102#define E_FLOATDOMAIN_ERROR         (mrb_exc_get(mrb, "FloatDomainError"))
     1103
     1104#define E_KEY_ERROR                 (mrb_exc_get(mrb, "KeyError"))
    9841105
    9851106MRB_API mrb_value mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg);
    9861107MRB_API mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv);
    9871108MRB_API mrb_value mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv, mrb_value self, struct RClass *c);
     1109
     1110/* continue execution to the proc */
     1111/* this function should always be called as the last function of a method */
     1112/* e.g. return mrb_yield_cont(mrb, proc, self, argc, argv); */
     1113mrb_value mrb_yield_cont(mrb_state *mrb, mrb_value b, mrb_value self, mrb_int argc, const mrb_value *argv);
    9881114
    9891115/* mrb_gc_protect() leaves the object in the arena */
    … …  
    10131139MRB_API mrb_bool mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid);
    10141140MRB_API mrb_bool mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c);
     1141MRB_API mrb_bool mrb_func_basic_p(mrb_state *mrb, mrb_value obj, mrb_sym mid, mrb_func_t func);
    10151142
    10161143
    … …  
    10341161 * @mrbgem mruby-fiber
    10351162 */
    1036 #define E_FIBER_ERROR (mrb_class_get(mrb, "FiberError"))
     1163#define E_FIBER_ERROR (mrb_exc_get(mrb, "FiberError"))
    10371164
    10381165/* memory pool implementation */
    … …  
    10501177MRB_API void mrb_show_copyright(mrb_state *mrb);
    10511178
    1052 #ifdef MRB_DEBUG
    1053 #include <assert.h>
    1054 #define mrb_assert(p) assert(p)
    1055 #define mrb_assert_int_fit(t1,n,t2,max) assert((n)>=0 && ((sizeof(n)<=sizeof(t2))||(n<=(t1)(max))))
    1056 #else
    1057 #define mrb_assert(p) ((void)0)
    1058 #define mrb_assert_int_fit(t1,n,t2,max) ((void)0)
    1059 #endif
    1060 
    1061 #if __STDC_VERSION__ >= 201112L
    1062 #define mrb_static_assert(exp, str) _Static_assert(exp, str)
    1063 #else
    1064 #define mrb_static_assert(exp, str) mrb_assert(exp)
    1065 #endif
    1066 
    10671179MRB_API mrb_value mrb_format(mrb_state *mrb, const char *format, ...);
    10681180
     1181#if 0
     1182/* memcpy and memset does not work with gdb reverse-next on my box */
     1183/* use naive memcpy and memset instead */
     1184#undef memcpy
     1185#undef memset
     1186static inline void*
     1187mrbmemcpy(void *dst, const void *src, size_t n)
     1188{
     1189  char *d = dst;
     1190  const char *s = src;
     1191  while (n--)
     1192    *d++ = *s++;
     1193  return d;
     1194}
     1195#define memcpy(a,b,c) mrbmemcpy(a,b,c)
     1196
     1197static inline void*
     1198mrbmemset(void *s, int c, size_t n)
     1199{
     1200  char *t = s;
     1201  while (n--)
     1202    *t++ = c;
     1203  return s;
     1204}
     1205#define memset(a,b,c) mrbmemset(a,b,c)
     1206#endif
     1207
    10691208MRB_END_DECL
    10701209
Note: See TracChangeset for help on using the changeset viewer.