sassc 1.7.1 → 1.8.0.pre1

data/ext/libsass/src/to_value.cpp

@@ -0,0 +1,109 @@
+#include "ast.hpp"
+#include "to_value.hpp"
+#include "to_string.hpp"
+
+namespace Sass {
+
+  Value* To_Value::fallback_impl(AST_Node* n)
+  {
+    // throw a runtime error if this happens
+    // we want a well defined set of possible nodes
+    throw std::runtime_error("invalid node for to_value");
+    // mute warning
+    return 0;
+  }
+
+  // Custom_Error is a valid value
+  Value* To_Value::operator()(Custom_Error* e)
+  {
+    return e;
+  }
+
+  // Custom_Warning is a valid value
+  Value* To_Value::operator()(Custom_Warning* w)
+  {
+    return w;
+  }
+
+  // Boolean is a valid value
+  Value* To_Value::operator()(Boolean* b)
+  {
+    return b;
+  }
+
+  // Number is a valid value
+  Value* To_Value::operator()(Number* n)
+  {
+    return n;
+  }
+
+  // Color is a valid value
+  Value* To_Value::operator()(Color* c)
+  {
+    return c;
+  }
+
+  // String_Constant is a valid value
+  Value* To_Value::operator()(String_Constant* s)
+  {
+    return s;
+  }
+
+  // String_Quoted is a valid value
+  Value* To_Value::operator()(String_Quoted* s)
+  {
+    return s;
+  }
+
+  // List is a valid value
+  Value* To_Value::operator()(List* l)
+  {
+    List* ll = SASS_MEMORY_NEW(mem, List,
+                               l->pstate(),
+                               l->length(),
+                               l->separator(),
+                               l->is_arglist());
+    for (size_t i = 0, L = l->length(); i < L; ++i) {
+      *ll << (*l)[i]->perform(this);
+    }
+    return ll;
+  }
+
+  // Map is a valid value
+  Value* To_Value::operator()(Map* m)
+  {
+    return m;
+  }
+
+  // Null is a valid value
+  Value* To_Value::operator()(Null* n)
+  {
+    return n;
+  }
+
+  // Argument returns its value
+  Value* To_Value::operator()(Argument* arg)
+  {
+    if (!arg->name().empty()) return 0;
+    return arg->value()->perform(this);
+  }
+
+  // Selector_List is converted to a string
+  Value* To_Value::operator()(Selector_List* s)
+  {
+    To_String to_string(&ctx);
+    return SASS_MEMORY_NEW(mem, String_Quoted,
+                           s->pstate(),
+                           s->perform(&to_string));
+  }
+
+  // Binary_Expression is converted to a string
+  Value* To_Value::operator()(Binary_Expression* s)
+  {
+    To_String to_string(&ctx);
+    return SASS_MEMORY_NEW(mem, String_Quoted,
+                           s->pstate(),
+                           s->perform(&to_string));
+  }
+
+};

data/ext/libsass/src/to_value.hpp

@@ -0,0 +1,50 @@
+#ifndef SASS_TO_VALUE_H
+#define SASS_TO_VALUE_H
+
+#include "operation.hpp"
+#include "sass/values.h"
+#include "ast_fwd_decl.hpp"
+
+namespace Sass {
+
+  class To_Value : public Operation_CRTP<Value*, To_Value> {
+
+    Value* fallback_impl(AST_Node* n);
+
+  private:
+
+    Context& ctx;
+    Memory_Manager& mem;
+
+  public:
+
+    To_Value(Context& ctx, Memory_Manager& mem)
+    : ctx(ctx), mem(mem)
+    { }
+    virtual ~To_Value() { }
+    using Operation<Value*>::operator();
+
+    Value* operator()(Argument*);
+    Value* operator()(Boolean*);
+    Value* operator()(Number*);
+    Value* operator()(Color*);
+    Value* operator()(String_Constant*);
+    Value* operator()(String_Quoted*);
+    Value* operator()(Custom_Warning*);
+    Value* operator()(Custom_Error*);
+    Value* operator()(List*);
+    Value* operator()(Map*);
+    Value* operator()(Null*);
+
+    // convert to string via `To_String`
+    Value* operator()(Selector_List*);
+    Value* operator()(Binary_Expression*);
+
+    // fallback throws error
+    template <typename U>
+    Value* fallback(U x) { return fallback_impl(x); }
+  };
+
+}
+
+#endif

data/ext/libsass/{units.cpp → src/units.cpp}

@@ -1,6 +1,10 @@
 #include <stdexcept>
 #include "units.hpp"
 
+#ifdef IN
+#undef IN
+#endif
+
 namespace Sass {
 
   /* the conversion matrix can be readed the following way */
@@ -52,75 +56,75 @@ namespace Sass {
   {
     switch (unit & 0xFF00)
     {
-      case SIZE: return SIZE; break;
-      case ANGLE: return ANGLE; break;
-      case TIME: return TIME; break;
-      case FREQUENCY: return FREQUENCY; break;
-      case RESOLUTION: return RESOLUTION; break;
-      default: return INCOMMENSURABLE; break;
+      case SassUnitType::LENGTH:      return SassUnitType::LENGTH; break;
+      case SassUnitType::ANGLE:       return SassUnitType::ANGLE; break;
+      case SassUnitType::TIME:        return SassUnitType::TIME; break;
+      case SassUnitType::FREQUENCY:   return SassUnitType::FREQUENCY; break;
+      case SassUnitType::RESOLUTION:  return SassUnitType::RESOLUTION; break;
+      default:                        return SassUnitType::INCOMMENSURABLE; break;
     }
   };
 
-  SassUnit string_to_unit(const string& s)
+  SassUnit string_to_unit(const std::string& s)
   {
     // size units
-    if      (s == "px") return PX;
-    else if (s == "pt") return PT;
-    else if (s == "pc") return PC;
-    else if (s == "mm") return MM;
-    else if (s == "cm") return CM;
-    else if (s == "in") return IN;
+    if      (s == "px")   return SassUnit::PX;
+    else if (s == "pt")   return SassUnit::PT;
+    else if (s == "pc")   return SassUnit::PC;
+    else if (s == "mm")   return SassUnit::MM;
+    else if (s == "cm")   return SassUnit::CM;
+    else if (s == "in")   return SassUnit::IN;
     // angle units
-    else if (s == "deg") return DEG;
-    else if (s == "grad") return GRAD;
-    else if (s == "rad") return RAD;
-    else if (s == "turn") return TURN;
+    else if (s == "deg")  return SassUnit::DEG;
+    else if (s == "grad") return SassUnit::GRAD;
+    else if (s == "rad")  return SassUnit::RAD;
+    else if (s == "turn") return SassUnit::TURN;
     // time units
-    else if (s == "s") return SEC;
-    else if (s == "ms") return MSEC;
+    else if (s == "s")    return SassUnit::SEC;
+    else if (s == "ms")   return SassUnit::MSEC;
     // frequency units
-    else if (s == "Hz") return HERTZ;
-    else if (s == "kHz") return KHERTZ;
+    else if (s == "Hz")   return SassUnit::HERTZ;
+    else if (s == "kHz")  return SassUnit::KHERTZ;
     // resolutions units
-    else if (s == "dpi") return DPI;
-    else if (s == "dpcm") return DPCM;
-    else if (s == "dppx") return DPPX;
+    else if (s == "dpi")  return SassUnit::DPI;
+    else if (s == "dpcm") return SassUnit::DPCM;
+    else if (s == "dppx") return SassUnit::DPPX;
     // for unknown units
-    else return UNKNOWN;
+    else return SassUnit::UNKNOWN;
   }
 
   const char* unit_to_string(SassUnit unit)
   {
     switch (unit) {
       // size units
-      case PX: return "px"; break;
-      case PT: return "pt"; break;
-      case PC: return "pc"; break;
-      case MM: return "mm"; break;
-      case CM: return "cm"; break;
-      case IN: return "in"; break;
+      case SassUnit::PX:      return "px"; break;
+      case SassUnit::PT:      return "pt"; break;
+      case SassUnit::PC:      return "pc"; break;
+      case SassUnit::MM:      return "mm"; break;
+      case SassUnit::CM:      return "cm"; break;
+      case SassUnit::IN:      return "in"; break;
       // angle units
-      case DEG: return "deg"; break;
-      case GRAD: return "grad"; break;
-      case RAD: return "rad"; break;
-      case TURN: return "turn"; break;
+      case SassUnit::DEG:     return "deg"; break;
+      case SassUnit::GRAD:    return "grad"; break;
+      case SassUnit::RAD:     return "rad"; break;
+      case SassUnit::TURN:    return "turn"; break;
       // time units
-      case SEC: return "s"; break;
-      case MSEC: return "ms"; break;
+      case SassUnit::SEC:     return "s"; break;
+      case SassUnit::MSEC:    return "ms"; break;
       // frequency units
-      case HERTZ: return "Hz"; break;
-      case KHERTZ: return "kHz"; break;
+      case SassUnit::HERTZ:   return "Hz"; break;
+      case SassUnit::KHERTZ:  return "kHz"; break;
       // resolutions units
-      case DPI: return "dpi"; break;
-      case DPCM: return "dpcm"; break;
-      case DPPX: return "dppx"; break;
+      case SassUnit::DPI:     return "dpi"; break;
+      case SassUnit::DPCM:    return "dpcm"; break;
+      case SassUnit::DPPX:    return "dppx"; break;
       // for unknown units
-      default: return ""; break;;
+      default:                return ""; break;
     }
   }
 
   // throws incompatibleUnits exceptions
-  double conversion_factor(const string& s1, const string& s2)
+  double conversion_factor(const std::string& s1, const std::string& s2, bool strict)
   {
     // assert for same units
     if (s1 == s2) return 1;
@@ -135,17 +139,18 @@ namespace Sass {
     size_t i1 = u1 - t1;
     size_t i2 = u2 - t2;
     // error if units are not of the same group
-    if (t1 != t2) throw incompatibleUnits(u1, u2);
+    // don't error for multiplication and division
+    if (strict && t1 != t2) throw incompatibleUnits(u1, u2);
     // only process known units
     if (u1 != UNKNOWN && u2 != UNKNOWN) {
       switch (t1) {
-        case SIZE: return size_conversion_factors[i1][i2]; break;
-        case ANGLE: return angle_conversion_factors[i1][i2]; break;
-        case TIME: return time_conversion_factors[i1][i2]; break;
-        case FREQUENCY: return frequency_conversion_factors[i1][i2]; break;
-        case RESOLUTION: return resolution_conversion_factors[i1][i2]; break;
+        case SassUnitType::LENGTH:              return size_conversion_factors[i1][i2]; break;
+        case SassUnitType::ANGLE:             return angle_conversion_factors[i1][i2]; break;
+        case SassUnitType::TIME:              return time_conversion_factors[i1][i2]; break;
+        case SassUnitType::FREQUENCY:         return frequency_conversion_factors[i1][i2]; break;
+        case SassUnitType::RESOLUTION:        return resolution_conversion_factors[i1][i2]; break;
         // ToDo: should we throw error here?
-        case INCOMMENSURABLE: return 0; break;
+        case SassUnitType::INCOMMENSURABLE:   return 0; break;
       }
     }
     // fallback

data/ext/libsass/{units.hpp → src/units.hpp}

@@ -6,12 +6,11 @@
 #include <sstream>
 
 namespace Sass {
-  using namespace std;
 
   const double PI = acos(-1);
 
   enum SassUnitType {
-    SIZE = 0x000,
+    LENGTH = 0x000,
     ANGLE = 0x100,
     TIME = 0x200,
     FREQUENCY = 0x300,
@@ -22,7 +21,7 @@ namespace Sass {
   enum SassUnit {
 
     // size units
-    IN = SIZE,
+    IN = SassUnitType::LENGTH,
     CM,
     PC,
     MM,
@@ -59,25 +58,25 @@ namespace Sass {
   extern const double frequency_conversion_factors[2][2];
   extern const double resolution_conversion_factors[3][3];
 
-  SassUnit string_to_unit(const string&);
+  enum SassUnit string_to_unit(const std::string&);
   const char* unit_to_string(SassUnit unit);
-  SassUnitType get_unit_type(SassUnit unit);
+  enum SassUnitType get_unit_type(SassUnit unit);
   // throws incompatibleUnits exceptions
-  double conversion_factor(const string&, const string&);
+  double conversion_factor(const std::string&, const std::string&, bool = true);
 
-  class incompatibleUnits: public exception
+  class incompatibleUnits: public std::exception
   {
     public:
       const char* msg;
       incompatibleUnits(SassUnit a, SassUnit b)
       : exception()
       {
-        stringstream ss;
+        std::stringstream ss;
         ss << "Incompatible units: ";
         ss << "'" << unit_to_string(a) << "' and ";
         ss << "'" << unit_to_string(b) << "'";
         msg = ss.str().c_str();
-      };
+      }
       virtual const char* what() const throw()
       {
         return msg;

data/ext/libsass/{utf8 → src/utf8}/core.h

@@ -116,15 +116,15 @@ namespace internal
     inline bool is_overlong_sequence(uint32_t cp, octet_difference_type length)
     {
         if (cp < 0x80) {
-            if (length != 1) 
+            if (length != 1)
                 return true;
         }
         else if (cp < 0x800) {
-            if (length != 2) 
+            if (length != 2)
                 return true;
         }
         else if (cp < 0x10000) {
-            if (length != 3) 
+            if (length != 3)
                 return true;
         }
 
@@ -142,11 +142,11 @@ namespace internal
 
         if (!utf8::internal::is_trail(*it))
             return INCOMPLETE_SEQUENCE;
-        
+
         return UTF8_OK;
     }
 
-    #define UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(IT, END) {utf_error ret = increase_safely(IT, END); if (ret != UTF8_OK) return ret;}    
+    #define UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(IT, END) {utf_error ret = increase_safely(IT, END); if (ret != UTF8_OK) return ret;}
 
     /// get_sequence_x functions decode utf-8 sequences of the length x
     template <typename octet_iterator>
@@ -163,9 +163,9 @@ namespace internal
     template <typename octet_iterator>
     utf_error get_sequence_2(octet_iterator& it, octet_iterator end, uint32_t& code_point)
     {
-        if (it == end) 
+        if (it == end)
             return NOT_ENOUGH_ROOM;
-        
+
         code_point = utf8::internal::mask8(*it);
 
         UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
@@ -180,7 +180,7 @@ namespace internal
     {
         if (it == end)
             return NOT_ENOUGH_ROOM;
-            
+
         code_point = utf8::internal::mask8(*it);
 
         UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
@@ -234,7 +234,7 @@ namespace internal
         // Get trail octets and calculate the code point
         utf_error err = UTF8_OK;
         switch (length) {
-            case 0: 
+            case 0:
                 return INVALID_LEAD;
             case 1:
                 err = utf8::internal::get_sequence_1(it, end, cp);
@@ -262,7 +262,7 @@ namespace internal
                 else
                     err = OVERLONG_SEQUENCE;
             }
-            else 
+            else
                 err = INVALID_CODE_POINT;
         }
 
@@ -311,8 +311,8 @@ namespace internal
             ((it != end) && (utf8::internal::mask8(*it))   == bom[2])
            );
     }
-	
-    //Deprecated in release 2.3 
+
+    //Deprecated in release 2.3
     template <typename octet_iterator>
     inline bool is_bom (octet_iterator it)
     {