sassc4 2.4.0

data/ext/libsass/src/environment.hpp

@@ -0,0 +1,124 @@
+#ifndef SASS_ENVIRONMENT_H
+#define SASS_ENVIRONMENT_H
+
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <map>
+#include <string>
+#include "ast_fwd_decl.hpp"
+#include "ast_def_macros.hpp"
+
+namespace Sass {
+
+  // this defeats the whole purpose of environment being templatable!!
+  typedef environment_map<sass::string, AST_Node_Obj>::iterator EnvIter;
+
+  class EnvResult {
+    public:
+      EnvIter it;
+      bool found;
+    public:
+      EnvResult(EnvIter it, bool found)
+      : it(it), found(found) {}
+  };
+
+  template <typename T>
+  class Environment {
+    // TODO: test with map
+    environment_map<sass::string, T> local_frame_;
+    ADD_PROPERTY(Environment*, parent)
+    ADD_PROPERTY(bool, is_shadow)
+
+  public:
+    Environment(bool is_shadow = false);
+    Environment(Environment* env, bool is_shadow = false);
+    Environment(Environment& env, bool is_shadow = false);
+
+    // link parent to create a stack
+    void link(Environment& env);
+    void link(Environment* env);
+
+    // this is used to find the global frame
+    // which is the second last on the stack
+    bool is_lexical() const;
+
+    // only match the real root scope
+    // there is still a parent around
+    // not sure what it is actually use for
+    // I guess we store functions etc. there
+    bool is_global() const;
+
+    // scope operates on the current frame
+
+    environment_map<sass::string, T>& local_frame();
+
+    bool has_local(const sass::string& key) const;
+
+    EnvResult find_local(const sass::string& key);
+
+    T& get_local(const sass::string& key);
+
+    // set variable on the current frame
+    void set_local(const sass::string& key, const T& val);
+    void set_local(const sass::string& key, T&& val);
+
+    void del_local(const sass::string& key);
+
+    // global operates on the global frame
+    // which is the second last on the stack
+    Environment* global_env();
+    // get the env where the variable already exists
+    // if it does not yet exist, we return current env
+    Environment* lexical_env(const sass::string& key);
+
+    bool has_global(const sass::string& key);
+
+    T& get_global(const sass::string& key);
+
+    // set a variable on the global frame
+    void set_global(const sass::string& key, const T& val);
+    void set_global(const sass::string& key, T&& val);
+
+    void del_global(const sass::string& key);
+
+    // see if we have a lexical variable
+    // move down the stack but stop before we
+    // reach the global frame (is not included)
+    bool has_lexical(const sass::string& key) const;
+
+    // see if we have a lexical we could update
+    // either update already existing lexical value
+    // or we create a new one on the current frame
+    void set_lexical(const sass::string& key, T&& val);
+    void set_lexical(const sass::string& key, const T& val);
+
+    // look on the full stack for key
+    // include all scopes available
+    bool has(const sass::string& key) const;
+
+    // look on the full stack for key
+    // include all scopes available
+    T& get(const sass::string& key);
+
+    // look on the full stack for key
+    // include all scopes available
+    EnvResult find(const sass::string& key);
+
+    // use array access for getter and setter functions
+    T& operator[](const sass::string& key);
+
+    #ifdef DEBUG
+    size_t print(sass::string prefix = "");
+    #endif
+
+  };
+
+  // define typedef for our use case
+  typedef Environment<AST_Node_Obj> Env;
+  typedef sass::vector<Env*> EnvStack;
+
+}
+
+#endif

data/ext/libsass/src/error_handling.cpp

@@ -0,0 +1,239 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "ast.hpp"
+#include "prelexer.hpp"
+#include "backtrace.hpp"
+#include "error_handling.hpp"
+
+#include <iostream>
+
+namespace Sass {
+
+  namespace Exception {
+
+    Base::Base(SourceSpan pstate, sass::string msg, Backtraces traces)
+    : std::runtime_error(msg.c_str()), msg(msg),
+      prefix("Error"), pstate(pstate), traces(traces)
+    { }
+
+    InvalidSass::InvalidSass(SourceSpan pstate, Backtraces traces, sass::string msg)
+    : Base(pstate, msg, traces)
+    { }
+
+
+    InvalidParent::InvalidParent(Selector* parent, Backtraces traces, Selector* selector)
+    : Base(selector->pstate(), def_msg, traces), parent(parent), selector(selector)
+    {
+      msg = "Invalid parent selector for "
+        "\"" + selector->to_string(Sass_Inspect_Options()) + "\": "
+        "\"" + parent->to_string(Sass_Inspect_Options()) + "\"";
+    }
+
+    InvalidVarKwdType::InvalidVarKwdType(SourceSpan pstate, Backtraces traces, sass::string name, const Argument* arg)
+    : Base(pstate, def_msg, traces), name(name), arg(arg)
+    {
+      msg = "Variable keyword argument map must have string keys.\n" +
+        name + " is not a string in " + arg->to_string() + ".";
+    }
+
+    InvalidArgumentType::InvalidArgumentType(SourceSpan pstate, Backtraces traces, sass::string fn, sass::string arg, sass::string type, const Value* value)
+    : Base(pstate, def_msg, traces), fn(fn), arg(arg), type(type), value(value)
+    {
+      msg = arg + ": \"";
+      if (value) msg += value->to_string(Sass_Inspect_Options());
+      msg += "\" is not a " + type + " for `" + fn + "'";
+    }
+
+    MissingArgument::MissingArgument(SourceSpan pstate, Backtraces traces, sass::string fn, sass::string arg, sass::string fntype)
+    : Base(pstate, def_msg, traces), fn(fn), arg(arg), fntype(fntype)
+    {
+      msg = fntype + " " + fn + " is missing argument " + arg + ".";
+    }
+
+    InvalidSyntax::InvalidSyntax(SourceSpan pstate, Backtraces traces, sass::string msg)
+    : Base(pstate, msg, traces)
+    { }
+
+    NestingLimitError::NestingLimitError(SourceSpan pstate, Backtraces traces, sass::string msg)
+    : Base(pstate, msg, traces)
+    { }
+
+    DuplicateKeyError::DuplicateKeyError(Backtraces traces, const Map& dup, const Expression& org)
+    : Base(org.pstate(), def_msg, traces), dup(dup), org(org)
+    {
+      msg = "Duplicate key " + dup.get_duplicate_key()->inspect() + " in map (" + org.inspect() + ").";
+    }
+
+    TypeMismatch::TypeMismatch(Backtraces traces, const Expression& var, const sass::string type)
+    : Base(var.pstate(), def_msg, traces), var(var), type(type)
+    {
+      msg = var.to_string() + " is not an " + type + ".";
+    }
+
+    InvalidValue::InvalidValue(Backtraces traces, const Expression& val)
+    : Base(val.pstate(), def_msg, traces), val(val)
+    {
+      msg = val.to_string() + " isn't a valid CSS value.";
+    }
+
+    StackError::StackError(Backtraces traces, const AST_Node& node)
+    : Base(node.pstate(), def_msg, traces), node(node)
+    {
+      msg = "stack level too deep";
+    }
+
+    EndlessExtendError::EndlessExtendError(Backtraces traces, const AST_Node& node)
+      : Base(node.pstate(), def_msg, traces), node(node)
+    {
+      msg = "Extend is creating an absurdly big selector, aborting!";
+    }
+
+    IncompatibleUnits::IncompatibleUnits(const Units& lhs, const Units& rhs)
+    {
+      msg = "Incompatible units: '" + rhs.unit() + "' and '" + lhs.unit() + "'.";
+    }
+
+    IncompatibleUnits::IncompatibleUnits(const UnitType lhs, const UnitType rhs)
+    {
+      msg = sass::string("Incompatible units: '") + unit_to_string(rhs) + "' and '" + unit_to_string(lhs) + "'.";
+    }
+
+    AlphaChannelsNotEqual::AlphaChannelsNotEqual(const Expression* lhs, const Expression* rhs, enum Sass_OP op)
+    : OperationError(), lhs(lhs), rhs(rhs), op(op)
+    {
+      msg = "Alpha channels must be equal: " +
+        lhs->to_string({ NESTED, 5 }) +
+        " " + sass_op_to_name(op) + " " +
+        rhs->to_string({ NESTED, 5 }) + ".";
+    }
+
+    ZeroDivisionError::ZeroDivisionError(const Expression& lhs, const Expression& rhs)
+    : OperationError(), lhs(lhs), rhs(rhs)
+    {
+      msg = "divided by 0";
+    }
+
+    UndefinedOperation::UndefinedOperation(const Expression* lhs, const Expression* rhs, enum Sass_OP op)
+    : OperationError(), lhs(lhs), rhs(rhs), op(op)
+    {
+      msg = def_op_msg + ": \"" +
+        lhs->to_string({ NESTED, 5 }) +
+        " " + sass_op_to_name(op) + " " +
+        rhs->to_string({ TO_SASS, 5 }) +
+        "\".";
+    }
+
+    InvalidNullOperation::InvalidNullOperation(const Expression* lhs, const Expression* rhs, enum Sass_OP op)
+    : UndefinedOperation(lhs, rhs, op)
+    {
+      msg = def_op_null_msg + ": \"" + lhs->inspect() + " " + sass_op_to_name(op) + " " + rhs->inspect() + "\".";
+    }
+
+    SassValueError::SassValueError(Backtraces traces, SourceSpan pstate, OperationError& err)
+    : Base(pstate, err.what(), traces)
+    {
+      msg = err.what();
+      prefix = err.errtype();
+    }
+
+    TopLevelParent::TopLevelParent(Backtraces traces, SourceSpan pstate)
+      : Base(pstate, "Top-level selectors may not contain the parent selector \"&\".", traces)
+    {
+
+    }
+
+    UnsatisfiedExtend::UnsatisfiedExtend(Backtraces traces, Extension extension)
+      : Base(extension.target->pstate(), "The target selector was not found.\n"
+        "Use \"@extend " + extension.target->to_string() + " !optional\" to avoid this error.", traces)
+    {
+
+    }
+
+    ExtendAcrossMedia::ExtendAcrossMedia(Backtraces traces, Extension extension)
+      : Base(extension.target->pstate(), "You may not @extend selectors across media queries.\n"
+        "Use \"@extend " + extension.target->to_string() + " !optional\" to avoid this error.", traces)
+    {
+
+    }
+    
+
+  }
+
+
+  void warn(sass::string msg, SourceSpan pstate)
+  {
+    std::cerr << "Warning: " << msg << std::endl;
+  }
+
+  void warning(sass::string msg, SourceSpan pstate)
+  {
+    sass::string cwd(Sass::File::get_cwd());
+    sass::string abs_path(Sass::File::rel2abs(pstate.getPath(), cwd, cwd));
+    sass::string rel_path(Sass::File::abs2rel(pstate.getPath(), cwd, cwd));
+    sass::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.getPath()));
+
+    std::cerr << "WARNING on line " << pstate.getLine() << ", column " << pstate.getColumn() << " of " << output_path << ":" << std::endl;
+    std::cerr << msg << std::endl << std::endl;
+  }
+
+  void warn(sass::string msg, SourceSpan pstate, Backtrace* bt)
+  {
+    warn(msg, pstate);
+  }
+
+  void deprecated_function(sass::string msg, SourceSpan pstate)
+  {
+    sass::string cwd(Sass::File::get_cwd());
+    sass::string abs_path(Sass::File::rel2abs(pstate.getPath(), cwd, cwd));
+    sass::string rel_path(Sass::File::abs2rel(pstate.getPath(), cwd, cwd));
+    sass::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.getPath()));
+
+    std::cerr << "DEPRECATION WARNING: " << msg << std::endl;
+    std::cerr << "will be an error in future versions of Sass." << std::endl;
+    std::cerr << "        on line " << pstate.getLine() << " of " << output_path << std::endl;
+  }
+
+  void deprecated(sass::string msg, sass::string msg2, bool with_column, SourceSpan pstate)
+  {
+    sass::string cwd(Sass::File::get_cwd());
+    sass::string abs_path(Sass::File::rel2abs(pstate.getPath(), cwd, cwd));
+    sass::string rel_path(Sass::File::abs2rel(pstate.getPath(), cwd, cwd));
+    sass::string output_path(Sass::File::path_for_console(rel_path, pstate.getPath(), pstate.getPath()));
+
+    std::cerr << "DEPRECATION WARNING on line " << pstate.getLine();
+    // if (with_column) std::cerr << ", column " << pstate.column + pstate.offset.column + 1;
+    if (output_path.length()) std::cerr << " of " << output_path;
+    std::cerr << ":" << std::endl;
+    std::cerr << msg << std::endl;
+    if (msg2.length()) std::cerr << msg2 << std::endl;
+    std::cerr << std::endl;
+  }
+
+  void deprecated_bind(sass::string msg, SourceSpan pstate)
+  {
+    sass::string cwd(Sass::File::get_cwd());
+    sass::string abs_path(Sass::File::rel2abs(pstate.getPath(), cwd, cwd));
+    sass::string rel_path(Sass::File::abs2rel(pstate.getPath(), cwd, cwd));
+    sass::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.getPath()));
+
+    std::cerr << "WARNING: " << msg << std::endl;
+    std::cerr << "        on line " << pstate.getLine() << " of " << output_path << std::endl;
+    std::cerr << "This will be an error in future versions of Sass." << std::endl;
+  }
+
+  // should be replaced with error with backtraces
+  void coreError(sass::string msg, SourceSpan pstate)
+  {
+    Backtraces traces;
+    throw Exception::InvalidSyntax(pstate, traces, msg);
+  }
+
+  void error(sass::string msg, SourceSpan pstate, Backtraces& traces)
+  {
+    traces.push_back(Backtrace(pstate));
+    throw Exception::InvalidSyntax(pstate, traces, msg);
+  }
+
+}

data/ext/libsass/src/error_handling.hpp

@@ -0,0 +1,248 @@
+#ifndef SASS_ERROR_HANDLING_H
+#define SASS_ERROR_HANDLING_H
+
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <string>
+#include <sstream>
+#include <stdexcept>
+#include "units.hpp"
+#include "position.hpp"
+#include "backtrace.hpp"
+#include "ast_fwd_decl.hpp"
+#include "sass/functions.h"
+
+namespace Sass {
+
+  struct Backtrace;
+
+  namespace Exception {
+
+    const sass::string def_msg = "Invalid sass detected";
+    const sass::string def_op_msg = "Undefined operation";
+    const sass::string def_op_null_msg = "Invalid null operation";
+    const sass::string def_nesting_limit = "Code too deeply nested";
+
+    class Base : public std::runtime_error {
+      protected:
+        sass::string msg;
+        sass::string prefix;
+      public:
+        SourceSpan pstate;
+        Backtraces traces;
+      public:
+        Base(SourceSpan pstate, sass::string msg, Backtraces traces);
+        virtual const char* errtype() const { return prefix.c_str(); }
+        virtual const char* what() const throw() { return msg.c_str(); }
+        virtual ~Base() throw() {};
+    };
+
+    class InvalidSass : public Base {
+      public:
+        InvalidSass(SourceSpan pstate, Backtraces traces, sass::string msg);
+        virtual ~InvalidSass() throw() {};
+    };
+
+    class InvalidParent : public Base {
+      protected:
+        Selector* parent;
+        Selector* selector;
+      public:
+        InvalidParent(Selector* parent, Backtraces traces, Selector* selector);
+        virtual ~InvalidParent() throw() {};
+    };
+
+    class MissingArgument : public Base {
+      protected:
+        sass::string fn;
+        sass::string arg;
+        sass::string fntype;
+      public:
+        MissingArgument(SourceSpan pstate, Backtraces traces, sass::string fn, sass::string arg, sass::string fntype);
+        virtual ~MissingArgument() throw() {};
+    };
+
+    class InvalidArgumentType : public Base {
+      protected:
+        sass::string fn;
+        sass::string arg;
+        sass::string type;
+        const Value* value;
+      public:
+        InvalidArgumentType(SourceSpan pstate, Backtraces traces, sass::string fn, sass::string arg, sass::string type, const Value* value = 0);
+        virtual ~InvalidArgumentType() throw() {};
+    };
+
+    class InvalidVarKwdType : public Base {
+      protected:
+        sass::string name;
+        const Argument* arg;
+      public:
+        InvalidVarKwdType(SourceSpan pstate, Backtraces traces, sass::string name, const Argument* arg = 0);
+        virtual ~InvalidVarKwdType() throw() {};
+    };
+
+    class InvalidSyntax : public Base {
+      public:
+        InvalidSyntax(SourceSpan pstate, Backtraces traces, sass::string msg);
+        virtual ~InvalidSyntax() throw() {};
+    };
+
+    class NestingLimitError : public Base {
+      public:
+        NestingLimitError(SourceSpan pstate, Backtraces traces, sass::string msg = def_nesting_limit);
+        virtual ~NestingLimitError() throw() {};
+    };
+
+    class DuplicateKeyError : public Base {
+      protected:
+        const Map& dup;
+        const Expression& org;
+      public:
+        DuplicateKeyError(Backtraces traces, const Map& dup, const Expression& org);
+        virtual const char* errtype() const { return "Error"; }
+        virtual ~DuplicateKeyError() throw() {};
+    };
+
+    class TypeMismatch : public Base {
+      protected:
+        const Expression& var;
+        const sass::string type;
+      public:
+        TypeMismatch(Backtraces traces, const Expression& var, const sass::string type);
+        virtual const char* errtype() const { return "Error"; }
+        virtual ~TypeMismatch() throw() {};
+    };
+
+    class InvalidValue : public Base {
+      protected:
+        const Expression& val;
+      public:
+        InvalidValue(Backtraces traces, const Expression& val);
+        virtual const char* errtype() const { return "Error"; }
+        virtual ~InvalidValue() throw() {};
+    };
+
+    class StackError : public Base {
+      protected:
+        const AST_Node& node;
+      public:
+        StackError(Backtraces traces, const AST_Node& node);
+        virtual const char* errtype() const { return "SystemStackError"; }
+        virtual ~StackError() throw() {};
+    };
+
+    class EndlessExtendError : public Base {
+    protected:
+      const AST_Node& node;
+    public:
+      EndlessExtendError(Backtraces traces, const AST_Node& node);
+      virtual const char* errtype() const { return "EndlessExtendError"; }
+      virtual ~EndlessExtendError() throw() {};
+    };
+
+    /* common virtual base class (has no pstate or trace) */
+    class OperationError : public std::runtime_error {
+      protected:
+        sass::string msg;
+      public:
+        OperationError(sass::string msg = def_op_msg)
+        : std::runtime_error(msg.c_str()), msg(msg)
+        {};
+      public:
+        virtual const char* errtype() const { return "Error"; }
+        virtual const char* what() const throw() { return msg.c_str(); }
+        virtual ~OperationError() throw() {};
+    };
+
+    class ZeroDivisionError : public OperationError {
+      protected:
+        const Expression& lhs;
+        const Expression& rhs;
+      public:
+        ZeroDivisionError(const Expression& lhs, const Expression& rhs);
+        virtual const char* errtype() const { return "ZeroDivisionError"; }
+        virtual ~ZeroDivisionError() throw() {};
+    };
+
+    class IncompatibleUnits : public OperationError {
+      protected:
+        // const Sass::UnitType lhs;
+        // const Sass::UnitType rhs;
+      public:
+        IncompatibleUnits(const Units& lhs, const Units& rhs);
+        IncompatibleUnits(const UnitType lhs, const UnitType rhs);
+        virtual ~IncompatibleUnits() throw() {};
+    };
+
+    class UndefinedOperation : public OperationError {
+      protected:
+        const Expression* lhs;
+        const Expression* rhs;
+        const Sass_OP op;
+      public:
+        UndefinedOperation(const Expression* lhs, const Expression* rhs, enum Sass_OP op);
+        // virtual const char* errtype() const { return "Error"; }
+        virtual ~UndefinedOperation() throw() {};
+    };
+
+    class InvalidNullOperation : public UndefinedOperation {
+      public:
+        InvalidNullOperation(const Expression* lhs, const Expression* rhs, enum Sass_OP op);
+        virtual ~InvalidNullOperation() throw() {};
+    };
+
+    class AlphaChannelsNotEqual : public OperationError {
+      protected:
+        const Expression* lhs;
+        const Expression* rhs;
+        const Sass_OP op;
+      public:
+        AlphaChannelsNotEqual(const Expression* lhs, const Expression* rhs, enum Sass_OP op);
+        // virtual const char* errtype() const { return "Error"; }
+        virtual ~AlphaChannelsNotEqual() throw() {};
+    };
+
+    class SassValueError : public Base {
+    public:
+      SassValueError(Backtraces traces, SourceSpan pstate, OperationError& err);
+      virtual ~SassValueError() throw() {};
+    };
+
+    class TopLevelParent : public Base {
+    public:
+      TopLevelParent(Backtraces traces, SourceSpan pstate);
+      virtual ~TopLevelParent() throw() {};
+    };
+
+    class UnsatisfiedExtend : public Base {
+    public:
+      UnsatisfiedExtend(Backtraces traces, Extension extension);
+      virtual ~UnsatisfiedExtend() throw() {};
+    };
+
+    class ExtendAcrossMedia : public Base {
+    public:
+      ExtendAcrossMedia(Backtraces traces, Extension extension);
+      virtual ~ExtendAcrossMedia() throw() {};
+    };
+
+  }
+
+  void warn(sass::string msg, SourceSpan pstate);
+  void warn(sass::string msg, SourceSpan pstate, Backtrace* bt);
+  void warning(sass::string msg, SourceSpan pstate);
+
+  void deprecated_function(sass::string msg, SourceSpan pstate);
+  void deprecated(sass::string msg, sass::string msg2, bool with_column, SourceSpan pstate);
+  void deprecated_bind(sass::string msg, SourceSpan pstate);
+  // void deprecated(sass::string msg, SourceSpan pstate, Backtrace* bt);
+
+  void coreError(sass::string msg, SourceSpan pstate);
+  void error(sass::string msg, SourceSpan pstate, Backtraces& traces);
+
+}
+
+#endif