VALUE set_if_hash(VALUE rb_if_hash, struct ifaddrs *ifa, int family){
char *if_host, *if_netmask, *if_name;
if_name = get_if_name(ifa);
if_host = malloc(sizeof(char) * NI_MAXHOST);
if (! get_if_host(ifa, if_host))
rb_raise(rb_eSystemCallError, "Can't get IP from %s", if_name);
if_netmask = malloc(sizeof(char) * NI_MAXHOST);
if (! get_if_netmask(ifa, if_netmask))
rb_raise(rb_eSystemCallError, "Can't get IP from %s", if_name);
char *str_inet_name = "inet_addr_v4";
char *str_inet_name6 = "inet_addr_v6";
char *str_netmask_name = "netmask_v4";
char *str_netmask_name6 = "netmask_v6";
VALUE rb_if_data_hash = rb_hash_aref(rb_if_hash, rb_str_intern(rb_str_new2(if_name)));
if (rb_if_data_hash == Qnil) {
rb_if_data_hash = rb_hash_new();
rb_hash_aset(rb_if_hash,
rb_str_intern(rb_str_new2(if_name)),
rb_if_data_hash);
}
rb_hash_aset(rb_if_data_hash,
rb_str_intern(rb_str_new2((family == AF_INET) ? str_inet_name : str_inet_name6)),
rb_str_new2(if_host));
rb_hash_aset(rb_if_data_hash,
rb_str_intern(rb_str_new2((family == AF_INET) ? str_netmask_name : str_netmask_name6)),
rb_str_new2(if_netmask));
return rb_if_data_hash;
}
int map_key_callback(void *ctx, const unsigned char *stringVal, size_t stringLen) {
VALUE key;
#ifdef HAVE_RUBY_ENCODING_H
rb_encoding *default_internal_enc;
#endif
if ( ((CTX *)ctx)->symbolizeKeys ) {
#ifdef HAVE_RUBY_ENCODING_H
ID id = rb_intern3((const char *)stringVal, stringLen, utf8Encoding);
key = ID2SYM(id);
#else
VALUE str = rb_str_new((const char *)stringVal, stringLen);
key = rb_str_intern(str);
#endif
} else {
key = rb_str_new((const char *)stringVal, stringLen);
#ifdef HAVE_RUBY_ENCODING_H
default_internal_enc = rb_default_internal_encoding();
rb_enc_associate(key, utf8Encoding);
if (default_internal_enc) {
key = rb_str_export_to_enc(key, default_internal_enc);
}
#endif
}
set_key(ctx, key);
return 1;
}
STATIC VALUE rb_read_object(ramf0_load_context_t* context, bool add_to_ref_cache)
{
static ID underscore_id = (ID)0;
if (underscore_id == (ID)0) {
underscore_id = rb_intern("underscore");
}
VALUE object = rb_hash_new();
if (add_to_ref_cache) {
rb_ary_push(context->cache, object);
}
while (1) {
VALUE key = rb_read_string(context, 0);
int8_t type = c_read_int8(context);
if (type == AMF0_OBJECT_END_MARKER) { break; }
key = rb_funcall(key, underscore_id, 0);
key = rb_str_intern(key);
rb_hash_aset(object, key, rb_deserialize(context, type));
}
return object;
}
static VALUE
nst_method_missing(int argc, VALUE *argv, VALUE self)
{
VALUE s, tag, obj;
if (argc == 2) {
s = rb_sym_to_s(argv[0]);
if (RSTRING_PTR(s)[RSTRING_LEN(s)-1] == '=') {
tag = rb_str_intern(rb_str_new(RSTRING_PTR(s), RSTRING_LEN(s)-1));
obj = nst_field(self, tag);
if (RTEST(obj)) {
rb_funcall(obj, rb_intern("store"), 1, argv[1]);
return argv[1];
}
}
return rb_call_super(argc,argv);
}
if (argc == 1) {
obj = nst_field(self,argv[0]);
if (RTEST(obj)) {
return obj;
}
}
return rb_call_super(argc,argv);
}
static VALUE
struct_field_initialize(int argc, VALUE* argv, VALUE self)
{
VALUE rbOffset = Qnil, rbName = Qnil, rbType = Qnil;
StructField* field;
int nargs;
Data_Get_Struct(self, StructField, field);
nargs = rb_scan_args(argc, argv, "3", &rbName, &rbOffset, &rbType);
if (TYPE(rbName) != T_SYMBOL && TYPE(rbName) != T_STRING) {
rb_raise(rb_eTypeError, "wrong argument type %s (expected Symbol/String)",
rb_obj_classname(rbName));
}
Check_Type(rbOffset, T_FIXNUM);
if (!rb_obj_is_kind_of(rbType, rbffi_TypeClass)) {
rb_raise(rb_eTypeError, "wrong argument type %s (expected FFI::Type)",
rb_obj_classname(rbType));
}
field->offset = NUM2UINT(rbOffset);
field->rbName = (TYPE(rbName) == T_SYMBOL) ? rbName : rb_str_intern(rbName);
field->rbType = rbType;
Data_Get_Struct(field->rbType, Type, field->type);
field->memoryOp = get_memory_op(field->type);
return self;
}
static void
hash2ptr_dispparams(VALUE hash, ITypeInfo *pTypeInfo, DISPID dispid, DISPPARAMS *pdispparams)
{
BSTR *bstrs;
HRESULT hr;
UINT len, i;
VARIANT *pvar;
VALUE val;
VALUE key;
len = 0;
bstrs = ALLOCA_N(BSTR, pdispparams->cArgs + 1);
hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, dispid,
bstrs, pdispparams->cArgs + 1,
&len);
if (FAILED(hr))
return;
for (i = 0; i < len - 1; i++) {
key = WC2VSTR(bstrs[i + 1]);
val = rb_hash_aref(hash, INT2FIX(i));
if (val == Qnil)
val = rb_hash_aref(hash, key);
if (val == Qnil)
val = rb_hash_aref(hash, rb_str_intern(key));
pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
ole_val2ptr_variant(val, pvar);
}
}
static int
rb_crustache__context_get(
crustache_var *var,
void *ctx,
const char *key,
size_t key_size)
{
VALUE rb_ctx = (VALUE)ctx;
VALUE rb_key, rb_val;
rb_key = rb_str_new(key, (long)key_size);
rb_val = Qnil;
if (TYPE(rb_ctx) == T_HASH) {
rb_val = rb_hash_lookup(rb_ctx, rb_key);
if (NIL_P(rb_val))
rb_val = rb_hash_lookup(rb_ctx, rb_str_intern(rb_key));
} else {
ID method = rb_to_id(rb_key);
if (rb_respond_to(rb_ctx, method))
rb_val = rb_funcall(rb_ctx, method, 0);
else if (rb_respond_to(rb_ctx, rb_intern("[]")))
rb_val = rb_funcall(rb_ctx, rb_intern("[]"), 1, key);
}
if (NIL_P(rb_val)) /* not found */
return -1;
return rb_crustache__setvar(var, rb_val);
}
static void
hash_set_cstr(ParseInfo pi, const char *key, size_t klen, const char *str, size_t len, const char *orig) {
Val parent = stack_peek(&pi->stack);
if (0 != pi->options.create_id &&
*pi->options.create_id == *key &&
pi->options.create_id_len == klen &&
0 == strncmp(pi->options.create_id, key, klen)) {
if (str < pi->json || pi->cur < str) {
parent->classname = oj_strndup(str, len);
} else {
parent->classname = str;
}
parent->clen = len;
} else {
volatile VALUE rstr = rb_str_new(str, len);
volatile VALUE rkey = rb_str_new(key, klen);
rstr = oj_encode(rstr);
rkey = oj_encode(rkey);
if (Yes == pi->options.sym_key) {
rkey = rb_str_intern(rkey);
}
rb_hash_aset(parent->val, rkey, rstr);
}
}
/**
* call-seq:
* instance.each_property do |name, value|
* ...
* end
*
* enumerates properties yielding the property name and
* its value
*
*/
static VALUE each_property(VALUE self)
{
CIMCInstance *ptr;
CIMCStatus status;
int k=0;
int num_props=0;
CIMCString *property_name = NULL;
CIMCData data;
Data_Get_Struct(self, CIMCInstance, ptr);
num_props = ptr->ft->getPropertyCount(ptr, &status);
if (!status.rc) {
for (; k < num_props; ++k) {
data = ptr->ft->getPropertyAt(ptr, k, &property_name, &status);
if (!status.rc) {
rb_yield_values(2, (property_name ? rb_str_intern(rb_str_new2(property_name->ft->getCharPtr(property_name, NULL))) : Qnil), sfcc_cimdata_to_value(data));
}
else {
sfcc_rb_raise_if_error(status, "Can't retrieve property #%d", k);
}
if (property_name) CMRelease(property_name);
}
}
else {
sfcc_rb_raise_if_error(status, "Can't retrieve property count");
}
return Qnil;
}
STATIC VALUE rb_read_hash(ramf0_load_context_t* context)
{
uint32_t len = c_read_word32_network(context);
VALUE object = Qnil;
VALUE key = rb_read_string(context, 0);
int8_t type = c_read_int8(context);
if (type == AMF0_OBJECT_END_MARKER) {
return rb_ary_new();
}
// We need to figure out whether this is a real hash, or whether some stupid serializer gave up
if (rb_str_cmp( rb_big2str(rb_str_to_inum(key, 10, Qfalse),10), key) == 0) {
// array
object = rb_ary_new();
rb_ary_push(context->cache, object);
rb_ary_store(object, NUM2LONG(rb_str_to_inum(key, 10, Qfalse)), rb_deserialize(context, type));
while (1) {
VALUE key = rb_str_to_inum(rb_read_string(context, 0), 10, Qfalse);
int8_t type = c_read_int8(context);
if (type == AMF0_OBJECT_END_MARKER) { break; }
rb_ary_store(object, NUM2LONG(key), rb_deserialize(context, type));
}
return object;
} else {
// hash
object = rb_hash_new();
rb_ary_push(context->cache, object);
key = rb_str_intern(key);
rb_hash_aset(object, key, rb_deserialize(context, type));
while (1) {
VALUE key = rb_read_string(context, 0);
int8_t type = c_read_int8(context);
if (type == AMF0_OBJECT_END_MARKER) { break; }
key = rb_str_intern(key);
rb_hash_aset(object, key, rb_deserialize(context, type));
}
return object;
}
}
static VALUE
hash2result(VALUE hash)
{
VALUE ret = Qnil;
ret = rb_hash_aref(hash, rb_str_new2("return"));
if (ret == Qnil)
ret = rb_hash_aref(hash, rb_str_intern(rb_str_new2("return")));
return ret;
}
/*
* call-seq:
* context.frame_method(frame_position = 0) -> sym
*
* Returns the sym of the method in the frame.
*/
static VALUE
Context_frame_method(int argc, VALUE * argv, VALUE self)
{
VALUE loc;
FRAME_SETUP;
loc = dc_frame_location(context, frame_n);
return rb_str_intern(rb_funcall(loc, rb_intern("label"), 0));
}
static void set_state_ivars(VALUE hash, VALUE state)
{
VALUE ivars = rb_obj_instance_variables(state);
int i = 0;
for (i = 0; i < RARRAY_LEN(ivars); i++) {
VALUE key = rb_funcall(rb_ary_entry(ivars, i), i_to_s, 0);
long key_len = RSTRING_LEN(key);
VALUE value = rb_iv_get(state, StringValueCStr(key));
rb_hash_aset(hash, rb_str_intern(rb_str_substr(key, 1, key_len - 1)), value);
}
}
static VALUE
calc_hash_key(ParseInfo pi, Val parent) {
volatile VALUE rkey = parent->key_val;
if (Qundef == rkey) {
rkey = rb_str_new(parent->key, parent->klen);
}
rkey = oj_encode(rkey);
if (Yes == pi->options.sym_key) {
rkey = rb_str_intern(rkey);
}
return rkey;
}
void
shoes_app_style(shoes_app *app, VALUE klass, VALUE hsh)
{
long i;
VALUE keys = rb_funcall(hsh, s_keys, 0);
for ( i = 0; i < RARRAY_LEN(keys); i++ )
{
VALUE key = rb_ary_entry(keys, i);
VALUE val = rb_hash_aref(hsh, key);
if (!SYMBOL_P(key)) key = rb_str_intern(key);
shoes_style_set(app->styles, klass, key, val);
}
}
static VALUE
data_type_set(VALUE self, VALUE value)
{
if (TYPE(value) != T_SYMBOL) {
value = rb_str_intern(rb_String(value));
}
if (rb_hash_aref(rb_hTypes, value) == Qnil) {
rb_raise(rb_eArgError, "invalid data type %s",
RSTRING_PTR(rb_inspect(value)));
}
rb_ivar_set(self, id_data_type, value);
return self;
}
grn_bool
rb_grn_equal_option (VALUE option, const char *key)
{
VALUE key_string, key_symbol;
key_string = rb_str_new2(key);
if (RVAL2CBOOL(rb_funcall(option, rb_intern("=="), 1, key_string)))
return GRN_TRUE;
key_symbol = rb_str_intern(key_string);
if (RVAL2CBOOL(rb_funcall(option, rb_intern("=="), 1, key_symbol)))
return GRN_TRUE;
return GRN_FALSE;
}
/*
* call-seq: initialize(name, offset, type)
* @param [String,Symbol] name
* @param [Fixnum] offset
* @param [FFI::Type] type
* @return [self]
* A new FFI::StructLayout::Field instance.
*/
static VALUE
struct_field_initialize(int argc, VALUE* argv, VALUE self)
{
VALUE rbOffset = Qnil, rbName = Qnil, rbType = Qnil;
StructField* field;
int nargs;
Data_Get_Struct(self, StructField, field);
nargs = rb_scan_args(argc, argv, "3", &rbName, &rbOffset, &rbType);
if (TYPE(rbName) != T_SYMBOL && TYPE(rbName) != T_STRING) {
rb_raise(rb_eTypeError, "wrong argument type %s (expected Symbol/String)",
rb_obj_classname(rbName));
}
Check_Type(rbOffset, T_FIXNUM);
if (!rb_obj_is_kind_of(rbType, rbffi_TypeClass)) {
rb_raise(rb_eTypeError, "wrong argument type %s (expected FFI::Type)",
rb_obj_classname(rbType));
}
field->offset = NUM2UINT(rbOffset);
field->rbName = (TYPE(rbName) == T_SYMBOL) ? rbName : rb_str_intern(rbName);
field->rbType = rbType;
Data_Get_Struct(field->rbType, Type, field->type);
field->memoryOp = get_memory_op(field->type);
field->referenceIndex = -1;
switch (field->type->nativeType == NATIVE_MAPPED ? ((MappedType *) field->type)->type->nativeType : field->type->nativeType) {
case NATIVE_FUNCTION:
case NATIVE_CALLBACK:
case NATIVE_POINTER:
field->referenceRequired = true;
break;
default:
field->referenceRequired = (rb_respond_to(self, rb_intern("reference_required?"))
&& RTEST(rb_funcall2(self, rb_intern("reference_required?"), 0, NULL)))
|| (rb_respond_to(rbType, rb_intern("reference_required?"))
&& RTEST(rb_funcall2(rbType, rb_intern("reference_required?"), 0, NULL)));
break;
}
return self;
}
static VALUE
sym_step_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, arg))
{
VALUE *iter = (VALUE *)arg;
if (FIXNUM_P(iter[0])) {
iter[0] -= INT2FIX(1) & ~FIXNUM_FLAG;
}
else {
iter[0] = rb_funcall(iter[0], '-', 1, INT2FIX(1));
}
if (iter[0] == INT2FIX(0)) {
rb_yield(rb_str_intern(i));
iter[0] = iter[1];
}
return Qnil;
}
static VALUE rb_thrift_union_read(VALUE self, VALUE protocol) {
// read struct begin
default_read_struct_begin(protocol);
VALUE struct_fields = STRUCT_FIELDS(self);
VALUE field_header = default_read_field_begin(protocol);
VALUE field_type_value = rb_ary_entry(field_header, 1);
int field_type = FIX2INT(field_type_value);
// make sure we got a type we expected
VALUE field_info = rb_hash_aref(struct_fields, rb_ary_entry(field_header, 2));
if (!NIL_P(field_info)) {
int specified_type = FIX2INT(rb_hash_aref(field_info, type_sym));
if (field_type == specified_type) {
// read the value
VALUE name = rb_hash_aref(field_info, name_sym);
rb_iv_set(self, "@setfield", rb_str_intern(name));
rb_iv_set(self, "@value", read_anything(protocol, field_type, field_info));
} else {
rb_funcall(protocol, skip_method_id, 1, field_type_value);
}
} else {
rb_funcall(protocol, skip_method_id, 1, field_type_value);
}
// read field end
default_read_field_end(protocol);
field_header = default_read_field_begin(protocol);
field_type_value = rb_ary_entry(field_header, 1);
field_type = FIX2INT(field_type_value);
if (field_type != TTYPE_STOP) {
rb_raise(rb_eRuntimeError, "too many fields in union!");
}
// read struct end
default_read_struct_end(protocol);
// call validate
rb_funcall(self, validate_method_id, 0);
return Qnil;
}
static VALUE
sym_step_i(VALUE i, void *arg)
{
VALUE *iter = arg;
if (FIXNUM_P(iter[0])) {
iter[0] -= INT2FIX(1) & ~FIXNUM_FLAG;
}
else {
iter[0] = rb_funcall(iter[0], '-', 1, INT2FIX(1));
}
if (iter[0] == INT2FIX(0)) {
rb_yield(rb_str_intern(i));
iter[0] = iter[1];
}
return Qnil;
}
static VALUE bert_read_atom(struct bert_buf *buf)
{
VALUE rb_atom;
uint32_t atom_len;
bert_buf_ensure(buf, 2);
atom_len = bert_buf_read16(buf);
/* Instead of trying to build the symbol
* from here, just create a Ruby string
* and internalize it. this will be faster for
* unique symbols */
bert_buf_ensure(buf, atom_len);
rb_atom = rb_str_new((char *)buf->data, atom_len);
buf->data += atom_len;
return rb_str_intern(rb_atom);
}
static VALUE rb_tinytds_result_fields(VALUE self) {
RETCODE dbsqlok_rc, dbresults_rc;
VALUE fields_processed;
GET_RESULT_WRAPPER(self);
dbsqlok_rc = rb_tinytds_result_ok_helper(rwrap->client);
dbresults_rc = rb_tinytds_result_dbresults_retcode(self);
fields_processed = rb_ary_entry(rwrap->fields_processed, rwrap->number_of_results);
if ((dbsqlok_rc == SUCCEED) && (dbresults_rc == SUCCEED) && (fields_processed == Qnil)) {
/* Default query options. */
int symbolize_keys = 0;
VALUE qopts = rb_iv_get(self, "@query_options");
if (rb_hash_aref(qopts, sym_symbolize_keys) == Qtrue)
symbolize_keys = 1;
/* Set number_of_fields count for this result set. */
rwrap->number_of_fields = dbnumcols(rwrap->client);
if (rwrap->number_of_fields > 0) {
/* Create fields for this result set. */
unsigned int fldi = 0;
VALUE fields = rb_ary_new2(rwrap->number_of_fields);
for (fldi = 0; fldi < rwrap->number_of_fields; fldi++) {
char *colname = dbcolname(rwrap->client, fldi+1);
VALUE field = symbolize_keys ? rb_str_intern(ENCODED_STR_NEW2(colname)) : rb_obj_freeze(ENCODED_STR_NEW2(colname));
rb_ary_store(fields, fldi, field);
}
/* Store the fields. */
if (rwrap->number_of_results == 0) {
rwrap->fields = fields;
} else if (rwrap->number_of_results == 1) {
VALUE multi_rs_fields = rb_ary_new();
rb_ary_store(multi_rs_fields, 0, rwrap->fields);
rb_ary_store(multi_rs_fields, 1, fields);
rwrap->fields = multi_rs_fields;
} else {
rb_ary_store(rwrap->fields, rwrap->number_of_results, fields);
}
}
rb_ary_store(rwrap->fields_processed, rwrap->number_of_results, Qtrue);
}
return rwrap->fields;
}
static VALUE
rsym_succ(VALUE sym, SEL sel)
{
return rb_str_intern(rb_str_succ(rb_sym_to_s(sym)));
}
/*
ポリゴン描画
*/
static VALUE drawing_draw_polygon(int argc, VALUE *argv, VALUE self)
{
VALUE vdst;
VALUE pairs;
VALUE mcolor;
VALUE fill;
VALUE aa;
Uint8 alpha;
Uint32 color;
int i, vertexes;
rb_scan_args(argc, argv, "32", &vdst, &pairs, &mcolor, &fill, &aa);
// bitmapメソッドを持っていれば、メソッドの値をvdstとする
VALUE methods = rb_funcall(vdst, rb_intern("methods"), 0);
if(rb_ary_includes(methods, rb_str_intern(rb_str_new2("to_unit"))) == Qfalse &&
rb_ary_includes(methods, rb_str_intern(rb_str_new2("bitmap"))) == Qfalse
)
rb_raise(eMiyakoError, "this method needs sprite have to_method or bitmap method!");
if(rb_ary_includes(methods, rb_str_intern(rb_str_new2("to_unit"))) == Qtrue)
vdst = rb_funcall(vdst, rb_intern("to_unit"), 0);
vdst = rb_funcall(vdst, rb_intern("bitmap"), 0);
vertexes = RARRAY_LEN(pairs);
// 頂点数チェック
if(vertexes > 65536)
rb_raise(eMiyakoError, "too many pairs. pairs is less than 65536.");
// 範囲チェック
for(i=0; i<vertexes; i++)
{
VALUE vertex = *(RARRAY_PTR(pairs)+i);
Sint16 x, y;
get_position(vertex, &x, &y);
}
SDL_Surface *dst = GetSurface(vdst)->surface;
color = value_2_color(rb_funcall(cColor, rb_intern("to_rgb"), 1, mcolor), dst->format, &alpha);
if(RTEST(fill) && RTEST(aa) && alpha < 255)
rb_raise(eMiyakoError, "can't draw filled antialiased alpha polygon");
Sint16 *px = (Sint16 *)malloc(sizeof(Sint16) * vertexes);
Sint16 *py = (Sint16 *)malloc(sizeof(Sint16) * vertexes);
for(i=0; i<vertexes; i++)
{
VALUE vertex = *(RARRAY_PTR(pairs)+i);
get_position(vertex, px+i, py+i);
}
if(!RTEST(fill) && !RTEST(aa) && alpha == 255)
{
for(i=0; i<vertexes-1; i++)
sge_Line(dst, px[i], py[i], px[i+1], py[i+1], color);
sge_Line(dst, px[vertexes-1], py[vertexes-1], px[0], py[0], color);
}
else if(!RTEST(fill) && !RTEST(aa) && alpha < 255)
{
for(i=0; i<vertexes-1; i++)
sge_LineAlpha(dst, px[i], py[i], px[i+1], py[i+1], color, alpha);
sge_LineAlpha(dst, px[vertexes-1], py[vertexes-1], px[0], py[0], color, alpha);
}
else if(!RTEST(fill) && RTEST(aa) && alpha == 255)
{
for(i=0; i<vertexes-1; i++)
sge_AALine(dst, px[i], py[i], px[i+1], py[i+1], color);
sge_AALine(dst, px[vertexes-1], py[vertexes-1], px[0], py[0], color);
}
else if(!RTEST(fill) && RTEST(aa) && alpha < 255)
{
for(i=0; i<vertexes-1; i++)
sge_AALineAlpha(dst, px[i], py[i], px[i+1], py[i+1], color, alpha);
sge_AALineAlpha(dst, px[vertexes-1], py[vertexes-1], px[0], py[0], color, alpha);
}
else if(RTEST(fill) && !RTEST(aa) && alpha == 255)
sge_FilledPolygon(dst, (Uint16)vertexes, px, py, color);
else if(RTEST(fill) && !RTEST(aa) && alpha < 255)
sge_FilledPolygonAlpha(dst, (Uint16)vertexes, px, py, color, alpha);
else if(RTEST(fill) && RTEST(aa) && alpha == 255)
sge_AAFilledPolygon(dst, (Uint16)vertexes, px, py, color);
free(py);
free(px);
return Qnil;
}
void
strb_InitializeSdlFont(void)
{
if (TTF_Init()) {
rb_raise_sdl_ttf_error();
}
fontFileInfos = ALLOC(FontFileInfo);
fontFileInfos->rbFontNameSymbol = Qundef;
fontFileInfos->rbFileNameSymbol = Qundef;
fontFileInfos->ttcIndex = -1;
fontFileInfos->next = NULL;
FontFileInfo* currentInfo = fontFileInfos;
(void)currentInfo;
#ifdef WIN32
HKEY hKey;
TCHAR* regPath =
_T("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts");
if (SUCCEEDED(RegOpenKeyEx(HKEY_LOCAL_MACHINE, regPath, 0,
KEY_READ, &hKey))) {
DWORD fontNameBuffMaxLength;
DWORD fileNameBuffMaxByteLength;
RegQueryInfoKey(hKey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
&fontNameBuffMaxLength, &fileNameBuffMaxByteLength,
NULL, NULL);
TCHAR fontNameBuff[fontNameBuffMaxLength + 1];
BYTE fileNameByteBuff[fileNameBuffMaxByteLength];
for (DWORD dwIndex = 0; ;dwIndex++) {
ZeroMemory(fontNameBuff, sizeof(fontNameBuff));
ZeroMemory(fileNameByteBuff, sizeof(fileNameByteBuff));
DWORD fontNameBuffLength = sizeof(fontNameBuff) / sizeof(TCHAR);
DWORD fileNameBuffByteLength = fileNameBuffMaxByteLength;
LONG result = RegEnumValue(hKey, dwIndex,
fontNameBuff, &fontNameBuffLength,
NULL, NULL,
fileNameByteBuff, &fileNameBuffByteLength);
TCHAR* fileNameBuff = (TCHAR*)fileNameByteBuff;
DWORD fileNameBuffLength = _tcslen(fileNameBuff);
if (result == ERROR_SUCCESS) {
const TCHAR* ext = &(fileNameBuff[fileNameBuffLength - 3]);
if (tolower(ext[0]) == _T('t') &&
tolower(ext[1]) == _T('t') &&
(tolower(ext[2]) == _T('f') ||
tolower(ext[2]) == _T('c'))) {
TCHAR* fontName = fontNameBuff;
const TCHAR* fileName = fileNameBuff;
// A TTF font name must end with ' (TrueType)'.
fontName[fontNameBuffLength - 11] = _T('\0');
for (int i = fileNameBuffLength - 1; 0 <= i; i--) {
if (fileName[i] == _T('\\')) {
fileName += i + 1;
break;
}
}
int length =
WideCharToMultiByte(CP_UTF8, 0,
fontName, -1,
NULL, 0,
NULL, NULL);
char fontNameUTF8[length];
WideCharToMultiByte(CP_UTF8, 0,
fontName, -1,
fontNameUTF8, length,
NULL, NULL);
volatile VALUE rbFontName = rb_str_new2(fontNameUTF8);
length =
WideCharToMultiByte(CP_ACP, 0,
fileName, -1,
NULL, 0,
NULL, NULL);
char fileNameANSI[length];
WideCharToMultiByte(CP_ACP, 0,
fileName, -1,
fileNameANSI, length,
NULL, NULL);
volatile VALUE rbFileName = rb_str_new2(fileNameANSI);
if (strchr(StringValueCStr(rbFontName), '&')) {
volatile VALUE rbArr = rb_str_split(rbFontName, "&");
const int arrLength = RARRAY_LEN(rbArr);
int ttcIndex = 0;
for (int i = 0; i < arrLength; i++) {
volatile VALUE rbFontName = rb_ary_entry(rbArr, i);
rb_funcall(rbFontName, rb_intern("strip!"), 0);
if (0 < RSTRING_LEN(rbFontName)) {
volatile VALUE rbFontNameSymbol = rb_str_intern(rbFontName);
volatile VALUE rbFileNameSymbol = rb_str_intern(rbFileName);
ADD_INFO(currentInfo, rbFontNameSymbol, rbFileNameSymbol,
ttcIndex);
ttcIndex++;
}
}
} else {
volatile VALUE rbFontNameSymbol = rb_str_intern(rbFontName);
volatile VALUE rbFileNameSymbol = rb_str_intern(rbFileName);
ADD_INFO(currentInfo, rbFontNameSymbol, rbFileNameSymbol, -1);
}
}
} else {
break;
}
}
RegCloseKey(hKey);
} else {
rb_raise(strb_GetStarRubyErrorClass(),
"Win32API error: %d", (int)GetLastError());
}
TCHAR szWindowsFontDirPath[MAX_PATH + 1];
if (FAILED(SHGetFolderPath(NULL, CSIDL_FONTS, NULL,
SHGFP_TYPE_CURRENT,
szWindowsFontDirPath))) {
rb_raise(strb_GetStarRubyErrorClass(),
"Win32API error: %d", (int)GetLastError());
}
int length =
WideCharToMultiByte(CP_UTF8, 0,
szWindowsFontDirPath, -1,
NULL, 0,
NULL, NULL);
char szWindowsFontDirPathUTF8[length];
WideCharToMultiByte(CP_UTF8, 0,
szWindowsFontDirPath, -1,
szWindowsFontDirPathUTF8, length,
NULL, NULL);
volatile VALUE rbWindowsFontDirPath = rb_str_new2(szWindowsFontDirPathUTF8);
rbWindowsFontDirPathSymbol = rb_str_intern(rbWindowsFontDirPath);
#endif
}
static VALUE
sym_each_i(VALUE v, void *arg)
{
rb_yield(rb_str_intern(v));
return Qnil;
}
static void
process_arguments_of_image_initialize(int const argc, VALUE* const argv,
VALUE* buffer_ptr,
rb_image_file_image_pixel_format_t* pixel_format_ptr,
long* width_ptr,
long* height_ptr,
long* stride_ptr
)
{
VALUE params;
VALUE buffer = Qnil;
VALUE pixel_format = Qnil;
VALUE width = Qnil;
VALUE height = Qnil;
VALUE stride = Qnil;
rb_image_file_image_pixel_format_t pf;
long wd, ht, st;
long min_len;
ID id_pixel_format, id_data, id_width, id_height, id_row_stride;
CONST_ID(id_data, "data");
CONST_ID(id_pixel_format, "pixel_format");
CONST_ID(id_width, "width");
CONST_ID(id_height, "height");
CONST_ID(id_row_stride, "row_stride");
rb_scan_args(argc, argv, "01", ¶ms);
if (TYPE(params) == T_HASH) {
buffer = rb_hash_lookup(params, ID2SYM(id_data));
pixel_format = rb_hash_lookup(params, ID2SYM(id_pixel_format));
width = rb_hash_lookup(params, ID2SYM(id_width));
height = rb_hash_lookup(params, ID2SYM(id_height));
stride = rb_hash_lookup(params, ID2SYM(id_row_stride));
}
if (!NIL_P(buffer)) {
Check_Type(buffer, T_STRING);
buffer = rb_str_dup(buffer);
}
if (NIL_P(pixel_format))
rb_raise(rb_eArgError, "missing image pixel format");
if (TYPE(pixel_format) == T_STRING)
pixel_format = rb_str_intern(pixel_format);
pf = check_pixel_format(pixel_format);
if (NIL_P(width))
rb_raise(rb_eArgError, "missing image width");
wd = NUM2LONG(width);
if (wd <= 0)
rb_raise(rb_eArgError, "zero or negative image width");
if (NIL_P(height))
rb_raise(rb_eArgError, "missing image height");
ht = NUM2LONG(height);
if (ht <= 0)
rb_raise(rb_eArgError, "zero or negative image height");
if (NIL_P(stride)) {
#ifdef HAVE_RB_CAIRO_H
st = cairo_format_stride_for_width(pixel_format_to_cairo_format(pf), (int)wd) / pixel_format_size(pf);
stride = INT2NUM(st);
#else
stride = width;
#endif
}
st = NUM2LONG(stride);
if (st <= 0)
rb_raise(rb_eArgError, "zero or negative image row-stride");
else if (st < wd) {
rb_warning("the given row-stride is less than the given image width.");
st = wd;
}
min_len = minimum_buffer_size(pf, st, ht);
if (NIL_P(buffer)) {
buffer = rb_str_new(NULL, min_len);
}
else if (RSTRING_LEN(buffer) < min_len) {
void rb_str_modify_expand(VALUE, long);
rb_warning("the size of the given data is too short for the given size of image");
rb_str_modify_expand(buffer, min_len - RSTRING_LEN(buffer));
}
*buffer_ptr = buffer;
*pixel_format_ptr = pf;
*width_ptr = wd;
*height_ptr = ht;
*stride_ptr = st;
}
VALUE string_spec_rb_str_intern(VALUE self, VALUE str) {
return rb_str_intern(str);
}
static VALUE
sym_each_i(RB_BLOCK_CALL_FUNC_ARGLIST(v, arg))
{
rb_yield(rb_str_intern(v));
return Qnil;
}
