2000-05-01 05:42:38 -04:00
|
|
|
/**********************************************************************
|
1998-01-16 07:13:05 -05:00
|
|
|
|
|
|
|
variable.c -
|
|
|
|
|
|
|
|
$Author$
|
|
|
|
created at: Tue Apr 19 23:55:15 JST 1994
|
|
|
|
|
* encoding.c: provide basic features for M17N.
* parse.y: encoding aware parsing.
* parse.y (pragma_encoding): encoding specification pragma.
* parse.y (rb_intern3): encoding specified symbols.
* string.c (rb_str_length): length based on characters.
for older behavior, bytesize method added.
* string.c (rb_str_index_m): index based on characters. rindex as
well.
* string.c (succ_char): encoding aware succeeding string.
* string.c (rb_str_reverse): reverse based on characters.
* string.c (rb_str_inspect): encoding aware string description.
* string.c (rb_str_upcase_bang): encoding aware case conversion.
downcase, capitalize, swapcase as well.
* string.c (rb_str_tr_bang): tr based on characters. delete,
squeeze, tr_s, count as well.
* string.c (rb_str_split_m): split based on characters.
* string.c (rb_str_each_line): encoding aware each_line.
* string.c (rb_str_each_char): added. iteration based on
characters.
* string.c (rb_str_strip_bang): encoding aware whitespace
stripping. lstrip, rstrip as well.
* string.c (rb_str_justify): encoding aware justifying (ljust,
rjust, center).
* string.c (str_encoding): get encoding attribute from a string.
* re.c (rb_reg_initialize): encoding aware regular expression
* sprintf.c (rb_str_format): formatting (i.e. length count) based
on characters.
* io.c (rb_io_getc): getc to return one-character string.
for older behavior, getbyte method added.
* ext/stringio/stringio.c (strio_getc): ditto.
* io.c (rb_io_ungetc): allow pushing arbitrary string at the
current reading point.
* ext/stringio/stringio.c (strio_ungetc): ditto.
* ext/strscan/strscan.c: encoding support.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@13261 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-08-24 23:29:39 -04:00
|
|
|
Copyright (C) 1993-2007 Yukihiro Matsumoto
|
2000-05-01 05:42:38 -04:00
|
|
|
Copyright (C) 2000 Network Applied Communication Laboratory, Inc.
|
2000-05-09 00:53:16 -04:00
|
|
|
Copyright (C) 2000 Information-technology Promotion Agency, Japan
|
2000-05-01 05:42:38 -04:00
|
|
|
|
|
|
|
**********************************************************************/
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2007-06-09 23:06:15 -04:00
|
|
|
#include "ruby/ruby.h"
|
|
|
|
#include "ruby/st.h"
|
|
|
|
#include "ruby/util.h"
|
2009-08-09 17:55:55 -04:00
|
|
|
#include "ruby/encoding.h"
|
* include/ruby/node.h, node.h: move node.h from include path.
This change stop to install node.h beacuase of saving ABI
(node.h will be changed. Extensions should not depends on
this file).
* blockinlining.c, class.c, compile.c, debug.h, enum.c,
gc.c, iseq.c, parse.y, ruby.c, signal.c, variable.c,
vm.c, vm_core.h, vm_dump.c: ditto.
* ext/ripper/depend: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@19500 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2008-09-23 15:52:31 -04:00
|
|
|
#include "node.h"
|
2010-10-26 13:27:32 -04:00
|
|
|
#include "constant.h"
|
2011-05-18 09:41:54 -04:00
|
|
|
#include "internal.h"
|
2013-05-02 03:54:17 -04:00
|
|
|
#include "id.h"
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2006-07-20 13:36:36 -04:00
|
|
|
st_table *rb_global_tbl;
|
2009-07-30 03:12:56 -04:00
|
|
|
static ID autoload, classpath, tmp_classpath, classid;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
Init_var_tables(void)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
1999-01-19 23:59:39 -05:00
|
|
|
rb_global_tbl = st_init_numtable();
|
2008-06-09 05:25:32 -04:00
|
|
|
CONST_ID(autoload, "__autoload__");
|
2012-07-31 05:22:36 -04:00
|
|
|
/* __classpath__: fully qualified class path */
|
2008-06-09 05:25:32 -04:00
|
|
|
CONST_ID(classpath, "__classpath__");
|
2012-07-31 05:22:36 -04:00
|
|
|
/* __tmp_classpath__: temporary class path which contains anonymous names */
|
2008-06-09 05:25:32 -04:00
|
|
|
CONST_ID(tmp_classpath, "__tmp_classpath__");
|
2012-07-31 05:22:36 -04:00
|
|
|
/* __classid__: name given to class/module under an anonymous namespace */
|
2009-07-30 03:12:56 -04:00
|
|
|
CONST_ID(classid, "__classid__");
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
struct fc_result {
|
2012-07-30 01:24:24 -04:00
|
|
|
ID name, preferred;
|
1998-01-16 07:19:22 -05:00
|
|
|
VALUE klass;
|
1998-01-16 07:13:05 -05:00
|
|
|
VALUE path;
|
|
|
|
VALUE track;
|
|
|
|
struct fc_result *prev;
|
|
|
|
};
|
|
|
|
|
2001-06-06 02:42:23 -04:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
fc_path(struct fc_result *fc, ID name)
|
2001-06-06 02:42:23 -04:00
|
|
|
{
|
|
|
|
VALUE path, tmp;
|
|
|
|
|
2007-12-24 11:38:44 -05:00
|
|
|
path = rb_str_dup(rb_id2str(name));
|
2001-06-06 02:42:23 -04:00
|
|
|
while (fc) {
|
2009-07-30 03:10:51 -04:00
|
|
|
st_data_t n;
|
2001-06-06 02:42:23 -04:00
|
|
|
if (fc->track == rb_cObject) break;
|
2007-09-28 02:21:46 -04:00
|
|
|
if (RCLASS_IV_TBL(fc->track) &&
|
2009-07-30 03:10:51 -04:00
|
|
|
st_lookup(RCLASS_IV_TBL(fc->track), (st_data_t)classpath, &n)) {
|
|
|
|
tmp = rb_str_dup((VALUE)n);
|
2001-06-06 02:42:23 -04:00
|
|
|
rb_str_cat2(tmp, "::");
|
|
|
|
rb_str_append(tmp, path);
|
2007-06-07 04:21:01 -04:00
|
|
|
path = tmp;
|
|
|
|
break;
|
2001-06-06 02:42:23 -04:00
|
|
|
}
|
2007-12-24 11:38:44 -05:00
|
|
|
tmp = rb_str_dup(rb_id2str(fc->name));
|
2001-06-06 02:42:23 -04:00
|
|
|
rb_str_cat2(tmp, "::");
|
|
|
|
rb_str_append(tmp, path);
|
|
|
|
path = tmp;
|
|
|
|
fc = fc->prev;
|
|
|
|
}
|
2007-06-07 04:21:01 -04:00
|
|
|
OBJ_FREEZE(path);
|
2001-06-06 02:42:23 -04:00
|
|
|
return path;
|
|
|
|
}
|
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
static int
|
2012-03-30 18:40:54 -04:00
|
|
|
fc_i(st_data_t k, st_data_t v, st_data_t a)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2012-03-30 18:40:54 -04:00
|
|
|
ID key = (ID)k;
|
|
|
|
rb_const_entry_t *ce = (rb_const_entry_t *)v;
|
|
|
|
struct fc_result *res = (struct fc_result *)a;
|
2010-10-26 13:27:32 -04:00
|
|
|
VALUE value = ce->value;
|
1999-12-14 01:50:43 -05:00
|
|
|
if (!rb_is_const_id(key)) return ST_CONTINUE;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2012-07-30 01:24:24 -04:00
|
|
|
if (value == res->klass && (!res->preferred || key == res->preferred)) {
|
2001-06-06 02:42:23 -04:00
|
|
|
res->path = fc_path(res, key);
|
1998-01-16 07:13:05 -05:00
|
|
|
return ST_STOP;
|
|
|
|
}
|
2012-07-28 13:04:58 -04:00
|
|
|
if (RB_TYPE_P(value, T_MODULE) || RB_TYPE_P(value, T_CLASS)) {
|
2010-10-26 13:27:21 -04:00
|
|
|
if (!RCLASS_CONST_TBL(value)) return ST_CONTINUE;
|
2001-06-06 02:42:23 -04:00
|
|
|
else {
|
|
|
|
struct fc_result arg;
|
|
|
|
struct fc_result *list;
|
|
|
|
|
|
|
|
list = res;
|
|
|
|
while (list) {
|
|
|
|
if (list->track == value) return ST_CONTINUE;
|
|
|
|
list = list->prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
arg.name = key;
|
2012-07-30 01:24:24 -04:00
|
|
|
arg.preferred = res->preferred;
|
2001-06-06 02:42:23 -04:00
|
|
|
arg.path = 0;
|
|
|
|
arg.klass = res->klass;
|
|
|
|
arg.track = value;
|
|
|
|
arg.prev = res;
|
2010-10-26 13:27:21 -04:00
|
|
|
st_foreach(RCLASS_CONST_TBL(value), fc_i, (st_data_t)&arg);
|
2001-06-06 02:42:23 -04:00
|
|
|
if (arg.path) {
|
|
|
|
res->path = arg.path;
|
|
|
|
return ST_STOP;
|
|
|
|
}
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return ST_CONTINUE;
|
|
|
|
}
|
|
|
|
|
2012-07-31 05:22:36 -04:00
|
|
|
/**
|
|
|
|
* Traverse constant namespace and find +classpath+ for _klass_. If
|
|
|
|
* _preferred_ is not 0, choice the path whose base name is set to it.
|
|
|
|
* If +classpath+ is found, the hidden instance variable __classpath__
|
|
|
|
* is set to the found path, and __tmp_classpath__ is removed.
|
|
|
|
* The path is frozen.
|
|
|
|
*/
|
1998-01-16 07:13:05 -05:00
|
|
|
static VALUE
|
2012-07-30 01:24:24 -04:00
|
|
|
find_class_path(VALUE klass, ID preferred)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
struct fc_result arg;
|
|
|
|
|
2012-07-30 01:24:24 -04:00
|
|
|
arg.preferred = preferred;
|
1998-01-16 07:13:05 -05:00
|
|
|
arg.name = 0;
|
|
|
|
arg.path = 0;
|
1999-01-19 23:59:39 -05:00
|
|
|
arg.klass = klass;
|
|
|
|
arg.track = rb_cObject;
|
1998-01-16 07:13:05 -05:00
|
|
|
arg.prev = 0;
|
2010-10-26 13:27:21 -04:00
|
|
|
if (RCLASS_CONST_TBL(rb_cObject)) {
|
|
|
|
st_foreach_safe(RCLASS_CONST_TBL(rb_cObject), fc_i, (st_data_t)&arg);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
2001-06-06 02:42:23 -04:00
|
|
|
if (arg.path) {
|
2009-07-30 03:10:51 -04:00
|
|
|
st_data_t tmp = tmp_classpath;
|
2007-09-28 02:21:46 -04:00
|
|
|
if (!RCLASS_IV_TBL(klass)) {
|
|
|
|
RCLASS_IV_TBL(klass) = st_init_numtable();
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
}
|
2013-06-14 05:23:54 -04:00
|
|
|
rb_st_insert_id_and_value(klass, RCLASS_IV_TBL(klass), (st_data_t)classpath, arg.path);
|
|
|
|
|
2009-07-30 03:10:51 -04:00
|
|
|
st_delete(RCLASS_IV_TBL(klass), &tmp, 0);
|
1998-01-16 07:13:05 -05:00
|
|
|
return arg.path;
|
|
|
|
}
|
|
|
|
return Qnil;
|
|
|
|
}
|
|
|
|
|
2012-07-31 05:22:36 -04:00
|
|
|
/**
|
|
|
|
* Returns +classpath+ of _klass_, if it is named, or +nil+ for
|
|
|
|
* anonymous +class+/+module+. The last part of named +classpath+ is
|
|
|
|
* never anonymous, but anonymous +class+/+module+ names may be
|
|
|
|
* contained. If the path is "permanent", that means it has no
|
|
|
|
* anonymous names, <code>*permanent</code> is set to 1.
|
|
|
|
*/
|
1998-01-16 07:13:05 -05:00
|
|
|
static VALUE
|
2012-07-31 05:22:36 -04:00
|
|
|
classname(VALUE klass, int *permanent)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
1999-08-13 01:45:20 -04:00
|
|
|
VALUE path = Qnil;
|
2009-07-30 03:10:51 -04:00
|
|
|
st_data_t n;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
1999-01-19 23:59:39 -05:00
|
|
|
if (!klass) klass = rb_cObject;
|
2012-07-31 05:22:36 -04:00
|
|
|
*permanent = 1;
|
2007-09-28 02:21:46 -04:00
|
|
|
if (RCLASS_IV_TBL(klass)) {
|
2009-07-30 03:10:51 -04:00
|
|
|
if (!st_lookup(RCLASS_IV_TBL(klass), (st_data_t)classpath, &n)) {
|
2012-07-31 05:22:36 -04:00
|
|
|
ID cid = 0;
|
2012-07-30 08:00:56 -04:00
|
|
|
if (st_lookup(RCLASS_IV_TBL(klass), (st_data_t)classid, &n)) {
|
2012-07-31 05:22:36 -04:00
|
|
|
cid = SYM2ID(n);
|
|
|
|
path = find_class_path(klass, cid);
|
2012-07-30 08:00:56 -04:00
|
|
|
}
|
|
|
|
if (NIL_P(path)) {
|
|
|
|
path = find_class_path(klass, (ID)0);
|
2012-07-30 01:24:24 -04:00
|
|
|
}
|
|
|
|
if (NIL_P(path)) {
|
2013-09-07 00:58:38 -04:00
|
|
|
if (!cid) {
|
2012-07-30 08:00:56 -04:00
|
|
|
return Qnil;
|
|
|
|
}
|
2013-09-07 00:58:38 -04:00
|
|
|
if (!st_lookup(RCLASS_IV_TBL(klass), (st_data_t)tmp_classpath, &n)) {
|
|
|
|
path = rb_str_dup(rb_id2str(cid));
|
|
|
|
OBJ_FREEZE(path);
|
|
|
|
return path;
|
|
|
|
}
|
2012-07-31 05:22:36 -04:00
|
|
|
*permanent = 0;
|
|
|
|
path = (VALUE)n;
|
2012-07-30 01:24:24 -04:00
|
|
|
return path;
|
2003-04-10 04:37:12 -04:00
|
|
|
}
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
2009-07-30 03:10:51 -04:00
|
|
|
else {
|
|
|
|
path = (VALUE)n;
|
|
|
|
}
|
2011-09-29 07:07:45 -04:00
|
|
|
if (!RB_TYPE_P(path, T_STRING)) {
|
2003-04-10 04:37:12 -04:00
|
|
|
rb_bug("class path is not set properly");
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
return path;
|
|
|
|
}
|
2012-07-30 01:24:24 -04:00
|
|
|
return find_class_path(klass, (ID)0);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2003-12-28 01:33:07 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* mod.name -> string
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2006-06-21 22:49:28 -04:00
|
|
|
* Returns the name of the module <i>mod</i>. Returns nil for anonymous modules.
|
2003-12-28 01:33:07 -05:00
|
|
|
*/
|
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_mod_name(VALUE mod)
|
1998-01-16 07:19:22 -05:00
|
|
|
{
|
2012-07-31 05:22:36 -04:00
|
|
|
int permanent;
|
|
|
|
VALUE path = classname(mod, &permanent);
|
1998-01-16 07:19:22 -05:00
|
|
|
|
2003-04-10 04:37:12 -04:00
|
|
|
if (!NIL_P(path)) return rb_str_dup(path);
|
2006-06-21 22:49:28 -04:00
|
|
|
return path;
|
1998-01-16 07:19:22 -05:00
|
|
|
}
|
|
|
|
|
2012-11-30 21:13:06 -05:00
|
|
|
typedef VALUE (*path_cache_func)(VALUE obj, ID id, VALUE val);
|
|
|
|
|
2012-07-30 01:24:24 -04:00
|
|
|
static VALUE
|
2012-11-30 21:13:06 -05:00
|
|
|
rb_tmp_class_path(VALUE klass, int *permanent, path_cache_func cache_path)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2012-07-31 05:22:36 -04:00
|
|
|
VALUE path = classname(klass, permanent);
|
2009-07-30 03:10:51 -04:00
|
|
|
st_data_t n = (st_data_t)path;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2012-07-30 01:24:24 -04:00
|
|
|
if (!NIL_P(path)) {
|
|
|
|
return path;
|
|
|
|
}
|
2007-09-28 02:21:46 -04:00
|
|
|
if (RCLASS_IV_TBL(klass) && st_lookup(RCLASS_IV_TBL(klass),
|
2009-07-30 03:10:51 -04:00
|
|
|
(st_data_t)tmp_classpath, &n)) {
|
2012-07-30 01:24:24 -04:00
|
|
|
*permanent = 0;
|
2009-07-30 03:43:32 -04:00
|
|
|
return (VALUE)n;
|
2003-08-02 01:02:43 -04:00
|
|
|
}
|
1998-01-16 07:13:05 -05:00
|
|
|
else {
|
* sprintf.c (rb_str_format): allow %c to print one character
string (e.g. ?x).
* lib/tempfile.rb (Tempfile::make_tmpname): put dot between
basename and pid. [ruby-talk:196272]
* parse.y (do_block): remove -> style block.
* parse.y (parser_yylex): remove tLAMBDA_ARG.
* eval.c (rb_call0): binding for the return event hook should have
consistent scope. [ruby-core:07928]
* eval.c (proc_invoke): return behavior should depend whether it
is surrounded by a lambda or a mere block.
* eval.c (formal_assign): handles post splat arguments.
* eval.c (rb_call0): ditto.
* st.c (strhash): use FNV-1a hash.
* parse.y (parser_yylex): removed experimental ';;' terminator.
* eval.c (rb_node_arity): should be aware of post splat arguments.
* eval.c (rb_proc_arity): ditto.
* parse.y (f_args): syntax rule enhanced to support arguments
after the splat.
* parse.y (block_param): ditto for block parameters.
* parse.y (f_post_arg): mandatory formal arguments after the splat
argument.
* parse.y (new_args_gen): generate nodes for mandatory formal
arguments after the splat argument.
* eval.c (rb_eval): dispatch mandatory formal arguments after the
splat argument.
* parse.y (args): allow more than one splat in the argument list.
* parse.y (method_call): allow aref [] to accept all kind of
method argument, including assocs, splat, and block argument.
* eval.c (SETUP_ARGS0): prepare block argument as well.
* lib/mathn.rb (Integer): remove Integer#gcd2. [ruby-core:07931]
* eval.c (error_line): print receivers true/false/nil specially.
* eval.c (rb_proc_yield): handles parameters in yield semantics.
* eval.c (nil_yield): gives LocalJumpError to denote no block
error.
* io.c (rb_io_getc): now takes one-character string.
* string.c (rb_str_hash): use FNV-1a hash from Fowler/Noll/Vo
hashing algorithm.
* string.c (rb_str_aref): str[0] now returns 1 character string,
instead of a fixnum. [Ruby2]
* parse.y (parser_yylex): ?c now returns 1 character string,
instead of a fixnum. [Ruby2]
* string.c (rb_str_aset): no longer support fixnum insertion.
* eval.c (umethod_bind): should not update original class.
[ruby-dev:28636]
* eval.c (ev_const_get): should support constant access from
within instance_eval(). [ruby-dev:28327]
* time.c (time_timeval): should round for usec floating
number. [ruby-core:07896]
* time.c (time_add): ditto.
* dir.c (sys_warning): should not call a vararg function
rb_sys_warning() indirectly. [ruby-core:07886]
* numeric.c (flo_divmod): the first element of Float#divmod should
be an integer. [ruby-dev:28589]
* test/ruby/test_float.rb: add tests for divmod, div, modulo and remainder.
* re.c (rb_reg_initialize): should not allow modifying literal
regexps. frozen check moved from rb_reg_initialize_m as well.
* re.c (rb_reg_initialize): should not modify untainted objects in
safe levels higher than 3.
* re.c (rb_memcmp): type change from char* to const void*.
* dir.c (dir_close): should not close untainted dir stream.
* dir.c (GetDIR): add tainted/frozen check for each dir operation.
* lib/rdoc/parsers/parse_rb.rb (RDoc::RubyParser::parse_symbol_arg):
typo fixed. a patch from Florian Gross <florg at florg.net>.
* eval.c (EXEC_EVENT_HOOK): trace_func may remove itself from
event_hooks. no guarantee for arbitrary hook deletion.
[ruby-dev:28632]
* util.c (ruby_strtod): differ addition to minimize error.
[ruby-dev:28619]
* util.c (ruby_strtod): should not raise ERANGE when the input
string does not have any digits. [ruby-dev:28629]
* eval.c (proc_invoke): should restore old ruby_frame->block.
thanks to ts <decoux at moulon.inra.fr>. [ruby-core:07833]
also fix [ruby-dev:28614] as well.
* signal.c (trap): sig should be less then NSIG. Coverity found
this bug. a patch from Kevin Tew <tewk at tewk.com>.
[ruby-core:07823]
* math.c (math_log2): add new method inspired by
[ruby-talk:191237].
* math.c (math_log): add optional base argument to Math::log().
[ruby-talk:191308]
* ext/syck/emitter.c (syck_scan_scalar): avoid accessing
uninitialized array element. a patch from Pat Eyler
<rubypate at gmail.com>. [ruby-core:07809]
* array.c (rb_ary_fill): initialize local variables first. a
patch from Pat Eyler <rubypate at gmail.com>. [ruby-core:07810]
* ext/syck/yaml2byte.c (syck_yaml2byte_handler): need to free
type_tag. a patch from Pat Eyler <rubypate at gmail.com>.
[ruby-core:07808]
* ext/socket/socket.c (make_hostent_internal): accept ai_family
check from Sam Roberts <sroberts at uniserve.com>.
[ruby-core:07691]
* util.c (ruby_strtod): should not cut off 18 digits for no
reason. [ruby-core:07796]
* array.c (rb_ary_fill): internalize local variable "beg" to
pacify Coverity. [ruby-core:07770]
* pack.c (pack_unpack): now supports CRLF newlines. a patch from
<tommy at tmtm.org>. [ruby-dev:28601]
* applied code clean-up patch from Stefan Huehner
<stefan at huehner.org>. [ruby-core:07764]
* lib/jcode.rb (String::tr_s): should have translated non
squeezing character sequence (i.e. a character) as well. thanks
to Hiroshi Ichikawa <gimite at gimite.ddo.jp> [ruby-list:42090]
* ext/socket/socket.c: document update patch from Sam Roberts
<sroberts at uniserve.com>. [ruby-core:07701]
* lib/mathn.rb (Integer): need not to remove gcd2. a patch from
NARUSE, Yui <naruse at airemix.com>. [ruby-dev:28570]
* parse.y (arg): too much NEW_LIST()
* eval.c (SETUP_ARGS0): remove unnecessary access to nd_alen.
* eval.c (rb_eval): use ARGSCAT for NODE_OP_ASGN1.
[ruby-dev:28585]
* parse.y (arg): use NODE_ARGSCAT for placeholder.
* lib/getoptlong.rb (GetoptLong::get): RDoc update patch from
mathew <meta at pobox.com>. [ruby-core:07738]
* variable.c (rb_const_set): raise error when no target klass is
supplied. [ruby-dev:28582]
* prec.c (prec_prec_f): documentation patch from
<gerardo.santana at gmail.com>. [ruby-core:07689]
* bignum.c (rb_big_pow): second operand may be too big even if
it's a Fixnum. [ruby-talk:187984]
* README.EXT: update symbol description. [ruby-talk:188104]
* COPYING: explicitly note GPLv2. [ruby-talk:187922]
* parse.y: remove some obsolete syntax rules (unparenthesized
method calls in argument list).
* eval.c (rb_call0): insecure calling should be checked for non
NODE_SCOPE method invocations too.
* eval.c (rb_alias): should preserve the current safe level as
well as method definition.
* process.c (rb_f_sleep): remove RDoc description about SIGALRM
which is not valid on the current implementation. [ruby-dev:28464]
Thu Mar 23 21:40:47 2006 K.Kosako <sndgk393 AT ybb.ne.jp>
* eval.c (method_missing): should support argument splat in
super. a bug in combination of super, splat and
method_missing. [ruby-talk:185438]
* configure.in: Solaris SunPro compiler -rapth patch from
<kuwa at labs.fujitsu.com>. [ruby-dev:28443]
* configure.in: remove enable_rpath=no for Solaris.
[ruby-dev:28440]
* ext/win32ole/win32ole.c (ole_val2olevariantdata): change behavior
of converting OLE Variant object with VT_ARRAY|VT_UI1 and Ruby
String object.
* ruby.1: a clarification patch from David Lutterkort
<dlutter at redhat.com>. [ruby-core:7508]
* lib/rdoc/ri/ri_paths.rb (RI::Paths): adding paths from rubygems
directories. a patch from Eric Hodel <drbrain at segment7.net>.
[ruby-core:07423]
* eval.c (rb_clear_cache_by_class): clearing wrong cache.
* ext/extmk.rb: use :remove_destination to install extension libraries
to avoid SEGV. [ruby-dev:28417]
* eval.c (rb_thread_fd_writable): should not re-schedule output
from KILLED thread (must be error printing).
* array.c (rb_ary_flatten_bang): allow specifying recursion
level. [ruby-talk:182170]
* array.c (rb_ary_flatten): ditto.
* gc.c (add_heap): a heap_slots may overflow. a patch from Stefan
Weil <weil at mail.berlios.de>.
* eval.c (rb_call): use separate cache for fcall/vcall
invocation.
* eval.c (rb_eval): NODE_FCALL, NODE_VCALL can call local
functions.
* eval.c (rb_mod_local): a new method to specify newly added
visibility "local".
* eval.c (search_method): search for local methods which are
visible only from the current class.
* class.c (rb_class_local_methods): a method to list local methods.
* object.c (Init_Object): add BasicObject class as a top level
BlankSlate class.
* ruby.h (SYM2ID): should not cast to signed long.
[ruby-core:07414]
* class.c (rb_include_module): allow module duplication.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@10235 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2006-06-09 17:20:17 -04:00
|
|
|
const char *s = "Class";
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2011-09-29 07:07:45 -04:00
|
|
|
if (RB_TYPE_P(klass, T_MODULE)) {
|
2002-08-28 10:59:01 -04:00
|
|
|
if (rb_obj_class(klass) == rb_cModule) {
|
2001-10-03 03:19:19 -04:00
|
|
|
s = "Module";
|
2002-08-28 10:59:01 -04:00
|
|
|
}
|
|
|
|
else {
|
2012-11-30 21:13:06 -05:00
|
|
|
int perm;
|
|
|
|
VALUE path;
|
|
|
|
|
|
|
|
path = rb_tmp_class_path(RBASIC(klass)->klass, &perm, cache_path);
|
|
|
|
s = RSTRING_PTR(path);
|
2002-08-28 10:59:01 -04:00
|
|
|
}
|
2001-10-03 03:19:19 -04:00
|
|
|
}
|
2006-09-17 21:59:00 -04:00
|
|
|
path = rb_sprintf("#<%s:%p>", s, (void*)klass);
|
2007-06-07 04:21:01 -04:00
|
|
|
OBJ_FREEZE(path);
|
2012-11-30 21:13:06 -05:00
|
|
|
|
|
|
|
cache_path(klass, tmp_classpath, path);
|
2012-07-30 01:24:24 -04:00
|
|
|
*permanent = 0;
|
2002-08-28 10:59:01 -04:00
|
|
|
|
2003-04-10 04:37:12 -04:00
|
|
|
return path;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-30 01:24:24 -04:00
|
|
|
VALUE
|
|
|
|
rb_class_path(VALUE klass)
|
|
|
|
{
|
|
|
|
int permanent;
|
2012-11-30 21:13:06 -05:00
|
|
|
VALUE path = rb_tmp_class_path(klass, &permanent, rb_ivar_set);
|
|
|
|
if (!NIL_P(path)) path = rb_str_dup(path);
|
|
|
|
return path;
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
null_cache(VALUE obj, ID id, VALUE val)
|
|
|
|
{
|
|
|
|
return Qnil;
|
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_class_path_no_cache(VALUE klass)
|
|
|
|
{
|
|
|
|
int permanent;
|
|
|
|
VALUE path = rb_tmp_class_path(klass, &permanent, null_cache);
|
2012-07-31 05:22:36 -04:00
|
|
|
if (!NIL_P(path)) path = rb_str_dup(path);
|
|
|
|
return path;
|
2012-07-30 01:24:24 -04:00
|
|
|
}
|
|
|
|
|
2009-07-30 03:45:42 -04:00
|
|
|
void
|
|
|
|
rb_set_class_path_string(VALUE klass, VALUE under, VALUE name)
|
|
|
|
{
|
|
|
|
VALUE str;
|
2012-07-30 08:00:56 -04:00
|
|
|
ID pathid = classpath;
|
2009-07-30 03:45:42 -04:00
|
|
|
|
|
|
|
if (under == rb_cObject) {
|
|
|
|
str = rb_str_new_frozen(name);
|
|
|
|
}
|
|
|
|
else {
|
2012-07-30 01:24:24 -04:00
|
|
|
int permanent;
|
2012-11-30 21:13:06 -05:00
|
|
|
str = rb_str_dup(rb_tmp_class_path(under, &permanent, rb_ivar_set));
|
2009-07-30 03:45:42 -04:00
|
|
|
rb_str_cat2(str, "::");
|
|
|
|
rb_str_append(str, name);
|
|
|
|
OBJ_FREEZE(str);
|
2012-07-31 05:22:36 -04:00
|
|
|
if (!permanent) {
|
|
|
|
pathid = tmp_classpath;
|
|
|
|
rb_ivar_set(klass, classid, ID2SYM(rb_intern_str(name)));
|
|
|
|
}
|
2009-07-30 03:45:42 -04:00
|
|
|
}
|
2012-07-30 08:00:56 -04:00
|
|
|
rb_ivar_set(klass, pathid, str);
|
2009-07-30 03:45:42 -04:00
|
|
|
}
|
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_set_class_path(VALUE klass, VALUE under, const char *name)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
VALUE str;
|
2012-07-30 08:00:56 -04:00
|
|
|
ID pathid = classpath;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
1999-01-19 23:59:39 -05:00
|
|
|
if (under == rb_cObject) {
|
|
|
|
str = rb_str_new2(name);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
else {
|
2012-07-30 08:00:56 -04:00
|
|
|
int permanent;
|
2012-11-30 21:13:06 -05:00
|
|
|
str = rb_str_dup(rb_tmp_class_path(under, &permanent, rb_ivar_set));
|
2000-04-10 01:48:43 -04:00
|
|
|
rb_str_cat2(str, "::");
|
|
|
|
rb_str_cat2(str, name);
|
2012-07-31 05:22:36 -04:00
|
|
|
if (!permanent) {
|
|
|
|
pathid = tmp_classpath;
|
|
|
|
rb_ivar_set(klass, classid, ID2SYM(rb_intern(name)));
|
|
|
|
}
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
2007-06-07 04:21:01 -04:00
|
|
|
OBJ_FREEZE(str);
|
2012-07-30 08:00:56 -04:00
|
|
|
rb_ivar_set(klass, pathid, str);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
2009-08-09 17:55:55 -04:00
|
|
|
rb_path_to_class(VALUE pathname)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2009-08-09 17:55:55 -04:00
|
|
|
rb_encoding *enc = rb_enc_get(pathname);
|
|
|
|
const char *pbeg, *p, *path = RSTRING_PTR(pathname);
|
2002-09-05 05:42:56 -04:00
|
|
|
ID id;
|
|
|
|
VALUE c = rb_cObject;
|
1999-11-29 01:33:02 -05:00
|
|
|
|
2009-08-09 17:55:55 -04:00
|
|
|
if (!rb_enc_asciicompat(enc)) {
|
|
|
|
rb_raise(rb_eArgError, "invalid class path encoding (non ASCII)");
|
|
|
|
}
|
|
|
|
pbeg = p = path;
|
1998-01-16 07:13:05 -05:00
|
|
|
if (path[0] == '#') {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_raise(rb_eArgError, "can't retrieve anonymous class %"PRIsVALUE,
|
|
|
|
QUOTE(pathname));
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
2002-09-05 05:42:56 -04:00
|
|
|
while (*p) {
|
|
|
|
while (*p && *p != ':') p++;
|
2012-12-22 10:04:57 -05:00
|
|
|
id = rb_check_id_cstr(pbeg, p-pbeg, enc);
|
2002-09-05 05:42:56 -04:00
|
|
|
if (p[0] == ':') {
|
|
|
|
if (p[1] != ':') goto undefined_class;
|
|
|
|
p += 2;
|
|
|
|
pbeg = p;
|
|
|
|
}
|
2012-12-22 10:04:57 -05:00
|
|
|
if (!id || !rb_const_defined_at(c, id)) {
|
2002-09-05 05:42:56 -04:00
|
|
|
undefined_class:
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_raise(rb_eArgError, "undefined class/module %.*"PRIsVALUE,
|
|
|
|
(int)(p-path), pathname);
|
2002-09-05 05:42:56 -04:00
|
|
|
}
|
|
|
|
c = rb_const_get_at(c, id);
|
2012-07-28 13:04:58 -04:00
|
|
|
if (!RB_TYPE_P(c, T_MODULE) && !RB_TYPE_P(c, T_CLASS)) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_raise(rb_eTypeError, "%"PRIsVALUE" does not refer to class/module",
|
|
|
|
pathname);
|
2002-09-05 05:42:56 -04:00
|
|
|
}
|
1999-11-29 01:33:02 -05:00
|
|
|
}
|
2012-12-04 02:23:20 -05:00
|
|
|
RB_GC_GUARD(pathname);
|
2002-09-05 05:42:56 -04:00
|
|
|
|
1999-11-29 01:33:02 -05:00
|
|
|
return c;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2009-08-09 17:55:55 -04:00
|
|
|
VALUE
|
|
|
|
rb_path2class(const char *path)
|
|
|
|
{
|
2009-09-09 00:09:09 -04:00
|
|
|
return rb_path_to_class(rb_str_new_cstr(path));
|
2009-08-09 17:55:55 -04:00
|
|
|
}
|
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_name_class(VALUE klass, ID id)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2009-07-30 03:12:56 -04:00
|
|
|
rb_ivar_set(klass, classid, ID2SYM(id));
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2004-01-19 04:19:31 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_class_name(VALUE klass)
|
2004-01-19 04:19:31 -05:00
|
|
|
{
|
|
|
|
return rb_class_path(rb_class_real(klass));
|
|
|
|
}
|
|
|
|
|
2008-05-31 05:28:20 -04:00
|
|
|
const char *
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_class2name(VALUE klass)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2013-10-19 15:21:05 -04:00
|
|
|
int permanent;
|
2013-10-19 16:24:30 -04:00
|
|
|
VALUE path = rb_tmp_class_path(rb_class_real(klass), &permanent, rb_ivar_set);
|
2013-10-19 15:21:05 -04:00
|
|
|
if (NIL_P(path)) return NULL;
|
|
|
|
return RSTRING_PTR(path);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2008-05-31 05:28:20 -04:00
|
|
|
const char *
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_obj_classname(VALUE obj)
|
2003-01-30 23:00:17 -05:00
|
|
|
{
|
2003-01-30 23:16:51 -05:00
|
|
|
return rb_class2name(CLASS_OF(obj));
|
2003-01-30 23:00:17 -05:00
|
|
|
}
|
|
|
|
|
2008-10-14 07:45:32 -04:00
|
|
|
#define global_variable rb_global_variable
|
2009-07-15 20:01:06 -04:00
|
|
|
#define global_entry rb_global_entry
|
2008-09-25 21:35:57 -04:00
|
|
|
|
2008-10-14 07:45:32 -04:00
|
|
|
#define gvar_getter_t rb_gvar_getter_t
|
|
|
|
#define gvar_setter_t rb_gvar_setter_t
|
|
|
|
#define gvar_marker_t rb_gvar_marker_t
|
2008-09-25 21:35:57 -04:00
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
struct trace_var {
|
1998-01-16 07:19:22 -05:00
|
|
|
int removed;
|
2008-09-25 21:35:57 -04:00
|
|
|
void (*func)(VALUE arg, VALUE val);
|
2001-03-18 22:20:24 -05:00
|
|
|
VALUE data;
|
1998-01-16 07:13:05 -05:00
|
|
|
struct trace_var *next;
|
|
|
|
};
|
|
|
|
|
2001-10-22 12:20:14 -04:00
|
|
|
struct global_variable {
|
|
|
|
int counter;
|
1998-01-16 07:13:05 -05:00
|
|
|
void *data;
|
2008-09-25 21:35:57 -04:00
|
|
|
gvar_getter_t *getter;
|
|
|
|
gvar_setter_t *setter;
|
|
|
|
gvar_marker_t *marker;
|
1998-01-16 07:13:05 -05:00
|
|
|
int block_trace;
|
|
|
|
struct trace_var *trace;
|
|
|
|
};
|
|
|
|
|
2008-10-14 07:45:32 -04:00
|
|
|
#define undef_getter rb_gvar_undef_getter
|
|
|
|
#define undef_setter rb_gvar_undef_setter
|
|
|
|
#define undef_marker rb_gvar_undef_marker
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2008-10-14 07:45:32 -04:00
|
|
|
#define val_getter rb_gvar_val_getter
|
|
|
|
#define val_setter rb_gvar_val_setter
|
|
|
|
#define val_marker rb_gvar_val_marker
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2008-10-14 07:45:32 -04:00
|
|
|
#define var_getter rb_gvar_var_getter
|
|
|
|
#define var_setter rb_gvar_var_setter
|
|
|
|
#define var_marker rb_gvar_var_marker
|
|
|
|
|
|
|
|
#define readonly_setter rb_gvar_readonly_setter
|
1998-01-16 07:13:05 -05:00
|
|
|
|
|
|
|
struct global_entry*
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_global_entry(ID id)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
struct global_entry *entry;
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
st_data_t data;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2009-07-30 03:10:51 -04:00
|
|
|
if (!st_lookup(rb_global_tbl, (st_data_t)id, &data)) {
|
2001-10-22 12:20:14 -04:00
|
|
|
struct global_variable *var;
|
1998-01-16 07:13:05 -05:00
|
|
|
entry = ALLOC(struct global_entry);
|
2001-10-22 12:20:14 -04:00
|
|
|
var = ALLOC(struct global_variable);
|
1998-01-16 07:13:05 -05:00
|
|
|
entry->id = id;
|
2001-10-22 12:20:14 -04:00
|
|
|
entry->var = var;
|
|
|
|
var->counter = 1;
|
|
|
|
var->data = 0;
|
|
|
|
var->getter = undef_getter;
|
|
|
|
var->setter = undef_setter;
|
|
|
|
var->marker = undef_marker;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2001-10-22 12:20:14 -04:00
|
|
|
var->block_trace = 0;
|
|
|
|
var->trace = 0;
|
* st.h, st.c: Introduce new conventional typedef's, st_data_t,
st_compare_func_t, st_hash_func_t and st_each_func_t.
* st.h, st.c: Do explicit function declarations and do not rely on
implicit declarations. On such platforms as IA64, int argument
values are NOT automatically promoted to long (64bit) values, so
explicit declarations are mandatory for those functions that
take long values or pointers. This fixes miniruby's coredump on
FreeBSD/IA64.
* class.c, eval.c, gc.c, hash.c, marshal.c, parse.y, variable.c:
Add proper casts to avoid warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3303 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-01-06 10:55:43 -05:00
|
|
|
st_add_direct(rb_global_tbl, id, (st_data_t)entry);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
else {
|
|
|
|
entry = (struct global_entry *)data;
|
|
|
|
}
|
1998-01-16 07:13:05 -05:00
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
|
2008-10-14 07:45:32 -04:00
|
|
|
VALUE
|
2008-09-25 21:35:57 -04:00
|
|
|
undef_getter(ID id, void *data, struct global_variable *var)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_warning("global variable `%"PRIsVALUE"' not initialized", QUOTE_ID(id));
|
2002-04-11 06:03:01 -04:00
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
return Qnil;
|
|
|
|
}
|
|
|
|
|
2008-10-14 07:45:32 -04:00
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
undef_setter(VALUE val, ID id, void *data, struct global_variable *var)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2001-10-22 12:20:14 -04:00
|
|
|
var->getter = val_getter;
|
|
|
|
var->setter = val_setter;
|
|
|
|
var->marker = val_marker;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2001-10-22 12:20:14 -04:00
|
|
|
var->data = (void*)val;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2008-10-14 07:45:32 -04:00
|
|
|
void
|
2008-09-25 21:35:57 -04:00
|
|
|
undef_marker(VALUE *var)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2008-10-14 07:45:32 -04:00
|
|
|
VALUE
|
2008-09-25 21:35:57 -04:00
|
|
|
val_getter(ID id, void *data, struct global_variable *var)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2008-09-25 21:35:57 -04:00
|
|
|
return (VALUE)data;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2008-10-14 07:45:32 -04:00
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
val_setter(VALUE val, ID id, void *data, struct global_variable *var)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2001-10-22 12:20:14 -04:00
|
|
|
var->data = (void*)val;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2008-10-14 07:45:32 -04:00
|
|
|
void
|
2008-09-25 21:35:57 -04:00
|
|
|
val_marker(VALUE *var)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2008-09-25 21:35:57 -04:00
|
|
|
VALUE data = (VALUE)var;
|
1999-01-19 23:59:39 -05:00
|
|
|
if (data) rb_gc_mark_maybe(data);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2008-10-14 07:45:32 -04:00
|
|
|
VALUE
|
2008-09-25 21:35:57 -04:00
|
|
|
var_getter(ID id, void *data, struct global_variable *gvar)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2008-09-25 21:35:57 -04:00
|
|
|
VALUE *var = data;
|
2001-11-13 03:19:52 -05:00
|
|
|
if (!var) return Qnil;
|
1998-01-16 07:13:05 -05:00
|
|
|
return *var;
|
|
|
|
}
|
|
|
|
|
2008-10-14 07:45:32 -04:00
|
|
|
void
|
2008-09-25 21:35:57 -04:00
|
|
|
var_setter(VALUE val, ID id, void *data, struct global_variable *gvar)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2008-09-25 21:35:57 -04:00
|
|
|
*(VALUE *)data = val;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2008-10-14 07:45:32 -04:00
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
var_marker(VALUE *var)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
1999-01-19 23:59:39 -05:00
|
|
|
if (var) rb_gc_mark_maybe(*var);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2008-10-14 07:45:32 -04:00
|
|
|
void
|
2008-09-25 21:35:57 -04:00
|
|
|
readonly_setter(VALUE val, ID id, void *data, struct global_variable *gvar)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error(id, "%"PRIsVALUE" is a read-only variable", QUOTE_ID(id));
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2012-03-30 18:40:54 -04:00
|
|
|
mark_global_entry(st_data_t k, st_data_t v, st_data_t a)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2012-03-30 18:40:54 -04:00
|
|
|
struct global_entry *entry = (struct global_entry *)v;
|
1998-01-16 07:13:05 -05:00
|
|
|
struct trace_var *trace;
|
2001-10-22 12:20:14 -04:00
|
|
|
struct global_variable *var = entry->var;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2001-10-22 12:20:14 -04:00
|
|
|
(*var->marker)(var->data);
|
|
|
|
trace = var->trace;
|
1998-01-16 07:13:05 -05:00
|
|
|
while (trace) {
|
1999-01-19 23:59:39 -05:00
|
|
|
if (trace->data) rb_gc_mark_maybe(trace->data);
|
1998-01-16 07:13:05 -05:00
|
|
|
trace = trace->next;
|
|
|
|
}
|
|
|
|
return ST_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_gc_mark_global_tbl(void)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2007-06-14 04:35:20 -04:00
|
|
|
if (rb_global_tbl)
|
|
|
|
st_foreach_safe(rb_global_tbl, mark_global_entry, 0);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static ID
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
global_id(const char *name)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
ID id;
|
|
|
|
|
|
|
|
if (name[0] == '$') id = rb_intern(name);
|
|
|
|
else {
|
* dir.c, dln.c, parse.y, re.c, ruby.c, sprintf.c, strftime.c,
string.c, util.c, variable.c: use strlcpy, memcpy and snprintf
instead of strcpy, strncpy and sprintf.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@22984 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2009-03-16 21:29:17 -04:00
|
|
|
size_t len = strlen(name);
|
|
|
|
char *buf = ALLOCA_N(char, len+1);
|
1998-01-16 07:13:05 -05:00
|
|
|
buf[0] = '$';
|
* dir.c, dln.c, parse.y, re.c, ruby.c, sprintf.c, strftime.c,
string.c, util.c, variable.c: use strlcpy, memcpy and snprintf
instead of strcpy, strncpy and sprintf.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@22984 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2009-03-16 21:29:17 -04:00
|
|
|
memcpy(buf+1, name, len);
|
|
|
|
id = rb_intern2(buf, len+1);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_define_hooked_variable(
|
|
|
|
const char *name,
|
|
|
|
VALUE *var,
|
2005-10-19 22:56:22 -04:00
|
|
|
VALUE (*getter)(ANYARGS),
|
|
|
|
void (*setter)(ANYARGS))
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2009-02-14 21:45:31 -05:00
|
|
|
volatile VALUE tmp = var ? *var : Qnil;
|
|
|
|
ID id = global_id(name);
|
|
|
|
struct global_variable *gvar = rb_global_entry(id)->var;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2001-10-22 12:20:14 -04:00
|
|
|
gvar->data = (void*)var;
|
2008-09-25 22:34:44 -04:00
|
|
|
gvar->getter = getter?(gvar_getter_t *)getter:var_getter;
|
|
|
|
gvar->setter = setter?(gvar_setter_t *)setter:var_setter;
|
2001-10-22 12:20:14 -04:00
|
|
|
gvar->marker = var_marker;
|
2008-05-02 10:57:23 -04:00
|
|
|
|
|
|
|
RB_GC_GUARD(tmp);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_define_variable(const char *name, VALUE *var)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
rb_define_hooked_variable(name, var, 0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_define_readonly_variable(const char *name, VALUE *var)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
rb_define_hooked_variable(name, var, 0, readonly_setter);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_define_virtual_variable(
|
|
|
|
const char *name,
|
2005-10-19 22:56:22 -04:00
|
|
|
VALUE (*getter)(ANYARGS),
|
|
|
|
void (*setter)(ANYARGS))
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
if (!getter) getter = val_getter;
|
|
|
|
if (!setter) setter = readonly_setter;
|
|
|
|
rb_define_hooked_variable(name, 0, getter, setter);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_trace_eval(VALUE cmd, VALUE val)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2001-11-13 03:19:52 -05:00
|
|
|
rb_eval_cmd(cmd, rb_ary_new3(1, val), 0);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2003-12-28 22:56:22 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* trace_var(symbol, cmd ) -> nil
|
|
|
|
* trace_var(symbol) {|val| block } -> nil
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 22:56:22 -05:00
|
|
|
* Controls tracing of assignments to global variables. The parameter
|
|
|
|
* +symbol_ identifies the variable (as either a string name or a
|
|
|
|
* symbol identifier). _cmd_ (which may be a string or a
|
|
|
|
* +Proc+ object) or block is executed whenever the variable
|
|
|
|
* is assigned. The block or +Proc+ object receives the
|
|
|
|
* variable's new value as a parameter. Also see
|
|
|
|
* <code>Kernel::untrace_var</code>.
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 22:56:22 -05:00
|
|
|
* trace_var :$_, proc {|v| puts "$_ is now '#{v}'" }
|
|
|
|
* $_ = "hello"
|
|
|
|
* $_ = ' there'
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 22:56:22 -05:00
|
|
|
* <em>produces:</em>
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 22:56:22 -05:00
|
|
|
* $_ is now 'hello'
|
|
|
|
* $_ is now ' there'
|
|
|
|
*/
|
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_f_trace_var(int argc, VALUE *argv)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
VALUE var, cmd;
|
|
|
|
struct global_entry *entry;
|
|
|
|
struct trace_var *trace;
|
|
|
|
|
|
|
|
if (rb_scan_args(argc, argv, "11", &var, &cmd) == 1) {
|
2003-06-16 03:14:50 -04:00
|
|
|
cmd = rb_block_proc();
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
if (NIL_P(cmd)) {
|
1999-01-19 23:59:39 -05:00
|
|
|
return rb_f_untrace_var(argc, argv);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
2001-11-13 03:19:52 -05:00
|
|
|
entry = rb_global_entry(rb_to_id(var));
|
|
|
|
if (OBJ_TAINTED(cmd)) {
|
|
|
|
rb_raise(rb_eSecurityError, "Insecure: tainted variable trace");
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
trace = ALLOC(struct trace_var);
|
2001-10-22 12:20:14 -04:00
|
|
|
trace->next = entry->var->trace;
|
1998-01-16 07:13:05 -05:00
|
|
|
trace->func = rb_trace_eval;
|
2001-03-18 22:20:24 -05:00
|
|
|
trace->data = cmd;
|
1998-01-16 07:19:22 -05:00
|
|
|
trace->removed = 0;
|
2001-10-22 12:20:14 -04:00
|
|
|
entry->var->trace = trace;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
|
|
|
return Qnil;
|
|
|
|
}
|
|
|
|
|
1998-01-16 07:19:22 -05:00
|
|
|
static void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
remove_trace(struct global_variable *var)
|
1998-01-16 07:19:22 -05:00
|
|
|
{
|
2001-10-22 12:20:14 -04:00
|
|
|
struct trace_var *trace = var->trace;
|
1998-01-16 07:19:22 -05:00
|
|
|
struct trace_var t;
|
|
|
|
struct trace_var *next;
|
|
|
|
|
|
|
|
t.next = trace;
|
|
|
|
trace = &t;
|
|
|
|
while (trace->next) {
|
|
|
|
next = trace->next;
|
|
|
|
if (next->removed) {
|
|
|
|
trace->next = next->next;
|
* array.c, bignum.c, cont.c, dir.c, dln.c, encoding.c, enumerator.c,
enumerator.c (enumerator_allocate), eval_jump.c, file.c, hash.c,
io.c, load.c, pack.c, proc.c, random.c, re.c, ruby.c, st.c,
string.c, thread.c, thread_pthread.c, time.c, util.c, variable.c,
vm.c, gc.c:
allocated memory objects by xmalloc (ruby_xmalloc) should be
freed by xfree (ruby_xfree).
* ext/curses/curses.c, ext/dbm/dbm.c, ext/digest/digest.c,
ext/gdbm/gdbm.c, ext/json/ext/parser/parser.c,
ext/json/ext/parser/unicode.c, ext/openssl/ossl_cipher.c,
ext/openssl/ossl_hmac.c, ext/openssl/ossl_pkey_ec.c,
ext/sdbm/init.c, ext/strscan/strscan.c, ext/zlib/zlib.c:
ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@17017 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2008-06-08 06:01:40 -04:00
|
|
|
xfree(next);
|
1998-01-16 07:19:22 -05:00
|
|
|
}
|
2001-10-21 09:22:54 -04:00
|
|
|
else {
|
|
|
|
trace = next;
|
|
|
|
}
|
1998-01-16 07:19:22 -05:00
|
|
|
}
|
2001-10-22 12:20:14 -04:00
|
|
|
var->trace = t.next;
|
1998-01-16 07:19:22 -05:00
|
|
|
}
|
|
|
|
|
2003-12-28 22:56:22 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* untrace_var(symbol [, cmd] ) -> array or nil
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 22:56:22 -05:00
|
|
|
* Removes tracing for the specified command on the given global
|
|
|
|
* variable and returns +nil+. If no command is specified,
|
|
|
|
* removes all tracing for that variable and returns an array
|
|
|
|
* containing the commands actually removed.
|
|
|
|
*/
|
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_f_untrace_var(int argc, VALUE *argv)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
VALUE var, cmd;
|
|
|
|
ID id;
|
|
|
|
struct global_entry *entry;
|
|
|
|
struct trace_var *trace;
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
st_data_t data;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
|
|
|
rb_scan_args(argc, argv, "11", &var, &cmd);
|
2011-07-26 12:05:35 -04:00
|
|
|
id = rb_check_id(&var);
|
|
|
|
if (!id) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error_str(var, "undefined global variable %"PRIsVALUE"", QUOTE(var));
|
2011-07-26 12:05:35 -04:00
|
|
|
}
|
2009-07-30 03:10:51 -04:00
|
|
|
if (!st_lookup(rb_global_tbl, (st_data_t)id, &data)) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error(id, "undefined global variable %"PRIsVALUE"", QUOTE_ID(id));
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
1999-01-19 23:59:39 -05:00
|
|
|
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
trace = (entry = (struct global_entry *)data)->var->trace;
|
1998-01-16 07:13:05 -05:00
|
|
|
if (NIL_P(cmd)) {
|
1999-01-19 23:59:39 -05:00
|
|
|
VALUE ary = rb_ary_new();
|
1998-01-16 07:13:05 -05:00
|
|
|
|
|
|
|
while (trace) {
|
|
|
|
struct trace_var *next = trace->next;
|
1999-01-19 23:59:39 -05:00
|
|
|
rb_ary_push(ary, (VALUE)trace->data);
|
1998-01-16 07:19:22 -05:00
|
|
|
trace->removed = 1;
|
1998-01-16 07:13:05 -05:00
|
|
|
trace = next;
|
|
|
|
}
|
|
|
|
|
2001-10-22 12:20:14 -04:00
|
|
|
if (!entry->var->block_trace) remove_trace(entry->var);
|
1998-01-16 07:13:05 -05:00
|
|
|
return ary;
|
|
|
|
}
|
|
|
|
else {
|
1998-01-16 07:19:22 -05:00
|
|
|
while (trace) {
|
2001-03-18 22:20:24 -05:00
|
|
|
if (trace->data == cmd) {
|
1998-01-16 07:19:22 -05:00
|
|
|
trace->removed = 1;
|
2001-10-22 12:20:14 -04:00
|
|
|
if (!entry->var->block_trace) remove_trace(entry->var);
|
1999-01-19 23:59:39 -05:00
|
|
|
return rb_ary_new3(1, cmd);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
1998-01-16 07:19:22 -05:00
|
|
|
trace = trace->next;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return Qnil;
|
|
|
|
}
|
2001-10-17 01:28:02 -04:00
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_gvar_get(struct global_entry *entry)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2001-10-22 12:20:14 -04:00
|
|
|
struct global_variable *var = entry->var;
|
|
|
|
return (*var->getter)(entry->id, var->data, var);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
struct trace_data {
|
|
|
|
struct trace_var *trace;
|
|
|
|
VALUE val;
|
|
|
|
};
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
|
1999-01-19 23:59:39 -05:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
trace_ev(struct trace_data *data)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
struct trace_var *trace = data->trace;
|
|
|
|
|
|
|
|
while (trace) {
|
|
|
|
(*trace->func)(trace->data, data->val);
|
|
|
|
trace = trace->next;
|
|
|
|
}
|
2012-04-13 20:36:26 -04:00
|
|
|
|
|
|
|
return Qnil;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
1999-01-19 23:59:39 -05:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
trace_en(struct global_variable *var)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2001-10-22 12:20:14 -04:00
|
|
|
var->block_trace = 0;
|
|
|
|
remove_trace(var);
|
1999-01-19 23:59:39 -05:00
|
|
|
return Qnil; /* not reached */
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_gvar_set(struct global_entry *entry, VALUE val)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
struct trace_data trace;
|
2001-10-22 12:20:14 -04:00
|
|
|
struct global_variable *var = entry->var;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2001-10-22 12:20:14 -04:00
|
|
|
(*var->setter)(val, entry->id, var->data, var);
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2001-10-22 12:20:14 -04:00
|
|
|
if (var->trace && !var->block_trace) {
|
|
|
|
var->block_trace = 1;
|
|
|
|
trace.trace = var->trace;
|
1998-01-16 07:13:05 -05:00
|
|
|
trace.val = val;
|
2001-10-22 12:20:14 -04:00
|
|
|
rb_ensure(trace_ev, (VALUE)&trace, trace_en, (VALUE)var);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_gv_set(const char *name, VALUE val)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
struct global_entry *entry;
|
|
|
|
|
|
|
|
entry = rb_global_entry(global_id(name));
|
|
|
|
return rb_gvar_set(entry, val);
|
|
|
|
}
|
|
|
|
|
1999-11-17 02:30:37 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_gv_get(const char *name)
|
1999-11-17 02:30:37 -05:00
|
|
|
{
|
|
|
|
struct global_entry *entry;
|
|
|
|
|
|
|
|
entry = rb_global_entry(global_id(name));
|
|
|
|
return rb_gvar_get(entry);
|
|
|
|
}
|
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_gvar_defined(struct global_entry *entry)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2001-10-22 12:20:14 -04:00
|
|
|
if (entry->var->getter == undef_getter) return Qfalse;
|
1999-01-19 23:59:39 -05:00
|
|
|
return Qtrue;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
1998-01-16 07:19:22 -05:00
|
|
|
static int
|
2012-03-30 18:40:54 -04:00
|
|
|
gvar_i(st_data_t k, st_data_t v, st_data_t a)
|
1998-01-16 07:19:22 -05:00
|
|
|
{
|
2012-03-30 18:40:54 -04:00
|
|
|
ID key = (ID)k;
|
|
|
|
VALUE ary = (VALUE)a;
|
2006-09-04 01:46:47 -04:00
|
|
|
rb_ary_push(ary, ID2SYM(key));
|
1998-01-16 07:19:22 -05:00
|
|
|
return ST_CONTINUE;
|
|
|
|
}
|
|
|
|
|
2003-12-28 22:56:22 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* global_variables -> array
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 22:56:22 -05:00
|
|
|
* Returns an array of the names of global variables.
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2008-03-08 20:04:46 -05:00
|
|
|
* global_variables.grep /std/ #=> [:$stdin, :$stdout, :$stderr]
|
2003-12-28 22:56:22 -05:00
|
|
|
*/
|
|
|
|
|
1998-01-16 07:19:22 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_f_global_variables(void)
|
1998-01-16 07:19:22 -05:00
|
|
|
{
|
1999-01-19 23:59:39 -05:00
|
|
|
VALUE ary = rb_ary_new();
|
* dir.c, dln.c, parse.y, re.c, ruby.c, sprintf.c, strftime.c,
string.c, util.c, variable.c: use strlcpy, memcpy and snprintf
instead of strcpy, strncpy and sprintf.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@22984 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2009-03-16 21:29:17 -04:00
|
|
|
char buf[2];
|
|
|
|
int i;
|
1998-01-16 07:19:22 -05:00
|
|
|
|
2004-09-29 01:15:33 -04:00
|
|
|
st_foreach_safe(rb_global_tbl, gvar_i, ary);
|
* dir.c, dln.c, parse.y, re.c, ruby.c, sprintf.c, strftime.c,
string.c, util.c, variable.c: use strlcpy, memcpy and snprintf
instead of strcpy, strncpy and sprintf.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@22984 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2009-03-16 21:29:17 -04:00
|
|
|
buf[0] = '$';
|
|
|
|
for (i = 1; i <= 9; ++i) {
|
|
|
|
buf[1] = (char)(i + '0');
|
|
|
|
rb_ary_push(ary, ID2SYM(rb_intern2(buf, 2)));
|
1998-01-16 07:19:22 -05:00
|
|
|
}
|
|
|
|
return ary;
|
|
|
|
}
|
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_alias_variable(ID name1, ID name2)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
struct global_entry *entry1, *entry2;
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
st_data_t data1;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2001-10-22 12:20:14 -04:00
|
|
|
entry2 = rb_global_entry(name2);
|
2009-07-30 03:10:51 -04:00
|
|
|
if (!st_lookup(rb_global_tbl, (st_data_t)name1, &data1)) {
|
2009-11-26 00:25:08 -05:00
|
|
|
entry1 = ALLOC(struct global_entry);
|
2001-10-22 12:20:14 -04:00
|
|
|
entry1->id = name1;
|
* st.h, st.c: Introduce new conventional typedef's, st_data_t,
st_compare_func_t, st_hash_func_t and st_each_func_t.
* st.h, st.c: Do explicit function declarations and do not rely on
implicit declarations. On such platforms as IA64, int argument
values are NOT automatically promoted to long (64bit) values, so
explicit declarations are mandatory for those functions that
take long values or pointers. This fixes miniruby's coredump on
FreeBSD/IA64.
* class.c, eval.c, gc.c, hash.c, marshal.c, parse.y, variable.c:
Add proper casts to avoid warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3303 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-01-06 10:55:43 -05:00
|
|
|
st_add_direct(rb_global_tbl, name1, (st_data_t)entry1);
|
2001-10-22 12:20:14 -04:00
|
|
|
}
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
else if ((entry1 = (struct global_entry *)data1)->var != entry2->var) {
|
2001-10-22 12:20:14 -04:00
|
|
|
struct global_variable *var = entry1->var;
|
|
|
|
if (var->block_trace) {
|
|
|
|
rb_raise(rb_eRuntimeError, "can't alias in tracer");
|
|
|
|
}
|
|
|
|
var->counter--;
|
|
|
|
if (var->counter == 0) {
|
|
|
|
struct trace_var *trace = var->trace;
|
|
|
|
while (trace) {
|
|
|
|
struct trace_var *next = trace->next;
|
* array.c, bignum.c, cont.c, dir.c, dln.c, encoding.c, enumerator.c,
enumerator.c (enumerator_allocate), eval_jump.c, file.c, hash.c,
io.c, load.c, pack.c, proc.c, random.c, re.c, ruby.c, st.c,
string.c, thread.c, thread_pthread.c, time.c, util.c, variable.c,
vm.c, gc.c:
allocated memory objects by xmalloc (ruby_xmalloc) should be
freed by xfree (ruby_xfree).
* ext/curses/curses.c, ext/dbm/dbm.c, ext/digest/digest.c,
ext/gdbm/gdbm.c, ext/json/ext/parser/parser.c,
ext/json/ext/parser/unicode.c, ext/openssl/ossl_cipher.c,
ext/openssl/ossl_hmac.c, ext/openssl/ossl_pkey_ec.c,
ext/sdbm/init.c, ext/strscan/strscan.c, ext/zlib/zlib.c:
ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@17017 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2008-06-08 06:01:40 -04:00
|
|
|
xfree(trace);
|
2001-10-22 12:20:14 -04:00
|
|
|
trace = next;
|
|
|
|
}
|
* array.c, bignum.c, cont.c, dir.c, dln.c, encoding.c, enumerator.c,
enumerator.c (enumerator_allocate), eval_jump.c, file.c, hash.c,
io.c, load.c, pack.c, proc.c, random.c, re.c, ruby.c, st.c,
string.c, thread.c, thread_pthread.c, time.c, util.c, variable.c,
vm.c, gc.c:
allocated memory objects by xmalloc (ruby_xmalloc) should be
freed by xfree (ruby_xfree).
* ext/curses/curses.c, ext/dbm/dbm.c, ext/digest/digest.c,
ext/gdbm/gdbm.c, ext/json/ext/parser/parser.c,
ext/json/ext/parser/unicode.c, ext/openssl/ossl_cipher.c,
ext/openssl/ossl_hmac.c, ext/openssl/ossl_pkey_ec.c,
ext/sdbm/init.c, ext/strscan/strscan.c, ext/zlib/zlib.c:
ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@17017 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2008-06-08 06:01:40 -04:00
|
|
|
xfree(var);
|
2001-10-22 12:20:14 -04:00
|
|
|
}
|
2001-10-17 01:28:02 -04:00
|
|
|
}
|
2001-10-22 12:20:14 -04:00
|
|
|
else {
|
|
|
|
return;
|
2001-10-17 01:28:02 -04:00
|
|
|
}
|
2001-10-22 12:20:14 -04:00
|
|
|
entry2->var->counter++;
|
|
|
|
entry1->var = entry2->var;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
1999-01-19 23:59:39 -05:00
|
|
|
static int special_generic_ivar = 0;
|
|
|
|
static st_table *generic_iv_tbl;
|
|
|
|
|
2000-01-04 23:41:21 -05:00
|
|
|
st_table*
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_generic_ivar_table(VALUE obj)
|
2000-01-04 23:41:21 -05:00
|
|
|
{
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
st_data_t tbl;
|
2000-01-04 23:41:21 -05:00
|
|
|
|
2003-10-09 13:45:53 -04:00
|
|
|
if (!FL_TEST(obj, FL_EXIVAR)) return 0;
|
2000-01-04 23:41:21 -05:00
|
|
|
if (!generic_iv_tbl) return 0;
|
2009-07-30 03:10:51 -04:00
|
|
|
if (!st_lookup(generic_iv_tbl, (st_data_t)obj, &tbl)) return 0;
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
return (st_table *)tbl;
|
2000-01-04 23:41:21 -05:00
|
|
|
}
|
|
|
|
|
1999-01-19 23:59:39 -05:00
|
|
|
static VALUE
|
2013-05-02 04:30:56 -04:00
|
|
|
generic_ivar_get(VALUE obj, ID id, VALUE undef)
|
1999-01-19 23:59:39 -05:00
|
|
|
{
|
2009-07-30 03:10:51 -04:00
|
|
|
st_data_t tbl, val;
|
1999-01-19 23:59:39 -05:00
|
|
|
|
2002-12-19 04:20:20 -05:00
|
|
|
if (generic_iv_tbl) {
|
2009-07-30 03:10:51 -04:00
|
|
|
if (st_lookup(generic_iv_tbl, (st_data_t)obj, &tbl)) {
|
|
|
|
if (st_lookup((st_table *)tbl, (st_data_t)id, &val)) {
|
|
|
|
return (VALUE)val;
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
}
|
2002-12-19 04:20:20 -05:00
|
|
|
}
|
1999-01-19 23:59:39 -05:00
|
|
|
}
|
2013-05-02 04:30:56 -04:00
|
|
|
return undef;
|
1999-01-19 23:59:39 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
generic_ivar_set(VALUE obj, ID id, VALUE val)
|
1999-01-19 23:59:39 -05:00
|
|
|
{
|
|
|
|
st_table *tbl;
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
st_data_t data;
|
1999-01-19 23:59:39 -05:00
|
|
|
|
|
|
|
if (rb_special_const_p(obj)) {
|
2007-12-18 03:28:39 -05:00
|
|
|
if (rb_obj_frozen_p(obj)) rb_error_frozen("object");
|
1999-01-19 23:59:39 -05:00
|
|
|
special_generic_ivar = 1;
|
|
|
|
}
|
|
|
|
if (!generic_iv_tbl) {
|
|
|
|
generic_iv_tbl = st_init_numtable();
|
|
|
|
}
|
2009-07-30 03:10:51 -04:00
|
|
|
if (!st_lookup(generic_iv_tbl, (st_data_t)obj, &data)) {
|
1999-01-19 23:59:39 -05:00
|
|
|
FL_SET(obj, FL_EXIVAR);
|
|
|
|
tbl = st_init_numtable();
|
2009-07-30 03:10:51 -04:00
|
|
|
st_add_direct(generic_iv_tbl, (st_data_t)obj, (st_data_t)tbl);
|
|
|
|
st_add_direct(tbl, (st_data_t)id, (st_data_t)val);
|
* gc.c: support RGENGC. [ruby-trunk - Feature #8339]
See this ticet about RGENGC.
* gc.c: Add several flags:
* RGENGC_DEBUG: if >0, then prints debug information.
* RGENGC_CHECK_MODE: if >0, add assertions.
* RGENGC_PROFILE: if >0, add profiling features.
check GC.stat and GC::Profiler.
* include/ruby/ruby.h: disable RGENGC by default (USE_RGENGC == 0).
* array.c: add write barriers for T_ARRAY and generate sunny objects.
* include/ruby/ruby.h (RARRAY_PTR_USE): added. Use this macro if
you want to access raw pointers. If you modify the contents which
pointer pointed, then you need to care write barrier.
* bignum.c, marshal.c, random.c: generate T_BIGNUM sunny objects.
* complex.c, include/ruby/ruby.h: add write barriers for T_COMPLEX
and generate sunny objects.
* rational.c (nurat_s_new_internal), include/ruby/ruby.h: add write
barriers for T_RATIONAL and generate sunny objects.
* internal.h: add write barriers for RBasic::klass.
* numeric.c (rb_float_new_in_heap): generate sunny T_FLOAT objects.
* object.c (rb_class_allocate_instance), range.c:
generate sunny T_OBJECT objects.
* string.c: add write barriers for T_STRING and generate sunny objects.
* variable.c: add write barriers for ivars.
* vm_insnhelper.c (vm_setivar): ditto.
* include/ruby/ruby.h, debug.c: use two flags
FL_WB_PROTECTED and FL_OLDGEN.
* node.h (NODE_FL_CREF_PUSHED_BY_EVAL, NODE_FL_CREF_OMOD_SHARED):
move flag bits.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@40703 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-05-13 14:07:47 -04:00
|
|
|
if (FL_ABLE(obj)) OBJ_WRITTEN(obj, Qundef, val);
|
1999-01-19 23:59:39 -05:00
|
|
|
return;
|
|
|
|
}
|
2009-07-30 03:10:51 -04:00
|
|
|
st_insert((st_table *)data, (st_data_t)id, (st_data_t)val);
|
* gc.c: support RGENGC. [ruby-trunk - Feature #8339]
See this ticet about RGENGC.
* gc.c: Add several flags:
* RGENGC_DEBUG: if >0, then prints debug information.
* RGENGC_CHECK_MODE: if >0, add assertions.
* RGENGC_PROFILE: if >0, add profiling features.
check GC.stat and GC::Profiler.
* include/ruby/ruby.h: disable RGENGC by default (USE_RGENGC == 0).
* array.c: add write barriers for T_ARRAY and generate sunny objects.
* include/ruby/ruby.h (RARRAY_PTR_USE): added. Use this macro if
you want to access raw pointers. If you modify the contents which
pointer pointed, then you need to care write barrier.
* bignum.c, marshal.c, random.c: generate T_BIGNUM sunny objects.
* complex.c, include/ruby/ruby.h: add write barriers for T_COMPLEX
and generate sunny objects.
* rational.c (nurat_s_new_internal), include/ruby/ruby.h: add write
barriers for T_RATIONAL and generate sunny objects.
* internal.h: add write barriers for RBasic::klass.
* numeric.c (rb_float_new_in_heap): generate sunny T_FLOAT objects.
* object.c (rb_class_allocate_instance), range.c:
generate sunny T_OBJECT objects.
* string.c: add write barriers for T_STRING and generate sunny objects.
* variable.c: add write barriers for ivars.
* vm_insnhelper.c (vm_setivar): ditto.
* include/ruby/ruby.h, debug.c: use two flags
FL_WB_PROTECTED and FL_OLDGEN.
* node.h (NODE_FL_CREF_PUSHED_BY_EVAL, NODE_FL_CREF_OMOD_SHARED):
move flag bits.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@40703 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-05-13 14:07:47 -04:00
|
|
|
if (FL_ABLE(obj)) OBJ_WRITTEN(obj, data, val);
|
1999-01-19 23:59:39 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
generic_ivar_defined(VALUE obj, ID id)
|
1999-01-19 23:59:39 -05:00
|
|
|
{
|
|
|
|
st_table *tbl;
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
st_data_t data;
|
1999-01-19 23:59:39 -05:00
|
|
|
|
|
|
|
if (!generic_iv_tbl) return Qfalse;
|
2009-07-30 03:10:51 -04:00
|
|
|
if (!st_lookup(generic_iv_tbl, (st_data_t)obj, &data)) return Qfalse;
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
tbl = (st_table *)data;
|
2009-07-30 03:10:51 -04:00
|
|
|
if (st_lookup(tbl, (st_data_t)id, &data)) {
|
1999-01-19 23:59:39 -05:00
|
|
|
return Qtrue;
|
|
|
|
}
|
|
|
|
return Qfalse;
|
|
|
|
}
|
|
|
|
|
2002-04-10 04:45:26 -04:00
|
|
|
static int
|
2009-07-30 03:10:51 -04:00
|
|
|
generic_ivar_remove(VALUE obj, ID id, st_data_t *valp)
|
1999-01-19 23:59:39 -05:00
|
|
|
{
|
|
|
|
st_table *tbl;
|
* compile.c (iseq_build_body), error.c (set_syserr, get_syserr),
(syserr_initialize), gc.c (define_final, rb_gc_copy_finalizer),
(run_final), hash.c (rb_hash_aref, rb_hash_lookup2),
(rb_hash_fetch_m, rb_hash_clear, rb_hash_aset, eql_i),
iseq.c (iseq_load, iseq_data_to_ary), marshal.c (r_symlink),
thread.c (rb_thread_local_aref),
variable.c (generic_ivar_remove, ivar_get, rb_const_get_0),
(rb_cvar_get), vm.c (rb_vm_check_redefinition_opt_method),
vm_insnhelper.c (vm_get_ev_const), vm_method.c (remove_method),
ext/iconv/iconv.c (map_charset): use st_data_t.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@29462 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2010-10-12 10:47:23 -04:00
|
|
|
st_data_t data, key = (st_data_t)id;
|
2002-04-10 04:45:26 -04:00
|
|
|
int status;
|
1999-01-19 23:59:39 -05:00
|
|
|
|
2002-04-10 04:45:26 -04:00
|
|
|
if (!generic_iv_tbl) return 0;
|
2009-07-30 03:10:51 -04:00
|
|
|
if (!st_lookup(generic_iv_tbl, (st_data_t)obj, &data)) return 0;
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
tbl = (st_table *)data;
|
* compile.c (iseq_build_body), error.c (set_syserr, get_syserr),
(syserr_initialize), gc.c (define_final, rb_gc_copy_finalizer),
(run_final), hash.c (rb_hash_aref, rb_hash_lookup2),
(rb_hash_fetch_m, rb_hash_clear, rb_hash_aset, eql_i),
iseq.c (iseq_load, iseq_data_to_ary), marshal.c (r_symlink),
thread.c (rb_thread_local_aref),
variable.c (generic_ivar_remove, ivar_get, rb_const_get_0),
(rb_cvar_get), vm.c (rb_vm_check_redefinition_opt_method),
vm_insnhelper.c (vm_get_ev_const), vm_method.c (remove_method),
ext/iconv/iconv.c (map_charset): use st_data_t.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@29462 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2010-10-12 10:47:23 -04:00
|
|
|
status = st_delete(tbl, &key, valp);
|
1999-01-19 23:59:39 -05:00
|
|
|
if (tbl->num_entries == 0) {
|
* compile.c (iseq_build_body), error.c (set_syserr, get_syserr),
(syserr_initialize), gc.c (define_final, rb_gc_copy_finalizer),
(run_final), hash.c (rb_hash_aref, rb_hash_lookup2),
(rb_hash_fetch_m, rb_hash_clear, rb_hash_aset, eql_i),
iseq.c (iseq_load, iseq_data_to_ary), marshal.c (r_symlink),
thread.c (rb_thread_local_aref),
variable.c (generic_ivar_remove, ivar_get, rb_const_get_0),
(rb_cvar_get), vm.c (rb_vm_check_redefinition_opt_method),
vm_insnhelper.c (vm_get_ev_const), vm_method.c (remove_method),
ext/iconv/iconv.c (map_charset): use st_data_t.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@29462 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2010-10-12 10:47:23 -04:00
|
|
|
key = (st_data_t)obj;
|
|
|
|
st_delete(generic_iv_tbl, &key, &data);
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
st_free_table((st_table *)data);
|
1999-01-19 23:59:39 -05:00
|
|
|
}
|
2002-04-10 04:45:26 -04:00
|
|
|
return status;
|
1999-01-19 23:59:39 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_mark_generic_ivar(VALUE obj)
|
1999-01-19 23:59:39 -05:00
|
|
|
{
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
st_data_t tbl;
|
1999-01-19 23:59:39 -05:00
|
|
|
|
1999-08-13 01:45:20 -04:00
|
|
|
if (!generic_iv_tbl) return;
|
2009-07-30 03:10:51 -04:00
|
|
|
if (st_lookup(generic_iv_tbl, (st_data_t)obj, &tbl)) {
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
rb_mark_tbl((st_table *)tbl);
|
1999-01-19 23:59:39 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-08-13 01:45:20 -04:00
|
|
|
static int
|
2012-03-30 18:40:54 -04:00
|
|
|
givar_mark_i(st_data_t k, st_data_t v, st_data_t a)
|
1999-08-13 01:45:20 -04:00
|
|
|
{
|
2012-03-30 18:40:54 -04:00
|
|
|
VALUE value = (VALUE)v;
|
1999-08-13 01:45:20 -04:00
|
|
|
rb_gc_mark(value);
|
|
|
|
return ST_CONTINUE;
|
|
|
|
}
|
|
|
|
|
1999-01-19 23:59:39 -05:00
|
|
|
static int
|
2012-03-30 18:40:54 -04:00
|
|
|
givar_i(st_data_t k, st_data_t v, st_data_t a)
|
1999-01-19 23:59:39 -05:00
|
|
|
{
|
2012-03-30 18:40:54 -04:00
|
|
|
VALUE obj = (VALUE)k;
|
|
|
|
st_table *tbl = (st_table *)v;
|
1999-01-19 23:59:39 -05:00
|
|
|
if (rb_special_const_p(obj)) {
|
2004-09-29 01:15:33 -04:00
|
|
|
st_foreach_safe(tbl, givar_mark_i, 0);
|
1999-01-19 23:59:39 -05:00
|
|
|
}
|
|
|
|
return ST_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_mark_generic_ivar_tbl(void)
|
1999-01-19 23:59:39 -05:00
|
|
|
{
|
|
|
|
if (!generic_iv_tbl) return;
|
1999-08-13 01:45:20 -04:00
|
|
|
if (special_generic_ivar == 0) return;
|
2004-09-29 01:15:33 -04:00
|
|
|
st_foreach_safe(generic_iv_tbl, givar_i, 0);
|
1999-01-19 23:59:39 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_free_generic_ivar(VALUE obj)
|
1999-01-19 23:59:39 -05:00
|
|
|
{
|
2009-07-20 23:38:17 -04:00
|
|
|
st_data_t key = (st_data_t)obj, tbl;
|
1999-01-19 23:59:39 -05:00
|
|
|
|
2004-10-30 02:56:18 -04:00
|
|
|
if (!generic_iv_tbl) return;
|
2009-07-20 23:38:17 -04:00
|
|
|
if (st_delete(generic_iv_tbl, &key, &tbl))
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
st_free_table((st_table *)tbl);
|
1999-01-19 23:59:39 -05:00
|
|
|
}
|
|
|
|
|
2010-08-14 02:33:06 -04:00
|
|
|
RUBY_FUNC_EXPORTED size_t
|
2009-06-22 10:25:04 -04:00
|
|
|
rb_generic_ivar_memsize(VALUE obj)
|
2009-06-16 18:36:27 -04:00
|
|
|
{
|
|
|
|
st_data_t tbl;
|
2009-07-20 23:38:17 -04:00
|
|
|
if (st_lookup(generic_iv_tbl, (st_data_t)obj, &tbl))
|
|
|
|
return st_memsize((st_table *)tbl);
|
2009-06-16 18:36:27 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
1999-08-13 01:45:20 -04:00
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_copy_generic_ivar(VALUE clone, VALUE obj)
|
1999-08-13 01:45:20 -04:00
|
|
|
{
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
st_data_t data;
|
1999-08-13 01:45:20 -04:00
|
|
|
|
|
|
|
if (!generic_iv_tbl) return;
|
* configure.in: check struct timespec, clock_gettime, utimensat,
struct stat.st_atim,
struct stat.st_atimespec,
struct stat.st_atimensec,
struct stat.st_mtim,
struct stat.st_mtimespec,
struct stat.st_mtimensec,
struct stat.st_ctim,
struct stat.st_ctimespec,
struct stat.st_ctimensec.
* include/ruby/missing.h: provide struct timespec if not available.
* time.c: support nanosecond-resolution using struct timespec.
* include/ruby/intern.h: provide rb_time_nano_new.
* file.c (utime_internal): use utimensat if available.
(rb_file_s_utime): refactored.
(rb_f_test): use stat_atime, stat_mtime, stat_ctime.
(rb_stat_cmp): check tv_nsec.
(stat_atimespec): new function.
(stat_atime): ditto.
(stat_mtimespec): ditto.
(stat_mtime): ditto.
(stat_ctimespec): ditto.
(stat_ctime): ditto.
(rb_stat_atime): use stat_atime.
(rb_file_s_atime): ditto.
(rb_file_atime): ditto.
(rb_stat_mtime): use stat_mtime.
(rb_file_s_mtime): ditto.
(rb_file_mtime): ditto.
(rb_file_ctime): use stat_ctime.
(rb_file_s_ctime): ditto.
(rb_stat_ctime): ditto.
* variable.c (rb_copy_generic_ivar): clear clone's instance variables
if obj has no instance variable.
* marshal.c (w_object): dump instance variables of generated string
for TYPE_USERDEF, even if original object has instance variables.
* lib/time.rb (Time#xmlschema): use nsec instead of usec.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@13968 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-11-19 04:09:38 -05:00
|
|
|
if (!FL_TEST(obj, FL_EXIVAR)) {
|
2009-07-20 23:38:17 -04:00
|
|
|
clear:
|
* configure.in: check struct timespec, clock_gettime, utimensat,
struct stat.st_atim,
struct stat.st_atimespec,
struct stat.st_atimensec,
struct stat.st_mtim,
struct stat.st_mtimespec,
struct stat.st_mtimensec,
struct stat.st_ctim,
struct stat.st_ctimespec,
struct stat.st_ctimensec.
* include/ruby/missing.h: provide struct timespec if not available.
* time.c: support nanosecond-resolution using struct timespec.
* include/ruby/intern.h: provide rb_time_nano_new.
* file.c (utime_internal): use utimensat if available.
(rb_file_s_utime): refactored.
(rb_f_test): use stat_atime, stat_mtime, stat_ctime.
(rb_stat_cmp): check tv_nsec.
(stat_atimespec): new function.
(stat_atime): ditto.
(stat_mtimespec): ditto.
(stat_mtime): ditto.
(stat_ctimespec): ditto.
(stat_ctime): ditto.
(rb_stat_atime): use stat_atime.
(rb_file_s_atime): ditto.
(rb_file_atime): ditto.
(rb_stat_mtime): use stat_mtime.
(rb_file_s_mtime): ditto.
(rb_file_mtime): ditto.
(rb_file_ctime): use stat_ctime.
(rb_file_s_ctime): ditto.
(rb_stat_ctime): ditto.
* variable.c (rb_copy_generic_ivar): clear clone's instance variables
if obj has no instance variable.
* marshal.c (w_object): dump instance variables of generated string
for TYPE_USERDEF, even if original object has instance variables.
* lib/time.rb (Time#xmlschema): use nsec instead of usec.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@13968 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-11-19 04:09:38 -05:00
|
|
|
if (FL_TEST(clone, FL_EXIVAR)) {
|
|
|
|
rb_free_generic_ivar(clone);
|
|
|
|
FL_UNSET(clone, FL_EXIVAR);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2009-07-30 03:10:51 -04:00
|
|
|
if (st_lookup(generic_iv_tbl, (st_data_t)obj, &data)) {
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
st_table *tbl = (st_table *)data;
|
2002-09-03 01:20:14 -04:00
|
|
|
|
* configure.in: check struct timespec, clock_gettime, utimensat,
struct stat.st_atim,
struct stat.st_atimespec,
struct stat.st_atimensec,
struct stat.st_mtim,
struct stat.st_mtimespec,
struct stat.st_mtimensec,
struct stat.st_ctim,
struct stat.st_ctimespec,
struct stat.st_ctimensec.
* include/ruby/missing.h: provide struct timespec if not available.
* time.c: support nanosecond-resolution using struct timespec.
* include/ruby/intern.h: provide rb_time_nano_new.
* file.c (utime_internal): use utimensat if available.
(rb_file_s_utime): refactored.
(rb_f_test): use stat_atime, stat_mtime, stat_ctime.
(rb_stat_cmp): check tv_nsec.
(stat_atimespec): new function.
(stat_atime): ditto.
(stat_mtimespec): ditto.
(stat_mtime): ditto.
(stat_ctimespec): ditto.
(stat_ctime): ditto.
(rb_stat_atime): use stat_atime.
(rb_file_s_atime): ditto.
(rb_file_atime): ditto.
(rb_stat_mtime): use stat_mtime.
(rb_file_s_mtime): ditto.
(rb_file_mtime): ditto.
(rb_file_ctime): use stat_ctime.
(rb_file_s_ctime): ditto.
(rb_stat_ctime): ditto.
* variable.c (rb_copy_generic_ivar): clear clone's instance variables
if obj has no instance variable.
* marshal.c (w_object): dump instance variables of generated string
for TYPE_USERDEF, even if original object has instance variables.
* lib/time.rb (Time#xmlschema): use nsec instead of usec.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@13968 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-11-19 04:09:38 -05:00
|
|
|
if (tbl->num_entries == 0)
|
|
|
|
goto clear;
|
|
|
|
|
2009-07-30 03:10:51 -04:00
|
|
|
if (st_lookup(generic_iv_tbl, (st_data_t)clone, &data)) {
|
* variable.c (rb_global_entry, rb_f_untrace_var, rb_alias_variable,
rb_generic_ivar_table, generic_ivar_get, generic_ivar_set,
generic_ivar_defined, generic_ivar_remove, rb_mark_generic_ivar,
rb_free_generic_ivar, rb_copy_generic_ivar,
rb_obj_instance_variables): suppress warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12563 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-06-17 12:12:32 -04:00
|
|
|
st_free_table((st_table *)data);
|
2009-07-30 03:10:51 -04:00
|
|
|
st_insert(generic_iv_tbl, (st_data_t)clone, (st_data_t)st_copy(tbl));
|
2002-09-03 01:20:14 -04:00
|
|
|
}
|
|
|
|
else {
|
2009-07-30 03:10:51 -04:00
|
|
|
st_add_direct(generic_iv_tbl, (st_data_t)clone, (st_data_t)st_copy(tbl));
|
2004-05-14 12:39:15 -04:00
|
|
|
FL_SET(clone, FL_EXIVAR);
|
2002-09-03 01:20:14 -04:00
|
|
|
}
|
1999-08-13 01:45:20 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-02-18 09:30:17 -05:00
|
|
|
static VALUE
|
2013-05-02 04:30:56 -04:00
|
|
|
rb_ivar_lookup(VALUE obj, ID id, VALUE undef)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2008-02-13 06:52:46 -05:00
|
|
|
VALUE val, *ptr;
|
|
|
|
struct st_table *iv_index_tbl;
|
|
|
|
long len;
|
2007-09-28 02:21:46 -04:00
|
|
|
st_data_t index;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2012-07-28 13:04:58 -04:00
|
|
|
if (SPECIAL_CONST_P(obj)) goto generic;
|
|
|
|
switch (BUILTIN_TYPE(obj)) {
|
1998-01-16 07:13:05 -05:00
|
|
|
case T_OBJECT:
|
2008-02-25 11:18:18 -05:00
|
|
|
len = ROBJECT_NUMIV(obj);
|
|
|
|
ptr = ROBJECT_IVPTR(obj);
|
2008-02-13 06:52:46 -05:00
|
|
|
iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);
|
2009-02-14 21:45:31 -05:00
|
|
|
if (!iv_index_tbl) break;
|
2009-07-30 03:10:51 -04:00
|
|
|
if (!st_lookup(iv_index_tbl, (st_data_t)id, &index)) break;
|
* array.c, bignum.c, dln.c, error.c, gc.c, io.c, marshal.c,
numeric.c, pack.c, strftime.c, string.c, thread.c, transcode.c,
transcode_data.h, util.c, variable.c, vm_dump.c,
include/ruby/encoding.h, missing/crypt.c, missing/vsnprintf.c:
suppress VC type warnings. [ruby-core:22726]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@22914 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2009-03-12 05:16:15 -04:00
|
|
|
if (len <= (long)index) break;
|
2008-02-13 06:52:46 -05:00
|
|
|
val = ptr[index];
|
2007-09-28 02:21:46 -04:00
|
|
|
if (val != Qundef)
|
|
|
|
return val;
|
|
|
|
break;
|
1998-01-16 07:13:05 -05:00
|
|
|
case T_CLASS:
|
|
|
|
case T_MODULE:
|
* compile.c (iseq_build_body), error.c (set_syserr, get_syserr),
(syserr_initialize), gc.c (define_final, rb_gc_copy_finalizer),
(run_final), hash.c (rb_hash_aref, rb_hash_lookup2),
(rb_hash_fetch_m, rb_hash_clear, rb_hash_aset, eql_i),
iseq.c (iseq_load, iseq_data_to_ary), marshal.c (r_symlink),
thread.c (rb_thread_local_aref),
variable.c (generic_ivar_remove, ivar_get, rb_const_get_0),
(rb_cvar_get), vm.c (rb_vm_check_redefinition_opt_method),
vm_insnhelper.c (vm_get_ev_const), vm_method.c (remove_method),
ext/iconv/iconv.c (map_charset): use st_data_t.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@29462 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2010-10-12 10:47:23 -04:00
|
|
|
if (RCLASS_IV_TBL(obj) && st_lookup(RCLASS_IV_TBL(obj), (st_data_t)id, &index))
|
|
|
|
return (VALUE)index;
|
1999-01-19 23:59:39 -05:00
|
|
|
break;
|
1998-01-16 07:13:05 -05:00
|
|
|
default:
|
2012-07-28 13:04:58 -04:00
|
|
|
generic:
|
1999-01-19 23:59:39 -05:00
|
|
|
if (FL_TEST(obj, FL_EXIVAR) || rb_special_const_p(obj))
|
2013-05-02 04:30:56 -04:00
|
|
|
return generic_ivar_get(obj, id, undef);
|
1998-01-16 07:13:05 -05:00
|
|
|
break;
|
|
|
|
}
|
2013-05-02 04:30:56 -04:00
|
|
|
return undef;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2003-02-18 09:30:17 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_ivar_get(VALUE obj, ID id)
|
2003-02-18 09:30:17 -05:00
|
|
|
{
|
2013-05-02 04:30:56 -04:00
|
|
|
VALUE iv = rb_ivar_lookup(obj, id, Qundef);
|
|
|
|
|
|
|
|
if (iv == Qundef) {
|
|
|
|
rb_warning("instance variable %"PRIsVALUE" not initialized", QUOTE_ID(id));
|
|
|
|
iv = Qnil;
|
|
|
|
}
|
|
|
|
return iv;
|
2003-02-18 09:30:17 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_attr_get(VALUE obj, ID id)
|
2003-02-18 09:30:17 -05:00
|
|
|
{
|
2013-05-02 04:30:56 -04:00
|
|
|
return rb_ivar_lookup(obj, id, Qnil);
|
2003-02-18 09:30:17 -05:00
|
|
|
}
|
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_ivar_set(VALUE obj, ID id, VALUE val)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2008-02-13 06:52:46 -05:00
|
|
|
struct st_table *iv_index_tbl;
|
2007-09-28 02:21:46 -04:00
|
|
|
st_data_t index;
|
|
|
|
long i, len;
|
|
|
|
int ivar_extended;
|
|
|
|
|
* array.c, gc.c, hash.c, object.c, string.c, struct.c,
transcode.c, variable.c, vm.c, vm_insnhelper.c, vm_method.c:
replace calls to rb_error_frozen() with rb_check_frozen(). a
patch from Run Paint Run Run at [ruby-core:32014]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@29583 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2010-10-24 04:14:05 -04:00
|
|
|
rb_check_frozen(obj);
|
2012-07-28 13:04:58 -04:00
|
|
|
if (SPECIAL_CONST_P(obj)) goto generic;
|
|
|
|
switch (BUILTIN_TYPE(obj)) {
|
1998-01-16 07:13:05 -05:00
|
|
|
case T_OBJECT:
|
2008-02-13 06:52:46 -05:00
|
|
|
iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);
|
|
|
|
if (!iv_index_tbl) {
|
|
|
|
VALUE klass = rb_obj_class(obj);
|
|
|
|
iv_index_tbl = RCLASS_IV_INDEX_TBL(klass);
|
|
|
|
if (!iv_index_tbl) {
|
|
|
|
iv_index_tbl = RCLASS_IV_INDEX_TBL(klass) = st_init_numtable();
|
|
|
|
}
|
|
|
|
}
|
2007-09-28 02:21:46 -04:00
|
|
|
ivar_extended = 0;
|
2009-07-30 03:10:51 -04:00
|
|
|
if (!st_lookup(iv_index_tbl, (st_data_t)id, &index)) {
|
2008-02-13 06:52:46 -05:00
|
|
|
index = iv_index_tbl->num_entries;
|
2009-07-30 03:10:51 -04:00
|
|
|
st_add_direct(iv_index_tbl, (st_data_t)id, index);
|
2007-09-28 02:21:46 -04:00
|
|
|
ivar_extended = 1;
|
|
|
|
}
|
2008-02-25 11:18:18 -05:00
|
|
|
len = ROBJECT_NUMIV(obj);
|
* array.c, bignum.c, dln.c, error.c, gc.c, io.c, marshal.c,
numeric.c, pack.c, strftime.c, string.c, thread.c, transcode.c,
transcode_data.h, util.c, variable.c, vm_dump.c,
include/ruby/encoding.h, missing/crypt.c, missing/vsnprintf.c:
suppress VC type warnings. [ruby-core:22726]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@22914 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2009-03-12 05:16:15 -04:00
|
|
|
if (len <= (long)index) {
|
2008-02-25 11:18:18 -05:00
|
|
|
VALUE *ptr = ROBJECT_IVPTR(obj);
|
2007-09-28 02:21:46 -04:00
|
|
|
if (index < ROBJECT_EMBED_LEN_MAX) {
|
|
|
|
RBASIC(obj)->flags |= ROBJECT_EMBED;
|
|
|
|
ptr = ROBJECT(obj)->as.ary;
|
|
|
|
for (i = 0; i < ROBJECT_EMBED_LEN_MAX; i++) {
|
|
|
|
ptr[i] = Qundef;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
VALUE *newptr;
|
|
|
|
long newsize = (index+1) + (index+1)/4; /* (index+1)*1.25 */
|
|
|
|
if (!ivar_extended &&
|
* array.c, bignum.c, dln.c, error.c, gc.c, io.c, marshal.c,
numeric.c, pack.c, strftime.c, string.c, thread.c, transcode.c,
transcode_data.h, util.c, variable.c, vm_dump.c,
include/ruby/encoding.h, missing/crypt.c, missing/vsnprintf.c:
suppress VC type warnings. [ruby-core:22726]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@22914 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2009-03-12 05:16:15 -04:00
|
|
|
iv_index_tbl->num_entries < (st_index_t)newsize) {
|
2008-02-13 06:52:46 -05:00
|
|
|
newsize = iv_index_tbl->num_entries;
|
2007-09-28 02:21:46 -04:00
|
|
|
}
|
|
|
|
if (RBASIC(obj)->flags & ROBJECT_EMBED) {
|
|
|
|
newptr = ALLOC_N(VALUE, newsize);
|
|
|
|
MEMCPY(newptr, ptr, VALUE, len);
|
|
|
|
RBASIC(obj)->flags &= ~ROBJECT_EMBED;
|
2008-02-25 11:18:18 -05:00
|
|
|
ROBJECT(obj)->as.heap.ivptr = newptr;
|
2007-09-28 02:21:46 -04:00
|
|
|
}
|
|
|
|
else {
|
2008-02-25 11:18:18 -05:00
|
|
|
REALLOC_N(ROBJECT(obj)->as.heap.ivptr, VALUE, newsize);
|
|
|
|
newptr = ROBJECT(obj)->as.heap.ivptr;
|
2007-09-28 02:21:46 -04:00
|
|
|
}
|
|
|
|
for (; len < newsize; len++)
|
|
|
|
newptr[len] = Qundef;
|
2008-02-25 11:18:18 -05:00
|
|
|
ROBJECT(obj)->as.heap.numiv = newsize;
|
2008-02-13 06:52:46 -05:00
|
|
|
ROBJECT(obj)->as.heap.iv_index_tbl = iv_index_tbl;
|
2007-09-28 02:21:46 -04:00
|
|
|
}
|
|
|
|
}
|
* gc.c: support RGENGC. [ruby-trunk - Feature #8339]
See this ticet about RGENGC.
* gc.c: Add several flags:
* RGENGC_DEBUG: if >0, then prints debug information.
* RGENGC_CHECK_MODE: if >0, add assertions.
* RGENGC_PROFILE: if >0, add profiling features.
check GC.stat and GC::Profiler.
* include/ruby/ruby.h: disable RGENGC by default (USE_RGENGC == 0).
* array.c: add write barriers for T_ARRAY and generate sunny objects.
* include/ruby/ruby.h (RARRAY_PTR_USE): added. Use this macro if
you want to access raw pointers. If you modify the contents which
pointer pointed, then you need to care write barrier.
* bignum.c, marshal.c, random.c: generate T_BIGNUM sunny objects.
* complex.c, include/ruby/ruby.h: add write barriers for T_COMPLEX
and generate sunny objects.
* rational.c (nurat_s_new_internal), include/ruby/ruby.h: add write
barriers for T_RATIONAL and generate sunny objects.
* internal.h: add write barriers for RBasic::klass.
* numeric.c (rb_float_new_in_heap): generate sunny T_FLOAT objects.
* object.c (rb_class_allocate_instance), range.c:
generate sunny T_OBJECT objects.
* string.c: add write barriers for T_STRING and generate sunny objects.
* variable.c: add write barriers for ivars.
* vm_insnhelper.c (vm_setivar): ditto.
* include/ruby/ruby.h, debug.c: use two flags
FL_WB_PROTECTED and FL_OLDGEN.
* node.h (NODE_FL_CREF_PUSHED_BY_EVAL, NODE_FL_CREF_OMOD_SHARED):
move flag bits.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@40703 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-05-13 14:07:47 -04:00
|
|
|
OBJ_WRITE(obj, &ROBJECT_IVPTR(obj)[index], val);
|
2007-09-28 02:21:46 -04:00
|
|
|
break;
|
1998-01-16 07:13:05 -05:00
|
|
|
case T_CLASS:
|
|
|
|
case T_MODULE:
|
2007-09-28 02:21:46 -04:00
|
|
|
if (!RCLASS_IV_TBL(obj)) RCLASS_IV_TBL(obj) = st_init_numtable();
|
2013-06-14 05:23:54 -04:00
|
|
|
rb_st_insert_id_and_value(obj, RCLASS_IV_TBL(obj), (st_data_t)id, val);
|
2007-09-28 21:21:15 -04:00
|
|
|
break;
|
1998-01-16 07:13:05 -05:00
|
|
|
default:
|
2012-07-28 13:04:58 -04:00
|
|
|
generic:
|
1999-01-19 23:59:39 -05:00
|
|
|
generic_ivar_set(obj, id, val);
|
1998-01-16 07:13:05 -05:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_ivar_defined(VALUE obj, ID id)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2008-02-13 06:52:46 -05:00
|
|
|
VALUE val;
|
|
|
|
struct st_table *iv_index_tbl;
|
2007-09-28 02:21:46 -04:00
|
|
|
st_data_t index;
|
2012-07-28 13:04:58 -04:00
|
|
|
if (SPECIAL_CONST_P(obj)) goto generic;
|
|
|
|
switch (BUILTIN_TYPE(obj)) {
|
1998-01-16 07:13:05 -05:00
|
|
|
case T_OBJECT:
|
2008-02-13 06:52:46 -05:00
|
|
|
iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);
|
|
|
|
if (!iv_index_tbl) break;
|
2009-07-30 03:10:51 -04:00
|
|
|
if (!st_lookup(iv_index_tbl, (st_data_t)id, &index)) break;
|
* array.c, bignum.c, dln.c, error.c, gc.c, io.c, marshal.c,
numeric.c, pack.c, strftime.c, string.c, thread.c, transcode.c,
transcode_data.h, util.c, variable.c, vm_dump.c,
include/ruby/encoding.h, missing/crypt.c, missing/vsnprintf.c:
suppress VC type warnings. [ruby-core:22726]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@22914 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2009-03-12 05:16:15 -04:00
|
|
|
if (ROBJECT_NUMIV(obj) <= (long)index) break;
|
2008-02-25 11:18:18 -05:00
|
|
|
val = ROBJECT_IVPTR(obj)[index];
|
2007-09-28 02:21:46 -04:00
|
|
|
if (val != Qundef)
|
|
|
|
return Qtrue;
|
|
|
|
break;
|
1998-01-16 07:13:05 -05:00
|
|
|
case T_CLASS:
|
|
|
|
case T_MODULE:
|
2009-07-30 03:10:51 -04:00
|
|
|
if (RCLASS_IV_TBL(obj) && st_lookup(RCLASS_IV_TBL(obj), (st_data_t)id, 0))
|
1999-01-19 23:59:39 -05:00
|
|
|
return Qtrue;
|
|
|
|
break;
|
|
|
|
default:
|
2012-07-28 13:04:58 -04:00
|
|
|
generic:
|
1999-01-19 23:59:39 -05:00
|
|
|
if (FL_TEST(obj, FL_EXIVAR) || rb_special_const_p(obj))
|
|
|
|
return generic_ivar_defined(obj, id);
|
1998-01-16 07:13:05 -05:00
|
|
|
break;
|
|
|
|
}
|
1999-01-19 23:59:39 -05:00
|
|
|
return Qfalse;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2007-09-28 02:21:46 -04:00
|
|
|
struct obj_ivar_tag {
|
|
|
|
VALUE obj;
|
|
|
|
int (*func)(ID key, VALUE val, st_data_t arg);
|
|
|
|
st_data_t arg;
|
|
|
|
};
|
|
|
|
|
1998-01-16 07:19:22 -05:00
|
|
|
static int
|
2009-12-05 00:45:29 -05:00
|
|
|
obj_ivar_i(st_data_t key, st_data_t index, st_data_t arg)
|
2007-09-28 02:21:46 -04:00
|
|
|
{
|
2009-12-05 00:45:29 -05:00
|
|
|
struct obj_ivar_tag *data = (struct obj_ivar_tag *)arg;
|
* array.c, bignum.c, dln.c, error.c, gc.c, io.c, marshal.c,
numeric.c, pack.c, strftime.c, string.c, thread.c, transcode.c,
transcode_data.h, util.c, variable.c, vm_dump.c,
include/ruby/encoding.h, missing/crypt.c, missing/vsnprintf.c:
suppress VC type warnings. [ruby-core:22726]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@22914 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2009-03-12 05:16:15 -04:00
|
|
|
if ((long)index < ROBJECT_NUMIV(data->obj)) {
|
2009-12-05 00:45:29 -05:00
|
|
|
VALUE val = ROBJECT_IVPTR(data->obj)[(long)index];
|
2007-09-28 02:21:46 -04:00
|
|
|
if (val != Qundef) {
|
2009-12-05 00:45:29 -05:00
|
|
|
return (data->func)((ID)key, val, data->arg);
|
2007-09-28 02:21:46 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return ST_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
obj_ivar_each(VALUE obj, int (*func)(ANYARGS), st_data_t arg)
|
|
|
|
{
|
|
|
|
st_table *tbl;
|
|
|
|
struct obj_ivar_tag data;
|
|
|
|
|
2008-02-13 06:52:46 -05:00
|
|
|
tbl = ROBJECT_IV_INDEX_TBL(obj);
|
2007-09-28 02:21:46 -04:00
|
|
|
if (!tbl)
|
|
|
|
return;
|
|
|
|
|
|
|
|
data.obj = obj;
|
2007-09-29 11:56:50 -04:00
|
|
|
data.func = (int (*)(ID key, VALUE val, st_data_t arg))func;
|
2007-09-28 02:21:46 -04:00
|
|
|
data.arg = arg;
|
|
|
|
|
|
|
|
st_foreach_safe(tbl, obj_ivar_i, (st_data_t)&data);
|
|
|
|
}
|
|
|
|
|
2009-12-05 00:45:29 -05:00
|
|
|
void
|
|
|
|
rb_ivar_foreach(VALUE obj, int (*func)(ANYARGS), st_data_t arg)
|
2007-09-28 02:21:46 -04:00
|
|
|
{
|
2012-07-28 13:04:58 -04:00
|
|
|
if (SPECIAL_CONST_P(obj)) goto generic;
|
|
|
|
switch (BUILTIN_TYPE(obj)) {
|
2007-09-28 02:21:46 -04:00
|
|
|
case T_OBJECT:
|
|
|
|
obj_ivar_each(obj, func, arg);
|
|
|
|
break;
|
|
|
|
case T_CLASS:
|
|
|
|
case T_MODULE:
|
|
|
|
if (RCLASS_IV_TBL(obj)) {
|
|
|
|
st_foreach_safe(RCLASS_IV_TBL(obj), func, arg);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2012-07-28 13:04:58 -04:00
|
|
|
generic:
|
2007-09-28 02:21:46 -04:00
|
|
|
if (!generic_iv_tbl) break;
|
|
|
|
if (FL_TEST(obj, FL_EXIVAR) || rb_special_const_p(obj)) {
|
|
|
|
st_data_t tbl;
|
|
|
|
|
2009-07-30 03:10:51 -04:00
|
|
|
if (st_lookup(generic_iv_tbl, (st_data_t)obj, &tbl)) {
|
2007-09-28 02:21:46 -04:00
|
|
|
st_foreach_safe((st_table *)tbl, func, arg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-05 01:35:07 -05:00
|
|
|
st_index_t
|
|
|
|
rb_ivar_count(VALUE obj)
|
|
|
|
{
|
|
|
|
st_table *tbl;
|
2012-07-28 13:04:58 -04:00
|
|
|
if (SPECIAL_CONST_P(obj)) goto generic;
|
|
|
|
switch (BUILTIN_TYPE(obj)) {
|
2009-12-05 01:35:07 -05:00
|
|
|
case T_OBJECT:
|
|
|
|
if ((tbl = ROBJECT_IV_INDEX_TBL(obj)) != 0) {
|
2010-10-03 18:57:23 -04:00
|
|
|
st_index_t i, count, num = tbl->num_entries;
|
2009-12-05 01:35:07 -05:00
|
|
|
const VALUE *const ivptr = ROBJECT_IVPTR(obj);
|
|
|
|
for (i = count = 0; i < num; ++i) {
|
|
|
|
if (ivptr[i] != Qundef) {
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return count;
|
2012-06-21 23:07:22 -04:00
|
|
|
}
|
2009-12-05 01:35:07 -05:00
|
|
|
break;
|
|
|
|
case T_CLASS:
|
|
|
|
case T_MODULE:
|
|
|
|
if ((tbl = RCLASS_IV_TBL(obj)) != 0) {
|
|
|
|
return tbl->num_entries;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2012-07-28 13:04:58 -04:00
|
|
|
generic:
|
2009-12-05 01:35:07 -05:00
|
|
|
if (!generic_iv_tbl) break;
|
|
|
|
if (FL_TEST(obj, FL_EXIVAR) || rb_special_const_p(obj)) {
|
|
|
|
st_data_t data;
|
|
|
|
|
|
|
|
if (st_lookup(generic_iv_tbl, (st_data_t)obj, &data) &&
|
|
|
|
(tbl = (st_table *)data) != 0) {
|
|
|
|
return tbl->num_entries;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-28 02:21:46 -04:00
|
|
|
static int
|
2012-03-30 18:40:54 -04:00
|
|
|
ivar_i(st_data_t k, st_data_t v, st_data_t a)
|
1998-01-16 07:19:22 -05:00
|
|
|
{
|
2012-03-30 18:40:54 -04:00
|
|
|
ID key = (ID)k;
|
|
|
|
VALUE ary = (VALUE)a;
|
|
|
|
|
* parse.y, compile.c, gc.c, insns.def, intern.h, iseq.c, node.h,
object.c, string.c, variable.c, vm_macro.def: revert private
instance variable feature, which is postponed until next major
release.
* marshal.c: TYPE_SYMBOL2 removed; MARSHAL_MINOR reverted back to
8th version.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11813 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-22 21:49:41 -05:00
|
|
|
if (rb_is_instance_id(key)) {
|
2006-09-04 01:46:47 -04:00
|
|
|
rb_ary_push(ary, ID2SYM(key));
|
1998-01-16 07:19:22 -05:00
|
|
|
}
|
|
|
|
return ST_CONTINUE;
|
|
|
|
}
|
|
|
|
|
2003-12-28 01:33:07 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* obj.instance_variables -> array
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 01:33:07 -05:00
|
|
|
* Returns an array of instance variable names for the receiver. Note
|
|
|
|
* that simply defining an accessor does not create the corresponding
|
|
|
|
* instance variable.
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 01:33:07 -05:00
|
|
|
* class Fred
|
|
|
|
* attr_accessor :a1
|
|
|
|
* def initialize
|
|
|
|
* @iv = 3
|
|
|
|
* end
|
|
|
|
* end
|
2008-03-08 20:04:46 -05:00
|
|
|
* Fred.new.instance_variables #=> [:@iv]
|
2003-12-28 01:33:07 -05:00
|
|
|
*/
|
|
|
|
|
1998-01-16 07:19:22 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_obj_instance_variables(VALUE obj)
|
1998-01-16 07:19:22 -05:00
|
|
|
{
|
1999-12-14 01:50:43 -05:00
|
|
|
VALUE ary;
|
1998-01-16 07:19:22 -05:00
|
|
|
|
1999-12-14 01:50:43 -05:00
|
|
|
ary = rb_ary_new();
|
2007-09-28 02:21:46 -04:00
|
|
|
rb_ivar_foreach(obj, ivar_i, ary);
|
1999-10-04 00:51:08 -04:00
|
|
|
return ary;
|
1998-01-16 07:19:22 -05:00
|
|
|
}
|
|
|
|
|
2003-12-28 01:33:07 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* obj.remove_instance_variable(symbol) -> obj
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 01:33:07 -05:00
|
|
|
* Removes the named instance variable from <i>obj</i>, returning that
|
|
|
|
* variable's value.
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 01:33:07 -05:00
|
|
|
* class Dummy
|
|
|
|
* attr_reader :var
|
|
|
|
* def initialize
|
|
|
|
* @var = 99
|
|
|
|
* end
|
|
|
|
* def remove
|
|
|
|
* remove_instance_variable(:@var)
|
|
|
|
* end
|
|
|
|
* end
|
|
|
|
* d = Dummy.new
|
|
|
|
* d.var #=> 99
|
|
|
|
* d.remove #=> 99
|
|
|
|
* d.var #=> nil
|
|
|
|
*/
|
|
|
|
|
1998-01-16 07:19:22 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_obj_remove_instance_variable(VALUE obj, VALUE name)
|
1998-01-16 07:19:22 -05:00
|
|
|
{
|
1999-01-19 23:59:39 -05:00
|
|
|
VALUE val = Qnil;
|
2011-07-26 12:05:27 -04:00
|
|
|
const ID id = rb_check_id(&name);
|
2008-10-07 22:23:04 -04:00
|
|
|
st_data_t n, v;
|
2008-02-13 06:52:46 -05:00
|
|
|
struct st_table *iv_index_tbl;
|
2007-09-28 02:21:46 -04:00
|
|
|
st_data_t index;
|
1998-01-16 07:19:22 -05:00
|
|
|
|
* array.c, gc.c, hash.c, object.c, string.c, struct.c,
transcode.c, variable.c, vm.c, vm_insnhelper.c, vm_method.c:
replace calls to rb_error_frozen() with rb_check_frozen(). a
patch from Run Paint Run Run at [ruby-core:32014]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@29583 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2010-10-24 04:14:05 -04:00
|
|
|
rb_check_frozen(obj);
|
2011-07-23 11:05:03 -04:00
|
|
|
if (!id) {
|
|
|
|
if (rb_is_instance_name(name)) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error_str(name, "instance variable %"PRIsVALUE" not defined",
|
|
|
|
name);
|
2011-07-23 11:05:03 -04:00
|
|
|
}
|
|
|
|
else {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error_str(name, "`%"PRIsVALUE"' is not allowed as an instance variable name",
|
|
|
|
QUOTE(name));
|
2011-07-23 11:05:03 -04:00
|
|
|
}
|
|
|
|
}
|
1999-01-19 23:59:39 -05:00
|
|
|
if (!rb_is_instance_id(id)) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error(id, "`%"PRIsVALUE"' is not allowed as an instance variable name",
|
|
|
|
QUOTE_ID(id));
|
1998-01-16 07:19:22 -05:00
|
|
|
}
|
|
|
|
|
2012-07-28 13:04:58 -04:00
|
|
|
if (SPECIAL_CONST_P(obj)) goto generic;
|
|
|
|
switch (BUILTIN_TYPE(obj)) {
|
1998-01-16 07:19:22 -05:00
|
|
|
case T_OBJECT:
|
2008-02-13 06:52:46 -05:00
|
|
|
iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);
|
|
|
|
if (!iv_index_tbl) break;
|
2009-07-30 03:10:51 -04:00
|
|
|
if (!st_lookup(iv_index_tbl, (st_data_t)id, &index)) break;
|
* array.c, bignum.c, dln.c, error.c, gc.c, io.c, marshal.c,
numeric.c, pack.c, strftime.c, string.c, thread.c, transcode.c,
transcode_data.h, util.c, variable.c, vm_dump.c,
include/ruby/encoding.h, missing/crypt.c, missing/vsnprintf.c:
suppress VC type warnings. [ruby-core:22726]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@22914 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2009-03-12 05:16:15 -04:00
|
|
|
if (ROBJECT_NUMIV(obj) <= (long)index) break;
|
2008-02-25 11:18:18 -05:00
|
|
|
val = ROBJECT_IVPTR(obj)[index];
|
2007-09-28 02:21:46 -04:00
|
|
|
if (val != Qundef) {
|
2008-02-25 11:18:18 -05:00
|
|
|
ROBJECT_IVPTR(obj)[index] = Qundef;
|
2007-09-28 02:21:46 -04:00
|
|
|
return val;
|
|
|
|
}
|
|
|
|
break;
|
1998-01-16 07:19:22 -05:00
|
|
|
case T_CLASS:
|
|
|
|
case T_MODULE:
|
2008-10-07 22:23:04 -04:00
|
|
|
n = id;
|
|
|
|
if (RCLASS_IV_TBL(obj) && st_delete(RCLASS_IV_TBL(obj), &n, &v)) {
|
|
|
|
return (VALUE)v;
|
1998-01-16 07:19:22 -05:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2012-07-28 13:04:58 -04:00
|
|
|
generic:
|
2002-04-10 04:45:26 -04:00
|
|
|
if (FL_TEST(obj, FL_EXIVAR) || rb_special_const_p(obj)) {
|
2009-07-30 03:10:51 -04:00
|
|
|
v = val;
|
|
|
|
if (generic_ivar_remove(obj, (st_data_t)id, &v)) {
|
|
|
|
return (VALUE)v;
|
2002-04-10 04:45:26 -04:00
|
|
|
}
|
|
|
|
}
|
1998-01-16 07:19:22 -05:00
|
|
|
break;
|
|
|
|
}
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error(id, "instance variable %"PRIsVALUE" not defined", QUOTE_ID(id));
|
2012-04-13 20:36:26 -04:00
|
|
|
|
|
|
|
UNREACHABLE;
|
1998-01-16 07:19:22 -05:00
|
|
|
}
|
|
|
|
|
* bignum.c: changed `foo _((boo))' to `foo(boo)`. [ruby-dev:27056]
* defines.h, dir.c, dln.h, enumerator.c, env.h, error.c, eval.c, file.c,
gc.c, hash.c, inits.c, intern.h, io.c, lex.c, marshal.c, missing.h,
node.h, numeric.c, pack.c, process.c, re.h, ruby.c, ruby.h, rubyio.h,
rubysig.h, signal.c, sprintf.c, st.h, string.c, struct.c, time.c,
util.c, util.h, variable.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9155 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-14 02:32:32 -04:00
|
|
|
NORETURN(static void uninitialized_constant(VALUE, ID));
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
static void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
uninitialized_constant(VALUE klass, ID id)
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
{
|
2010-06-11 20:20:27 -04:00
|
|
|
if (klass && rb_class_real(klass) != rb_cObject)
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error(id, "uninitialized constant %"PRIsVALUE"::%"PRIsVALUE"",
|
|
|
|
rb_class_name(klass),
|
|
|
|
QUOTE_ID(id));
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
else {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error(id, "uninitialized constant %"PRIsVALUE"", QUOTE_ID(id));
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-07-22 04:42:47 -04:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
const_missing(VALUE klass, ID id)
|
2003-07-22 04:42:47 -04:00
|
|
|
{
|
|
|
|
return rb_funcall(klass, rb_intern("const_missing"), 1, ID2SYM(id));
|
|
|
|
}
|
|
|
|
|
2003-12-28 01:33:07 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* mod.const_missing(sym) -> obj
|
2003-12-28 01:33:07 -05:00
|
|
|
*
|
2011-06-16 02:17:59 -04:00
|
|
|
* Invoked when a reference is made to an undefined constant in
|
|
|
|
* <i>mod</i>. It is passed a symbol for the undefined constant, and
|
|
|
|
* returns a value to be used for that constant. The
|
2011-06-17 18:33:54 -04:00
|
|
|
* following code is an example of the same:
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2011-06-16 02:17:59 -04:00
|
|
|
* def Foo.const_missing(name)
|
|
|
|
* name # return the constant name as Symbol
|
|
|
|
* end
|
|
|
|
*
|
|
|
|
* Foo::UNDEFINED_CONST #=> :UNDEFINED_CONST: symbol returned
|
|
|
|
*
|
|
|
|
* In the next example when a reference is made to an undefined constant,
|
|
|
|
* it attempts to load a file whose name is the lowercase version of the
|
|
|
|
* constant (thus class <code>Fred</code> is assumed to be in file
|
|
|
|
* <code>fred.rb</code>). If found, it returns the loaded class. It
|
|
|
|
* therefore implements an autoload feature similar to Kernel#autoload and
|
|
|
|
* Module#autoload.
|
|
|
|
*
|
|
|
|
* def Object.const_missing(name)
|
|
|
|
* @looked_for ||= {}
|
|
|
|
* str_name = name.to_s
|
|
|
|
* raise "Class not found: #{name}" if @looked_for[str_name]
|
|
|
|
* @looked_for[str_name] = 1
|
|
|
|
* file = str_name.downcase
|
|
|
|
* require file
|
|
|
|
* klass = const_get(name)
|
|
|
|
* return klass if klass
|
|
|
|
* raise "Class not found: #{name}"
|
|
|
|
* end
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 01:33:07 -05:00
|
|
|
*/
|
|
|
|
|
2003-07-22 04:42:47 -04:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_mod_const_missing(VALUE klass, VALUE name)
|
2003-07-22 04:42:47 -04:00
|
|
|
{
|
2006-12-31 10:02:22 -05:00
|
|
|
rb_frame_pop(); /* pop frame for "const_missing" */
|
2003-07-22 04:42:47 -04:00
|
|
|
uninitialized_constant(klass, rb_to_id(name));
|
2012-04-13 20:36:26 -04:00
|
|
|
|
|
|
|
UNREACHABLE;
|
2003-07-22 04:42:47 -04:00
|
|
|
}
|
|
|
|
|
2009-09-09 00:09:09 -04:00
|
|
|
static void
|
|
|
|
autoload_mark(void *ptr)
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
{
|
2009-09-09 00:09:09 -04:00
|
|
|
rb_mark_tbl((st_table *)ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
autoload_free(void *ptr)
|
|
|
|
{
|
|
|
|
st_free_table((st_table *)ptr);
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
}
|
|
|
|
|
2009-09-09 00:09:09 -04:00
|
|
|
static size_t
|
|
|
|
autoload_memsize(const void *ptr)
|
|
|
|
{
|
|
|
|
const st_table *tbl = ptr;
|
|
|
|
return st_memsize(tbl);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const rb_data_type_t autoload_data_type = {
|
|
|
|
"autoload",
|
2010-07-18 03:31:54 -04:00
|
|
|
{autoload_mark, autoload_free, autoload_memsize,},
|
2009-09-09 00:09:09 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
#define check_autoload_table(av) \
|
2011-01-11 06:33:53 -05:00
|
|
|
(struct st_table *)rb_check_typeddata((av), &autoload_data_type)
|
2009-09-09 00:09:09 -04:00
|
|
|
|
2011-08-31 04:28:19 -04:00
|
|
|
static VALUE
|
|
|
|
autoload_data(VALUE mod, ID id)
|
|
|
|
{
|
|
|
|
struct st_table *tbl;
|
|
|
|
st_data_t val;
|
|
|
|
|
|
|
|
if (!st_lookup(RCLASS_IV_TBL(mod), autoload, &val) ||
|
|
|
|
!(tbl = check_autoload_table((VALUE)val)) || !st_lookup(tbl, (st_data_t)id, &val)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return (VALUE)val;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct autoload_data_i {
|
|
|
|
VALUE feature;
|
|
|
|
int safe_level;
|
|
|
|
VALUE thread;
|
|
|
|
VALUE value;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
autoload_i_mark(void *ptr)
|
|
|
|
{
|
|
|
|
struct autoload_data_i *p = ptr;
|
|
|
|
rb_gc_mark(p->feature);
|
|
|
|
rb_gc_mark(p->thread);
|
|
|
|
rb_gc_mark(p->value);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
autoload_i_free(void *ptr)
|
|
|
|
{
|
|
|
|
struct autoload_data_i *p = ptr;
|
|
|
|
xfree(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
autoload_i_memsize(const void *ptr)
|
|
|
|
{
|
|
|
|
return sizeof(struct autoload_data_i);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const rb_data_type_t autoload_data_i_type = {
|
|
|
|
"autoload_i",
|
|
|
|
{autoload_i_mark, autoload_i_free, autoload_i_memsize,},
|
|
|
|
};
|
|
|
|
|
|
|
|
#define check_autoload_data(av) \
|
|
|
|
(struct autoload_data_i *)rb_check_typeddata((av), &autoload_data_i_type)
|
|
|
|
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_autoload(VALUE mod, ID id, const char *file)
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
{
|
2009-07-30 03:10:51 -04:00
|
|
|
st_data_t av;
|
2011-08-31 04:28:19 -04:00
|
|
|
VALUE ad, fn;
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
struct st_table *tbl;
|
2011-08-31 04:28:19 -04:00
|
|
|
struct autoload_data_i *ele;
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
|
|
|
|
if (!rb_is_const_id(id)) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_raise(rb_eNameError, "autoload must be constant name: %"PRIsVALUE"",
|
|
|
|
QUOTE_ID(id));
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
}
|
|
|
|
if (!file || !*file) {
|
|
|
|
rb_raise(rb_eArgError, "empty file name");
|
|
|
|
}
|
|
|
|
|
2010-10-26 13:27:32 -04:00
|
|
|
if ((tbl = RCLASS_CONST_TBL(mod)) && st_lookup(tbl, (st_data_t)id, &av) && ((rb_const_entry_t*)av)->value != Qundef)
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
return;
|
|
|
|
|
|
|
|
rb_const_set(mod, id, Qundef);
|
2007-09-28 02:21:46 -04:00
|
|
|
tbl = RCLASS_IV_TBL(mod);
|
2010-10-26 13:27:21 -04:00
|
|
|
if (tbl && st_lookup(tbl, (st_data_t)autoload, &av)) {
|
2009-07-30 03:10:51 -04:00
|
|
|
tbl = check_autoload_table((VALUE)av);
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
}
|
|
|
|
else {
|
2010-10-26 13:27:21 -04:00
|
|
|
if (!tbl) tbl = RCLASS_IV_TBL(mod) = st_init_numtable();
|
2009-09-09 00:33:13 -04:00
|
|
|
av = (st_data_t)TypedData_Wrap_Struct(0, &autoload_data_type, 0);
|
2009-07-30 03:10:51 -04:00
|
|
|
st_add_direct(tbl, (st_data_t)autoload, av);
|
2013-06-17 21:18:32 -04:00
|
|
|
OBJ_WRITTEN(mod, Qnil, av);
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
DATA_PTR(av) = tbl = st_init_numtable();
|
|
|
|
}
|
2003-10-13 10:57:36 -04:00
|
|
|
fn = rb_str_new2(file);
|
|
|
|
FL_UNSET(fn, FL_TAINT);
|
|
|
|
OBJ_FREEZE(fn);
|
2011-08-31 04:35:27 -04:00
|
|
|
|
|
|
|
ele = ALLOC(struct autoload_data_i);
|
2011-08-31 04:28:19 -04:00
|
|
|
ele->feature = fn;
|
|
|
|
ele->safe_level = rb_safe_level();
|
|
|
|
ele->thread = Qnil;
|
|
|
|
ele->value = Qundef;
|
2011-08-31 04:35:27 -04:00
|
|
|
ad = TypedData_Wrap_Struct(0, &autoload_data_i_type, ele);
|
|
|
|
st_insert(tbl, (st_data_t)id, (st_data_t)ad);
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
}
|
|
|
|
|
2011-08-31 04:28:19 -04:00
|
|
|
static void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
autoload_delete(VALUE mod, ID id)
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
{
|
2008-10-07 22:23:04 -04:00
|
|
|
st_data_t val, load = 0, n = id;
|
2010-10-26 13:27:32 -04:00
|
|
|
rb_const_entry_t *ce;
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
|
2010-10-26 13:27:32 -04:00
|
|
|
st_delete(RCLASS_CONST_TBL(mod), &n, &val);
|
|
|
|
ce = (rb_const_entry_t*)val;
|
|
|
|
if (ce) xfree(ce);
|
2009-07-30 03:10:51 -04:00
|
|
|
if (st_lookup(RCLASS_IV_TBL(mod), (st_data_t)autoload, &val)) {
|
2008-10-07 22:23:04 -04:00
|
|
|
struct st_table *tbl = check_autoload_table((VALUE)val);
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
|
2008-10-07 22:23:04 -04:00
|
|
|
st_delete(tbl, &n, &load);
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
|
2003-06-25 01:28:24 -04:00
|
|
|
if (tbl->num_entries == 0) {
|
2008-10-07 22:23:04 -04:00
|
|
|
n = autoload;
|
2011-08-11 02:51:42 -04:00
|
|
|
st_delete(RCLASS_IV_TBL(mod), &n, &val);
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-04 13:29:20 -05:00
|
|
|
static VALUE
|
|
|
|
autoload_provided(VALUE arg)
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
{
|
2008-12-04 13:29:20 -05:00
|
|
|
const char **p = (const char **)arg;
|
|
|
|
return rb_feature_provided(*p, p);
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2008-12-04 13:29:20 -05:00
|
|
|
reset_safe(VALUE safe)
|
|
|
|
{
|
|
|
|
rb_set_safe_level_force((int)safe);
|
|
|
|
return safe;
|
|
|
|
}
|
|
|
|
|
2011-08-31 04:28:19 -04:00
|
|
|
static VALUE
|
|
|
|
check_autoload_required(VALUE mod, ID id, const char **loadingpath)
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
{
|
2011-08-31 04:28:19 -04:00
|
|
|
VALUE file, load;
|
|
|
|
struct autoload_data_i *ele;
|
2008-12-04 13:29:20 -05:00
|
|
|
const char *loading;
|
|
|
|
int safe;
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
|
2011-08-31 04:28:19 -04:00
|
|
|
if (!(load = autoload_data(mod, id)) || !(ele = check_autoload_data(load))) {
|
2008-12-04 13:29:20 -05:00
|
|
|
return 0;
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
}
|
2011-08-31 04:28:19 -04:00
|
|
|
file = ele->feature;
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
Check_Type(file, T_STRING);
|
2008-04-07 14:39:28 -04:00
|
|
|
if (!RSTRING_PTR(file) || !*RSTRING_PTR(file)) {
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
rb_raise(rb_eArgError, "empty file name");
|
|
|
|
}
|
2008-12-04 13:29:20 -05:00
|
|
|
loading = RSTRING_PTR(file);
|
|
|
|
safe = rb_safe_level();
|
|
|
|
rb_set_safe_level_force(0);
|
|
|
|
if (!rb_ensure(autoload_provided, (VALUE)&loading, reset_safe, (VALUE)safe)) {
|
|
|
|
return load;
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
}
|
2009-05-16 00:49:26 -04:00
|
|
|
if (loadingpath && loading) {
|
|
|
|
*loadingpath = loading;
|
2008-12-04 13:29:20 -05:00
|
|
|
return load;
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
}
|
2008-12-04 13:29:20 -05:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-31 04:28:19 -04:00
|
|
|
int
|
|
|
|
rb_autoloading_value(VALUE mod, ID id, VALUE* value)
|
|
|
|
{
|
|
|
|
VALUE load;
|
|
|
|
struct autoload_data_i *ele;
|
|
|
|
|
|
|
|
if (!(load = autoload_data(mod, id)) || !(ele = check_autoload_data(load))) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (ele->thread == rb_thread_current()) {
|
|
|
|
if (ele->value != Qundef) {
|
2012-06-21 23:07:22 -04:00
|
|
|
if (value) {
|
|
|
|
*value = ele->value;
|
|
|
|
}
|
2011-08-31 04:28:19 -04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-31 20:31:18 -04:00
|
|
|
static int
|
|
|
|
autoload_defined_p(VALUE mod, ID id)
|
|
|
|
{
|
|
|
|
struct st_table *tbl = RCLASS_CONST_TBL(mod);
|
|
|
|
st_data_t val;
|
|
|
|
|
|
|
|
if (!tbl || !st_lookup(tbl, (st_data_t)id, &val) || ((rb_const_entry_t*)val)->value != Qundef) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return !rb_autoloading_value(mod, id, NULL);
|
|
|
|
}
|
|
|
|
|
2011-08-31 04:28:19 -04:00
|
|
|
struct autoload_const_set_args {
|
|
|
|
VALUE mod;
|
|
|
|
ID id;
|
|
|
|
VALUE value;
|
|
|
|
};
|
|
|
|
|
2012-02-13 22:10:11 -05:00
|
|
|
static VALUE
|
|
|
|
autoload_const_set(VALUE arg)
|
2011-08-31 04:28:19 -04:00
|
|
|
{
|
2012-02-13 22:10:11 -05:00
|
|
|
struct autoload_const_set_args* args = (struct autoload_const_set_args *)arg;
|
2011-08-31 04:28:19 -04:00
|
|
|
autoload_delete(args->mod, args->id);
|
|
|
|
rb_const_set(args->mod, args->id, args->value);
|
2012-02-13 22:10:11 -05:00
|
|
|
return 0; /* ignored */
|
2011-08-31 04:28:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2012-02-13 22:10:11 -05:00
|
|
|
autoload_require(VALUE arg)
|
2011-08-31 04:28:19 -04:00
|
|
|
{
|
2012-02-13 22:10:11 -05:00
|
|
|
struct autoload_data_i *ele = (struct autoload_data_i *)arg;
|
2011-08-31 04:28:19 -04:00
|
|
|
return rb_require_safe(ele->feature, ele->safe_level);
|
|
|
|
}
|
|
|
|
|
2008-12-04 13:29:20 -05:00
|
|
|
VALUE
|
2009-05-16 00:49:26 -04:00
|
|
|
rb_autoload_load(VALUE mod, ID id)
|
2008-12-04 13:29:20 -05:00
|
|
|
{
|
2011-08-31 04:28:19 -04:00
|
|
|
VALUE load, result;
|
2009-05-16 00:49:26 -04:00
|
|
|
const char *loading = 0, *src;
|
2011-08-31 04:28:19 -04:00
|
|
|
struct autoload_data_i *ele;
|
|
|
|
int state = 0;
|
2008-12-04 13:29:20 -05:00
|
|
|
|
2011-08-31 04:28:19 -04:00
|
|
|
if (!autoload_defined_p(mod, id)) return Qfalse;
|
|
|
|
load = check_autoload_required(mod, id, &loading);
|
2008-12-04 13:29:20 -05:00
|
|
|
if (!load) return Qfalse;
|
2009-05-16 00:49:26 -04:00
|
|
|
src = rb_sourcefile();
|
|
|
|
if (src && loading && strcmp(src, loading) == 0) return Qfalse;
|
2011-08-31 04:28:19 -04:00
|
|
|
|
|
|
|
/* set ele->thread for a marker of autoloading thread */
|
|
|
|
if (!(ele = check_autoload_data(load))) {
|
|
|
|
return Qfalse;
|
|
|
|
}
|
|
|
|
if (ele->thread == Qnil) {
|
|
|
|
ele->thread = rb_thread_current();
|
|
|
|
}
|
|
|
|
/* autoload_data_i can be deleted by another thread while require */
|
2012-02-13 22:10:11 -05:00
|
|
|
result = rb_protect(autoload_require, (VALUE)ele, &state);
|
2011-08-31 04:28:19 -04:00
|
|
|
if (ele->thread == rb_thread_current()) {
|
|
|
|
ele->thread = Qnil;
|
|
|
|
}
|
|
|
|
if (state) rb_jump_tag(state);
|
|
|
|
|
|
|
|
if (RTEST(result)) {
|
|
|
|
/* At the last, move a value defined in autoload to constant table */
|
|
|
|
if (ele->value != Qundef) {
|
|
|
|
int safe_backup;
|
|
|
|
struct autoload_const_set_args args;
|
|
|
|
args.mod = mod;
|
|
|
|
args.id = id;
|
|
|
|
args.value = ele->value;
|
|
|
|
safe_backup = rb_safe_level();
|
|
|
|
rb_set_safe_level_force(ele->safe_level);
|
2012-02-13 22:10:11 -05:00
|
|
|
rb_ensure(autoload_const_set, (VALUE)&args, reset_safe, (VALUE)safe_backup);
|
2011-08-31 04:28:19 -04:00
|
|
|
}
|
|
|
|
}
|
2011-08-31 04:35:27 -04:00
|
|
|
RB_GC_GUARD(load);
|
2011-08-31 04:28:19 -04:00
|
|
|
return result;
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_autoload_p(VALUE mod, ID id)
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
{
|
2011-08-31 04:28:19 -04:00
|
|
|
VALUE load;
|
|
|
|
struct autoload_data_i *ele;
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
|
2011-08-31 04:28:19 -04:00
|
|
|
while (!autoload_defined_p(mod, id)) {
|
2011-04-14 08:23:32 -04:00
|
|
|
mod = RCLASS_SUPER(mod);
|
|
|
|
if (!mod) return Qnil;
|
|
|
|
}
|
2011-08-31 04:28:19 -04:00
|
|
|
load = check_autoload_required(mod, id, 0);
|
2009-05-15 02:15:14 -04:00
|
|
|
if (!load) return Qnil;
|
2011-08-31 04:28:19 -04:00
|
|
|
return (ele = check_autoload_data(load)) ? ele->feature : Qnil;
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
}
|
|
|
|
|
2003-06-20 03:11:44 -04:00
|
|
|
static VALUE
|
2011-01-28 12:57:27 -05:00
|
|
|
rb_const_get_0(VALUE klass, ID id, int exclude, int recurse, int visibility)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2011-08-31 04:28:19 -04:00
|
|
|
VALUE value, tmp, av;
|
2006-12-31 10:02:22 -05:00
|
|
|
int mod_retry = 0;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
1999-01-19 23:59:39 -05:00
|
|
|
tmp = klass;
|
2001-05-02 00:22:21 -04:00
|
|
|
retry:
|
2008-04-07 14:39:28 -04:00
|
|
|
while (RTEST(tmp)) {
|
2009-01-31 15:19:44 -05:00
|
|
|
VALUE am = 0;
|
* compile.c (iseq_build_body), error.c (set_syserr, get_syserr),
(syserr_initialize), gc.c (define_final, rb_gc_copy_finalizer),
(run_final), hash.c (rb_hash_aref, rb_hash_lookup2),
(rb_hash_fetch_m, rb_hash_clear, rb_hash_aset, eql_i),
iseq.c (iseq_load, iseq_data_to_ary), marshal.c (r_symlink),
thread.c (rb_thread_local_aref),
variable.c (generic_ivar_remove, ivar_get, rb_const_get_0),
(rb_cvar_get), vm.c (rb_vm_check_redefinition_opt_method),
vm_insnhelper.c (vm_get_ev_const), vm_method.c (remove_method),
ext/iconv/iconv.c (map_charset): use st_data_t.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@29462 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2010-10-12 10:47:23 -04:00
|
|
|
st_data_t data;
|
2010-10-26 13:27:21 -04:00
|
|
|
while (RCLASS_CONST_TBL(tmp) && st_lookup(RCLASS_CONST_TBL(tmp), (st_data_t)id, &data)) {
|
2010-10-26 13:27:44 -04:00
|
|
|
rb_const_entry_t *ce = (rb_const_entry_t *)data;
|
2011-01-28 12:57:27 -05:00
|
|
|
if (visibility && ce->flag == CONST_PRIVATE) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error(id, "private constant %"PRIsVALUE"::%"PRIsVALUE" referenced",
|
|
|
|
rb_class_name(klass), QUOTE_ID(id));
|
2010-10-26 13:27:44 -04:00
|
|
|
}
|
|
|
|
value = ce->value;
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
if (value == Qundef) {
|
2009-01-31 15:19:44 -05:00
|
|
|
if (am == tmp) break;
|
|
|
|
am = tmp;
|
2011-08-31 04:28:19 -04:00
|
|
|
if (rb_autoloading_value(tmp, id, &av)) return av;
|
2008-12-04 13:29:20 -05:00
|
|
|
rb_autoload_load(tmp, id);
|
* eval.c (ev_const_defined, ev_const_get), variable.c
(rb_const_get_at, rb_const_get, rb_mod_remove_const): use Qundef
as autoload marker. [ruby-dev:18103], [ruby-dev:18184]
* eval.c (rb_mod_autoload, rb_mod_autoload_p): new method;
Module#autoload, Module#autoload?.
* variable.c (rb_autoload, rb_autoload_load, rb_autoload_p):
manage autoload constants per classes/modules.
* variable.c (rb_const_defined_at, rb_const_defined): return false
for autoloading constants.
* class.c (rb_define_class, rb_define_module), eval.c (rb_eval),
variable.c (rb_mod_const_at, rb_const_assign): removed autoload
stuff.
* intern.h: prototypes; rb_autoload, rb_autoload_load,
rb_autoload_p.
* lib/optparse.rb (OptionParser::Switch::PlacedArgument::parse):
do not treat unmatched argument as an option.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@3874 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2003-05-28 20:11:11 -04:00
|
|
|
continue;
|
|
|
|
}
|
2003-07-09 18:28:42 -04:00
|
|
|
if (exclude && tmp == rb_cObject && klass != rb_cObject) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_warn("toplevel constant %"PRIsVALUE" referenced by %"PRIsVALUE"::%"PRIsVALUE"",
|
|
|
|
QUOTE_ID(id), rb_class_name(klass), QUOTE_ID(id));
|
2003-07-09 18:28:42 -04:00
|
|
|
}
|
1998-01-16 07:13:05 -05:00
|
|
|
return value;
|
|
|
|
}
|
2011-06-29 01:20:37 -04:00
|
|
|
if (!recurse) break;
|
2007-09-28 02:21:46 -04:00
|
|
|
tmp = RCLASS_SUPER(tmp);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
2006-12-31 10:02:22 -05:00
|
|
|
if (!exclude && !mod_retry && BUILTIN_TYPE(klass) == T_MODULE) {
|
|
|
|
mod_retry = 1;
|
|
|
|
tmp = rb_cObject;
|
|
|
|
goto retry;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
2006-12-31 10:02:22 -05:00
|
|
|
|
2009-01-15 10:31:43 -05:00
|
|
|
value = const_missing(klass, id);
|
|
|
|
rb_vm_inc_const_missing_count();
|
|
|
|
return value;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2003-06-20 03:11:44 -04:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_const_get_from(VALUE klass, ID id)
|
2003-06-20 03:11:44 -04:00
|
|
|
{
|
2011-01-28 12:57:27 -05:00
|
|
|
return rb_const_get_0(klass, id, TRUE, TRUE, FALSE);
|
2003-06-20 03:11:44 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_const_get(VALUE klass, ID id)
|
2003-06-20 03:11:44 -04:00
|
|
|
{
|
2011-01-28 12:57:27 -05:00
|
|
|
return rb_const_get_0(klass, id, FALSE, TRUE, FALSE);
|
2003-08-28 04:35:43 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_const_get_at(VALUE klass, ID id)
|
2003-08-28 04:35:43 -04:00
|
|
|
{
|
2011-01-28 12:57:27 -05:00
|
|
|
return rb_const_get_0(klass, id, TRUE, FALSE, FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_public_const_get_from(VALUE klass, ID id)
|
|
|
|
{
|
|
|
|
return rb_const_get_0(klass, id, TRUE, TRUE, TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_public_const_get(VALUE klass, ID id)
|
|
|
|
{
|
|
|
|
return rb_const_get_0(klass, id, FALSE, TRUE, TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_public_const_get_at(VALUE klass, ID id)
|
|
|
|
{
|
|
|
|
return rb_const_get_0(klass, id, TRUE, FALSE, TRUE);
|
2003-06-20 03:11:44 -04:00
|
|
|
}
|
|
|
|
|
2003-12-28 01:33:07 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* remove_const(sym) -> obj
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 01:33:07 -05:00
|
|
|
* Removes the definition of the given constant, returning that
|
2012-03-14 00:48:02 -04:00
|
|
|
* constant's previous value. If that constant referred to
|
|
|
|
* a module, this will not change that module's name and can lead
|
|
|
|
* to confusion.
|
2003-12-28 01:33:07 -05:00
|
|
|
*/
|
|
|
|
|
1999-01-19 23:59:39 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_mod_remove_const(VALUE mod, VALUE name)
|
1999-01-19 23:59:39 -05:00
|
|
|
{
|
2011-07-26 12:05:27 -04:00
|
|
|
const ID id = rb_check_id(&name);
|
1999-01-19 23:59:39 -05:00
|
|
|
|
2011-07-23 11:05:03 -04:00
|
|
|
if (!id) {
|
|
|
|
if (rb_is_const_name(name)) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error_str(name, "constant %"PRIsVALUE"::%"PRIsVALUE" not defined",
|
|
|
|
rb_class_name(mod), name);
|
2011-07-23 11:05:03 -04:00
|
|
|
}
|
|
|
|
else {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error_str(name, "`%"PRIsVALUE"' is not allowed as a constant name",
|
2012-12-27 11:45:36 -05:00
|
|
|
QUOTE(name));
|
2011-07-23 11:05:03 -04:00
|
|
|
}
|
|
|
|
}
|
1999-12-14 01:50:43 -05:00
|
|
|
if (!rb_is_const_id(id)) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error(id, "`%"PRIsVALUE"' is not allowed as a constant name",
|
|
|
|
QUOTE_ID(id));
|
1999-01-19 23:59:39 -05:00
|
|
|
}
|
2010-03-11 17:15:11 -05:00
|
|
|
return rb_const_remove(mod, id);
|
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_const_remove(VALUE mod, ID id)
|
|
|
|
{
|
|
|
|
VALUE val;
|
|
|
|
st_data_t v, n = id;
|
|
|
|
|
* array.c, gc.c, hash.c, object.c, string.c, struct.c,
transcode.c, variable.c, vm.c, vm_insnhelper.c, vm_method.c:
replace calls to rb_error_frozen() with rb_check_frozen(). a
patch from Run Paint Run Run at [ruby-core:32014]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@29583 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2010-10-24 04:14:05 -04:00
|
|
|
rb_check_frozen(mod);
|
2010-10-26 13:27:21 -04:00
|
|
|
if (!RCLASS_CONST_TBL(mod) || !st_delete(RCLASS_CONST_TBL(mod), &n, &v)) {
|
2009-09-13 09:18:35 -04:00
|
|
|
if (rb_const_defined_at(mod, id)) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error(id, "cannot remove %"PRIsVALUE"::%"PRIsVALUE"",
|
|
|
|
rb_class_name(mod), QUOTE_ID(id));
|
2003-05-29 17:21:23 -04:00
|
|
|
}
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error(id, "constant %"PRIsVALUE"::%"PRIsVALUE" not defined",
|
|
|
|
rb_class_name(mod), QUOTE_ID(id));
|
1999-01-19 23:59:39 -05:00
|
|
|
}
|
2009-09-13 09:18:35 -04:00
|
|
|
|
* insns.def, vm.c, vm_insnhelper.c, vm_insnhelper.h, vm_method.c: split
ruby_vm_global_state_version into two separate counters - one for the
global method state and one for the global constant state. This means
changes to constants do not affect method caches, and changes to
methods do not affect constant caches. In particular, this means
inclusions of modules containing constants no longer globally
invalidate the method cache.
* class.c, eval.c, include/ruby/intern.h, insns.def, vm.c, vm_method.c:
rename rb_clear_cache_by_class to rb_clear_method_cache_by_class
* class.c, include/ruby/intern.h, variable.c, vm_method.c: add
rb_clear_constant_cache
* compile.c, vm_core.h, vm_insnhelper.c: rename vmstat field in
rb_call_info_struct to method_state
* vm_method.c: rename vmstat field in struct cache_entry to method_state
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@43455 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-10-28 20:52:38 -04:00
|
|
|
rb_clear_constant_cache();
|
2009-09-13 09:18:35 -04:00
|
|
|
|
2010-10-26 13:27:32 -04:00
|
|
|
val = ((rb_const_entry_t*)v)->value;
|
2009-09-13 09:18:35 -04:00
|
|
|
if (val == Qundef) {
|
|
|
|
autoload_delete(mod, id);
|
|
|
|
val = Qnil;
|
1999-01-19 23:59:39 -05:00
|
|
|
}
|
2010-10-26 13:27:32 -04:00
|
|
|
xfree((rb_const_entry_t*)v);
|
2009-09-13 09:18:35 -04:00
|
|
|
return val;
|
1999-01-19 23:59:39 -05:00
|
|
|
}
|
|
|
|
|
1998-01-16 07:19:22 -05:00
|
|
|
static int
|
2012-03-30 18:40:54 -04:00
|
|
|
sv_i(st_data_t k, st_data_t v, st_data_t a)
|
2001-06-05 03:19:39 -04:00
|
|
|
{
|
2012-03-30 18:40:54 -04:00
|
|
|
ID key = (ID)k;
|
|
|
|
rb_const_entry_t *ce = (rb_const_entry_t *)v;
|
|
|
|
st_table *tbl = (st_table *)a;
|
|
|
|
|
2001-06-05 03:19:39 -04:00
|
|
|
if (rb_is_const_id(key)) {
|
2009-07-30 03:10:51 -04:00
|
|
|
if (!st_lookup(tbl, (st_data_t)key, 0)) {
|
2011-01-28 12:57:48 -05:00
|
|
|
st_insert(tbl, (st_data_t)key, (st_data_t)ce);
|
2001-06-05 03:19:39 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return ST_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void*
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_mod_const_at(VALUE mod, void *data)
|
1998-01-16 07:19:22 -05:00
|
|
|
{
|
2001-06-05 03:19:39 -04:00
|
|
|
st_table *tbl = data;
|
|
|
|
if (!tbl) {
|
|
|
|
tbl = st_init_numtable();
|
|
|
|
}
|
2010-10-26 13:27:21 -04:00
|
|
|
if (RCLASS_CONST_TBL(mod)) {
|
|
|
|
st_foreach_safe(RCLASS_CONST_TBL(mod), sv_i, (st_data_t)tbl);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
2001-06-05 03:19:39 -04:00
|
|
|
return tbl;
|
1998-01-16 07:19:22 -05:00
|
|
|
}
|
|
|
|
|
2001-06-05 03:19:39 -04:00
|
|
|
void*
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_mod_const_of(VALUE mod, void *data)
|
1998-01-16 07:19:22 -05:00
|
|
|
{
|
2003-07-03 07:02:53 -04:00
|
|
|
VALUE tmp = mod;
|
1998-01-16 07:19:22 -05:00
|
|
|
for (;;) {
|
2003-07-03 07:02:53 -04:00
|
|
|
data = rb_mod_const_at(tmp, data);
|
2007-09-28 02:21:46 -04:00
|
|
|
tmp = RCLASS_SUPER(tmp);
|
2003-07-03 07:02:53 -04:00
|
|
|
if (!tmp) break;
|
|
|
|
if (tmp == rb_cObject && mod != rb_cObject) break;
|
1998-01-16 07:19:22 -05:00
|
|
|
}
|
2001-06-05 03:19:39 -04:00
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2011-01-28 12:57:48 -05:00
|
|
|
list_i(st_data_t key, st_data_t value, VALUE ary)
|
2001-06-05 03:19:39 -04:00
|
|
|
{
|
2011-01-28 12:57:48 -05:00
|
|
|
ID sym = (ID)key;
|
|
|
|
rb_const_entry_t *ce = (rb_const_entry_t *)value;
|
|
|
|
if (ce->flag != CONST_PRIVATE) rb_ary_push(ary, ID2SYM(sym));
|
2001-06-05 03:19:39 -04:00
|
|
|
return ST_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_const_list(void *data)
|
2001-06-05 03:19:39 -04:00
|
|
|
{
|
|
|
|
st_table *tbl = data;
|
|
|
|
VALUE ary;
|
|
|
|
|
|
|
|
if (!tbl) return rb_ary_new2(0);
|
|
|
|
ary = rb_ary_new2(tbl->num_entries);
|
2004-09-29 01:15:33 -04:00
|
|
|
st_foreach_safe(tbl, list_i, ary);
|
2002-03-20 06:15:19 -05:00
|
|
|
st_free_table(tbl);
|
2001-06-05 03:19:39 -04:00
|
|
|
|
1998-01-16 07:19:22 -05:00
|
|
|
return ary;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2003-12-28 01:33:07 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* mod.constants(inherit=true) -> array
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 01:33:07 -05:00
|
|
|
* Returns an array of the names of the constants accessible in
|
|
|
|
* <i>mod</i>. This includes the names of constants in any included
|
2012-07-19 02:41:47 -04:00
|
|
|
* modules (example at start of section), unless the <i>inherit</i>
|
2006-12-04 10:19:33 -05:00
|
|
|
* parameter is set to <code>false</code>.
|
|
|
|
*
|
2010-05-17 17:07:33 -04:00
|
|
|
* IO.constants.include?(:SYNC) #=> true
|
|
|
|
* IO.constants(false).include?(:SYNC) #=> false
|
2006-12-04 10:19:33 -05:00
|
|
|
*
|
|
|
|
* Also see <code>Module::const_defined?</code>.
|
2003-12-28 01:33:07 -05:00
|
|
|
*/
|
|
|
|
|
1999-11-17 02:30:37 -05:00
|
|
|
VALUE
|
2006-12-04 10:19:33 -05:00
|
|
|
rb_mod_constants(int argc, VALUE *argv, VALUE mod)
|
1999-11-17 02:30:37 -05:00
|
|
|
{
|
2006-12-04 10:19:33 -05:00
|
|
|
VALUE inherit;
|
|
|
|
st_table *tbl;
|
|
|
|
|
|
|
|
if (argc == 0) {
|
|
|
|
inherit = Qtrue;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
rb_scan_args(argc, argv, "01", &inherit);
|
|
|
|
}
|
|
|
|
if (RTEST(inherit)) {
|
|
|
|
tbl = rb_mod_const_of(mod, 0);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
tbl = rb_mod_const_at(mod, 0);
|
|
|
|
}
|
|
|
|
return rb_const_list(tbl);
|
1999-11-17 02:30:37 -05:00
|
|
|
}
|
|
|
|
|
2003-08-29 20:04:02 -04:00
|
|
|
static int
|
2011-01-28 12:57:27 -05:00
|
|
|
rb_const_defined_0(VALUE klass, ID id, int exclude, int recurse, int visibility)
|
2003-06-20 03:11:44 -04:00
|
|
|
{
|
2009-07-30 03:10:51 -04:00
|
|
|
st_data_t value;
|
|
|
|
VALUE tmp;
|
2006-12-31 10:02:22 -05:00
|
|
|
int mod_retry = 0;
|
2003-06-20 03:11:44 -04:00
|
|
|
|
2003-10-01 23:00:23 -04:00
|
|
|
tmp = klass;
|
|
|
|
retry:
|
2003-06-20 03:11:44 -04:00
|
|
|
while (tmp) {
|
2010-10-26 13:27:21 -04:00
|
|
|
if (RCLASS_CONST_TBL(tmp) && st_lookup(RCLASS_CONST_TBL(tmp), (st_data_t)id, &value)) {
|
2011-01-28 12:57:27 -05:00
|
|
|
rb_const_entry_t *ce = (rb_const_entry_t *)value;
|
|
|
|
if (visibility && ce->flag == CONST_PRIVATE) {
|
|
|
|
return (int)Qfalse;
|
|
|
|
}
|
2011-08-31 04:28:19 -04:00
|
|
|
if (ce->value == Qundef && !check_autoload_required(tmp, id, 0) && !rb_autoloading_value(tmp, id, 0))
|
2009-09-22 09:11:21 -04:00
|
|
|
return (int)Qfalse;
|
|
|
|
return (int)Qtrue;
|
2003-06-20 03:11:44 -04:00
|
|
|
}
|
2011-06-30 14:34:09 -04:00
|
|
|
if (!recurse) break;
|
2007-09-28 02:21:46 -04:00
|
|
|
tmp = RCLASS_SUPER(tmp);
|
2003-06-20 03:11:44 -04:00
|
|
|
}
|
2006-12-31 10:02:22 -05:00
|
|
|
if (!exclude && !mod_retry && BUILTIN_TYPE(klass) == T_MODULE) {
|
|
|
|
mod_retry = 1;
|
|
|
|
tmp = rb_cObject;
|
|
|
|
goto retry;
|
2003-08-29 20:04:02 -04:00
|
|
|
}
|
2009-09-22 09:11:21 -04:00
|
|
|
return (int)Qfalse;
|
2003-06-20 03:11:44 -04:00
|
|
|
}
|
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
int
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_const_defined_from(VALUE klass, ID id)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2011-01-28 12:57:27 -05:00
|
|
|
return rb_const_defined_0(klass, id, TRUE, TRUE, FALSE);
|
2003-08-29 20:04:02 -04:00
|
|
|
}
|
1999-01-19 23:59:39 -05:00
|
|
|
|
2003-08-29 20:04:02 -04:00
|
|
|
int
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_const_defined(VALUE klass, ID id)
|
2003-08-29 20:04:02 -04:00
|
|
|
{
|
2011-01-28 12:57:27 -05:00
|
|
|
return rb_const_defined_0(klass, id, FALSE, TRUE, FALSE);
|
2003-08-29 20:04:02 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_const_defined_at(VALUE klass, ID id)
|
2003-08-29 20:04:02 -04:00
|
|
|
{
|
2011-01-28 12:57:27 -05:00
|
|
|
return rb_const_defined_0(klass, id, TRUE, FALSE, FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
rb_public_const_defined_from(VALUE klass, ID id)
|
|
|
|
{
|
|
|
|
return rb_const_defined_0(klass, id, TRUE, TRUE, TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
rb_public_const_defined(VALUE klass, ID id)
|
|
|
|
{
|
|
|
|
return rb_const_defined_0(klass, id, FALSE, TRUE, TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
rb_public_const_defined_at(VALUE klass, ID id)
|
|
|
|
{
|
|
|
|
return rb_const_defined_0(klass, id, TRUE, FALSE, TRUE);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2011-08-02 23:47:10 -04:00
|
|
|
static void
|
2010-10-26 13:27:21 -04:00
|
|
|
check_before_mod_set(VALUE klass, ID id, VALUE val, const char *dest)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
* array.c, gc.c, hash.c, object.c, string.c, struct.c,
transcode.c, variable.c, vm.c, vm_insnhelper.c, vm_method.c:
replace calls to rb_error_frozen() with rb_check_frozen(). a
patch from Run Paint Run Run at [ruby-core:32014]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@29583 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2010-10-24 04:14:05 -04:00
|
|
|
rb_check_frozen(klass);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
2000-12-08 02:10:38 -05:00
|
|
|
|
2000-02-18 01:59:36 -05:00
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_const_set(VALUE klass, ID id, VALUE val)
|
2000-02-18 01:59:36 -05:00
|
|
|
{
|
2010-10-26 13:27:32 -04:00
|
|
|
rb_const_entry_t *ce;
|
2013-06-07 10:22:53 -04:00
|
|
|
rb_const_flag_t visibility = CONST_PUBLIC;
|
2010-10-26 13:27:32 -04:00
|
|
|
|
* sprintf.c (rb_str_format): allow %c to print one character
string (e.g. ?x).
* lib/tempfile.rb (Tempfile::make_tmpname): put dot between
basename and pid. [ruby-talk:196272]
* parse.y (do_block): remove -> style block.
* parse.y (parser_yylex): remove tLAMBDA_ARG.
* eval.c (rb_call0): binding for the return event hook should have
consistent scope. [ruby-core:07928]
* eval.c (proc_invoke): return behavior should depend whether it
is surrounded by a lambda or a mere block.
* eval.c (formal_assign): handles post splat arguments.
* eval.c (rb_call0): ditto.
* st.c (strhash): use FNV-1a hash.
* parse.y (parser_yylex): removed experimental ';;' terminator.
* eval.c (rb_node_arity): should be aware of post splat arguments.
* eval.c (rb_proc_arity): ditto.
* parse.y (f_args): syntax rule enhanced to support arguments
after the splat.
* parse.y (block_param): ditto for block parameters.
* parse.y (f_post_arg): mandatory formal arguments after the splat
argument.
* parse.y (new_args_gen): generate nodes for mandatory formal
arguments after the splat argument.
* eval.c (rb_eval): dispatch mandatory formal arguments after the
splat argument.
* parse.y (args): allow more than one splat in the argument list.
* parse.y (method_call): allow aref [] to accept all kind of
method argument, including assocs, splat, and block argument.
* eval.c (SETUP_ARGS0): prepare block argument as well.
* lib/mathn.rb (Integer): remove Integer#gcd2. [ruby-core:07931]
* eval.c (error_line): print receivers true/false/nil specially.
* eval.c (rb_proc_yield): handles parameters in yield semantics.
* eval.c (nil_yield): gives LocalJumpError to denote no block
error.
* io.c (rb_io_getc): now takes one-character string.
* string.c (rb_str_hash): use FNV-1a hash from Fowler/Noll/Vo
hashing algorithm.
* string.c (rb_str_aref): str[0] now returns 1 character string,
instead of a fixnum. [Ruby2]
* parse.y (parser_yylex): ?c now returns 1 character string,
instead of a fixnum. [Ruby2]
* string.c (rb_str_aset): no longer support fixnum insertion.
* eval.c (umethod_bind): should not update original class.
[ruby-dev:28636]
* eval.c (ev_const_get): should support constant access from
within instance_eval(). [ruby-dev:28327]
* time.c (time_timeval): should round for usec floating
number. [ruby-core:07896]
* time.c (time_add): ditto.
* dir.c (sys_warning): should not call a vararg function
rb_sys_warning() indirectly. [ruby-core:07886]
* numeric.c (flo_divmod): the first element of Float#divmod should
be an integer. [ruby-dev:28589]
* test/ruby/test_float.rb: add tests for divmod, div, modulo and remainder.
* re.c (rb_reg_initialize): should not allow modifying literal
regexps. frozen check moved from rb_reg_initialize_m as well.
* re.c (rb_reg_initialize): should not modify untainted objects in
safe levels higher than 3.
* re.c (rb_memcmp): type change from char* to const void*.
* dir.c (dir_close): should not close untainted dir stream.
* dir.c (GetDIR): add tainted/frozen check for each dir operation.
* lib/rdoc/parsers/parse_rb.rb (RDoc::RubyParser::parse_symbol_arg):
typo fixed. a patch from Florian Gross <florg at florg.net>.
* eval.c (EXEC_EVENT_HOOK): trace_func may remove itself from
event_hooks. no guarantee for arbitrary hook deletion.
[ruby-dev:28632]
* util.c (ruby_strtod): differ addition to minimize error.
[ruby-dev:28619]
* util.c (ruby_strtod): should not raise ERANGE when the input
string does not have any digits. [ruby-dev:28629]
* eval.c (proc_invoke): should restore old ruby_frame->block.
thanks to ts <decoux at moulon.inra.fr>. [ruby-core:07833]
also fix [ruby-dev:28614] as well.
* signal.c (trap): sig should be less then NSIG. Coverity found
this bug. a patch from Kevin Tew <tewk at tewk.com>.
[ruby-core:07823]
* math.c (math_log2): add new method inspired by
[ruby-talk:191237].
* math.c (math_log): add optional base argument to Math::log().
[ruby-talk:191308]
* ext/syck/emitter.c (syck_scan_scalar): avoid accessing
uninitialized array element. a patch from Pat Eyler
<rubypate at gmail.com>. [ruby-core:07809]
* array.c (rb_ary_fill): initialize local variables first. a
patch from Pat Eyler <rubypate at gmail.com>. [ruby-core:07810]
* ext/syck/yaml2byte.c (syck_yaml2byte_handler): need to free
type_tag. a patch from Pat Eyler <rubypate at gmail.com>.
[ruby-core:07808]
* ext/socket/socket.c (make_hostent_internal): accept ai_family
check from Sam Roberts <sroberts at uniserve.com>.
[ruby-core:07691]
* util.c (ruby_strtod): should not cut off 18 digits for no
reason. [ruby-core:07796]
* array.c (rb_ary_fill): internalize local variable "beg" to
pacify Coverity. [ruby-core:07770]
* pack.c (pack_unpack): now supports CRLF newlines. a patch from
<tommy at tmtm.org>. [ruby-dev:28601]
* applied code clean-up patch from Stefan Huehner
<stefan at huehner.org>. [ruby-core:07764]
* lib/jcode.rb (String::tr_s): should have translated non
squeezing character sequence (i.e. a character) as well. thanks
to Hiroshi Ichikawa <gimite at gimite.ddo.jp> [ruby-list:42090]
* ext/socket/socket.c: document update patch from Sam Roberts
<sroberts at uniserve.com>. [ruby-core:07701]
* lib/mathn.rb (Integer): need not to remove gcd2. a patch from
NARUSE, Yui <naruse at airemix.com>. [ruby-dev:28570]
* parse.y (arg): too much NEW_LIST()
* eval.c (SETUP_ARGS0): remove unnecessary access to nd_alen.
* eval.c (rb_eval): use ARGSCAT for NODE_OP_ASGN1.
[ruby-dev:28585]
* parse.y (arg): use NODE_ARGSCAT for placeholder.
* lib/getoptlong.rb (GetoptLong::get): RDoc update patch from
mathew <meta at pobox.com>. [ruby-core:07738]
* variable.c (rb_const_set): raise error when no target klass is
supplied. [ruby-dev:28582]
* prec.c (prec_prec_f): documentation patch from
<gerardo.santana at gmail.com>. [ruby-core:07689]
* bignum.c (rb_big_pow): second operand may be too big even if
it's a Fixnum. [ruby-talk:187984]
* README.EXT: update symbol description. [ruby-talk:188104]
* COPYING: explicitly note GPLv2. [ruby-talk:187922]
* parse.y: remove some obsolete syntax rules (unparenthesized
method calls in argument list).
* eval.c (rb_call0): insecure calling should be checked for non
NODE_SCOPE method invocations too.
* eval.c (rb_alias): should preserve the current safe level as
well as method definition.
* process.c (rb_f_sleep): remove RDoc description about SIGALRM
which is not valid on the current implementation. [ruby-dev:28464]
Thu Mar 23 21:40:47 2006 K.Kosako <sndgk393 AT ybb.ne.jp>
* eval.c (method_missing): should support argument splat in
super. a bug in combination of super, splat and
method_missing. [ruby-talk:185438]
* configure.in: Solaris SunPro compiler -rapth patch from
<kuwa at labs.fujitsu.com>. [ruby-dev:28443]
* configure.in: remove enable_rpath=no for Solaris.
[ruby-dev:28440]
* ext/win32ole/win32ole.c (ole_val2olevariantdata): change behavior
of converting OLE Variant object with VT_ARRAY|VT_UI1 and Ruby
String object.
* ruby.1: a clarification patch from David Lutterkort
<dlutter at redhat.com>. [ruby-core:7508]
* lib/rdoc/ri/ri_paths.rb (RI::Paths): adding paths from rubygems
directories. a patch from Eric Hodel <drbrain at segment7.net>.
[ruby-core:07423]
* eval.c (rb_clear_cache_by_class): clearing wrong cache.
* ext/extmk.rb: use :remove_destination to install extension libraries
to avoid SEGV. [ruby-dev:28417]
* eval.c (rb_thread_fd_writable): should not re-schedule output
from KILLED thread (must be error printing).
* array.c (rb_ary_flatten_bang): allow specifying recursion
level. [ruby-talk:182170]
* array.c (rb_ary_flatten): ditto.
* gc.c (add_heap): a heap_slots may overflow. a patch from Stefan
Weil <weil at mail.berlios.de>.
* eval.c (rb_call): use separate cache for fcall/vcall
invocation.
* eval.c (rb_eval): NODE_FCALL, NODE_VCALL can call local
functions.
* eval.c (rb_mod_local): a new method to specify newly added
visibility "local".
* eval.c (search_method): search for local methods which are
visible only from the current class.
* class.c (rb_class_local_methods): a method to list local methods.
* object.c (Init_Object): add BasicObject class as a top level
BlankSlate class.
* ruby.h (SYM2ID): should not cast to signed long.
[ruby-core:07414]
* class.c (rb_include_module): allow module duplication.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@10235 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2006-06-09 17:20:17 -04:00
|
|
|
if (NIL_P(klass)) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_raise(rb_eTypeError, "no class/module to define constant %"PRIsVALUE"",
|
|
|
|
QUOTE_ID(id));
|
* sprintf.c (rb_str_format): allow %c to print one character
string (e.g. ?x).
* lib/tempfile.rb (Tempfile::make_tmpname): put dot between
basename and pid. [ruby-talk:196272]
* parse.y (do_block): remove -> style block.
* parse.y (parser_yylex): remove tLAMBDA_ARG.
* eval.c (rb_call0): binding for the return event hook should have
consistent scope. [ruby-core:07928]
* eval.c (proc_invoke): return behavior should depend whether it
is surrounded by a lambda or a mere block.
* eval.c (formal_assign): handles post splat arguments.
* eval.c (rb_call0): ditto.
* st.c (strhash): use FNV-1a hash.
* parse.y (parser_yylex): removed experimental ';;' terminator.
* eval.c (rb_node_arity): should be aware of post splat arguments.
* eval.c (rb_proc_arity): ditto.
* parse.y (f_args): syntax rule enhanced to support arguments
after the splat.
* parse.y (block_param): ditto for block parameters.
* parse.y (f_post_arg): mandatory formal arguments after the splat
argument.
* parse.y (new_args_gen): generate nodes for mandatory formal
arguments after the splat argument.
* eval.c (rb_eval): dispatch mandatory formal arguments after the
splat argument.
* parse.y (args): allow more than one splat in the argument list.
* parse.y (method_call): allow aref [] to accept all kind of
method argument, including assocs, splat, and block argument.
* eval.c (SETUP_ARGS0): prepare block argument as well.
* lib/mathn.rb (Integer): remove Integer#gcd2. [ruby-core:07931]
* eval.c (error_line): print receivers true/false/nil specially.
* eval.c (rb_proc_yield): handles parameters in yield semantics.
* eval.c (nil_yield): gives LocalJumpError to denote no block
error.
* io.c (rb_io_getc): now takes one-character string.
* string.c (rb_str_hash): use FNV-1a hash from Fowler/Noll/Vo
hashing algorithm.
* string.c (rb_str_aref): str[0] now returns 1 character string,
instead of a fixnum. [Ruby2]
* parse.y (parser_yylex): ?c now returns 1 character string,
instead of a fixnum. [Ruby2]
* string.c (rb_str_aset): no longer support fixnum insertion.
* eval.c (umethod_bind): should not update original class.
[ruby-dev:28636]
* eval.c (ev_const_get): should support constant access from
within instance_eval(). [ruby-dev:28327]
* time.c (time_timeval): should round for usec floating
number. [ruby-core:07896]
* time.c (time_add): ditto.
* dir.c (sys_warning): should not call a vararg function
rb_sys_warning() indirectly. [ruby-core:07886]
* numeric.c (flo_divmod): the first element of Float#divmod should
be an integer. [ruby-dev:28589]
* test/ruby/test_float.rb: add tests for divmod, div, modulo and remainder.
* re.c (rb_reg_initialize): should not allow modifying literal
regexps. frozen check moved from rb_reg_initialize_m as well.
* re.c (rb_reg_initialize): should not modify untainted objects in
safe levels higher than 3.
* re.c (rb_memcmp): type change from char* to const void*.
* dir.c (dir_close): should not close untainted dir stream.
* dir.c (GetDIR): add tainted/frozen check for each dir operation.
* lib/rdoc/parsers/parse_rb.rb (RDoc::RubyParser::parse_symbol_arg):
typo fixed. a patch from Florian Gross <florg at florg.net>.
* eval.c (EXEC_EVENT_HOOK): trace_func may remove itself from
event_hooks. no guarantee for arbitrary hook deletion.
[ruby-dev:28632]
* util.c (ruby_strtod): differ addition to minimize error.
[ruby-dev:28619]
* util.c (ruby_strtod): should not raise ERANGE when the input
string does not have any digits. [ruby-dev:28629]
* eval.c (proc_invoke): should restore old ruby_frame->block.
thanks to ts <decoux at moulon.inra.fr>. [ruby-core:07833]
also fix [ruby-dev:28614] as well.
* signal.c (trap): sig should be less then NSIG. Coverity found
this bug. a patch from Kevin Tew <tewk at tewk.com>.
[ruby-core:07823]
* math.c (math_log2): add new method inspired by
[ruby-talk:191237].
* math.c (math_log): add optional base argument to Math::log().
[ruby-talk:191308]
* ext/syck/emitter.c (syck_scan_scalar): avoid accessing
uninitialized array element. a patch from Pat Eyler
<rubypate at gmail.com>. [ruby-core:07809]
* array.c (rb_ary_fill): initialize local variables first. a
patch from Pat Eyler <rubypate at gmail.com>. [ruby-core:07810]
* ext/syck/yaml2byte.c (syck_yaml2byte_handler): need to free
type_tag. a patch from Pat Eyler <rubypate at gmail.com>.
[ruby-core:07808]
* ext/socket/socket.c (make_hostent_internal): accept ai_family
check from Sam Roberts <sroberts at uniserve.com>.
[ruby-core:07691]
* util.c (ruby_strtod): should not cut off 18 digits for no
reason. [ruby-core:07796]
* array.c (rb_ary_fill): internalize local variable "beg" to
pacify Coverity. [ruby-core:07770]
* pack.c (pack_unpack): now supports CRLF newlines. a patch from
<tommy at tmtm.org>. [ruby-dev:28601]
* applied code clean-up patch from Stefan Huehner
<stefan at huehner.org>. [ruby-core:07764]
* lib/jcode.rb (String::tr_s): should have translated non
squeezing character sequence (i.e. a character) as well. thanks
to Hiroshi Ichikawa <gimite at gimite.ddo.jp> [ruby-list:42090]
* ext/socket/socket.c: document update patch from Sam Roberts
<sroberts at uniserve.com>. [ruby-core:07701]
* lib/mathn.rb (Integer): need not to remove gcd2. a patch from
NARUSE, Yui <naruse at airemix.com>. [ruby-dev:28570]
* parse.y (arg): too much NEW_LIST()
* eval.c (SETUP_ARGS0): remove unnecessary access to nd_alen.
* eval.c (rb_eval): use ARGSCAT for NODE_OP_ASGN1.
[ruby-dev:28585]
* parse.y (arg): use NODE_ARGSCAT for placeholder.
* lib/getoptlong.rb (GetoptLong::get): RDoc update patch from
mathew <meta at pobox.com>. [ruby-core:07738]
* variable.c (rb_const_set): raise error when no target klass is
supplied. [ruby-dev:28582]
* prec.c (prec_prec_f): documentation patch from
<gerardo.santana at gmail.com>. [ruby-core:07689]
* bignum.c (rb_big_pow): second operand may be too big even if
it's a Fixnum. [ruby-talk:187984]
* README.EXT: update symbol description. [ruby-talk:188104]
* COPYING: explicitly note GPLv2. [ruby-talk:187922]
* parse.y: remove some obsolete syntax rules (unparenthesized
method calls in argument list).
* eval.c (rb_call0): insecure calling should be checked for non
NODE_SCOPE method invocations too.
* eval.c (rb_alias): should preserve the current safe level as
well as method definition.
* process.c (rb_f_sleep): remove RDoc description about SIGALRM
which is not valid on the current implementation. [ruby-dev:28464]
Thu Mar 23 21:40:47 2006 K.Kosako <sndgk393 AT ybb.ne.jp>
* eval.c (method_missing): should support argument splat in
super. a bug in combination of super, splat and
method_missing. [ruby-talk:185438]
* configure.in: Solaris SunPro compiler -rapth patch from
<kuwa at labs.fujitsu.com>. [ruby-dev:28443]
* configure.in: remove enable_rpath=no for Solaris.
[ruby-dev:28440]
* ext/win32ole/win32ole.c (ole_val2olevariantdata): change behavior
of converting OLE Variant object with VT_ARRAY|VT_UI1 and Ruby
String object.
* ruby.1: a clarification patch from David Lutterkort
<dlutter at redhat.com>. [ruby-core:7508]
* lib/rdoc/ri/ri_paths.rb (RI::Paths): adding paths from rubygems
directories. a patch from Eric Hodel <drbrain at segment7.net>.
[ruby-core:07423]
* eval.c (rb_clear_cache_by_class): clearing wrong cache.
* ext/extmk.rb: use :remove_destination to install extension libraries
to avoid SEGV. [ruby-dev:28417]
* eval.c (rb_thread_fd_writable): should not re-schedule output
from KILLED thread (must be error printing).
* array.c (rb_ary_flatten_bang): allow specifying recursion
level. [ruby-talk:182170]
* array.c (rb_ary_flatten): ditto.
* gc.c (add_heap): a heap_slots may overflow. a patch from Stefan
Weil <weil at mail.berlios.de>.
* eval.c (rb_call): use separate cache for fcall/vcall
invocation.
* eval.c (rb_eval): NODE_FCALL, NODE_VCALL can call local
functions.
* eval.c (rb_mod_local): a new method to specify newly added
visibility "local".
* eval.c (search_method): search for local methods which are
visible only from the current class.
* class.c (rb_class_local_methods): a method to list local methods.
* object.c (Init_Object): add BasicObject class as a top level
BlankSlate class.
* ruby.h (SYM2ID): should not cast to signed long.
[ruby-core:07414]
* class.c (rb_include_module): allow module duplication.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@10235 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2006-06-09 17:20:17 -04:00
|
|
|
}
|
2010-10-26 13:27:21 -04:00
|
|
|
|
|
|
|
check_before_mod_set(klass, id, val, "constant");
|
|
|
|
if (!RCLASS_CONST_TBL(klass)) {
|
|
|
|
RCLASS_CONST_TBL(klass) = st_init_numtable();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
st_data_t value;
|
|
|
|
|
|
|
|
if (st_lookup(RCLASS_CONST_TBL(klass), (st_data_t)id, &value)) {
|
2011-01-28 12:57:42 -05:00
|
|
|
rb_const_entry_t *ce = (rb_const_entry_t*)value;
|
2011-08-31 04:28:19 -04:00
|
|
|
if (ce->value == Qundef) {
|
|
|
|
VALUE load;
|
|
|
|
struct autoload_data_i *ele;
|
|
|
|
|
|
|
|
load = autoload_data(klass, id);
|
|
|
|
/* for autoloading thread, keep the defined value to autoloading storage */
|
|
|
|
if (load && (ele = check_autoload_data(load)) && (ele->thread == rb_thread_current())) {
|
* insns.def, vm.c, vm_insnhelper.c, vm_insnhelper.h, vm_method.c: split
ruby_vm_global_state_version into two separate counters - one for the
global method state and one for the global constant state. This means
changes to constants do not affect method caches, and changes to
methods do not affect constant caches. In particular, this means
inclusions of modules containing constants no longer globally
invalidate the method cache.
* class.c, eval.c, include/ruby/intern.h, insns.def, vm.c, vm_method.c:
rename rb_clear_cache_by_class to rb_clear_method_cache_by_class
* class.c, include/ruby/intern.h, variable.c, vm_method.c: add
rb_clear_constant_cache
* compile.c, vm_core.h, vm_insnhelper.c: rename vmstat field in
rb_call_info_struct to method_state
* vm_method.c: rename vmstat field in struct cache_entry to method_state
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@43455 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-10-28 20:52:38 -04:00
|
|
|
rb_clear_constant_cache();
|
* class.c, compile.c, eval.c, gc.h, insns.def, internal.h, method.h,
variable.c, vm.c, vm_core.c, vm_insnhelper.c, vm_insnhelper.h,
vm_method.c: Implement class hierarchy method cache invalidation.
[ruby-core:55053] [Feature #8426] [GH-387]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@42822 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-09-04 01:25:06 -04:00
|
|
|
|
2013-06-18 15:50:44 -04:00
|
|
|
ele->value = val; /* autoload_i is shady */
|
2011-08-31 04:28:19 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* otherwise, allow to override */
|
2010-10-26 13:27:21 -04:00
|
|
|
autoload_delete(klass, id);
|
2011-08-31 04:28:19 -04:00
|
|
|
}
|
2011-01-28 12:57:42 -05:00
|
|
|
else {
|
2012-12-22 10:04:57 -05:00
|
|
|
VALUE name = QUOTE_ID(id);
|
2011-01-28 12:57:42 -05:00
|
|
|
visibility = ce->flag;
|
2012-11-29 03:45:13 -05:00
|
|
|
if (klass == rb_cObject)
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_warn("already initialized constant %"PRIsVALUE"", name);
|
2012-11-29 03:45:13 -05:00
|
|
|
else
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_warn("already initialized constant %"PRIsVALUE"::%"PRIsVALUE"",
|
|
|
|
rb_class_name(klass), name);
|
2011-09-03 11:11:53 -04:00
|
|
|
if (!NIL_P(ce->file) && ce->line) {
|
|
|
|
rb_compile_warn(RSTRING_PTR(ce->file), ce->line,
|
2012-12-22 10:04:57 -05:00
|
|
|
"previous definition of %"PRIsVALUE" was here", name);
|
2011-09-03 11:11:53 -04:00
|
|
|
}
|
2011-01-28 12:57:42 -05:00
|
|
|
}
|
2010-10-26 13:27:21 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
* insns.def, vm.c, vm_insnhelper.c, vm_insnhelper.h, vm_method.c: split
ruby_vm_global_state_version into two separate counters - one for the
global method state and one for the global constant state. This means
changes to constants do not affect method caches, and changes to
methods do not affect constant caches. In particular, this means
inclusions of modules containing constants no longer globally
invalidate the method cache.
* class.c, eval.c, include/ruby/intern.h, insns.def, vm.c, vm_method.c:
rename rb_clear_cache_by_class to rb_clear_method_cache_by_class
* class.c, include/ruby/intern.h, variable.c, vm_method.c: add
rb_clear_constant_cache
* compile.c, vm_core.h, vm_insnhelper.c: rename vmstat field in
rb_call_info_struct to method_state
* vm_method.c: rename vmstat field in struct cache_entry to method_state
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@43455 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-10-28 20:52:38 -04:00
|
|
|
rb_clear_constant_cache();
|
* class.c, compile.c, eval.c, gc.h, insns.def, internal.h, method.h,
variable.c, vm.c, vm_core.c, vm_insnhelper.c, vm_insnhelper.h,
vm_method.c: Implement class hierarchy method cache invalidation.
[ruby-core:55053] [Feature #8426] [GH-387]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@42822 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-09-04 01:25:06 -04:00
|
|
|
|
2010-10-26 13:27:32 -04:00
|
|
|
|
|
|
|
ce = ALLOC(rb_const_entry_t);
|
2013-06-18 15:50:44 -04:00
|
|
|
MEMZERO(ce, rb_const_entry_t, 1);
|
2013-06-07 09:25:41 -04:00
|
|
|
ce->flag = visibility;
|
2011-09-03 11:11:53 -04:00
|
|
|
ce->line = rb_sourceline();
|
2010-10-26 13:27:32 -04:00
|
|
|
st_insert(RCLASS_CONST_TBL(klass), (st_data_t)id, (st_data_t)ce);
|
2013-06-21 15:52:40 -04:00
|
|
|
OBJ_WRITE(klass, &ce->value, val);
|
|
|
|
OBJ_WRITE(klass, &ce->file, rb_sourcefilename());
|
2000-02-18 01:59:36 -05:00
|
|
|
}
|
1998-01-16 07:13:05 -05:00
|
|
|
|
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_define_const(VALUE klass, const char *name, VALUE val)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
ID id = rb_intern(name);
|
1999-01-19 23:59:39 -05:00
|
|
|
|
2003-07-24 01:18:47 -04:00
|
|
|
if (!rb_is_const_id(id)) {
|
2006-12-10 21:49:37 -05:00
|
|
|
rb_warn("rb_define_const: invalid name `%s' for constant", name);
|
2003-07-24 01:18:47 -04:00
|
|
|
}
|
1999-12-14 01:50:43 -05:00
|
|
|
rb_const_set(klass, id, val);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_define_global_const(const char *name, VALUE val)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
1999-01-19 23:59:39 -05:00
|
|
|
rb_define_const(rb_cObject, name, val);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2010-10-26 13:27:44 -04:00
|
|
|
static void
|
|
|
|
set_const_visibility(VALUE mod, int argc, VALUE *argv, rb_const_flag_t flag)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
st_data_t v;
|
|
|
|
ID id;
|
|
|
|
|
2011-12-03 06:52:14 -05:00
|
|
|
if (argc == 0) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_warning("%"PRIsVALUE" with no argument is just ignored",
|
2013-05-24 22:24:33 -04:00
|
|
|
QUOTE_ID(rb_frame_callee()));
|
2013-05-24 22:28:51 -04:00
|
|
|
return;
|
2011-12-03 06:52:14 -05:00
|
|
|
}
|
|
|
|
|
2010-10-26 13:27:44 -04:00
|
|
|
for (i = 0; i < argc; i++) {
|
2011-07-26 12:05:35 -04:00
|
|
|
VALUE val = argv[i];
|
|
|
|
id = rb_check_id(&val);
|
|
|
|
if (!id) {
|
* class.c, compile.c, eval.c, gc.h, insns.def, internal.h, method.h,
variable.c, vm.c, vm_core.c, vm_insnhelper.c, vm_insnhelper.h,
vm_method.c: Implement class hierarchy method cache invalidation.
[ruby-core:55053] [Feature #8426] [GH-387]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@42822 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-09-04 01:25:06 -04:00
|
|
|
if (i > 0) {
|
* insns.def, vm.c, vm_insnhelper.c, vm_insnhelper.h, vm_method.c: split
ruby_vm_global_state_version into two separate counters - one for the
global method state and one for the global constant state. This means
changes to constants do not affect method caches, and changes to
methods do not affect constant caches. In particular, this means
inclusions of modules containing constants no longer globally
invalidate the method cache.
* class.c, eval.c, include/ruby/intern.h, insns.def, vm.c, vm_method.c:
rename rb_clear_cache_by_class to rb_clear_method_cache_by_class
* class.c, include/ruby/intern.h, variable.c, vm_method.c: add
rb_clear_constant_cache
* compile.c, vm_core.h, vm_insnhelper.c: rename vmstat field in
rb_call_info_struct to method_state
* vm_method.c: rename vmstat field in struct cache_entry to method_state
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@43455 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-10-28 20:52:38 -04:00
|
|
|
rb_clear_constant_cache();
|
* class.c, compile.c, eval.c, gc.h, insns.def, internal.h, method.h,
variable.c, vm.c, vm_core.c, vm_insnhelper.c, vm_insnhelper.h,
vm_method.c: Implement class hierarchy method cache invalidation.
[ruby-core:55053] [Feature #8426] [GH-387]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@42822 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-09-04 01:25:06 -04:00
|
|
|
}
|
|
|
|
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error_str(val, "constant %"PRIsVALUE"::%"PRIsVALUE" not defined",
|
|
|
|
rb_class_name(mod), QUOTE(val));
|
2011-07-26 12:05:35 -04:00
|
|
|
}
|
2011-12-08 09:47:19 -05:00
|
|
|
if (RCLASS_CONST_TBL(mod) &&
|
|
|
|
st_lookup(RCLASS_CONST_TBL(mod), (st_data_t)id, &v)) {
|
2010-10-26 13:27:44 -04:00
|
|
|
((rb_const_entry_t*)v)->flag = flag;
|
|
|
|
}
|
2011-12-08 09:47:19 -05:00
|
|
|
else {
|
* class.c, compile.c, eval.c, gc.h, insns.def, internal.h, method.h,
variable.c, vm.c, vm_core.c, vm_insnhelper.c, vm_insnhelper.h,
vm_method.c: Implement class hierarchy method cache invalidation.
[ruby-core:55053] [Feature #8426] [GH-387]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@42822 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-09-04 01:25:06 -04:00
|
|
|
if (i > 0) {
|
* insns.def, vm.c, vm_insnhelper.c, vm_insnhelper.h, vm_method.c: split
ruby_vm_global_state_version into two separate counters - one for the
global method state and one for the global constant state. This means
changes to constants do not affect method caches, and changes to
methods do not affect constant caches. In particular, this means
inclusions of modules containing constants no longer globally
invalidate the method cache.
* class.c, eval.c, include/ruby/intern.h, insns.def, vm.c, vm_method.c:
rename rb_clear_cache_by_class to rb_clear_method_cache_by_class
* class.c, include/ruby/intern.h, variable.c, vm_method.c: add
rb_clear_constant_cache
* compile.c, vm_core.h, vm_insnhelper.c: rename vmstat field in
rb_call_info_struct to method_state
* vm_method.c: rename vmstat field in struct cache_entry to method_state
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@43455 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-10-28 20:52:38 -04:00
|
|
|
rb_clear_constant_cache();
|
* class.c, compile.c, eval.c, gc.h, insns.def, internal.h, method.h,
variable.c, vm.c, vm_core.c, vm_insnhelper.c, vm_insnhelper.h,
vm_method.c: Implement class hierarchy method cache invalidation.
[ruby-core:55053] [Feature #8426] [GH-387]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@42822 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-09-04 01:25:06 -04:00
|
|
|
}
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error(id, "constant %"PRIsVALUE"::%"PRIsVALUE" not defined",
|
|
|
|
rb_class_name(mod), QUOTE_ID(id));
|
2011-12-08 09:47:19 -05:00
|
|
|
}
|
2010-10-26 13:27:44 -04:00
|
|
|
}
|
* insns.def, vm.c, vm_insnhelper.c, vm_insnhelper.h, vm_method.c: split
ruby_vm_global_state_version into two separate counters - one for the
global method state and one for the global constant state. This means
changes to constants do not affect method caches, and changes to
methods do not affect constant caches. In particular, this means
inclusions of modules containing constants no longer globally
invalidate the method cache.
* class.c, eval.c, include/ruby/intern.h, insns.def, vm.c, vm_method.c:
rename rb_clear_cache_by_class to rb_clear_method_cache_by_class
* class.c, include/ruby/intern.h, variable.c, vm_method.c: add
rb_clear_constant_cache
* compile.c, vm_core.h, vm_insnhelper.c: rename vmstat field in
rb_call_info_struct to method_state
* vm_method.c: rename vmstat field in struct cache_entry to method_state
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@43455 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-10-28 20:52:38 -04:00
|
|
|
rb_clear_constant_cache();
|
2010-10-26 13:27:44 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* mod.private_constant(symbol, ...) => mod
|
|
|
|
*
|
|
|
|
* Makes a list of existing constants private.
|
|
|
|
*/
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_mod_private_constant(int argc, VALUE *argv, VALUE obj)
|
|
|
|
{
|
|
|
|
set_const_visibility(obj, argc, argv, CONST_PRIVATE);
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* mod.public_constant(symbol, ...) => mod
|
|
|
|
*
|
|
|
|
* Makes a list of existing constants public.
|
|
|
|
*/
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_mod_public_constant(int argc, VALUE *argv, VALUE obj)
|
|
|
|
{
|
|
|
|
set_const_visibility(obj, argc, argv, CONST_PUBLIC);
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2007-10-03 02:48:06 -04:00
|
|
|
static VALUE
|
2007-12-24 04:25:27 -05:00
|
|
|
original_module(VALUE c)
|
2007-10-03 02:48:06 -04:00
|
|
|
{
|
2011-09-29 07:07:45 -04:00
|
|
|
if (RB_TYPE_P(c, T_ICLASS))
|
2007-10-03 02:48:06 -04:00
|
|
|
return RBASIC(c)->klass;
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
2012-08-06 11:24:01 -04:00
|
|
|
static int
|
|
|
|
cvar_lookup_at(VALUE klass, ID id, st_data_t *v)
|
|
|
|
{
|
|
|
|
if (!RCLASS_IV_TBL(klass)) return 0;
|
|
|
|
return st_lookup(RCLASS_IV_TBL(klass), (st_data_t)id, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
cvar_front_klass(VALUE klass)
|
|
|
|
{
|
|
|
|
if (FL_TEST(klass, FL_SINGLETON)) {
|
2013-05-02 03:54:17 -04:00
|
|
|
VALUE obj = rb_ivar_get(klass, id__attached__);
|
2012-08-06 11:24:01 -04:00
|
|
|
if (RB_TYPE_P(obj, T_MODULE) || RB_TYPE_P(obj, T_CLASS)) {
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return RCLASS_SUPER(klass);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define CVAR_FOREACH_ANCESTORS(klass, v, r) \
|
|
|
|
for (klass = cvar_front_klass(klass); klass; klass = RCLASS_SUPER(klass)) { \
|
|
|
|
if (cvar_lookup_at(klass, id, (v))) { \
|
|
|
|
r; \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
2007-02-02 04:47:55 -05:00
|
|
|
#define CVAR_LOOKUP(v,r) do {\
|
2012-08-06 11:24:01 -04:00
|
|
|
if (cvar_lookup_at(klass, id, (v))) {r;}\
|
|
|
|
CVAR_FOREACH_ANCESTORS(klass, v, r);\
|
2007-02-02 04:47:55 -05:00
|
|
|
} while(0)
|
|
|
|
|
2007-11-09 03:14:42 -05:00
|
|
|
void
|
|
|
|
rb_cvar_set(VALUE klass, ID id, VALUE val)
|
|
|
|
{
|
|
|
|
VALUE tmp, front = 0, target = 0;
|
|
|
|
|
|
|
|
tmp = klass;
|
|
|
|
CVAR_LOOKUP(0, {if (!front) front = klass; target = klass;});
|
|
|
|
if (target) {
|
|
|
|
if (front && target != front) {
|
2009-07-30 03:10:51 -04:00
|
|
|
st_data_t did = id;
|
2007-11-09 03:14:42 -05:00
|
|
|
|
|
|
|
if (RTEST(ruby_verbose)) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_warning("class variable %"PRIsVALUE" of %"PRIsVALUE" is overtaken by %"PRIsVALUE"",
|
|
|
|
QUOTE_ID(id), rb_class_name(original_module(front)),
|
|
|
|
rb_class_name(original_module(target)));
|
2007-11-09 03:14:42 -05:00
|
|
|
}
|
|
|
|
if (BUILTIN_TYPE(front) == T_CLASS) {
|
|
|
|
st_delete(RCLASS_IV_TBL(front),&did,0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
target = tmp;
|
|
|
|
}
|
2010-10-26 13:27:21 -04:00
|
|
|
|
|
|
|
check_before_mod_set(target, id, val, "class variable");
|
|
|
|
if (!RCLASS_IV_TBL(target)) {
|
|
|
|
RCLASS_IV_TBL(target) = st_init_numtable();
|
|
|
|
}
|
|
|
|
|
2013-06-14 05:23:54 -04:00
|
|
|
rb_st_insert_id_and_value(target, RCLASS_IV_TBL(target), (st_data_t)id, (st_data_t)val);
|
2007-11-09 03:14:42 -05:00
|
|
|
}
|
|
|
|
|
2000-02-18 01:59:36 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_cvar_get(VALUE klass, ID id)
|
2000-02-18 01:59:36 -05:00
|
|
|
{
|
* compile.c (iseq_build_body), error.c (set_syserr, get_syserr),
(syserr_initialize), gc.c (define_final, rb_gc_copy_finalizer),
(run_final), hash.c (rb_hash_aref, rb_hash_lookup2),
(rb_hash_fetch_m, rb_hash_clear, rb_hash_aset, eql_i),
iseq.c (iseq_load, iseq_data_to_ary), marshal.c (r_symlink),
thread.c (rb_thread_local_aref),
variable.c (generic_ivar_remove, ivar_get, rb_const_get_0),
(rb_cvar_get), vm.c (rb_vm_check_redefinition_opt_method),
vm_insnhelper.c (vm_get_ev_const), vm_method.c (remove_method),
ext/iconv/iconv.c (map_charset): use st_data_t.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@29462 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2010-10-12 10:47:23 -04:00
|
|
|
VALUE tmp, front = 0, target = 0;
|
|
|
|
st_data_t value;
|
2000-02-18 01:59:36 -05:00
|
|
|
|
2007-02-02 04:47:55 -05:00
|
|
|
tmp = klass;
|
2007-10-03 02:48:06 -04:00
|
|
|
CVAR_LOOKUP(&value, {if (!front) front = klass; target = klass;});
|
|
|
|
if (!target) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error(id, "uninitialized class variable %"PRIsVALUE" in %"PRIsVALUE"",
|
|
|
|
QUOTE_ID(id), rb_class_name(tmp));
|
2007-10-03 02:48:06 -04:00
|
|
|
}
|
|
|
|
if (front && target != front) {
|
2009-07-30 03:10:51 -04:00
|
|
|
st_data_t did = id;
|
2007-10-03 02:48:06 -04:00
|
|
|
|
|
|
|
if (RTEST(ruby_verbose)) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_warning("class variable %"PRIsVALUE" of %"PRIsVALUE" is overtaken by %"PRIsVALUE"",
|
|
|
|
QUOTE_ID(id), rb_class_name(original_module(front)),
|
|
|
|
rb_class_name(original_module(target)));
|
2007-10-03 02:48:06 -04:00
|
|
|
}
|
|
|
|
if (BUILTIN_TYPE(front) == T_CLASS) {
|
|
|
|
st_delete(RCLASS_IV_TBL(front),&did,0);
|
|
|
|
}
|
|
|
|
}
|
* compile.c (iseq_build_body), error.c (set_syserr, get_syserr),
(syserr_initialize), gc.c (define_final, rb_gc_copy_finalizer),
(run_final), hash.c (rb_hash_aref, rb_hash_lookup2),
(rb_hash_fetch_m, rb_hash_clear, rb_hash_aset, eql_i),
iseq.c (iseq_load, iseq_data_to_ary), marshal.c (r_symlink),
thread.c (rb_thread_local_aref),
variable.c (generic_ivar_remove, ivar_get, rb_const_get_0),
(rb_cvar_get), vm.c (rb_vm_check_redefinition_opt_method),
vm_insnhelper.c (vm_get_ev_const), vm_method.c (remove_method),
ext/iconv/iconv.c (map_charset): use st_data_t.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@29462 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2010-10-12 10:47:23 -04:00
|
|
|
return (VALUE)value;
|
2000-02-18 01:59:36 -05:00
|
|
|
}
|
|
|
|
|
2000-12-08 02:10:38 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_cvar_defined(VALUE klass, ID id)
|
2000-02-18 01:59:36 -05:00
|
|
|
{
|
2007-02-02 04:47:55 -05:00
|
|
|
if (!klass) return Qfalse;
|
2007-10-03 02:48:06 -04:00
|
|
|
CVAR_LOOKUP(0,return Qtrue);
|
2000-02-18 01:59:36 -05:00
|
|
|
return Qfalse;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_cv_set(VALUE klass, const char *name, VALUE val)
|
2000-03-23 03:37:35 -05:00
|
|
|
{
|
2001-05-02 00:22:21 -04:00
|
|
|
ID id = rb_intern(name);
|
|
|
|
if (!rb_is_class_id(id)) {
|
2001-07-02 04:46:28 -04:00
|
|
|
rb_name_error(id, "wrong class variable name %s", name);
|
2001-05-02 00:22:21 -04:00
|
|
|
}
|
2007-02-02 04:41:47 -05:00
|
|
|
rb_cvar_set(klass, id, val);
|
2000-03-23 03:37:35 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_cv_get(VALUE klass, const char *name)
|
2000-03-23 03:37:35 -05:00
|
|
|
{
|
2001-05-02 00:22:21 -04:00
|
|
|
ID id = rb_intern(name);
|
|
|
|
if (!rb_is_class_id(id)) {
|
2001-07-02 04:46:28 -04:00
|
|
|
rb_name_error(id, "wrong class variable name %s", name);
|
2001-05-02 00:22:21 -04:00
|
|
|
}
|
|
|
|
return rb_cvar_get(klass, id);
|
2000-03-23 03:37:35 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_define_class_variable(VALUE klass, const char *name, VALUE val)
|
2000-02-18 01:59:36 -05:00
|
|
|
{
|
|
|
|
ID id = rb_intern(name);
|
|
|
|
|
2000-03-23 03:37:35 -05:00
|
|
|
if (!rb_is_class_id(id)) {
|
2001-07-02 04:46:28 -04:00
|
|
|
rb_name_error(id, "wrong class variable name %s", name);
|
2000-02-18 01:59:36 -05:00
|
|
|
}
|
2007-02-02 04:41:47 -05:00
|
|
|
rb_cvar_set(klass, id, val);
|
2000-02-18 01:59:36 -05:00
|
|
|
}
|
|
|
|
|
2000-09-15 02:00:30 -04:00
|
|
|
static int
|
2012-03-30 18:40:54 -04:00
|
|
|
cv_i(st_data_t k, st_data_t v, st_data_t a)
|
2000-09-15 02:00:30 -04:00
|
|
|
{
|
2012-03-30 18:40:54 -04:00
|
|
|
ID key = (ID)k;
|
2012-07-19 02:41:47 -04:00
|
|
|
st_table *tbl = (st_table *)a;
|
2012-03-30 18:40:54 -04:00
|
|
|
|
2000-09-15 02:00:30 -04:00
|
|
|
if (rb_is_class_id(key)) {
|
2012-07-19 02:41:47 -04:00
|
|
|
if (!st_lookup(tbl, (st_data_t)key, 0)) {
|
|
|
|
st_insert(tbl, (st_data_t)key, 0);
|
2000-09-15 02:00:30 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return ST_CONTINUE;
|
|
|
|
}
|
2012-08-23 03:45:46 -04:00
|
|
|
|
2012-07-19 02:41:47 -04:00
|
|
|
static void*
|
|
|
|
mod_cvar_at(VALUE mod, void *data)
|
|
|
|
{
|
|
|
|
st_table *tbl = data;
|
|
|
|
if (!tbl) {
|
|
|
|
tbl = st_init_numtable();
|
|
|
|
}
|
|
|
|
if (RCLASS_IV_TBL(mod)) {
|
|
|
|
st_foreach_safe(RCLASS_IV_TBL(mod), cv_i, (st_data_t)tbl);
|
|
|
|
}
|
|
|
|
return tbl;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void*
|
|
|
|
mod_cvar_of(VALUE mod, void *data)
|
|
|
|
{
|
|
|
|
VALUE tmp = mod;
|
|
|
|
for (;;) {
|
|
|
|
data = mod_cvar_at(tmp, data);
|
|
|
|
tmp = RCLASS_SUPER(tmp);
|
|
|
|
if (!tmp) break;
|
|
|
|
}
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cv_list_i(st_data_t key, st_data_t value, VALUE ary)
|
|
|
|
{
|
|
|
|
ID sym = (ID)key;
|
|
|
|
rb_ary_push(ary, ID2SYM(sym));
|
|
|
|
return ST_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
cvar_list(void *data)
|
|
|
|
{
|
|
|
|
st_table *tbl = data;
|
|
|
|
VALUE ary;
|
|
|
|
|
|
|
|
if (!tbl) return rb_ary_new2(0);
|
|
|
|
ary = rb_ary_new2(tbl->num_entries);
|
|
|
|
st_foreach_safe(tbl, cv_list_i, ary);
|
|
|
|
st_free_table(tbl);
|
|
|
|
|
|
|
|
return ary;
|
|
|
|
}
|
2000-09-15 02:00:30 -04:00
|
|
|
|
2003-12-28 01:33:07 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2012-07-19 02:41:47 -04:00
|
|
|
* mod.class_variables(inherit=true) -> array
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2004-06-26 02:17:20 -04:00
|
|
|
* Returns an array of the names of class variables in <i>mod</i>.
|
2012-07-19 02:41:47 -04:00
|
|
|
* This includes the names of class variables in any included
|
|
|
|
* modules, unless the <i>inherit</i> parameter is set to
|
|
|
|
* <code>false</code>.
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 01:33:07 -05:00
|
|
|
* class One
|
|
|
|
* @@var1 = 1
|
|
|
|
* end
|
|
|
|
* class Two < One
|
|
|
|
* @@var2 = 2
|
|
|
|
* end
|
2008-03-08 20:04:46 -05:00
|
|
|
* One.class_variables #=> [:@@var1]
|
2012-07-19 02:41:47 -04:00
|
|
|
* Two.class_variables #=> [:@@var2, :@@var1]
|
2003-12-28 01:33:07 -05:00
|
|
|
*/
|
|
|
|
|
2000-09-15 02:00:30 -04:00
|
|
|
VALUE
|
2012-07-19 02:41:47 -04:00
|
|
|
rb_mod_class_variables(int argc, VALUE *argv, VALUE mod)
|
2000-09-15 02:00:30 -04:00
|
|
|
{
|
2012-07-19 02:41:47 -04:00
|
|
|
VALUE inherit;
|
|
|
|
st_table *tbl;
|
2000-09-15 02:00:30 -04:00
|
|
|
|
2012-07-19 02:41:47 -04:00
|
|
|
if (argc == 0) {
|
|
|
|
inherit = Qtrue;
|
2000-09-15 02:00:30 -04:00
|
|
|
}
|
2012-07-19 02:41:47 -04:00
|
|
|
else {
|
|
|
|
rb_scan_args(argc, argv, "01", &inherit);
|
|
|
|
}
|
|
|
|
if (RTEST(inherit)) {
|
|
|
|
tbl = mod_cvar_of(mod, 0);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
tbl = mod_cvar_at(mod, 0);
|
|
|
|
}
|
|
|
|
return cvar_list(tbl);
|
2000-09-15 02:00:30 -04:00
|
|
|
}
|
|
|
|
|
2003-12-28 01:33:07 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* remove_class_variable(sym) -> obj
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 01:33:07 -05:00
|
|
|
* Removes the definition of the <i>sym</i>, returning that
|
|
|
|
* constant's value.
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 01:33:07 -05:00
|
|
|
* class Dummy
|
|
|
|
* @@var = 99
|
|
|
|
* puts @@var
|
|
|
|
* remove_class_variable(:@@var)
|
2008-10-09 09:07:28 -04:00
|
|
|
* p(defined? @@var)
|
2003-12-28 01:33:07 -05:00
|
|
|
* end
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 01:33:07 -05:00
|
|
|
* <em>produces:</em>
|
2009-02-14 21:45:31 -05:00
|
|
|
*
|
2003-12-28 01:33:07 -05:00
|
|
|
* 99
|
|
|
|
* nil
|
|
|
|
*/
|
|
|
|
|
2000-12-08 02:10:38 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_mod_remove_cvar(VALUE mod, VALUE name)
|
2000-12-08 02:10:38 -05:00
|
|
|
{
|
2011-07-26 12:05:27 -04:00
|
|
|
const ID id = rb_check_id(&name);
|
2008-10-09 09:07:28 -04:00
|
|
|
st_data_t val, n = id;
|
2000-12-08 02:10:38 -05:00
|
|
|
|
2011-07-23 11:05:03 -04:00
|
|
|
if (!id) {
|
|
|
|
if (rb_is_class_name(name)) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error_str(name, "class variable %"PRIsVALUE" not defined for %"PRIsVALUE"",
|
|
|
|
name, rb_class_name(mod));
|
2011-07-23 11:05:03 -04:00
|
|
|
}
|
|
|
|
else {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error_str(name, "wrong class variable name %"PRIsVALUE"", QUOTE(name));
|
2011-07-23 11:05:03 -04:00
|
|
|
}
|
|
|
|
}
|
2000-12-08 02:10:38 -05:00
|
|
|
if (!rb_is_class_id(id)) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error(id, "wrong class variable name %"PRIsVALUE"", QUOTE_ID(id));
|
2000-12-08 02:10:38 -05:00
|
|
|
}
|
* array.c, gc.c, hash.c, object.c, string.c, struct.c,
transcode.c, variable.c, vm.c, vm_insnhelper.c, vm_method.c:
replace calls to rb_error_frozen() with rb_check_frozen(). a
patch from Run Paint Run Run at [ruby-core:32014]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@29583 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2010-10-24 04:14:05 -04:00
|
|
|
rb_check_frozen(mod);
|
2008-10-07 22:23:04 -04:00
|
|
|
if (RCLASS_IV_TBL(mod) && st_delete(RCLASS_IV_TBL(mod), &n, &val)) {
|
|
|
|
return (VALUE)val;
|
2000-12-08 02:10:38 -05:00
|
|
|
}
|
|
|
|
if (rb_cvar_defined(mod, id)) {
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error(id, "cannot remove %"PRIsVALUE" for %"PRIsVALUE"",
|
|
|
|
QUOTE_ID(id), rb_class_name(mod));
|
2000-12-08 02:10:38 -05:00
|
|
|
}
|
2012-12-22 10:04:57 -05:00
|
|
|
rb_name_error(id, "class variable %"PRIsVALUE" not defined for %"PRIsVALUE"",
|
|
|
|
QUOTE_ID(id), rb_class_name(mod));
|
2012-04-13 20:36:26 -04:00
|
|
|
|
|
|
|
UNREACHABLE;
|
2000-12-08 02:10:38 -05:00
|
|
|
}
|
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_iv_get(VALUE obj, const char *name)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
ID id = rb_intern(name);
|
|
|
|
|
|
|
|
return rb_ivar_get(obj, id);
|
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_iv_set(VALUE obj, const char *name, VALUE val)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
|
|
|
ID id = rb_intern(name);
|
|
|
|
|
|
|
|
return rb_ivar_set(obj, id, val);
|
|
|
|
}
|
2013-06-14 05:23:54 -04:00
|
|
|
|
|
|
|
/* tbl = xx(obj); tbl[key] = value; */
|
|
|
|
int
|
|
|
|
rb_st_insert_id_and_value(VALUE obj, st_table *tbl, ID key, VALUE value)
|
|
|
|
{
|
|
|
|
int result = st_insert(tbl, (st_data_t)key, (st_data_t)value);
|
|
|
|
OBJ_WRITTEN(obj, Qundef, value);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tbl_copy_i(st_data_t key, st_data_t value, st_data_t data)
|
|
|
|
{
|
|
|
|
OBJ_WRITTEN((VALUE)data, Qundef, (VALUE)value);
|
|
|
|
return ST_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
st_table *
|
|
|
|
rb_st_copy(VALUE obj, struct st_table *orig_tbl)
|
|
|
|
{
|
|
|
|
st_table *new_tbl = st_copy(orig_tbl);
|
|
|
|
st_foreach(new_tbl, tbl_copy_i, (st_data_t)obj);
|
|
|
|
return new_tbl;
|
|
|
|
}
|