sender 1.0.1 → 1.1.0

data/ext/sender/rb_Global.c

@@ -1,17 +1,25 @@
 
-#include <ruby.h>
-
 #include "rb_Global.h"
-#include "rb_Global_internal.h"
 
 //	Internals from ruby that aren't included in the ruby lib
 #include "RubySourceSupport.h"
 
 #include "eval_intern.h"
 
+/***********
+*  Global  *
+***********/
+
+void Init_senderGlobal()	{
+	
+	rb_define_global_function( "__sender__",		rb_RPRuby_Sender___sender__,			0 );
+	rb_define_global_function( "__caller__",		rb_RPRuby_Sender___caller__,			0 );
+
+}
+
 /***************************************************************************************************************************************************************
 ****************************************************************************************************************************************************************
-													Global Ruby Methods
+													Ruby Global Methods
 ****************************************************************************************************************************************************************
 ***************************************************************************************************************************************************************/
 
@@ -25,15 +33,17 @@
  *
  * Return object sending message to receiver.
  */
-VALUE rb_RPRuby_SenderCaller__sender__()	{
+VALUE rb_RPRuby_Sender___sender__()	{
 
-	rb_control_frame_t*		c_sending_frame	=	RPRuby_internal_framePriorToCurrent();
+	//	get the frame prior to current frame
+	rb_control_frame_t*		c_sending_frame	=	RPRuby_internal_framePriorTo( NULL );
 	
+	//	make sure the current frame wasn't the first frame or return nil
 	if ( c_sending_frame == NULL )	{
 		return Qnil;
 	}
 	
-	//	return rb_self that is sender
+	//	assuming we have a previous frame, return its rb_self (our current receiver's sender)
 	return c_sending_frame->self;
 }
 
@@ -47,30 +57,8 @@ VALUE rb_RPRuby_SenderCaller__sender__()	{
  *
  * Return method sending message to receiver.
  */
-VALUE rb_RPRuby_SenderCaller__caller__()	{
+VALUE rb_RPRuby_Sender___caller__()	{
 
 	return ID2SYM( rb_frame_caller() );
 }
 
-/***************************************************************************************************************************************************************
-****************************************************************************************************************************************************************
-													Internal Methods
-****************************************************************************************************************************************************************
-***************************************************************************************************************************************************************/
-
-/*************************
- *  framePriorToCurrent  *
- ************************/
-
-rb_control_frame_t* RPRuby_internal_framePriorToCurrent()	{
-
-	rb_thread_t*			c_thread				= GET_THREAD();
-    rb_control_frame_t*		prior_control_frame		= RUBY_VM_PREVIOUS_CONTROL_FRAME( c_thread->cfp );
-
-    //	Make sure we actually have a prior frame
-	if ( (void*)( c_thread->stack + c_thread->stack_size ) == (void*)( prior_control_frame ) )	{
-        return NULL;
-    }
-	
-	return prior_control_frame;
-}

data/ext/sender/rb_Global.h

@@ -1,11 +1,11 @@
-#ifndef RP_SENDER_CALLER_GLOBAL
-	#define RP_SENDER_CALLER_GLOBAL
+#ifndef RP_SENDER_GLOBAL
+	#define RP_SENDER_GLOBAL
 
-	#include "ruby.h"
-	#include "eval_intern.h"
-	#include "RubySourceSupport.h"
+	#include "RPSender_internal.h"
 
-	VALUE rb_RPRuby_SenderCaller__sender__();
-	VALUE rb_RPRuby_SenderCaller__caller__();
+	void Init_senderGlobal();
 
+	VALUE rb_RPRuby_Sender___sender__();
+	VALUE rb_RPRuby_Sender___caller__();
+	
 #endif

data/ext/sender/rb_Global_internal.h

@@ -2,6 +2,6 @@
 #ifndef RP_SENDER_CALLER_GLOBAL_INTERNAL
 	#define RP_SENDER_CALLER_GLOBAL_INTERNAL
 	
-	rb_control_frame_t* RPRuby_internal_framePriorToCurrent();
+	rb_control_frame_t* RPRuby_internal_framePriorTo();
 
 #endif

data/ext/sender/rb_Kernel.c

@@ -0,0 +1,162 @@
+
+#include "rb_Kernel.h"
+
+#include "RPSender_internal.h"
+
+#include "RubySourceSupport.h"
+
+/***********
+*  Kernel  *
+***********/
+
+void Init_senderKernel()	{
+	
+	rb_define_singleton_method( rb_mKernel, "backtrace",				rb_RPRuby_Sender_Kernel_backtrace,				-1 );
+	rb_define_singleton_method( rb_mKernel, "backtrace_includes?",		rb_RPRuby_Sender_Kernel_backtrace_includes,		-1 );
+
+}
+
+/***************************************************************************************************************************************************************
+****************************************************************************************************************************************************************
+													Ruby Kernel Methods
+****************************************************************************************************************************************************************
+***************************************************************************************************************************************************************/
+
+/******************
+ *  __backtrace__  *
+ ******************/
+
+/*
+ * call-seq:
+ *   __backtrace__( number_of_frames = nil ) -> [ { :object => object, :method => method }, ... ]
+ *
+ * Return array of hashes with object and method frame information for backtrace.
+ * Specifying number_of_frames will cause only the last number_of_frames to be returned.
+ */
+VALUE rb_RPRuby_Sender_Kernel_backtrace(	int		argc,
+											VALUE*	args,
+											VALUE	rb_self )	{
+	
+	//	create return array
+	VALUE	rb_return_array	=	rb_ary_new();
+	
+	//	for each previous frame
+	rb_control_frame_t*		c_control_frame		=	NULL;
+	int						c_stack_level		=	0;
+	int						c_max_stack_level	=	0;
+	if ( argc )	{
+		c_max_stack_level	=	FIX2INT( args[ 0 ] );
+	}
+	//	loop while we have a prior control frame
+	while (		( c_control_frame = RPRuby_internal_framePriorTo( c_control_frame ) ) != NULL
+		   //	and as long as we either have no stack limit specified, or until we reach the stack limit
+		   &&	(	argc == 0
+				 ||	c_stack_level < c_max_stack_level ) )	{
+
+		//	get hash of info for this frame
+		VALUE	rb_frame_hash	=	RPSender_internal_backtraceHashForControlFrame( c_control_frame );
+
+		if ( rb_frame_hash == Qnil )	{
+			break;
+		}
+			   
+		//	push hash to array
+		rb_ary_push(	rb_return_array,
+						rb_frame_hash );
+		
+		c_stack_level++;
+	}
+	
+	//	return return array
+	return rb_return_array;
+}
+
+/*****************************
+ *  __backtrace_includes?__  *
+ ****************************/
+
+/*
+ * call-seq:
+ *   __backtrace_includes?( method_or_object, ... ) -> true or false
+ *   __backtrace_includes?( number_of_frames, method_or_object, ... ) -> true or false
+ *
+ * Returns whether specified methods or objects or classes are in the current backtrace context.
+ * Backtrace begins with the prior frame, so asking if the backtrace includes the current method
+ * will only report true if the current method is part of the earlier call chain.
+ */
+VALUE rb_RPRuby_Sender_Kernel_backtrace_includes(	int		argc,
+													VALUE*	args,
+													VALUE	rb_self )	{
+	
+	//	create tracking array
+	VALUE	rb_tracking_array	=	rb_ary_new();
+	
+	//	populate array with methods/objects
+	int	c_which_arg	=	0;
+	for ( c_which_arg = 0 ; c_which_arg < argc ; c_which_arg++ )	{
+		rb_ary_push(	rb_tracking_array,
+						args[ c_which_arg ] );
+	}
+	
+	//	for each previous frame
+	rb_control_frame_t*	c_control_frame	=	NULL;
+	while (	 ( c_control_frame = RPRuby_internal_framePriorTo( c_control_frame ) ) != NULL )	{
+	
+		//	iterate each array member 
+		int	c_which_member;
+		for ( c_which_member = 0 ; c_which_member < RARRAY_LEN( rb_tracking_array ) ; c_which_member++ )	{
+			
+			VALUE	rb_array_member	=	args[ c_which_member ];
+			
+			int		matched	=	0;
+			
+			//	if rb_array_member is a class
+			if	( TYPE( rb_array_member ) == T_CLASS ) {
+				//	if rb_array_member is the current frame's object's class
+				if ( rb_array_member == rb_class_of( c_control_frame->self ) )	{
+					matched	=	1;
+				}
+			}
+			//	if rb_array_member is a method symbol and matches our current frame's method
+			else if	( TYPE( rb_array_member ) == T_SYMBOL )	{
+				
+				if ( rb_to_id( rb_array_member ) == frame_func_id( c_control_frame ) )	{
+					matched	=	1;
+				}
+			}
+			//	if rb_array_member is an object
+			else if ( TYPE( rb_array_member ) == T_OBJECT )	{
+				//	if rb_array_member is the current frame's object (self)
+				if ( rb_array_member == c_control_frame->self )	{
+					matched	=	1;
+				}
+			}
+			
+			//	if array member exists in frame, remove from array
+			if ( matched )	{
+				//	delete this index
+				rb_ary_delete_at(	rb_tracking_array,
+									c_which_member );
+				
+				//	decrement the loop iterator so that the increase is offset
+				//	this is necessary since we just removed an index and are iterating vs. the length of the array
+				c_which_member--;
+			}
+		}
+		
+		//	if array is empty, return true
+		//	we check here as well as at the end so we can stop iterating the backtrace if we find all our items
+		if ( RARRAY_LEN( rb_tracking_array ) == 0 )	{
+			return Qtrue;
+		}		
+	}
+		
+	//	if we finish iterating frames and still have items in the array, return false
+	if ( RARRAY_LEN( rb_tracking_array ) > 0 )	{
+		return Qfalse;
+	}
+	
+	//	otherwise, return true
+	return Qtrue;
+}
+

data/ext/sender/rb_Kernel.h

@@ -0,0 +1,16 @@
+
+#ifndef RP_SENDER_KERNEL
+	#define RP_SENDER_KERNEL
+
+	#include "ruby.h"
+
+	void Init_senderKernel();
+
+	VALUE rb_RPRuby_Sender_Kernel_backtrace(	int	argc,
+												VALUE*	args,
+												VALUE	rb_self );
+	VALUE rb_RPRuby_Sender_Kernel_backtrace_includes(	int	argc,
+														VALUE*	args,
+														VALUE	rb_self );
+
+#endif

data/ext/sender/regenc.h

@@ -0,0 +1,207 @@
+#ifndef ONIGURUMA_REGENC_H
+#define ONIGURUMA_REGENC_H
+/**********************************************************************
+  regenc.h -  Oniguruma (regular expression library)
+**********************************************************************/
+/*-
+ * Copyright (c) 2002-2007  K.Kosako  <sndgk393 AT ybb DOT ne DOT jp>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#ifndef REGINT_H
+#ifndef RUBY_EXTERN
+#include "ruby/config.h"
+#include "ruby/defines.h"
+#endif
+#ifdef ONIG_ESCAPE_UCHAR_COLLISION
+#undef ONIG_ESCAPE_UCHAR_COLLISION
+#endif
+#endif
+#include "ruby/oniguruma.h"
+
+typedef struct {
+  OnigCodePoint from;
+  OnigCodePoint to;
+} OnigPairCaseFoldCodes;
+
+
+#ifndef NULL
+#define NULL   ((void* )0)
+#endif
+
+#ifndef TRUE
+#define TRUE    1
+#endif
+
+#ifndef FALSE
+#define FALSE   0
+#endif
+
+#ifndef ARG_UNUSED
+#if defined(__GNUC__)
+#  define ARG_UNUSED  __attribute__ ((unused))
+#else
+#  define ARG_UNUSED
+#endif
+#endif
+
+#define ONIG_IS_NULL(p)                    (((void*)(p)) == (void*)0)
+#define ONIG_IS_NOT_NULL(p)                (((void*)(p)) != (void*)0)
+#define ONIG_CHECK_NULL_RETURN(p)          if (ONIG_IS_NULL(p)) return NULL
+#define ONIG_CHECK_NULL_RETURN_VAL(p,val)  if (ONIG_IS_NULL(p)) return (val)
+
+#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e))
+
+/* character types bit flag */
+#define BIT_CTYPE_NEWLINE  (1<< ONIGENC_CTYPE_NEWLINE)
+#define BIT_CTYPE_ALPHA    (1<< ONIGENC_CTYPE_ALPHA)
+#define BIT_CTYPE_BLANK    (1<< ONIGENC_CTYPE_BLANK)
+#define BIT_CTYPE_CNTRL    (1<< ONIGENC_CTYPE_CNTRL)
+#define BIT_CTYPE_DIGIT    (1<< ONIGENC_CTYPE_DIGIT)
+#define BIT_CTYPE_GRAPH    (1<< ONIGENC_CTYPE_GRAPH)
+#define BIT_CTYPE_LOWER    (1<< ONIGENC_CTYPE_LOWER)
+#define BIT_CTYPE_PRINT    (1<< ONIGENC_CTYPE_PRINT)
+#define BIT_CTYPE_PUNCT    (1<< ONIGENC_CTYPE_PUNCT)
+#define BIT_CTYPE_SPACE    (1<< ONIGENC_CTYPE_SPACE)
+#define BIT_CTYPE_UPPER    (1<< ONIGENC_CTYPE_UPPER)
+#define BIT_CTYPE_XDIGIT   (1<< ONIGENC_CTYPE_XDIGIT)
+#define BIT_CTYPE_WORD     (1<< ONIGENC_CTYPE_WORD)
+#define BIT_CTYPE_ALNUM    (1<< ONIGENC_CTYPE_ALNUM)
+#define BIT_CTYPE_ASCII    (1<< ONIGENC_CTYPE_ASCII)
+
+#define CTYPE_TO_BIT(ctype)  (1<<(ctype))
+#define CTYPE_IS_WORD_GRAPH_PRINT(ctype) \
+  ((ctype) == ONIGENC_CTYPE_WORD || (ctype) == ONIGENC_CTYPE_GRAPH ||\
+   (ctype) == ONIGENC_CTYPE_PRINT)
+
+
+typedef struct {
+  UChar    *name;
+  int       ctype;
+  short int len;
+} PosixBracketEntryType;
+
+
+/* #define USE_CRNL_AS_LINE_TERMINATOR */
+#define USE_UNICODE_PROPERTIES
+/* #define USE_UNICODE_CASE_FOLD_TURKISH_AZERI */
+/* #define USE_UNICODE_ALL_LINE_TERMINATORS */  /* see Unicode.org UTF#18 */
+
+
+#define ONIG_ENCODING_INIT_DEFAULT           ONIG_ENCODING_ASCII
+
+/* for encoding system implementation (internal) */
+ONIG_EXTERN int onigenc_ascii_apply_all_case_fold P_((OnigCaseFoldType flag, OnigApplyAllCaseFoldFunc f, void* arg, OnigEncoding enc));
+ONIG_EXTERN int onigenc_ascii_get_case_fold_codes_by_str P_((OnigCaseFoldType flag, const OnigUChar* p, const OnigUChar* end, OnigCaseFoldCodeItem items[], OnigEncoding enc));
+ONIG_EXTERN int onigenc_apply_all_case_fold_with_map P_((int map_size, const OnigPairCaseFoldCodes map[], int ess_tsett_flag, OnigCaseFoldType flag, OnigApplyAllCaseFoldFunc f, void* arg));
+ONIG_EXTERN int onigenc_get_case_fold_codes_by_str_with_map P_((int map_size, const OnigPairCaseFoldCodes map[], int ess_tsett_flag, OnigCaseFoldType flag, const OnigUChar* p, const OnigUChar* end, OnigCaseFoldCodeItem items[]));
+ONIG_EXTERN int onigenc_not_support_get_ctype_code_range P_((OnigCtype ctype, OnigCodePoint* sb_out, const OnigCodePoint* ranges[], OnigEncoding enc));
+ONIG_EXTERN int onigenc_is_mbc_newline_0x0a P_((const UChar* p, const UChar* end, OnigEncoding enc));
+
+
+/* methods for single byte encoding */
+ONIG_EXTERN int onigenc_ascii_mbc_case_fold P_((OnigCaseFoldType flag, const UChar** p, const UChar* end, UChar* lower, OnigEncoding enc));
+ONIG_EXTERN int onigenc_single_byte_mbc_enc_len P_((const UChar* p, const UChar* e, OnigEncoding enc));
+ONIG_EXTERN OnigCodePoint onigenc_single_byte_mbc_to_code P_((const UChar* p, const UChar* end, OnigEncoding enc));
+ONIG_EXTERN int onigenc_single_byte_code_to_mbclen P_((OnigCodePoint code, OnigEncoding enc));
+ONIG_EXTERN int onigenc_single_byte_code_to_mbc P_((OnigCodePoint code, UChar *buf, OnigEncoding enc));
+ONIG_EXTERN UChar* onigenc_single_byte_left_adjust_char_head P_((const UChar* start, const UChar* s, const OnigUChar* end, OnigEncoding enc));
+ONIG_EXTERN int onigenc_always_true_is_allowed_reverse_match P_((const UChar* s, const UChar* end, OnigEncoding enc));
+ONIG_EXTERN int onigenc_always_false_is_allowed_reverse_match P_((const UChar* s, const UChar* end, OnigEncoding enc));
+ONIG_EXTERN int onigenc_ascii_is_code_ctype P_((OnigCodePoint code, unsigned int ctype, OnigEncoding enc));
+
+/* methods for multi byte encoding */
+ONIG_EXTERN OnigCodePoint onigenc_mbn_mbc_to_code P_((OnigEncoding enc, const UChar* p, const UChar* end));
+ONIG_EXTERN int onigenc_mbn_mbc_case_fold P_((OnigEncoding enc, OnigCaseFoldType flag, const UChar** p, const UChar* end, UChar* lower));
+ONIG_EXTERN int onigenc_mb2_code_to_mbclen P_((OnigCodePoint code, OnigEncoding enc));
+ONIG_EXTERN int onigenc_mb2_code_to_mbc P_((OnigEncoding enc, OnigCodePoint code, UChar *buf));
+ONIG_EXTERN int onigenc_minimum_property_name_to_ctype P_((OnigEncoding enc, UChar* p, UChar* end));
+ONIG_EXTERN int onigenc_unicode_property_name_to_ctype P_((OnigEncoding enc, UChar* p, UChar* end));
+ONIG_EXTERN int onigenc_mb2_is_code_ctype P_((OnigEncoding enc, OnigCodePoint code, unsigned int ctype));
+ONIG_EXTERN int onigenc_mb4_code_to_mbclen P_((OnigCodePoint code, OnigEncoding enc));
+ONIG_EXTERN int onigenc_mb4_code_to_mbc P_((OnigEncoding enc, OnigCodePoint code, UChar *buf));
+ONIG_EXTERN int onigenc_mb4_is_code_ctype P_((OnigEncoding enc, OnigCodePoint code, unsigned int ctype));
+
+
+/* in enc/unicode.c */
+ONIG_EXTERN int onigenc_unicode_is_code_ctype P_((OnigCodePoint code, unsigned int ctype, OnigEncoding enc));
+ONIG_EXTERN int onigenc_utf16_32_get_ctype_code_range P_((OnigCtype ctype, OnigCodePoint *sb_out, const OnigCodePoint* ranges[], OnigEncoding enc));
+ONIG_EXTERN int onigenc_unicode_ctype_code_range P_((int ctype, const OnigCodePoint* ranges[]));
+ONIG_EXTERN int onigenc_unicode_get_case_fold_codes_by_str P_((OnigEncoding enc, OnigCaseFoldType flag, const OnigUChar* p, const OnigUChar* end, OnigCaseFoldCodeItem items[]));
+ONIG_EXTERN int onigenc_unicode_mbc_case_fold P_((OnigEncoding enc, OnigCaseFoldType flag, const UChar** pp, const UChar* end, UChar* fold));
+ONIG_EXTERN int onigenc_unicode_apply_all_case_fold P_((OnigCaseFoldType flag, OnigApplyAllCaseFoldFunc f, void* arg, OnigEncoding enc));
+
+
+#define ONIGENC_ISO_8859_1_TO_LOWER_CASE(c) \
+  OnigEncISO_8859_1_ToLowerCaseTable[c]
+#define ONIGENC_ISO_8859_1_TO_UPPER_CASE(c) \
+  OnigEncISO_8859_1_ToUpperCaseTable[c]
+
+ONIG_EXTERN const UChar OnigEncISO_8859_1_ToLowerCaseTable[];
+ONIG_EXTERN const UChar OnigEncISO_8859_1_ToUpperCaseTable[];
+
+ONIG_EXTERN int
+onigenc_with_ascii_strncmp P_((OnigEncoding enc, const UChar* p, const UChar* end, const UChar* sascii /* ascii */, int n));
+ONIG_EXTERN UChar*
+onigenc_step P_((OnigEncoding enc, const UChar* p, const UChar* end, int n));
+
+/* defined in regexec.c, but used in enc/xxx.c */
+extern int  onig_is_in_code_range P_((const UChar* p, OnigCodePoint code));
+
+ONIG_EXTERN OnigEncoding  OnigEncDefaultCharEncoding;
+ONIG_EXTERN const UChar  OnigEncAsciiToLowerCaseTable[];
+ONIG_EXTERN const UChar  OnigEncAsciiToUpperCaseTable[];
+ONIG_EXTERN const unsigned short OnigEncAsciiCtypeTable[];
+
+#define ONIGENC_IS_ASCII_CODE(code)  ((code) < 0x80)
+#define ONIGENC_ASCII_CODE_TO_LOWER_CASE(c) OnigEncAsciiToLowerCaseTable[c]
+#define ONIGENC_ASCII_CODE_TO_UPPER_CASE(c) OnigEncAsciiToUpperCaseTable[c]
+#define ONIGENC_IS_ASCII_CODE_CTYPE(code,ctype) \
+  ((OnigEncAsciiCtypeTable[code] & CTYPE_TO_BIT(ctype)) != 0)
+#define ONIGENC_IS_ASCII_CODE_CASE_AMBIG(code) \
+ (ONIGENC_IS_ASCII_CODE_CTYPE(code, ONIGENC_CTYPE_UPPER) ||\
+  ONIGENC_IS_ASCII_CODE_CTYPE(code, ONIGENC_CTYPE_LOWER))
+   
+#ifdef ONIG_ENC_REGISTER
+extern int ONIG_ENC_REGISTER(const char *, OnigEncodingType*);
+#define OnigEncodingName(n) encoding_##n
+#define OnigEncodingDeclare(n) static OnigEncodingType OnigEncodingName(n)
+#define OnigEncodingDefine(f,n)			     \
+    OnigEncodingDeclare(n);			     \
+    void Init_##f(void) {			     \
+	ONIG_ENC_REGISTER(OnigEncodingName(n).name,  \
+			  &OnigEncodingName(n));     \
+    }						     \
+    OnigEncodingDeclare(n)
+#else
+#define OnigEncodingName(n) OnigEncoding##n
+#define OnigEncodingDeclare(n) OnigEncodingType OnigEncodingName(n)
+#define OnigEncodingDefine(f,n) OnigEncodingDeclare(n)
+#endif
+
+/* macros for define replica encoding and encoding alias */
+#define ENC_REPLICATE(name, orig)
+#define ENC_ALIAS(name, orig)
+#define ENC_DUMMY(name)
+
+#endif /* ONIGURUMA_REGENC_H */