static VALUE check_app_file_exist(VALUE dir, VALUE fname1, const char* szPlatform)
{
VALUE res = rb_str_dup(dir);
//RAWLOG_INFO1("find_file: check dir %s", RSTRING_PTR(dir));
#ifdef __SYMBIAN32__
if(*RSTRING_PTR(res) == '/')
res = rb_str_substr(res,1,RSTRING_LEN(res) - 1);
#endif
rb_str_cat(res,"/",1);
rb_str_cat(res,RSTRING_PTR(fname1),RSTRING_LEN(fname1));
if (szPlatform)
{
rb_str_cat(res,".",1);
rb_str_cat(res,szPlatform,strlen(szPlatform));
}
rb_str_cat(res,RHO_RB_EXT,strlen(RHO_RB_EXT));
//RAWLOG_INFO1("find_file: check file: %s", RSTRING_PTR(res));
return eaccess(RSTRING_PTR(res), R_OK) == 0 ? res : 0;
}
static VALUE
range_to_s(VALUE range)
{
VALUE str, str2;
str = rb_obj_as_string(RANGE_BEG(range));
str2 = rb_obj_as_string(RANGE_END(range));
str = rb_str_dup(str);
rb_str_cat(str, "...", EXCL(range) ? 3 : 2);
rb_str_append(str, str2);
OBJ_INFECT(str, str2);
return str;
}
static void _concat_char(VALUE s, char c, bool ispath) {
static char buf[3] = {'%', 0, 0};
static char plus[1] = {'+'};
if (ispath) {
if (_should_escape(c) && c != '+' && c != '/') {
buf[1] = _hex_char((unsigned char)c / 16);
buf[2] = _hex_char((unsigned char)c % 16);
rb_str_cat(s, buf, 3);
} else {
rb_str_cat(s, &c, 1);
}
} else {
if (c == ' ') {
rb_str_cat(s, plus, 1);
} else if (_should_escape(c)) {
buf[1] = _hex_char((unsigned char)c / 16);
buf[2] = _hex_char((unsigned char)c % 16);
rb_str_cat(s, buf, 3);
} else {
rb_str_cat(s, &c, 1);
}
}
}
/**
* Convert the Ruby integer into a BSON as per the 64 bit specification,
* which is 8 bytes.
*
* @example Convert the integer to 64bit BSON.
* rb_integer_to_bson_int64(128, encoded);
*
* @param [ Integer ] self The Ruby integer.
* @param [ String ] encoded The Ruby binary string to append to.
*
* @return [ String ] encoded Ruby binary string with BSON raw bytes appended.
*
* @since 2.0.0
*/
static VALUE rb_integer_to_bson_int64(VALUE self, VALUE encoded)
{
const int64_t v = NUM2INT64(self);
const char bytes[8] = {
v & 255,
(v >> 8) & 255,
(v >> 16) & 255,
(v >> 24) & 255,
(v >> 32) & 255,
(v >> 40) & 255,
(v >> 48) & 255,
(v >> 56) & 255
};
return rb_str_cat(encoded, bytes, 8);
}
static int on_header_value(http_parser* parser, const char* s, size_t len) {
Request* p = (Request*)parser;
if (p->last_field == Qnil) {
if (p->last_value == Qnil) {
p->parse_state = PS_ERROR;
return 1;
}
rb_str_cat(p->last_value, s, len);
} else {
nyara_headerlize(p->last_field);
p->last_value = rb_enc_str_new(s, len, u8_encoding);
rb_hash_aset(p->header, p->last_field, p->last_value);
p->last_field = Qnil;
}
return 0;
}
static VALUE
inspect_range(VALUE range, VALUE dummy, int recur)
{
VALUE str, str2;
if (recur) {
return rb_str_new2(EXCL(range) ? "(... ... ...)" : "(... .. ...)");
}
str = rb_inspect(RANGE_BEG(range));
str2 = rb_inspect(RANGE_END(range));
str = rb_str_dup(str);
rb_str_cat(str, "...", EXCL(range) ? 3 : 2);
rb_str_append(str, str2);
OBJ_INFECT(str, str2);
return str;
}
int on_header_value(ryah_http_parser *parser, const char *at, size_t length) {
GET_WRAPPER(wrapper, parser);
if (wrapper->last_field_name == Qnil) {
wrapper->last_field_name = rb_str_new(wrapper->last_field_name_at, wrapper->last_field_name_length);
VALUE val = rb_hash_aref(wrapper->headers, wrapper->last_field_name);
if (val != Qnil) {
rb_str_cat(val, ", ", 2);
}
wrapper->last_field_name_at = NULL;
wrapper->last_field_name_length = 0;
}
HASH_CAT(wrapper->headers, wrapper->last_field_name, at, length);
return 0;
}
VALUE grpc_rb_byte_buffer_to_s(grpc_byte_buffer *buffer) {
VALUE rb_string;
grpc_byte_buffer_reader reader;
grpc_slice next;
if (buffer == NULL) {
return Qnil;
}
rb_string = rb_str_buf_new(grpc_byte_buffer_length(buffer));
if (!grpc_byte_buffer_reader_init(&reader, buffer)) {
rb_raise(rb_eRuntimeError, "Error initializing byte buffer reader.");
return Qnil;
}
while (grpc_byte_buffer_reader_next(&reader, &next) != 0) {
rb_str_cat(rb_string, (const char *) GRPC_SLICE_START_PTR(next),
GRPC_SLICE_LENGTH(next));
grpc_slice_unref(next);
}
grpc_byte_buffer_reader_destroy(&reader);
return rb_string;
}
VALUE
rb_id2str(ID id)
{
LOCK();
VALUE sym = (VALUE)CFDictionaryGetValue(id_str, (const void *)id);
UNLOCK();
if (sym != 0) {
//printf("lookup %ld -> %s\n", id, rb_sym2name(sym));
return sym;
}
if (is_attrset_id(id)) {
// Attribute assignment.
ID id2 = (id & ~ID_SCOPE_MASK) | ID_LOCAL;
while ((sym = rb_id2str(id2)) == 0) {
if (!is_local_id(id2)) {
//printf("lookup %ld -> FAIL\n", id);
return 0;
}
id2 = (id & ~ID_SCOPE_MASK) | ID_CONST;
}
VALUE str = rb_str_dup(RSYM(sym)->str);
rb_str_cat(str, "=", 1);
rb_intern_str(str);
// Retry one more time.
LOCK();
sym = (VALUE)CFDictionaryGetValue(id_str, (const void *)id);
UNLOCK();
if (sym != 0) {
//printf("lookup %ld -> %s\n", id, rb_sym2name(sym));
return sym;
}
}
//printf("lookup %ld -> FAIL\n", id);
return 0;
}
static VALUE fcgi_stream_read(int argc, VALUE *argv, VALUE self)
{
VALUE num,str;
FCGX_Stream *stream;
char *buff;
int n;
if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
}
Data_Get_Struct(self, FCGX_Stream, stream);
if (argc==0) {
buff = ALLOC_N(char, 16384);
n = FCGX_GetStr(buff, 16384, stream);
CHECK_STREAM_ERROR(stream);
if (n == 0) {
free(buff);
return Qnil;
}
str = rb_str_new(buff, n);
OBJ_TAINT(str);
while(!FCGX_HasSeenEOF(stream)) {
n = FCGX_GetStr(buff, 16384, stream);
CHECK_STREAM_ERROR(stream);
if (n > 0) {
rb_str_cat(str, buff, n);
} else {
free(buff);
return Qnil;
}
}
free(buff);
return str;
}
VALUE CRbWin32API::initialize(int argc, VALUE * argv, VALUE obj)
{
VALUE dllname, proc, _import, _export;
rb_scan_args(argc, argv, "4", &dllname, &proc, &_import, &_export);
SafeStringValue(dllname);
SafeStringValue(proc);
m_hDll = LoadLibraryA(RSTRING_PTR(dllname));
if (!m_hDll)
rb_raise(rb_eSinError, "LoadLibrary: %s\n", RSTRING_PTR(dllname));
HANDLE hproc = (HANDLE)GetProcAddress(m_hDll, RSTRING_PTR(proc));
if (!hproc)
{
VALUE str = rb_str_new3(proc); str = rb_str_cat(str, "A", 1);
hproc = (HANDLE)GetProcAddress(m_hDll, RSTRING_PTR(str));
if (!hproc)
{
rb_raise(rb_eSinError, "GetProcAddress: %s or %s\n", RSTRING_PTR(proc), RSTRING_PTR(str));
}
}
rb_iv_set(obj, "__dll__", rb_uint2inum((u32)m_hDll));
rb_iv_set(obj, "__dllname__", dllname);
rb_iv_set(obj, "__proc__", rb_uint2inum((u32)hproc));
VALUE ary_import = SinParseImportArgs(_import);
if (16 < RARRAY_LEN(ary_import))
{
rb_raise(rb_eSinError, "too many parameters: %ld\n", RARRAY_LEN(ary_import));
}
rb_iv_set(obj, "__import__", ary_import);
rb_iv_set(obj, "__export__", INT2FIX(SinParseExportArgs(_export)));
return obj;
}
VALUE Parser_execute(VALUE self, VALUE data) {
ParserWrapper *wrapper = NULL;
Check_Type(data, T_STRING);
char *ptr = RSTRING_PTR(data);
long len = RSTRING_LEN(data);
DATA_GET(self, ParserWrapper, wrapper);
wrapper->stopped = Qfalse;
size_t nparsed = ryah_http_parser_execute(&wrapper->parser, &settings, ptr, len);
if (wrapper->parser.upgrade) {
rb_str_cat(wrapper->upgrade_data, ptr + nparsed + 1, len - nparsed - 1);
} else if (nparsed != (size_t)len) {
if (!RTEST(wrapper->stopped) && !RTEST(wrapper->completed))
rb_raise(eParserError, "Could not parse data entirely");
else
nparsed += 1; // error states fail on the current character
}
return INT2FIX(nparsed);
}
/**
* Encode a true value to bson.
*
* @example Encode the true value.
* rb_true_class_to_bson(0, true);
*
* @param [ int ] argc The number or arguments.
* @param [ Array<Object> ] argv The arguments.
* @param [ TrueClass ] self The true value.
*
* @return [ String ] The encoded string.
*
* @since 2.0.0
*/
static VALUE rb_true_class_to_bson(int argc, VALUE *argv, VALUE self)
{
VALUE encoded = rb_get_default_encoded(argc, argv);
rb_str_cat(encoded, &rb_bson_true_byte, 1);
return encoded;
}
/**
* Convert the ruby string to a BSON string.
*
* @example Convert the Ruby string to a BSON string.
* rb_string_to_bson_string(0, Qnil, "test");
*
* @param [ String ] self The string value.
* @param [ String ] encoded The encoded string to append to.
*
* @return [ String ] The encoded string.
*
* @since 2.0.0
*/
static VALUE rb_string_to_bson_string(VALUE self, VALUE encoded)
{
const VALUE binary = rb_bson_to_utf8_binary(self);
rb_str_cat(encoded, RSTRING_PTR(binary), RSTRING_LEN(binary));
return encoded;
}
/*RHO static*/ VALUE
eval_string_with_cref(VALUE self, VALUE src, VALUE scope, NODE *cref, const char *file, int line)
{
int state;
VALUE result = Qundef;
VALUE envval;
rb_binding_t *bind = 0;
rb_thread_t *th = GET_THREAD();
rb_env_t *env = NULL;
rb_block_t block;
volatile int parse_in_eval;
volatile int mild_compile_error;
if (file == 0) {
file = rb_sourcefile();
line = rb_sourceline();
}
parse_in_eval = th->parse_in_eval;
mild_compile_error = th->mild_compile_error;
PUSH_TAG();
if ((state = EXEC_TAG()) == 0) {
rb_iseq_t *iseq;
volatile VALUE iseqval;
if (scope != Qnil) {
if (rb_obj_is_kind_of(scope, rb_cBinding)) {
GetBindingPtr(scope, bind);
envval = bind->env;
}
else {
rb_raise(rb_eTypeError,
"wrong argument type %s (expected Binding)",
rb_obj_classname(scope));
}
GetEnvPtr(envval, env);
th->base_block = &env->block;
}
else {
rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(th, th->cfp);
if (cfp != 0) {
block = *RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp);
th->base_block = █
th->base_block->self = self;
th->base_block->iseq = cfp->iseq; /* TODO */
}
else {
rb_raise(rb_eRuntimeError, "Can't eval on top of Fiber or Thread");
}
}
//RHO
if ( TYPE(src) != T_STRING ){
iseqval = src;
}else
//RHO
{
/* make eval iseq */
th->parse_in_eval++;
th->mild_compile_error++;
iseqval = rb_iseq_compile(src, rb_str_new2(file), INT2FIX(line));
th->mild_compile_error--;
th->parse_in_eval--;
}
vm_set_eval_stack(th, iseqval, cref);
th->base_block = 0;
if (0) { /* for debug */
printf("%s\n", RSTRING_PTR(rb_iseq_disasm(iseqval)));
}
/* save new env */
GetISeqPtr(iseqval, iseq);
if (bind && iseq->local_size > 0) {
bind->env = rb_vm_make_env_object(th, th->cfp);
}
/* kick */
CHECK_STACK_OVERFLOW(th->cfp, iseq->stack_max);
result = vm_exec(th);
}
POP_TAG();
th->mild_compile_error = mild_compile_error;
th->parse_in_eval = parse_in_eval;
if (state) {
if (state == TAG_RAISE) {
VALUE errinfo = th->errinfo;
if (strcmp(file, "(eval)") == 0) {
VALUE mesg, errat, bt2;
extern VALUE rb_get_backtrace(VALUE info);
ID id_mesg;
CONST_ID(id_mesg, "mesg");
errat = rb_get_backtrace(errinfo);
mesg = rb_attr_get(errinfo, id_mesg);
if (!NIL_P(errat) && TYPE(errat) == T_ARRAY &&
(bt2 = vm_backtrace(th, -2), RARRAY_LEN(bt2) > 0)) {
if (!NIL_P(mesg) && TYPE(mesg) == T_STRING && !RSTRING_LEN(mesg)) {
if (OBJ_FROZEN(mesg)) {
VALUE m = rb_str_cat(rb_str_dup(RARRAY_PTR(errat)[0]), ": ", 2);
rb_ivar_set(errinfo, id_mesg, rb_str_append(m, mesg));
}
else {
rb_str_update(mesg, 0, 0, rb_str_new2(": "));
rb_str_update(mesg, 0, 0, RARRAY_PTR(errat)[0]);
}
}
RARRAY_PTR(errat)[0] = RARRAY_PTR(bt2)[0];
}
}
rb_exc_raise(errinfo);
}
JUMP_TAG(state);
}
return result;
}
/*
* call-seq:
* Win32::API.new(function, prototype='V', return='L', dll='kernel32')
*
* Creates and returns a new Win32::API object. The +function+ is the name
* of the Windows function.
*
* The +prototype+ is the function prototype for +function+. This can be a
* string or an array of characters. The possible valid characters are 'I'
* (integer), 'L' (long), 'V' (void), 'P' (pointer), 'K' (callback) or 'S'
* (string).
*
* The default is void ('V').
*
* Constant (const char*) strings should use 'S'. Pass by reference string
* buffers should use 'P'. The former is faster, but cannot be modified.
*
* The +return+ argument is the return type for the function. The valid
* characters are the same as for the +prototype+. The default is 'L' (long).
*
* The +dll+ is the name of the DLL file that the function is exported from.
* The default is 'kernel32'.
*
* If the function cannot be found then an API::Error is raised (a subclass
* of RuntimeError).
*
* Example:
*
* require 'win32/api'
* include Win32
*
* buf = 0.chr * 260
* len = [buf.length].pack('L')
*
* GetUserName = API.new('GetUserName', 'PP', 'I', 'advapi32')
* GetUserName.call(buf, len)
*
* puts buf.strip
*/
static VALUE api_init(int argc, VALUE* argv, VALUE self)
{
HMODULE hLibrary;
FARPROC fProc;
Win32API* ptr;
int i;
char* first = "A";
char* second = "W";
VALUE v_proc, v_proto, v_return, v_dll;
rb_scan_args(argc, argv, "13", &v_proc, &v_proto, &v_return, &v_dll);
Data_Get_Struct(self, Win32API, ptr);
// Convert a string prototype to an array of characters
if(rb_respond_to(v_proto, rb_intern("split")))
v_proto = rb_str_split(v_proto, "");
// Convert a nil or empty prototype to 'V' (void) automatically
if(NIL_P(v_proto) || RARRAY_LEN(v_proto) == 0){
v_proto = rb_ary_new();
rb_ary_push(v_proto, rb_str_new2("V"));
}
// Set an arbitrary limit of 20 parameters
if(20 < RARRAY_LEN(v_proto))
rb_raise(rb_eArgError, "too many parameters: %d\n", RARRAY_LEN(v_proto));
// Set the default dll to 'kernel32'
if(NIL_P(v_dll))
v_dll = rb_str_new2("kernel32");
// Set the default return type to 'L' (DWORD)
if(NIL_P(v_return))
v_return = rb_str_new2("L");
SafeStringValue(v_dll);
SafeStringValue(v_proc);
hLibrary = LoadLibrary(TEXT(RSTRING_PTR(v_dll)));
// The most likely cause of failure is a bad DLL load path
if(!hLibrary){
rb_raise(cAPILoadError, "LoadLibrary() function failed for '%s': %s",
RSTRING_PTR(v_dll),
StringError(GetLastError())
);
}
ptr->library = hLibrary;
/* Attempt to get the function. If it fails, try again with an 'A'
* appended. If that fails, try again with a 'W' appended. If that
* still fails, raise an API::LoadLibraryError.
*/
fProc = GetProcAddress(hLibrary, TEXT(RSTRING_PTR(v_proc)));
// Skip the ANSI and Wide function checks for MSVCRT functions.
if(!fProc){
if(strstr(RSTRING_PTR(v_dll), "msvcr")){
rb_raise(
cAPILoadError,
"Unable to load function '%s'",
RSTRING_PTR(v_proc)
);
}
else{
VALUE v_ascii = rb_str_new3(v_proc);
v_ascii = rb_str_cat(v_ascii, first, 1);
fProc = GetProcAddress(hLibrary, TEXT(RSTRING_PTR(v_ascii)));
if(!fProc){
VALUE v_unicode = rb_str_new3(v_proc);
v_unicode = rb_str_cat(v_unicode, second, 1);
fProc = GetProcAddress(hLibrary, TEXT(RSTRING_PTR(v_unicode)));
if(!fProc){
rb_raise(
cAPILoadError,
"Unable to load function '%s', '%s', or '%s'",
RSTRING_PTR(v_proc),
RSTRING_PTR(v_ascii),
RSTRING_PTR(v_unicode)
);
}
else{
rb_iv_set(self, "@effective_function_name", v_unicode);
}
}
else{
rb_iv_set(self, "@effective_function_name", v_ascii);
}
}
}
else{
rb_iv_set(self, "@effective_function_name", v_proc);
}
ptr->function = fProc;
// Push the numeric prototypes onto our int array for later use.
for(i = 0; i < RARRAY_LEN(v_proto); i++){
SafeStringValue(RARRAY_PTR(v_proto)[i]);
switch(*(char*)StringValuePtr(RARRAY_PTR(v_proto)[i])){
case 'L':
ptr->prototype[i] = _T_LONG;
break;
case 'P':
ptr->prototype[i] = _T_POINTER;
break;
case 'I': case 'B':
ptr->prototype[i] = _T_INTEGER;
break;
case 'V':
ptr->prototype[i] = _T_VOID;
break;
case 'K':
ptr->prototype[i] = _T_CALLBACK;
break;
case 'S':
ptr->prototype[i] = _T_STRING;
break;
default:
rb_raise(cAPIProtoError, "Illegal prototype '%s'",
StringValuePtr(RARRAY_PTR(v_proto)[i])
);
}
}
// Store the return type for later use.
// Automatically convert empty strings or nil to type void.
if(NIL_P(v_return) || RSTRING_LEN(v_return) == 0){
v_return = rb_str_new2("V");
ptr->return_type = _T_VOID;
}
else{
SafeStringValue(v_return);
switch(*RSTRING_PTR(v_return)){
case 'L':
ptr->return_type = _T_LONG;
break;
case 'P':
ptr->return_type = _T_POINTER;
break;
case 'I': case 'B':
ptr->return_type = _T_INTEGER;
break;
case 'V':
ptr->return_type = _T_VOID;
break;
case 'S':
ptr->return_type = _T_STRING;
break;
default:
rb_raise(cAPIProtoError, "Illegal return type '%s'",
RSTRING_PTR(v_return)
);
}
}
rb_iv_set(self, "@dll_name", v_dll);
rb_iv_set(self, "@function_name", v_proc);
rb_iv_set(self, "@prototype", v_proto);
rb_iv_set(self, "@return_type", v_return);
return self;
}
{
if (post_readline_pos >= post_readline_watermark)
{
post_readline_pos = post_readline_watermark = U_NULLPTR; // all the readline buffer has been consumed
U_RETURN(Qnil);
}
U_INTERNAL_DUMP("hint = %ld", NUM2LONG(RARRAY_PTR(args)[0]))
}
if (post_readline_pos < post_readline_watermark)
{
// If buffer is given, then the read data will be placed into buffer instead of a newly created String object
VALUE result = (RARRAY_LEN(args) > 1 ? rb_str_cat(RARRAY_PTR(args)[1], post_readline_pos, post_readline_watermark - post_readline_pos)
: rb_str_new( post_readline_pos, post_readline_watermark - post_readline_pos));
post_readline_pos = post_readline_watermark = U_NULLPTR; // all the readline buffer has been consumed
U_RETURN(result);
}
U_RETURN(Qnil);
}
static VALUE URUBY_io_gets(VALUE obj, VALUE args)
{
U_TRACE(0, "URUBY_io_gets(%llu,%llu)", obj, args)
U_INTERNAL_DUMP("post_readline_pos = %p post_readline_watermark = %p", post_readline_pos, post_readline_watermark)
static VALUE
optimized_unescape(VALUE str, VALUE encoding)
{
long i, len, beg = 0;
VALUE dest = 0;
const char *cstr;
int cr, origenc, encidx = rb_to_encoding_index(encoding);
len = RSTRING_LEN(str);
cstr = RSTRING_PTR(str);
for (i = 0; i < len; ++i) {
char buf[1];
const char c = cstr[i];
int clen = 0;
if (c == '%') {
if (i + 3 > len) break;
if (!ISXDIGIT(cstr[i+1])) continue;
if (!ISXDIGIT(cstr[i+2])) continue;
buf[0] = ((char_to_number(cstr[i+1]) << 4)
| char_to_number(cstr[i+2]));
clen = 2;
}
else if (c == '+') {
buf[0] = ' ';
}
else {
continue;
}
if (!dest) {
dest = rb_str_buf_new(len);
}
rb_str_cat(dest, cstr + beg, i - beg);
i += clen;
beg = i + 1;
rb_str_cat(dest, buf, 1);
}
if (dest) {
rb_str_cat(dest, cstr + beg, len - beg);
preserve_original_state(str, dest);
cr = ENC_CODERANGE_UNKNOWN;
}
else {
dest = rb_str_dup(str);
cr = ENC_CODERANGE(str);
}
origenc = rb_enc_get_index(str);
if (origenc != encidx) {
rb_enc_associate_index(dest, encidx);
if (!ENC_CODERANGE_CLEAN_P(rb_enc_str_coderange(dest))) {
rb_enc_associate_index(dest, origenc);
if (cr != ENC_CODERANGE_UNKNOWN)
ENC_CODERANGE_SET(dest, cr);
}
}
return dest;
}
static VALUE defout_write(VALUE self, VALUE str)
{
str = rb_obj_as_string(str);
rb_str_cat(self, RSTRING_PTR(str), RSTRING_LEN(str));
return Qnil;
}
int on_query_string(ryah_http_parser *parser, const char *at, size_t length) {
GET_WRAPPER(wrapper, parser);
rb_str_cat(wrapper->query_string, at, length);
return 0;
}
VALUE require_compiled(VALUE fname, VALUE* result, int bLoad)
{
VALUE path;
char* szName1 = 0;
VALUE retval = Qtrue;
if (TYPE(fname) != T_STRING)
rb_raise(rb_eLoadError, "can not load non-string");
szName1 = RSTRING_PTR(fname);
if ( String_endsWith(szName1,".rb") )
{
rb_str_chop_bang(fname); rb_str_chop_bang(fname); rb_str_chop_bang(fname);
}
//rb_funcall(fname, rb_intern("sub!"), 2, rb_str_new2(".rb"), rb_str_new2("") );
szName1 = RSTRING_PTR(fname);
if ( strcmp("strscan",szName1)==0 || strcmp("enumerator",szName1)==0 ||
strcmp("stringio",szName1)==0 || strcmp("socket",szName1)==0 )
return Qtrue;
RHO_LOCK(require_lock);
if ( !bLoad && isAlreadyLoaded(fname) == Qtrue )
goto RCompExit;
path = find_file(fname);
if ( path != 0 )
{
VALUE seq;
RAWLOG_INFO1("require_compiled: %s", szName1);
//optimize require
//rb_ary_push(GET_VM()->loaded_features, path);
rb_ary_push(GET_VM()->loaded_features, fname);
#ifdef RHODES_EMULATOR
if ( strstr( RSTRING_PTR(path), ".rb") == 0 )
rb_str_cat(path,".rb",3);
GET_VM()->src_encoding_index = rb_utf8_encindex();
rb_load(path, 0);
if( rho_simconf_getBool("reload_app_changes") )
{
if ( strncmp( RSTRING_PTR(path), rho_native_rhopath(), strlen(rho_native_rhopath()) ) == 0 )
rb_ary_delete(GET_VM()->loaded_features, fname);
}
#else
//rb_gc_disable();
seq = loadISeqFromFile(path);
//*result = rb_funcall(seq, rb_intern("eval"), 0 );
*result = rb_iseq_eval(seq);
//rb_gc_enable();
#endif
goto RCompExit;
}
RAWLOG_ERROR1("require_compiled: error: can not find %s", RSTRING_PTR(fname));
retval = Qnil;
RCompExit:
RHO_UNLOCK(require_lock);
return retval;
}
static VALUE find_file(VALUE fname)
{
VALUE res = 0;
int nOK = 0;
//RAWLOG_INFO1("find_file: fname: %s", RSTRING_PTR(fname));
#ifdef RHODES_EMULATOR
if ( strncmp(RSTRING_PTR(fname), rho_simconf_getRhodesPath(), strlen(rho_simconf_getRhodesPath())) == 0 )
res = fname;
else
#endif
if ( strncmp(RSTRING_PTR(fname), rho_native_rhopath(), strlen(rho_native_rhopath())) == 0 ){
res = rb_str_dup(fname);
rb_str_cat(res,RHO_RB_EXT,strlen(RHO_RB_EXT));
//RAWLOG_INFO1("find_file: res: %s", RSTRING_PTR(res));
} else if ( strncmp(RSTRING_PTR(fname), rho_native_reruntimepath(), strlen(rho_native_reruntimepath())) == 0 ){
res = rb_str_dup(fname);
rb_str_cat(res,RHO_RB_EXT,strlen(RHO_RB_EXT));
//RAWLOG_INFO1("find_file: res: %s", RSTRING_PTR(res));
}else{
int i = 0;
VALUE load_path = GET_VM()->load_path;
//VALUE dir;
VALUE fname1 = checkRhoBundleInPath(fname);
//RAWLOG_INFO1("find_file: fname after checkRhoBundleInPath: %s", RSTRING_PTR(fname));
//TODO: support document relative require in case of multiple apps
if (RARRAY_LEN(load_path)>1){
for( ; i < RARRAY_LEN(load_path); i++ ){
VALUE dir = RARRAY_PTR(load_path)[i];
#ifdef RHODES_EMULATOR
res = check_app_file_exist(dir, fname1, rho_simconf_getString("platform"));
#endif
if ( !res )
res = check_app_file_exist(dir, fname1, 0 );
if (res)
{
nOK = 1;
break;
}
}
if ( !nOK )
{
#ifdef RHODES_EMULATOR
//check for extensions
/* res = rb_str_new2(rho_simconf_getRhodesPath() );
rb_str_cat2(res,"/lib/extensions/");
res = check_extension(res, fname, 1);
if ( !res )
{
res = rb_str_new2(rho_native_rhopath() );
rb_str_cat2(res,"/extensions/");
res = check_extension(res, fname,1);
}
if ( !res )
{
res = rb_str_new2( rho_simconf_getString("ext_path") );
res = check_extension(res, fname, 0);
}
*/
const char* szPaths = rho_simconf_getString("ext_path");
const char* szPath = szPaths;
const char* szSep = strchr(szPath, ';');
res = 0;
for( ; szSep; szSep = strchr(szPath, ';') )
{
res = rb_str_new( szPath, szSep-szPath);
rb_str_cat2(res,"/");
rb_str_append(res,fname);
rb_str_cat2(res,RHO_RB_EXT);
if ( eaccess(RSTRING_PTR(res), R_OK) == 0 )
break;
res = rb_str_new( szPath, szSep-szPath);
rb_str_cat2(res,"/app/");
rb_str_append(res,fname);
rb_str_cat2(res,RHO_RB_EXT);
if ( eaccess(RSTRING_PTR(res), R_OK) == 0 )
break;
res = 0;
szPath = szSep+1;
}
if( res )
nOK = 1;
else
return 0;
#else
return 0;
#endif
}
} /*else {
dir = RARRAY_PTR(load_path)[RARRAY_LEN(load_path)-1];
res = rb_str_dup(dir);
rb_str_cat(res,"/",1);
rb_str_cat(res,RSTRING_PTR(fname),RSTRING_LEN(fname));
rb_str_cat(res,RHO_RB_EXT,strlen(RHO_RB_EXT));
if ( g_curAppPath != 0 && eaccess(RSTRING_PTR(res), R_OK) != 0 ){
res = rb_str_new2(g_curAppPath);
rb_str_cat(res,"/",1);
rb_str_cat(res,RSTRING_PTR(fname),RSTRING_LEN(fname));
rb_str_cat(res,RHO_RB_EXT,strlen(RHO_RB_EXT));
}
} */
}
//RAWLOG_INFO1("find_file: RhoPreparePath: %s", RSTRING_PTR(res));
res = RhoPreparePath(res);
if ( !nOK )
nOK = 1;//eaccess(RSTRING_PTR(res), R_OK) == 0 ? 1 : 0;
return nOK ? res : 0;
}
int on_fragment(ryah_http_parser *parser, const char *at, size_t length) {
GET_WRAPPER(wrapper, parser);
rb_str_cat(wrapper->fragment, at, length);
return 0;
}
VALUE ss_cat_as_question(VALUE self, VALUE str) {
return rb_str_cat(str, "?", 1);
}
VALUE
asn1_encode_object(asn_TYPE_descriptor_t *td, VALUE encoder_v, void *object)
{
VALUE encoded;
bufferInfo_t bi;
asn_enc_rval_t er;
char *encoder = encoder_string(encoder_v);
/*
* Setup buffer
*/
bi.buffer = (char *)malloc(512);
bi.offset = 0;
bi.length = 512;
/*
* Encode
*/
if (strcmp(encoder, "der") == 0)
{
er = td->der_encoder(td, object, 0, 0, (asn_app_consume_bytes_f *)consumeBytes, (void *)&bi);
if (er.encoded == -1)
{
rb_raise(rb_eException, "Can't encode type");
}
/* Free memory */
}
else if (strcmp(encoder, "per") == 0)
{
size_t bit_length;
size_t bits_to_flush;
int byte_length;
char *b = (char *)calloc(512, sizeof(char));
asn_per_outp_t apo;
apo.buffer = apo.tmpspace;
apo.nboff = 0;
apo.nbits = 32 * 8;
apo.outper = per_bytes;
apo.op_key = (void *)b;
apo.flushed_bytes = 0;
er = td->uper_encoder(td, td->per_constraints, object, &apo);
if (er.encoded == -1)
{
rb_raise(rb_eException, "Can't encode type");
/* Free memory */
}
/* Relies on knowledge of internals - XXXXX - bad */
bits_to_flush = ((apo.buffer - apo.tmpspace) << 3) + apo.nboff;
bit_length = (apo.flushed_bytes << 3) + bits_to_flush;
byte_length = bit_length % 8 != 0 ? bit_length / 8 + 1 : bit_length / 8;
encoded = rb_str_new(b, apo.flushed_bytes);
rb_str_cat(encoded, apo.tmpspace, byte_length - apo.flushed_bytes);
return encoded;
}
else if (strcmp(encoder, "xer") == 0)
{
xer_encode(td, object, XER_F_CANONICAL, (asn_app_consume_bytes_f *)consumeBytes, (void *)&bi);
if (er.encoded == -1)
{
rb_raise(rb_eException, "Can't encode type");
}
/* Free memory */
}
encoded = rb_str_new(bi.buffer, bi.offset);
return encoded;
}
static
int _parse_http_request(char *buf, ssize_t buf_len, VALUE env) {
const char* method;
size_t method_len;
const char* path;
size_t path_len;
int minor_version;
struct phr_header headers[MAX_HEADERS];
size_t num_headers, question_at;
size_t i;
int ret;
char tmp[MAX_HEADER_NAME_LEN + sizeof("HTTP_") - 1];
VALUE last_value;
num_headers = MAX_HEADERS;
ret = phr_parse_request(buf, buf_len, &method, &method_len, &path,
&path_len, &minor_version, headers, &num_headers, 0);
if (ret < 0)
goto done;
rb_hash_aset(env, request_method_key, rb_str_new(method,method_len));
rb_hash_aset(env, request_uri_key, rb_str_new(path, path_len));
rb_hash_aset(env, script_name_key, rb_str_new2(""));
strcpy(tmp, "HTTP/1.");
tmp[7] = 48 + ((minor_version > 1 || minor_version < 0 ) ? 0 : minor_version);
rb_hash_aset(env, server_protocol_key, rb_str_new(tmp, sizeof("HTTP/1.0") - 1));
/* PATH_INFO QUERY_STRING */
path_len = find_ch(path, path_len, '#'); /* strip off all text after # after storing request_uri */
question_at = find_ch(path, path_len, '?');
if ( store_path_info(env, path, question_at) < 0 ) {
rb_hash_clear(env);
ret = -1;
goto done;
}
if (question_at != path_len) ++question_at;
rb_hash_aset(env, query_string_key, rb_str_new(path + question_at, path_len - question_at));
last_value = Qnil;
for (i = 0; i < num_headers; ++i) {
if (headers[i].name != NULL) {
const char* name;
size_t name_len;
VALUE slot;
VALUE env_key;
env_key = find_common_header(headers + i);
if ( env_key == Qnil ) {
const char* s;
char* d;
size_t n;
if (sizeof(tmp) - 5 < headers[i].name_len) {
rb_hash_clear(env);
ret = -1;
goto done;
}
strcpy(tmp, "HTTP_");
for (s = headers[i].name, n = headers[i].name_len, d = tmp + 5;
n != 0;
s++, --n, d++) {
*d = *s == '-' ? '_' : TOU(*s);
name = tmp;
name_len = headers[i].name_len + 5;
env_key = rb_str_new(name, name_len);
}
}
slot = rb_hash_aref(env, env_key);
if ( slot != Qnil ) {
rb_str_cat2(slot, ", ");
rb_str_cat(slot, headers[i].value, headers[i].value_len);
} else {
slot = rb_str_new(headers[i].value, headers[i].value_len);
rb_hash_aset(env, env_key, slot);
last_value = slot;
}
} else {
/* continuing lines of a mulitiline header */
if ( last_value != Qnil )
rb_str_cat(last_value, headers[i].value, headers[i].value_len);
}
}
done:
return ret;
}
static void
process_sflag(struct cmdline_options *opt)
{
if (opt->sflag) {
long n;
VALUE *args;
VALUE argv = rb_argv;
n = RARRAY_LEN(argv);
args = RARRAY_PTR(argv);
while (n > 0) {
VALUE v = *args++;
char *s = StringValuePtr(v);
char *p;
int hyphen = Qfalse;
if (s[0] != '-')
break;
n--;
if (s[1] == '-' && s[2] == '\0')
break;
v = Qtrue;
/* check if valid name before replacing - with _ */
for (p = s + 1; *p; p++) {
if (*p == '=') {
*p++ = '\0';
v = rb_str_new2(p);
break;
}
if (*p == '-') {
hyphen = Qtrue;
}
else if (*p != '_' && !ISALNUM(*p)) {
VALUE name_error[2];
name_error[0] =
rb_str_new2("invalid name for global variable - ");
if (!(p = strchr(p, '='))) {
rb_str_cat2(name_error[0], s);
}
else {
rb_str_cat(name_error[0], s, p - s);
}
name_error[1] = args[-1];
rb_exc_raise(rb_class_new_instance(2, name_error, rb_eNameError));
}
}
s[0] = '$';
if (hyphen) {
for (p = s + 1; *p; ++p) {
if (*p == '-')
*p = '_';
}
}
rb_gv_set(s, v);
}
n = RARRAY_LEN(argv) - n;
while (n--) {
rb_ary_shift(argv);
}
}
opt->sflag = 0;
}
VALUE string_spec_rb_str_cat(VALUE self, VALUE str) {
return rb_str_cat(str, "?", 1);
}
VALUE oily_png_encode_png_image_pass_to_stream(VALUE self, VALUE stream, VALUE color_mode, VALUE bit_depth, VALUE filtering) {
UNUSED_PARAMETER(bit_depth);
// Get the data
char depth = (char) FIX2INT(bit_depth);
long width = FIX2LONG(rb_funcall(self, rb_intern("width"), 0));
long height = FIX2LONG(rb_funcall(self, rb_intern("height"), 0));
VALUE pixels = rb_funcall(self, rb_intern("pixels"), 0);
if (RARRAY_LEN(pixels) != width * height) {
rb_raise(rb_eRuntimeError, "The number of pixels does not match the canvas dimensions.");
}
// Get the encoding palette if we're encoding to an indexed bytestream.
VALUE encoding_palette = Qnil;
if (FIX2INT(color_mode) == OILY_PNG_COLOR_INDEXED) {
encoding_palette = oily_png_encode_palette(self);
}
char pixel_size = oily_png_pixel_bytesize(FIX2INT(color_mode), depth);
long line_size = oily_png_scanline_bytesize(FIX2INT(color_mode), depth, width);
long pass_size = oily_png_pass_bytesize(FIX2INT(color_mode), depth, width, height);
// Allocate memory for the byte array.
BYTE* bytes = ALLOC_N(BYTE, pass_size);
// Get the scanline encoder function.
scanline_encoder_func scanline_encoder = oily_png_encode_scanline_func(FIX2INT(color_mode), depth);
if (scanline_encoder == NULL) {
rb_raise(rb_eRuntimeError, "No encoder for color mode %d and bit depth %d", FIX2INT(color_mode), depth);
}
long y, pos;
for (y = height - 1; y >= 0; y--) {
pos = line_size * y;
bytes[pos] = (BYTE) FIX2INT(filtering);
scanline_encoder(bytes + pos + 1, pixels, y, width, encoding_palette);
}
if (FIX2INT(filtering) != OILY_PNG_FILTER_NONE) {
// Get the scanline filter function
void (*scanline_filter)(BYTE*, long, long, char) = NULL;
switch (FIX2INT(filtering)) {
case OILY_PNG_FILTER_SUB: scanline_filter = &oily_png_encode_filter_sub; break;
case OILY_PNG_FILTER_UP: scanline_filter = &oily_png_encode_filter_up; break;
case OILY_PNG_FILTER_AVERAGE: scanline_filter = &oily_png_encode_filter_average; break;
case OILY_PNG_FILTER_PAETH: scanline_filter = &oily_png_encode_filter_paeth; break;
default: rb_raise(rb_eRuntimeError, "Unsupported filter type: %d", FIX2INT(filtering));
}
for (y = height - 1; y >= 0; y--) {
scanline_filter(bytes, line_size * y, line_size, pixel_size);
}
}
// Append to encoded image pass to the output stream.
rb_str_cat(stream, (char*) bytes, pass_size);
xfree(bytes);
return Qnil;
}
static VALUE
optimized_unescape_html(VALUE str)
{
enum {UNICODE_MAX = 0x10ffff};
rb_encoding *enc = rb_enc_get(str);
unsigned long charlimit = (strcasecmp(rb_enc_name(enc), "UTF-8") == 0 ? UNICODE_MAX :
strcasecmp(rb_enc_name(enc), "ISO-8859-1") == 0 ? 256 :
128);
long i, len, beg = 0;
size_t clen, plen;
int overflow;
const char *cstr;
char buf[6];
VALUE dest = 0;
len = RSTRING_LEN(str);
cstr = RSTRING_PTR(str);
for (i = 0; i < len; i++) {
unsigned long cc;
char c = cstr[i];
if (c != '&') continue;
plen = i - beg;
if (++i >= len) break;
c = (unsigned char)cstr[i];
switch (c) {
case 'a':
++i;
if (len - i >= 4 && memcmp(&cstr[i], "pos;", 4) == 0) {
c = '\'';
i += 3;
}
else if (len - i >= 3 && memcmp(&cstr[i], "mp;", 3) == 0) {
c = '&';
i += 2;
}
else continue;
break;
case 'q':
++i;
if (len - i >= 4 && memcmp(&cstr[i], "uot;", 4) == 0) {
c = '"';
i += 3;
}
else continue;
break;
case 'g':
++i;
if (len - i >= 2 && memcmp(&cstr[i], "t;", 2) == 0) {
c = '>';
i += 1;
}
else continue;
break;
case 'l':
++i;
if (len - i >= 2 && memcmp(&cstr[i], "t;", 2) == 0) {
c = '<';
i += 1;
}
else continue;
break;
case '#':
if (len - ++i >= 2 && ISDIGIT(cstr[i])) {
cc = ruby_scan_digits(&cstr[i], len-i, 10, &clen, &overflow);
}
else if ((cstr[i] == 'x' || cstr[i] == 'X') && len - ++i >= 2 && ISXDIGIT(cstr[i])) {
cc = ruby_scan_digits(&cstr[i], len-i, 16, &clen, &overflow);
}
else continue;
i += clen;
if (overflow || cc >= charlimit || cstr[i] != ';') continue;
if (!dest) {
dest = rb_str_buf_new(len);
}
rb_str_cat(dest, cstr + beg, plen);
if (charlimit > 256) {
rb_str_cat(dest, buf, rb_enc_mbcput((OnigCodePoint)cc, buf, enc));
}
else {
c = (unsigned char)cc;
rb_str_cat(dest, &c, 1);
}
beg = i + 1;
continue;
default:
--i;
continue;
}
if (!dest) {
dest = rb_str_buf_new(len);
}
rb_str_cat(dest, cstr + beg, plen);
rb_str_cat(dest, &c, 1);
beg = i + 1;
}
if (dest) {
rb_str_cat(dest, cstr + beg, len - beg);
preserve_original_state(str, dest);
return dest;
}
else {
return rb_str_dup(str);
}
}