From bb0bee6f6dfea907ad66a613b2f3d835e0e1dd4a Mon Sep 17 00:00:00 2001
From: Brett Langdon <brett@blangdon.com>
Date: Sun, 30 Dec 2012 15:38:45 -0500
Subject: [PATCH] added instance function

---
 src/v8type.cc | 65 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)

diff --git a/src/v8type.cc b/src/v8type.cc
index 73e1eda..9bbf4a5 100644
--- a/src/v8type.cc
+++ b/src/v8type.cc
@@ -5,14 +5,18 @@ using namespace v8;
 
 #define ARRAY String::NewSymbol("array")
 #define BOOLEAN String::NewSymbol("boolean")
+#define BOOLEAN_OBJECT String::NewSymbol("boolean_object")
 #define DATE String::NewSymbol("date")
 #define FUNCTION String::NewSymbol("function")
 #define NUMBER String::NewSymbol("number")
+#define NUMBER_OBJECT String::NewSymbol("number_object")
 #define REGEXP String::NewSymbol("regexp")
 #define STRING String::NewSymbol("string")
+#define STRING_OBJECT String::NewSymbol("string_object")
 #define OBJECT String::NewSymbol("object")
 #define UNDEFINED String::NewSymbol("undefined")
 #define NULL_TYPE String::NewSymbol("null")
+#define PRIMITIVE String::NewSymbol("primitive")
 
 Handle<Value> v8type_of(const Arguments& args){
   HandleScope scope;
@@ -28,6 +32,9 @@ Handle<Value> v8type_of(const Arguments& args){
   } else if(args[0]->IsBoolean()){
     return scope.Close(BOOLEAN);
 
+  } else if(args[0]->IsBooleanObject()){
+    return scope.Close(BOOLEAN_OBJECT);
+
   } else if(args[0]->IsDate()){
     return scope.Close(DATE);
 
@@ -37,9 +44,15 @@ Handle<Value> v8type_of(const Arguments& args){
   } else if(args[0]->IsNumber()){
     return scope.Close(NUMBER);
 
+  } else if(args[0]->IsNumberObject()){
+    return scope.Close(NUMBER_OBJECT);
+
   } else if(args[0]->IsString()){
     return scope.Close(STRING);
 
+  } else if(args[0]->IsStringObject()){
+    return scope.Close(STRING_OBJECT);
+
   } else if(args[0]->IsRegExp()){
     return scope.Close(REGEXP);
 
@@ -79,17 +92,64 @@ Handle<Value> v8type_is(const Arguments& args){
   return scope.Close(Boolean::New(args[1] == type));
 }
 
+Handle<Value> v8type_instance(const Arguments& args){
+  HandleScope scope;
+
+  if(args.Length() < 2){
+    ThrowException(Exception::TypeError(String::New("v8type.instance function requires at least 2 arguments")));
+    return scope.Close(Undefined());
+  }
+
+  if(!args[1]->IsString()){
+    ThrowException(Exception::TypeError(String::New("v8type.instance second argument must be a string")));
+    return scope.Close(Undefined());
+  }
+
+  Handle<Context> context = Context::New();
+  Context::Scope context_scope(context);
+
+  Handle<Value> arguments[] = { args[0] };
+  Handle<Value> type = FunctionTemplate::New(v8type_of)->GetFunction()->Call(context->Global(), 1, arguments);
+
+  if(args[1] == type){
+    return scope.Close(Boolean::New(true));
+  }
+
+  if(args[1]->ToString() == OBJECT){
+    if(type == ARRAY or type == FUNCTION or type == DATE or type == REGEXP or type == STRING_OBJECT
+       or type == BOOLEAN_OBJECT or type == NUMBER_OBJECT){
+      return scope.Close(Boolean::New(true));
+    }
+  } else if(args[1]->ToString() == PRIMITIVE){
+    if(type == NUMBER or type == BOOLEAN or type == STRING){
+      return scope.Close(Boolean::New(true));
+    }
+  } else if(args[1]->ToString() == NUMBER and type == NUMBER_OBJECT){
+    return scope.Close(Boolean::New(true));
+  } else if(args[1]->ToString() == STRING and type == STRING_OBJECT){
+    return scope.Close(Boolean::New(true));
+  } else if(args[1]->ToString() == BOOLEAN and type == BOOLEAN_OBJECT){
+    return scope.Close(Boolean::New(true));
+  }
+
+  return scope.Close(Boolean::New(false));
+}
+
 void init_constants(Handle<Object> target){
   target->Set(String::NewSymbol("ARRAY"), ARRAY);
   target->Set(String::NewSymbol("BOOLEAN"), BOOLEAN);
+  target->Set(String::NewSymbol("BOOLEAN_OBJECT"), BOOLEAN_OBJECT);
   target->Set(String::NewSymbol("DATE"), DATE);
   target->Set(String::NewSymbol("FUNCTION"), FUNCTION);
   target->Set(String::NewSymbol("NUMBER"), NUMBER);
+  target->Set(String::NewSymbol("NUMBER_OBJECT"), NUMBER_OBJECT);
   target->Set(String::NewSymbol("REGEXP"), REGEXP);
   target->Set(String::NewSymbol("STRING"), STRING);
+  target->Set(String::NewSymbol("STRING_OBJECT"), STRING_OBJECT);
   target->Set(String::NewSymbol("OBJECT"), OBJECT);
   target->Set(String::NewSymbol("UNDEFINED"), UNDEFINED);
   target->Set(String::NewSymbol("NULL"), NULL_TYPE);
+  target->Set(String::NewSymbol("PRIMITIVE"), PRIMITIVE);
 }
 
 void init_v8type_of(Handle<Object> target){
@@ -100,10 +160,15 @@ void init_v8type_is(Handle<Object> target){
   target->Set(String::NewSymbol("is"), FunctionTemplate::New(v8type_is)->GetFunction());
 }
 
+void init_v8type_instance(Handle<Object> target){
+  target->Set(String::NewSymbol("instance"), FunctionTemplate::New(v8type_instance)->GetFunction());
+}
+
 void init(Handle<Object> target){
   init_constants(target);
   init_v8type_of(target);
   init_v8type_is(target);
+  init_v8type_instance(target);
 }
 
 NODE_MODULE(v8type, init);