~ubuntu-branches/ubuntu/quantal/ruby1.9.1/quantal

  $Author: drbrain $

#include "constant.h"

#include "internal.h"

/*

 * Generates a <code>Fixnum</code> hash value for this object.

 * This function must have the property that a.eql?(b) implies

 * a.hash <code>==</code> b.hash.

 * The hash value is used by class <code>Hash</code>.

 * Any hash value that exceeds the capacity of a <code>Fixnum</code> will be

 * truncated before being used.

 *

 *      "waffle".hash #=> -910576647

 */

        if (RCLASS_CONST_TBL(dest)) {

            rb_free_const_table(RCLASS_CONST_TBL(dest));

            RCLASS_CONST_TBL(dest) = 0;

        }

    RBASIC(clone)->flags = (RBASIC(obj)->flags | FL_TEST(clone, FL_TAINT) | FL_TEST(clone, FL_UNTRUSTED)) & ~(FL_FREEZE|FL_FINALIZE|FL_MARK);

/* Document-method: method_added

 *

 * call-seq:

 *   method_added(method_name)

 *

 * Invoked as a callback whenever an instance method is added to the

 * receiver.

 *

 *   module Chatty

 *     def self.method_added(method_name)

 *       puts "Adding #{method_name.inspect}"

 *     end

 *     def self.some_class_method() end

 *     def some_instance_method() end

 *   end

 *

 * produces:

 *

 *   Adding :some_instance_method

 *

 */

 

/* Document-method: method_removed

 *

 * call-seq:

 *   method_removed(method_name)

 *

 * Invoked as a callback whenever an instance method is removed from the

 * receiver.

 *

 *   module Chatty

 *     def self.method_removed(method_name)

 *       puts "Removing #{method_name.inspect}"

 *     end

 *     def self.some_class_method() end

 *     def some_instance_method() end

 *     class << self

 *       remove_method :some_class_method

 *     end

 *     remove_method :some_instance_method

 *   end

 *

 * produces:

 *

 *   Removing :some_instance_method

 *

 */

 

 *    BasicObject.new

 * Returns a new BasicObject.

        rb_check_frozen(obj);

        rb_check_frozen(obj);

        rb_check_frozen(obj);

        rb_check_frozen(obj);

/*

 *  call-seq:

 *     obj <=> other -> 0 or nil

 *

 *  Returns 0 if obj === other, otherwise nil.

 */

 *     fred = Module.new do

 *     a.extend(fred)   #=> "my string"

 *

 *  Assign the module to a constant (name starting uppercase) if you

 *  want to treat it like a regular module.

 *     Class.new(super_class=Object)               -> a_class

 *     Class.new(super_class=Object) { |mod| ... } -> a_class

 *  If a block is given, it is passed the class object, and the block

 *  is evaluated in the context of this class using

 *  <code>class_eval</code>.

 *

 *     fred = Class.new do

 *       def meth1

 *         "hello"

 *       end

 *       def meth2

 *         "bye"

 *       end

 *     end

 *

 *     a = fred.new     #=> #<#<Class:0x100381890>:0x100376b98>

 *     a.meth1          #=> "hello"

 *     a.meth2          #=> "bye"

 *

 *  Assign the class to a constant (name starting uppercase) if you

 *  want to treat it like a regular class.

VALUE

VALUE

rb_class_get_superclass(VALUE klass)

{

    return RCLASS_SUPER(klass);

}

 

 *  Checks for a constant with the given name in <i>mod</i>

 *  If +inherit+ is set, the lookup will also search

 *  the ancestors (and +Object+ if <i>mod</i> is a +Module+.)

 *

 *  The value of the constant is returned if a definition is found,

 *  otherwise a +NameError+ is raised.

 *  Checks for a constant with the given name in <i>mod</i>

 *  If +inherit+ is set, the lookup will also search

 *  the ancestors (and +Object+ if <i>mod</i> is a +Module+.)

 *

 *  Returns whether or not a definition is found:

 *     IO.const_defined? :SYNC   #=> true

 *     IO.const_defined? :SYNC, false   #=> false

 *     Integer("0930", 10) #=> 930

 *     Integer("111", 2)   #=> 7

    double ret;

    VALUE v = 0;

            char *p =  ALLOCV(v, len);

    ret = rb_cstr_to_dbl(s, badcheck);

    if (v)

        ALLOCV_END(v);

    return ret;

    VALUE tmp = rb_check_string_type(val);

    if (NIL_P(tmp))

        tmp = rb_convert_type(val, T_STRING, "String", "to_s");

    return tmp;

/*  Document-class: BasicObject

 *

 *  BasicObject is the parent class of all classes in Ruby.  It's an explicit

 *  blank class.

 *

 *  BasicObject can be used for creating object hierarchies independent of

 *  Ruby's object hierarchy, proxy objects like the Delegator class, or other

 *  uses where namespace pollution from Ruby's methods and classes must be

 *  avoided.

 *

 *  To avoid polluting BasicObject for other users an appropriately named

 *  subclass of BasicObject should be created instead of directly modifying

 *  BasicObject:

 *

 *    class MyObjectSystem < BasicObject

 *    end

 *

 *  BasicObject does not include Kernel (for methods like +puts+) and

 *  BasicObject is outside of the namespace of the standard library so common

 *  classes will not be found without a using a full class path.

 *

 *  A variety of strategies can be used to provide useful portions of the

 *  standard library to subclasses of BasicObject.  A subclass could

 *  <code>include Kernel</code> to obtain +puts+, +exit+, etc.  A custom

 *  Kernel-like module could be created and included or delegation can be used

 *  via #method_missing:

 *

 *    class MyObjectSystem < BasicObject

 *      DELEGATE = [:puts, :p]

 *

 *      def method_missing(name, *args, &block)

 *        super unless DELEGATE.include? name

 *        ::Kernel.send(name, *args, &block)

 *      end

 *

 *      def respond_to_missing?(name, include_private = false)

 *        DELGATE.include?(name) or super

 *      end

 *    end

 *

 *  Access to classes and modules from the Ruby standard library can be

 *  obtained in a BasicObject subclass by referencing the desired constant

 *  from the root like <code>::File</code> or <code>::Enumerator</code>.

 *  Like #method_missing, #const_missing can be used to delegate constant

 *  lookup to +Object+:

 *

 *    class MyObjectSystem < BasicObject

 *      def self.const_missing(name)

 *        ::Object.const_get(name)

 *      end

 *    end

 */

 

/*  Document-class: Object

 *

 *  Object is the root of Ruby's class hierarchy.  Its methods are available

 *  to all classes unless explicitly overridden.

 *

 *  Object mixes in the Kernel module, making the built-in kernel functions

 *  globally accessible. Although the instance methods of Object are defined

 *  by the Kernel module, we have chosen to document them here for clarity.

 *  to a symbol, which is either a quoted string or a Symbol (such as

 *  <code>:name</code>).

#if 0

    // teach RDoc about these classes

    rb_cBasicObject = rb_define_class("BasicObject", Qnil);

    rb_cObject = rb_define_class("Object", rb_cBasicObject);

    rb_cModule = rb_define_class("Module", rb_cObject);

    rb_cClass =  rb_define_class("Class",  rb_cModule);

#endif