Updated Xcode project build settings in conformity with 10.8/Xcode 4.4

1 files changed, 54 insertions, 162 deletions

diff --git a/src/etc.c b/src/etc.c
index 90ec47fb9..d14498d9c 100644
--- a/src/etc.c
+++ b/src/etc.c
@@ -10,14 +10,6 @@
 #include "mruby/numeric.h"
 #include "mruby/data.h"
 
-#ifndef FALSE
-#define FALSE   0
-#endif
-
-#ifndef TRUE
-#define TRUE    1
-#endif
-
 struct RData*
 mrb_data_object_alloc(mrb_state *mrb, struct RClass *klass, void *ptr, const struct mrb_data_type *type)
 {
@@ -60,11 +52,6 @@ mrb_check_datatype(mrb_state *mrb, mrb_value obj, const struct mrb_data_type *ty
 mrb_value
 mrb_lastline_get(mrb_state *mrb)
 {
-  //mrb_value *var = mrb_svar(0);
-  //if (var) {
-  //  return *var;
-  //}
-  //return mrb_nil_value();
   mrb_value *argv;
   int argc;
 
@@ -78,21 +65,6 @@ mrb_lastline_get(mrb_state *mrb)
   }
 }
 
-mrb_value
-mrb_rescue2(mrb_state *mrb, mrb_value (* b_proc) (ANYARGS), mrb_value *data1,
-                           mrb_value (* r_proc) (ANYARGS), mrb_value *data2, ...)
-{
-    mrb_value result = (*b_proc) (mrb, data1);
-    return result;
-}
-
-mrb_value
-mrb_rescue(mrb_state *mrb, mrb_value (* b_proc)(ANYARGS), mrb_value *data1,
-                          mrb_value (* r_proc)(ANYARGS), mrb_value *data2)
-{
-  return mrb_rescue2(mrb, b_proc, data1, r_proc, data2, mrb->eStandardError_class,
-                         mrb_fixnum_value(0));
-}
 /* ------------------------------------------------ */
 /*
  * Calls func(obj, arg, recursive), where recursive is non-zero if the
@@ -111,14 +83,6 @@ mrb_exec_recursive(mrb_state *mrb, mrb_value (*func) (mrb_state *, mrb_value, mr
  * current method is called recursively on the ordered pair <obj, paired_obj>
  */
 
-mrb_value
-mrb_exec_recursive_paired(mrb_state *mrb, mrb_value (*func) (mrb_state *, mrb_value, mrb_value, int),
-                                             mrb_value obj, mrb_value paired_obj, void* arg)
-{
-  //  return mrb_exec_recursive_paired(mrb, recursive_eql, hash1, hash2, mrb_fixnum_value((int)&data));
-  return func(mrb, obj, paired_obj, 0);
-}
-
 mrb_sym
 mrb_to_id(mrb_state *mrb, mrb_value name)
 {
@@ -157,136 +121,64 @@ mrb_block_proc(void)
   return mrb_nil_value();//proc_new(mrb_cProc, FALSE);
 }
 
-/*
- *  Document-method: __id__
- *  Document-method: object_id
- *
- *  call-seq:
- *     obj.__id__       -> fixnum
- *     obj.object_id    -> fixnum
- *
- *  Returns an integer identifier for <i>obj</i>. The same number will
- *  be returned on all calls to <code>id</code> for a given object, and
- *  no two active objects will share an id.
- *  <code>Object#object_id</code> is a different concept from the
- *  <code>:name</code> notation, which returns the symbol id of
- *  <code>name</code>. Replaces the deprecated <code>Object#id</code>.
- */
+static mrb_int
+float_id(mrb_float f)
+{
+  const char *p = (const char*)&f;
+  int len = sizeof(f);
+  mrb_int id = 0;
 
-/*
- *  call-seq:
- *     obj.hash    -> fixnum
- *
- *  Generates a <code>Fixnum</code> hash value for this object. This
- *  function must have the property that <code>a.eql?(b)</code> implies
- *  <code>a.hash == b.hash</code>. 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.
- */
+  while (len--) {
+    id = id*65599 + *p;
+    p++;
+  }
+  id = id + (id>>5);
+
+  return id;
+}
 
-int
+mrb_int
 mrb_obj_id(mrb_value obj)
 {
-    /*
-     *                32-bit mrb_value space
-     *          MSB ------------------------ LSB
-     *  false   00000000000000000000000000000000
-     *  true    00000000000000000000000000000010
-     *  nil     00000000000000000000000000000100
-     *  undef   00000000000000000000000000000110
-     *  symbol  ssssssssssssssssssssssss00001110
-     *  object  oooooooooooooooooooooooooooooo00        = 0 (mod sizeof(RVALUE))
-     *  fixnum  fffffffffffffffffffffffffffffff1
-     *
-     *                    object_id space
-     *                                       LSB
-     *  false   00000000000000000000000000000000
-     *  true    00000000000000000000000000000010
-     *  nil     00000000000000000000000000000100
-     *  undef   00000000000000000000000000000110
-     *  symbol   000SSSSSSSSSSSSSSSSSSSSSSSSSSS0        S...S % A = 4 (S...S = s...s * A + 4)
-     *  object   oooooooooooooooooooooooooooooo0        o...o % A = 0
-     *  fixnum  fffffffffffffffffffffffffffffff1        bignum if required
-     *
-     *  where A = sizeof(RVALUE)/4
-     *
-     *  sizeof(RVALUE) is
-     *  20 if 32-bit, double is 4-byte aligned
-     *  24 if 32-bit, double is 8-byte aligned
-     *  40 if 64-bit
-     */
-    /*
-     *                128-bit mrb_value space
-     *          MSB -------- LSB
-     *  x86           [0,1]             [2,3]            [4,5]            [6,7]            [8,9]            [A,B]            [C,D]            [E,F]
-     *          7                6                5                4                3                2                1                0
-     *          0123456789ABCDEF 0123456789ABCDEF 0123456789ABCDEF 0123456789ABCDEF 0123456789ABCDEF 0123456789ABCDEF 0123456789ABCDEF 0123456789ABCDEF
-     *          FEDCBA9876543210 FEDCBA9876543210 FEDCBA9876543210 FEDCBA9876543210 FEDCBA9876543210 FEDCBA9876543210 FEDCBA9876543210 FEDCBA9876543210
-     *  false   0000000000000000 0000000000000000 xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxx00000001 xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx
-     *  true    0000000000000001 0000000000000000 xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxx00000010 xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx
-     *  nil     0000000000000001 0000000000000000 xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxx00000001 xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx
-     *  undef   0000000000000000 0000000000000000 xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxx00000101 xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx
-     *  symbol  ssssssssssssssss ssssssssssssssss xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxx00000100 xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx
-     *  object  oooooooooooooooo oooooooooooooo00        = 0 (mod sizeof(RVALUE))
-     (1)fixnum  0000000000000001 0000000000000000 xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxx00000011 xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx
-     *  float   0000000000000001 0000000000000000 0000000000000000 0000000000000000 xxxxxxxx00000011 xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx
-     *          <--                          mrb_float                          --> xxxxxxxx00001101 xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx
-     *
-     *                    object_id space
-     *                                       LSB
-     *  false   0000000000000000 0000000000000000
-     *  true    0000000000000000 0000000000000010
-     *  nil     0000000000000000 0000000000000100
-     *  undef   0000000000000000 0000000000000110
-     *  symbol  000SSSSSSSSSSSS SSSSSSSSSSSSSSS0        S...S % A = 4 (S...S = s...s * A + 4)
-     *  object  ooooooooooooooo ooooooooooooooo0        o...o % A = 0
-     *  fixnum  ffffffffffffffff fffffffffffffff1        bignum if required
-     *
-     *  where A = sizeof(RVALUE)/4
-     *
-     *  sizeof(RVALUE) is
-     *  20 if 32-bit, double is 4-byte aligned
-     *  24 if 32-bit, double is 8-byte aligned
-     *  40 if 64-bit
-     */
-    /* tt:0_27 */
-  switch (mrb_type(obj)) {
-    case  MRB_TT_FREE:
-      return 0; /* not define */
-    case  MRB_TT_FALSE:
-      if (mrb_nil_p(obj))
-        return 4;
-      return 0;
-    case  MRB_TT_TRUE:
-      return 2;
-    case  MRB_TT_FIXNUM:
-      return mrb_fixnum(obj)*2+1; /* odd number */
-    case  MRB_TT_SYMBOL:
-      return SYM2ID(obj) * 2;
-    case  MRB_TT_UNDEF:
-      return 0; /* not define */
-    case  MRB_TT_FLOAT:
-      return (int)mrb_float(obj)*2; /* even number */
-    case  MRB_TT_OBJECT:
-    case  MRB_TT_CLASS:
-    case  MRB_TT_MODULE:
-    case  MRB_TT_ICLASS:
-    case  MRB_TT_SCLASS:
-    case  MRB_TT_PROC:
-    case  MRB_TT_ARRAY:
-    case  MRB_TT_HASH:
-    case  MRB_TT_STRING:
-    case  MRB_TT_RANGE:
-    case  MRB_TT_REGEX:
-    case  MRB_TT_STRUCT:
-    case  MRB_TT_EXCEPTION:
-    case  MRB_TT_MATCH:
-    case  MRB_TT_FILE:
-    case  MRB_TT_DATA:
-    case  MRB_TT_THREAD:
-    case  MRB_TT_THREADGRP:
-    default:
-      return mrb_fixnum(obj); /* even number */
+  mrb_int tt = obj.tt;
+
+#define MakeID2(p,t) (((intptr_t)(p))^(t))
+#define MakeID(p)    MakeID2(p,tt)
+
+  switch (tt) {
+  case  MRB_TT_FREE:
+  case  MRB_TT_UNDEF:
+    return MakeID(0); /* not define */
+  case  MRB_TT_FALSE:
+    if (mrb_nil_p(obj))
+      return MakeID(1);
+    return MakeID(0);
+  case  MRB_TT_TRUE:
+    return MakeID(1);
+  case  MRB_TT_SYMBOL:
+    return MakeID(SYM2ID(obj));
+  case  MRB_TT_FIXNUM:
+    return MakeID2(float_id((mrb_float)mrb_fixnum(obj)), MRB_TT_FLOAT);
+  case  MRB_TT_FLOAT:
+    return MakeID(float_id(mrb_float(obj)));
+  case  MRB_TT_STRING:
+  case  MRB_TT_OBJECT:
+  case  MRB_TT_CLASS:
+  case  MRB_TT_MODULE:
+  case  MRB_TT_ICLASS:
+  case  MRB_TT_SCLASS:
+  case  MRB_TT_PROC:
+  case  MRB_TT_ARRAY:
+  case  MRB_TT_HASH:
+  case  MRB_TT_RANGE:
+  case  MRB_TT_REGEX:
+  case  MRB_TT_STRUCT:
+  case  MRB_TT_EXCEPTION:
+  case  MRB_TT_MATCH:
+  case  MRB_TT_FILE:
+  case  MRB_TT_DATA:
+  default:
+    return MakeID(obj.value.p);
   }
 }