Changeset 331 for EcnlProtoTool/trunk/mruby-1.3.0/include/mruby.h
- Timestamp:
- Jan 21, 2018, 12:10:09 AM (6 years ago)
- 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 2 2 ** mruby - An embeddable Ruby implementation 3 3 ** 4 ** Copyright (c) mruby developers 2010-201 54 ** Copyright (c) mruby developers 2010-2017 5 5 ** 6 6 ** Permission is hereby granted, free of charge, to any person obtaining … … 29 29 #define MRUBY_H 30 30 31 #ifdef __cplusplus 32 #define __STDC_LIMIT_MACROS 33 #define __STDC_CONSTANT_MACROS 34 #define __STDC_FORMAT_MACROS 35 #endif 36 31 37 #include <stdint.h> 32 38 #include <stddef.h> 33 39 #include <limits.h> 34 40 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 35 66 #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 36 74 #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> 40 78 41 79 /** … … 76 114 int nregs; 77 115 int ridx; 78 int e idx;116 int epos; 79 117 struct REnv *env; 80 118 mrb_code *pc; /* return address */ … … 88 126 MRB_FIBER_CREATED = 0, 89 127 MRB_FIBER_RUNNING, 90 MRB_FIBER_RESUM ING,128 MRB_FIBER_RESUMED, 91 129 MRB_FIBER_SUSPENDED, 92 130 MRB_FIBER_TRANSFERRED, … … 106 144 int rsize; 107 145 struct RProc **ensure; /* ensure handler stack */ 108 int esize ;146 int esize, eidx; 109 147 110 148 enum mrb_fiber_state status; 149 mrb_bool vmexec; 111 150 struct RFiber *fib; 112 151 }; … … 116 155 typedef void (*mrb_atexit_func)(struct mrb_state*); 117 156 157 #define MRB_STATE_NO_REGEXP 1 158 #define MRB_STATE_REGEXP 2 159 118 160 typedef struct mrb_state { 119 161 struct mrb_jmpbuf *jmp; 120 162 163 uint32_t flags; 121 164 mrb_allocf allocf; /* memory allocation function */ 122 165 void *allocf_ud; /* auxiliary data of allocf */ … … 124 167 struct mrb_context *c; 125 168 struct mrb_context *root_c; 169 struct iv_tbl *globals; /* global variable table */ 126 170 127 171 struct RObject *exc; /* exception */ 128 struct iv_tbl *globals; /* global variable table */129 172 130 173 struct RObject *top_self; … … 158 201 #endif 159 202 203 #ifdef MRB_BYTECODE_DECODE_OPTION 204 mrb_code (*bytecode_decoder)(struct mrb_state* mrb, mrb_code code); 205 #endif 206 160 207 struct RClass *eException_class; 161 208 struct RClass *eStandardError_class; 162 209 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 163 214 164 215 void *ud; /* auxiliary data */ … … 182 233 * !!!c 183 234 * void mrb_example_gem_init(mrb_state* mrb) { 184 * 185 * 235 * struct RClass *example_class; 236 * example_class = mrb_define_class(mrb, "Example_Class", mrb->object_class); 186 237 * } 187 238 * 188 239 * void mrb_example_gem_final(mrb_state* mrb) { 189 * 240 * //free(TheAnimals); 190 241 * } 191 242 * … … 200 251 /** 201 252 * Defines a new module. 253 * 202 254 * @param [mrb_state *] mrb_state* The current mruby state. 203 255 * @param [const char *] char* The name of the module. … … 209 261 /** 210 262 * 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 216 268 * @param [mrb_state *] mrb_state* The current mruby state. 217 269 * @param [struct RClass *] RClass* A reference to module or a class. … … 230 282 * @param [struct RClass *] RClass* A reference to module or a class. 231 283 * @param [struct RClass *] RClass* A reference to the module to be prepended. 232 */ 284 */ 233 285 MRB_API void mrb_prepend_module(mrb_state*, struct RClass*, struct RClass*); 234 286 … … 264 316 * 265 317 * 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 270 323 * 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. 289 334 * @param [struct RClass *] RClass* The class where the class method will be defined. 290 335 * @param [const char *] char* The name of the class method being defined. … … 299 344 * 300 345 * 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 * } 321 361 * @param [mrb_state *] mrb_state* The MRuby state reference. 322 362 * @param [struct RClass *] RClass* The module where the module function will be defined. 323 363 * @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. 325 365 * @param [mrb_aspec] mrb_aspec The method parameters declaration. 326 366 */ … … 331 371 * 332 372 * 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 * } 356 390 * @param [mrb_state *] mrb_state* The MRuby state reference. 357 391 * @param [struct RClass *] RClass* A class or module the constant is defined in. … … 365 399 * 366 400 * 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 373 408 * 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 * } 420 441 * @param [mrb_state*] mrb_state* The mruby state reference. 421 442 * @param [struct RClass*] RClass* A class the method will be undefined from. … … 426 447 /** 427 448 * Undefine a class method. 428 *429 449 * 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 * } 469 480 * @param [mrb_state*] mrb_state* The mruby state reference. 470 481 * @param [RClass*] RClass* A class the class method will be undefined from. … … 478 489 * Example: 479 490 * 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 * } 498 508 * @param [mrb_state*] mrb The current mruby state. 499 509 * @param [RClass*] c Reference to the class of the new object. … … 517 527 * Example: 518 528 * 519 * void520 * 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#p527 * }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 * } 528 538 * 529 539 * @param [mrb_state*] mrb The current mruby state. … … 537 547 * 538 548 * Example: 539 * void540 * 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 * } 545 555 * 546 556 * @param [mrb_state*] mrb The current mruby state. … … 553 563 * 554 564 * 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 * } 567 581 * } 568 * else {569 * puts("False");570 * }571 * }572 582 * 573 583 * @param [mrb_state*] mrb The current mruby state. … … 584 594 */ 585 595 MRB_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 */ 603 MRB_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 */ 634 MRB_API mrb_bool mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, const char *name); 586 635 587 636 /** … … 616 665 * 617 666 * Equivalent to: 618 * Object#dup 667 * Object#dup 619 668 * @param [mrb_state*] mrb The current mruby state. 620 669 * @param [mrb_value] obj Object to be duplicate. … … 628 677 * class it returns true, it returns false otherwise. 629 678 * 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 634 684 * 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 * } 655 708 * } 656 * else if (obj_resp == 0) {657 * puts("False");658 * }659 * }660 709 * 661 710 * @param [mrb_state*] mrb The current mruby state. … … 795 844 /** 796 845 * 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. 797 870 */ 798 871 MRB_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 */ 799 901 MRB_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 */ 800 905 MRB_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 */ 801 918 MRB_API mrb_sym mrb_intern_cstr(mrb_state*,const char*); 802 919 MRB_API mrb_sym mrb_intern(mrb_state*,const char*,size_t); … … 892 1009 MRB_API mrb_value mrb_top_self(mrb_state *); 893 1010 MRB_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); 1011 MRB_API mrb_value mrb_top_run(mrb_state*, struct RProc*, mrb_value, unsigned int); 1012 MRB_API mrb_value mrb_vm_run(mrb_state*, struct RProc*, mrb_value, unsigned int); 1013 MRB_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)) 896 1018 897 1019 MRB_API void mrb_p(mrb_state*, mrb_value); … … 965 1087 + exception objects obtained from those macros are local to mrb 966 1088 */ 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")) 984 1105 985 1106 MRB_API mrb_value mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg); 986 1107 MRB_API mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv); 987 1108 MRB_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); */ 1113 mrb_value mrb_yield_cont(mrb_state *mrb, mrb_value b, mrb_value self, mrb_int argc, const mrb_value *argv); 988 1114 989 1115 /* mrb_gc_protect() leaves the object in the arena */ … … 1013 1139 MRB_API mrb_bool mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid); 1014 1140 MRB_API mrb_bool mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c); 1141 MRB_API mrb_bool mrb_func_basic_p(mrb_state *mrb, mrb_value obj, mrb_sym mid, mrb_func_t func); 1015 1142 1016 1143 … … 1034 1161 * @mrbgem mruby-fiber 1035 1162 */ 1036 #define E_FIBER_ERROR (mrb_ class_get(mrb, "FiberError"))1163 #define E_FIBER_ERROR (mrb_exc_get(mrb, "FiberError")) 1037 1164 1038 1165 /* memory pool implementation */ … … 1050 1177 MRB_API void mrb_show_copyright(mrb_state *mrb); 1051 1178 1052 #ifdef MRB_DEBUG1053 #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 #else1057 #define mrb_assert(p) ((void)0)1058 #define mrb_assert_int_fit(t1,n,t2,max) ((void)0)1059 #endif1060 1061 #if __STDC_VERSION__ >= 201112L1062 #define mrb_static_assert(exp, str) _Static_assert(exp, str)1063 #else1064 #define mrb_static_assert(exp, str) mrb_assert(exp)1065 #endif1066 1067 1179 MRB_API mrb_value mrb_format(mrb_state *mrb, const char *format, ...); 1068 1180 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 1186 static inline void* 1187 mrbmemcpy(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 1197 static inline void* 1198 mrbmemset(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 1069 1208 MRB_END_DECL 1070 1209
Note:
See TracChangeset
for help on using the changeset viewer.