mrb_value mrb_discount_header(mrb_state *mrb, mrb_value self) { mrb_md_context *md_ctx = mrb_md_get_context(mrb, self, "mrb_md_context"); char *header; size_t len; len = HEADER_SIZE + strlen(md_ctx->title) + strlen(md_ctx->css); header = (char *)mrb_malloc(mrb, len); snprintf(header, len, //"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" //"<!DOCTYPE html PUBLIC \n" //" \"-//W3C//DTD XHTML 1.0 Strict//EN\"\n" //" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n" "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n" "<head>\n" "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\" />\n" "<meta http-equiv=\"Content-Style-Type\" content=\"text/css\" />\n" "<title>%s</title>\n" "<link rel=\"stylesheet\" href=\"%s\" type=\"text/css\" />\n" "</head>\n" "<body>\n" , md_ctx->title , md_ctx->css ); return mrb_str_new(mrb, header, (mrb_int)strlen(header)); }
int main() { mrb_state* mrb = mrb_open(); // mrubyファイルをロードする FILE *fd = fopen("person.mrb", "r"); mrb_load_irep_file(mrb, fd); // *.rbを直接ロードする // FILE *fd = fopen("person.rb", "r"); // mrb_load_file(mrb, fd); // クラスオブジェクトを取得する struct RClass *person = mrb_class_get(mrb, "Person"); // 引数をmrb_valueに変換する mrb_value person_value = mrb_obj_value(person); mrb_value name_value = mrb_str_new(mrb, "naoty", 5); mrb_value age_value = mrb_fixnum_value(25); // Person#newを呼び出す mrb_value naoty = mrb_funcall(mrb, person_value, "new", 2, name_value, age_value); // Person#greetingを呼び出す mrb_value greeting_value = mrb_funcall(mrb, naoty, "greeting", 0); // 返り値をchar*に変換して出力する char *greeting = mrb_string_value_ptr(mrb, greeting_value); printf("%s\n", greeting); mrb_close(mrb); return 0; }
mrb_value mrb_discount_md2html(mrb_state *mrb, mrb_value self) { mrb_md_context *md_ctx = mrb_md_get_context(mrb, self, "mrb_md_context"); MMIOT *md; mrb_value md_obj; int size; char *html, *title; mrb_value header, footer, data; mrb_get_args(mrb, "o", &md_obj); md = mkd_string(RSTRING_PTR(md_obj), strlen(RSTRING_PTR(md_obj)), 0); mkd_compile(md, MKD_TOC|MKD_AUTOLINK); title = mkd_doc_title(md); if (title) { md_ctx->title = title; } if ((size = mkd_document(md, &html)) == EOF) { mrb_raise(mrb, E_RUNTIME_ERROR, "mkd_document() failed"); } header = mrb_discount_header(mrb, self); footer = mrb_discount_footer(mrb, self); data = mrb_str_plus(mrb, header, mrb_str_new(mrb, html, strlen(html))); data = mrb_str_plus(mrb, data, footer); mkd_cleanup(md); return data; }
mrb_value regexp_pcre_initialize(mrb_state *mrb, mrb_value self) { int erroff = 0, coptions; const char *errstr = NULL; struct mrb_regexp_pcre *reg = NULL; mrb_value source, opt = mrb_nil_value(); reg = (struct mrb_regexp_pcre *)DATA_PTR(self); if (reg) { mrb_regexp_free(mrb, reg); } DATA_TYPE(self) = &mrb_regexp_type; DATA_PTR(self) = NULL; mrb_get_args(mrb, "S|o", &source, &opt); reg = mrb_malloc(mrb, sizeof(struct mrb_regexp_pcre)); reg->re = NULL; DATA_PTR(self) = reg; coptions = mrb_mruby_to_pcre_options(opt); source = mrb_str_new(mrb, RSTRING_PTR(source), RSTRING_LEN(source)); reg->re = pcre_compile(RSTRING_PTR(source), coptions, &errstr, &erroff, NULL); if (reg->re == NULL) { mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid regular expression"); } mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "@source"), source); mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "@options"), mrb_fixnum_value(mrb_pcre_to_mruby_options(coptions))); unsigned char *name_table; int i, namecount, name_entry_size; pcre_fullinfo(reg->re, NULL, PCRE_INFO_NAMECOUNT, &namecount); if (namecount > 0) { pcre_fullinfo(reg->re, NULL, PCRE_INFO_NAMETABLE, &name_table); pcre_fullinfo(reg->re, NULL, PCRE_INFO_NAMEENTRYSIZE, &name_entry_size); unsigned char *tabptr = name_table; for (i = 0; i < namecount; i++) { int n = (tabptr[0] << 8) | tabptr[1]; mrb_funcall(mrb, self, "name_push", 2, mrb_str_new(mrb, (const char *)(tabptr + 2), strlen((const char *)tabptr + 2)), mrb_fixnum_value(n)); tabptr += name_entry_size; } } return self; }
static mrb_value mrb_uefi_pointer_value(mrb_state *mrb, mrb_value self) { mrb_value value = mrb_str_new(mrb, NULL, sizeof(VOID *)); VOID *ptr = mrb_uefi_pointer_raw_value(mrb, self); memcpy(RSTRING_PTR(value), &ptr, sizeof(ptr)); return value; }
mrb_value ap_mrb_get_env_hash(mrb_state *mrb, mrb_value str) { int i; mrb_value hash = mrb_hash_new(mrb); request_rec *r = ap_mrb_get_request(); apr_table_t *e = r->subprocess_env; const apr_array_header_t *arr = apr_table_elts(e); apr_table_entry_t *elts = (apr_table_entry_t *)arr->elts; for (i = 0; i < arr->nelts; i++) { mrb_hash_set(mrb , hash , mrb_str_new(mrb, elts[i].key, strlen(elts[i].key)) , mrb_str_new(mrb, elts[i].val, strlen(elts[i].val)) ); } return hash; }
static mrb_value sha256_digest(mrb_state *mrb, mrb_value self) { char *digest = (char*)mrb_malloc(mrb, SHA256_DIGEST_LENGTH); SHA256_CTX ctx = *(SHA256_CTX*)DATA_PTR(self); SHA256_Final((u_int8_t *)digest, &ctx); return mrb_str_new(mrb, digest, SHA256_DIGEST_LENGTH); }
static mrb_value ngx_stream_mrb_proxy_protocol_addr(mrb_state *mrb, mrb_value self) { ngx_stream_mruby_internal_ctx_t *ictx = mrb->ud; ngx_stream_session_t *s = ictx->s; return mrb_str_new(mrb, (const char *)s->connection->proxy_protocol_addr.data, s->connection->proxy_protocol_addr.len); }
static mrb_value ngx_stream_mrb_upstream_get_server(mrb_state *mrb, mrb_value self) { ngx_stream_mruby_upstream_context *ctx = DATA_PTR(self); if (ctx->target == NULL) { return mrb_nil_value(); } return mrb_str_new(mrb, (char *)ctx->target->name.data, ctx->target->name.len); }
int main(int argc, char** argv) { const char rite[] = "app.mrb"; mrb_state* mrb = mrb_open(); FILE* fp = fopen(rite, "r"); if (fp == NULL) { fprintf(stderr, "%s not found.\n", rite); fprintf(stderr, "`mruby/bin/mrbc app.rb` to create app.mrb file.\n"); exit(EXIT_FAILURE); } int n = mrb_read_irep_file(mrb, fp); fclose(fp); if (n < 0) { fprintf(stderr, "%s - irep load error.\n", rite); exit(EXIT_FAILURE); } mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb)); if (argc < 2) { printf("Usage %s <environment>\n", argv[0]); return 0; } // AppSetting struct RClass* clz = mrb_class_get(mrb, "AppSetting"); mrb_value setting = mrb_obj_value(clz); // AppSetting.load(*targets) -> AppConfig mrb_value target = mrb_str_new(mrb, argv[1], strlen(argv[1])); mrb_value conf = mrb_funcall(mrb, setting, "load", 1, target); // AppConfig.#debug -> bool mrb_value debug = mrb_funcall(mrb, conf, "debug", 0); printf("debug: %d\n", mrb_type(debug) == MRB_TT_TRUE); // AppConfig.#timeout -> Integer mrb_value timeout = mrb_funcall(mrb, conf, "timeout", 0); printf("timeout: %d\n", timeout.value.i); // AppConfig.#title -> String mrb_value title = mrb_funcall(mrb, conf, "title", 0); printf("title: %s\n", mrb_string_value_ptr(mrb, title)); // AppConfig.#messages -> Array mrb_value messages = mrb_funcall(mrb, conf, "messages", 0); { // Array.#size -> Integer mrb_value len = mrb_funcall(mrb, messages, "size", 0); int i; for (i = 0; i < len.value.i; i++) { // Array.#at(nth) -> object mrb_value message = mrb_funcall(mrb, messages, "at", 1, mrb_fixnum_value(i)); printf("%s\n", mrb_string_value_ptr(mrb, message)); } } mrb_close(mrb); return 0; }
static khint_t mrb_hash_ht_hash_func(mrb_state *mrb, mrb_value key) { char type = mrb_type(key); mrb_value s1 = mrb_str_new(mrb, &type, 1); mrb_value s2 = mrb_inspect(mrb, key); s1 = mrb_str_cat(mrb, s1, RSTRING_PTR(s2), RSTRING_LEN(s2)); return kh_str_hash_func(mrb, RSTRING_PTR(s1)); }
static mrb_value mrb_hash_inspect(mrb_state *mrb, mrb_value hash) { khash_t(ht) *h = RHASH_TBL(hash); if (!h || kh_size(h) == 0) return mrb_str_new(mrb, "{}", 2); return inspect_hash(mrb, hash, 0); }
void mrb_show_copyright(mrb_state *mrb) { static const char copyright_msg[] = "mruby - Copyright (c) 2010-2013 mruby developers\n"; mrb_value msg; msg = mrb_str_new(mrb, copyright_msg, sizeof(copyright_msg) - 1); printstr(mrb, msg); }
static mrb_value lib_md_digest_bang(mrb_state *mrb, struct mrb_md *md) { unsigned char mdstr[MAX_DIGEST_LENGTH]; md_final(md->type, mdstr, md->ctx); md_init(md->type, md->ctx); return mrb_str_new(mrb, (char *)mdstr, md_digest_length(md->type)); }
mrb_value mrb_Git_Buf_to_s(mrb_state * mrb, mrb_value self) { git_buf * native_self = mruby_unbox_git_buf(self); if (native_self->ptr == NULL) { return mrb_nil_value(); } else { return mrb_str_new(mrb, native_self->ptr, native_self->size); } }
void mrb_show_version(mrb_state *mrb) { static const char version_msg[] = "mruby - Embeddable Ruby Copyright (c) 2010-2013 mruby developers\n"; mrb_value msg; msg = mrb_str_new(mrb, version_msg, sizeof(version_msg) - 1); printstr(mrb, msg); }
static int parser_settings_on_header_field(http_parser* parser, const char* at, size_t len) { mrb_http_parser_context *context = (mrb_http_parser_context*) parser->data; mrb_state* mrb = context->mrb; if (context->was_header_value) { if (!mrb_nil_p(CTXV_GET(context, "last_header_field"))) { mrb_str_concat(mrb, CTXV_GET(context, "last_header_field"), CTXV_GET(context, "last_header_value")); CTXV_SET(context, "last_header_value", mrb_nil_value()); } CTXV_SET(context, "last_header_field", mrb_str_new(mrb, at, len)); context->was_header_value = FALSE; } else { mrb_str_concat(mrb, CTXV_GET(context, "last_header_field"), mrb_str_new(mrb, at, len)); } return 0; }
static mrb_value lib_md_digest(mrb_state *mrb, const struct mrb_md *md) { union ctx_union ctx; unsigned char mdstr[MAX_DIGEST_LENGTH]; memcpy(&ctx, md->ctx, md_ctx_size(md->type)); md_final(md->type, mdstr, &ctx); return mrb_str_new(mrb, (char *)mdstr, md_digest_length(md->type)); }
static mrb_value lib_hmac_digest(mrb_state *mrb, const struct mrb_hmac *hmac) { CCHmacContext ctx; unsigned char str[MAX_DIGEST_LENGTH]; memcpy(&ctx, &hmac->ctx, sizeof(ctx)); CCHmacFinal(&ctx, str); return mrb_str_new(mrb, (const char *)str, md_digest_length(hmac->type)); }
static int parser_settings_on_header_value(http_parser* parser, const char* at, size_t len) { mrb_http_parser_context *context = (mrb_http_parser_context*) parser->data; mrb_state* mrb = context->mrb; int ai = mrb_gc_arena_save(mrb); if(!context->was_header_value) { OBJECT_SET(mrb, context->instance, "last_header_value", mrb_str_new(mrb, at, len)); context->was_header_value = TRUE; mrb_hash_set(mrb, OBJECT_GET(mrb, context->instance, "headers"), OBJECT_GET(mrb, context->instance, "last_header_field"), OBJECT_GET(mrb, context->instance, "last_header_value")); } else { mrb_str_concat(mrb, OBJECT_GET(mrb, context->instance, "last_header_value"), mrb_str_new(mrb, at, len)); } mrb_gc_arena_restore(mrb, ai); return 0; }
static mrb_value h2o_mrb_req_query(mrb_state *mrb, mrb_value self) { h2o_mruby_internal_context_t *mruby_ctx = (h2o_mruby_internal_context_t *)mrb->ud; h2o_iovec_t *path = &mruby_ctx->req->path; size_t offset = mruby_ctx->req->query_at; if (offset == SIZE_MAX) return mrb_nil_value(); return mrb_str_new(mrb, path->base + offset, path->len - offset); }
int main(void) { mrb_state *mrb = mrb_open(); struct RClass* cv = mrb_class_get(mrb, "String"); mrb_value str = mrb_obj_new(mrb, cv, 0, 0); mrb_value head = mrb_str_new(mrb,"p 'hello",8); mrb_value tail = mrb_str_new(mrb," world'",7); str = mrb_funcall_argv(mrb, str, mrb_intern2(mrb, "+", 1), 1, &head); str = mrb_funcall_argv(mrb, str, mrb_intern2(mrb, "+", 1), 1, &tail); printf("str#size is %d \n", mrb_funcall(mrb, str, "size", 0, 0)); printf("str is '%s' \n", RSTRING_PTR(str)); mrb_load_string(mrb, RSTRING_PTR(str)); return 0; }
static mrb_value lib_md_digest_bang(mrb_state *mrb, struct mrb_md *md) { unsigned int mdlen; unsigned char mdstr[EVP_MAX_MD_SIZE]; EVP_DigestFinal_ex(md->ctx, mdstr, &mdlen); EVP_DigestInit_ex(md->ctx, EVP_MD_CTX_md(md->ctx), NULL); return mrb_str_new(mrb, (char *)mdstr, mdlen); }
mrb_value ap_mrb_str_to_value(mrb_state *mrb, apr_pool_t *p, const char *str) { const char *val; if (str == NULL) { return mrb_nil_value(); } val = apr_pstrdup(p, str); return mrb_str_new(mrb, val, strlen(val)); }
static mrb_value mrb_uefi_handle_value(mrb_state *mrb, mrb_value self) { struct MRB_UEFI_HANDLE_DATA *hd; mrb_value value = mrb_str_new(mrb, NULL, sizeof(EFI_HANDLE)); hd = (struct MRB_UEFI_HANDLE_DATA *)mrb_get_datatype(mrb, self, &mrb_uefi_handle_type); memcpy(RSTRING_PTR(value), &hd->handle, sizeof(hd->handle)); return value; }
/* * call-seq: * sym.id2name -> string * sym.to_s -> string * * Returns the name or string corresponding to <i>sym</i>. * * :fred.id2name #=> "fred" */ mrb_value mrb_sym_to_s(mrb_state *mrb, mrb_value sym) { mrb_sym id = mrb_symbol(sym); const char *p; size_t len; p = mrb_sym2name_len(mrb, id, &len); return mrb_str_new(mrb, p, len); }
static mrb_value mrb_ary_inspect(mrb_state *mrb, mrb_value ary) { if (RARRAY_LEN(ary) == 0) return mrb_str_new(mrb, "[]", 2); #if 0 /* THREAD */ return mrb_exec_recursive(inspect_ary_r, ary, 0); #else return inspect_ary(mrb, ary, mrb_ary_new(mrb)); #endif }
static mrb_value ap_mrb_get_request_headers_out(mrb_state *mrb, mrb_value str) { mrb_value key; const char *val; request_rec *r = ap_mrb_get_request(); mrb_get_args(mrb, "o", &key); val = apr_table_get(r->headers_out, mrb_str_to_cstr(mrb, key)); return mrb_str_new(mrb, val, strlen(val)); }
static mrb_value mrb_mod_to_s(mrb_state *mrb, mrb_value klass) { mrb_value str; if (mrb_type(klass) == MRB_TT_SCLASS) { mrb_value v = mrb_iv_get(mrb, klass, mrb_intern2(mrb, "__attached__", 12)); str = mrb_str_new(mrb, "#<Class:", 8); switch (mrb_type(v)) { case MRB_TT_CLASS: case MRB_TT_MODULE: case MRB_TT_SCLASS: mrb_str_append(mrb, str, mrb_inspect(mrb, v)); break; default: mrb_str_append(mrb, str, mrb_any_to_s(mrb, v)); break; } mrb_str_cat(mrb, str, ">", 1); } else { struct RClass *c; mrb_value path; str = mrb_str_buf_new(mrb, 32); c = mrb_class_ptr(klass); path = mrb_class_path(mrb, c); if (mrb_nil_p(path)) { switch (mrb_type(klass)) { case MRB_TT_CLASS: mrb_str_cat(mrb, str, "#<Class:", 8); break; case MRB_TT_MODULE: mrb_str_cat(mrb, str, "#<Module:", 9); break; default: /* Shouldn't be happened? */ mrb_str_cat(mrb, str, "#<??????:", 9); break; } mrb_str_concat(mrb, str, mrb_ptr_to_str(mrb, c)); mrb_str_cat(mrb, str, ">", 1); } else { str = path; } } return str; }
/* * call-seq: * obj.inspect -> string * * Returns a string containing a human-readable representation of * <i>obj</i>. If not overridden and no instance variables, uses the * <code>to_s</code> method to generate the string. * <i>obj</i>. If not overridden, uses the <code>to_s</code> method to * generate the string. * * [ 1, 2, 3..4, 'five' ].inspect #=> "[1, 2, 3..4, \"five\"]" * Time.new.inspect #=> "2008-03-08 19:43:39 +0900" */ mrb_value mrb_obj_inspect(mrb_state *mrb, mrb_value obj) { if ((mrb_type(obj) == MRB_TT_OBJECT) && mrb_obj_basic_to_s_p(mrb, obj)) { return mrb_obj_iv_inspect(mrb, mrb_obj_ptr(obj)); } else if (mrb_nil_p(obj)) { return mrb_str_new(mrb, "nil", 3); } return mrb_funcall(mrb, obj, "to_s", 0, 0); }