C++ rb_utf8_encoding函数代码示例

static void DNSSD_API
dnssd_service_query_record_reply(DNSServiceRef client, DNSServiceFlags flags,
    uint32_t interface, DNSServiceErrorType e, const char *fullname,
    uint16_t rrtype, uint16_t rrclass, uint16_t rdlen, const void *rdata,
    uint32_t ttl, void *context) {
  VALUE service, reply, argv[8];

  dnssd_check_error_code(e);

  service = (VALUE)context;

  argv[0] = service;
  argv[1] = ULONG2NUM(flags);
  argv[2] = ULONG2NUM(interface);
  argv[3] = rb_str_new2(fullname);
  rb_enc_associate(argv[3], rb_utf8_encoding());
  argv[4] = UINT2NUM(rrtype);
  argv[5] = UINT2NUM(rrclass);
  argv[6] = rb_str_new((char *)rdata, rdlen);
  rb_enc_associate(argv[6], rb_utf8_encoding());
  argv[7] = ULONG2NUM(ttl);

  reply = rb_class_new_instance(8, argv, cDNSSDReplyQueryRecord);

  dnssd_service_callback(service, reply);
}

static void DNSSD_API
dnssd_service_resolve_reply(DNSServiceRef client, DNSServiceFlags flags,
    uint32_t interface, DNSServiceErrorType e, const char *name,
    const char *target, uint16_t port, uint16_t txt_len,
    const unsigned char *txt_rec, void *context) {
  VALUE service, reply, argv[7];

  dnssd_check_error_code(e);

  service = (VALUE)context;

  argv[0] = service;
  argv[1] = ULONG2NUM(flags);
  argv[2] = ULONG2NUM(interface);
  argv[3] = rb_str_new2(name);
  rb_enc_associate(argv[3], rb_utf8_encoding());
  argv[4] = rb_str_new2(target);
  rb_enc_associate(argv[4], rb_utf8_encoding());
  argv[5] = UINT2NUM(ntohs(port));
  argv[6] = rb_str_new((char *)txt_rec, txt_len);
  rb_enc_associate(argv[6], rb_utf8_encoding());

  reply = rb_class_new_instance(7, argv, cDNSSDReplyResolve);

  dnssd_service_callback(service, reply);
}

void
Init_nkf()
{
    VALUE mNKF = rb_define_module("NKF");

    rb_define_module_function(mNKF, "nkf", rb_nkf_convert, 2);
    rb_define_module_function(mNKF, "guess", rb_nkf_guess, 1);
    rb_define_alias(rb_singleton_class(mNKF), "guess", "guess");

    rb_define_const(mNKF, "AUTO",	Qnil);
    rb_define_const(mNKF, "NOCONV",	Qnil);
    rb_define_const(mNKF, "UNKNOWN",	Qnil);
    rb_define_const(mNKF, "BINARY",	rb_enc_from_encoding(rb_nkf_enc_get("BINARY")));
    rb_define_const(mNKF, "ASCII",	rb_enc_from_encoding(rb_nkf_enc_get("US-ASCII")));
    rb_define_const(mNKF, "JIS",	rb_enc_from_encoding(rb_nkf_enc_get("ISO-2022-JP")));
    rb_define_const(mNKF, "EUC",	rb_enc_from_encoding(rb_nkf_enc_get("EUC-JP")));
    rb_define_const(mNKF, "SJIS",	rb_enc_from_encoding(rb_nkf_enc_get("Shift_JIS")));
    rb_define_const(mNKF, "UTF8",	rb_enc_from_encoding(rb_utf8_encoding()));
    rb_define_const(mNKF, "UTF16",	rb_enc_from_encoding(rb_nkf_enc_get("UTF-16BE")));
    rb_define_const(mNKF, "UTF32",	rb_enc_from_encoding(rb_nkf_enc_get("UTF-32BE")));

    /* Full version string of nkf */
    rb_define_const(mNKF, "VERSION", rb_str_new2(RUBY_NKF_VERSION));
    /* Version of nkf */
    rb_define_const(mNKF, "NKF_VERSION", rb_str_new2(NKF_VERSION));
    /* Release date of nkf */
    rb_define_const(mNKF, "NKF_RELEASE_DATE", rb_str_new2(NKF_RELEASE_DATE));
}

VALUE rugged_signature_new(const git_signature *sig, const char *encoding_name)
{
	VALUE rb_sig, rb_time;
	rb_encoding *encoding = rb_utf8_encoding();

	if (encoding_name != NULL)
		encoding = rb_enc_find(encoding_name);

	rb_sig = rb_hash_new();

	/* Allocate the time with a the given timezone */
	rb_time = rb_funcall(
		rb_time_new(sig->when.time, 0),
		rb_intern("getlocal"), 1,
		INT2FIX(sig->when.offset * 60)
	);

	rb_hash_aset(rb_sig, CSTR2SYM("name"),
		rb_enc_str_new(sig->name, strlen(sig->name), encoding));

	rb_hash_aset(rb_sig, CSTR2SYM("email"),
		rb_enc_str_new(sig->email, strlen(sig->email), encoding));

	rb_hash_aset(rb_sig, CSTR2SYM("time"), rb_time);

	return rb_sig;
}

// Ruby Extension initializer
void Init_streamly_ext() {
  mStreamly = rb_define_module("Streamly");

  cRequest = rb_define_class_under(mStreamly, "Request", rb_cObject);
  rb_define_singleton_method(cRequest, "new", rb_streamly_new, -1);
  rb_define_method(cRequest, "initialize", rb_streamly_init, -1);
  rb_define_method(cRequest, "execute", rb_streamly_execute, -1);

  eStreamlyError = rb_define_class_under(mStreamly, "Error", rb_eStandardError);
  eUnsupportedProtocol = rb_define_class_under(mStreamly, "UnsupportedProtocol", rb_eStandardError);
  eURLFormatError = rb_define_class_under(mStreamly, "URLFormatError", rb_eStandardError);
  eHostResolutionError = rb_define_class_under(mStreamly, "HostResolutionError", rb_eStandardError);
  eConnectionFailed = rb_define_class_under(mStreamly, "ConnectionFailed", rb_eStandardError);
  ePartialFileError = rb_define_class_under(mStreamly, "PartialFileError", rb_eStandardError);
  eTimeoutError = rb_define_class_under(mStreamly, "TimeoutError", rb_eStandardError);
  eTooManyRedirects = rb_define_class_under(mStreamly, "TooManyRedirects", rb_eStandardError);

  sym_method = ID2SYM(rb_intern("method"));
  sym_url = ID2SYM(rb_intern("url"));
  sym_payload = ID2SYM(rb_intern("payload"));
  sym_headers = ID2SYM(rb_intern("headers"));
  sym_head = ID2SYM(rb_intern("head"));
  sym_get = ID2SYM(rb_intern("get"));
  sym_post = ID2SYM(rb_intern("post"));
  sym_put = ID2SYM(rb_intern("put"));
  sym_delete = ID2SYM(rb_intern("delete"));
  sym_username = ID2SYM(rb_intern("username"));
  sym_password = ID2SYM(rb_intern("password"));
  sym_response_header_handler = ID2SYM(rb_intern("response_header_handler"));
  sym_response_body_handler = ID2SYM(rb_intern("response_body_handler"));

#ifdef HAVE_RUBY_ENCODING_H
  utf8Encoding = rb_utf8_encoding();
#endif
}

static VALUE to_utf8(UChar *ustr, int32_t ulen) {
    char buffer[BUF_SIZE];
    int32_t len = 0;
    UErrorCode status = U_ZERO_ERROR;

    /* Figure out the size of the buffer we need to allocate: */
    u_strToUTF8(buffer, 0, &len, ustr, ulen, &status);
    if (status == U_INVALID_CHAR_FOUND)
        len = 0;
    else if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
        return Qnil;

    /* Allocate the buffer and encode into it: */
    status = U_ZERO_ERROR;
    char *ptr = ALLOC_N(char, len);
    u_strToUTF8(ptr, len, &len, ustr, ulen, &status);
    if (U_FAILURE(status)) {
        xfree(ptr);
        return Qnil;
    }

    VALUE str = rb_enc_str_new(ptr, len, rb_utf8_encoding());
    xfree(ptr);
    return str;
;
}

VALUE typecast_detect(const char *data, size_t size, int type) {
    VALUE value;
    char *bytea;
    size_t bytea_len;
    switch (type) {
        case SWIFT_TYPE_INT:
            return rb_cstr2inum(data, 10);
        case SWIFT_TYPE_FLOAT:
            return rb_float_new(atof(data));
        case SWIFT_TYPE_NUMERIC:
            return rb_funcall(cBigDecimal, fnew, 1, rb_str_new(data, size));
        case SWIFT_TYPE_BOOLEAN:
            return (data && (data[0] =='t' || data[0] == '1')) ? Qtrue : Qfalse;
        case SWIFT_TYPE_BLOB:
            bytea = PQunescapeBytea(data, &bytea_len);
            value = rb_str_new(bytea, bytea_len);
            PQfreemem(bytea);
            return rb_funcall(cStringIO, fnew, 1, value);
        case SWIFT_TYPE_TIMESTAMP:
            return datetime_parse(cSwiftDateTime, data, size);
        case SWIFT_TYPE_DATE:
            return date_parse(cSwiftDateTime, data, size);
        default:
            return rb_enc_str_new(data, size, rb_utf8_encoding());
    }
}

static void CheckOSStatusOrRaise(OSStatus err){
  if(err != 0){
    CFStringRef description = SecCopyErrorMessageString(err, NULL);

    CFIndex bufferSize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(description), kCFStringEncodingUTF8);
    char *buffer = malloc(bufferSize + 1);
    CFStringGetCString(description, buffer, bufferSize + 1, kCFStringEncodingUTF8);
    CFRelease(description);

    VALUE exceptionString = rb_enc_str_new(buffer, strlen(buffer), rb_utf8_encoding());
    free(buffer);
    VALUE exception = Qnil;

    switch(err){
      case errSecAuthFailed:
        exception = rb_obj_alloc(rb_eKeychainAuthFailedError);
        break;
      case errSecNoSuchKeychain:
        exception = rb_obj_alloc(rb_eKeychainNoSuchKeychainError);
        break;
      case errSecDuplicateItem:
        exception = rb_obj_alloc(rb_eKeychainDuplicateItemError);
        break;
      default:
        exception = rb_obj_alloc(rb_eKeychainError);
    }
    rb_funcall(exception, rb_intern("initialize"), 2,exceptionString, INT2FIX(err));
    rb_exc_raise(exception);
  }
}

static int yajl_found_hash_key(void * ctx, const unsigned char * stringVal, unsigned int stringLen) {
    yajl_parser_wrapper * wrapper;
    VALUE keyStr;
#ifdef HAVE_RUBY_ENCODING_H
    rb_encoding *default_internal_enc;
#endif
    GetParser((VALUE)ctx, wrapper);
#ifdef HAVE_RUBY_ENCODING_H
    default_internal_enc = rb_default_internal_encoding();
#endif

    if (wrapper->symbolizeKeys) {
        char buf[stringLen+1];
        memcpy(buf, stringVal, stringLen);
        buf[stringLen] = 0;
        VALUE stringEncoded = rb_str_new2(buf);
#ifdef HAVE_RUBY_ENCODING_H
        rb_enc_associate(stringEncoded, rb_utf8_encoding());
#endif

        yajl_set_static_value(ctx, ID2SYM(rb_to_id(stringEncoded)));
    } else {
        keyStr = rb_str_new((const char *)stringVal, stringLen);
#ifdef HAVE_RUBY_ENCODING_H
        rb_enc_associate(keyStr, utf8Encoding);
        if (default_internal_enc) {
          keyStr = rb_str_export_to_enc(keyStr, default_internal_enc);
        }
#endif
        yajl_set_static_value(ctx, keyStr);
    }
    yajl_check_and_fire_callback(ctx);
    return 1;
}

static VALUE rb_mysql_result_fetch_field(VALUE self, unsigned int idx, int symbolize_keys) {
  VALUE rb_field;
  GET_RESULT(self);

  if (wrapper->fields == Qnil) {
    wrapper->numberOfFields = mysql_num_fields(wrapper->result);
    wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
  }

  rb_field = rb_ary_entry(wrapper->fields, idx);
  if (rb_field == Qnil) {
    MYSQL_FIELD *field = NULL;
    rb_encoding *default_internal_enc = rb_default_internal_encoding();
    rb_encoding *conn_enc = rb_to_encoding(wrapper->encoding);

    field = mysql_fetch_field_direct(wrapper->result, idx);
    if (symbolize_keys) {
      rb_field = rb_intern3(field->name, field->name_length, rb_utf8_encoding());
      rb_field = ID2SYM(rb_field);
    } else {
      rb_field = rb_str_new(field->name, field->name_length);
      rb_enc_associate(rb_field, conn_enc);
      if (default_internal_enc) {
        rb_field = rb_str_export_to_enc(rb_field, default_internal_enc);
      }
    }
    rb_ary_store(wrapper->fields, idx, rb_field);
  }

  return rb_field;
}

static VALUE transcode_string(VALUE src, int * parser_encoding)
{
    int utf8    = rb_utf8_encindex();
    int utf16le = rb_enc_find_index("UTF16_LE");
    int utf16be = rb_enc_find_index("UTF16_BE");
    int source_encoding = rb_enc_get_index(src);

    if (source_encoding == utf8) {
	*parser_encoding = YAML_UTF8_ENCODING;
	return src;
    }

    if (source_encoding == utf16le) {
	*parser_encoding = YAML_UTF16LE_ENCODING;
	return src;
    }

    if (source_encoding == utf16be) {
	*parser_encoding = YAML_UTF16BE_ENCODING;
	return src;
    }

    src = rb_str_export_to_enc(src, rb_utf8_encoding());
    RB_GC_GUARD(src);

    *parser_encoding = YAML_UTF8_ENCODING;
    return src;
}

static inline VALUE
get_user_from_path(wchar_t **wpath, int offset, UINT cp, UINT path_cp, rb_encoding *path_encoding)
{
    VALUE result, tmp;
    wchar_t *wuser = *wpath + offset;
    wchar_t *pos = wuser;
    char *user;
    size_t size;

    while (!IS_DIR_SEPARATOR_P(*pos) && *pos != '\0')
     pos++;

    *pos = '\0';
    convert_wchar_to_mb(wuser, &user, &size, cp);

    /* convert to VALUE and set the path encoding */
    if (path_cp == INVALID_CODE_PAGE) {
	tmp = rb_enc_str_new(user, size, rb_utf8_encoding());
	result = rb_str_encode(tmp, rb_enc_from_encoding(path_encoding), 0, Qnil);
	rb_str_resize(tmp, 0);
    }
    else {
	result = rb_enc_str_new(user, size, path_encoding);
    }

    if (user)
	xfree(user);

    return result;
}

/*
 *  call-seq:
 *    commit.header_field(field_name) -> str
 *
 *  Returns +commit+'s header field value.
 */
static VALUE rb_git_commit_header_field(VALUE self, VALUE rb_field)
{
	git_buf header_field = { 0 };
	git_commit *commit = NULL;

	const char *encoding_name;
	rb_encoding *encoding = rb_utf8_encoding();
	VALUE rb_result;

	int error;

	Check_Type(rb_field, T_STRING);
	Data_Get_Struct(self, git_commit, commit);

	error = git_commit_header_field(&header_field, commit, StringValueCStr(rb_field));

	if (error < 0) {
		git_buf_free(&header_field);
		if (error == GIT_ENOTFOUND)
			return Qnil;
		rugged_exception_check(error);
	}

	encoding_name = git_commit_message_encoding(commit);
	if (encoding_name != NULL)
		encoding = rb_enc_find(encoding_name);

	rb_result = rb_enc_str_new(header_field.ptr, header_field.size, encoding);
	git_buf_free(&header_field);
	return rb_result;
}

static VALUE decode(VALUE self, VALUE str)
{
  int rc;
  punycode_uint *ustr;
  size_t len;
  char *buf = NULL;
  VALUE retv;

  str = rb_check_convert_type(str, T_STRING, "String", "to_s");

  len = RSTRING_LEN(str);
  ustr = malloc(len * sizeof(punycode_uint));

  if (ustr == NULL) {
    rb_raise(rb_eNoMemError, "cannot allocate memory (%d bytes)", (uint32_t)len);
    return Qnil;
  }

  rc = punycode_decode(RSTRING_LEN(str), RSTRING_PTR(str),
                       &len, ustr, NULL);

  if (rc != PUNYCODE_SUCCESS) {
    xfree(ustr);
    rb_raise(ePunycodeError, "%s (%d)", punycode_strerror(rc), rc);
    return Qnil;
  }

  buf = stringprep_ucs4_to_utf8(ustr, len, NULL, &len);
  retv = rb_enc_str_new(buf, len, rb_utf8_encoding());
  xfree(ustr);
  xfree(buf);
  return retv;
}

VALUE wrap< wxString >(const wxString &st )
{
#ifdef HAVE_RUBY_ENCODING_H
	return rb_enc_str_new(st.c_str(),strlen(st.c_str()),rb_utf8_encoding());
#else
	return rb_str_new2(st.c_str());
#endif
}