Add Custom_Warning/Error for exchange with C-API

Author: mgreter

ast.cpp

@@ -1173,6 +1173,32 @@ namespace Sass {
     return string();
   }
 
+  bool Custom_Warning::operator== (Expression* rhs) const
+  {
+    if (Custom_Warning* r = dynamic_cast<Custom_Warning*>(rhs)) {
+      return message() == r->message();
+    }
+    return false;
+  }
+
+  bool Custom_Warning::operator== (Expression& rhs) const
+  {
+    return operator==(&rhs);
+  }
+
+  bool Custom_Error::operator== (Expression* rhs) const
+  {
+    if (Custom_Error* r = dynamic_cast<Custom_Error*>(rhs)) {
+      return message() == r->message();
+    }
+    return false;
+  }
+
+  bool Custom_Error::operator== (Expression& rhs) const
+  {
+    return operator==(&rhs);
+  }
+
   bool Number::operator== (Expression* rhs) const
   {
     if (Number* r = dynamic_cast<Number*>(rhs)) {
@@ -1585,5 +1611,14 @@ namespace Sass {
     return quote_mark_ ? quote(value_, quote_mark_, true) : value_;
   }
 
+  string Custom_Error::to_string(bool compressed, int precision) const
+  {
+    return message();
+  }
+  string Custom_Warning::to_string(bool compressed, int precision) const
+  {
+    return message();
+  }
+
 }
 

ast.hpp

@@ -103,6 +103,8 @@ namespace Sass {
       MAP,
       SELECTOR,
       NULL_VAL,
+      C_WARNING,
+      C_ERROR,
       NUM_TYPES
     };
   private:
@@ -1250,6 +1252,36 @@ namespace Sass {
     ATTACH_OPERATIONS()
   };
 
+  //////////////////////////////
+  // Errors from Sass_Values.
+  //////////////////////////////
+  class Custom_Error : public Value {
+    ADD_PROPERTY(string, message)
+  public:
+    Custom_Error(ParserState pstate, string msg)
+    : Value(pstate), message_(msg)
+    { concrete_type(C_ERROR); }
+    virtual bool operator== (Expression& rhs) const;
+    virtual bool operator== (Expression* rhs) const;
+    virtual string to_string(bool compressed = false, int precision = 5) const;
+    ATTACH_OPERATIONS()
+  };
+
+  //////////////////////////////
+  // Warnings from Sass_Values.
+  //////////////////////////////
+  class Custom_Warning : public Value {
+    ADD_PROPERTY(string, message)
+  public:
+    Custom_Warning(ParserState pstate, string msg)
+    : Value(pstate), message_(msg)
+    { concrete_type(C_WARNING); }
+    virtual bool operator== (Expression& rhs) const;
+    virtual bool operator== (Expression* rhs) const;
+    virtual string to_string(bool compressed = false, int precision = 5) const;
+    ATTACH_OPERATIONS()
+  };
+
   ////////////
   // Booleans.
   ////////////

ast_factory.hpp

@@ -24,6 +24,8 @@ namespace Sass {
     Assignment* new_Assignment(string p, size_t l, string var, Expression* val, bool guarded = false);
     Import<Function_Call*>* new_CSS_Import(string p, size_t l, Function_Call* loc);
     Import<String*>* new_SASS_Import(string p, size_t l, String* loc);
+    Custom_Warning* new_Custom_Warning(string msg, size_t l, string msg);
+    Custom_Error* new_Custom_Error(string p, size_t l, string msg);
     Warning* new_Warning(string p, size_t l, Expression* msg);
     Error* new_Error(string p, size_t l, Expression* msg);
     Debug* new_Debug(string p, size_t l, Expression* val);

ast_fwd_decl.hpp

@@ -46,6 +46,8 @@ namespace Sass {
   class Unary_Expression;
   class Function_Call;
   class Function_Call_Schema;
+  class Custom_Warning;
+  class Custom_Error;
   class Variable;
   class Textual;
   class Number;

debugger.hpp

@@ -557,6 +557,8 @@ inline void debug_ast(AST_Node* node, string ind = "", Env* env = 0)
       case Expression::Concrete_Type::MAP: cerr << " [MAP]"; break;
       case Expression::Concrete_Type::SELECTOR: cerr << " [SELECTOR]"; break;
       case Expression::Concrete_Type::NULL_VAL: cerr << " [NULL_VAL]"; break;
+      case Expression::Concrete_Type::C_WARNING: cerr << " [C_WARNING]"; break;
+      case Expression::Concrete_Type::C_ERROR: cerr << " [C_ERROR]"; break;
       case Expression::Concrete_Type::NUM_TYPES: cerr << " [NUM_TYPES]"; break;
     }
     cerr << endl;

inspect.hpp

@@ -57,6 +57,8 @@ namespace Sass {
     virtual void operator()(Unary_Expression*);
     virtual void operator()(Function_Call*);
     virtual void operator()(Function_Call_Schema*);
+    // virtual void operator()(Custom_Warning*);
+    // virtual void operator()(Custom_Error*);
     virtual void operator()(Variable*);
     virtual void operator()(Textual*);
     virtual void operator()(Number*);

operation.hpp

@@ -48,6 +48,8 @@ namespace Sass {
     virtual T operator()(Unary_Expression* x)       = 0;
     virtual T operator()(Function_Call* x)          = 0;
     virtual T operator()(Function_Call_Schema* x)   = 0;
+    virtual T operator()(Custom_Warning* x)         = 0;
+    virtual T operator()(Custom_Error* x)           = 0;
     virtual T operator()(Variable* x)               = 0;
     virtual T operator()(Textual* x)                = 0;
     virtual T operator()(Number* x)                 = 0;
@@ -123,6 +125,8 @@ namespace Sass {
     virtual T operator()(Unary_Expression* x)       { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Function_Call* x)          { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Function_Call_Schema* x)   { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Custom_Warning* x)         { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Custom_Error* x)           { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Variable* x)               { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Textual* x)                { return static_cast<D*>(this)->fallback(x); }
     virtual T operator()(Number* x)                 { return static_cast<D*>(this)->fallback(x); }

to_c.cpp

@@ -7,14 +7,20 @@ namespace Sass {
   using namespace std;
 
   union Sass_Value* To_C::fallback_impl(AST_Node* n)
-  { return sass_make_null(); }
+  { return sass_make_error("unknown type for C-API"); }
 
   union Sass_Value* To_C::operator()(Boolean* b)
   { return sass_make_boolean(b->value()); }
 
   union Sass_Value* To_C::operator()(Number* n)
   { return sass_make_number(n->value(), n->unit().c_str()); }
 
+  union Sass_Value* To_C::operator()(Custom_Warning* w)
+  { return sass_make_warning(w->message().c_str()); }
+
+  union Sass_Value* To_C::operator()(Custom_Error* e)
+  { return sass_make_error(e->message().c_str()); }
+
   union Sass_Value* To_C::operator()(Color* c)
   { return sass_make_color(c->r(), c->g(), c->b(), c->a()); }
 

to_c.hpp

@@ -24,6 +24,8 @@ namespace Sass {
     union Sass_Value* operator()(Color*);
     union Sass_Value* operator()(String_Constant*);
     union Sass_Value* operator()(String_Quoted*);
+    union Sass_Value* operator()(Custom_Warning*);
+    union Sass_Value* operator()(Custom_Error*);
     union Sass_Value* operator()(List*);
     union Sass_Value* operator()(Map*);
     union Sass_Value* operator()(Null*);

to_value.cpp

@@ -15,6 +15,18 @@ namespace Sass {
     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)
   {