diff --git a/ChangeLog b/ChangeLog index 524ca65dd9..be6935c55c 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +Tue Sep 26 15:59:50 2000 Yukihiro Matsumoto + + * object.c (rb_mod_dup): metaclasses of class/module should not be + cleared by rb_obj_dup. + Tue Sep 26 02:44:54 2000 Yukihiro Matsumoto * gc.c (GC_MALLOC_LIMIT): size extended. diff --git a/object.c b/object.c index fe9f8adbb9..3574c6f23a 100644 --- a/object.c +++ b/object.c @@ -113,7 +113,6 @@ rb_obj_dup(obj) } if (!SPECIAL_CONST_P(dup)) { OBJSETUP(dup, rb_obj_type(obj), BUILTIN_TYPE(obj)); - OBJ_INFECT(dup, obj); } return dup; } @@ -471,7 +470,6 @@ rb_obj_alloc(klass) { NEWOBJ(obj, struct RObject); OBJSETUP(obj, klass, T_OBJECT); - obj->iv_tbl = 0; return (VALUE)obj; } @@ -530,6 +528,15 @@ rb_mod_clone(module) return (VALUE)clone; } +static VALUE +rb_mod_dup(module) + VALUE module; +{ + VALUE dup = rb_mod_clone(module); + OBJSETUP(dup, RBASIC(module)->klass, BUILTIN_TYPE(module)); + return dup; +} + static VALUE rb_mod_to_s(klass) VALUE klass; @@ -1153,6 +1160,7 @@ Init_Object() rb_define_method(rb_cModule, ">", rb_mod_gt, 1); rb_define_method(rb_cModule, ">=", rb_mod_ge, 1); rb_define_method(rb_cModule, "clone", rb_mod_clone, 0); + rb_define_method(rb_cModule, "dup", rb_mod_dup, 0); rb_define_method(rb_cModule, "to_s", rb_mod_to_s, 0); rb_define_method(rb_cModule, "included_modules", rb_mod_included_modules, 0); rb_define_method(rb_cModule, "name", rb_mod_name, 0); diff --git a/regex.c b/regex.c index 2b2b842b89..f1dcb3b77d 100644 --- a/regex.c +++ b/regex.c @@ -84,8 +84,6 @@ void *xrealloc _((void*,size_t)); void xfree _((void*)); #endif -#define NO_ALLOCA /* try it out for now */ -#ifndef NO_ALLOCA /* Make alloca work the best possible way. */ #ifdef __GNUC__ # ifndef atarist @@ -111,73 +109,55 @@ char *alloca(); # include #endif -#define RE_ALLOCATE alloca #ifdef C_ALLOCA #define FREE_VARIABLES() alloca(0) #else #define FREE_VARIABLES() #endif -#define FREE_AND_RETURN_VOID(stackb) return -#define FREE_AND_RETURN(stackb,val) return(val) -#define DOUBLE_STACK(stackx,stackb,len,type) \ - (stackx = (type*)alloca(2 * len * sizeof(type)), \ - /* Only copy what is in use. */ \ - (type*)memcpy(stackx, stackb, len * sizeof (type))) -#else /* NO_ALLOCA defined */ - -#define RE_ALLOCATE xmalloc - -#define FREE_VARIABLES() - #define FREE_AND_RETURN_VOID(stackb) do { \ + FREE_VARIABLES(); \ if (stackb != stacka) xfree(stackb); \ return; \ } while(0) #define FREE_AND_RETURN(stackb,val) do { \ + FREE_VARIABLES(); \ if (stackb != stacka) xfree(stackb); \ return(val); \ } while(0) -#define DOUBLE_STACK(stackx,stackb,len,type) do { \ +#define DOUBLE_STACK(type) do { \ + type *stackx; \ + unsigned int xlen = stacke - stackb; \ if (stackb == stacka) { \ - stackx = (type*)xmalloc(2*len*sizeof(type)); \ + stackx = (type*)xmalloc(2 * xlen * sizeof(type)); \ + memcpy(stackx, stackb, xlen * sizeof (type)); \ } \ else { \ - stackx = (type*)xrealloc(stackb, 2 * len * sizeof(type)); \ + stackx = (type*)xrealloc(stackb, 2 * xlen * sizeof(type)); \ } \ + /* Rearrange the pointers. */ \ + stackp = stackx + (stackp - stackb); \ + stackb = stackx; \ + stacke = stackb + 2 * xlen; \ } while (0) -#endif /* NO_ALLOCA */ - -#define RE_TALLOC(n,t) ((t*)RE_ALLOCATE((n)*sizeof(t))) +#define RE_TALLOC(n,t) ((t*)alloca((n)*sizeof(t))) #define TMALLOC(n,t) ((t*)xmalloc((n)*sizeof(t))) #define TREALLOC(s,n,t) (s=((t*)xrealloc(s,(n)*sizeof(t)))) -#define EXPAND_FAIL_STACK(stackx,stackb,len) \ - do { \ - /* Roughly double the size of the stack. */ \ - DOUBLE_STACK(stackx,stackb,len,unsigned char*); \ - /* Rearrange the pointers. */ \ - stackp = stackx + (stackp - stackb); \ - stackb = stackx; \ - stacke = stackb + 2 * len; \ - } while (0) - +#define EXPAND_FAIL_STACK() DOUBLE_STACK(unsigned char*) #define ENSURE_FAIL_STACK(n) \ do { \ if (stacke - stackp <= (n)) { \ - unsigned char **stackx; \ - unsigned int len = stacke - stackb; \ /* if (len > re_max_failures * MAX_NUM_FAILURE_ITEMS) \ { \ - FREE_VARIABLES(); \ FREE_AND_RETURN(stackb,(-2)); \ }*/ \ \ /* Roughly double the size of the stack. */ \ - EXPAND_FAIL_STACK(stackx, stackb, len); \ + EXPAND_FAIL_STACK(); \ } \ } while (0) @@ -1794,14 +1774,7 @@ re_compile_pattern(pattern, size, bufp) } if (c == '#') break; if (stackp+8 >= stacke) { - int *stackx; - unsigned int len = stacke - stackb; - - DOUBLE_STACK(stackx,stackb,len,int); - /* Rearrange the pointers. */ - stackp = stackx + (stackp - stackb); - stackb = stackx; - stacke = stackb + 2 * len; + DOUBLE_STACK(int); } /* Laststart should point to the start_memory that we are about @@ -2891,10 +2864,7 @@ re_compile_fastmap(bufp) EXTRACT_NUMBER_AND_INCR(j, p); if (p + j < pend) { if (stackp == stacke) { - unsigned char **stackx; - unsigned int len = stacke - stackb; - - EXPAND_FAIL_STACK(stackx, stackb, len); + EXPAND_FAIL_STACK(); } *++stackp = p + j; /* push */ } @@ -3564,7 +3534,7 @@ re_match(bufp, string_arg, size, pos, regs) ``dummy''; if a failure happens and the failure point is a dummy, it gets discarded and the next next one is tried. */ - unsigned char *stacka[MAX_NUM_FAILURE_ITEMS * NFAILURES]; + unsigned char **stacka; unsigned char **stackb; unsigned char **stackp; unsigned char **stacke; @@ -3613,6 +3583,7 @@ re_match(bufp, string_arg, size, pos, regs) } /* Initialize the stack. */ + stacka = RE_TALLOC(MAX_NUM_FAILURE_ITEMS * NFAILURES, unsigned char*); stackb = stacka; stackp = stackb; stacke = &stackb[MAX_NUM_FAILURE_ITEMS * NFAILURES]; @@ -3714,7 +3685,6 @@ re_match(bufp, string_arg, size, pos, regs) regs->end[mcnt] = regend[mcnt] - string; } } - FREE_VARIABLES(); FREE_AND_RETURN(stackb, (d - pos - string)); } @@ -3797,7 +3767,6 @@ re_match(bufp, string_arg, size, pos, regs) case start_nowidth: PUSH_FAILURE_POINT(0, d); if (stackp - stackb > RE_DUP_MAX) { - FREE_VARIABLES(); FREE_AND_RETURN(stackb,(-2)); } EXTRACT_NUMBER_AND_INCR(mcnt, p); @@ -4375,7 +4344,6 @@ re_match(bufp, string_arg, size, pos, regs) if (best_regs_set) goto restore_best_regs; - FREE_VARIABLES(); FREE_AND_RETURN(stackb,(-1)); /* Failure to match. */ }