Esempi in C++ (Cpp) per MRB_ARGS_REQ

Esempio n. 1

0

Mostra file

File: ngx_http_mruby_var.c Progetto: heartshare/ngx_mruby

      , __func__
      , __LINE__
      , keyp
      , valp
    );
    return mrb_str_new(mrb, (char *)vv->data, vv->len);
  }

  ngx_log_error(NGX_LOG_ERR
    , r->connection->log
    , 0
    , "%s ERROR %s:%d: %s is not found"
    , MODULE_NAME
    , __func__
    , __LINE__
    , keyp
  );

ARENA_RESTOR_AND_ERROR:
  return mrb_nil_value();
}

void ngx_mrb_var_class_init(mrb_state *mrb, struct RClass *class)
{
  struct RClass *class_var;

  class_var = mrb_define_class_under(mrb, class, "Var", mrb->object_class);
  mrb_define_method(mrb, class_var, "method_missing", ngx_mrb_var_method_missing, MRB_ARGS_ANY());
  mrb_define_method(mrb, class_var, "set", ngx_mrb_var_set_func, MRB_ARGS_REQ(2));
}

Esempio n. 2

0

Mostra file

File: game-reload.c Progetto: Archytaus/qgame

void
mrb_game_reload_gem_init(mrb_state* mrb)
{
  struct RClass* mrb_game_class = mrb_class_get(mrb, "Game");
  mrb_define_module_function(mrb, mrb_game_class, "reload_file", mrb_game_reload_file, MRB_ARGS_REQ(1));
}

Esempio n. 3

0

Mostra file

File: hash.c Progetto: TJ-Hidetaka-Takano/mruby

void
mrb_init_hash(mrb_state *mrb)
{
  struct RClass *h;

  mrb->hash_class = h = mrb_define_class(mrb, "Hash", mrb->object_class);              /* 15.2.13 */
  MRB_SET_INSTANCE_TT(h, MRB_TT_HASH);

  mrb_define_method(mrb, h, "[]",              mrb_hash_aget,        MRB_ARGS_REQ(1)); /* 15.2.13.4.2  */
  mrb_define_method(mrb, h, "[]=",             mrb_hash_aset,        MRB_ARGS_REQ(2)); /* 15.2.13.4.3  */
  mrb_define_method(mrb, h, "clear",           mrb_hash_clear,       MRB_ARGS_NONE()); /* 15.2.13.4.4  */
  mrb_define_method(mrb, h, "default",         mrb_hash_default,     MRB_ARGS_ANY());  /* 15.2.13.4.5  */
  mrb_define_method(mrb, h, "default=",        mrb_hash_set_default, MRB_ARGS_REQ(1)); /* 15.2.13.4.6  */
  mrb_define_method(mrb, h, "default_proc",    mrb_hash_default_proc,MRB_ARGS_NONE()); /* 15.2.13.4.7  */
  mrb_define_method(mrb, h, "default_proc=",   mrb_hash_set_default_proc,MRB_ARGS_REQ(1)); /* 15.2.13.4.7  */
  mrb_define_method(mrb, h, "__delete",        mrb_hash_delete,      MRB_ARGS_REQ(1)); /* core of 15.2.13.4.8  */
  mrb_define_method(mrb, h, "empty?",          mrb_hash_empty_p,     MRB_ARGS_NONE()); /* 15.2.13.4.12 */
  mrb_define_method(mrb, h, "has_key?",        mrb_hash_has_key,     MRB_ARGS_REQ(1)); /* 15.2.13.4.13 */
  mrb_define_method(mrb, h, "has_value?",      mrb_hash_has_value,   MRB_ARGS_REQ(1)); /* 15.2.13.4.14 */
  mrb_define_method(mrb, h, "include?",        mrb_hash_has_key,     MRB_ARGS_REQ(1)); /* 15.2.13.4.15 */
  mrb_define_method(mrb, h, "initialize",      mrb_hash_init,        MRB_ARGS_OPT(1)); /* 15.2.13.4.16 */
  mrb_define_method(mrb, h, "key?",            mrb_hash_has_key,     MRB_ARGS_REQ(1)); /* 15.2.13.4.18 */
  mrb_define_method(mrb, h, "keys",            mrb_hash_keys,        MRB_ARGS_NONE()); /* 15.2.13.4.19 */
  mrb_define_method(mrb, h, "length",          mrb_hash_size_m,      MRB_ARGS_NONE()); /* 15.2.13.4.20 */
  mrb_define_method(mrb, h, "member?",         mrb_hash_has_key,     MRB_ARGS_REQ(1)); /* 15.2.13.4.21 */
  mrb_define_method(mrb, h, "shift",           mrb_hash_shift,       MRB_ARGS_NONE()); /* 15.2.13.4.24 */
  mrb_define_method(mrb, h, "dup",             mrb_hash_dup,         MRB_ARGS_NONE());
  mrb_define_method(mrb, h, "size",            mrb_hash_size_m,      MRB_ARGS_NONE()); /* 15.2.13.4.25 */
  mrb_define_method(mrb, h, "store",           mrb_hash_aset,        MRB_ARGS_REQ(2)); /* 15.2.13.4.26 */
  mrb_define_method(mrb, h, "value?",          mrb_hash_has_value,   MRB_ARGS_REQ(1)); /* 15.2.13.4.27 */
  mrb_define_method(mrb, h, "values",          mrb_hash_values,      MRB_ARGS_NONE()); /* 15.2.13.4.28 */

  mrb_define_method(mrb, h, "to_hash",         mrb_hash_to_hash,     MRB_ARGS_NONE()); /* 15.2.13.4.29 (x)*/
}

Esempio n. 4

0

Mostra file

File: math.c Progetto: miura1729/mruby

/* ------------------------------------------------------------------------*/
void
mrb_mruby_math_gem_init(mrb_state* mrb)
{
  struct RClass *mrb_math;
  mrb_math = mrb_define_module(mrb, "Math");

  mrb_define_class_under(mrb, mrb_math, "DomainError", mrb->eStandardError_class);

#ifdef M_PI
  mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(mrb, M_PI));
#else
  mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(mrb, atan(1.0)*4.0));
#endif

#ifdef M_E
  mrb_define_const(mrb, mrb_math, "E", mrb_float_value(mrb, M_E));
#else
  mrb_define_const(mrb, mrb_math, "E", mrb_float_value(mrb, exp(1.0)));
#endif

#ifdef MRB_USE_FLOAT
  mrb_define_const(mrb, mrb_math, "TOLERANCE", mrb_float_value(mrb, 1e-5));
#else
  mrb_define_const(mrb, mrb_math, "TOLERANCE", mrb_float_value(mrb, 1e-12));
#endif

  mrb_define_module_function(mrb, mrb_math, "sin", math_sin, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mrb_math, "cos", math_cos, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mrb_math, "tan", math_tan, MRB_ARGS_REQ(1));

  mrb_define_module_function(mrb, mrb_math, "asin", math_asin, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mrb_math, "acos", math_acos, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mrb_math, "atan", math_atan, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mrb_math, "atan2", math_atan2, MRB_ARGS_REQ(2));

  mrb_define_module_function(mrb, mrb_math, "sinh", math_sinh, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mrb_math, "cosh", math_cosh, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mrb_math, "tanh", math_tanh, MRB_ARGS_REQ(1));

  mrb_define_module_function(mrb, mrb_math, "asinh", math_asinh, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mrb_math, "acosh", math_acosh, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mrb_math, "atanh", math_atanh, MRB_ARGS_REQ(1));

  mrb_define_module_function(mrb, mrb_math, "exp", math_exp, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mrb_math, "log", math_log, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  mrb_define_module_function(mrb, mrb_math, "log2", math_log2, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mrb_math, "log10", math_log10, MRB_ARGS_REQ(1));

  mrb_define_module_function(mrb, mrb_math, "sqrt", math_sqrt, MRB_ARGS_REQ(1));
  mrbjit_define_primitive(mrb, ((struct RBasic *)mrb_math)->c, "sqrt", mrbjit_prim_math_sqrt);
  mrbjit_define_primitive(mrb, mrb_math, "sqrt", mrbjit_prim_math_sqrt);

  mrb_define_module_function(mrb, mrb_math, "cbrt", math_cbrt, MRB_ARGS_REQ(1));

  mrb_define_module_function(mrb, mrb_math, "frexp", math_frexp, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mrb_math, "ldexp", math_ldexp, MRB_ARGS_REQ(2));

  mrb_define_module_function(mrb, mrb_math, "hypot", math_hypot, MRB_ARGS_REQ(2));

  mrb_define_module_function(mrb, mrb_math, "erf",  math_erf,  MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mrb_math, "erfc", math_erfc, MRB_ARGS_REQ(1));
}

Esempio n. 5

0

Mostra file

File: cp_constraint.c Progetto: afaur/mruby-chipmunk2d

void
mrb_cp_constraint_init(mrb_state *mrb, struct RClass *cp_module)
{
  mrb_cp_constraint_class = mrb_define_class_under(mrb, cp_module, "Constraint", mrb->object_class);
  MRB_SET_INSTANCE_TT(mrb_cp_constraint_class, MRB_TT_DATA);
  /* */
  mrb_define_method(mrb, mrb_cp_constraint_class, "initialize",      constraint_initialize,         MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_constraint_class, "space",           constraint_get_space,          MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_constraint_class, "body_a",          constraint_get_body_a,         MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_constraint_class, "body_b",          constraint_get_body_b,         MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_constraint_class, "max_force",       constraint_get_max_force,      MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_constraint_class, "max_force=",      constraint_set_max_force,      MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_constraint_class, "error_bias",      constraint_get_error_bias,     MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_constraint_class, "error_bias=",     constraint_set_error_bias,     MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_constraint_class, "max_bias",        constraint_get_max_bias,       MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_constraint_class, "max_bias=",       constraint_set_max_bias,       MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_constraint_class, "collide_bodies",  constraint_get_collide_bodies, MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_constraint_class, "collide_bodies=", constraint_set_collide_bodies, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_constraint_class, "impulse",         constraint_get_impulse,        MRB_ARGS_NONE());
}

Esempio n. 6

0

Mostra file

File: numeric.c Progetto: HirokiMiyaoka/mruby4VS

/* ------------------------------------------------------------------------*/
void
mrb_init_numeric(mrb_state *mrb)
{
  struct RClass *numeric, *integer, *fixnum, *fl;

  /* Numeric Class */
  numeric = mrb_define_class(mrb, "Numeric",  mrb->object_class);

  mrb_define_method(mrb, numeric, "**",       num_pow,        MRB_ARGS_REQ(1));
  mrb_define_method(mrb, numeric, "/",        num_div,        MRB_ARGS_REQ(1));  /* 15.2.8.3.4  */
  mrb_define_method(mrb, numeric, "quo",      num_div,        MRB_ARGS_REQ(1));  /* 15.2.7.4.5 (x) */
  mrb_define_method(mrb, numeric, "<=>",      num_cmp,        MRB_ARGS_REQ(1));  /* 15.2.9.3.6  */

  /* Integer Class */
  integer = mrb_define_class(mrb, "Integer",  numeric);
  mrb_undef_class_method(mrb, integer, "new");
  mrb_define_method(mrb, integer, "to_i", int_to_i, MRB_ARGS_NONE());              /* 15.2.8.3.24 */
  mrb_define_method(mrb, integer, "to_int", int_to_i, MRB_ARGS_NONE());

  fixnum = mrb->fixnum_class = mrb_define_class(mrb, "Fixnum", integer);
  mrb_define_method(mrb, fixnum,  "+",        fix_plus,          MRB_ARGS_REQ(1)); /* 15.2.8.3.1  */
  mrb_define_method(mrb, fixnum,  "-",        fix_minus,         MRB_ARGS_REQ(1)); /* 15.2.8.3.2  */
  mrb_define_method(mrb, fixnum,  "*",        fix_mul,           MRB_ARGS_REQ(1)); /* 15.2.8.3.3  */
  mrb_define_method(mrb, fixnum,  "%",        fix_mod,           MRB_ARGS_REQ(1)); /* 15.2.8.3.5  */
  mrb_define_method(mrb, fixnum,  "==",       fix_equal,         MRB_ARGS_REQ(1)); /* 15.2.8.3.7  */
  mrb_define_method(mrb, fixnum,  "~",        fix_rev,           MRB_ARGS_NONE()); /* 15.2.8.3.8  */
  mrb_define_method(mrb, fixnum,  "&",        fix_and,           MRB_ARGS_REQ(1)); /* 15.2.8.3.9  */
  mrb_define_method(mrb, fixnum,  "|",        fix_or,            MRB_ARGS_REQ(1)); /* 15.2.8.3.10 */
  mrb_define_method(mrb, fixnum,  "^",        fix_xor,           MRB_ARGS_REQ(1)); /* 15.2.8.3.11 */
  mrb_define_method(mrb, fixnum,  "<<",       fix_lshift,        MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */
  mrb_define_method(mrb, fixnum,  ">>",       fix_rshift,        MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */
  mrb_define_method(mrb, fixnum,  "eql?",     num_eql,           MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
  mrb_define_method(mrb, fixnum,  "hash",     flo_hash,          MRB_ARGS_NONE()); /* 15.2.8.3.18 */
  mrb_define_method(mrb, fixnum,  "to_f",     fix_to_f,          MRB_ARGS_NONE()); /* 15.2.8.3.23 */
  mrb_define_method(mrb, fixnum,  "to_s",     fix_to_s,          MRB_ARGS_NONE()); /* 15.2.8.3.25 */
  mrb_define_method(mrb, fixnum,  "inspect",  fix_to_s,          MRB_ARGS_NONE());
  mrb_define_method(mrb, fixnum,  "divmod",   fix_divmod,        MRB_ARGS_REQ(1)); /* 15.2.8.3.30 (x) */

  /* Float Class */
  fl = mrb->float_class = mrb_define_class(mrb, "Float", numeric);
  mrb_undef_class_method(mrb,  fl, "new");
  mrb_define_method(mrb, fl,      "+",         flo_plus,         MRB_ARGS_REQ(1)); /* 15.2.9.3.1  */
  mrb_define_method(mrb, fl,      "-",         flo_minus,        MRB_ARGS_REQ(1)); /* 15.2.9.3.2  */
  mrb_define_method(mrb, fl,      "*",         flo_mul,          MRB_ARGS_REQ(1)); /* 15.2.9.3.3  */
  mrb_define_method(mrb, fl,      "%",         flo_mod,          MRB_ARGS_REQ(1)); /* 15.2.9.3.5  */
  mrb_define_method(mrb, fl,      "==",        flo_eq,           MRB_ARGS_REQ(1)); /* 15.2.9.3.7  */
  mrb_define_method(mrb, fl,      "ceil",      flo_ceil,         MRB_ARGS_NONE()); /* 15.2.9.3.8  */
  mrb_define_method(mrb, fl,      "finite?",   flo_finite_p,     MRB_ARGS_NONE()); /* 15.2.9.3.9  */
  mrb_define_method(mrb, fl,      "floor",     flo_floor,        MRB_ARGS_NONE()); /* 15.2.9.3.10 */
  mrb_define_method(mrb, fl,      "infinite?", flo_infinite_p,   MRB_ARGS_NONE()); /* 15.2.9.3.11 */
  mrb_define_method(mrb, fl,      "round",     flo_round,        MRB_ARGS_NONE()); /* 15.2.9.3.12 */
  mrb_define_method(mrb, fl,      "to_f",      flo_to_f,         MRB_ARGS_NONE()); /* 15.2.9.3.13 */
  mrb_define_method(mrb, fl,      "to_i",      flo_truncate,     MRB_ARGS_NONE()); /* 15.2.9.3.14 */
  mrb_define_method(mrb, fl,      "to_int",    flo_truncate,     MRB_ARGS_NONE());
  mrb_define_method(mrb, fl,      "truncate",  flo_truncate,     MRB_ARGS_NONE()); /* 15.2.9.3.15 */
  mrb_define_method(mrb, fl,      "divmod",    flo_divmod,       MRB_ARGS_REQ(1));

  mrb_define_method(mrb, fl,      "to_s",      flo_to_s,         MRB_ARGS_NONE()); /* 15.2.9.3.16(x) */
  mrb_define_method(mrb, fl,      "inspect",   flo_to_s,         MRB_ARGS_NONE());
}

Esempio n. 7

0

Mostra file

File: mrb_http.c Progetto: BingoBinBingo/mruby-http

void
mrb_mruby_http_gem_init(mrb_state* mrb) {

    struct RClass* _class_http;
    struct RClass* _class_http_parser;
    struct RClass* _class_http_request;
    struct RClass* _class_http_response;
    struct RClass *_class_http_url;
    int ai = mrb_gc_arena_save(mrb);

    _class_http = mrb_define_module(mrb, "HTTP");
    _class_http_parser = mrb_define_class_under(mrb, _class_http, "Parser", mrb->object_class);
    mrb_define_method(mrb, _class_http_parser, "initialize", mrb_http_parser_init, MRB_ARGS_OPT(1));
    mrb_define_method(mrb, _class_http_parser, "parse_request", mrb_http_parser_parse_request, MRB_ARGS_OPT(2));
    mrb_define_method(mrb, _class_http_parser, "parse_response", mrb_http_parser_parse_response, MRB_ARGS_OPT(2));
    mrb_define_method(mrb, _class_http_parser, "parse_url", mrb_http_parser_parse_url, MRB_ARGS_REQ(1));
    mrb_define_method(mrb, _class_http_parser, "execute", mrb_http_parser_execute, MRB_ARGS_REQ(1));
    mrb_gc_arena_restore(mrb, ai);

    _class_http_request = mrb_define_class_under(mrb, _class_http, "Request", mrb->object_class);
    mrb_define_method(mrb, _class_http_request, "initialize", mrb_http_object_initialize, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_request, "schema", mrb_http_object_schema_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_request, "host", mrb_http_object_host_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_request, "port", mrb_http_object_port_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_request, "path", mrb_http_object_path_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_request, "query", mrb_http_object_query_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_request, "headers", mrb_http_object_headers_get, MRB_ARGS_NONE());
    //mrb_define_method(mrb, _class_http_request, "headers[]=", mrb_http_object_headers_set_item, MRB_ARGS_REQ(2));
    mrb_define_method(mrb, _class_http_request, "method", mrb_http_object_method_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_request, "method=", mrb_http_object_method_set, MRB_ARGS_REQ(1));
    mrb_define_method(mrb, _class_http_request, "body", mrb_http_object_body_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_request, "body=", mrb_http_object_body_set, MRB_ARGS_REQ(1));
    mrb_gc_arena_restore(mrb, ai);

    _class_http_response = mrb_define_class_under(mrb, _class_http, "Response", mrb->object_class);
    mrb_define_method(mrb, _class_http_response, "initialize", mrb_http_object_initialize, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_response, "status_code", mrb_http_object_status_code_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_response, "message", mrb_http_object_message_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_response, "content_length", mrb_http_object_content_length_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_response, "schema", mrb_http_object_schema_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_response, "host", mrb_http_object_host_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_response, "port", mrb_http_object_port_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_response, "path", mrb_http_object_path_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_response, "query", mrb_http_object_query_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_response, "headers", mrb_http_object_headers_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_response, "method", mrb_http_object_method_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_response, "body", mrb_http_object_body_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_response, "body=", mrb_http_object_body_set, MRB_ARGS_REQ(1));
    mrb_gc_arena_restore(mrb, ai);

    _class_http_url = mrb_define_class_under(mrb, _class_http, "URL", mrb->object_class);
    mrb_define_method(mrb, _class_http_url, "schema", mrb_http_object_schema_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_url, "host", mrb_http_object_host_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_url, "port", mrb_http_object_port_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_url, "path", mrb_http_object_path_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_url, "query", mrb_http_object_query_get, MRB_ARGS_NONE());
    mrb_define_method(mrb, _class_http_url, "fragment", mrb_http_object_fragment_get, MRB_ARGS_NONE());
    //mrb_define_method(mrb, _class_http_url, "to_url", mrb_http_url_to_url, MRB_ARGS_NONE());
    mrb_define_class_method(mrb, _class_http_url, "encode", mrb_http_url_encode, MRB_ARGS_REQ(1));
    mrb_define_class_method(mrb, _class_http_url, "decode", mrb_http_url_decode, MRB_ARGS_REQ(1));
    mrb_gc_arena_restore(mrb, ai);
}

Esempio n. 8

0

Mostra file

File: ctx_impl_mrb.c Progetto: SvenDowideit/clearlinux

static void
grn_ctx_impl_mrb_init_bindings(grn_ctx *ctx)
{
  mrb_state *mrb = ctx->impl->mrb.state;

  mrb->ud = ctx;
  ctx->impl->mrb.module = mrb_define_module(mrb, "Groonga");

  mrb_define_class(mrb, "LoadError", mrb_class_get(mrb, "ScriptError"));
  mrb_define_method(mrb, mrb->kernel_module,
                    "load", mrb_kernel_load, MRB_ARGS_REQ(1));

  {
    mrb_value load_path;
    const char *plugins_dir;
    const char *system_ruby_scripts_dir;

    load_path = mrb_ary_new(mrb);
    plugins_dir = grn_plugin_get_system_plugins_dir();
    mrb_ary_push(mrb, load_path,
                 mrb_str_new_cstr(mrb, plugins_dir));
    system_ruby_scripts_dir = grn_mrb_get_system_ruby_scripts_dir(ctx);
    mrb_ary_push(mrb, load_path,
                 mrb_str_new_cstr(mrb, system_ruby_scripts_dir));
    mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$LOAD_PATH"), load_path);
  }

  grn_mrb_load(ctx, "require.rb");
  grn_mrb_load(ctx, "initialize/pre.rb");

  grn_mrb_converter_init(ctx);
  grn_mrb_error_init(ctx);
  grn_mrb_id_init(ctx);
  grn_mrb_operator_init(ctx);
  grn_mrb_ctx_init(ctx);
  grn_mrb_logger_init(ctx);
  grn_mrb_void_init(ctx);
  grn_mrb_bulk_init(ctx);
  grn_mrb_object_init(ctx);
  grn_mrb_object_flags_init(ctx);
  grn_mrb_database_init(ctx);
  grn_mrb_table_init(ctx);
  grn_mrb_array_init(ctx);
  grn_mrb_hash_table_init(ctx);
  grn_mrb_patricia_trie_init(ctx);
  grn_mrb_double_array_trie_init(ctx);
  grn_mrb_column_init(ctx);
  grn_mrb_fixed_size_column_init(ctx);
  grn_mrb_variable_size_column_init(ctx);
  grn_mrb_index_column_init(ctx);
  grn_mrb_index_cursor_init(ctx);
  grn_mrb_type_init(ctx);
  grn_mrb_expr_init(ctx);
  grn_mrb_accessor_init(ctx);
  grn_mrb_procedure_init(ctx);
  grn_mrb_command_init(ctx);
  grn_mrb_command_input_init(ctx);
  grn_mrb_table_cursor_init(ctx);
  grn_mrb_table_cursor_flags_init(ctx);
  grn_mrb_content_type_init(ctx);
  grn_mrb_writer_init(ctx);

  grn_mrb_load(ctx, "initialize/post.rb");
}

Esempio n. 9

0

Mostra file

File: hdb.c Progetto: nozomiS/mruby-tokyocabinet

void
mrb_mruby_tokyocabinet_gem_init(mrb_state* mrb) {
  struct RClass *c = mrb_define_class(mrb, "Hdb", mrb->object_class);
  MRB_SET_INSTANCE_TT(c, MRB_TT_DATA);

  mrb_define_method(mrb, c, "initialize", hdb_initialize, MRB_ARGS_NONE());
  mrb_define_method(mrb, c, "ecode", hdb_ecode, MRB_ARGS_NONE());
  mrb_define_method(mrb, c, "tune", hdb_tune, MRB_ARGS_REQ(4));
  mrb_define_method(mrb, c, "set_cache", hdb_set_cache, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, c, "set_xmsize", hdb_set_xmsize, MRB_ARGS_REQ(1));

  mrb_define_method(mrb, c, "open", hdb_open, MRB_ARGS_REQ(2));
  mrb_define_method(mrb, c, "close", hdb_close, MRB_ARGS_NONE());
  mrb_define_method(mrb, c, "put", hdb_put, MRB_ARGS_REQ(2)|MRB_ARGS_OPT(1));
  mrb_define_method(mrb, c, "out", hdb_out, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, c, "get", hdb_get, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, c, "vsize", hdb_value_size, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, c, "sync", hdb_sync, MRB_ARGS_NONE());
  mrb_define_method(mrb, c, "optimize", hdb_optimize, MRB_ARGS_REQ(4));
  mrb_define_method(mrb, c, "vanish", hdb_vanish, MRB_ARGS_NONE());
  mrb_define_method(mrb, c, "copy", hdb_copy, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, c, "path", hdb_path, MRB_ARGS_NONE());
  mrb_define_method(mrb, c, "rnum", hdb_record_num, MRB_ARGS_NONE());
  mrb_define_method(mrb, c, "fize", hdb_filesize, MRB_ARGS_NONE());

  // interfaces for hash compliant 
  
  mrb_define_method(mrb, c, "[]", hdb_get, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, c, "[]=", hdb_put, MRB_ARGS_REQ(2));
  mrb_define_method(mrb, c, "store", hdb_put, MRB_ARGS_REQ(2));
  mrb_define_method(mrb, c, "assoc", hdb_assoc, MRB_ARGS_REQ(2));
  mrb_define_method(mrb, c, "delete", hdb_out, MRB_ARGS_REQ(1));

  mrb_define_method(mrb, c, "empty?", hdb_empty_, MRB_ARGS_NONE());
  mrb_define_method(mrb, c, "has_key?", hdb_check_key, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, c, "include?", hdb_check_key, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, c, "member?", hdb_check_key, MRB_ARGS_REQ(1));

  mrb_define_method(mrb, c, "length", hdb_record_num, MRB_ARGS_NONE());
  mrb_define_method(mrb, c, "size", hdb_record_num, MRB_ARGS_NONE());


  mrb_define_const(mrb, c, "TLARGE",   mrb_fixnum_value(HDBTLARGE));
  mrb_define_const(mrb, c, "TDEFLATE", mrb_fixnum_value(HDBTDEFLATE));
  mrb_define_const(mrb, c, "TBZIP",    mrb_fixnum_value(HDBTBZIP));
  mrb_define_const(mrb, c, "TTCBS",    mrb_fixnum_value(HDBTTCBS));
  mrb_define_const(mrb, c, "TEXCODEC", mrb_fixnum_value(HDBTEXCODEC));

  mrb_define_const(mrb, c, "OREADER", mrb_fixnum_value(HDBOREADER));
  mrb_define_const(mrb, c, "OWRITER", mrb_fixnum_value(HDBOWRITER));
  mrb_define_const(mrb, c, "OCREATE", mrb_fixnum_value(HDBOCREAT));
  mrb_define_const(mrb, c, "OTRUNC",  mrb_fixnum_value(HDBOTRUNC));
  mrb_define_const(mrb, c, "ONOLOCK", mrb_fixnum_value(HDBONOLCK));
  mrb_define_const(mrb, c, "OLOCKNB", mrb_fixnum_value(HDBOLCKNB));
  mrb_define_const(mrb, c, "OOTSYNC", mrb_fixnum_value(HDBOTSYNC));
}

Esempio n. 10

0

Mostra file

File: math.cpp Progetto: Prashant-Jonny/red_tint

/* ------------------------------------------------------------------------*/
void mrb_mruby_math_gem_init(mrb_state* mrb)
{
    mrb->define_module("Math")

        #ifdef M_PI
            .define_const("PI", mrb_float_value(M_PI))
        #else
            .define_const("PI", mrb_float_value(atan(1.0)*4.0))
        #endif

        #ifdef M_E
            .define_const("E", mrb_float_value(M_E))
        #else
            .define_const("E", mrb_float_value(exp(1.0)))
        #endif

        #ifdef MRB_USE_FLOAT
            .define_const("TOLERANCE", mrb_float_value(1e-5))
        #else
            .define_const("TOLERANCE", mrb_float_value(1e-12))
        #endif

            .define_module_function("sin", math_sin, MRB_ARGS_REQ(1))
            .define_module_function("cos", math_cos, MRB_ARGS_REQ(1))
            .define_module_function("tan", math_tan, MRB_ARGS_REQ(1))

            .define_module_function("asin", math_asin, MRB_ARGS_REQ(1))
            .define_module_function("acos", math_acos, MRB_ARGS_REQ(1))
            .define_module_function("atan", math_atan, MRB_ARGS_REQ(1))
            .define_module_function("atan2", math_atan2, MRB_ARGS_REQ(2))

            .define_module_function("sinh", math_sinh, MRB_ARGS_REQ(1))
            .define_module_function("cosh", math_cosh, MRB_ARGS_REQ(1))
            .define_module_function("tanh", math_tanh, MRB_ARGS_REQ(1))

            .define_module_function("asinh", math_asinh, MRB_ARGS_REQ(1))
            .define_module_function("acosh", math_acosh, MRB_ARGS_REQ(1))
            .define_module_function("atanh", math_atanh, MRB_ARGS_REQ(1))

            .define_module_function("exp", math_exp, MRB_ARGS_REQ(1))
            .define_module_function("log", math_log, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1))
            .define_module_function("log2", math_log2, MRB_ARGS_REQ(1))
            .define_module_function("log10", math_log10, MRB_ARGS_REQ(1))
            .define_module_function("sqrt", math_sqrt, MRB_ARGS_REQ(1))
            .define_module_function("cbrt", math_cbrt, MRB_ARGS_REQ(1))

            .define_module_function("frexp", math_frexp, MRB_ARGS_REQ(1))
            .define_module_function("ldexp", math_ldexp, MRB_ARGS_REQ(2))

            .define_module_function("hypot", math_hypot, MRB_ARGS_REQ(2))

            .define_module_function("erf",  math_erf,  MRB_ARGS_REQ(1))
            .define_module_function("erfc", math_erfc, MRB_ARGS_REQ(1))
            .fin();
}

Esempio n. 11

0

Mostra file

File: mrb_expr.c Progetto: naoa/groonga

void
grn_mrb_expr_init(grn_ctx *ctx)
{
  mrb_state *mrb = ctx->impl->mrb.state;
  struct RClass *module = ctx->impl->mrb.module;
  struct RClass *object_class = ctx->impl->mrb.object_class;
  struct RClass *klass;

  klass = mrb_define_class_under(mrb, module, "ScanInfo", mrb->object_class);
  MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA);
  mrb_define_method(mrb, klass, "initialize",
                    mrb_grn_scan_info_initialize, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "put_index",
                    mrb_grn_scan_info_put_index, MRB_ARGS_REQ(6));
  mrb_define_method(mrb, klass, "op",
                    mrb_grn_scan_info_get_op, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "op=",
                    mrb_grn_scan_info_set_op, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "end=",
                    mrb_grn_scan_info_set_end, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "query=",
                    mrb_grn_scan_info_set_query, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "flags",
                    mrb_grn_scan_info_get_flags, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "flags=",
                    mrb_grn_scan_info_set_flags, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "logical_op",
                    mrb_grn_scan_info_get_logical_op, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "logical_op=",
                    mrb_grn_scan_info_set_logical_op, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "max_interval",
                    mrb_grn_scan_info_get_max_interval, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "max_interval=",
                    mrb_grn_scan_info_set_max_interval, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "similarity_threshold",
                    mrb_grn_scan_info_get_similarity_threshold, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "similarity_threshold=",
                    mrb_grn_scan_info_set_similarity_threshold, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "get_arg",
                    mrb_grn_scan_info_get_arg, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "push_arg",
                    mrb_grn_scan_info_push_arg, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "start_position",
                    mrb_grn_scan_info_get_start_position, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "start_position=",
                    mrb_grn_scan_info_set_start_position, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "reset_position",
                    mrb_grn_scan_info_reset_position, MRB_ARGS_NONE());

  klass = mrb_define_class_under(mrb, module,
                                 "ExpressionCode", mrb->object_class);
  MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA);
  mrb_define_method(mrb, klass, "initialize",
                    mrb_grn_expr_code_initialize, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "inspect",
                    mrb_grn_expr_code_inspect, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "weight",
                    mrb_grn_expr_code_get_weight, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "value",
                    mrb_grn_expr_code_get_value, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "n_args",
                    mrb_grn_expr_code_get_n_args, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "op",
                    mrb_grn_expr_code_get_op, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "flags",
                    mrb_grn_expr_code_get_flags, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "modify",
                    mrb_grn_expr_code_get_modify, MRB_ARGS_NONE());

  {
    struct RClass *expression_code_class = klass;
    struct RClass *flags_module;
    flags_module = mrb_define_module_under(mrb, expression_code_class, "Flags");
    mrb_define_const(mrb, flags_module, "RELATIONAL_EXPRESSION",
                     mrb_fixnum_value(GRN_EXPR_CODE_RELATIONAL_EXPRESSION));
  }

  klass = mrb_define_class_under(mrb, module, "Expression", object_class);
  MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA);

#define DEFINE_FLAG(name)                               \
  mrb_define_const(mrb, klass,                          \
                   #name,                               \
                   mrb_fixnum_value(GRN_EXPR_ ## name))

  DEFINE_FLAG(SYNTAX_QUERY);
  DEFINE_FLAG(SYNTAX_SCRIPT);
  DEFINE_FLAG(SYNTAX_OUTPUT_COLUMNS);
  DEFINE_FLAG(ALLOW_PRAGMA);
  DEFINE_FLAG(ALLOW_COLUMN);
  DEFINE_FLAG(ALLOW_UPDATE);
  DEFINE_FLAG(ALLOW_LEADING_NOT);

#undef DEFINE_FLAG

  mrb_define_class_method(mrb, klass, "create",
                          mrb_grn_expression_class_create,
                          MRB_ARGS_REQ(1));

  mrb_define_method(mrb, klass, "initialize",
                    mrb_grn_expression_initialize, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "empty?",
                    mrb_grn_expression_is_empty, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "codes",
                    mrb_grn_expression_codes, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "[]",
                    mrb_grn_expression_array_reference, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "condition=",
                    mrb_grn_expression_set_condition, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "take_object",
                    mrb_grn_expression_take_object, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "allocate_constant",
                    mrb_grn_expression_allocate_constant, MRB_ARGS_REQ(1));

  mrb_define_method(mrb, klass, "parse",
                    mrb_grn_expression_parse, MRB_ARGS_ARG(1, 1));

  mrb_define_method(mrb, klass, "append_object",
                    mrb_grn_expression_append_object, MRB_ARGS_REQ(2));
  mrb_define_method(mrb, klass, "append_constant",
                    mrb_grn_expression_append_constant, MRB_ARGS_REQ(3));
  mrb_define_method(mrb, klass, "append_operator",
                    mrb_grn_expression_append_operator, MRB_ARGS_REQ(2));
}

Esempio n. 12

0

Mostra file

File: printer.c Progetto: FernandoCleberSouza/mruby-cloudwalk-platform

void
mrb_print_init(mrb_state* mrb)
{
  struct RClass *platform;
  struct RClass *print;

  platform = mrb_class_get(mrb, "Platform");
  print    = mrb_define_class_under(mrb, platform, "Printer", mrb->object_class);

  mrb_define_class_method(mrb , print , "_open"      , mrb_platform_printer_s__open      , MRB_ARGS_NONE());
  mrb_define_class_method(mrb , print , "_reset"     , mrb_platform_printer_s__reset     , MRB_ARGS_NONE());
  mrb_define_class_method(mrb , print , "_close"     , mrb_platform_printer_s__close     , MRB_ARGS_NONE());
  mrb_define_class_method(mrb , print , "_font="     , mrb_platform_printer_s__font      , MRB_ARGS_REQ(1));
  mrb_define_class_method(mrb , print , "_level="    , mrb_platform_printer_s__level     , MRB_ARGS_REQ(1));
  mrb_define_class_method(mrb , print , "_size"      , mrb_platform_printer_s__size      , MRB_ARGS_REQ(4));
  mrb_define_class_method(mrb , print , "_feed"      , mrb_platform_printer_s__feed      , MRB_ARGS_REQ(1));
  mrb_define_class_method(mrb , print , "_print"     , mrb_platform_printer_s__print     , MRB_ARGS_REQ(1));
  mrb_define_class_method(mrb , print , "_print_bmp" , mrb_platform_printer_s__print_bmp , MRB_ARGS_REQ(1));
  mrb_define_class_method(mrb , print , "_check"     , mrb_platform_printer_s__check     , MRB_ARGS_NONE());
}

Esempio n. 13

0

Mostra file

File: cfunc_struct.c Progetto: fundamental/mruby-cfunc

void
init_cfunc_struct(mrb_state *mrb, struct RClass* module)
{
    struct cfunc_state *state = cfunc_state(mrb, module);
    struct RClass *struct_class = mrb_define_class_under(mrb, module, "Struct", mrb->object_class);
    set_cfunc_state(mrb, struct_class, state);
    state->struct_class = struct_class;
    
    mrb_define_class_method(mrb, struct_class, "define_struct", cfunc_struct_define_struct, MRB_ARGS_REQ(1));
}

Esempio n. 14

0

Mostra file

File: sdl2-ttf.c Progetto: Moon4u/mruby-sdl2-ttf

void
mrb_mruby_sdl2_ttf_gem_init(mrb_state *mrb)
{
  int arena_size;
  struct RClass *mod_Ttf = mrb_define_module_under(mrb, mod_SDL2, "TTF");
  class_Font = mrb_define_class_under(mrb, mod_Ttf, "Font", mrb->object_class);

  MRB_SET_INSTANCE_TT(class_Font, MRB_TT_DATA);

  mrb_define_module_function(mrb, mod_Ttf, "init",                  mrb_sdl2_ttf_init,                MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Ttf, "quit",                  mrb_sdl2_ttf_quit,                MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Ttf, "is_init?",              mrb_sdl2_ttf_was_init,                MRB_ARGS_NONE());

  mrb_define_method(mrb, class_Font, "initialize",                     mrb_sdl2_ttf_font_initialize,   MRB_ARGS_REQ(2) | MRB_ARGS_OPT(1));
  mrb_define_method(mrb, class_Font, "free",                           mrb_sdl2_ttf_font_free,                           MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Font, "destroy",                        mrb_sdl2_ttf_font_free,                           MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Font, "get_style",                      mrb_sdl2_ttf_font_get_style,                      MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Font, "set_style",                      mrb_sdl2_ttf_font_set_style,                      MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Font, "get_outline",                    mrb_sdl2_ttf_font_get_outline,                    MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Font, "set_outline",                    mrb_sdl2_ttf_font_set_outline,                    MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Font, "get_hinting",                    mrb_sdl2_ttf_font_get_hinting,                    MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Font, "set_hinting",                    mrb_sdl2_ttf_font_set_hinting,                    MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Font, "get_height",                     mrb_sdl2_ttf_font_get_height,                     MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Font, "get_ascent",                     mrb_sdl2_ttf_font_get_ascent,                     MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Font, "get_descent",                    mrb_sdl2_ttf_font_get_descent,                    MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Font, "get_lineskip",                   mrb_sdl2_ttf_font_get_lineskip,                   MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Font, "get_kerning",                    mrb_sdl2_ttf_font_get_kerning,                    MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Font, "set_kerning",                    mrb_sdl2_ttf_font_set_kerning,                    MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Font, "get_faces",                      mrb_sdl2_ttf_font_get_faces,                      MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Font, "face_is_fixed_width?",           mrb_sdl2_ttf_font_face_fixed_width,               MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Font, "get_face_family_name",           mrb_sdl2_ttf_font_get_face_family_name,           MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Font, "get_face_style_name",            mrb_sdl2_ttf_font_get_face_style_name,            MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Font, "get_glyph_index",                mrb_sdl2_ttf_font_get_glyph_index,                MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Font, "get_glyph_metric",               mrb_sdl2_ttf_font_get_glyph_metric,               MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Font, "size_text",                      mrb_sdl2_ttf_font_get_size_text,                  MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Font, "size_UTF8",                      mrb_sdl2_ttf_font_get_size_UTF8,                  MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Font, "size_UNICODE",                   mrb_sdl2_ttf_font_get_size_UNICODE,               MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Font, "render_text",                    mrb_sdl2_ttf_font_render_text,                    MRB_ARGS_REQ(5));
  mrb_define_method(mrb, class_Font, "render_UTF8",                    mrb_sdl2_ttf_font_render_UTF8,                    MRB_ARGS_REQ(5));
  mrb_define_method(mrb, class_Font, "render_UNICODE",                 mrb_sdl2_ttf_font_render_UNICODE,                 MRB_ARGS_REQ(5));
  mrb_define_method(mrb, class_Font, "render_glyph",                   mrb_sdl2_ttf_font_render_glyph,                   MRB_ARGS_REQ(5));
  mrb_define_method(mrb, class_Font, "render_text_shaded",             mrb_sdl2_ttf_font_render_text_shaded,             MRB_ARGS_REQ(9));
  mrb_define_method(mrb, class_Font, "render_UTF8_shaded",             mrb_sdl2_ttf_font_render_UTF8_shaded,             MRB_ARGS_REQ(9));
  mrb_define_method(mrb, class_Font, "render_UNICODE_shaded",          mrb_sdl2_ttf_font_render_UNICODE_shaded,          MRB_ARGS_REQ(9));
  mrb_define_method(mrb, class_Font, "render_glyph_shaded",            mrb_sdl2_ttf_font_render_glyph_shaded,            MRB_ARGS_REQ(9));
  mrb_define_method(mrb, class_Font, "render_text_blended",            mrb_sdl2_ttf_font_render_text_blended,            MRB_ARGS_REQ(5));
  mrb_define_method(mrb, class_Font, "render_UTF8_blended",            mrb_sdl2_ttf_font_render_UTF8_blended,            MRB_ARGS_REQ(5));
  mrb_define_method(mrb, class_Font, "render_UNICODE_blended",         mrb_sdl2_ttf_font_render_UNICODE_blended,         MRB_ARGS_REQ(5));
  mrb_define_method(mrb, class_Font, "render_glyph_blended",           mrb_sdl2_ttf_font_render_glyph_blended,           MRB_ARGS_REQ(5));
  mrb_define_method(mrb, class_Font, "render_text_blended_wrapped",    mrb_sdl2_ttf_font_render_text_blended_wrapped,    MRB_ARGS_REQ(6));
  mrb_define_method(mrb, class_Font, "render_UTF8_blended_wrapped",    mrb_sdl2_ttf_font_render_UTF8_blended_wrapped,    MRB_ARGS_REQ(6));
  mrb_define_method(mrb, class_Font, "render_UNICODE_blended_wrapped", mrb_sdl2_ttf_font_render_UNICODE_blended_wrapped, MRB_ARGS_REQ(6));
  mrb_define_method(mrb, class_Font, "get_kerning_size",               mrb_sdl2_ttf_font_get_kerning_size,               MRB_ARGS_REQ(2));

  arena_size = mrb_gc_arena_save(mrb);
  mrb_define_const(mrb, mod_Ttf, "UNICODE_BOM_NATIVE",  mrb_fixnum_value(UNICODE_BOM_NATIVE));
  mrb_define_const(mrb, mod_Ttf, "UNICODE_BOM_SWAPPED", mrb_fixnum_value(UNICODE_BOM_SWAPPED));
  mrb_gc_arena_restore(mrb, arena_size);

  arena_size = mrb_gc_arena_save(mrb);
  mrb_define_const(mrb, mod_Ttf, "TTF_STYLE_NORMAL",        mrb_fixnum_value(TTF_STYLE_NORMAL));
  mrb_define_const(mrb, mod_Ttf, "TTF_STYLE_BOLD",          mrb_fixnum_value(TTF_STYLE_BOLD));
  mrb_define_const(mrb, mod_Ttf, "TTF_STYLE_ITALIC",        mrb_fixnum_value(TTF_STYLE_ITALIC));
  mrb_define_const(mrb, mod_Ttf, "TTF_STYLE_UNDERLINE",     mrb_fixnum_value(TTF_STYLE_UNDERLINE));
  mrb_define_const(mrb, mod_Ttf, "TTF_STYLE_STRIKETHROUGH", mrb_fixnum_value(TTF_STYLE_STRIKETHROUGH));
  mrb_gc_arena_restore(mrb, arena_size);

  arena_size = mrb_gc_arena_save(mrb);
  mrb_define_const(mrb, mod_Ttf, "TTF_HINTING_NORMAL",  mrb_fixnum_value(TTF_HINTING_NORMAL));
  mrb_define_const(mrb, mod_Ttf, "TTF_HINTING_LIGHT",   mrb_fixnum_value(TTF_HINTING_LIGHT));
  mrb_define_const(mrb, mod_Ttf, "TTF_HINTING_MONO",    mrb_fixnum_value(TTF_HINTING_MONO));
  mrb_define_const(mrb, mod_Ttf, "TTF_HINTING_NONE",    mrb_fixnum_value(TTF_HINTING_NONE));
  mrb_gc_arena_restore(mrb, arena_size);
}

Esempio n. 15

0

Mostra file

File: cp_transform.c Progetto: IceDragon200/mruby-chipmunk2d

MRB_CP_EXTERN void
mrb_cp_transform_init(mrb_state* mrb, struct RClass* cp_module)
{
  mrb_cp_transform_class = mrb_define_class_under(mrb, cp_module, "Transform", mrb->object_class);
  MRB_SET_INSTANCE_TT(mrb_cp_transform_class, MRB_TT_DATA);
  /* */
  mrb_define_method(mrb, mrb_cp_transform_class, "initialize",    transform_initialize,    MRB_ARGS_REQ(6));
  mrb_define_method(mrb, mrb_cp_transform_class, "inverse",       transform_inverse,       MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_transform_class, "a",             transform_get_a,         MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_transform_class, "a=",            transform_set_a,         MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_transform_class, "b",             transform_get_b,         MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_transform_class, "b=",            transform_set_b,         MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_transform_class, "c",             transform_get_c,         MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_transform_class, "c=",            transform_set_c,         MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_transform_class, "d",             transform_get_d,         MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_transform_class, "d=",            transform_set_d,         MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_transform_class, "tx",            transform_get_tx,        MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_transform_class, "tx=",           transform_set_tx,        MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_transform_class, "ty",            transform_get_ty,        MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_transform_class, "ty=",           transform_set_ty,        MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_transform_class, "*",             transform_mult,          MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_transform_class, "point",         transform_point,         MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_transform_class, "vect",          transform_vect,          MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_transform_class, "bb",            transform_bb,            MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_transform_class, "rigid_inverse", transform_rigid_inverse, MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_transform_class, "wrap",          transform_wrap,          MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_transform_class, "wrap_inverse",  transform_wrap_inverse,  MRB_ARGS_REQ(1));
  mrb_define_class_method(mrb, mrb_cp_transform_class, "new_transpose",  transform_s_new_transpose, MRB_ARGS_REQ(6));
  mrb_define_class_method(mrb, mrb_cp_transform_class, "translate",      transform_s_translate,     MRB_ARGS_REQ(1));
  mrb_define_class_method(mrb, mrb_cp_transform_class, "scale",          transform_s_scale,         MRB_ARGS_REQ(2));
  mrb_define_class_method(mrb, mrb_cp_transform_class, "rotate",         transform_s_rotate,        MRB_ARGS_REQ(1));
  mrb_define_class_method(mrb, mrb_cp_transform_class, "rigid",          transform_s_rigid,         MRB_ARGS_REQ(1));
  mrb_define_class_method(mrb, mrb_cp_transform_class, "ortho",          transform_s_ortho,         MRB_ARGS_REQ(1));
  mrb_define_class_method(mrb, mrb_cp_transform_class, "bone_scale",     transform_s_bone_scale,    MRB_ARGS_REQ(2));
  mrb_define_class_method(mrb, mrb_cp_transform_class, "axial_scale",    transform_s_axial_scale,   MRB_ARGS_REQ(3));
}

Esempio n. 16

0

Mostra file

File: fltk.cpp Progetto: RyanScottLewis/mruby-fltk

void mrb_fltk_module_init( mrb_state *mrb ) {
  ARENA_SAVE;

  struct RClass *mrb_fltk_module = mrb_define_module( mrb, "FLTK" );

  // Fl_Align
  DEFINE_FIXNUM_CONSTANT( ALIGN_CENTER, FL_ALIGN_CENTER, mrb_fltk_module );                         // Align the label horizontally in the middle.
  DEFINE_FIXNUM_CONSTANT( ALIGN_TOP, FL_ALIGN_TOP, mrb_fltk_module );                               // Align the label at the top of the widget. Inside labels appear below the top, outside labels are drawn on top of the widget.
  DEFINE_FIXNUM_CONSTANT( ALIGN_BOTTOM, FL_ALIGN_BOTTOM, mrb_fltk_module );                         // Align the label at the bottom of the widget.
  DEFINE_FIXNUM_CONSTANT( ALIGN_LEFT, FL_ALIGN_LEFT, mrb_fltk_module );                             // Align the label at the left of the widget. Inside labels appear left-justified starting at the left side of the widget, outside labels are right-justified and drawn to the left of the widget.
  DEFINE_FIXNUM_CONSTANT( ALIGN_RIGHT, FL_ALIGN_RIGHT, mrb_fltk_module );                           // Align the label to the right of the widget.
  DEFINE_FIXNUM_CONSTANT( ALIGN_INSIDE, FL_ALIGN_INSIDE, mrb_fltk_module );                         // Draw the label inside of the widget.
  DEFINE_FIXNUM_CONSTANT( ALIGN_TEXT_OVER_IMAGE, FL_ALIGN_TEXT_OVER_IMAGE, mrb_fltk_module );       // If the label contains an image, draw the text on top of the image.
  DEFINE_FIXNUM_CONSTANT( ALIGN_IMAGE_OVER_TEXT, FL_ALIGN_IMAGE_OVER_TEXT, mrb_fltk_module );       // If the label contains an image, draw the text below the image.
  DEFINE_FIXNUM_CONSTANT( ALIGN_CLIP, FL_ALIGN_CLIP, mrb_fltk_module );                             // All parts of the label that are lager than the widget will not be drawn .
  DEFINE_FIXNUM_CONSTANT( ALIGN_WRAP, FL_ALIGN_WRAP, mrb_fltk_module );                             // Wrap text that does not fit the width of the widget.
  DEFINE_FIXNUM_CONSTANT( ALIGN_IMAGE_NEXT_TO_TEXT, FL_ALIGN_IMAGE_NEXT_TO_TEXT, mrb_fltk_module ); // If the label contains an image, draw the text to the right of the image.
  DEFINE_FIXNUM_CONSTANT( ALIGN_TEXT_NEXT_TO_IMAGE, FL_ALIGN_TEXT_NEXT_TO_IMAGE, mrb_fltk_module ); // If the label contains an image, draw the text to the left of the image.
  DEFINE_FIXNUM_CONSTANT( ALIGN_IMAGE_BACKDROP, FL_ALIGN_IMAGE_BACKDROP, mrb_fltk_module );         // If the label contains an image, draw the image or deimage in the background.
  DEFINE_FIXNUM_CONSTANT( ALIGN_TOP_LEFT, FL_ALIGN_TOP_LEFT, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( ALIGN_TOP_RIGHT, FL_ALIGN_TOP_RIGHT, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( ALIGN_BOTTOM_LEFT, FL_ALIGN_BOTTOM_LEFT, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( ALIGN_BOTTOM_RIGHT, FL_ALIGN_BOTTOM_RIGHT, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( ALIGN_LEFT_TOP, FL_ALIGN_LEFT_TOP, mrb_fltk_module );           // magic value
  DEFINE_FIXNUM_CONSTANT( ALIGN_RIGHT_TOP, FL_ALIGN_RIGHT_TOP, mrb_fltk_module );         // magic value
  DEFINE_FIXNUM_CONSTANT( ALIGN_LEFT_BOTTOM, FL_ALIGN_LEFT_BOTTOM, mrb_fltk_module );     // magic value
  DEFINE_FIXNUM_CONSTANT( ALIGN_RIGHT_BOTTOM, FL_ALIGN_RIGHT_BOTTOM, mrb_fltk_module );   // magic value
  DEFINE_FIXNUM_CONSTANT( ALIGN_NOWRAP, FL_ALIGN_NOWRAP, mrb_fltk_module );               // for back compatibility
  DEFINE_FIXNUM_CONSTANT( ALIGN_POSITION_MASK, FL_ALIGN_POSITION_MASK, mrb_fltk_module ); // left, right, top, bottom
  DEFINE_FIXNUM_CONSTANT( ALIGN_IMAGE_MASK, FL_ALIGN_IMAGE_MASK, mrb_fltk_module );       // l/r, t/b, backdrop

  // Fl_Font
  DEFINE_FIXNUM_CONSTANT( HELVETICA, FL_HELVETICA, mrb_fltk_module );                         // Helvetica (or Arial) normal (0)
  DEFINE_FIXNUM_CONSTANT( HELVETICA_BOLD, FL_HELVETICA_BOLD, mrb_fltk_module );               // Helvetica (or Arial) bold
  DEFINE_FIXNUM_CONSTANT( HELVETICA_ITALIC, FL_HELVETICA_ITALIC, mrb_fltk_module );           // Helvetica (or Arial) oblique
  DEFINE_FIXNUM_CONSTANT( HELVETICA_BOLD_ITALIC, FL_HELVETICA_BOLD_ITALIC, mrb_fltk_module ); // Helvetica (or Arial) bold-oblique
  DEFINE_FIXNUM_CONSTANT( COURIER, FL_COURIER, mrb_fltk_module );                             // Courier normal
  DEFINE_FIXNUM_CONSTANT( COURIER_BOLD, FL_COURIER_BOLD, mrb_fltk_module );                   // Courier bold
  DEFINE_FIXNUM_CONSTANT( COURIER_ITALIC, FL_COURIER_ITALIC, mrb_fltk_module );               // Courier italic
  DEFINE_FIXNUM_CONSTANT( COURIER_BOLD_ITALIC, FL_COURIER_BOLD_ITALIC, mrb_fltk_module );     // Courier bold-italic
  DEFINE_FIXNUM_CONSTANT( TIMES, FL_TIMES, mrb_fltk_module );                                 // Times roman
  DEFINE_FIXNUM_CONSTANT( TIMES_BOLD, FL_TIMES_BOLD, mrb_fltk_module );                       // Times roman bold
  DEFINE_FIXNUM_CONSTANT( TIMES_ITALIC, FL_TIMES_ITALIC, mrb_fltk_module );                   // Times roman italic
  DEFINE_FIXNUM_CONSTANT( TIMES_BOLD_ITALIC, FL_TIMES_BOLD_ITALIC, mrb_fltk_module );         // Times roman bold-italic
  DEFINE_FIXNUM_CONSTANT( SYMBOL, FL_SYMBOL, mrb_fltk_module );                               // Standard symbol font
  DEFINE_FIXNUM_CONSTANT( SCREEN, FL_SCREEN, mrb_fltk_module );                               // Default monospaced screen font
  DEFINE_FIXNUM_CONSTANT( SCREEN_BOLD, FL_SCREEN_BOLD, mrb_fltk_module );                     // Default monospaced bold screen font
  DEFINE_FIXNUM_CONSTANT( ZAPF_DINGBATS, FL_ZAPF_DINGBATS, mrb_fltk_module );                 // Zapf-dingbats font
  DEFINE_FIXNUM_CONSTANT( FREE_FONT, FL_FREE_FONT, mrb_fltk_module );                         // first one to allocate
  DEFINE_FIXNUM_CONSTANT( BOLD, FL_BOLD, mrb_fltk_module );                                   // add this to helvetica, courier, or times
  DEFINE_FIXNUM_CONSTANT( ITALIC, FL_ITALIC, mrb_fltk_module );                               // add this to helvetica, courier, or times
  DEFINE_FIXNUM_CONSTANT( BOLD_ITALIC, FL_BOLD_ITALIC, mrb_fltk_module );                     // add this to helvetica, courier, or times

  // Fl_When
  DEFINE_FIXNUM_CONSTANT( WHEN_NEVER, FL_WHEN_NEVER, mrb_fltk_module );                         // Never call the callback.
  DEFINE_FIXNUM_CONSTANT( WHEN_CHANGED, FL_WHEN_CHANGED, mrb_fltk_module );                     // Do the callback only when the widget value changes.
  DEFINE_FIXNUM_CONSTANT( WHEN_NOT_CHANGED, FL_WHEN_NOT_CHANGED, mrb_fltk_module );             // Do the callback whenever the user interacts with the widget.
  DEFINE_FIXNUM_CONSTANT( WHEN_RELEASE, FL_WHEN_RELEASE, mrb_fltk_module );                     // Do the callback when the button or key is released and the value changes.
  DEFINE_FIXNUM_CONSTANT( WHEN_RELEASE_ALWAYS, FL_WHEN_RELEASE_ALWAYS, mrb_fltk_module );       // Do the callback when the button or key is released, even if the value doesn't change.
  DEFINE_FIXNUM_CONSTANT( WHEN_ENTER_KEY, FL_WHEN_ENTER_KEY, mrb_fltk_module );                 // Do the callback when the user presses the ENTER key and the value changes.
  DEFINE_FIXNUM_CONSTANT( WHEN_ENTER_KEY_ALWAYS, FL_WHEN_ENTER_KEY_ALWAYS, mrb_fltk_module );   // Do the callback when the user presses the ENTER key, even if the value doesn't change.
  DEFINE_FIXNUM_CONSTANT( WHEN_ENTER_KEY_CHANGED, FL_WHEN_ENTER_KEY_CHANGED, mrb_fltk_module ); // ?

  // Fl_Event
  DEFINE_FIXNUM_CONSTANT( NO_EVENT, FL_NO_EVENT, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( PUSH, FL_PUSH, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( RELEASE, FL_RELEASE, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( ENTER, FL_ENTER, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( LEAVE, FL_LEAVE, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( DRAG, FL_DRAG, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( FOCUS, FL_FOCUS, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( UNFOCUS, FL_UNFOCUS, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( KEYDOWN, FL_KEYDOWN, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( KEYBOARD, FL_KEYBOARD, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( KEYUP, FL_KEYUP, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( CLOSE, FL_CLOSE, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( MOVE, FL_MOVE, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( SHORTCUT, FL_SHORTCUT, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( DEACTIVATE, FL_DEACTIVATE, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( ACTIVATE, FL_ACTIVATE, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( HIDE, FL_HIDE, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( SHOW, FL_SHOW, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( PASTE, FL_PASTE, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( SELECTIONCLEAR, FL_SELECTIONCLEAR, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( MOUSEWHEEL, FL_MOUSEWHEEL, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( DND_ENTER, FL_DND_ENTER, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( DND_DRAG, FL_DND_DRAG, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( DND_LEAVE, FL_DND_LEAVE, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( DND_RELEASE, FL_DND_RELEASE, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( SCREEN_CONFIGURATION_CHANGED, FL_SCREEN_CONFIGURATION_CHANGED, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( FULLSCREEN, FL_FULLSCREEN, mrb_fltk_module );

  // Fl_Boxtype
  DEFINE_FIXNUM_CONSTANT( NO_BOX, FL_NO_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( FLAT_BOX, FL_FLAT_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( UP_BOX, FL_UP_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( DOWN_BOX, FL_DOWN_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( UP_FRAME, FL_UP_FRAME, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( DOWN_FRAME, FL_DOWN_FRAME, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( THIN_UP_BOX, FL_THIN_UP_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( THIN_DOWN_BOX, FL_THIN_DOWN_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( THIN_UP_FRAME, FL_THIN_UP_FRAME, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( THIN_DOWN_FRAME, FL_THIN_DOWN_FRAME, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( ENGRAVED_BOX, FL_ENGRAVED_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( EMBOSSED_BOX, FL_EMBOSSED_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( ENGRAVED_FRAME, FL_ENGRAVED_FRAME, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( EMBOSSED_FRAME, FL_EMBOSSED_FRAME, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( BORDER_BOX, FL_BORDER_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( SHADOW_BOX, _FL_SHADOW_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( BORDER_FRAME, FL_BORDER_FRAME, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( SHADOW_FRAME, _FL_SHADOW_FRAME, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( ROUNDED_BOX, _FL_ROUNDED_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( RSHADOW_BOX, _FL_RSHADOW_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( ROUNDED_FRAME, _FL_ROUNDED_FRAME, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( RFLAT_BOX, _FL_RFLAT_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( ROUND_UP_BOX, _FL_ROUND_UP_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( ROUND_DOWN_BOX, _FL_ROUND_DOWN_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( DIAMOND_UP_BOX, _FL_DIAMOND_UP_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( DIAMOND_DOWN_BOX, _FL_DIAMOND_DOWN_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( OVAL_BOX, _FL_OVAL_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( OSHADOW_BOX, _FL_OSHADOW_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( OVAL_FRAME, _FL_OVAL_FRAME, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( OFLAT_BOX, _FL_OFLAT_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( PLASTIC_UP_BOX, _FL_PLASTIC_UP_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( PLASTIC_DOWN_BOX, _FL_PLASTIC_DOWN_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( PLASTIC_UP_FRAME, _FL_PLASTIC_UP_FRAME, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( PLASTIC_DOWN_FRAME, _FL_PLASTIC_DOWN_FRAME, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( PLASTIC_THIN_UP_BOX, _FL_PLASTIC_THIN_UP_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( PLASTIC_THIN_DOWN_BOX, _FL_PLASTIC_THIN_DOWN_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( PLASTIC_ROUND_UP_BOX, _FL_PLASTIC_ROUND_UP_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( PLASTIC_ROUND_DOWN_BOX, _FL_PLASTIC_ROUND_DOWN_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( GTK_UP_BOX, _FL_GTK_UP_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( GTK_DOWN_BOX, _FL_GTK_DOWN_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( GTK_UP_FRAME, _FL_GTK_UP_FRAME, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( GTK_DOWN_FRAME, _FL_GTK_DOWN_FRAME, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( GTK_THIN_UP_BOX, _FL_GTK_THIN_UP_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( GTK_THIN_DOWN_BOX, _FL_GTK_THIN_DOWN_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( GTK_THIN_UP_FRAME, _FL_GTK_THIN_UP_FRAME, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( GTK_THIN_DOWN_FRAME, _FL_GTK_THIN_DOWN_FRAME, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( GTK_ROUND_UP_BOX, _FL_GTK_ROUND_UP_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( GTK_ROUND_DOWN_BOX, _FL_GTK_ROUND_DOWN_BOX, mrb_fltk_module );
  DEFINE_FIXNUM_CONSTANT( FREE_BOXTYPE, FL_FREE_BOXTYPE, mrb_fltk_module );

  // DEFINE_MODULE_METHOD( root, font_name, MRB_ARGS_REQ( 1 ) );
  mrb_define_module_function( mrb, mrb_fltk_module, "focus=", mrb_fltk_focus_setter_module_method, MRB_ARGS_REQ( 1 ) );
  mrb_define_module_function( mrb, mrb_fltk_module, "font", mrb_fltk_font_module_method, MRB_ARGS_OPT( 2 ) );
  mrb_define_module_function( mrb, mrb_fltk_module, "measure", mrb_fltk_measure_module_method, MRB_ARGS_REQ( 1 ) );
  mrb_define_module_function( mrb, mrb_fltk_module, "run", mrb_fltk_run_module_method, MRB_ARGS_NONE() );
  mrb_define_module_function( mrb, mrb_fltk_module, "width", mrb_fltk_width_module_method, MRB_ARGS_REQ( 1 ) );
  // DEFINE_MODULE_METHOD( root, set_fonts, MRB_ARGS_REQ( 1 ) );

  ARENA_RESTORE;
}

Esempio n. 17

0

Mostra file

File: sdl2_keyboard.c Progetto: asfluido/mruby-sdl2

void
mruby_sdl2_keyboard_init(mrb_state *mrb)
{
  struct RClass *mod_Input = mrb_module_get_under(mrb, mod_SDL2, "Input");

  mod_Keyboard = mrb_define_module_under(mrb, mod_Input, "Keyboard");

  mrb_define_module_function(mrb, mod_Keyboard, "key_from_name",      mrb_sdl2_keyboard_key_from_name,      MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Keyboard, "key_from_scancode",  mrb_sdl2_keyboard_key_from_scancode,  MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Keyboard, "key_name",           mrb_sdl2_keyboard_key_name,           MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Keyboard, "keyboard_focus",     mrb_sdl2_keyboard_keyboard_focus,     MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Keyboard, "mod_state",          mrb_sdl2_keyboard_get_mod_state,      MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Keyboard, "mod_state=",         mrb_sdl2_keyboard_set_mod_state,      MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Keyboard, "scancode_from_key",  mrb_sdl2_keyboard_scancode_from_key,  MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Keyboard, "scancode_from_name", mrb_sdl2_keyboard_scancode_from_name, MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Keyboard, "scancode_name",      mrb_sdl2_keyboard_scancode_name,      MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Keyboard, "text_input_rect",    mrb_sdl2_keyboard_text_input_rect,    MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Keyboard, "text_input_start",   mrb_sdl2_keyboard_text_input_start,   MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Keyboard, "text_input_stop",    mrb_sdl2_keyboard_text_input_stop,    MRB_ARGS_NONE());

  class_Keysym = mrb_define_class_under(mrb, mod_Keyboard, "Keysym", mrb->object_class);

  MRB_SET_INSTANCE_TT(class_Keysym, MRB_TT_DATA);

  mrb_define_method(mrb, class_Keysym, "scancode", mrb_sdl2_keyboard_keysym_get_scancode, MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Keysym, "symbol",   mrb_sdl2_keyboard_keysym_get_symbol,   MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Keysym, "modifier", mrb_sdl2_keyboard_keysym_get_modifier, MRB_ARGS_NONE());

  int arena_size = mrb_gc_arena_save(mrb);

  /* SDL_Scancode */
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_0", mrb_fixnum_value(SDL_SCANCODE_0));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_1", mrb_fixnum_value(SDL_SCANCODE_1));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_2", mrb_fixnum_value(SDL_SCANCODE_2));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_3", mrb_fixnum_value(SDL_SCANCODE_3));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_4", mrb_fixnum_value(SDL_SCANCODE_4));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_5", mrb_fixnum_value(SDL_SCANCODE_5));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_6", mrb_fixnum_value(SDL_SCANCODE_6));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_7", mrb_fixnum_value(SDL_SCANCODE_7));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_8", mrb_fixnum_value(SDL_SCANCODE_8));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_9", mrb_fixnum_value(SDL_SCANCODE_9));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_A", mrb_fixnum_value(SDL_SCANCODE_A));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_B", mrb_fixnum_value(SDL_SCANCODE_B));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_C", mrb_fixnum_value(SDL_SCANCODE_C));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_D", mrb_fixnum_value(SDL_SCANCODE_D));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_E", mrb_fixnum_value(SDL_SCANCODE_E));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F", mrb_fixnum_value(SDL_SCANCODE_F));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_G", mrb_fixnum_value(SDL_SCANCODE_G));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_H", mrb_fixnum_value(SDL_SCANCODE_H));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_I", mrb_fixnum_value(SDL_SCANCODE_I));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_J", mrb_fixnum_value(SDL_SCANCODE_J));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_K", mrb_fixnum_value(SDL_SCANCODE_K));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_L", mrb_fixnum_value(SDL_SCANCODE_L));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_M", mrb_fixnum_value(SDL_SCANCODE_M));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_N", mrb_fixnum_value(SDL_SCANCODE_N));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_O", mrb_fixnum_value(SDL_SCANCODE_O));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_P", mrb_fixnum_value(SDL_SCANCODE_P));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_Q", mrb_fixnum_value(SDL_SCANCODE_Q));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_R", mrb_fixnum_value(SDL_SCANCODE_R));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_S", mrb_fixnum_value(SDL_SCANCODE_S));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_T", mrb_fixnum_value(SDL_SCANCODE_T));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_U", mrb_fixnum_value(SDL_SCANCODE_U));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_V", mrb_fixnum_value(SDL_SCANCODE_V));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_W", mrb_fixnum_value(SDL_SCANCODE_W));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_X", mrb_fixnum_value(SDL_SCANCODE_X));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_Y", mrb_fixnum_value(SDL_SCANCODE_Y));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_Z", mrb_fixnum_value(SDL_SCANCODE_Z));

  mrb_gc_arena_restore(mrb, arena_size);
  arena_size = mrb_gc_arena_save(mrb);

  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F1", mrb_fixnum_value(SDL_SCANCODE_F1));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F2", mrb_fixnum_value(SDL_SCANCODE_F2));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F3", mrb_fixnum_value(SDL_SCANCODE_F3));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F4", mrb_fixnum_value(SDL_SCANCODE_F4));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F5", mrb_fixnum_value(SDL_SCANCODE_F5));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F6", mrb_fixnum_value(SDL_SCANCODE_F6));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F7", mrb_fixnum_value(SDL_SCANCODE_F7));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F8", mrb_fixnum_value(SDL_SCANCODE_F8));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F9", mrb_fixnum_value(SDL_SCANCODE_F9));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F10", mrb_fixnum_value(SDL_SCANCODE_F10));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F11", mrb_fixnum_value(SDL_SCANCODE_F11));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F12", mrb_fixnum_value(SDL_SCANCODE_F12));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F13", mrb_fixnum_value(SDL_SCANCODE_F13));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F14", mrb_fixnum_value(SDL_SCANCODE_F14));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F15", mrb_fixnum_value(SDL_SCANCODE_F15));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F16", mrb_fixnum_value(SDL_SCANCODE_F16));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F17", mrb_fixnum_value(SDL_SCANCODE_F17));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F18", mrb_fixnum_value(SDL_SCANCODE_F18));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F19", mrb_fixnum_value(SDL_SCANCODE_F19));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F20", mrb_fixnum_value(SDL_SCANCODE_F20));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F21", mrb_fixnum_value(SDL_SCANCODE_F21));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F22", mrb_fixnum_value(SDL_SCANCODE_F22));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F23", mrb_fixnum_value(SDL_SCANCODE_F23));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F24", mrb_fixnum_value(SDL_SCANCODE_F24));

  mrb_gc_arena_restore(mrb, arena_size);
  arena_size = mrb_gc_arena_save(mrb);

  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_BACKSPACE",   mrb_fixnum_value(SDL_SCANCODE_BACKSPACE));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_CAPSLOCK",    mrb_fixnum_value(SDL_SCANCODE_CAPSLOCK));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_DELETE",      mrb_fixnum_value(SDL_SCANCODE_DELETE));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_ESCAPE",      mrb_fixnum_value(SDL_SCANCODE_ESCAPE));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_END",         mrb_fixnum_value(SDL_SCANCODE_END));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_HOME",        mrb_fixnum_value(SDL_SCANCODE_HOME));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_INSERT",      mrb_fixnum_value(SDL_SCANCODE_INSERT));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_LALT",        mrb_fixnum_value(SDL_SCANCODE_LALT));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_LCTRL",       mrb_fixnum_value(SDL_SCANCODE_LCTRL));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_LEFT",        mrb_fixnum_value(SDL_SCANCODE_LEFT));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_LSHIFT",      mrb_fixnum_value(SDL_SCANCODE_LSHIFT));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_PAGEDOWN",    mrb_fixnum_value(SDL_SCANCODE_PAGEDOWN));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_PAGEUP",      mrb_fixnum_value(SDL_SCANCODE_PAGEUP));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_PRINTSCREEN", mrb_fixnum_value(SDL_SCANCODE_PRINTSCREEN));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_RALT",        mrb_fixnum_value(SDL_SCANCODE_RALT));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_RCTRL",       mrb_fixnum_value(SDL_SCANCODE_RCTRL));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_RETURN",      mrb_fixnum_value(SDL_SCANCODE_RETURN));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_RIGHT",       mrb_fixnum_value(SDL_SCANCODE_RIGHT));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_RSHIFT",      mrb_fixnum_value(SDL_SCANCODE_RSHIFT));
  mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_UNKNOWN",     mrb_fixnum_value(SDL_SCANCODE_UNKNOWN));

  mrb_gc_arena_restore(mrb, arena_size);
  arena_size = mrb_gc_arena_save(mrb);

  /* SDL_Keycode */
  mrb_define_const(mrb, mod_Keyboard, "SDLK_0", mrb_fixnum_value(SDLK_0));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_1", mrb_fixnum_value(SDLK_1));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_2", mrb_fixnum_value(SDLK_2));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_3", mrb_fixnum_value(SDLK_3));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_4", mrb_fixnum_value(SDLK_4));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_5", mrb_fixnum_value(SDLK_5));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_6", mrb_fixnum_value(SDLK_6));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_7", mrb_fixnum_value(SDLK_7));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_8", mrb_fixnum_value(SDLK_8));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_9", mrb_fixnum_value(SDLK_9));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_A", mrb_fixnum_value(SDLK_a));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_B", mrb_fixnum_value(SDLK_b));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_C", mrb_fixnum_value(SDLK_c));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_D", mrb_fixnum_value(SDLK_d));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_E", mrb_fixnum_value(SDLK_e));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F", mrb_fixnum_value(SDLK_f));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_G", mrb_fixnum_value(SDLK_g));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_H", mrb_fixnum_value(SDLK_h));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_I", mrb_fixnum_value(SDLK_i));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_J", mrb_fixnum_value(SDLK_j));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_K", mrb_fixnum_value(SDLK_k));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_L", mrb_fixnum_value(SDLK_l));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_M", mrb_fixnum_value(SDLK_m));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_N", mrb_fixnum_value(SDLK_n));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_O", mrb_fixnum_value(SDLK_o));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_P", mrb_fixnum_value(SDLK_p));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_Q", mrb_fixnum_value(SDLK_q));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_R", mrb_fixnum_value(SDLK_r));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_S", mrb_fixnum_value(SDLK_s));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_T", mrb_fixnum_value(SDLK_t));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_U", mrb_fixnum_value(SDLK_u));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_V", mrb_fixnum_value(SDLK_v));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_W", mrb_fixnum_value(SDLK_w));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_X", mrb_fixnum_value(SDLK_x));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_Y", mrb_fixnum_value(SDLK_y));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_Z", mrb_fixnum_value(SDLK_z));

  mrb_gc_arena_restore(mrb, arena_size);
  arena_size = mrb_gc_arena_save(mrb);

  mrb_define_const(mrb, mod_Keyboard, "SDLK_F1", mrb_fixnum_value(SDLK_F1));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F2", mrb_fixnum_value(SDLK_F2));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F3", mrb_fixnum_value(SDLK_F3));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F4", mrb_fixnum_value(SDLK_F4));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F5", mrb_fixnum_value(SDLK_F5));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F6", mrb_fixnum_value(SDLK_F6));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F7", mrb_fixnum_value(SDLK_F7));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F8", mrb_fixnum_value(SDLK_F8));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F9", mrb_fixnum_value(SDLK_F9));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F10", mrb_fixnum_value(SDLK_F10));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F11", mrb_fixnum_value(SDLK_F11));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F12", mrb_fixnum_value(SDLK_F12));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F13", mrb_fixnum_value(SDLK_F13));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F14", mrb_fixnum_value(SDLK_F14));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F15", mrb_fixnum_value(SDLK_F15));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F16", mrb_fixnum_value(SDLK_F16));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F17", mrb_fixnum_value(SDLK_F17));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F18", mrb_fixnum_value(SDLK_F18));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F19", mrb_fixnum_value(SDLK_F19));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F20", mrb_fixnum_value(SDLK_F20));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F21", mrb_fixnum_value(SDLK_F21));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F22", mrb_fixnum_value(SDLK_F22));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F23", mrb_fixnum_value(SDLK_F23));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_F24", mrb_fixnum_value(SDLK_F24));

  mrb_gc_arena_restore(mrb, arena_size);
  arena_size = mrb_gc_arena_save(mrb);

  mrb_define_const(mrb, mod_Keyboard, "SDLK_BACKSPACE",   mrb_fixnum_value(SDLK_BACKSPACE));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_CAPSLOCK",    mrb_fixnum_value(SDLK_CAPSLOCK));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_DELETE",      mrb_fixnum_value(SDLK_DELETE));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_ESCAPE",      mrb_fixnum_value(SDLK_ESCAPE));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_END",         mrb_fixnum_value(SDLK_END));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_HOME",        mrb_fixnum_value(SDLK_HOME));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_INSERT",      mrb_fixnum_value(SDLK_INSERT));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_LALT",        mrb_fixnum_value(SDLK_LALT));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_LCTRL",       mrb_fixnum_value(SDLK_LCTRL));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_LEFT",        mrb_fixnum_value(SDLK_LEFT));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_LSHIFT",      mrb_fixnum_value(SDLK_LSHIFT));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_PAGEDOWN",    mrb_fixnum_value(SDLK_PAGEDOWN));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_PAGEUP",      mrb_fixnum_value(SDLK_PAGEUP));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_PRINTSCREEN", mrb_fixnum_value(SDLK_PRINTSCREEN));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_RALT",        mrb_fixnum_value(SDLK_RALT));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_RCTRL",       mrb_fixnum_value(SDLK_RCTRL));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_RETURN",      mrb_fixnum_value(SDLK_RETURN));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_RIGHT",       mrb_fixnum_value(SDLK_RIGHT));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_RSHIFT",      mrb_fixnum_value(SDLK_RSHIFT));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_AMPERSAND",   mrb_fixnum_value(SDLK_AMPERSAND));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_ASTERISK",    mrb_fixnum_value(SDLK_ASTERISK));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_AT",          mrb_fixnum_value(SDLK_AT));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_CARET",       mrb_fixnum_value(SDLK_CARET));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_COLON",       mrb_fixnum_value(SDLK_COLON));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_DOLLAR",      mrb_fixnum_value(SDLK_DOLLAR));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_EXCLAIM",     mrb_fixnum_value(SDLK_EXCLAIM));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_GREATER",     mrb_fixnum_value(SDLK_GREATER));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_HASH",        mrb_fixnum_value(SDLK_HASH));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_LEFTPAREN",   mrb_fixnum_value(SDLK_LEFTPAREN));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_LESS",        mrb_fixnum_value(SDLK_LESS));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_PERCENT",     mrb_fixnum_value(SDLK_PERCENT));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_PLUS",        mrb_fixnum_value(SDLK_PLUS));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_QUESTION",    mrb_fixnum_value(SDLK_QUESTION));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_QUOTEDBL",    mrb_fixnum_value(SDLK_QUOTEDBL));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_RIGHTPAREN",  mrb_fixnum_value(SDLK_RIGHTPAREN));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_UNDERSCORE",  mrb_fixnum_value(SDLK_UNDERSCORE));
  mrb_define_const(mrb, mod_Keyboard, "SDLK_UNKNOWN",     mrb_fixnum_value(SDLK_UNKNOWN));

  mrb_gc_arena_restore(mrb, arena_size);
  arena_size = mrb_gc_arena_save(mrb);

  /* SDL_Keymod */
  mrb_define_const(mrb, mod_Keyboard, "KMOD_NONE",   mrb_fixnum_value(KMOD_NONE));
  mrb_define_const(mrb, mod_Keyboard, "KMOD_LSHIFT", mrb_fixnum_value(KMOD_LSHIFT));
  mrb_define_const(mrb, mod_Keyboard, "KMOD_RSHIFT", mrb_fixnum_value(KMOD_RSHIFT));
  mrb_define_const(mrb, mod_Keyboard, "KMOD_LCTRL",  mrb_fixnum_value(KMOD_LCTRL));
  mrb_define_const(mrb, mod_Keyboard, "KMOD_RCTRL",  mrb_fixnum_value(KMOD_RCTRL));
  mrb_define_const(mrb, mod_Keyboard, "KMOD_LALT",   mrb_fixnum_value(KMOD_LALT));
  mrb_define_const(mrb, mod_Keyboard, "KMOD_RALT",   mrb_fixnum_value(KMOD_RALT));
  mrb_define_const(mrb, mod_Keyboard, "KMOD_LGUI",   mrb_fixnum_value(KMOD_LGUI));
  mrb_define_const(mrb, mod_Keyboard, "KMOD_RGUI",   mrb_fixnum_value(KMOD_RGUI));
  mrb_define_const(mrb, mod_Keyboard, "KMOD_NUM",    mrb_fixnum_value(KMOD_NUM));
  mrb_define_const(mrb, mod_Keyboard, "KMOD_CAPS",   mrb_fixnum_value(KMOD_CAPS));
  mrb_define_const(mrb, mod_Keyboard, "KMOD_MODE",   mrb_fixnum_value(KMOD_MODE));
  mrb_define_const(mrb, mod_Keyboard, "KMOD_CTRL",   mrb_fixnum_value(KMOD_CTRL));
  mrb_define_const(mrb, mod_Keyboard, "KMOD_SHIFT",  mrb_fixnum_value(KMOD_SHIFT));
  mrb_define_const(mrb, mod_Keyboard, "KMOD_ALT",    mrb_fixnum_value(KMOD_ALT));
  mrb_define_const(mrb, mod_Keyboard, "KMOD_GUI",    mrb_fixnum_value(KMOD_GUI));

  mrb_gc_arena_restore(mrb, arena_size);
}

Esempio n. 18

0

Mostra file

File: sSdCard.cpp Progetto: takjn/wrbb-v2lib-firm

//**************************************************
// ライブラリを定義します
//**************************************************
int sdcard_Init(mrb_state *mrb)
{
	//SDカードライブラリを初期化します
	if(SD_init(NULL) == 0){
		return 0;
	}

	//SDクラスが既に設定されているか
	if(SdClassFlag == true){
		return 1;
	}
	
	//日付と時刻を返す関数を登録
	SdFile::dateTimeCallback( &SD_DateTime );

	struct RClass *sdcardModule = mrb_define_module(mrb, SD_CLASS);

	mrb_define_module_function(mrb, sdcardModule, "exists", mrb_sdcard_exists, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, sdcardModule, "mkdir", mrb_sdcard_mkdir, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, sdcardModule, "remove", mrb_sdcard_remove, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, sdcardModule, "rename", mrb_sdcard_copy, MRB_ARGS_REQ(2));
	mrb_define_module_function(mrb, sdcardModule, "rmdir", mrb_sdcard_rmdir, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, sdcardModule, "open", mrb_sdcard_open, MRB_ARGS_REQ(2) | MRB_ARGS_OPT(1));

	mrb_define_module_function(mrb, sdcardModule, "close", mrb_sdcard_close, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, sdcardModule, "read", mrb_sdcard_read, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, sdcardModule, "seek", mrb_sdcard_seek, MRB_ARGS_REQ(2));
	mrb_define_module_function(mrb, sdcardModule, "write", mrb_sdcard_write, MRB_ARGS_REQ(3));
	mrb_define_module_function(mrb, sdcardModule, "flush", mrb_sdcard_flush, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, sdcardModule, "size", mrb_sdcard_size, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, sdcardModule, "position", mrb_sdcard_position, MRB_ARGS_REQ(1));

	mrb_define_module_function(mrb, sdcardModule, "cpmem", mrb_sdcard_cpmem, MRB_ARGS_REQ(2) | MRB_ARGS_OPT(1));

	//SDクラスのセットフラグをtrueにする
	SdClassFlag = true;

	return 1;
}

Esempio n. 19

0

Mostra file

File: hash.c Progetto: arton/mruby

void
mrb_init_hash(mrb_state *mrb)
{
  struct RClass *h;

  h = mrb->hash_class = mrb_define_class(mrb, "Hash", mrb->object_class);
  MRB_SET_INSTANCE_TT(h, MRB_TT_HASH);

  mrb_include_module(mrb, h, mrb_class_get(mrb, "Enumerable"));
  mrb_define_method(mrb, h, "==",              mrb_hash_equal,       MRB_ARGS_REQ(1)); /* 15.2.13.4.1  */
  mrb_define_method(mrb, h, "[]",              mrb_hash_aget,        MRB_ARGS_REQ(1)); /* 15.2.13.4.2  */
  mrb_define_method(mrb, h, "[]=",             mrb_hash_aset,        MRB_ARGS_REQ(2)); /* 15.2.13.4.3  */
  mrb_define_method(mrb, h, "clear",           mrb_hash_clear,       MRB_ARGS_NONE()); /* 15.2.13.4.4  */
  mrb_define_method(mrb, h, "default",         mrb_hash_default,     MRB_ARGS_ANY());  /* 15.2.13.4.5  */
  mrb_define_method(mrb, h, "default=",        mrb_hash_set_default, MRB_ARGS_REQ(1)); /* 15.2.13.4.6  */
  mrb_define_method(mrb, h, "default_proc",    mrb_hash_default_proc,MRB_ARGS_NONE()); /* 15.2.13.4.7  */
  mrb_define_method(mrb, h, "default_proc=",   mrb_hash_set_default_proc,MRB_ARGS_REQ(1)); /* 15.2.13.4.7  */
  mrb_define_method(mrb, h, "__delete",        mrb_hash_delete,      MRB_ARGS_REQ(1)); /* core of 15.2.13.4.8  */
  mrb_define_method(mrb, h, "empty?",          mrb_hash_empty_p,     MRB_ARGS_NONE()); /* 15.2.13.4.12 */
  mrb_define_method(mrb, h, "has_key?",        mrb_hash_has_key,     MRB_ARGS_REQ(1)); /* 15.2.13.4.13 */
  mrb_define_method(mrb, h, "has_value?",      mrb_hash_has_value,   MRB_ARGS_REQ(1)); /* 15.2.13.4.14 */
  mrb_define_method(mrb, h, "include?",        mrb_hash_has_key,     MRB_ARGS_REQ(1)); /* 15.2.13.4.15 */
  mrb_define_method(mrb, h, "__init_core",     mrb_hash_init_core,   MRB_ARGS_ANY());  /* core of 15.2.13.4.16 */
  mrb_define_method(mrb, h, "initialize_copy", mrb_hash_replace,     MRB_ARGS_REQ(1)); /* 15.2.13.4.17 */
  mrb_define_method(mrb, h, "key?",            mrb_hash_has_key,     MRB_ARGS_REQ(1)); /* 15.2.13.4.18 */
  mrb_define_method(mrb, h, "keys",            mrb_hash_keys,        MRB_ARGS_NONE()); /* 15.2.13.4.19 */
  mrb_define_method(mrb, h, "length",          mrb_hash_size_m,      MRB_ARGS_NONE()); /* 15.2.13.4.20 */
  mrb_define_method(mrb, h, "member?",         mrb_hash_has_key,     MRB_ARGS_REQ(1)); /* 15.2.13.4.21 */
  mrb_define_method(mrb, h, "replace",         mrb_hash_replace,     MRB_ARGS_REQ(1)); /* 15.2.13.4.23 */
  mrb_define_method(mrb, h, "shift",           mrb_hash_shift,       MRB_ARGS_NONE()); /* 15.2.13.4.24 */
  mrb_define_method(mrb, h, "size",            mrb_hash_size_m,      MRB_ARGS_NONE()); /* 15.2.13.4.25 */
  mrb_define_method(mrb, h, "store",           mrb_hash_aset,        MRB_ARGS_REQ(2)); /* 15.2.13.4.26 */
  mrb_define_method(mrb, h, "value?",          mrb_hash_has_value,   MRB_ARGS_REQ(1)); /* 15.2.13.4.27 */
  mrb_define_method(mrb, h, "values",          mrb_hash_values,      MRB_ARGS_NONE()); /* 15.2.13.4.28 */

  mrb_define_method(mrb, h, "to_hash",         mrb_hash_to_hash,     MRB_ARGS_NONE()); /* 15.2.13.4.29 (x)*/
  mrb_define_method(mrb, h, "inspect",         mrb_hash_inspect,     MRB_ARGS_NONE()); /* 15.2.13.4.30 (x)*/
  mrb_define_alias(mrb,  h, "to_s",            "inspect");                             /* 15.2.13.4.31 (x)*/
  mrb_define_method(mrb, h, "eql?",            mrb_hash_eql,         MRB_ARGS_REQ(1)); /* 15.2.13.4.32 (x)*/
}

Esempio n. 20

0

Mostra file

File: sdl2-mixer.c Progetto: Moon4u/mruby-sdl2-mixer

void
mrb_mruby_sdl2_mixer_gem_init(mrb_state *mrb)
{
  int arena_size;
	struct RClass *mod_Mixer = mrb_define_module_under(mrb, mod_SDL2, "Mixer");
  class_Chunk = mrb_define_class_under(mrb, mod_Mixer, "Chunk", mrb->object_class);
  class_Music = mrb_define_class_under(mrb, mod_Mixer, "Music", mrb->object_class);

  MRB_SET_INSTANCE_TT(class_Chunk, MRB_TT_DATA);
  MRB_SET_INSTANCE_TT(class_Music, MRB_TT_DATA);

  mrb_define_module_function(mrb, mod_Mixer, "init",                  mrb_sdl2_mixer_init,                MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "quit",                  mrb_sdl2_mixer_quit,                MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Mixer, "open",                  mrb_sdl2_mixer_open,                MRB_ARGS_REQ(4));
  mrb_define_module_function(mrb, mod_Mixer, "allocate_channels",      mrb_sdl2_mixer_allocate_channels,   MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "querySpec",             mrb_sdl2_mixer_query_spec,          MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Mixer, "get_num_chuck_decoder", mrb_sdl2_mixer_GetNumChunkDecoders, MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Mixer, "get_chunk_decoder",     mrb_sdl2_mixer_GetChunkDecoder,     MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "get_num_music_decoder", mrb_sdl2_mixer_GetNumMusicDecoders, MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Mixer, "get_music_decoder",     mrb_sdl2_mixer_GetMusicDecoder,     MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "set_panning",           mrb_sdl2_mixer_set_panning,         MRB_ARGS_REQ(3));
  mrb_define_module_function(mrb, mod_Mixer, "set_position",          mrb_sdl2_mixer_set_position,        MRB_ARGS_REQ(3));
  mrb_define_module_function(mrb, mod_Mixer, "set_distance",          mrb_sdl2_mixer_set_distance,        MRB_ARGS_REQ(2));
  mrb_define_module_function(mrb, mod_Mixer, "set_reverse_stereo",    mrb_sdl2_mixer_set_reverse_stereo,  MRB_ARGS_REQ(2));
  mrb_define_module_function(mrb, mod_Mixer, "reverse_channel",       mrb_sdl2_mixer_reverse_channel,     MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "group_channel",         mrb_sdl2_mixer_group_channel,       MRB_ARGS_REQ(2));
  mrb_define_module_function(mrb, mod_Mixer, "group_channels",        mrb_sdl2_mixer_group_channels,      MRB_ARGS_REQ(3));
  mrb_define_module_function(mrb, mod_Mixer, "group_count",           mrb_sdl2_mixer_group_count,         MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "group_oldest",          mrb_sdl2_mixer_group_oldest,        MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "group_newer",           mrb_sdl2_mixer_group_newer,         MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "volume",                mrb_sdl2_mixer_volume,              MRB_ARGS_REQ(2));
  mrb_define_module_function(mrb, mod_Mixer, "music_volume",          mrb_sdl2_mixer_music_volume,        MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "halt_channel",          mrb_sdl2_mixer_halt_channel,        MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "halt_group",            mrb_sdl2_mixer_halt_group,          MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "halt_music",            mrb_sdl2_mixer_halt_music,          MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Mixer, "expire_channel",        mrb_sdl2_mixer_expire_channel,      MRB_ARGS_REQ(2));
  mrb_define_module_function(mrb, mod_Mixer, "fade_out_channel",      mrb_sdl2_mixer_fade_out_channel,    MRB_ARGS_REQ(2));
  mrb_define_module_function(mrb, mod_Mixer, "fade_out_group",        mrb_sdl2_mixer_fade_out_group,      MRB_ARGS_REQ(2));
  mrb_define_module_function(mrb, mod_Mixer, "fade_out_music",        mrb_sdl2_mixer_fade_out_music,      MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "fading_music",          mrb_sdl2_mixer_fading_music,        MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Mixer, "fading_channel",        mrb_sdl2_mixer_fading_channel,      MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "pause_channel",         mrb_sdl2_mixer_pause_channel,       MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "resume_channel",        mrb_sdl2_mixer_resume_channel,      MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "paused_channel",        mrb_sdl2_mixer_paused_channel,      MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "pause_music",           mrb_sdl2_mixer_pause_music,         MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Mixer, "resume_music",          mrb_sdl2_mixer_resume_music,        MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Mixer, "rewind_music",          mrb_sdl2_mixer_rewind_music,        MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Mixer, "paused_music",          mrb_sdl2_mixer_paused_music,        MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Mixer, "set_music_position",    mrb_sdl2_mixer_set_music_position,  MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "channel_playing?",      mrb_sdl2_mixer_channel_playing,     MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "music_playing?",        mrb_sdl2_mixer_music_playing,       MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Mixer, "set_music_cmd",         mrb_sdl2_mixer_set_music_cmd,       MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "set_sync_value",        mrb_sdl2_mixer_set_sync_value,      MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "get_sync_value",        mrb_sdl2_mixer_get_sync_value,      MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Mixer, "set_sound_fonts",       mrb_sdl2_mixer_set_sound_fonts,     MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "get_sound_fonts",       mrb_sdl2_mixer_get_sound_fonts,     MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Mixer, "get_channel_chunk",     mrb_sdl2_mixer_get_channel_chunk,   MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Mixer, "close_audio",           mrb_sdl2_mixer_close_audio,         MRB_ARGS_NONE());

  mrb_define_method(mrb, class_Chunk, "initialize",    mrb_sdl2_mixer_chunk_initialize,    MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Chunk, "free",          mrb_sdl2_mixer_chunk_free,          MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Chunk, "destroy",       mrb_sdl2_mixer_chunk_free,          MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Chunk, "play",          mrb_sdl2_mixer_chunk_play,          MRB_ARGS_REQ(2) | MRB_ARGS_OPT(1));
  mrb_define_method(mrb, class_Chunk, "fade_in_timed", mrb_sdl2_mixer_music_fade_in_timed, MRB_ARGS_REQ(4));
  mrb_define_method(mrb, class_Chunk, "volume=",       mrb_sdl2_mixer_chunk_volume,        MRB_ARGS_REQ(1));

  mrb_define_method(mrb, class_Music, "initialize",  mrb_sdl2_mixer_music_initialize,  MRB_ARGS_REQ(1) | MRB_ARGS_REQ(2));
  mrb_define_method(mrb, class_Music, "free",        mrb_sdl2_mixer_music_free,        MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Music, "destroy",     mrb_sdl2_mixer_music_free,        MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Music, "type",        mrb_sdl2_mixer_music_get_type,    MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Music, "play",        mrb_sdl2_mixer_music_play,        MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Music, "fade_in",     mrb_sdl2_mixer_music_fade_in,     MRB_ARGS_REQ(2));
  mrb_define_method(mrb, class_Music, "fade_in_pos", mrb_sdl2_mixer_music_fade_in_pos, MRB_ARGS_REQ(2));


  arena_size = mrb_gc_arena_save(mrb);
  mrb_define_const(mrb, mod_Mixer, "MIX_CHANNELS",          mrb_fixnum_value(MIX_CHANNELS));
  mrb_define_const(mrb, mod_Mixer, "MIX_DEFAULT_FREQUENCY", mrb_fixnum_value(MIX_DEFAULT_FREQUENCY));
  mrb_define_const(mrb, mod_Mixer, "MIX_DEFAULT_FORMAT",    mrb_fixnum_value(MIX_DEFAULT_FORMAT));
  mrb_define_const(mrb, mod_Mixer, "MIX_DEFAULT_CHANNELS",  mrb_fixnum_value(MIX_DEFAULT_CHANNELS));
  mrb_define_const(mrb, mod_Mixer, "MIX_MAX_VOLUME",        mrb_fixnum_value(MIX_MAX_VOLUME));
  mrb_gc_arena_restore(mrb, arena_size);

  arena_size = mrb_gc_arena_save(mrb);
  mrb_define_const(mrb, mod_Mixer, "MIX_NO_FADING",  mrb_fixnum_value(MIX_NO_FADING));
  mrb_define_const(mrb, mod_Mixer, "MIX_FADING_OUT", mrb_fixnum_value(MIX_FADING_OUT));
  mrb_define_const(mrb, mod_Mixer, "MIX_FADING_IN",  mrb_fixnum_value(MIX_FADING_IN));
  mrb_gc_arena_restore(mrb, arena_size);

  arena_size = mrb_gc_arena_save(mrb);
  mrb_define_const(mrb, mod_Mixer, "MUS_NONE",     mrb_fixnum_value(MUS_NONE));
  mrb_define_const(mrb, mod_Mixer, "MUS_CMD",      mrb_fixnum_value(MUS_CMD));
  mrb_define_const(mrb, mod_Mixer, "MUS_WAV",      mrb_fixnum_value(MUS_WAV));
  mrb_define_const(mrb, mod_Mixer, "MUS_MOD",      mrb_fixnum_value(MUS_MOD));
  mrb_define_const(mrb, mod_Mixer, "MUS_MID",      mrb_fixnum_value(MUS_MID));
  mrb_define_const(mrb, mod_Mixer, "MUS_OGG",      mrb_fixnum_value(MUS_OGG));
  mrb_define_const(mrb, mod_Mixer, "MUS_MP3",      mrb_fixnum_value(MUS_MP3));
  mrb_define_const(mrb, mod_Mixer, "MUS_MP3_MAD",  mrb_fixnum_value(MUS_MP3_MAD));
  mrb_define_const(mrb, mod_Mixer, "MUS_FLAC",     mrb_fixnum_value(MUS_FLAC));
  mrb_define_const(mrb, mod_Mixer, "MUS_MODPLUG",  mrb_fixnum_value(MUS_MODPLUG));
  mrb_gc_arena_restore(mrb, arena_size);

  arena_size = mrb_gc_arena_save(mrb);
  mrb_define_const(mrb, mod_Mixer, "MIX_INIT_FLAC",       mrb_fixnum_value(MIX_INIT_FLAC));
  mrb_define_const(mrb, mod_Mixer, "MIX_INIT_MOD",        mrb_fixnum_value(MIX_INIT_MOD));
  mrb_define_const(mrb, mod_Mixer, "MIX_INIT_MODPLUG",    mrb_fixnum_value(MIX_INIT_MODPLUG));
  mrb_define_const(mrb, mod_Mixer, "MIX_INIT_MP3",        mrb_fixnum_value(MIX_INIT_MP3));
  mrb_define_const(mrb, mod_Mixer, "MIX_INIT_OGG",        mrb_fixnum_value(MIX_INIT_OGG));
  mrb_define_const(mrb, mod_Mixer, "MIX_INIT_FLUIDSYNTH", mrb_fixnum_value(MIX_INIT_FLUIDSYNTH));
  mrb_gc_arena_restore(mrb, arena_size);
}

Esempio n. 21

0

Mostra file

File: array.c Progetto: mirichi/mruby

void
mrb_init_array(mrb_state *mrb)
{
  struct RClass *a;

  a = mrb->array_class = mrb_define_class(mrb, "Array", mrb->object_class);            /* 15.2.12 */
  MRB_SET_INSTANCE_TT(a, MRB_TT_ARRAY);

  mrb_define_class_method(mrb, a, "[]",        mrb_ary_s_create,     MRB_ARGS_ANY());  /* 15.2.12.4.1 */

  mrb_define_method(mrb, a, "+",               mrb_ary_plus,         MRB_ARGS_REQ(1)); /* 15.2.12.5.1  */
  mrb_define_method(mrb, a, "*",               mrb_ary_times,        MRB_ARGS_REQ(1)); /* 15.2.12.5.2  */
  mrb_define_method(mrb, a, "<<",              mrb_ary_push_m,       MRB_ARGS_REQ(1)); /* 15.2.12.5.3  */
  mrb_define_method(mrb, a, "[]",              mrb_ary_aget,         MRB_ARGS_ANY());  /* 15.2.12.5.4  */
  mrb_define_method(mrb, a, "[]=",             mrb_ary_aset,         MRB_ARGS_ANY());  /* 15.2.12.5.5  */
  mrb_define_method(mrb, a, "clear",           mrb_ary_clear,        MRB_ARGS_NONE()); /* 15.2.12.5.6  */
  mrb_define_method(mrb, a, "concat",          mrb_ary_concat_m,     MRB_ARGS_REQ(1)); /* 15.2.12.5.8  */
  mrb_define_method(mrb, a, "delete_at",       mrb_ary_delete_at,    MRB_ARGS_REQ(1)); /* 15.2.12.5.9  */
  mrb_define_method(mrb, a, "empty?",          mrb_ary_empty_p,      MRB_ARGS_NONE()); /* 15.2.12.5.12 */
  mrb_define_method(mrb, a, "first",           mrb_ary_first,        MRB_ARGS_OPT(1)); /* 15.2.12.5.13 */
  mrb_define_method(mrb, a, "index",           mrb_ary_index_m,      MRB_ARGS_REQ(1)); /* 15.2.12.5.14 */
  mrb_define_method(mrb, a, "initialize_copy", mrb_ary_replace_m,    MRB_ARGS_REQ(1)); /* 15.2.12.5.16 */
  mrb_define_method(mrb, a, "join",            mrb_ary_join_m,       MRB_ARGS_ANY());  /* 15.2.12.5.17 */
  mrb_define_method(mrb, a, "last",            mrb_ary_last,         MRB_ARGS_ANY());  /* 15.2.12.5.18 */
  mrb_define_method(mrb, a, "length",          mrb_ary_size,         MRB_ARGS_NONE()); /* 15.2.12.5.19 */
  mrb_define_method(mrb, a, "pop",             mrb_ary_pop,          MRB_ARGS_NONE()); /* 15.2.12.5.21 */
  mrb_define_method(mrb, a, "push",            mrb_ary_push_m,       MRB_ARGS_ANY());  /* 15.2.12.5.22 */
  mrb_define_method(mrb, a, "replace",         mrb_ary_replace_m,    MRB_ARGS_REQ(1)); /* 15.2.12.5.23 */
  mrb_define_method(mrb, a, "reverse",         mrb_ary_reverse,      MRB_ARGS_NONE()); /* 15.2.12.5.24 */
  mrb_define_method(mrb, a, "reverse!",        mrb_ary_reverse_bang, MRB_ARGS_NONE()); /* 15.2.12.5.25 */
  mrb_define_method(mrb, a, "rindex",          mrb_ary_rindex_m,     MRB_ARGS_REQ(1)); /* 15.2.12.5.26 */
  mrb_define_method(mrb, a, "shift",           mrb_ary_shift,        MRB_ARGS_NONE()); /* 15.2.12.5.27 */
  mrb_define_method(mrb, a, "size",            mrb_ary_size,         MRB_ARGS_NONE()); /* 15.2.12.5.28 */
  mrb_define_method(mrb, a, "slice",           mrb_ary_aget,         MRB_ARGS_ANY());  /* 15.2.12.5.29 */
  mrb_define_method(mrb, a, "unshift",         mrb_ary_unshift_m,    MRB_ARGS_ANY());  /* 15.2.12.5.30 */

  mrb_define_method(mrb, a, "__ary_eq",        mrb_ary_eq,           MRB_ARGS_REQ(1));
  mrb_define_method(mrb, a, "__ary_cmp",       mrb_ary_cmp,           MRB_ARGS_REQ(1));
}

Esempio n. 22

0

Mostra file

File: murmurhash1.c Progetto: keizo042/mruby-murmurhash1

void
mrb_mruby_murmurhash1_gem_init(mrb_state *mrb)
{
  struct RClass *mMurmurhash1 = mrb_define_module(mrb, "MurmurHash1");
  mrb_define_class_method(mrb, mMurmurhash1, "digest", mrb_murmurhash1_digest, MRB_ARGS_REQ(1));
}

Esempio n. 23

0

Mostra file

File: polarssl.c Progetto: murasesyuka/mruby-polarssl

void mrb_mruby_polarssl_gem_init(mrb_state *mrb) {
  struct RClass *p, *e, *c, *s, *pkey, *ecdsa, *cipher, *des, *des3;

  p = mrb_define_module(mrb, "PolarSSL");
  pkey = mrb_define_module_under(mrb, p, "PKey");

  e = mrb_define_class_under(mrb, p, "Entropy", mrb->object_class);
  MRB_SET_INSTANCE_TT(e, MRB_TT_DATA);
  mrb_define_method(mrb, e, "initialize", mrb_entropy_initialize, MRB_ARGS_NONE());
  mrb_define_method(mrb, e, "gather", mrb_entropy_gather, MRB_ARGS_NONE());

  c = mrb_define_class_under(mrb, p, "CtrDrbg", mrb->object_class);
  MRB_SET_INSTANCE_TT(c, MRB_TT_DATA);
  mrb_define_method(mrb, c, "initialize", mrb_ctrdrbg_initialize, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(1));
  mrb_define_singleton_method(mrb, (struct RObject*)c, "self_test", mrb_ctrdrbg_self_test, MRB_ARGS_NONE());

  s = mrb_define_class_under(mrb, p, "SSL", mrb->object_class);
  MRB_SET_INSTANCE_TT(s, MRB_TT_DATA);
  mrb_define_method(mrb, s, "initialize", mrb_ssl_initialize, MRB_ARGS_NONE());
  // 0: Endpoint mode for acting as a client.
  mrb_define_const(mrb, s, "SSL_IS_CLIENT", mrb_fixnum_value(SSL_IS_CLIENT));
  // 0: Certificate verification mode for doing no verification.
  mrb_define_const(mrb, s, "SSL_VERIFY_NONE", mrb_fixnum_value(SSL_VERIFY_NONE));
  // 1: Certificate verification mode for optional verification.
  mrb_define_const(mrb, s, "SSL_VERIFY_OPTIONAL", mrb_fixnum_value(SSL_VERIFY_OPTIONAL));
  // 2: Certificate verification mode for having required verification.
  mrb_define_const(mrb, s, "SSL_VERIFY_REQUIRED", mrb_fixnum_value(SSL_VERIFY_REQUIRED));
  mrb_define_method(mrb, s, "set_endpoint", mrb_ssl_set_endpoint, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, s, "set_authmode", mrb_ssl_set_authmode, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, s, "set_rng", mrb_ssl_set_rng, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, s, "set_socket", mrb_ssl_set_socket, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, s, "handshake", mrb_ssl_handshake, MRB_ARGS_NONE());
  mrb_define_method(mrb, s, "write", mrb_ssl_write, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, s, "read", mrb_ssl_read, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, s, "bytes_available", mrb_ssl_bytes_available, MRB_ARGS_NONE());
  mrb_define_method(mrb, s, "fileno", mrb_ssl_fileno, MRB_ARGS_NONE());
  mrb_define_method(mrb, s, "close_notify", mrb_ssl_close_notify, MRB_ARGS_NONE());
  mrb_define_method(mrb, s, "close", mrb_ssl_close, MRB_ARGS_NONE());

  ecdsa = mrb_define_class_under(mrb, pkey, "EC", mrb->object_class);
  MRB_SET_INSTANCE_TT(ecdsa, MRB_TT_DATA);
  mrb_define_method(mrb, ecdsa, "alloc", mrb_ecdsa_alloc, MRB_ARGS_NONE());
  mrb_define_method(mrb, ecdsa, "generate_key", mrb_ecdsa_generate_key, MRB_ARGS_NONE());
  mrb_define_method(mrb, ecdsa, "load_pem", mrb_ecdsa_load_pem, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, ecdsa, "public_key", mrb_ecdsa_public_key, MRB_ARGS_NONE());
  mrb_define_method(mrb, ecdsa, "private_key", mrb_ecdsa_private_key, MRB_ARGS_NONE());
  mrb_define_method(mrb, ecdsa, "sign", mrb_ecdsa_sign, MRB_ARGS_REQ(1));

  cipher = mrb_define_class_under(mrb, p, "Cipher", mrb->object_class);

  des = mrb_define_class_under(mrb, cipher, "DES", cipher);
  mrb_define_class_method(mrb, des, "encrypt", mrb_des_encrypt, MRB_ARGS_REQ(4));
  mrb_define_class_method(mrb, des, "decrypt", mrb_des_decrypt, MRB_ARGS_REQ(4));

  des3 = mrb_define_class_under(mrb, cipher, "DES3", cipher);
  mrb_define_class_method(mrb, des3, "encrypt", mrb_des3_encrypt, MRB_ARGS_REQ(4));
  mrb_define_class_method(mrb, des3, "decrypt", mrb_des3_decrypt, MRB_ARGS_REQ(4));
}

Esempio n. 24

0

Mostra file

File: syslog.c Progetto: iij/mruby-syslog

void
mrb_mruby_syslog_gem_init(mrb_state *mrb)
{
  struct RClass *slog;

  slog = mrb_define_module(mrb, "Syslog");

  mrb_define_module_function(mrb, slog, "open",    mrb_f_syslog_open,   MRB_ARGS_ANY());
  mrb_define_module_function(mrb, slog, "_log0",   mrb_f_syslog_log0,   MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, slog, "close",   mrb_f_syslog_close,  MRB_ARGS_NONE());
  mrb_define_module_function(mrb, slog, "ident",   mrb_f_syslog_ident,  MRB_ARGS_NONE());
  reset_vars(mrb, mrb_obj_value(slog));

  /* Syslog options */
#define mrb_define_syslog_option(c) \
    mrb_define_const(mrb, slog, #c, mrb_fixnum_value(c))

#ifdef LOG_PID
  mrb_define_syslog_option(LOG_PID);
#endif
#ifdef LOG_CONS
  mrb_define_syslog_option(LOG_CONS);
#endif
#ifdef LOG_ODELAY
  mrb_define_syslog_option(LOG_ODELAY); /* deprecated */
#endif
#ifdef LOG_NDELAY
  mrb_define_syslog_option(LOG_NDELAY);
#endif
#ifdef LOG_NOWAIT
  mrb_define_syslog_option(LOG_NOWAIT); /* deprecated */
#endif
#ifdef LOG_PERROR
  mrb_define_syslog_option(LOG_PERROR);
#endif

  /* Syslog facilities */
#define mrb_define_syslog_facility(c) \
  mrb_define_const(mrb, slog, #c, mrb_fixnum_value(c))

#ifdef LOG_AUTH
  mrb_define_syslog_facility(LOG_AUTH);
#endif
#ifdef LOG_AUTHPRIV
  mrb_define_syslog_facility(LOG_AUTHPRIV);
#endif
#ifdef LOG_CONSOLE
  mrb_define_syslog_facility(LOG_CONSOLE);
#endif
#ifdef LOG_CRON
  mrb_define_syslog_facility(LOG_CRON);
#endif
#ifdef LOG_DAEMON
  mrb_define_syslog_facility(LOG_DAEMON);
#endif
#ifdef LOG_FTP
  mrb_define_syslog_facility(LOG_FTP);
#endif
#ifdef LOG_KERN
  mrb_define_syslog_facility(LOG_KERN);
#endif
#ifdef LOG_LPR
  mrb_define_syslog_facility(LOG_LPR);
#endif
#ifdef LOG_MAIL
  mrb_define_syslog_facility(LOG_MAIL);
#endif
#ifdef LOG_NEWS
  mrb_define_syslog_facility(LOG_NEWS);
#endif
#ifdef LOG_NTP
   mrb_define_syslog_facility(LOG_NTP);
#endif
#ifdef LOG_SECURITY
  mrb_define_syslog_facility(LOG_SECURITY);
#endif
#ifdef LOG_SYSLOG
  mrb_define_syslog_facility(LOG_SYSLOG);
#endif
#ifdef LOG_USER
  mrb_define_syslog_facility(LOG_USER);
#endif
#ifdef LOG_UUCP
  mrb_define_syslog_facility(LOG_UUCP);
#endif
#ifdef LOG_LOCAL0
  mrb_define_syslog_facility(LOG_LOCAL0);
#endif
#ifdef LOG_LOCAL1
  mrb_define_syslog_facility(LOG_LOCAL1);
#endif
#ifdef LOG_LOCAL2
  mrb_define_syslog_facility(LOG_LOCAL2);
#endif
#ifdef LOG_LOCAL3
  mrb_define_syslog_facility(LOG_LOCAL3);
#endif
#ifdef LOG_LOCAL4
  mrb_define_syslog_facility(LOG_LOCAL4);
#endif
#ifdef LOG_LOCAL5
  mrb_define_syslog_facility(LOG_LOCAL5);
#endif
#ifdef LOG_LOCAL6
  mrb_define_syslog_facility(LOG_LOCAL6);
#endif
#ifdef LOG_LOCAL7
  mrb_define_syslog_facility(LOG_LOCAL7);
#endif

  /* Syslog levels and the shortcut methods */
#define mrb_define_syslog_level(c, m) \
  mrb_define_const(mrb, slog, #c, mrb_fixnum_value(c));

#ifdef LOG_EMERG
  mrb_define_syslog_level(LOG_EMERG, emerg);
#endif
#ifdef LOG_ALERT
  mrb_define_syslog_level(LOG_ALERT, alert);
#endif
#ifdef LOG_CRIT
  mrb_define_syslog_level(LOG_CRIT, crit);
#endif
#ifdef LOG_ERR
  mrb_define_syslog_level(LOG_ERR, err);
#endif
#ifdef LOG_WARNING
  mrb_define_syslog_level(LOG_WARNING, warning);
#endif
#ifdef LOG_NOTICE
  mrb_define_syslog_level(LOG_NOTICE, notice);
#endif
#ifdef LOG_INFO
  mrb_define_syslog_level(LOG_INFO, info);
#endif
#ifdef LOG_DEBUG
  mrb_define_syslog_level(LOG_DEBUG, debug);
#endif
}

Esempio n. 25

0

Mostra file

File: cp_contact_point.c Progetto: afaur/mruby-chipmunk2d

void
mrb_cp_contact_point_init(mrb_state *mrb, struct RClass *cp_module)
{
  mrb_cp_contact_point_class = mrb_define_class_under(mrb, cp_module, "ContactPoint", mrb->object_class);
  mrb_cp_contact_point_set_class = mrb_define_class_under(mrb, cp_module, "ContactPointSet", mrb->object_class);
  /* */
  MRB_SET_INSTANCE_TT(mrb_cp_contact_point_class, MRB_TT_OBJECT);
  MRB_SET_INSTANCE_TT(mrb_cp_contact_point_set_class, MRB_TT_OBJECT);
  /* */
  mrb_define_method(mrb, mrb_cp_contact_point_class, "initialize", contact_point_initialize,   MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_contact_point_class, "point_a",    contact_point_get_point_a,  MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_contact_point_class, "point_a=",   contact_point_set_point_a,  MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_contact_point_class, "point_b",    contact_point_get_point_b,  MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_contact_point_class, "point_b=",   contact_point_set_point_b,  MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_contact_point_class, "distance",   contact_point_get_distance, MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_contact_point_class, "distance=",  contact_point_set_distance, MRB_ARGS_REQ(1));
  /* */
  mrb_define_method(mrb, mrb_cp_contact_point_set_class, "initialize", contact_point_set_initialize, MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_contact_point_set_class, "count",   contact_point_set_get_count,     MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_contact_point_set_class, "count=",  contact_point_set_set_count,     MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_contact_point_set_class, "normal",  contact_point_set_get_normal,    MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_contact_point_set_class, "normal=", contact_point_set_set_normal,    MRB_ARGS_REQ(1));
  mrb_define_method(mrb, mrb_cp_contact_point_set_class, "points",  contact_point_set_get_points,    MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb_cp_contact_point_set_class, "points=", contact_point_set_set_points,    MRB_ARGS_REQ(1));
}

Esempio n. 26

0

Mostra file

File: misc.c Progetto: asfluido/mruby-sdl2

void
mruby_sdl2_misc_init(mrb_state *mrb)
{
  class_Buffer      = mrb_define_class_under(mrb, mod_SDL2, "Buffer",      mrb->object_class);
  class_FloatBuffer = mrb_define_class_under(mrb, mod_SDL2, "FloatBuffer", class_Buffer);
  class_ByteBuffer  = mrb_define_class_under(mrb, mod_SDL2, "ByteBuffer",  class_Buffer);

  MRB_SET_INSTANCE_TT(class_Buffer,      MRB_TT_DATA);
  MRB_SET_INSTANCE_TT(class_FloatBuffer, MRB_TT_DATA);
  MRB_SET_INSTANCE_TT(class_ByteBuffer,  MRB_TT_DATA);

  mrb_define_method(mrb, class_Buffer, "initialize", mrb_sdl2_misc_buffer_initialize,  MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Buffer, "address",    mrb_sdl2_misc_buffer_get_address, MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Buffer, "size",       mrb_sdl2_misc_buffer_get_size,    MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Buffer, "cptr",       mrb_sdl2_misc_buffer_get_cptr,    MRB_ARGS_NONE());

  mrb_define_method(mrb, class_FloatBuffer, "initialize", mrb_sdl2_misc_floatbuffer_initialize, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_FloatBuffer, "size",       mrb_sdl2_misc_floatbuffer_get_size,   MRB_ARGS_NONE());
  mrb_define_method(mrb, class_FloatBuffer, "[]",         mrb_sdl2_misc_floatbuffer_get_at,     MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_FloatBuffer, "[]=",        mrb_sdl2_misc_floatbuffer_set_at,     MRB_ARGS_REQ(2));

  mrb_define_method(mrb, class_ByteBuffer, "initialize", mrb_sdl2_misc_bytebuffer_initialize, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_ByteBuffer, "[]",         mrb_sdl2_misc_bytebuffer_get_at,     MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_ByteBuffer, "[]=",        mrb_sdl2_misc_bytebuffer_set_at,     MRB_ARGS_REQ(2));
}

Esempio n. 27

0

Mostra file

File: kernel.c Progetto: FikiHafana/ArangoDB

void
mrb_init_kernel(mrb_state *mrb)
{
  struct RClass *krn;

  krn = mrb->kernel_module = mrb_define_module(mrb, "Kernel");
  mrb_define_class_method(mrb, krn, "block_given?",         mrb_f_block_given_p_m,           MRB_ARGS_NONE());    /* 15.3.1.2.2  */
  mrb_define_class_method(mrb, krn, "global_variables",     mrb_f_global_variables,          MRB_ARGS_NONE());    /* 15.3.1.2.4  */
  mrb_define_class_method(mrb, krn, "iterator?",            mrb_f_block_given_p_m,           MRB_ARGS_NONE());    /* 15.3.1.2.5  */
;     /* 15.3.1.2.11 */
  mrb_define_class_method(mrb, krn, "raise",                mrb_f_raise,                     MRB_ARGS_ANY());     /* 15.3.1.2.12 */

  mrb_define_method(mrb, krn, "singleton_class",            mrb_singleton_class,             MRB_ARGS_NONE());

  mrb_define_method(mrb, krn, "==",                         mrb_obj_equal_m,                 MRB_ARGS_REQ(1));    /* 15.3.1.3.1  */
  mrb_define_method(mrb, krn, "!=",                         mrb_obj_not_equal_m,             MRB_ARGS_REQ(1));
  mrb_define_method(mrb, krn, "===",                        mrb_equal_m,                     MRB_ARGS_REQ(1));    /* 15.3.1.3.2  */
  mrb_define_method(mrb, krn, "__id__",                     mrb_obj_id_m,                    MRB_ARGS_NONE());    /* 15.3.1.3.3  */
  mrb_define_method(mrb, krn, "__send__",                   mrb_f_send,                      MRB_ARGS_ANY());     /* 15.3.1.3.4  */
  mrb_define_method(mrb, krn, "block_given?",               mrb_f_block_given_p_m,           MRB_ARGS_NONE());    /* 15.3.1.3.6  */
  mrb_define_method(mrb, krn, "class",                      mrb_obj_class_m,                 MRB_ARGS_NONE());    /* 15.3.1.3.7  */
  mrb_define_method(mrb, krn, "clone",                      mrb_obj_clone,                   MRB_ARGS_NONE());    /* 15.3.1.3.8  */
  mrb_define_method(mrb, krn, "dup",                        mrb_obj_dup,                     MRB_ARGS_NONE());    /* 15.3.1.3.9  */
  mrb_define_method(mrb, krn, "eql?",                       mrb_obj_equal_m,                 MRB_ARGS_REQ(1));    /* 15.3.1.3.10 */
  mrb_define_method(mrb, krn, "equal?",                     mrb_obj_equal_m,                 MRB_ARGS_REQ(1));    /* 15.3.1.3.11 */
  mrb_define_method(mrb, krn, "extend",                     mrb_obj_extend_m,                MRB_ARGS_ANY());     /* 15.3.1.3.13 */
  mrb_define_method(mrb, krn, "global_variables",           mrb_f_global_variables,          MRB_ARGS_NONE());    /* 15.3.1.3.14 */
  mrb_define_method(mrb, krn, "hash",                       mrb_obj_hash,                    MRB_ARGS_NONE());    /* 15.3.1.3.15 */
  mrb_define_method(mrb, krn, "initialize_copy",            mrb_obj_init_copy,               MRB_ARGS_REQ(1));    /* 15.3.1.3.16 */
  mrb_define_method(mrb, krn, "inspect",                    mrb_obj_inspect,                 MRB_ARGS_NONE());    /* 15.3.1.3.17 */
  mrb_define_method(mrb, krn, "instance_eval",              mrb_obj_instance_eval,           MRB_ARGS_ANY());     /* 15.3.1.3.18 */
  mrb_define_method(mrb, krn, "instance_of?",               obj_is_instance_of,              MRB_ARGS_REQ(1));    /* 15.3.1.3.19 */
  mrb_define_method(mrb, krn, "instance_variable_defined?", mrb_obj_ivar_defined,            MRB_ARGS_REQ(1));    /* 15.3.1.3.20 */
  mrb_define_method(mrb, krn, "instance_variable_get",      mrb_obj_ivar_get,                MRB_ARGS_REQ(1));    /* 15.3.1.3.21 */
  mrb_define_method(mrb, krn, "instance_variable_set",      mrb_obj_ivar_set,                MRB_ARGS_REQ(2));    /* 15.3.1.3.22 */
  mrb_define_method(mrb, krn, "instance_variables",         mrb_obj_instance_variables,      MRB_ARGS_NONE());    /* 15.3.1.3.23 */
  mrb_define_method(mrb, krn, "is_a?",                      mrb_obj_is_kind_of_m,            MRB_ARGS_REQ(1));    /* 15.3.1.3.24 */
  mrb_define_method(mrb, krn, "iterator?",                  mrb_f_block_given_p_m,           MRB_ARGS_NONE());    /* 15.3.1.3.25 */
  mrb_define_method(mrb, krn, "kind_of?",                   mrb_obj_is_kind_of_m,            MRB_ARGS_REQ(1));    /* 15.3.1.3.26 */
  mrb_define_method(mrb, krn, "methods",                    mrb_obj_methods_m,               MRB_ARGS_OPT(1));    /* 15.3.1.3.31 */
  mrb_define_method(mrb, krn, "nil?",                       mrb_false,                       MRB_ARGS_NONE());    /* 15.3.1.3.32 */
  mrb_define_method(mrb, krn, "object_id",                  mrb_obj_id_m,                    MRB_ARGS_NONE());    /* 15.3.1.3.33 */
  mrb_define_method(mrb, krn, "private_methods",            mrb_obj_private_methods,         MRB_ARGS_OPT(1));    /* 15.3.1.3.36 */
  mrb_define_method(mrb, krn, "protected_methods",          mrb_obj_protected_methods,       MRB_ARGS_OPT(1));    /* 15.3.1.3.37 */
  mrb_define_method(mrb, krn, "public_methods",             mrb_obj_public_methods,          MRB_ARGS_OPT(1));    /* 15.3.1.3.38 */
  mrb_define_method(mrb, krn, "raise",                      mrb_f_raise,                     MRB_ARGS_ANY());     /* 15.3.1.3.40 */
  mrb_define_method(mrb, krn, "remove_instance_variable",   mrb_obj_remove_instance_variable,MRB_ARGS_REQ(1));    /* 15.3.1.3.41 */
  mrb_define_method(mrb, krn, "respond_to?",                obj_respond_to,                  MRB_ARGS_ANY());     /* 15.3.1.3.43 */
  mrb_define_method(mrb, krn, "send",                       mrb_f_send,                      MRB_ARGS_ANY());     /* 15.3.1.3.44 */
  mrb_define_method(mrb, krn, "singleton_methods",          mrb_obj_singleton_methods_m,     MRB_ARGS_OPT(1));    /* 15.3.1.3.45 */
  mrb_define_method(mrb, krn, "to_s",                       mrb_any_to_s,                    MRB_ARGS_NONE());    /* 15.3.1.3.46 */

  mrb_include_module(mrb, mrb->object_class, mrb->kernel_module);
  mrb_alias_method(mrb, mrb->module_class, mrb_intern2(mrb, "dup", 3), mrb_intern2(mrb, "clone", 5));
}

Esempio n. 28

0

Mostra file

File: eval.c Progetto: Alanchi/mruby

void
mrb_mruby_eval_gem_init(mrb_state* mrb)
{
  mrb_define_class_method(mrb, mrb->kernel_module, "eval", f_eval, MRB_ARGS_REQ(1));
}

Esempio n. 29

0

Mostra file

File: mrb_expr.c Progetto: tamano/groonga

void
grn_mrb_expr_init(grn_ctx *ctx)
{
  mrb_state *mrb = ctx->impl->mrb.state;
  struct RClass *module = ctx->impl->mrb.module;
  struct RClass *object_class = ctx->impl->mrb.object_class;
  struct RClass *klass;

  klass = mrb_define_class_under(mrb, module, "ScanInfo", mrb->object_class);
  MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA);
  mrb_define_method(mrb, klass, "initialize",
                    mrb_grn_scan_info_initialize, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "put_index",
                    mrb_grn_scan_info_put_index, MRB_ARGS_REQ(3));
  mrb_define_method(mrb, klass, "op",
                    mrb_grn_scan_info_get_op, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "op=",
                    mrb_grn_scan_info_set_op, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "end=",
                    mrb_grn_scan_info_set_end, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "query=",
                    mrb_grn_scan_info_set_query, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "flags",
                    mrb_grn_scan_info_get_flags, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "flags=",
                    mrb_grn_scan_info_set_flags, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "logical_op",
                    mrb_grn_scan_info_get_logical_op, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "logical_op=",
                    mrb_grn_scan_info_set_logical_op, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "max_interval",
                    mrb_grn_scan_info_get_max_interval, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "max_interval=",
                    mrb_grn_scan_info_set_max_interval, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "similarity_threshold",
                    mrb_grn_scan_info_get_similarity_threshold, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "similarity_threshold=",
                    mrb_grn_scan_info_set_similarity_threshold, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "get_arg",
                    mrb_grn_scan_info_get_arg, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "push_arg",
                    mrb_grn_scan_info_push_arg, MRB_ARGS_REQ(1));

  klass = mrb_define_class_under(mrb, module,
                                 "ExpressionCode", mrb->object_class);
  MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA);
  mrb_define_method(mrb, klass, "initialize",
                    mrb_grn_expr_code_initialize, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "weight",
                    mrb_grn_expr_code_get_weight, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "value",
                    mrb_grn_expr_code_get_value, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "op",
                    mrb_grn_expr_code_get_op, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "flags",
                    mrb_grn_expr_code_get_flags, MRB_ARGS_NONE());

  klass = mrb_define_class_under(mrb, module, "Expression", object_class);
  MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA);
  mrb_define_method(mrb, klass, "initialize",
                    mrb_grn_expression_initialize, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "codes",
                    mrb_grn_expression_codes, MRB_ARGS_NONE());
  mrb_define_method(mrb, klass, "get_var_by_offset",
                    mrb_grn_expression_get_var_by_offset, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "take_object",
                    mrb_grn_expression_take_object, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, klass, "allocate_constant",
                    mrb_grn_expression_allocate_constant, MRB_ARGS_REQ(1));

  grn_mrb_load(ctx, "expression.rb");
  grn_mrb_load(ctx, "scan_info.rb");
  grn_mrb_load(ctx, "scan_info_data.rb");
  grn_mrb_load(ctx, "scan_info_builder.rb");
}

Esempio n. 30

0

Mostra file

File: BindImage.cpp Progetto: ongaeshi/rubykokuban-osx

//----------------------------------------------------------
void BindImage::Bind(mrb_state* mrb)
{
    struct RClass *cc = mrb_define_class(mrb, "Image", mrb->object_class);
    
    mrb_define_class_method(mrb , cc, "load",               load,               MRB_ARGS_REQ(1));
    mrb_define_class_method(mrb , cc, "grab_screen",        grab_screen,        MRB_ARGS_OPT(4));
                                                             
    mrb_define_method(mrb, cc,        "clone",              clone,              MRB_ARGS_NONE());
    mrb_define_method(mrb, cc,        "save",               save,               MRB_ARGS_ARG(2, 1));
    mrb_define_method(mrb, cc,        "color",              color,              MRB_ARGS_REQ(2));
    mrb_define_method(mrb, cc,        "set_color",          set_color,          MRB_ARGS_REQ(3));
    mrb_define_method(mrb, cc,        "resize",             resize,             MRB_ARGS_REQ(2));
    mrb_define_method(mrb, cc,        "set_image_type",     set_image_type,     MRB_ARGS_REQ(1));
    mrb_define_method(mrb, cc,        "crop",               crop,               MRB_ARGS_REQ(4));
    mrb_define_method(mrb, cc,        "crop!",              crop_bang,          MRB_ARGS_REQ(4));
    mrb_define_method(mrb, cc,        "rotate90",           rotate90,           MRB_ARGS_OPT(1));
    mrb_define_method(mrb, cc,        "mirror",             mirror,             MRB_ARGS_REQ(2));
    mrb_define_method(mrb, cc,        "update",             update,             MRB_ARGS_NONE());
    mrb_define_method(mrb, cc,        "set_anchor_percent", set_anchor_percent, MRB_ARGS_REQ(2));
    mrb_define_method(mrb, cc,        "set_anchor_point",   set_anchor_point,   MRB_ARGS_REQ(2));
    mrb_define_method(mrb, cc,        "reset_anchor",       reset_anchor,       MRB_ARGS_REQ(2));
    mrb_define_method(mrb, cc,        "draw",               draw,               MRB_ARGS_ARG(2, 2));
    mrb_define_method(mrb, cc,        "draw_sub",           draw_sub,           MRB_ARGS_ARG(6, 2));
    mrb_define_method(mrb, cc,        "height",             height,             MRB_ARGS_NONE());
    mrb_define_method(mrb, cc,        "width",              width,              MRB_ARGS_NONE());
    mrb_define_method(mrb, cc,        "each_pixels",        each_pixels,        MRB_ARGS_OPT(2));
    mrb_define_method(mrb, cc,        "map_pixels",         map_pixels,         MRB_ARGS_OPT(2));
}