/*
* Checks whether a thread is either in the running or sleeping state.
*/
int
is_living_thread(VALUE thread)
{
VALUE status = rb_funcall(thread, rb_intern("status"), 0);
if (NIL_P(status) || status == Qfalse)
return 0;
if (rb_str_cmp(status, rb_str_new2("run")) == 0
|| rb_str_cmp(status, rb_str_new2("sleep")) == 0)
return 1;
return 0;
}
static VALUE
oleclass_from_typelib(VALUE self, ITypeLib *pTypeLib, VALUE oleclass)
{
long count;
int i;
HRESULT hr;
BSTR bstr;
VALUE typelib;
ITypeInfo *pTypeInfo;
VALUE found = Qfalse;
count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
for (i = 0; i < count && found == Qfalse; i++) {
hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
if (FAILED(hr))
continue;
hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
&bstr, NULL, NULL, NULL);
if (FAILED(hr))
continue;
typelib = WC2VSTR(bstr);
if (rb_str_cmp(oleclass, typelib) == 0) {
oletype_set_member(self, pTypeInfo, typelib);
found = Qtrue;
}
OLE_RELEASE(pTypeInfo);
}
return found;
}
/* Callback used to iterate over the HTTP headers and store them in an slist. */
static int each_http_header(VALUE header_key, VALUE header_value, VALUE self) {
struct curl_state *state = get_curl_state(self);
CURL* curl = state->handle;
VALUE name = rb_obj_as_string(header_key);
VALUE value = rb_obj_as_string(header_value);
VALUE header_str = Qnil;
// TODO: see how to combine this with automatic_content_encoding
if (rb_str_cmp(name, rb_str_new2("Accept-Encoding")) == 0) {
if (rb_funcall(value, rb_intern("include?"), 1, rb_str_new2("gzip"))) {
#ifdef CURLOPT_ACCEPT_ENCODING
curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, "gzip");
#elif defined CURLOPT_ENCODING
curl_easy_setopt(curl, CURLOPT_ENCODING, "gzip");
#else
rb_raise(rb_eArgError,
"The libcurl version installed doesn't support 'gzip'.");
#endif
}
}
header_str = rb_str_plus(name, rb_str_new2(": "));
header_str = rb_str_plus(header_str, value);
state->headers = curl_slist_append(state->headers, StringValuePtr(header_str));
return 0;
}
static VALUE
rsym_cmp(VALUE sym, SEL sel, VALUE other)
{
if (TYPE(other) != T_SYMBOL) {
return Qnil;
}
return INT2FIX(rb_str_cmp(RSYM(sym)->str, RSYM(other)->str));
}
static VALUE
typelib_file_from_typelib(VALUE ole)
{
HKEY htypelib, hclsid, hversion, hlang;
double fver;
DWORD i, j, k;
LONG err;
BOOL found = FALSE;
VALUE typelib;
VALUE file = Qnil;
VALUE clsid;
VALUE ver;
VALUE lang;
err = reg_open_key(HKEY_CLASSES_ROOT, "TypeLib", &htypelib);
if(err != ERROR_SUCCESS) {
return Qnil;
}
for(i = 0; !found; i++) {
clsid = reg_enum_key(htypelib, i);
if (clsid == Qnil)
break;
err = reg_open_vkey(htypelib, clsid, &hclsid);
if (err != ERROR_SUCCESS)
continue;
fver = 0;
for(j = 0; !found; j++) {
ver = reg_enum_key(hclsid, j);
if (ver == Qnil)
break;
err = reg_open_vkey(hclsid, ver, &hversion);
if (err != ERROR_SUCCESS || fver > atof(StringValuePtr(ver)))
continue;
fver = atof(StringValuePtr(ver));
typelib = reg_get_val(hversion, NULL);
if (typelib == Qnil)
continue;
if (rb_str_cmp(typelib, ole) == 0) {
for(k = 0; !found; k++) {
lang = reg_enum_key(hversion, k);
if (lang == Qnil)
break;
err = reg_open_vkey(hversion, lang, &hlang);
if (err == ERROR_SUCCESS) {
if ((file = reg_get_typelib_file_path(hlang)) != Qnil)
found = TRUE;
RegCloseKey(hlang);
}
}
}
RegCloseKey(hversion);
}
RegCloseKey(hclsid);
}
RegCloseKey(htypelib);
return file;
}
/*
* call-seq:
* context.suspend -> nil
*
* Suspends the thread when it is running.
*/
static VALUE
Context_suspend(VALUE self)
{
VALUE status;
debug_context_t *context;
Data_Get_Struct(self, debug_context_t, context);
status = rb_funcall(context->thread, rb_intern("status"), 0);
if (rb_str_cmp(status, rb_str_new2("run")) == 0)
CTX_FL_SET(context, CTX_FL_WAS_RUNNING);
else if (rb_str_cmp(status, rb_str_new2("sleep")) == 0)
CTX_FL_UNSET(context, CTX_FL_WAS_RUNNING);
else
return Qnil;
CTX_FL_SET(context, CTX_FL_SUSPEND);
return Qnil;
}
int
classname_cmp(VALUE name, VALUE klass)
{
VALUE mod_name;
VALUE class_name = NIL_P(name) ? rb_str_new2("main") : name;
if (NIL_P(klass))
return 0;
mod_name = rb_mod_name(klass);
return (!NIL_P(mod_name) && rb_str_cmp(class_name, mod_name) == 0);
}
static VALUE
oletypelib_search_registry(VALUE self, VALUE typelib)
{
HKEY htypelib, hguid, hversion;
DWORD i, j;
LONG err;
VALUE found = Qfalse;
VALUE tlib;
VALUE guid;
VALUE ver;
HRESULT hr;
ITypeLib *pTypeLib;
err = reg_open_key(HKEY_CLASSES_ROOT, "TypeLib", &htypelib);
if(err != ERROR_SUCCESS) {
return Qfalse;
}
for(i = 0; !found; i++) {
guid = reg_enum_key(htypelib, i);
if (guid == Qnil)
break;
err = reg_open_vkey(htypelib, guid, &hguid);
if (err != ERROR_SUCCESS)
continue;
for(j = 0; found == Qfalse; j++) {
ver = reg_enum_key(hguid, j);
if (ver == Qnil)
break;
err = reg_open_vkey(hguid, ver, &hversion);
if (err != ERROR_SUCCESS)
continue;
tlib = reg_get_val(hversion, NULL);
if (tlib == Qnil) {
RegCloseKey(hversion);
continue;
}
if (rb_str_cmp(typelib, tlib) == 0) {
hr = oletypelib_from_guid(guid, ver, &pTypeLib);
if (SUCCEEDED(hr)) {
oletypelib_set_member(self, pTypeLib);
found = Qtrue;
}
}
RegCloseKey(hversion);
}
RegCloseKey(hguid);
}
RegCloseKey(htypelib);
return found;
}
static int rb_key_compare(VALUE a, VALUE b) {
if (a == b) return 0;
if (FIXNUM_P(a) && FIXNUM_P(b)) {
long x = FIX2LONG(a), y = FIX2LONG(b);
if (x == y) return 0;
if (x > y) return 1;
return -1;
}
if (TYPE(a) == T_STRING && RBASIC(a)->klass == rb_cString &&
TYPE(b) == T_STRING && RBASIC(b)->klass == rb_cString) {
return rb_str_cmp(a, b);
}
return FIX2INT(rb_funcall((VALUE) a, id_compare_operator, 1, (VALUE) b));
}
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
buffer_equal(VALUE self, VALUE other)
{
VALUE str1, str2;
str1 = buffer_digest(0, 0, self);
str2 = buffer_digest(0, 0, other);
StringValue(str1);
StringValue(str2);
if (RSTRING_LEN(str1) == RSTRING_LEN(str2) &&
rb_str_cmp(str1, str2) == 0) {
return Qtrue;
} else {
return Qfalse;
}
}
static VALUE
close_token_p(pairmatcher_t *pairmatcher, VALUE token)
{
int i;
VALUE type = fragment_type(token);
VALUE text = fragment_text(token);
for (i = 0; i < RARRAY(pairmatcher->pair_defs)->len; i++) {
VALUE def = RARRAY(pairmatcher->pair_defs)->ptr[i];
VALUE close_type = RARRAY(def)->ptr[2];
VALUE close_text = RARRAY(def)->ptr[3];
if (close_type == Qnil || close_type == type) {
if (close_text == Qnil || rb_str_cmp(close_text, text) == 0) {
return def;
}
}
}
return Qfalse;
}
VALUE CRbFont::set_name(VALUE name)
{
SafeStringValue(name);
if (rb_str_cmp(m_name, name) == 0)
return Qnil;
m_name = name;
// 重新创建逻辑字体
wcscpy_s(m_lfw.lfFaceName, Kconv::UTF8ToUnicode(RSTRING_PTR(name)));
if (m_hFont)
{
DeleteObject(m_hFont);
m_hFont = NULL;
}
m_hFont = CreateFontIndirectW(&m_lfw);
return name;
}
/*
* call-seq:
* digest_obj == another_digest_obj -> boolean
* digest_obj == string -> boolean
*
* If a string is given, checks whether it is equal to the hex-encoded
* hash value of the digest object. If another digest instance is
* given, checks whether they have the same hash value. Otherwise
* returns false.
*/
static VALUE
rb_digest_instance_equal(VALUE self, VALUE other)
{
VALUE str1, str2;
if (rb_obj_is_kind_of(other, rb_mDigest_Instance) == Qtrue) {
str1 = rb_digest_instance_digest(0, 0, self);
str2 = rb_digest_instance_digest(0, 0, other);
} else {
str1 = rb_digest_instance_to_s(self);
str2 = other;
}
/* never blindly assume that subclass methods return strings */
StringValue(str1);
StringValue(str2);
if (RSTRING_LEN(str1) == RSTRING_LEN(str2) &&
rb_str_cmp(str1, str2) == 0) {
return Qtrue;
}
return Qfalse;
}
static VALUE
ole_search_event(VALUE ary, VALUE ev, BOOL *is_default)
{
VALUE event;
VALUE def_event;
VALUE event_name;
int i, len;
*is_default = FALSE;
def_event = Qnil;
len = RARRAY_LEN(ary);
for(i = 0; i < len; i++) {
event = rb_ary_entry(ary, i);
event_name = rb_ary_entry(event, 1);
if(NIL_P(event_name)) {
*is_default = TRUE;
def_event = event;
}
else if (rb_str_cmp(ev, event_name) == 0) {
*is_default = FALSE;
return event;
}
}
return def_event;
}
static long
ole_search_event_at(VALUE ary, VALUE ev)
{
VALUE event;
VALUE event_name;
long i, len;
long ret = -1;
len = RARRAY_LEN(ary);
for(i = 0; i < len; i++) {
event = rb_ary_entry(ary, i);
event_name = rb_ary_entry(event, 1);
if(NIL_P(event_name) && NIL_P(ev)) {
ret = i;
break;
}
else if (RB_TYPE_P(ev, T_STRING) &&
RB_TYPE_P(event_name, T_STRING) &&
rb_str_cmp(ev, event_name) == 0) {
ret = i;
break;
}
}
return ret;
}
VALUE string_spec_rb_str_cmp(VALUE self, VALUE str1, VALUE str2) {
return INT2NUM(rb_str_cmp(str1, str2));
}
static VALUE
ole_method_event(ITypeInfo *pTypeInfo, UINT method_index, VALUE method_name)
{
TYPEATTR *pTypeAttr;
HRESULT hr;
WORD i;
int flags;
HREFTYPE href;
ITypeInfo *pRefTypeInfo;
FUNCDESC *pFuncDesc;
BSTR bstr;
VALUE name;
VALUE event = Qfalse;
hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr);
if (FAILED(hr))
return event;
if(pTypeAttr->typekind != TKIND_COCLASS) {
pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
return event;
}
for (i = 0; i < pTypeAttr->cImplTypes; i++) {
hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
if (FAILED(hr))
continue;
if (flags & IMPLTYPEFLAG_FSOURCE) {
hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
i, &href);
if (FAILED(hr))
continue;
hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
href, &pRefTypeInfo);
if (FAILED(hr))
continue;
hr = pRefTypeInfo->lpVtbl->GetFuncDesc(pRefTypeInfo, method_index,
&pFuncDesc);
if (FAILED(hr)) {
OLE_RELEASE(pRefTypeInfo);
continue;
}
hr = pRefTypeInfo->lpVtbl->GetDocumentation(pRefTypeInfo,
pFuncDesc->memid,
&bstr, NULL, NULL, NULL);
if (FAILED(hr)) {
pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
OLE_RELEASE(pRefTypeInfo);
continue;
}
name = WC2VSTR(bstr);
pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
OLE_RELEASE(pRefTypeInfo);
if (rb_str_cmp(method_name, name) == 0) {
event = Qtrue;
break;
}
}
}
OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
return event;
}
VALUE ss_str_cmp(VALUE self, VALUE str1, VALUE str2) {
return INT2NUM(rb_str_cmp(str1, str2));
}
