void Init_rcovrt() {
ID id_rcov = rb_intern("Rcov");
ID id_coverage__ = rb_intern("RCOV__");
ID id_script_lines__ = rb_intern("SCRIPT_LINES__");
id_cover = rb_intern("COVER");
if(rb_const_defined(rb_cObject, id_rcov))
mRcov = rb_const_get(rb_cObject, id_rcov);
else
mRcov = rb_define_module("Rcov");
if(rb_const_defined(mRcov, id_coverage__))
mRCOV__ = rb_const_get_at(mRcov, id_coverage__);
else
mRCOV__ = rb_define_module_under(mRcov, "RCOV__");
if(rb_const_defined(rb_cObject, id_script_lines__))
oSCRIPT_LINES__ = rb_const_get(rb_cObject, rb_intern("SCRIPT_LINES__"));
else {
oSCRIPT_LINES__ = rb_hash_new();
rb_const_set(rb_cObject, id_script_lines__, oSCRIPT_LINES__);
}
coverage_hook_set_p = 0;
rb_define_singleton_method(mRCOV__, "install_coverage_hook", cov_install_coverage_hook, 0);
rb_define_singleton_method(mRCOV__, "remove_coverage_hook", cov_remove_coverage_hook, 0);
rb_define_singleton_method(mRCOV__, "generate_coverage_info", cov_generate_coverage_info, 0);
rb_define_singleton_method(mRCOV__, "reset_coverage", cov_reset_coverage, 0);
rb_define_singleton_method(mRCOV__, "ABI", cov_ABI, 0);
Init_rcov_callsite();
}
int load_constants() {
if(!rb_const_defined(rb_cObject, id_GPS)) return 0;
mGPS = rb_const_get(rb_cObject, rb_intern("GPS"));
if(!rb_const_defined(mGPS, id_Latitude)) return 0;
cLatitude = rb_const_get(mGPS, rb_intern("Latitude"));
if(!rb_const_defined(mGPS, id_Longitude)) return 0;
cLongitude = rb_const_get(mGPS, rb_intern("Longitude"));
return 1;
}
static VALUE
handler_for_tag(rb_yaml_parser_t *parser, yaml_char_t *tag)
{
if (tag == NULL) {
return Qnil;
}
const void *h =
CFDictionaryGetValue(RYAMLResolver(parser->resolver)->tags,
(const void *)rb_intern((const char *)tag));
if (h != NULL) {
return (VALUE)h;
}
// Dynamic handler, only for pure objects.
VALUE outer = Qnil;
if (strncmp((const char *)tag, "!ruby/object:", 13) == 0) {
outer = rb_cObject;
}
else if (strncmp((const char *)tag, "!ruby/struct:", 13) == 0) {
outer = rb_cStruct;
}
if (outer != Qnil) {
char *path = (char *)tag + 13;
assert(strlen(path) < 100);
char *p;
while ((p = strstr(path, "::")) != NULL) {
char buf[100];
strncpy(buf, path, p - path);
buf[p - path] = '\0';
ID id = rb_intern(buf);
if (rb_const_defined(outer, id)) {
outer = rb_const_get(outer, id);
}
else {
return Qnil;
}
path = p + 2;
}
ID pathid = rb_intern(path);
if (rb_const_defined(outer, pathid)) {
return rb_const_get(outer, pathid);
}
}
return Qnil;
}
void Init_instruction(void)
{
#ifdef RUBY_VM
VALUE rb_cRubyVM;
VALUE rb_cInstruction;
if(!rb_const_defined(rb_cObject, rb_intern("RubyVM")))
{
rb_define_const(
rb_cObject,
"RubyVM",
rb_const_get(rb_cObject, rb_intern("VM")));
}
rb_cRubyVM = rb_define_class("RubyVM", rb_cObject);
rb_cInstruction = rb_define_class_under(rb_cRubyVM, "Instruction", rb_cObject);
rb_define_method(rb_cInstruction, "initialize", instruction_initialize, -1);
rb_define_method(rb_cInstruction, "operands", instruction_operands, 0);
rb_undef_method(rb_cInstruction, "new");
define_instruction_subclasses(rb_cInstruction);
/* Silence compiler warnings about unused static functions */
insn_name(0);
insn_op_type(0, 0);
insn_op_types(0);
#endif
}
/*!
* Defines a top-level class.
* \param name name of the class
* \param super a class from which the new class will derive.
* NULL means \c Object class.
* \return the created class
* \throw TypeError if the constant name \a name is already taken but
* the constant is not a \c Class.
* \throw NameError if the class is already defined but the class can not
* be reopened because its superclass is not \a super.
* \post top-level constant named \a name refers the returned class.
*
* \note if a class named \a name is already defined and its superclass is
* \a super, the function just returns the defined class.
*/
VALUE
rb_define_class(const char *name, VALUE super)
{
VALUE klass;
ID id;
id = rb_intern(name);
if (rb_const_defined(rb_cObject, id)) {
klass = rb_const_get(rb_cObject, id);
if (!RB_TYPE_P(klass, T_CLASS)) {
rb_raise(rb_eTypeError, "%s is not a class", name);
}
if (rb_class_real(RCLASS_SUPER(klass)) != super) {
rb_raise(rb_eTypeError, "superclass mismatch for class %s", name);
}
return klass;
}
if (!super) {
rb_warn("no super class for `%s', Object assumed", name);
}
klass = rb_define_class_id(id, super);
rb_vm_add_root_module(id, klass);
rb_name_class(klass, id);
rb_const_set(rb_cObject, id, klass);
rb_class_inherited(super, klass);
return klass;
}
VALUE
rb_define_class(const char *name, VALUE super)
{
VALUE klass;
ID id;
id = rb_intern(name);
if (rb_const_defined(rb_cObject, id)) {
klass = rb_const_get(rb_cObject, id);
if (TYPE(klass) != T_CLASS) {
rb_raise(rb_eTypeError, "%s is not a class", name);
}
if (rb_class_real(RCLASS_SUPER(klass)) != super) {
rb_name_error(id, "%s is already defined", name);
}
return klass;
}
if (!super) {
rb_warn("no super class for `%s', Object assumed", name);
}
klass = rb_define_class_id(id, super);
st_add_direct(rb_class_tbl, id, klass);
rb_name_class(klass, id);
rb_const_set(rb_cObject, id, klass);
rb_class_inherited(super, klass);
return klass;
}
VALUE
rb_path2class(const char *path)
{
const char *pbeg, *p;
ID id;
VALUE c = rb_cObject;
if (path[0] == '#') {
rb_raise(rb_eArgError, "can't retrieve anonymous class %s", path);
}
pbeg = p = path;
while (*p) {
while (*p && *p != ':') p++;
id = rb_intern2(pbeg, p-pbeg);
if (p[0] == ':') {
if (p[1] != ':') goto undefined_class;
p += 2;
pbeg = p;
}
if (!rb_const_defined(c, id)) {
undefined_class:
rb_raise(rb_eArgError, "undefined class/module %.*s", (int)(p-path), path);
}
c = rb_const_get_at(c, id);
switch (TYPE(c)) {
case T_MODULE:
case T_CLASS:
break;
default:
rb_raise(rb_eTypeError, "%s does not refer class/module", path);
}
}
return c;
}
void Init_constants(void)
{
#ifdef RUBY_VM
VALUE rb_cRubyVM;
if(!rb_const_defined(rb_cObject, rb_intern("RubyVM")))
{
rb_define_const(
rb_cObject,
"RubyVM",
rb_const_get(rb_cObject, rb_intern("VM")));
}
rb_cRubyVM = rb_define_class("RubyVM", rb_cObject);
rb_define_const(rb_cRubyVM, "CALL_ARGS_SPLAT_BIT", INT2NUM(VM_CALL_ARGS_SPLAT_BIT));
rb_define_const(rb_cRubyVM, "CALL_ARGS_BLOCKARG_BIT", INT2NUM(VM_CALL_ARGS_BLOCKARG_BIT));
rb_define_const(rb_cRubyVM, "CALL_FCALL_BIT", INT2NUM(VM_CALL_FCALL_BIT));
rb_define_const(rb_cRubyVM, "CALL_VCALL_BIT", INT2NUM(VM_CALL_VCALL_BIT));
rb_define_const(rb_cRubyVM, "CALL_TAILCALL_BIT", INT2NUM(VM_CALL_TAILCALL_BIT));
rb_define_const(rb_cRubyVM, "CALL_TAILRECURSION_BIT", INT2NUM(VM_CALL_TAILRECURSION_BIT));
rb_define_const(rb_cRubyVM, "CALL_SUPER_BIT", INT2NUM(VM_CALL_SUPER_BIT));
#ifdef HAVE_RUBY_CALL_SEND_BIT
rb_define_const(rb_cRubyVM, "CALL_SEND_BIT", INT2NUM(VM_CALL_SEND_BIT));
#endif
rb_define_const(rb_cRubyVM, "SPECIAL_OBJECT_VMCORE", INT2NUM(VM_SPECIAL_OBJECT_VMCORE));
rb_define_const(rb_cRubyVM, "SPECIAL_OBJECT_CBASE", INT2NUM(VM_SPECIAL_OBJECT_CBASE));
#endif
}
/*
* call-seq:
* inspect -> String
*
* Human-readable description.
* ===Return value
* String
*/
VALUE _inspect(VALUE self)
{
if(wrap< RubyWindowHolder* >(self)->window==NULL){
VALUE array[2];
array[0]=rb_str_new2("#<%s:(destroyed)>");
array[1]=rb_class_of(self);
return rb_f_sprintf(2,array);
}else{
if(rb_const_defined(rb_class_of(self),rb_intern("WidgetTypeName")))
if(_self->getType() == wrap<CEGUI::String>(rb_const_get(rb_class_of(self),rb_intern("WidgetTypeName"))))
{
VALUE array[3];
array[0]=rb_str_new2("#<%s:%s>");
array[1]=rb_class_of(self);
array[2]=rb_funcall(self,rb_intern("name"),0);
return rb_f_sprintf(3,array);
}
VALUE array[4];
array[0]=rb_str_new2("#<%s(%s):%s>");
array[1]=rb_class_of(self);
array[2]=_getType(self);
array[3]=rb_funcall(self,rb_intern("name"),0);
return rb_f_sprintf(4,array);
}
}
void init_kgio_tryopen(void)
{
VALUE mKgio = rb_define_module("Kgio");
VALUE mPipeMethods = rb_const_get(mKgio, rb_intern("PipeMethods"));
VALUE cFile;
VALUE tmp;
VALUE *ptr;
long len;
id_path = rb_intern("path");
id_for_fd = rb_intern("for_fd");
id_to_path = rb_intern("to_path");
/*
* Document-class: Kgio::File
*
* This subclass of the core File class adds the "tryopen" singleton
* method for opening files. A single "tryopen" and check for the
* return value may be used to avoid unnecessary stat(2) syscalls
* or File.open exceptions when checking for the existence of a file
* and opening it.
*/
cFile = rb_define_class_under(mKgio, "File", rb_cFile);
rb_define_singleton_method(cFile, "tryopen", s_tryopen, -1);
rb_include_module(cFile, mPipeMethods);
if (!rb_funcall(cFile, rb_intern("method_defined?"), 1,
ID2SYM(id_to_path)))
rb_define_alias(cFile, "to_path", "path");
errno2sym = st_init_numtable();
tmp = rb_funcall(rb_mErrno, rb_intern("constants"), 0);
ptr = RARRAY_PTR(tmp);
len = RARRAY_LEN(tmp);
for (; --len >= 0; ptr++) {
VALUE error;
ID const_id;
switch (TYPE(*ptr)) {
case T_SYMBOL: const_id = SYM2ID(*ptr); break;
case T_STRING: const_id = rb_intern(RSTRING_PTR(*ptr)); break;
default: rb_bug("constant not a symbol or string");
}
error = rb_const_get(rb_mErrno, const_id);
if ((TYPE(error) != T_CLASS) ||
!rb_const_defined(error, rb_intern("Errno")))
continue;
error = rb_const_get(error, rb_intern("Errno"));
switch (TYPE(error)) {
case T_FIXNUM:
case T_BIGNUM:
st_insert(errno2sym, (st_data_t)NUM2INT(error),
ID2SYM(const_id));
}
}
}
void
Init_cparse(void)
{
VALUE Racc, Parser;
ID id_racc = rb_intern("Racc");
if (rb_const_defined(rb_cObject, id_racc)) {
Racc = rb_const_get(rb_cObject, id_racc);
Parser = rb_const_get_at(Racc, rb_intern("Parser"));
}
else {
Racc = rb_define_module("Racc");
Parser = rb_define_class_under(Racc, "Parser", rb_cObject);
}
rb_define_method(Parser, "initialize", (VALUE(*)(ANYARGS))initialize, 0);
rb_define_private_method(Parser, "_racc_do_parse_c", racc_cparse, 0);
rb_define_private_method(Parser, "_racc_yyparse_c", racc_yyparse, 2);
rb_define_const(Parser, "Racc_Runtime_Core_Version_C",
rb_str_new2(RACC_VERSION));
rb_define_const(Parser, "Racc_Runtime_Core_Id_C",
rb_str_new2("$originalId: cparse.c,v 1.8 2006/07/06 11:39:46 aamine Exp $"));
CparseParams = rb_define_class_under(Racc, "CparseParams", rb_cObject);
RaccBug = rb_eRuntimeError;
id_yydebug = rb_intern("@yydebug");
id_nexttoken = rb_intern("next_token");
id_onerror = rb_intern("on_error");
id_noreduce = rb_intern("_reduce_none");
id_errstatus = rb_intern("@racc_error_status");
id_d_shift = rb_intern("racc_shift");
id_d_reduce = rb_intern("racc_reduce");
id_d_accept = rb_intern("racc_accept");
id_d_read_token = rb_intern("racc_read_token");
id_d_next_state = rb_intern("racc_next_state");
id_d_e_pop = rb_intern("racc_e_pop");
id_action_table = rb_intern("@action_table");
id_action_check = rb_intern("@action_check");
id_action_default = rb_intern("@action_default");
id_action_pointer = rb_intern("@action_pointer");
id_goto_table = rb_intern("@goto_table");
id_goto_check = rb_intern("@goto_check");
id_goto_default = rb_intern("@goto_default");
id_goto_pointer = rb_intern("@goto_pointer");
id_nt_base = rb_intern("@nt_base");
id_reduce_table = rb_intern("@reduce_table");
id_token_table = rb_intern("@token_table");
id_shift_n = rb_intern("@shift_n");
id_reduce_n = rb_intern("@reduce_n");
id_use_result = rb_intern("@use_result");
}
VALUE Cegui_method_missing(int argc,VALUE *argv,VALUE self)
{
VALUE methID,args;
rb_scan_args(argc, argv, "1*",&methID,&args);
if(rb_const_defined(self,SYM2ID(methID))) {
return rb_funcall2(rb_const_get(self,SYM2ID(methID)),rb_intern("new"),argc-1,RARRAY_PTR(args));
} else {
return rb_call_super(argc,argv);
}
}
void init_StringScanner_UTF8() {
ID intern_string_scanner = rb_intern("StringScanner");
VALUE rb_cStringScanner, rb_cStringScanner_UTF8;
if (!rb_const_defined(rb_cObject, intern_string_scanner)) {
rb_require("strscan");
}
rb_cStringScanner = rb_const_get(rb_cObject, intern_string_scanner);
rb_cStringScanner_UTF8 = rb_define_class_under(rb_cStringScanner, "UTF8", rb_cStringScanner);
rb_define_method(rb_cStringScanner_UTF8, "getch", rb_cStringScanner_UTF8_getch, 0);
}
void Init_charguess()
{
ID id;
id = rb_intern("CharGuess");
if (rb_const_defined(rb_cObject, id)) {
mCharGuess = rb_const_get(rb_cObject, id);
} else {
mCharGuess = rb_define_module("CharGuess");
}
rb_define_singleton_method(mCharGuess, "guess", cg_s_guess, 1);
}
void
pg_coder_init_decoder( VALUE self )
{
t_pg_coder *this = DATA_PTR( self );
VALUE klass = rb_class_of(self);
this->enc_func = NULL;
if( rb_const_defined( klass, s_id_CFUNC ) ){
VALUE cfunc = rb_const_get( klass, s_id_CFUNC );
this->dec_func = DATA_PTR(cfunc);
} else {
this->dec_func = NULL;
}
this->coder_obj = self;
this->oid = 0;
this->format = 0;
rb_iv_set( self, "@name", Qnil );
}
long double
rbffi_num2longdouble(VALUE value)
{
if (TYPE(value) == T_FLOAT) {
return rb_num2dbl(value);
}
if (!RTEST(rb_cBigDecimal) && rb_const_defined(rb_cObject, rb_intern("BigDecimal"))) {
rb_cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
}
if (RTEST(rb_cBigDecimal) && rb_cBigDecimal != rb_cObject && RTEST(rb_obj_is_kind_of(value, rb_cBigDecimal))) {
VALUE s = rb_funcall(value, rb_intern("to_s"), 1, rb_str_new2("E"));
return strtold(RSTRING_PTR(s), NULL);
}
/* Fall through to handling as a float */
return rb_num2dbl(value);
}
VALUE
rb_define_module(const char *name)
{
VALUE module;
ID id;
id = rb_intern(name);
if (rb_const_defined(rb_cObject, id)) {
module = rb_const_get(rb_cObject, id);
if (TYPE(module) == T_MODULE)
return module;
rb_raise(rb_eTypeError, "%s is not a module", rb_obj_classname(module));
}
module = rb_define_module_id(id);
st_add_direct(rb_class_tbl, id, module);
rb_const_set(rb_cObject, id, module);
return module;
}
VALUE
rb_define_module(const char *name)
{
VALUE module;
ID id;
id = rb_intern(name);
if (rb_const_defined(rb_cObject, id)) {
module = rb_const_get(rb_cObject, id);
if (RB_TYPE_P(module, T_MODULE))
return module;
rb_raise(rb_eTypeError, "%s is not a module", rb_obj_classname(module));
}
module = rb_define_module_id(id);
rb_vm_add_root_module(id, module);
rb_const_set(rb_cObject, id, module);
return module;
}
static int getButtonArg(VALUE self, int argc, VALUE *argv)
{
int num;
#ifdef RGSS3
ID sym;
rb_get_args(argc, argv, "n", &sym RB_ARG_END);
if (rb_const_defined(self, sym))
num = FIX2INT(rb_const_get(self, sym));
else
num = 0;
#else
(void) self;
rb_get_args(argc, argv, "i", &num RB_ARG_END);
#endif
return num;
}
void InitReader(VALUE mod) {
klass_reader = rb_define_class_under(mod, "Reader", rb_cObject);
rb_global_variable(&klass_reader);
rb_define_alloc_func(klass_reader, reader_allocate);
rb_define_method(klass_reader, "feed", reader_feed, 1);
rb_define_method(klass_reader, "gets", reader_gets, 0);
/* If the Encoding class is present, #default_external should be used to
* determine the encoding for new strings. The "enc_default_external"
* ID is non-zero when encoding should be set on new strings. */
if (rb_const_defined(rb_cObject, rb_intern("Encoding"))) {
enc_klass = rb_const_get(rb_cObject, rb_intern("Encoding"));
enc_default_external = rb_intern("default_external");
str_force_encoding = rb_intern("force_encoding");
rb_global_variable(&enc_klass);
} else {
enc_default_external = 0;
}
}
void rxml_init_schema_type(void)
{
/* Add in infinity support for ruby 1.8.7 */
#if !defined(RUBY_VM) && defined(INFINITY)
ID infinityId = rb_intern("INFINITY");
if (rb_const_defined(rb_cFloat, infinityId) == Qfalse)
rb_define_const(rb_cFloat, "INFINITY", rb_float_new(INFINITY));
#endif
cXMLSchemaType = rb_define_class_under(cXMLSchema, "Type", rb_cObject);
rb_define_method(cXMLSchemaType, "namespace", rxml_schema_type_namespace, 0);
rb_define_method(cXMLSchemaType, "name", rxml_schema_type_name, 0);
rb_define_method(cXMLSchemaType, "elements", rxml_schema_type_elements, 0);
rb_define_method(cXMLSchemaType, "attributes", rxml_schema_type_attributes, 0);
rb_define_method(cXMLSchemaType, "base", rxml_schema_type_base, 0);
rb_define_method(cXMLSchemaType, "kind", rxml_schema_type_kind, 0);
rb_define_method(cXMLSchemaType, "node", rxml_schema_type_node, 0);
rb_define_method(cXMLSchemaType, "facets", rxml_schema_type_facets, 0);
rb_define_method(cXMLSchemaType, "annotation", rxml_schema_type_annot, 0);
}
VALUE
rb_path_to_class(VALUE pathname)
{
rb_encoding *enc = rb_enc_get(pathname);
const char *pbeg, *p, *path = RSTRING_PTR(pathname);
ID id;
VALUE c = rb_cObject;
if (!rb_enc_asciicompat(enc)) {
rb_raise(rb_eArgError, "invalid class path encoding (non ASCII)");
}
pbeg = p = path;
if (path[0] == '#') {
rb_raise(rb_eArgError, "can't retrieve anonymous class %s", path);
}
while (*p) {
while (*p && *p != ':') p++;
id = rb_intern3(pbeg, p-pbeg, enc);
if (p[0] == ':') {
if (p[1] != ':') goto undefined_class;
p += 2;
pbeg = p;
}
if (!rb_const_defined(c, id)) {
undefined_class:
rb_raise(rb_eArgError, "undefined class/module %.*s", (int)(p-path), path);
}
c = rb_const_get_at(c, id);
switch (TYPE(c)) {
case T_MODULE:
case T_CLASS:
break;
default:
rb_raise(rb_eTypeError, "%s does not refer to class/module", path);
}
}
return c;
}
void rbTransform::Init( VALUE SFML )
{
rbTransform::Class = rb_define_class_under( SFML, "Transform", rb_cObject );
rb_define_alloc_func( rbTransform::Class, rbMacros::Allocate< sf::Transform > );
// Instance methods
ext_define_method( rbTransform::Class, "initialize", rbTransform::Initialize, -1 );
ext_define_method( rbTransform::Class, "initialize_copy", rbTransform::InitializeCopy, 1 );
ext_define_method( rbTransform::Class, "matrix", rbTransform::GetMatrix, 0 );
ext_define_method( rbTransform::Class, "inverse", rbTransform::GetInverse, 0 );
ext_define_method( rbTransform::Class, "transform_point", rbTransform::TransformPoint, -1 );
ext_define_method( rbTransform::Class, "transform_rect", rbTransform::TransformRect, 1 );
ext_define_method( rbTransform::Class, "combine", rbTransform::Combine, 1 );
ext_define_method( rbTransform::Class, "translate", rbTransform::Translate, -1 );
ext_define_method( rbTransform::Class, "rotate", rbTransform::Rotate, -1 );
ext_define_method( rbTransform::Class, "scale", rbTransform::Scale, -1 );
ext_define_method( rbTransform::Class, "*", rbTransform::MultiplyOperator, 1 );
ext_define_method( rbTransform::Class, "marshal_dump", rbTransform::MarshalDump, 0 );
ext_define_method( rbTransform::Class, "marshal_load", rbTransform::MarshalLoad, 1 );
ext_define_method( rbTransform::Class, "==", rbTransform::Equal, 1 );
ext_define_method( rbTransform::Class, "inspect", rbTransform::Inspect, 0 );
// Instance aliases
rb_define_alias( rbTransform::Class, "to_s", "inspect" );
rb_define_alias( rbTransform::Class, "get_matrix", "matrix" );
rb_define_alias( rbTransform::Class, "getMatrix", "matrix" );
rb_define_alias( rbTransform::Class, "to_a", "matrix" );
rb_define_alias( rbTransform::Class, "get_inverse", "inverse" );
rb_define_alias( rbTransform::Class, "getInverse", "inverse" );
rb_define_alias( rbTransform::Class, "transformPoint", "transform_point" );
rb_define_alias( rbTransform::Class, "transformRect", "transform_rect" );
if( rb_const_defined( rbTransform::Class, rb_intern( "Identity" ) ) == Qfalse )
rb_define_const( rbTransform::Class, "Identity", rbMacros::ToConstRuby( &sf::Transform::Identity, rbTransform::Class ) );
}
/*
* call-seq:
* IO.console -> #<File:/dev/tty>
*
* Returns an File instance opened console.
*
* You must require 'io/console' to use this method.
*/
static VALUE
console_dev(VALUE klass)
{
VALUE con = 0;
rb_io_t *fptr;
if (klass == rb_cIO) klass = rb_cFile;
if (rb_const_defined(klass, id_console)) {
con = rb_const_get(klass, id_console);
if (RB_TYPE_P(con, T_FILE)) {
if ((fptr = RFILE(con)->fptr) && GetReadFD(fptr) != -1)
return con;
}
rb_mod_remove_const(klass, ID2SYM(id_console));
}
{
VALUE args[2];
#if defined HAVE_TERMIOS_H || defined HAVE_TERMIO_H || defined HAVE_SGTTY_H
# define CONSOLE_DEVICE "/dev/tty"
#elif defined _WIN32
# define CONSOLE_DEVICE "con$"
# define CONSOLE_DEVICE_FOR_READING "conin$"
# define CONSOLE_DEVICE_FOR_WRITING "conout$"
#endif
#ifndef CONSOLE_DEVICE_FOR_READING
# define CONSOLE_DEVICE_FOR_READING CONSOLE_DEVICE
#endif
#ifdef CONSOLE_DEVICE_FOR_WRITING
VALUE out;
rb_io_t *ofptr;
#endif
int fd;
#ifdef CONSOLE_DEVICE_FOR_WRITING
fd = rb_cloexec_open(CONSOLE_DEVICE_FOR_WRITING, O_WRONLY, 0);
if (fd < 0) return Qnil;
rb_update_max_fd(fd);
args[1] = INT2FIX(O_WRONLY);
args[0] = INT2NUM(fd);
out = rb_class_new_instance(2, args, klass);
#endif
fd = rb_cloexec_open(CONSOLE_DEVICE_FOR_READING, O_RDWR, 0);
if (fd < 0) {
#ifdef CONSOLE_DEVICE_FOR_WRITING
rb_io_close(out);
#endif
return Qnil;
}
rb_update_max_fd(fd);
args[1] = INT2FIX(O_RDWR);
args[0] = INT2NUM(fd);
con = rb_class_new_instance(2, args, klass);
GetOpenFile(con, fptr);
#ifdef HAVE_RUBY_IO_H
fptr->pathv = rb_obj_freeze(rb_str_new2(CONSOLE_DEVICE));
#else
fptr->path = ruby_strdup(CONSOLE_DEVICE);
#endif
#ifdef CONSOLE_DEVICE_FOR_WRITING
GetOpenFile(out, ofptr);
# ifdef HAVE_RB_IO_GET_WRITE_IO
ofptr->pathv = fptr->pathv;
fptr->tied_io_for_writing = out;
# else
fptr->f2 = ofptr->f;
ofptr->f = 0;
# endif
ofptr->mode |= FMODE_SYNC;
#endif
fptr->mode |= FMODE_SYNC;
rb_const_set(klass, id_console, con);
}
return con;
}
/*
* call-seq:
* IO.console -> #<File:/dev/tty>
* IO.console(sym, *args)
*
* Returns an File instance opened console.
*
* If +sym+ is given, it will be sent to the opened console with
* +args+ and the result will be returned instead of the console IO
* itself.
*
* You must require 'io/console' to use this method.
*/
static VALUE
console_dev(int argc, VALUE *argv, VALUE klass)
{
VALUE con = 0;
rb_io_t *fptr;
VALUE sym = 0;
rb_check_arity(argc, 0, UNLIMITED_ARGUMENTS);
if (argc) {
Check_Type(sym = argv[0], T_SYMBOL);
}
if (klass == rb_cIO) klass = rb_cFile;
if (rb_const_defined(klass, id_console)) {
con = rb_const_get(klass, id_console);
if (!RB_TYPE_P(con, T_FILE) ||
(!(fptr = RFILE(con)->fptr) || GetReadFD(fptr) == -1)) {
rb_const_remove(klass, id_console);
con = 0;
}
}
if (sym) {
if (sym == ID2SYM(id_close) && argc == 1) {
if (con) {
rb_io_close(con);
rb_const_remove(klass, id_console);
con = 0;
}
return Qnil;
}
}
if (!con) {
VALUE args[2];
#if defined HAVE_TERMIOS_H || defined HAVE_TERMIO_H || defined HAVE_SGTTY_H
# define CONSOLE_DEVICE "/dev/tty"
#elif defined _WIN32
# define CONSOLE_DEVICE "con$"
# define CONSOLE_DEVICE_FOR_READING "conin$"
# define CONSOLE_DEVICE_FOR_WRITING "conout$"
#endif
#ifndef CONSOLE_DEVICE_FOR_READING
# define CONSOLE_DEVICE_FOR_READING CONSOLE_DEVICE
#endif
#ifdef CONSOLE_DEVICE_FOR_WRITING
VALUE out;
rb_io_t *ofptr;
#endif
int fd;
#ifdef CONSOLE_DEVICE_FOR_WRITING
fd = rb_cloexec_open(CONSOLE_DEVICE_FOR_WRITING, O_RDWR, 0);
if (fd < 0) return Qnil;
rb_update_max_fd(fd);
args[1] = INT2FIX(O_WRONLY);
args[0] = INT2NUM(fd);
out = rb_class_new_instance(2, args, klass);
#endif
fd = rb_cloexec_open(CONSOLE_DEVICE_FOR_READING, O_RDWR, 0);
if (fd < 0) {
#ifdef CONSOLE_DEVICE_FOR_WRITING
rb_io_close(out);
#endif
return Qnil;
}
rb_update_max_fd(fd);
args[1] = INT2FIX(O_RDWR);
args[0] = INT2NUM(fd);
con = rb_class_new_instance(2, args, klass);
GetOpenFile(con, fptr);
fptr->pathv = rb_obj_freeze(rb_str_new2(CONSOLE_DEVICE));
#ifdef CONSOLE_DEVICE_FOR_WRITING
GetOpenFile(out, ofptr);
ofptr->pathv = fptr->pathv;
fptr->tied_io_for_writing = out;
ofptr->mode |= FMODE_SYNC;
#endif
fptr->mode |= FMODE_SYNC;
rb_const_set(klass, id_console, con);
}
if (sym) {
return rb_f_send(argc, argv, con);
}
return con;
}
VALUE
bpObjectToRuby(const bp::Object * obj,
unsigned int tid)
{
if (obj == NULL) return Qnil;
VALUE v = Qnil;
switch (obj->type()) {
case BPTNull:
v = Qnil;
break;
case BPTBoolean:
{
if (((bp::Bool *) obj)->value()) v = Qtrue;
else v = Qfalse;
break;
}
case BPTInteger:
v = rb_ull2inum(((bp::Integer *) obj)->value());
break;
case BPTCallBack: {
VALUE args[2];
args[0] = rb_uint2inum(tid);
args[1] = rb_ull2inum(((bp::Integer *) obj)->value());
v = rb_class_new_instance(2, args, bp_rb_cCallback);
break;
}
case BPTDouble:
v = rb_float_new(((bp::Double *) obj)->value());
break;
case BPTString:
v = rb_str_new2(((bp::String *) obj)->value());
break;
case BPTNativePath: {
VALUE id = rb_intern("Pathname");
VALUE klass = 0;
if (rb_const_defined(rb_cObject, id) &&
(klass = rb_const_get(rb_cObject, id)) &&
TYPE(klass) == T_CLASS)
{
std::string path = convert::toUTF8(((bp::Path *) obj)->value());
VALUE p = rb_str_new2(path.c_str());
v = rb_class_new_instance(1, &p, klass);
}
break;
}
case BPTMap:
{
bp::Map * m = (bp::Map *) obj;
v = rb_hash_new();
bp::Map::Iterator i(*m);
const char * key;
while (NULL != (key = i.nextKey())) {
rb_hash_aset(v,ID2SYM(rb_intern(key)),
bpObjectToRuby(m->value(key), tid));
}
break;
}
case BPTList:
{
bp::List * l = (bp::List *) obj;
v = rb_ary_new();
unsigned int i;
for (i=0; i < l->size(); i++) {
rb_ary_push(v, bpObjectToRuby(l->value(i), tid));
}
break;
}
case BPTAny:
// invalid
break;
}
return v;
}
static VALUE module_specs_const_defined(VALUE self, VALUE klass, VALUE id) {
return rb_const_defined(klass, SYM2ID(id)) ? Qtrue : Qfalse;
}
bp::Object *
rubyToBPObject(VALUE v)
{
bp::Object * obj = NULL;
switch (TYPE(v)) {
case T_FLOAT:
obj = new bp::Double(rb_num2dbl(v));
break;
case T_STRING:
obj = new bp::String(RSTRING_PTR(v));
break;
case T_FIXNUM:
obj = new bp::Integer(rb_num2ull(v));
break;
case T_TRUE:
obj = new bp::Bool(true);
break;
case T_FALSE:
obj = new bp::Bool(false);
break;
case T_HASH:
obj = new bp::Map;
rb_hash_foreach(v,
(int (*)(ANYARGS)) hashPopulator,
(VALUE) obj);
break;
case T_ARRAY:
{
long i;
bp::List * l = new bp::List;
for (i=0; i < RARRAY_LEN(v); i++) {
l->append(rubyToBPObject(rb_ary_entry(v, i)));
}
obj = l;
}
break;
case T_OBJECT: {
// map Pathname objects into BPTPath types
VALUE id = rb_intern("Pathname");
VALUE klass = 0;
if (rb_const_defined(rb_cObject, id) &&
(klass = rb_const_get(rb_cObject, id)) &&
TYPE(klass) == T_CLASS)
{
VALUE r = rb_obj_is_kind_of(v, klass);
if (RTEST(r)) {
// convert to abs path
int error = 0;
VALUE absPath =
ruby::invokeFunction(v, "realpath", &error, 0);
VALUE pathString =
ruby::invokeFunction(absPath, "to_s", &error, 0);
if (!error && TYPE(pathString) == T_STRING) {
obj = new bp::Path((const BPPath) convert::fromUTF8(RSTRING_PTR(pathString)).c_str());
}
break;
}
}
}
case T_NIL:
default:
obj = new bp::Null();
break;
}
return obj;
}
VALUE sm_const_defined(VALUE self, VALUE klass, VALUE id) {
return rb_const_defined(klass, SYM2ID(id)) ? Qtrue : Qfalse;
}
