void rgeo_init_geos_line_string(RGeo_Globals* globals)
{
VALUE geos_line_string_class = rb_define_class_under(globals->geos_module, "LineStringImpl", globals->geos_geometry);
globals->geos_line_string = geos_line_string_class;
globals->feature_line_string = rb_const_get_at(globals->feature_module, rb_intern("LineString"));
VALUE geos_linear_ring_class = rb_define_class_under(globals->geos_module, "LinearRingImpl", geos_line_string_class);
globals->geos_linear_ring = geos_linear_ring_class;
globals->feature_linear_ring = rb_const_get_at(globals->feature_module, rb_intern("LinearRing"));
VALUE geos_line_class = rb_define_class_under(globals->geos_module, "LineImpl", geos_line_string_class);
globals->geos_line = geos_line_class;
globals->feature_line = rb_const_get_at(globals->feature_module, rb_intern("Line"));
rb_define_module_function(geos_line_string_class, "create", cmethod_create_line_string, 2);
rb_define_module_function(geos_line_string_class, "_copy_from", cmethod_line_string_copy_from, 2);
rb_define_method(geos_line_string_class, "eql?", method_line_string_eql, 1);
rb_define_method(geos_line_string_class, "geometry_type", method_line_string_geometry_type, 0);
rb_define_method(geos_line_string_class, "length", method_line_string_length, 0);
rb_define_method(geos_line_string_class, "num_points", method_line_string_num_points, 0);
rb_define_method(geos_line_string_class, "point_n", method_line_string_point_n, 1);
rb_define_method(geos_line_string_class, "points", method_line_string_points, 0);
rb_define_method(geos_line_string_class, "start_point", method_line_string_start_point, 0);
rb_define_method(geos_line_string_class, "end_point", method_line_string_end_point, 0);
rb_define_method(geos_line_string_class, "is_closed?", method_line_string_is_closed, 0);
rb_define_method(geos_line_string_class, "is_ring?", method_line_string_is_ring, 0);
rb_define_module_function(geos_linear_ring_class, "create", cmethod_create_linear_ring, 2);
rb_define_module_function(geos_linear_ring_class, "_copy_from", cmethod_linear_ring_copy_from, 2);
rb_define_method(geos_linear_ring_class, "geometry_type", method_linear_ring_geometry_type, 0);
rb_define_module_function(geos_line_class, "create", cmethod_create_line, 3);
rb_define_module_function(geos_line_class, "_copy_from", cmethod_line_copy_from, 2);
rb_define_method(geos_line_class, "geometry_type", method_line_geometry_type, 0);
}
/**
* Make the actual application call, we call the application instance with the
* method given and pass it ARGV and ENV in that order
*/
VALUE crate_wrap_app( VALUE arg )
{
crate_app *ca = (crate_app*)arg;
char *r = "Amalgalite::Requires.new( :dbfile_name => 'lib.db' )\n"\
"Amalgalite::Requires.new( :dbfile_name => 'app.db' )\n";
char buf[BUFSIZ];
char* dot ;
/* require the class file */
dot = strchr( ca->file_name, '.');
if ( NULL != dot ) { *dot = '\0' ; }
sprintf( buf,"%s\nrequire '%s'", r, ca->file_name);
rb_eval_string(buf);
/* get an instance of the application class and pack up the instance and the
* method
*/
ca->app_instance = rb_class_new_instance(0, 0, rb_const_get( rb_cObject, rb_intern( ca->class_name ) ) );
ca->run_method = rb_intern( ca->method_name );
return rb_funcall( ca->app_instance,
ca->run_method, 2,
rb_const_get_at( rb_cObject, rb_intern("ARGV") ),
rb_const_get_at( rb_cObject, rb_intern("ENV") ) );
}
void Init_openssl_rsa_pss_verify() {
fprintf(stderr, "VERSION: %s\n", SSLeay_version(SSLEAY_VERSION));
rb_mOpenSSL = rb_const_get_at(rb_cObject, rb_intern("OpenSSL"));
rb_mPKey = rb_const_get_at(rb_mOpenSSL, rb_intern("PKey"));
rb_cRSA = rb_const_get_at(rb_mPKey, rb_intern("RSA"));
rb_cRSAError = rb_const_get_at(rb_mPKey, rb_intern("RSAError"));
rb_define_private_method(rb_cRSA, "__verify_pss_sha1", ORPV__verify_pss_sha1, 4);
}
/* Hook up the ruby methods. Similar to lua's luaopen_(mod) functions */
void Init_gazelle_ruby_bindings() {
VALUE Gazelle = rb_const_get(rb_cObject, rb_intern("Gazelle"));
VALUE Gazelle_Parser = rb_const_get_at(Gazelle, rb_intern("Parser"));
rb_define_method(Gazelle_Parser, "parse?", rb_gazelle_parse_p, 1);
rb_define_method(Gazelle_Parser, "parse", rb_gazelle_parse, 1);
}
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_trenni() {
id_open_tag_begin = rb_intern("open_tag_begin");
id_open_tag_end = rb_intern("open_tag_end");
id_close_tag = rb_intern("close_tag");
id_cdata = rb_intern("cdata");
id_attribute = rb_intern("attribute");
id_comment = rb_intern("comment");
id_text = rb_intern("text");
id_doctype = rb_intern("doctype");
id_instruction = rb_intern("instruction");
id_expression = rb_intern("expression");
id_read = rb_intern("read");
id_key_get = rb_intern("[]");
rb_Trenni = rb_define_module("Trenni");
rb_Trenni_Native = rb_define_module_under(rb_Trenni, "Native");
rb_Trenni_ParseError = rb_const_get_at(rb_Trenni, rb_intern("ParseError"));
rb_define_module_function(rb_Trenni_Native, "parse_markup", Trenni_Native_parse_markup, 3);
rb_define_module_function(rb_Trenni_Native, "parse_template", Trenni_Native_parse_template, 2);
}
VALUE
rb_define_class_under(VALUE outer, const char *name, VALUE super)
{
VALUE klass;
ID id;
id = rb_intern(name);
if (rb_const_defined_at(outer, id)) {
klass = rb_const_get_at(outer, id);
if (TYPE(klass) != T_CLASS) {
rb_raise(rb_eTypeError, "%s is not a class", name);
}
if (RCLASS_RUBY(klass)) {
// Only for pure Ruby classes, as Objective-C classes
// might be returned from the dynamic resolver.
if (rb_class_real(RCLASS_SUPER(klass), true) != super) {
rb_name_error(id, "%s is already defined", name);
}
return klass;
}
}
if (!super) {
rb_warn("no super class for `%s::%s', Object assumed",
rb_class2name(outer), name);
}
klass = rb_define_class_id(id, super);
rb_set_class_path(klass, outer, name);
rb_const_set(outer, id, klass);
rb_class_inherited(super, klass);
return klass;
}
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();
}
static VALUE rb_czmq_ctx_socket(VALUE obj, VALUE type)
{
VALUE socket;
int socket_type;
struct nogvl_socket_args args;
zmq_sock_wrapper *sock = NULL;
errno = 0;
ZmqGetContext(obj);
if (TYPE(type) != T_FIXNUM && TYPE(type) != T_SYMBOL) rb_raise(rb_eTypeError, "wrong socket type %s (expected Fixnum or Symbol)", RSTRING_PTR(rb_obj_as_string(type)));
socket_type = FIX2INT((SYMBOL_P(type)) ? rb_const_get_at(rb_mZmq, rb_to_id(type)) : type);
socket = Data_Make_Struct(rb_czmq_ctx_socket_klass(socket_type), zmq_sock_wrapper, rb_czmq_mark_sock, rb_czmq_free_sock_gc, sock);
args.ctx = ctx->ctx;
args.type = socket_type;
sock->socket = (void*)rb_thread_blocking_region(rb_czmq_nogvl_socket_new, (void *)&args, RUBY_UBF_IO, 0);
ZmqAssertObjOnAlloc(sock->socket, sock);
#ifndef HAVE_RB_THREAD_BLOCKING_REGION
sock->str_buffer = zlist_new();
sock->frame_buffer = zlist_new();
sock->msg_buffer = zlist_new();
#endif
sock->handler = Qnil;
sock->flags = 0;
sock->ctx = ctx->ctx;
sock->verbose = FALSE;
sock->state = ZMQ_SOCKET_PENDING;
sock->endpoint = Qnil;
sock->thread = rb_thread_current();
sock->recv_timeout = ZMQ_SOCKET_DEFAULT_TIMEOUT;
sock->send_timeout = ZMQ_SOCKET_DEFAULT_TIMEOUT;
rb_obj_call_init(socket, 0, NULL);
return socket;
}
/*!
* Defines a class under the namespace of \a outer.
* \param outer a class which contains the new class.
* \param id name of the new 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_id_under(VALUE outer, ID id, VALUE super)
{
VALUE klass;
if (rb_const_defined_at(outer, id)) {
klass = rb_const_get_at(outer, id);
if (TYPE(klass) != T_CLASS) {
rb_raise(rb_eTypeError, "%s is not a class", rb_id2name(id));
}
if (rb_class_real(RCLASS_SUPER(klass)) != super) {
rb_name_error(id, "%s is already defined", rb_id2name(id));
}
return klass;
}
if (!super) {
rb_warn("no super class for `%s::%s', Object assumed",
rb_class2name(outer), rb_id2name(id));
}
klass = rb_define_class_id(id, super);
rb_set_class_path_string(klass, outer, rb_id2str(id));
rb_const_set(outer, id, klass);
rb_class_inherited(super, klass);
rb_gc_register_mark_object(klass);
return klass;
}
VALUE
rb_define_class_under(VALUE outer, const char *name, VALUE super)
{
VALUE klass;
ID id;
id = rb_intern(name);
if (rb_const_defined_at(outer, id)) {
klass = rb_const_get_at(outer, 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::%s', Object assumed",
rb_class2name(outer), name);
}
klass = rb_define_class_id(id, super);
rb_set_class_path(klass, outer, name);
rb_const_set(outer, id, klass);
rb_class_inherited(super, klass);
return klass;
}
/*
* Removes a file or directory, using File.unlink if +self+ is a file, or
* Dir.unlink as necessary.
*/
static VALUE
path_unlink(VALUE self)
{
VALUE eENOTDIR = rb_const_get_at(rb_mErrno, rb_intern("ENOTDIR"));
VALUE str = get_strpath(self);
return rb_rescue2(unlink_body, str, unlink_rescue, str, eENOTDIR, (VALUE)0);
}
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");
}
void Init_cmultibyte() {
idUnpack = rb_intern("unpack");
idPack = rb_intern("pack");
idForceEncoding = rb_intern("force_encoding");
rb_funcall(rb_cObject, rb_intern("require"), 1, rb_str_new2("active_support/all"));
ActiveSupport = rb_const_get(rb_cObject, rb_intern("ActiveSupport"));
Multibyte = rb_const_get_at(ActiveSupport, rb_intern("Multibyte"));
Unicode = rb_const_get_at(Multibyte, rb_intern("Unicode"));
VALUE database = rb_funcall(Unicode, rb_intern("database"), 0);
rb_funcall(database, rb_intern("load"), 0);
VALUE cp1252_hash = rb_ivar_get(database, rb_intern("@cp1252"));
cp1252_hash_to_array(cp1252_hash);
rb_define_singleton_method(Unicode, "tidy_byte", rb_tidy_byte, 1);
rb_define_singleton_method(Unicode, "tidy_bytes", rb_tidy_bytes, -1);
}
static VALUE method_factory_write_for_psych(VALUE self, VALUE obj)
{
RGeo_FactoryData* self_data;
GEOSContextHandle_t self_context;
GEOSWKTWriter* wkt_writer;
const GEOSGeometry* geom;
VALUE result;
char* str;
size_t size;
char has_3d;
#ifndef RGEO_GEOS_SUPPORTS_SETOUTPUTDIMENSION
RGeo_Globals* globals;
VALUE wkt_generator;
#endif
self_data = RGEO_FACTORY_DATA_PTR(self);
self_context = self_data->geos_context;
has_3d = self_data->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M;
#ifndef RGEO_GEOS_SUPPORTS_SETOUTPUTDIMENSION
if (has_3d) {
globals = self_data->globals;
wkt_generator = globals->psych_wkt_generator;
if (NIL_P(wkt_generator)) {
wkt_generator = rb_funcall(
rb_const_get_at(globals->geos_module, rb_intern("Utils")),
rb_intern("psych_wkt_generator"), 0);
globals->psych_wkt_generator = wkt_generator;
}
return rb_funcall(wkt_generator, globals->id_generate, 1, obj);
}
#endif
wkt_writer = self_data->psych_wkt_writer;
if (!wkt_writer) {
wkt_writer = GEOSWKTWriter_create_r(self_context);
if (has_3d) {
GEOSWKTWriter_setOutputDimension_r(self_context, wkt_writer, 3);
}
self_data->psych_wkt_writer = wkt_writer;
}
result = Qnil;
if (wkt_writer) {
geom = rgeo_get_geos_geometry_safe(obj);
if (geom) {
str = GEOSWKTWriter_write_r(self_context, wkt_writer, geom);
if (str) {
result = rb_str_new2(str);
GEOSFree_r(self_context, str);
}
}
}
return result;
}
/*
* call-seq:
* parser.mark # => #<Psych::Parser::Mark>
*
* Returns a Psych::Parser::Mark object that contains line, column, and index
* information.
*/
static VALUE mark(VALUE self)
{
VALUE mark_klass;
VALUE args[3];
yaml_parser_t * parser;
Data_Get_Struct(self, yaml_parser_t, parser);
mark_klass = rb_const_get_at(cPsychParser, rb_intern("Mark"));
args[0] = INT2NUM(parser->mark.index);
args[1] = INT2NUM(parser->mark.line);
args[2] = INT2NUM(parser->mark.column);
return rb_class_new_instance(3, args, mark_klass);
}
void
ox_sax_define() {
VALUE sax_module = rb_const_get_at(Ox, rb_intern("Sax"));
ox_sax_value_class = rb_define_class_under(sax_module, "Value", rb_cObject);
rb_define_method(ox_sax_value_class, "as_s", sax_value_as_s, 0);
rb_define_method(ox_sax_value_class, "as_sym", sax_value_as_sym, 0);
rb_define_method(ox_sax_value_class, "as_i", sax_value_as_i, 0);
rb_define_method(ox_sax_value_class, "as_f", sax_value_as_f, 0);
rb_define_method(ox_sax_value_class, "as_time", sax_value_as_time, 0);
rb_define_method(ox_sax_value_class, "as_bool", sax_value_as_bool, 0);
rb_define_method(ox_sax_value_class, "empty?", sax_value_empty, 0);
}
void rgeo_init_geos_point(RGeo_Globals* globals)
{
VALUE geos_point_class = rb_define_class_under(globals->geos_module, "PointImpl", globals->geos_geometry);
globals->geos_point = geos_point_class;
globals->feature_point = rb_const_get_at(globals->feature_module, rb_intern("Point"));
rb_define_module_function(geos_point_class, "create", cmethod_create, 4);
rb_define_method(geos_point_class, "eql?", method_point_eql, 1);
rb_define_method(geos_point_class, "geometry_type", method_point_geometry_type, 0);
rb_define_method(geos_point_class, "x", method_point_x, 0);
rb_define_method(geos_point_class, "y", method_point_y, 0);
rb_define_method(geos_point_class, "z", method_point_z, 0);
rb_define_method(geos_point_class, "m", method_point_m, 0);
}
/*
* call-seq:
* parser.external_encoding=(encoding)
*
* Set the encoding for this parser to +encoding+
*/
static VALUE set_external_encoding(VALUE self, VALUE encoding)
{
yaml_parser_t * parser;
VALUE exception;
Data_Get_Struct(self, yaml_parser_t, parser);
if(parser->encoding) {
exception = rb_const_get_at(mPsych, rb_intern("Exception"));
rb_raise(exception, "don't set the encoding twice!");
}
yaml_parser_set_encoding(parser, NUM2INT(encoding));
return encoding;
}
VALUE
rb_define_module_under(VALUE outer, const char *name)
{
ID id = rb_intern(name);
if (rb_const_defined_at(outer, id)) {
VALUE module = rb_const_get_at(outer, id);
if (TYPE(module) == T_MODULE) {
return module;
}
rb_raise(rb_eTypeError, "%s::%s:%s is not a module",
rb_class2name(outer), name, rb_obj_classname(module));
}
VALUE module = rb_define_module_id(id);
rb_const_set(outer, id, module);
rb_set_class_path(module, outer, name);
return module;
}
void rgeo_init_geos_polygon(RGeo_Globals* globals)
{
VALUE geos_polygon_class = rb_define_class_under(globals->geos_module, "PolygonImpl", globals->geos_geometry);
globals->geos_polygon = geos_polygon_class;
globals->feature_polygon = rb_const_get_at(globals->feature_module, rb_intern("Polygon"));
rb_define_module_function(geos_polygon_class, "create", cmethod_create, 3);
rb_define_method(geos_polygon_class, "eql?", method_polygon_eql, 1);
rb_define_method(geos_polygon_class, "geometry_type", method_polygon_geometry_type, 0);
rb_define_method(geos_polygon_class, "area", method_polygon_area, 0);
rb_define_method(geos_polygon_class, "centroid", method_polygon_centroid, 0);
rb_define_method(geos_polygon_class, "point_on_surface", method_polygon_point_on_surface, 0);
rb_define_method(geos_polygon_class, "exterior_ring", method_polygon_exterior_ring, 0);
rb_define_method(geos_polygon_class, "num_interior_rings", method_polygon_num_interior_rings, 0);
rb_define_method(geos_polygon_class, "interior_ring_n", method_polygon_interior_ring_n, 1);
rb_define_method(geos_polygon_class, "interior_rings", method_polygon_interior_rings, 0);
}
void rgeo_init_geos_geometry(RGeo_Globals* globals)
{
VALUE geos_geometry_class = rb_define_class_under(globals->geos_module, "GeometryImpl", rb_cObject);
globals->geos_geometry = geos_geometry_class;
globals->feature_geometry = rb_const_get_at(globals->feature_module, rb_intern("Geometry"));
rb_define_alloc_func(geos_geometry_class, alloc_geometry);
rb_define_method(geos_geometry_class, "_set_factory", method_geometry_set_factory, 1);
rb_define_method(geos_geometry_class, "initialize_copy", method_geometry_initialize_copy, 1);
rb_define_method(geos_geometry_class, "initialized?", method_geometry_initialized_p, 0);
rb_define_method(geos_geometry_class, "factory", method_geometry_factory, 0);
rb_define_method(geos_geometry_class, "dimension", method_geometry_dimension, 0);
rb_define_method(geos_geometry_class, "geometry_type", method_geometry_geometry_type, 0);
rb_define_method(geos_geometry_class, "srid", method_geometry_srid, 0);
rb_define_method(geos_geometry_class, "envelope", method_geometry_envelope, 0);
rb_define_method(geos_geometry_class, "boundary", method_geometry_boundary, 0);
rb_define_method(geos_geometry_class, "as_text", method_geometry_as_text, 0);
rb_define_method(geos_geometry_class, "to_s", method_geometry_as_text, 0);
rb_define_method(geos_geometry_class, "as_binary", method_geometry_as_binary, 0);
rb_define_method(geos_geometry_class, "is_empty?", method_geometry_is_empty, 0);
rb_define_method(geos_geometry_class, "is_simple?", method_geometry_is_simple, 0);
rb_define_method(geos_geometry_class, "equals?", method_geometry_equals, 1);
rb_define_method(geos_geometry_class, "==", method_geometry_equals, 1);
rb_define_method(geos_geometry_class, "eql?", method_geometry_eql, 1);
rb_define_method(geos_geometry_class, "disjoint?", method_geometry_disjoint, 1);
rb_define_method(geos_geometry_class, "intersects?", method_geometry_intersects, 1);
rb_define_method(geos_geometry_class, "touches?", method_geometry_touches, 1);
rb_define_method(geos_geometry_class, "crosses?", method_geometry_crosses, 1);
rb_define_method(geos_geometry_class, "within?", method_geometry_within, 1);
rb_define_method(geos_geometry_class, "contains?", method_geometry_contains, 1);
rb_define_method(geos_geometry_class, "overlaps?", method_geometry_overlaps, 1);
rb_define_method(geos_geometry_class, "relate?", method_geometry_relate, 2);
rb_define_method(geos_geometry_class, "distance", method_geometry_distance, 1);
rb_define_method(geos_geometry_class, "buffer", method_geometry_buffer, 1);
rb_define_method(geos_geometry_class, "convex_hull", method_geometry_convex_hull, 0);
rb_define_method(geos_geometry_class, "intersection", method_geometry_intersection, 1);
rb_define_method(geos_geometry_class, "*", method_geometry_intersection, 1);
rb_define_method(geos_geometry_class, "union", method_geometry_union, 1);
rb_define_method(geos_geometry_class, "+", method_geometry_union, 1);
rb_define_method(geos_geometry_class, "difference", method_geometry_difference, 1);
rb_define_method(geos_geometry_class, "-", method_geometry_difference, 1);
rb_define_method(geos_geometry_class, "sym_difference", method_geometry_sym_difference, 1);
}
VALUE
rb_define_module_id_under(VALUE outer, ID id)
{
VALUE module;
if (rb_const_defined_at(outer, id)) {
module = rb_const_get_at(outer, id);
if (TYPE(module) == T_MODULE)
return module;
rb_raise(rb_eTypeError, "%s::%s is not a module",
rb_class2name(outer), rb_obj_classname(module));
}
module = rb_define_module_id(id);
rb_const_set(outer, id, module);
rb_set_class_path_string(module, outer, rb_id2str(id));
rb_gc_register_mark_object(module);
return module;
}
static VALUE cmethod_factory_create(VALUE klass, VALUE flags, VALUE srid, VALUE buffer_resolution,
VALUE wkt_generator, VALUE wkb_generator, VALUE proj4_obj, VALUE coord_sys_obj)
{
VALUE result;
RGeo_FactoryData* data;
GEOSContextHandle_t context;
VALUE wrapped_globals;
result = Qnil;
data = ALLOC(RGeo_FactoryData);
if (data) {
context = initGEOS_r(message_handler, message_handler);
if (context) {
wrapped_globals = rb_const_get_at(klass, rb_intern("INTERNAL_CGLOBALS"));
data->globals = (RGeo_Globals*)DATA_PTR(wrapped_globals);
data->geos_context = context;
data->flags = NUM2INT(flags);
data->srid = NUM2INT(srid);
data->buffer_resolution = NUM2INT(buffer_resolution);
data->wkt_reader = NULL;
data->wkb_reader = NULL;
data->wkt_writer = NULL;
data->wkb_writer = NULL;
data->psych_wkt_reader = NULL;
data->marshal_wkb_reader = NULL;
data->psych_wkt_writer = NULL;
data->marshal_wkb_writer = NULL;
data->wkrep_wkt_generator = wkt_generator;
data->wkrep_wkb_generator = wkb_generator;
data->wkrep_wkt_parser = Qnil;
data->wkrep_wkb_parser = Qnil;
data->proj4_obj = proj4_obj;
data->coord_sys_obj = coord_sys_obj;
result = Data_Wrap_Struct(klass, mark_factory_func, destroy_factory_func, data);
}
else {
free(data);
}
}
return result;
}
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;
}
RGeo_Globals* rgeo_init_geos_factory()
{
RGeo_Globals* globals;
VALUE rgeo_module;
VALUE geos_factory_class;
VALUE wrapped_globals;
VALUE feature_module;
globals = ALLOC(RGeo_Globals);
// Cache some modules so we don't have to look them up by name every time
rgeo_module = rb_define_module("RGeo");
feature_module = rb_define_module_under(rgeo_module, "Feature");
globals->feature_module = feature_module;
globals->geos_module = rb_define_module_under(rgeo_module, "Geos");
globals->feature_geometry = rb_const_get_at(feature_module, rb_intern("Geometry"));
globals->feature_point = rb_const_get_at(feature_module, rb_intern("Point"));
globals->feature_line_string = rb_const_get_at(feature_module, rb_intern("LineString"));
globals->feature_linear_ring = rb_const_get_at(feature_module, rb_intern("LinearRing"));
globals->feature_line = rb_const_get_at(feature_module, rb_intern("Line"));
globals->feature_polygon = rb_const_get_at(feature_module, rb_intern("Polygon"));
globals->feature_geometry_collection = rb_const_get_at(feature_module, rb_intern("GeometryCollection"));
globals->feature_multi_point = rb_const_get_at(feature_module, rb_intern("MultiPoint"));
globals->feature_multi_line_string = rb_const_get_at(feature_module, rb_intern("MultiLineString"));
globals->feature_multi_polygon = rb_const_get_at(feature_module, rb_intern("MultiPolygon"));
// Cache some commonly used names
globals->id_cast = rb_intern("cast");
globals->id_eql = rb_intern("eql?");
globals->id_generate = rb_intern("generate");
globals->id_enum_for = rb_intern("enum_for");
globals->id_hash = rb_intern("hash");
globals->sym_force_new = ID2SYM(rb_intern("force_new"));
globals->sym_keep_subtype = ID2SYM(rb_intern("keep_subtype"));
#ifndef RGEO_GEOS_SUPPORTS_SETOUTPUTDIMENSION
globals->psych_wkt_generator = Qnil;
globals->marshal_wkb_generator = Qnil;
#endif
// Add C methods to the factory.
geos_factory_class = rb_define_class_under(globals->geos_module, "CAPIFactory", rb_cObject);
rb_define_alloc_func(geos_factory_class, alloc_factory);
rb_define_method(geos_factory_class, "initialize_copy", method_factory_initialize_copy, 1);
rb_define_method(geos_factory_class, "_parse_wkt_impl", method_factory_parse_wkt, 1);
rb_define_method(geos_factory_class, "_parse_wkb_impl", method_factory_parse_wkb, 1);
rb_define_method(geos_factory_class, "_srid", method_factory_srid, 0);
rb_define_method(geos_factory_class, "_buffer_resolution", method_factory_buffer_resolution, 0);
rb_define_method(geos_factory_class, "_flags", method_factory_flags, 0);
rb_define_method(geos_factory_class, "_set_wkrep_parsers", method_set_wkrep_parsers, 2);
rb_define_method(geos_factory_class, "_proj4", method_get_proj4, 0);
rb_define_method(geos_factory_class, "_coord_sys", method_get_coord_sys, 0);
rb_define_method(geos_factory_class, "_wkt_generator", method_get_wkt_generator, 0);
rb_define_method(geos_factory_class, "_wkb_generator", method_get_wkb_generator, 0);
rb_define_method(geos_factory_class, "_wkt_parser", method_get_wkt_parser, 0);
rb_define_method(geos_factory_class, "_wkb_parser", method_get_wkb_parser, 0);
rb_define_method(geos_factory_class, "_read_for_marshal", method_factory_read_for_marshal, 1);
rb_define_method(geos_factory_class, "_write_for_marshal", method_factory_write_for_marshal, 1);
rb_define_method(geos_factory_class, "_read_for_psych", method_factory_read_for_psych, 1);
rb_define_method(geos_factory_class, "_write_for_psych", method_factory_write_for_psych, 1);
rb_define_module_function(geos_factory_class, "_create", cmethod_factory_create, 7);
rb_define_module_function(geos_factory_class, "_geos_version", cmethod_factory_geos_version, 0);
// Pre-define implementation classes and set up allocation methods
globals->geos_geometry = rb_define_class_under(globals->geos_module, "CAPIGeometryImpl", rb_cObject);
rb_define_alloc_func(globals->geos_geometry, alloc_geometry);
globals->geos_point = rb_define_class_under(globals->geos_module, "CAPIPointImpl", rb_cObject);
rb_define_alloc_func(globals->geos_point, alloc_geometry);
globals->geos_line_string = rb_define_class_under(globals->geos_module, "CAPILineStringImpl", rb_cObject);
rb_define_alloc_func(globals->geos_line_string, alloc_geometry);
globals->geos_linear_ring = rb_define_class_under(globals->geos_module, "CAPILinearRingImpl", rb_cObject);
rb_define_alloc_func(globals->geos_linear_ring, alloc_geometry);
globals->geos_line = rb_define_class_under(globals->geos_module, "CAPILineImpl", rb_cObject);
rb_define_alloc_func(globals->geos_line, alloc_geometry);
globals->geos_polygon = rb_define_class_under(globals->geos_module, "CAPIPolygonImpl", rb_cObject);
rb_define_alloc_func(globals->geos_polygon, alloc_geometry);
globals->geos_geometry_collection = rb_define_class_under(globals->geos_module, "CAPIGeometryCollectionImpl", rb_cObject);
rb_define_alloc_func(globals->geos_geometry_collection, alloc_geometry);
globals->geos_multi_point = rb_define_class_under(globals->geos_module, "CAPIMultiPointImpl", rb_cObject);
rb_define_alloc_func(globals->geos_multi_point, alloc_geometry);
globals->geos_multi_line_string = rb_define_class_under(globals->geos_module, "CAPIMultiLineStringImpl", rb_cObject);
rb_define_alloc_func(globals->geos_multi_line_string, alloc_geometry);
globals->geos_multi_polygon = rb_define_class_under(globals->geos_module, "CAPIMultiPolygonImpl", rb_cObject);
rb_define_alloc_func(globals->geos_multi_polygon, alloc_geometry);
// Wrap the globals in a Ruby object and store it off so we have access
// to it later. Each factory instance will reference it internally.
wrapped_globals = Data_Wrap_Struct(rb_cObject, mark_globals_func, destroy_globals_func, globals);
rb_define_const(geos_factory_class, "INTERNAL_CGLOBALS", wrapped_globals);
return globals;
}
static VALUE ORPV__verify_pss_sha1(VALUE self, VALUE vPubKey, VALUE vSig, VALUE vHashData, VALUE vSaltLen) {
enum ORPV_errors err = OK;
BIO * pkey_bio = NULL;
RSA * rsa_pub_key = NULL;
EVP_PKEY * pkey = NULL;
EVP_PKEY_CTX * pkey_ctx = NULL;
char * pub_key = NULL;
int verify_rval = -1, salt_len;
char ossl_err_strs[(OSSL_ERR_STR_LEN + 2) * ORPV_MAX_ERRS] = "";
if (ERR_peek_error()) {
err = EXTERNAL;
goto Cleanup;
}
vPubKey = StringValue(vPubKey);
vSig = StringValue(vSig);
vHashData = StringValue(vHashData);
salt_len = NUM2INT(vSaltLen);
if (RSTRING_LEN(vPubKey) > (long)INT_MAX) {
err = KEY_OVERFLOW;
goto Cleanup;
}
pub_key = malloc(RSTRING_LEN(vPubKey));
if (! pub_key) {
err = NOMEM;
goto Cleanup;
}
memcpy(pub_key, StringValuePtr(vPubKey), RSTRING_LEN(vPubKey));
pkey_bio = BIO_new_mem_buf(pub_key, (int)RSTRING_LEN(vPubKey));
rsa_pub_key = PEM_read_bio_RSA_PUBKEY(pkey_bio, NULL, NULL, NULL);
if (! rsa_pub_key) {
err = PUBKEY_PARSE;
goto Cleanup;
}
pkey = EVP_PKEY_new();
if (! pkey) {
err = PKEY_INIT;
goto Cleanup;
}
if (! EVP_PKEY_set1_RSA(pkey, rsa_pub_key)) {
err = RSA_ASSIGN;
goto Cleanup;
}
pkey_ctx = EVP_PKEY_CTX_new(pkey, ENGINE_get_default_RSA());
if (! pkey_ctx) {
err = PKEY_CTX_INIT;
goto Cleanup;
}
if (EVP_PKEY_verify_init(pkey_ctx) <= 0) {
err = VERIFY_INIT;
goto Cleanup;
}
if (EVP_PKEY_CTX_set_signature_md(pkey_ctx, EVP_sha1()) <= 0) {
err = SET_SIG_MD;
goto Cleanup;
}
if (EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING) <= 0) {
err = SET_PADDING;
goto Cleanup;
}
if (EVP_PKEY_CTX_set_rsa_pss_saltlen(pkey_ctx, salt_len) <= 0) {
err = SET_SALTLEN;
goto Cleanup;
}
verify_rval = EVP_PKEY_verify(pkey_ctx,
(unsigned char*)StringValuePtr(vSig), (size_t)RSTRING_LEN(vSig),
(unsigned char*)StringValuePtr(vHashData), (size_t)RSTRING_LEN(vHashData));
Cleanup:
/*
* BIO * pkey_bio = NULL;
* RSA * rsa_pub_key = NULL;
* EVP_PKEY * pkey = NULL;
* EVP_PKEY_CTX * pkey_ctx = NULL;
* char * pub_key = NULL;
*/
if (pkey_ctx) EVP_PKEY_CTX_free(pkey_ctx);
if (pkey) EVP_PKEY_free(pkey);
if (rsa_pub_key) RSA_free(rsa_pub_key);
if (pkey_bio) BIO_free(pkey_bio);
if (pub_key) free(pub_key);
switch (err) {
case OK:
switch (verify_rval) {
case 1:
return Qtrue;
case 0:
return Qfalse;
default:
bind_err_strs(ossl_err_strs, ORPV_MAX_ERRS);
rb_raise(rb_cRSAError, "An error occurred during validation.\n%s", ossl_err_strs);
}
break;
case EXTERNAL:
bind_err_strs(ossl_err_strs, ORPV_MAX_ERRS);
rb_raise(rb_eRuntimeError, "OpenSSL was in an error state prior to invoking this verification.\n%s", ossl_err_strs);
break;
case KEY_OVERFLOW:
rb_raise(rb_cRSAError, "Your public key is too big. How is that even possible?");
break;
case NOMEM:
rb_raise(rb_const_get_at(rb_mErrno, rb_intern("ENOMEM")), "Insufficient memory to allocate pubkey copy. Woof.");
break;
case PUBKEY_PARSE:
bind_err_strs(ossl_err_strs, ORPV_MAX_ERRS);
rb_raise(rb_cRSAError, "Error parsing public key\n%s", ossl_err_strs);
break;
case PKEY_INIT:
bind_err_strs(ossl_err_strs, ORPV_MAX_ERRS);
rb_raise(rb_cRSAError, "Failed to initialize PKEY\n%s", ossl_err_strs);
break;
case RSA_ASSIGN:
bind_err_strs(ossl_err_strs, ORPV_MAX_ERRS);
rb_raise(rb_cRSAError, "Failed to assign RSA object to PKEY\n%s", ossl_err_strs);
break;
case PKEY_CTX_INIT:
bind_err_strs(ossl_err_strs, ORPV_MAX_ERRS);
rb_raise(rb_cRSAError, "Failed to initialize PKEY context.\n%s", ossl_err_strs);
break;
case VERIFY_INIT:
bind_err_strs(ossl_err_strs, ORPV_MAX_ERRS);
rb_raise(rb_cRSAError, "Failed to initialize verification process.\n%s", ossl_err_strs);
break;
case SET_SIG_MD:
bind_err_strs(ossl_err_strs, ORPV_MAX_ERRS);
rb_raise(rb_cRSAError, "Failed to set signature message digest to SHA1.\n%s", ossl_err_strs);
break;
case SET_PADDING:
bind_err_strs(ossl_err_strs, ORPV_MAX_ERRS);
rb_raise(rb_cRSAError, "Failed to set PSS padding.\n%s", ossl_err_strs);
break;
case SET_SALTLEN:
bind_err_strs(ossl_err_strs, ORPV_MAX_ERRS);
rb_raise(rb_cRSAError, "Failed to set salt length.\n%s", ossl_err_strs);
break;
default:
bind_err_strs(ossl_err_strs, ORPV_MAX_ERRS);
rb_raise(rb_eRuntimeError, "Something has gone horribly wrong.\n%s", ossl_err_strs);
}
return Qnil;
}
static VALUE module_specs_const_get_at(VALUE self, VALUE klass, VALUE val) {
return rb_const_get_at(klass, SYM2ID(val));
}
