ruby-magic 0.0.1 → 0.4.0

data/ext/magic/ruby-magic.h

@@ -1,23 +1,3 @@
-/* :enddoc: */
-
-/*
- * ruby-magic.h
- *
- * Copyright 2013-2014 Krzysztof Wilczynski
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 #if !defined(_RUBY_MAGIC_H)
 #define _RUBY_MAGIC_H 1
 
@@ -28,217 +8,447 @@ extern "C" {
 #include "common.h"
 #include "functions.h"
 
-#define DATA_P(x)   (TYPE(x) == T_DATA)
-#define STRING_P(x) (TYPE(x) == T_STRING)
-#define ARRAY_P(x)  (TYPE(x) == T_ARRAY)
+#define MAGIC_SYNCHRONIZED(f, d) magic_lock(object, (f), (d))
 
-#if !defined(STR2CSTR)
-# define STR2CSTR(x) StringValuePtr(x)
-#endif
+#define MAGIC_OBJECT(o) \
+	TypedData_Get_Struct(object, magic_object_t, &rb_magic_type, (o))
 
-#if !defined(RVAL2CSTR)
-# define RVAL2CSTR(x) (NIL_P(x) ? NULL : STR2CSTR(x))
-#endif
+#define MAGIC_COOKIE(o, c) \
+	((c) = MAGIC_OBJECT((o))->cookie)
 
-#if !defined(CSTR2RVAL)
-# define CSTR2RVAL(x) ((x) == NULL ? Qnil : rb_str_new2(x))
-#endif
+#define MAGIC_CLOSED_P(o) RTEST(rb_mgc_close_p((o)))
+#define MAGIC_LOADED_P(o) RTEST(rb_mgc_load_p((o)))
 
-#if !defined(RARRAY_LEN)
-# define RARRAY_LEN(a) (RARRAY(a)->len)
-#endif
+#define MAGIC_WARNING(i, ...)				  \
+	do {						  \
+		if (!(i) || !(rb_mgc_warning & BIT(i))) { \
+			rb_mgc_warning |= BIT(i);	  \
+			rb_warn(__VA_ARGS__);		  \
+		}					  \
+	} while(0)
 
-#if !defined(RSTRING_LEN)
-# define RSTRING_LEN(s) (RSTRING(s)->len)
-#endif
+#define MAGIC_ARGUMENT_TYPE_ERROR(o, ...) \
+	rb_raise(rb_eTypeError, error(E_ARGUMENT_TYPE_INVALID), CLASS_NAME((o)), __VA_ARGS__)
 
-#if !defined(RSTRING_PTR)
-# define RSTRING_PTR(s) (RSTRING(s)->ptr)
-#endif
+#define MAGIC_GENERIC_ERROR(k, e, m) \
+	rb_exc_raise(magic_generic_error((k), (e), error(m)))
 
-#define RSTRING_EMPTY_P(s) (RSTRING_LEN(s) == 0)
-#define RARRAY_EMPTY_P(a)  (RARRAY_LEN(a) == 0)
-#define RARRAY_FIRST(a)    (RARRAY_EMPTY_P(a) ? Qnil : RARRAY_PTR(a)[0])
-
-#define NOGVL_FUNCTION (VALUE (*)(void *))
-
-#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) && \
-     defined(HAVE_RUBY_THREAD_H) && HAVE_RUBY_THREAD_H
-# include <ruby/thread.h>
-# define NOGVL(f, d) \
-   rb_thread_call_without_gvl((f), (d), RUBY_UBF_IO, NULL)
-#elif defined(HAVE_RB_THREAD_BLOCKING_REGION)
-# define NOGVL(f, d) \
-   rb_thread_blocking_region(NOGVL_FUNCTION(f), (d), RUBY_UBF_IO, NULL)
-#else
-# include <rubysig.h>
-static inline VALUE
-fake_blocking_region(VALUE (*f)(ANYARGS), void *data)
-{
-  VALUE rv;
+#define MAGIC_LIBRARY_ERROR(c) \
+	rb_exc_raise(magic_library_error(rb_mgc_eMagicError, (c)))
 
-  TRAP_BEG;
-  rv = f(data);
-  TRAP_END;
+#define MAGIC_CHECK_INTEGER_TYPE(o) magic_check_type((o), T_FIXNUM)
+#define MAGIC_CHECK_STRING_TYPE(o)  magic_check_type((o), T_STRING)
 
-  return rv;
-}
-# define NOGVL(f, d) fake_blocking_region(NOGVL_FUNCTION(f), (d))
-#endif
+#define MAGIC_CHECK_ARGUMENT_MISSING(t, o)					     \
+	do {									     \
+		if ((t) < (o))							     \
+			rb_raise(rb_eArgError, error(E_ARGUMENT_MISSING), (t), (o)); \
+	} while(0)
 
-#define MAGIC_SYNCHRONIZED(f, d) magic_lock(object, (f), (d))
+#define MAGIC_CHECK_ARRAY_EMPTY(o)							  \
+	do {										  \
+		if (RARRAY_EMPTY_P(o))							  \
+			rb_raise(rb_eArgError, "%s", error(E_ARGUMENT_TYPE_ARRAY_EMPTY)); \
+	} while(0)
 
-#define MAGIC_COOKIE(c) \
-    Data_Get_Struct(object, struct magic_set, (c))
+#define MAGIC_CHECK_ARRAY_OF_STRINGS(o) \
+	magic_check_type_array_of_strings((o))
 
-#define MAGIC_CLOSED_P(o) RTEST(rb_mgc_closed((o)))
+#define MAGIC_CHECK_OPEN(o)						  \
+	do {								  \
+		if (MAGIC_CLOSED_P(o))					  \
+			MAGIC_GENERIC_ERROR(rb_mgc_eLibraryError, EFAULT, \
+					    E_MAGIC_LIBRARY_CLOSED);	  \
+	} while(0)
 
-#define MAGIC_GENERIC_ERROR(k, e, m)                        \
-    do {                                                    \
-        VALUE __e_##k = magic_generic_error((k), (e), (m)); \
-        rb_exc_raise(__e_##k);                              \
-    } while(0)
+#define MAGIC_CHECK_LOADED(o)						 \
+	do {								 \
+		if (!MAGIC_LOADED_P(o))					 \
+			MAGIC_GENERIC_ERROR(rb_mgc_eMagicError, EFAULT,	 \
+					    E_MAGIC_LIBRARY_NOT_LOADED); \
+	} while(0)
 
-#define MAGIC_LIBRARY_ERROR(c)                                              \
-    do {                                                                    \
-        VALUE __e_library = magic_library_error(rb_mgc_eMagicError, (c));   \
-        rb_exc_raise(__e_library);                                          \
-    } while(0)
+#define MAGIC_STRINGIFY(s) #s
 
-#define CHECK_MAGIC_OPEN(o)                                         \
-    do {                                                            \
-        if (MAGIC_CLOSED_P(o)) {                                    \
-            MAGIC_GENERIC_ERROR(rb_mgc_eLibraryError, EFAULT,       \
-                                    error(E_MAGIC_LIBRARY_CLOSED)); \
-        }                                                           \
-    } while(0)                                                      \
+#define MAGIC_DEFINE_FLAG(c) \
+	rb_define_const(rb_cMagic, MAGIC_STRINGIFY(c), INT2NUM(MAGIC_##c));
+
+#define MAGIC_DEFINE_PARAMETER(c) \
+	rb_define_const(rb_cMagic, MAGIC_STRINGIFY(PARAM_##c), INT2NUM(MAGIC_PARAM_##c));
 
 #define error(t) errors[(t)]
 
 enum error {
-    E_UNKNOWN = 0,
-    E_NOT_IMPLEMENTED,
-    E_MAGIC_LIBRARY_INITIALIZE,
-    E_MAGIC_LIBRARY_CLOSED,
-    E_FLAG_INVALID_VALUE,
-    E_FLAG_NOT_IMPLEMENTED
+	E_UNKNOWN = 0,
+	E_NOT_ENOUGH_MEMORY,
+	E_ARGUMENT_MISSING,
+	E_ARGUMENT_TYPE_INVALID,
+	E_ARGUMENT_TYPE_UNKNOWN,
+	E_ARGUMENT_TYPE_ARRAY_EMPTY,
+	E_ARGUMENT_TYPE_ARRAY_STRINGS,
+	E_MAGIC_LIBRARY_INITIALIZE,
+	E_MAGIC_LIBRARY_CLOSED,
+	E_MAGIC_LIBRARY_NOT_LOADED,
+	E_PARAM_INVALID_TYPE,
+	E_PARAM_INVALID_VALUE,
+	E_FLAG_NOT_IMPLEMENTED,
+	E_FLAG_INVALID_TYPE
 };
 
-union file {
-    int fd;
-    const char *path;
-};
+typedef struct parameter {
+	size_t value;
+	int tag;
+} parameter_t;
+
+typedef union file {
+	const char *path;
+	int fd;
+} file_t;
+
+typedef struct buffers {
+	size_t count;
+	size_t *sizes;
+	void **pointers;
+} buffers_t;
+
+typedef struct magic_object {
+	magic_t cookie;
+	VALUE mutex;
+	unsigned int database_loaded:1;
+	unsigned int stop_on_errors:1;
+} magic_object_t;
+
+typedef struct magic_arguments {
+	union {
+		file_t file;
+		parameter_t parameter;
+		buffers_t buffers;
+	} type;
+	magic_t cookie;
+	const char *result;
+	int flags;
+	int status;
+	unsigned int stop_on_errors:1;
+} magic_arguments_t;
+
+typedef struct magic_exception {
+	const char *magic_error;
+	VALUE klass;
+	int magic_errno;
+} magic_exception_t;
 
-struct buffer {
-    size_t size;
-    const char *buffer;
+static const char *errors[] = {
+	[E_UNKNOWN]			= "an unknown error has occurred",
+	[E_NOT_ENOUGH_MEMORY]		= "cannot allocate memory",
+	[E_ARGUMENT_MISSING]		= "wrong number of arguments (given %d, expected %d)",
+	[E_ARGUMENT_TYPE_INVALID]	= "wrong argument type %s (expected %s)",
+	[E_ARGUMENT_TYPE_UNKNOWN]	= "unknown type 0x%x (0x%x given)",
+	[E_ARGUMENT_TYPE_ARRAY_EMPTY]	= "arguments list cannot be empty (expected array of String)",
+	[E_ARGUMENT_TYPE_ARRAY_STRINGS]	= "wrong argument type %s in arguments list (expected String)",
+	[E_MAGIC_LIBRARY_INITIALIZE]	= "failed to initialize Magic library",
+	[E_MAGIC_LIBRARY_CLOSED]	= "Magic library is not open",
+	[E_MAGIC_LIBRARY_NOT_LOADED]	= "Magic library not loaded",
+	[E_PARAM_INVALID_TYPE]		= "unknown or invalid parameter specified",
+	[E_PARAM_INVALID_VALUE]		= "invalid parameter value specified",
+	[E_FLAG_NOT_IMPLEMENTED]	= "flag is not implemented",
+	[E_FLAG_INVALID_TYPE]		= "unknown or invalid flag specified",
+	NULL
 };
 
-typedef union file file_t;
-typedef struct buffer buffer_t;
-
-struct magic_arguments {
-    int flags;
-    magic_t cookie;
-    union {
-        file_t file;
-        buffer_t buffer;
-    } data;
+#if defined(MAGIC_CUSTOM_CHECK_TYPE)
+static const char *ruby_types[] = {
+	"", /* Not an object */
+	[T_OBJECT]	= "Object",
+	[T_CLASS]	= "Class",
+	[T_MODULE]	= "Module",
+	[T_FLOAT]	= "Float",
+	[T_STRING]	= "String",
+	[T_REGEXP]	= "Regexp",
+	[T_ARRAY]	= "Array",
+	[T_HASH]	= "Hash",
+	[T_STRUCT]	= "Struct",
+	[T_BIGNUM]	= "Integer",
+	[T_FILE]	= "File",
+	"", /* Internal use */
+	[T_MATCH]	= "MatchData",
+	[T_COMPLEX]	= "Complex",
+	[T_RATIONAL]	= "Rational",
+	"", /* Internal use */
+	[T_NIL]		= "nil",
+	[T_TRUE]	= "true",
+	[T_FALSE]	= "false",
+	[T_SYMBOL]	= "Symbol",
+	[T_FIXNUM]	= "Integer",
+	"", /* Internal use */
+	NULL
 };
 
-struct magic_exception {
-    int magic_errno;
-    const char *magic_error;
-    VALUE klass;
-};
+static const char *
+magic_ruby_type_name(int type)
+{
+	const char *name;
 
-typedef struct magic_arguments magic_arguments_t;
-typedef struct magic_exception magic_exception_t;
+	if (type >= ARRAY_SIZE(ruby_types))
+		return NULL;
 
-static const char *errors[] = {
-    "unknown error",
-    "function is not implemented",
-    "failed to initialize Magic library",
-    "Magic library is not open",
-    "unknown or invalid flag specified",
-    "flag is not implemented",
-    NULL
-};
+	name = ruby_types[type];
+	if (name)
+		return name;
+
+	return NULL;
+}
 
-inline static VALUE
-magic_size(VALUE v)
+static const char *
+magic_ruby_class_name(VALUE object)
 {
-    if (ARRAY_P(v) || STRING_P(v)) {
-        return rb_funcall(v, rb_intern("size"), 0, NULL);
-    }
+	const char *name = NULL;
+
+	if (NIL_P(object))
+		name = "nil";
+	else if (RB_TYPE_P(object, T_TRUE))
+		name = "true";
+	else if (RB_TYPE_P(object, T_FALSE))
+		name = "false";
+	else
+		name = CLASS_NAME(object);
+
+	return name;
+}
 
-    return Qnil;
+void
+magic_check_ruby_type(VALUE object, int type)
+{
+	const char *name;
+	int object_type = TYPE(object);
+
+	if (object == Qundef)
+		rb_bug("invalid type leaked to the Ruby space");
+
+	if (object_type > T_MASK || object_type == T_DATA)
+		goto error;
+
+	if (object_type == type)
+		return;
+
+	name = magic_ruby_type_name(type);
+	if (name)
+		rb_raise(rb_eTypeError, error(E_ARGUMENT_TYPE_INVALID),
+			 magic_ruby_class_name(object),
+			 name);
+error:
+	rb_raise(rb_eTypeError, error(E_ARGUMENT_TYPE_UNKNOWN),
+		 object_type,
+		 type);
 }
+#endif /* MAGIC_CUSTOM_CHECK_TYPE */
 
-inline static VALUE
+static inline VALUE
 magic_shift(VALUE v)
 {
-    if (ARRAY_P(v)) {
-        return rb_funcall(v, rb_intern("shift"), 0, NULL);
-    }
-
-    return Qnil;
+	return ARRAY_P(v) ?			       \
+		rb_funcall(v, rb_intern("shift"), 0) : \
+		Qnil;
 }
 
-inline static VALUE
+static inline VALUE
 magic_split(VALUE a, VALUE b)
 {
-    if (STRING_P(a) && STRING_P(b)) {
-        return rb_funcall(a, rb_intern("split"), 1, b);
-    }
-
-    return Qnil;
+	return (STRING_P(a) && STRING_P(b)) ?		  \
+		rb_funcall(a, rb_intern("split"), 1, b) : \
+		Qnil;
 }
 
-inline static VALUE
+static inline VALUE
 magic_join(VALUE a, VALUE b)
 {
-    if (ARRAY_P(a) && STRING_P(b)) {
-        return rb_funcall(a, rb_intern("join"), 1, b);
-    }
+	return (ARRAY_P(a) && STRING_P(b)) ?		 \
+		rb_funcall(a, rb_intern("join"), 1, b) : \
+		Qnil;
+}
+
+static inline VALUE
+magic_flatten(VALUE v)
+{
+	return ARRAY_P(v) ?				 \
+		rb_funcall(v, rb_intern("flatten"), 0) : \
+		Qnil;
+}
+
+static int
+magic_fileno(VALUE object)
+{
+	int fd;
+	rb_io_t *io;
+
+	if (rb_respond_to(object, rb_intern("fileno"))) {
+		object = rb_funcall(object, rb_intern("fileno"), 0);
+		return NUM2INT(object);
+	}
+
+	if (!FILE_P(object))
+		object = rb_convert_type(object, T_FILE, "IO", "to_io");
+
+	GetOpenFile(object, io);
+	if ((fd = FPTR_TO_FD(io)) < 0)
+		rb_raise(rb_eIOError, "closed stream");
+
+	return fd;
+}
+
+static inline VALUE
+magic_path(VALUE object)
+{
+	if (STRING_P(object))
+		return object;
+
+	if (rb_respond_to(object, rb_intern("to_path")))
+		return rb_funcall(object, rb_intern("to_path"), 0);
+
+	if (rb_respond_to(object, rb_intern("path")))
+		return rb_funcall(object, rb_intern("path"), 0);
+
+	if (rb_respond_to(object, rb_intern("to_s")))
+		return rb_funcall(object, rb_intern("to_s"), 0);
+
+	return Qnil;
+}
+
+static inline void
+magic_check_type(VALUE object, RVALUE_TYPE type)
+{
+	VALUE boolean = Qundef;
+
+	boolean = rb_obj_is_kind_of(object, T_INTEGER);
+	if (type == T_FIXNUM && !RVAL2CBOOL(boolean))
+		MAGIC_ARGUMENT_TYPE_ERROR(object, rb_class2name(T_INTEGER));
+
+	MAGIC_CHECK_RUBY_TYPE(object, type);
+}
 
-    return Qnil;
+static inline void
+magic_check_type_array_of_strings(VALUE object)
+{
+	VALUE value = Qundef;
+
+	for (int i = 0; i < RARRAY_LEN(object); i++) {
+		value = RARRAY_AREF(object, (long)i);
+		if (NIL_P(value) || !STRING_P(value))
+			rb_raise(rb_eTypeError,
+				 error(E_ARGUMENT_TYPE_ARRAY_STRINGS),
+				 CLASS_NAME(value));
+	}
 }
 
-RUBY_EXTERN ID id_at_flags, id_at_path, id_at_mutex;
+static int rb_mgc_do_not_auto_load;
+static int rb_mgc_do_not_stop_on_error;
+static int rb_mgc_warning;
+
+static ID id_at_flags;
+static ID id_at_paths;
+
+static VALUE rb_cMagic;
+
+static VALUE rb_mgc_eError;
+static VALUE rb_mgc_eMagicError;
+static VALUE rb_mgc_eLibraryError;
+static VALUE rb_mgc_eNotImplementedError;
+static VALUE rb_mgc_eParameterError;
+static VALUE rb_mgc_eFlagsError;
+
+static const rb_data_type_t rb_magic_type;
 
-RUBY_EXTERN VALUE rb_cMagic;
+void Init_magic(void);
 
-RUBY_EXTERN VALUE rb_mgc_eError;
-RUBY_EXTERN VALUE rb_mgc_eMagicError;
-RUBY_EXTERN VALUE rb_mgc_eLibraryError;
-RUBY_EXTERN VALUE rb_mgc_eFlagsError;
-RUBY_EXTERN VALUE rb_mgc_eNotImplementedError;
+VALUE rb_mgc_get_do_not_auto_load_global(VALUE object);
+VALUE rb_mgc_set_do_not_auto_load_global(VALUE object, VALUE value);
+VALUE rb_mgc_get_do_not_stop_on_error_global(VALUE object);
+VALUE rb_mgc_set_do_not_stop_on_error_global(VALUE object, VALUE value);
 
-RUBY_EXTERN VALUE rb_mgc_initialize(VALUE object, VALUE arguments);
+VALUE rb_mgc_initialize(VALUE object, VALUE arguments);
 
-RUBY_EXTERN VALUE rb_mgc_close(VALUE object);
-RUBY_EXTERN VALUE rb_mgc_closed(VALUE object);
+VALUE rb_mgc_get_do_not_stop_on_error(VALUE object);
+VALUE rb_mgc_set_do_not_stop_on_error(VALUE object, VALUE value);
 
-RUBY_EXTERN VALUE rb_mgc_get_path(VALUE object);
+VALUE rb_mgc_open_p(VALUE object);
+VALUE rb_mgc_close(VALUE object);
+VALUE rb_mgc_close_p(VALUE object);
 
-RUBY_EXTERN VALUE rb_mgc_get_flags(VALUE object);
-RUBY_EXTERN VALUE rb_mgc_set_flags(VALUE object, VALUE value);
+VALUE rb_mgc_get_paths(VALUE object);
 
-RUBY_EXTERN VALUE rb_mgc_load(VALUE object, VALUE arguments);
-RUBY_EXTERN VALUE rb_mgc_compile(VALUE object, VALUE arguments);
-RUBY_EXTERN VALUE rb_mgc_check(VALUE object, VALUE arguments);
+VALUE rb_mgc_get_parameter(VALUE object, VALUE tag);
+VALUE rb_mgc_set_parameter(VALUE object, VALUE tag, VALUE value);
 
-RUBY_EXTERN VALUE rb_mgc_file(VALUE object, VALUE value);
-RUBY_EXTERN VALUE rb_mgc_buffer(VALUE object, VALUE value);
-RUBY_EXTERN VALUE rb_mgc_descriptor(VALUE object, VALUE value);
+VALUE rb_mgc_get_flags(VALUE object);
+VALUE rb_mgc_set_flags(VALUE object, VALUE value);
 
-RUBY_EXTERN VALUE rb_mgc_version(VALUE object);
+VALUE rb_mgc_load(VALUE object, VALUE arguments);
+VALUE rb_mgc_load_buffers(VALUE object, VALUE arguments);
+VALUE rb_mgc_load_p(VALUE object);
+
+VALUE rb_mgc_compile(VALUE object, VALUE arguments);
+VALUE rb_mgc_check(VALUE object, VALUE arguments);
+
+VALUE rb_mgc_file(VALUE object, VALUE value);
+VALUE rb_mgc_buffer(VALUE object, VALUE value);
+VALUE rb_mgc_descriptor(VALUE object, VALUE value);
+
+VALUE rb_mgc_version(VALUE object);
+
+static VALUE magic_get_parameter_internal(void *data);
+static VALUE magic_set_parameter_internal(void *data);
+
+static VALUE magic_get_flags_internal(void *data);
+static VALUE magic_set_flags_internal(void *data);
+
+static VALUE magic_load_internal(void *data);
+static VALUE magic_load_buffers_internal(void *data);
+
+static VALUE magic_compile_internal(void *data);
+static VALUE magic_check_internal(void *data);
+
+static VALUE magic_file_internal(void *data);
+static VALUE magic_buffer_internal(void *data);
+static VALUE magic_descriptor_internal(void *data);
+
+static VALUE magic_close_internal(void *data);
+
+static void* nogvl_magic_load(void *data);
+static void* nogvl_magic_compile(void *data);
+static void* nogvl_magic_check(void *data);
+static void* nogvl_magic_file(void *data);
+static void* nogvl_magic_descriptor(void *data);
+
+static void* magic_library_open(void);
+static void magic_library_close(void *data);
+
+static VALUE magic_allocate(VALUE klass);
+static void magic_mark(void *data);
+static void magic_free(void *data);
+static size_t magic_size(const void *data);
+#if defined(HAVE_RUBY_GC_COMPACT)
+static void magic_compact(void *data);
+#endif
+
+static VALUE magic_exception_wrapper(VALUE value);
+static VALUE magic_exception(void *data);
+
+static VALUE magic_library_error(VALUE klass, void *data);
+static VALUE magic_generic_error(VALUE klass, int magic_errno,
+				 const char *magic_error);
+
+static VALUE magic_lock(VALUE object, VALUE (*function)(ANYARGS),
+			void *data);
+static VALUE magic_unlock(VALUE object);
+
+static VALUE magic_return(void *data);
+
+static int magic_get_flags(VALUE object);
+static int magic_set_flags(VALUE object, VALUE value);
+
+static VALUE magic_set_paths(VALUE object, VALUE value);
 
 #if defined(__cplusplus)
 }
 #endif
 
 #endif /* _RUBY_MAGIC_H */
-
-/* vim: set ts=8 sw=4 sts=2 et : */