sassc 2.0.1 → 2.1.0.pre1

data/ext/libsass/src/fn_maps.hpp

@@ -0,0 +1,30 @@
+#ifndef SASS_FN_MAPS_H
+#define SASS_FN_MAPS_H
+
+#include "fn_utils.hpp"
+
+namespace Sass {
+
+  namespace Functions {
+
+    #define ARGM(argname, argtype) get_arg_m(argname, env, sig, pstate, traces)
+
+    extern Signature map_get_sig;
+    extern Signature map_merge_sig;
+    extern Signature map_remove_sig;
+    extern Signature map_keys_sig;
+    extern Signature map_values_sig;
+    extern Signature map_has_key_sig;
+
+    BUILT_IN(map_get);
+    BUILT_IN(map_merge);
+    BUILT_IN(map_remove);
+    BUILT_IN(map_keys);
+    BUILT_IN(map_values);
+    BUILT_IN(map_has_key);
+
+  }
+
+}
+
+#endif

data/ext/libsass/src/fn_miscs.cpp

@@ -0,0 +1,256 @@
+#include "ast.hpp"
+#include "expand.hpp"
+#include "fn_utils.hpp"
+#include "fn_miscs.hpp"
+#include "util_string.hpp"
+
+namespace Sass {
+
+  namespace Functions {
+
+    // features
+    static std::set<std::string> features {
+      "global-variable-shadowing",
+      "extend-selector-pseudoclass",
+      "at-error",
+      "units-level-3",
+      "custom-property"
+    };
+
+    //////////////////////////
+    // INTROSPECTION FUNCTIONS
+    //////////////////////////
+
+    Signature type_of_sig = "type-of($value)";
+    BUILT_IN(type_of)
+    {
+      Expression* v = ARG("$value", Expression);
+      return SASS_MEMORY_NEW(String_Quoted, pstate, v->type());
+    }
+
+    Signature variable_exists_sig = "variable-exists($name)";
+    BUILT_IN(variable_exists)
+    {
+      std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
+
+      if(d_env.has("$"+s)) {
+        return SASS_MEMORY_NEW(Boolean, pstate, true);
+      }
+      else {
+        return SASS_MEMORY_NEW(Boolean, pstate, false);
+      }
+    }
+
+    Signature global_variable_exists_sig = "global-variable-exists($name)";
+    BUILT_IN(global_variable_exists)
+    {
+      std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
+
+      if(d_env.has_global("$"+s)) {
+        return SASS_MEMORY_NEW(Boolean, pstate, true);
+      }
+      else {
+        return SASS_MEMORY_NEW(Boolean, pstate, false);
+      }
+    }
+
+    Signature function_exists_sig = "function-exists($name)";
+    BUILT_IN(function_exists)
+    {
+      String_Constant* ss = Cast<String_Constant>(env["$name"]);
+      if (!ss) {
+        error("$name: " + (env["$name"]->to_string()) + " is not a string for `function-exists'", pstate, traces);
+      }
+
+      std::string name = Util::normalize_underscores(unquote(ss->value()));
+
+      if(d_env.has(name+"[f]")) {
+        return SASS_MEMORY_NEW(Boolean, pstate, true);
+      }
+      else {
+        return SASS_MEMORY_NEW(Boolean, pstate, false);
+      }
+    }
+
+    Signature mixin_exists_sig = "mixin-exists($name)";
+    BUILT_IN(mixin_exists)
+    {
+      std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
+
+      if(d_env.has(s+"[m]")) {
+        return SASS_MEMORY_NEW(Boolean, pstate, true);
+      }
+      else {
+        return SASS_MEMORY_NEW(Boolean, pstate, false);
+      }
+    }
+
+    Signature feature_exists_sig = "feature-exists($name)";
+    BUILT_IN(feature_exists)
+    {
+      std::string s = unquote(ARG("$name", String_Constant)->value());
+
+      if(features.find(s) == features.end()) {
+        return SASS_MEMORY_NEW(Boolean, pstate, false);
+      }
+      else {
+        return SASS_MEMORY_NEW(Boolean, pstate, true);
+      }
+    }
+
+    Signature call_sig = "call($name, $args...)";
+    BUILT_IN(call)
+    {
+      std::string name;
+      Function* ff = Cast<Function>(env["$name"]);
+      String_Constant* ss = Cast<String_Constant>(env["$name"]);
+
+      if (ss) {
+        name = Util::normalize_underscores(unquote(ss->value()));
+        std::cerr << "DEPRECATION WARNING: ";
+        std::cerr << "Passing a string to call() is deprecated and will be illegal" << std::endl;
+        std::cerr << "in Sass 4.0. Use call(get-function(" + quote(name) + ")) instead." << std::endl;
+        std::cerr << std::endl;
+      } else if (ff) {
+        name = ff->name();
+      }
+
+      List_Obj arglist = SASS_MEMORY_COPY(ARG("$args", List));
+
+      Arguments_Obj args = SASS_MEMORY_NEW(Arguments, pstate);
+      // std::string full_name(name + "[f]");
+      // Definition* def = d_env.has(full_name) ? Cast<Definition>((d_env)[full_name]) : 0;
+      // Parameters* params = def ? def->parameters() : 0;
+      // size_t param_size = params ? params->length() : 0;
+      for (size_t i = 0, L = arglist->length(); i < L; ++i) {
+        Expression_Obj expr = arglist->value_at_index(i);
+        // if (params && params->has_rest_parameter()) {
+        //   Parameter_Obj p = param_size > i ? (*params)[i] : 0;
+        //   List* list = Cast<List>(expr);
+        //   if (list && p && !p->is_rest_parameter()) expr = (*list)[0];
+        // }
+        if (arglist->is_arglist()) {
+          Expression_Obj obj = arglist->at(i);
+          Argument_Obj arg = (Argument*) obj.ptr(); // XXX
+          args->append(SASS_MEMORY_NEW(Argument,
+                                       pstate,
+                                       expr,
+                                       arg ? arg->name() : "",
+                                       arg ? arg->is_rest_argument() : false,
+                                       arg ? arg->is_keyword_argument() : false));
+        } else {
+          args->append(SASS_MEMORY_NEW(Argument, pstate, expr));
+        }
+      }
+      Function_Call_Obj func = SASS_MEMORY_NEW(Function_Call, pstate, name, args);
+      Expand expand(ctx, &d_env, &selector_stack);
+      func->via_call(true); // calc invoke is allowed
+      if (ff) func->func(ff);
+      return Cast<PreValue>(func->perform(&expand.eval));
+    }
+
+    ////////////////////
+    // BOOLEAN FUNCTIONS
+    ////////////////////
+
+    Signature not_sig = "not($value)";
+    BUILT_IN(sass_not)
+    {
+      return SASS_MEMORY_NEW(Boolean, pstate, ARG("$value", Expression)->is_false());
+    }
+
+    Signature if_sig = "if($condition, $if-true, $if-false)";
+    // BUILT_IN(sass_if)
+    // { return ARG("$condition", Expression)->is_false() ? ARG("$if-false", Expression) : ARG("$if-true", Expression); }
+    BUILT_IN(sass_if)
+    {
+      Expand expand(ctx, &d_env, &selector_stack);
+      Expression_Obj cond = ARG("$condition", Expression)->perform(&expand.eval);
+      bool is_true = !cond->is_false();
+      Expression_Obj res = ARG(is_true ? "$if-true" : "$if-false", Expression);
+      Value_Obj qwe = Cast<Value>(res->perform(&expand.eval));
+      // res = res->perform(&expand.eval.val_eval);
+      qwe->set_delayed(false); // clone?
+      return qwe.detach();
+    }
+
+    //////////////////////////
+    // MISCELLANEOUS FUNCTIONS
+    //////////////////////////
+
+    // value.check_deprecated_interp if value.is_a?(Sass::Script::Value::String)
+    // unquoted_string(value.to_sass)
+
+    Signature inspect_sig = "inspect($value)";
+    BUILT_IN(inspect)
+    {
+      Expression* v = ARG("$value", Expression);
+      if (v->concrete_type() == Expression::NULL_VAL) {
+        return SASS_MEMORY_NEW(String_Constant, pstate, "null");
+      } else if (v->concrete_type() == Expression::BOOLEAN && v->is_false()) {
+        return SASS_MEMORY_NEW(String_Constant, pstate, "false");
+      } else if (v->concrete_type() == Expression::STRING) {
+        String_Constant *s = Cast<String_Constant>(v);
+        if (s->quote_mark()) {
+          return SASS_MEMORY_NEW(String_Constant, pstate, quote(s->value(), s->quote_mark()));
+        } else {
+          return s;
+        }
+      } else {
+        // ToDo: fix to_sass for nested parentheses
+        Sass_Output_Style old_style;
+        old_style = ctx.c_options.output_style;
+        ctx.c_options.output_style = TO_SASS;
+        Emitter emitter(ctx.c_options);
+        Inspect i(emitter);
+        i.in_declaration = false;
+        v->perform(&i);
+        ctx.c_options.output_style = old_style;
+        return SASS_MEMORY_NEW(String_Quoted, pstate, i.get_buffer());
+      }
+      // return v;
+    }
+
+    Signature content_exists_sig = "content-exists()";
+    BUILT_IN(content_exists)
+    {
+      if (!d_env.has_global("is_in_mixin")) {
+        error("Cannot call content-exists() except within a mixin.", pstate, traces);
+      }
+      return SASS_MEMORY_NEW(Boolean, pstate, d_env.has_lexical("@content[m]"));
+    }
+
+    Signature get_function_sig = "get-function($name, $css: false)";
+    BUILT_IN(get_function)
+    {
+      String_Constant* ss = Cast<String_Constant>(env["$name"]);
+      if (!ss) {
+        error("$name: " + (env["$name"]->to_string()) + " is not a string for `get-function'", pstate, traces);
+      }
+
+      std::string name = Util::normalize_underscores(unquote(ss->value()));
+      std::string full_name = name + "[f]";
+
+      Boolean_Obj css = ARG("$css", Boolean);
+      if (!css->is_false()) {
+        Definition* def = SASS_MEMORY_NEW(Definition,
+                                         pstate,
+                                         name,
+                                         SASS_MEMORY_NEW(Parameters, pstate),
+                                         SASS_MEMORY_NEW(Block, pstate, 0, false),
+                                         Definition::FUNCTION);
+        return SASS_MEMORY_NEW(Function, pstate, def, true);
+      }
+
+
+      if (!d_env.has_global(full_name)) {
+        error("Function not found: " + name, pstate, traces);
+      }
+
+      Definition* def = Cast<Definition>(d_env[full_name]);
+      return SASS_MEMORY_NEW(Function, pstate, def, false);
+    }
+
+  }
+
+}

data/ext/libsass/src/fn_miscs.hpp

@@ -0,0 +1,40 @@
+#ifndef SASS_FN_MISCS_H
+#define SASS_FN_MISCS_H
+
+#include "fn_utils.hpp"
+
+namespace Sass {
+
+  namespace Functions {
+
+    extern Signature type_of_sig;
+    extern Signature variable_exists_sig;
+    extern Signature global_variable_exists_sig;
+    extern Signature function_exists_sig;
+    extern Signature mixin_exists_sig;
+    extern Signature feature_exists_sig;
+    extern Signature call_sig;
+    extern Signature not_sig;
+    extern Signature if_sig;
+    extern Signature set_nth_sig;
+    extern Signature content_exists_sig;
+    extern Signature get_function_sig;
+
+    BUILT_IN(type_of);
+    BUILT_IN(variable_exists);
+    BUILT_IN(global_variable_exists);
+    BUILT_IN(function_exists);
+    BUILT_IN(mixin_exists);
+    BUILT_IN(feature_exists);
+    BUILT_IN(call);
+    BUILT_IN(sass_not);
+    BUILT_IN(sass_if);
+    BUILT_IN(set_nth);
+    BUILT_IN(content_exists);
+    BUILT_IN(get_function);
+
+  }
+
+}
+
+#endif

data/ext/libsass/src/fn_numbers.cpp

@@ -0,0 +1,220 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <cstdint>
+#include <cstdlib>
+#include <cmath>
+#include <cctype>
+#include <random>
+#include <sstream>
+#include <iomanip>
+#include <algorithm>
+
+#include "ast.hpp"
+#include "units.hpp"
+#include "fn_utils.hpp"
+#include "fn_numbers.hpp"
+
+#ifdef __MINGW32__
+#include "windows.h"
+#include "wincrypt.h"
+#endif
+
+namespace Sass {
+
+  namespace Functions {
+
+    #ifdef __MINGW32__
+      uint64_t GetSeed()
+      {
+        HCRYPTPROV hp = 0;
+        BYTE rb[8];
+        CryptAcquireContext(&hp, 0, 0, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
+        CryptGenRandom(hp, sizeof(rb), rb);
+        CryptReleaseContext(hp, 0);
+
+        uint64_t seed;
+        memcpy(&seed, &rb[0], sizeof(seed));
+
+        return seed;
+      }
+    #else
+      uint64_t GetSeed()
+      {
+        std::random_device rd;
+        return rd();
+      }
+    #endif
+
+    // note: the performance of many implementations of
+    // random_device degrades sharply once the entropy pool
+    // is exhausted. For practical use, random_device is
+    // generally only used to seed a PRNG such as mt19937.
+    static std::mt19937 rand(static_cast<unsigned int>(GetSeed()));
+
+    ///////////////////
+    // NUMBER FUNCTIONS
+    ///////////////////
+
+    Signature percentage_sig = "percentage($number)";
+    BUILT_IN(percentage)
+    {
+      Number_Obj n = ARGN("$number");
+      if (!n->is_unitless()) error("argument $number of `" + std::string(sig) + "` must be unitless", pstate, traces);
+      return SASS_MEMORY_NEW(Number, pstate, n->value() * 100, "%");
+    }
+
+    Signature round_sig = "round($number)";
+    BUILT_IN(round)
+    {
+      Number_Obj r = ARGN("$number");
+      r->value(Sass::round(r->value(), ctx.c_options.precision));
+      r->pstate(pstate);
+      return r.detach();
+    }
+
+    Signature ceil_sig = "ceil($number)";
+    BUILT_IN(ceil)
+    {
+      Number_Obj r = ARGN("$number");
+      r->value(std::ceil(r->value()));
+      r->pstate(pstate);
+      return r.detach();
+    }
+
+    Signature floor_sig = "floor($number)";
+    BUILT_IN(floor)
+    {
+      Number_Obj r = ARGN("$number");
+      r->value(std::floor(r->value()));
+      r->pstate(pstate);
+      return r.detach();
+    }
+
+    Signature abs_sig = "abs($number)";
+    BUILT_IN(abs)
+    {
+      Number_Obj r = ARGN("$number");
+      r->value(std::abs(r->value()));
+      r->pstate(pstate);
+      return r.detach();
+    }
+
+    Signature min_sig = "min($numbers...)";
+    BUILT_IN(min)
+    {
+      List* arglist = ARG("$numbers", List);
+      Number_Obj least;
+      for (size_t i = 0, L = arglist->length(); i < L; ++i) {
+        Expression_Obj val = arglist->value_at_index(i);
+        Number_Obj xi = Cast<Number>(val);
+        if (!xi) {
+          error("\"" + val->to_string(ctx.c_options) + "\" is not a number for `min'", pstate, traces);
+        }
+        if (least) {
+          if (*xi < *least) least = xi;
+        } else least = xi;
+      }
+      return least.detach();
+    }
+
+    Signature max_sig = "max($numbers...)";
+    BUILT_IN(max)
+    {
+      List* arglist = ARG("$numbers", List);
+      Number_Obj greatest;
+      for (size_t i = 0, L = arglist->length(); i < L; ++i) {
+        Expression_Obj val = arglist->value_at_index(i);
+        Number_Obj xi = Cast<Number>(val);
+        if (!xi) {
+          error("\"" + val->to_string(ctx.c_options) + "\" is not a number for `max'", pstate, traces);
+        }
+        if (greatest) {
+          if (*greatest < *xi) greatest = xi;
+        } else greatest = xi;
+      }
+      return greatest.detach();
+    }
+
+    Signature random_sig = "random($limit:false)";
+    BUILT_IN(random)
+    {
+      AST_Node_Obj arg = env["$limit"];
+      Value* v = Cast<Value>(arg);
+      Number* l = Cast<Number>(arg);
+      Boolean* b = Cast<Boolean>(arg);
+      if (l) {
+        double lv = l->value();
+        if (lv < 1) {
+          std::stringstream err;
+          err << "$limit " << lv << " must be greater than or equal to 1 for `random'";
+          error(err.str(), pstate, traces);
+        }
+        bool eq_int = std::fabs(trunc(lv) - lv) < NUMBER_EPSILON;
+        if (!eq_int) {
+          std::stringstream err;
+          err << "Expected $limit to be an integer but got " << lv << " for `random'";
+          error(err.str(), pstate, traces);
+        }
+        std::uniform_real_distribution<> distributor(1, lv + 1);
+        uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
+        return SASS_MEMORY_NEW(Number, pstate, (double)distributed);
+      }
+      else if (b) {
+        std::uniform_real_distribution<> distributor(0, 1);
+        double distributed = static_cast<double>(distributor(rand));
+        return SASS_MEMORY_NEW(Number, pstate, distributed);
+      } else if (v) {
+        traces.push_back(Backtrace(pstate));
+        throw Exception::InvalidArgumentType(pstate, traces, "random", "$limit", "number", v);
+      } else {
+        traces.push_back(Backtrace(pstate));
+        throw Exception::InvalidArgumentType(pstate, traces, "random", "$limit", "number");
+      }
+    }
+
+    Signature unique_id_sig = "unique-id()";
+    BUILT_IN(unique_id)
+    {
+      std::stringstream ss;
+      std::uniform_real_distribution<> distributor(0, 4294967296); // 16^8
+      uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
+      ss << "u" << std::setfill('0') << std::setw(8) << std::hex << distributed;
+      return SASS_MEMORY_NEW(String_Quoted, pstate, ss.str());
+    }
+
+    Signature unit_sig = "unit($number)";
+    BUILT_IN(unit)
+    {
+      Number_Obj arg = ARGN("$number");
+      std::string str(quote(arg->unit(), '"'));
+      return SASS_MEMORY_NEW(String_Quoted, pstate, str);
+    }
+
+    Signature unitless_sig = "unitless($number)";
+    BUILT_IN(unitless)
+    {
+      Number_Obj arg = ARGN("$number");
+      bool unitless = arg->is_unitless();
+      return SASS_MEMORY_NEW(Boolean, pstate, unitless);
+    }
+
+    Signature comparable_sig = "comparable($number-1, $number-2)";
+    BUILT_IN(comparable)
+    {
+      Number_Obj n1 = ARGN("$number-1");
+      Number_Obj n2 = ARGN("$number-2");
+      if (n1->is_unitless() || n2->is_unitless()) {
+        return SASS_MEMORY_NEW(Boolean, pstate, true);
+      }
+      // normalize into main units
+      n1->normalize(); n2->normalize();
+      Units &lhs_unit = *n1, &rhs_unit = *n2;
+      bool is_comparable = (lhs_unit == rhs_unit);
+      return SASS_MEMORY_NEW(Boolean, pstate, is_comparable);
+    }
+
+  }
+
+}