mirror of
https://github.com/mruby/mruby
synced 2026-06-08 16:11:16 +00:00
add mruby sources
This commit is contained in:
mimaki
@@ -0,0 +1,42 @@
|
||||
#ifndef MRUBY_ARRAY_H
|
||||
#define MRUBY_ARRAY_H
|
||||
|
||||
struct RArray {
|
||||
MRUBY_OBJECT_HEADER;
|
||||
size_t len;
|
||||
size_t capa;
|
||||
mrb_value *buf;
|
||||
};
|
||||
|
||||
#define mrb_ary_ptr(v) ((struct RArray*)((v).value.p))
|
||||
#define mrb_ary_value(p) mrb_obj_value((void*)(p))
|
||||
#define RARRAY(v) ((struct RArray*)((v).value.p))
|
||||
|
||||
#define RARRAY_LEN(a) (RARRAY(a)->len)
|
||||
#define RARRAY_PTR(a) (RARRAY(a)->buf)
|
||||
|
||||
mrb_value mrb_ary_new_capa(mrb_state*, size_t);
|
||||
mrb_value mrb_ary_new(mrb_state *mrb);
|
||||
mrb_value mrb_ary_new_elts(mrb_state *mrb, long n, const mrb_value *elts);
|
||||
void mrb_ary_concat(mrb_state*, mrb_value, mrb_value);
|
||||
mrb_value mrb_ary_splat(mrb_state*, mrb_value);
|
||||
void mrb_ary_push(mrb_state*, mrb_value, mrb_value);
|
||||
mrb_value mrb_ary_pop(mrb_state *mrb, mrb_value ary);
|
||||
mrb_value mrb_ary_new_from_values(mrb_state *mrb, mrb_value *vals, size_t size);
|
||||
mrb_value mrb_ary_aget(mrb_state *mrb, mrb_value self);
|
||||
mrb_value mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n);
|
||||
void mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val);
|
||||
int mrb_ary_len(mrb_state *mrb, mrb_value ary);
|
||||
mrb_value mrb_ary_replace_m(mrb_state *mrb, mrb_value self);
|
||||
void mrb_ary_replace(mrb_state *mrb, struct RArray *a, mrb_value *argv, size_t len);
|
||||
mrb_value mrb_check_array_type(mrb_state *mrb, mrb_value self);
|
||||
mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item);
|
||||
mrb_value mrb_ary_new4(mrb_state *mrb, long n, const mrb_value *elts);
|
||||
mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr);
|
||||
mrb_value mrb_ary_entry(mrb_value ary, long offset);
|
||||
void mrb_mem_clear(mrb_value *mem, long size);
|
||||
mrb_value mrb_ary_tmp_new(mrb_state *mrb, long capa);
|
||||
mrb_value mrb_ary_sort(mrb_state *mrb, mrb_value ary);
|
||||
mrb_value mrb_ary_shift(mrb_state *mrb, mrb_value self);
|
||||
|
||||
#endif /* MRUBY_ARRAY_H */
|
||||
@@ -0,0 +1,71 @@
|
||||
#ifndef MRUBY_CLASS_H
|
||||
#define MRUBY_CLASS_H
|
||||
|
||||
struct RClass {
|
||||
MRUBY_OBJECT_HEADER;
|
||||
struct kh_iv *iv;
|
||||
struct kh_mt *mt;
|
||||
struct RClass *super;
|
||||
};
|
||||
|
||||
#define mrb_class_ptr(v) ((struct RClass*)((v).value.p))
|
||||
#define RCLASS_SUPER(v) (((struct RClass*)((v).value.p))->super)
|
||||
#define RCLASS_IV_TBL(v) (((struct RClass*)((v).value.p))->iv)
|
||||
#define RCLASS_M_TBL(v) (((struct RClass*)((v).value.p))->mt)
|
||||
|
||||
static inline struct RClass*
|
||||
mrb_class(mrb_state *mrb, mrb_value v)
|
||||
{
|
||||
switch (mrb_type(v)) {
|
||||
case MRB_TT_FALSE:
|
||||
if (v.value.p)
|
||||
return mrb->false_class;
|
||||
return mrb->nil_class;
|
||||
case MRB_TT_TRUE:
|
||||
return mrb->true_class;
|
||||
case MRB_TT_SYMBOL:
|
||||
return mrb->symbol_class;
|
||||
case MRB_TT_FIXNUM:
|
||||
return mrb->fixnum_class;
|
||||
case MRB_TT_FLOAT:
|
||||
return mrb->float_class;
|
||||
|
||||
#ifdef INCLUDE_REGEXP
|
||||
// case MRB_TT_REGEX:
|
||||
// return mrb->regex_class;
|
||||
// case MRB_TT_MATCH:
|
||||
// return mrb->match_class;
|
||||
// case MRB_TT_DATA:
|
||||
// return mrb->encode_class;
|
||||
#else
|
||||
case MRB_TT_REGEX:
|
||||
case MRB_TT_MATCH:
|
||||
mrb_raise(mrb, E_TYPE_ERROR, "type mismatch: %s given",
|
||||
mrb_obj_classname(mrb, v));
|
||||
return mrb->nil_class; /* not reach */
|
||||
#endif
|
||||
default:
|
||||
return ((struct RBasic*)mrb_object(v))->c;
|
||||
}
|
||||
}
|
||||
|
||||
#define MRB_SET_INSTANCE_TT(c, tt) c->flags = ((c->flags & ~0xff) | (char)tt)
|
||||
#define MRB_INSTANCE_TT(c) (enum mrb_vtype)(c->flags & 0xff)
|
||||
|
||||
struct RClass* mrb_define_class_id(mrb_state*, mrb_sym, struct RClass*);
|
||||
struct RClass* mrb_define_module_id(mrb_state*, mrb_sym);
|
||||
struct RClass *mrb_vm_define_class(mrb_state*, mrb_value, mrb_value, mrb_sym);
|
||||
struct RClass *mrb_vm_define_module(mrb_state*, mrb_value, mrb_sym);
|
||||
void mrb_define_method_vm(mrb_state*, struct RClass*, mrb_sym, mrb_value);
|
||||
void mrb_define_method_raw(mrb_state*, struct RClass*, mrb_sym, struct RProc *);
|
||||
|
||||
struct RClass *mrb_class_outer_module(mrb_state*, struct RClass *);
|
||||
struct RProc *mrb_method_search_vm(mrb_state*, struct RClass**, mrb_sym);
|
||||
struct RProc *mrb_method_search(mrb_state*, struct RClass*, mrb_sym);
|
||||
|
||||
int mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid);
|
||||
void mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, int aspec);
|
||||
|
||||
void mrb_obj_call_init(mrb_state *mrb, mrb_value obj, int argc, mrb_value *argv);
|
||||
|
||||
#endif /* MRUBY_CLASS_H */
|
||||
@@ -0,0 +1,59 @@
|
||||
#ifndef MRUBY_HASH_H
|
||||
#define MRUBY_HASH_H
|
||||
|
||||
struct RHash {
|
||||
MRUBY_OBJECT_HEADER;
|
||||
struct kh_ht *ht;
|
||||
mrb_value ifnone;
|
||||
};
|
||||
|
||||
#define N 624
|
||||
#define M 397
|
||||
#define MATRIX_A 0x9908b0dfU /* constant vector a */
|
||||
#define UMASK 0x80000000U /* most significant w-r bits */
|
||||
#define LMASK 0x7fffffffU /* least significant r bits */
|
||||
#define MIXBITS(u,v) ( ((u) & UMASK) | ((v) & LMASK) )
|
||||
#define TWIST(u,v) ((MIXBITS(u,v) >> 1) ^ ((v)&1U ? MATRIX_A : 0U))
|
||||
enum {MT_MAX_STATE = N};
|
||||
|
||||
struct MT {
|
||||
/* assume int is enough to store 32bits */
|
||||
unsigned int state[N]; /* the array for the state vector */
|
||||
unsigned int *next;
|
||||
int left;
|
||||
};
|
||||
|
||||
#define mrb_hash_end(h) st_hash_end(h)
|
||||
#define mrb_hash_uint(h, i) st_hash_uint(h, i)
|
||||
|
||||
#define mrb_hash_ptr(v) ((struct RHash*)((v).value.p))
|
||||
#define mrb_hash_value(p) mrb_obj_value((void*)(p))
|
||||
|
||||
mrb_value mrb_hash_new_capa(mrb_state*, size_t);
|
||||
mrb_value mrb_hash_new(mrb_state *mrb, int capa);
|
||||
|
||||
void mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val);
|
||||
mrb_value mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key);
|
||||
mrb_value mrb_hash_getWithDef(mrb_state *mrb, mrb_value hash, mrb_value vkey, mrb_value def);
|
||||
mrb_value mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key);
|
||||
mrb_value mrb_hash(mrb_state *mrb, mrb_value obj);
|
||||
void ruby_setenv(mrb_state *mrb, const char *name, const char *value);
|
||||
|
||||
/* RHASH_TBL allocates st_table if not available. */
|
||||
#define RHASH(obj) ((struct RHash*)((obj).value.p))
|
||||
#define RHASH_TBL(h) mrb_hash_tbl(h)
|
||||
#define RHASH_H_TBL(h) (RHASH(h)->ht)
|
||||
#define RHASH_SIZE(h) (RHASH_H_TBL(h)->size)
|
||||
#define RHASH_EMPTY_P(h) (RHASH_SIZE(h) == 0)
|
||||
#define RHASH_IFNONE(h) (RHASH(h)->ifnone)
|
||||
#define RHASH_PROCDEFAULT(h) (RHASH(h)->ifnone)
|
||||
struct kh_ht * mrb_hash_tbl(mrb_state *mrb, mrb_value hash);
|
||||
|
||||
#define MRB_HASH_PROC_DEFAULT 256
|
||||
#define MRB_RHASH_PROCDEFAULT_P(h) (RHASH(h)->flags & MRB_HASH_PROC_DEFAULT)
|
||||
|
||||
char * ruby_strdup(const char *str);
|
||||
void mrb_reset_random_seed(void);
|
||||
mrb_value mrb_obj_is_proc(mrb_value proc);
|
||||
|
||||
#endif /* MRUBY_HASH_H */
|
||||
@@ -0,0 +1,17 @@
|
||||
#ifndef MRUBY_NUMERIC_H
|
||||
#define MRUBY_NUMERIC_H
|
||||
|
||||
#include <limits.h>
|
||||
|
||||
#define RSHIFT(x,y) ((x)>>(int)(y))
|
||||
#define FIXNUM_MAX (LONG_MAX>>1)
|
||||
#define FIXNUM_MIN RSHIFT((long)LONG_MIN,1)
|
||||
#define POSFIXABLE(f) ((f) < FIXNUM_MAX+1)
|
||||
#define NEGFIXABLE(f) ((f) >= FIXNUM_MIN)
|
||||
#define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f))
|
||||
|
||||
mrb_value mrb_dbl2big(mrb_state *mrb, float d);
|
||||
void mrb_num_zerodiv(mrb_state *mrb);
|
||||
mrb_value mrb_fix2str(mrb_state *mrb, mrb_value x, int base);
|
||||
|
||||
#endif /* MRUBY_NUMERIC_H */
|
||||
@@ -0,0 +1,46 @@
|
||||
#ifndef MRUBY_OBJECT_H
|
||||
#define MRUBY_OBJECT_H
|
||||
|
||||
#define MRUBY_OBJECT_HEADER \
|
||||
enum mrb_vtype tt:8;\
|
||||
int color:3;\
|
||||
unsigned int flags:21;\
|
||||
struct RClass *c;\
|
||||
struct RBasic *gcnext;
|
||||
|
||||
|
||||
/* white: 011, black: 100, gray: 000 */
|
||||
#define MRB_GC_GRAY 0
|
||||
#define MRB_GC_WHITE_A 1
|
||||
#define MRB_GC_WHITE_B (1 << 1)
|
||||
#define MRB_GC_BLACK (1 << 2)
|
||||
#define MRB_GC_WHITES (MRB_GC_WHITE_A | MRB_GC_WHITE_B)
|
||||
#define MRB_GC_COLOR_MASK 7
|
||||
|
||||
#define paint_gray(o) ((o)->color = MRB_GC_GRAY)
|
||||
#define paint_black(o) ((o)->color = MRB_GC_BLACK)
|
||||
#define paint_white(o) ((o)->color = MRB_GC_WHITES)
|
||||
#define paint_partial_white(s, o) ((o)->color = (s)->current_white_part)
|
||||
#define is_gray(o) ((o)->color == MRB_GC_GRAY)
|
||||
#define is_white(o) ((o)->color & MRB_GC_WHITES)
|
||||
#define is_black(o) ((o)->color & MRB_GC_BLACK)
|
||||
#define is_dead(s, o) (((o)->color & other_white_part(s) & MRB_GC_WHITES) || (o)->tt == MRB_TT_FREE)
|
||||
#define flip_white_part(s) ((s)->current_white_part = other_white_part(s))
|
||||
#define other_white_part(s) ((s)->current_white_part ^ MRB_GC_WHITES)
|
||||
|
||||
struct RBasic {
|
||||
MRUBY_OBJECT_HEADER;
|
||||
};
|
||||
|
||||
struct RObject {
|
||||
MRUBY_OBJECT_HEADER;
|
||||
struct kh_iv *iv;
|
||||
};
|
||||
|
||||
#define mrb_obj_ptr(v) ((struct RObject*)((v).value.p))
|
||||
#define RBASIC(obj) ((struct RBasic*)((obj).value.p))
|
||||
#define RBASIC_KLASS(v) ((struct RClass *)(((struct RBasic*)((v).value.p))->c))
|
||||
#define ROBJECT(v) ((struct RObject*)((v).value.p))
|
||||
#define ROBJECT_IVPTR(v) (((struct RObject*)((v).value.p))->iv)
|
||||
#define ROBJECT_NUMIV(v) (ROBJECT_IVPTR(v) ? ROBJECT_IVPTR(v)->size : 0)
|
||||
#endif /* MRUBY_OBJECT_H */
|
||||
@@ -0,0 +1,44 @@
|
||||
#ifndef MRUBY_PROC_H
|
||||
#define MRUBY_PROC_H
|
||||
|
||||
#include "mruby.h"
|
||||
#include "irep.h"
|
||||
|
||||
struct REnv {
|
||||
MRUBY_OBJECT_HEADER;
|
||||
mrb_value *stack;
|
||||
mrb_sym mid;
|
||||
int cioff;
|
||||
};
|
||||
|
||||
struct RProc {
|
||||
MRUBY_OBJECT_HEADER;
|
||||
union {
|
||||
mrb_irep *irep;
|
||||
mrb_func_t func;
|
||||
} body;
|
||||
struct RClass *target_class;
|
||||
struct REnv *env;
|
||||
};
|
||||
|
||||
/* aspec access */
|
||||
#define ARGS_GETREQ(a) (((a) >> 19) & 0x1f)
|
||||
#define ARGS_GETOPT(a) (((a) >> 14) & 0x1f)
|
||||
#define ARGS_GETREST(a) ((a) & (1<<13))
|
||||
#define ARGS_GETPOST(a) (((a) >> 8) & 0x1f)
|
||||
#define ARGS_GETKEY(a) (((a) >> 3) & 0x1f))
|
||||
#define ARGS_GETKDICT(a) ((a) & (1<<2))
|
||||
#define ARGS_GETBLOCK(a) ((a) & (1<<1))
|
||||
|
||||
#define MRB_PROC_CFUNC 128
|
||||
#define MRB_PROC_CFUNC_P(p) ((p)->flags & MRB_PROC_CFUNC)
|
||||
#define MRB_PROC_STRICT 256
|
||||
#define MRB_PROC_STRICT_P(p) ((p)->flags & MRB_PROC_STRICT)
|
||||
|
||||
#define mrb_proc_ptr(v) ((struct RProc*)((v).value.p))
|
||||
|
||||
struct RProc *mrb_proc_new(mrb_state*, mrb_irep*);
|
||||
struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t);
|
||||
struct RProc *mrb_closure_new(mrb_state*, mrb_irep*);
|
||||
|
||||
#endif /* MRUBY_STRING_H */
|
||||
@@ -0,0 +1,21 @@
|
||||
#ifndef MRUBY_RANGE_H
|
||||
#define MRUBY_RANGE_H
|
||||
|
||||
struct RRange {
|
||||
MRUBY_OBJECT_HEADER;
|
||||
struct mrb_range_edges {
|
||||
mrb_value beg;
|
||||
mrb_value end;
|
||||
} *edges;
|
||||
int excl;
|
||||
};
|
||||
|
||||
#define mrb_range_ptr(v) ((struct RRange*)((v).value.p))
|
||||
#define mrb_range_value(p) mrb_obj_value((void*)(p))
|
||||
|
||||
mrb_value mrb_range_new(mrb_state*, mrb_value, mrb_value, int);
|
||||
mrb_int mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len, mrb_int err);
|
||||
int mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c);
|
||||
struct RClass* mrb_class_real(struct RClass* cl);
|
||||
|
||||
#endif /* MRUBY_RANGE_H */
|
||||
@@ -0,0 +1,133 @@
|
||||
#ifndef MRUBY_STRING_H
|
||||
#define MRUBY_STRING_H
|
||||
|
||||
#ifdef INCLUDE_ENCODING
|
||||
#include "encoding.h"
|
||||
#endif
|
||||
|
||||
#ifndef RB_GC_GUARD
|
||||
#define RB_GC_GUARD(v) v
|
||||
#endif
|
||||
|
||||
#define IS_EVSTR(p,e) ((p) < (e) && (*(p) == '$' || *(p) == '@' || *(p) == '{'))
|
||||
|
||||
#define mrb_str_new4 mrb_str_new_frozen
|
||||
|
||||
#define STR_BUF_MIN_SIZE 128
|
||||
//#define RSTRING_EMBED_LEN_MAX STR_BUF_MIN_SIZE
|
||||
|
||||
extern const char ruby_digitmap[];
|
||||
|
||||
struct RString {
|
||||
MRUBY_OBJECT_HEADER;
|
||||
size_t len;
|
||||
union {
|
||||
size_t capa;
|
||||
mrb_value shared;
|
||||
} aux;
|
||||
char *buf;
|
||||
};
|
||||
|
||||
extern struct SCOPE {
|
||||
struct RBasic super;
|
||||
mrb_sym *local_tbl;
|
||||
mrb_value *local_vars;
|
||||
int flags;
|
||||
} *ruby_scope;
|
||||
|
||||
struct RVarmap {
|
||||
struct RBasic super;
|
||||
mrb_sym id;
|
||||
mrb_value val;
|
||||
struct RVarmap *next;
|
||||
};
|
||||
extern struct RVarmap *ruby_dyna_vars;
|
||||
|
||||
//struct st_hash_type {
|
||||
// int (*compare)();
|
||||
// int (*hash)();
|
||||
//};
|
||||
|
||||
#define mrb_str_ptr(s) ((struct RString*)((s).value.p))
|
||||
#define RSTRING(s) ((struct RString*)((s).value.p))
|
||||
#define RSTRING_PTR(s) (RSTRING(s)->buf)
|
||||
#define RSTRING_LEN(s) (RSTRING(s)->len)
|
||||
#define RSTRING_CAPA(s) (RSTRING(s)->aux.capa)
|
||||
#define RSTRING_SHARED(s) (RSTRING(s)->aux.shared)
|
||||
#define RSTRING_END(s) (RSTRING(s)->buf + RSTRING(s)->len)
|
||||
|
||||
#define MRB_STR_SHARED 256
|
||||
#define MRB_STR_SHARED_P(s) (FL_ALL(s, MRB_STR_SHARED))
|
||||
#define MRB_STR_NOCAPA (MRB_STR_SHARED)
|
||||
#define MRB_STR_NOCAPA_P(s) (FL_ANY(s, MRB_STR_NOCAPA))
|
||||
#define MRB_STR_UNSET_NOCAPA(s) do {\
|
||||
FL_UNSET(s, MRB_STR_NOCAPA);\
|
||||
} while (0)
|
||||
|
||||
mrb_value mrb_str_literal(mrb_state*, mrb_value);
|
||||
void mrb_str_concat(mrb_state*, mrb_value, mrb_value);
|
||||
mrb_value mrb_obj_to_str(mrb_state*, mrb_value);
|
||||
mrb_value mrb_str_plus(mrb_state*, mrb_value, mrb_value);
|
||||
mrb_value mrb_obj_as_string(mrb_state *mrb, mrb_value obj);
|
||||
mrb_value mrb_str_new(mrb_state *mrb, const char *p, size_t len); /* mrb_str_new */
|
||||
mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, size_t len); /* mrb_str_resize */
|
||||
mrb_value mrb_string_value(mrb_state *mrb, mrb_value *ptr); /* StringValue */
|
||||
mrb_value mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, int len);
|
||||
mrb_value mrb_check_string_type(mrb_state *mrb, mrb_value str);
|
||||
mrb_value mrb_str_buf_new(mrb_state *mrb, size_t capa);
|
||||
mrb_value mrb_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len);
|
||||
mrb_value str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len);
|
||||
|
||||
char * mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr);
|
||||
char * mrb_string_value_ptr(mrb_state *mrb, mrb_value ptr);
|
||||
mrb_value mrb_str_subseq(mrb_state *mrb, mrb_value str, long beg, long len);
|
||||
size_t mrb_str_sublen(mrb_state *mrb, mrb_value str, long pos);
|
||||
mrb_value mrb_str_size(mrb_state *mrb, mrb_value self);
|
||||
long mrb_str_offset(mrb_state *mrb, mrb_value str, long pos);
|
||||
mrb_value mrb_str_new2(mrb_state *mrb, const char *p);
|
||||
mrb_value mrb_str_dup(mrb_state *mrb, mrb_value str); /* mrb_str_dup */
|
||||
mrb_value mrb_str_new_frozen(mrb_state *mrb, mrb_value orig);
|
||||
mrb_value mrb_lastline_get(mrb_state *mrb);
|
||||
mrb_value mrb_usascii_str_new(mrb_state *mrb, const char *ptr, long len);
|
||||
void mrb_lastline_set(mrb_value val);
|
||||
mrb_value mrb_str_buf_cat_ascii(mrb_state *mrb, mrb_value str, const char *ptr);
|
||||
void mrb_str_modify(mrb_state *mrb, mrb_value str);
|
||||
void mrb_str_set_len(mrb_state *mrb, mrb_value str, long len);
|
||||
mrb_value mrb_str_intern(mrb_state *mrb, mrb_value self);
|
||||
void mrb_str_shared_replace(mrb_state *mrb, mrb_value str, mrb_value str2);
|
||||
mrb_value mrb_str_cat2(mrb_state *mrb, mrb_value str, const char *ptr);
|
||||
mrb_value mrb_str_catf(mrb_state *mrb, mrb_value str, const char *format, ...);
|
||||
mrb_value mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, int badcheck);
|
||||
double mrb_str_to_dbl(mrb_state *mrb, mrb_value str, int badcheck);
|
||||
mrb_value mrb_str_to_str(mrb_state *mrb, mrb_value str);
|
||||
mrb_value mrb_locale_str_new(mrb_state *mrb, const char *ptr, long len);
|
||||
mrb_value mrb_filesystem_str_new_cstr(mrb_state *mrb, const char *ptr);
|
||||
mrb_int mrb_str_hash(mrb_state *mrb, mrb_value str);
|
||||
int mrb_str_hash_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2);
|
||||
mrb_value str_new3(mrb_state *mrb, struct RClass* klass, mrb_value str);
|
||||
mrb_value mrb_str_buf_append(mrb_state *mrb, mrb_value str, mrb_value str2);
|
||||
void mrb_str_setter(mrb_state *mrb, mrb_value val, mrb_sym id, mrb_value *var);
|
||||
int mrb_str_is_ascii_only_p(mrb_state *mrb, mrb_value str);
|
||||
mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str);
|
||||
int mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2);
|
||||
mrb_value str_new4(mrb_state *mrb, enum mrb_vtype ttype, mrb_value str);
|
||||
mrb_value * mrb_svar(mrb_int cnt);
|
||||
mrb_value mrb_str_drop_bytes(mrb_state *mrb, mrb_value str, long len);
|
||||
mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str);
|
||||
mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, long len);
|
||||
mrb_value mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2);
|
||||
size_t mrb_str_capacity(mrb_value str);
|
||||
|
||||
#ifdef INCLUDE_ENCODING
|
||||
int sym_printable(mrb_state *mrb, const char *s, const char *send, mrb_encoding *enc);
|
||||
mrb_value mrb_str_conv_enc(mrb_state *mrb, mrb_value str, mrb_encoding *from, mrb_encoding *to);
|
||||
mrb_value mrb_str_conv_enc_opts(mrb_state *mrb, mrb_value str, mrb_encoding *from, mrb_encoding *to, int ecflags, mrb_value ecopts);
|
||||
mrb_value mrb_enc_str_new(mrb_state *mrb, const char *ptr, long len, mrb_encoding *enc);
|
||||
#else
|
||||
int mrb_symname_p(const char *name);
|
||||
#endif
|
||||
|
||||
mrb_value mrb_tainted_str_new(mrb_state *mrb, const char *ptr, long len);
|
||||
int mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2);
|
||||
|
||||
#endif /* MRUBY_STRING_H */
|
||||
@@ -0,0 +1,16 @@
|
||||
#ifndef MSTRUCT_H
|
||||
#define MSTRUCT_H
|
||||
|
||||
struct RStruct {
|
||||
struct RBasic basic;
|
||||
long len;
|
||||
mrb_value *ptr;
|
||||
};
|
||||
#define RSTRUCT(st) ((struct RStruct*)((st).value.p))
|
||||
#define RSTRUCT_LEN(st) ((int)(RSTRUCT(st)->len))
|
||||
#define RSTRUCT_PTR(st) (RSTRUCT(st)->ptr)
|
||||
|
||||
mrb_value mrb_yield_values(int n, ...);
|
||||
mrb_value mrb_mod_module_eval(mrb_state *mrb, int argc, mrb_value *argv, mrb_value mod);
|
||||
|
||||
#endif //MSTRUCT_H
|
||||
Reference in New Issue
Block a user