Return NULL when failed to construct a Sass value

::construct() methods may return NULL and
indicate an error in the returned error value.

src/sass_types/color.cpp

@@ -5,14 +5,14 @@ namespace SassTypes
 {
   Color::Color(Sass_Value* v) : SassValueWrapper(v) {}
 
-  Sass_Value* Color::construct(const std::vector<v8::Local<v8::Value>> raw_val) {
+  Sass_Value* Color::construct(const std::vector<v8::Local<v8::Value>> raw_val, Sass_Value **out) {
     double a = 1.0, r = 0, g = 0, b = 0;
     unsigned argb;
 
     switch (raw_val.size()) {
     case 1:
       if (!raw_val[0]->IsNumber()) {
-        throw std::invalid_argument("Only argument should be an integer.");
+        return fail("Only argument should be an integer.", out);
       }
 
       argb = Nan::To<int32_t>(raw_val[0]).FromJust();
@@ -24,7 +24,7 @@ namespace SassTypes
 
     case 4:
       if (!raw_val[3]->IsNumber()) {
-        throw std::invalid_argument("Constructor arguments should be numbers exclusively.");
+        return fail("Constructor arguments should be numbers exclusively.", out);
       }
 
       a = Nan::To<double>(raw_val[3]).FromJust();
@@ -32,7 +32,7 @@ namespace SassTypes
 
     case 3:
       if (!raw_val[0]->IsNumber() || !raw_val[1]->IsNumber() || !raw_val[2]->IsNumber()) {
-        throw std::invalid_argument("Constructor arguments should be numbers exclusively.");
+        return fail("Constructor arguments should be numbers exclusively.", out);
       }
 
       r = Nan::To<double>(raw_val[0]).FromJust();
@@ -44,10 +44,10 @@ namespace SassTypes
       break;
 
     default:
-      throw std::invalid_argument("Constructor should be invoked with either 0, 1, 3 or 4 arguments.");
+      return fail("Constructor should be invoked with either 0, 1, 3 or 4 arguments.", out);
     }
 
-    return sass_make_color(r, g, b, a);
+    return *out = sass_make_color(r, g, b, a);
   }
 
   void Color::initPrototype(v8::Local<v8::FunctionTemplate> proto) {

src/sass_types/color.h

@@ -10,7 +10,7 @@ namespace SassTypes
     public:
       Color(Sass_Value*);
       static char const* get_constructor_name() { return "SassColor"; }
-      static Sass_Value* construct(const std::vector<v8::Local<v8::Value>>);
+      static Sass_Value* construct(const std::vector<v8::Local<v8::Value>>, Sass_Value **);
 
       static void initPrototype(v8::Local<v8::FunctionTemplate>);
 

src/sass_types/error.cpp

@@ -6,18 +6,18 @@ namespace SassTypes
 {
   Error::Error(Sass_Value* v) : SassValueWrapper(v) {}
 
-  Sass_Value* Error::construct(const std::vector<v8::Local<v8::Value>> raw_val) {
+  Sass_Value* Error::construct(const std::vector<v8::Local<v8::Value>> raw_val, Sass_Value **out) {
     char const* value = "";
 
     if (raw_val.size() >= 1) {
       if (!raw_val[0]->IsString()) {
-        throw std::invalid_argument("Argument should be a string.");
+        return fail("Argument should be a string.", out);
       }
 
       value = create_string(raw_val[0]);
     }
 
-    return sass_make_error(value);
+    return *out = sass_make_error(value);
   }
 
   void Error::initPrototype(v8::Local<v8::FunctionTemplate>) {}

src/sass_types/error.h

@@ -10,7 +10,7 @@ namespace SassTypes
     public:
       Error(Sass_Value*);
       static char const* get_constructor_name() { return "SassError"; }
-      static Sass_Value* construct(const std::vector<v8::Local<v8::Value>>);
+      static Sass_Value* construct(const std::vector<v8::Local<v8::Value>>, Sass_Value **);
 
       static void initPrototype(v8::Local<v8::FunctionTemplate>);
   };

src/sass_types/list.cpp

@@ -5,27 +5,27 @@ namespace SassTypes
 {
   List::List(Sass_Value* v) : SassValueWrapper(v) {}
 
-  Sass_Value* List::construct(const std::vector<v8::Local<v8::Value>> raw_val) {
+  Sass_Value* List::construct(const std::vector<v8::Local<v8::Value>> raw_val, Sass_Value **out) {
     size_t length = 0;
     bool comma = true;
 
     if (raw_val.size() >= 1) {
       if (!raw_val[0]->IsNumber()) {
-        throw std::invalid_argument("First argument should be an integer.");
+        return fail("First argument should be an integer.", out);
       }
 
       length = Nan::To<uint32_t>(raw_val[0]).FromJust();
 
       if (raw_val.size() >= 2) {
         if (!raw_val[1]->IsBoolean()) {
-          throw std::invalid_argument("Second argument should be a boolean.");
+          return fail("Second argument should be a boolean.", out);
         }
 
         comma = Nan::To<bool>(raw_val[1]).FromJust();
       }
     }
 
-    return sass_make_list(length, comma ? SASS_COMMA : SASS_SPACE);
+    return *out = sass_make_list(length, comma ? SASS_COMMA : SASS_SPACE);
   }
 
   void List::initPrototype(v8::Local<v8::FunctionTemplate> proto) {

src/sass_types/list.h

@@ -10,7 +10,7 @@ namespace SassTypes
     public:
       List(Sass_Value*);
       static char const* get_constructor_name() { return "SassList"; }
-      static Sass_Value* construct(const std::vector<v8::Local<v8::Value>>);
+      static Sass_Value* construct(const std::vector<v8::Local<v8::Value>>, Sass_Value **);
 
       static void initPrototype(v8::Local<v8::FunctionTemplate>);
 

src/sass_types/map.cpp

@@ -5,18 +5,18 @@ namespace SassTypes
 {
   Map::Map(Sass_Value* v) : SassValueWrapper(v) {}
 
-  Sass_Value* Map::construct(const std::vector<v8::Local<v8::Value>> raw_val) {
+  Sass_Value* Map::construct(const std::vector<v8::Local<v8::Value>> raw_val, Sass_Value **out) {
     size_t length = 0;
 
     if (raw_val.size() >= 1) {
       if (!raw_val[0]->IsNumber()) {
-        throw std::invalid_argument("First argument should be an integer.");
+        return fail("First argument should be an integer.", out);
       }
 
       length = Nan::To<uint32_t>(raw_val[0]).FromJust();
     }
 
-    return sass_make_map(length);
+    return *out = sass_make_map(length);
   }
 
   void Map::initPrototype(v8::Local<v8::FunctionTemplate> proto) {

src/sass_types/map.h

@@ -10,7 +10,7 @@ namespace SassTypes
     public:
       Map(Sass_Value*);
       static char const* get_constructor_name() { return "SassMap"; }
-      static Sass_Value* construct(const std::vector<v8::Local<v8::Value>>);
+      static Sass_Value* construct(const std::vector<v8::Local<v8::Value>>, Sass_Value **);
 
       static void initPrototype(v8::Local<v8::FunctionTemplate>);
 

src/sass_types/number.cpp

@@ -6,27 +6,27 @@ namespace SassTypes
 {
   Number::Number(Sass_Value* v) : SassValueWrapper(v) {}
 
-  Sass_Value* Number::construct(const std::vector<v8::Local<v8::Value>> raw_val) {
+  Sass_Value* Number::construct(const std::vector<v8::Local<v8::Value>> raw_val, Sass_Value **out) {
     double value = 0;
     char const* unit = "";
 
     if (raw_val.size() >= 1) {
       if (!raw_val[0]->IsNumber()) {
-        throw std::invalid_argument("First argument should be a number.");
+        return fail("First argument should be a number.", out);
       }
 
       value = Nan::To<double>(raw_val[0]).FromJust();
 
       if (raw_val.size() >= 2) {
         if (!raw_val[1]->IsString()) {
-          throw std::invalid_argument("Second argument should be a string.");
+          return fail("Second argument should be a string.", out);
         }
 
         unit = create_string(raw_val[1]);
       }
     }
 
-    return sass_make_number(value, unit);
+    return *out = sass_make_number(value, unit);
   }
 
   void Number::initPrototype(v8::Local<v8::FunctionTemplate> proto) {

src/sass_types/number.h

@@ -11,7 +11,7 @@ namespace SassTypes
     public:
       Number(Sass_Value*);
       static char const* get_constructor_name() { return "SassNumber"; }
-      static Sass_Value* construct(const std::vector<v8::Local<v8::Value>>);
+      static Sass_Value* construct(const std::vector<v8::Local<v8::Value>>, Sass_Value **out);
 
       static void initPrototype(v8::Local<v8::FunctionTemplate>);
 

src/sass_types/sass_value_wrapper.h

@@ -95,15 +95,15 @@ namespace SassTypes
       localArgs[i] = info[i];
     }
     if (info.IsConstructCall()) {
-      try {
-        Sass_Value* value = T::construct(localArgs);
+      Sass_Value* value;
+      if (T::construct(localArgs, &value) != NULL) {
         T* obj = new T(value);
         sass_delete_value(value);
 
         Nan::SetInternalFieldPointer(info.This(), 0, obj);
         obj->js_object.Reset(info.This());
-      } catch (const std::exception& e) {
-        return Nan::ThrowError(Nan::New<v8::String>(e.what()).ToLocalChecked());
+      } else {
+        return Nan::ThrowError(Nan::New<v8::String>(sass_error_get_message(value)).ToLocalChecked());
       }
     } else {
       v8::Local<v8::Function> cons = T::get_constructor();

src/sass_types/string.cpp

@@ -6,18 +6,18 @@ namespace SassTypes
 {
   String::String(Sass_Value* v) : SassValueWrapper(v) {}
 
-  Sass_Value* String::construct(const std::vector<v8::Local<v8::Value>> raw_val) {
+  Sass_Value* String::construct(const std::vector<v8::Local<v8::Value>> raw_val, Sass_Value **out) {
     char const* value = "";
 
     if (raw_val.size() >= 1) {
       if (!raw_val[0]->IsString()) {
-        throw std::invalid_argument("Argument should be a string.");
+        return fail("Argument should be a string.", out);
       }
 
       value = create_string(raw_val[0]);
     }
 
-    return sass_make_string(value);
+    return *out = sass_make_string(value);
   }
 
   void String::initPrototype(v8::Local<v8::FunctionTemplate> proto) {

src/sass_types/string.h

@@ -10,7 +10,7 @@ namespace SassTypes
     public:
       String(Sass_Value*);
       static char const* get_constructor_name() { return "SassString"; }
-      static Sass_Value* construct(const std::vector<v8::Local<v8::Value>>);
+      static Sass_Value* construct(const std::vector<v8::Local<v8::Value>>, Sass_Value **);
 
       static void initPrototype(v8::Local<v8::FunctionTemplate>);