www.aleph1.co.uk Git - yaffs-website/blob - node_modules/node-sass/src/libsass/src/functions.cpp

   1 #include "sass.hpp"
   2 #include "functions.hpp"
   3 #include "ast.hpp"
   4 #include "context.hpp"
   5 #include "backtrace.hpp"
   6 #include "parser.hpp"
   7 #include "constants.hpp"
   8 #include "inspect.hpp"
   9 #include "extend.hpp"
  10 #include "eval.hpp"
  11 #include "util.hpp"
  12 #include "expand.hpp"
  13 #include "utf8_string.hpp"
  14 #include "sass/base.h"
  15 #include "utf8.h"
  16
  17 #include <cstdint>
  18 #include <cstdlib>
  19 #include <cmath>
  20 #include <cctype>
  21 #include <sstream>
  22 #include <string>
  23 #include <iomanip>
  24 #include <iostream>
  25 #include <random>
  26 #include <set>
  27
  28 #ifdef __MINGW32__
  29 #include "windows.h"
  30 #include "wincrypt.h"
  31 #endif
  32
  33 #define ARG(argname, argtype) get_arg<argtype>(argname, env, sig, pstate, backtrace)
  34 #define ARGR(argname, argtype, lo, hi) get_arg_r(argname, env, sig, pstate, lo, hi, backtrace)
  35 #define ARGM(argname, argtype, ctx) get_arg_m(argname, env, sig, pstate, backtrace, ctx)
  36
  37 namespace Sass {
  38   using std::stringstream;
  39   using std::endl;
  40
  41   Definition_Ptr make_native_function(Signature sig, Native_Function func, Context& ctx)
  42   {
  43     Parser sig_parser = Parser::from_c_str(sig, ctx, ParserState("[built-in function]"));
  44     sig_parser.lex<Prelexer::identifier>();
  45     std::string name(Util::normalize_underscores(sig_parser.lexed));
  46     Parameters_Obj params = sig_parser.parse_parameters();
  47     return SASS_MEMORY_NEW(Definition,
  48                            ParserState("[built-in function]"),
  49                            sig,
  50                            name,
  51                            params,
  52                            func,
  53                            false);
  54   }
  55
  56   Definition_Ptr make_c_function(Sass_Function_Entry c_func, Context& ctx)
  57   {
  58     using namespace Prelexer;
  59
  60     const char* sig = sass_function_get_signature(c_func);
  61     Parser sig_parser = Parser::from_c_str(sig, ctx, ParserState("[c function]"));
  62     // allow to overload generic callback plus @warn, @error and @debug with custom functions
  63     sig_parser.lex < alternatives < identifier, exactly <'*'>,
  64                                     exactly < Constants::warn_kwd >,
  65                                     exactly < Constants::error_kwd >,
  66                                     exactly < Constants::debug_kwd >
  67                    >              >();
  68     std::string name(Util::normalize_underscores(sig_parser.lexed));
  69     Parameters_Obj params = sig_parser.parse_parameters();
  70     return SASS_MEMORY_NEW(Definition,
  71                            ParserState("[c function]"),
  72                            sig,
  73                            name,
  74                            params,
  75                            c_func,
  76                            false, true);
  77   }
  78
  79   std::string function_name(Signature sig)
  80   {
  81     std::string str(sig);
  82     return str.substr(0, str.find('('));
  83   }
  84
  85   namespace Functions {
  86
  87     inline void handle_utf8_error (const ParserState& pstate, Backtrace* backtrace)
  88     {
  89       try {
  90        throw;
  91       }
  92       catch (utf8::invalid_code_point) {
  93         std::string msg("utf8::invalid_code_point");
  94         error(msg, pstate, backtrace);
  95       }
  96       catch (utf8::not_enough_room) {
  97         std::string msg("utf8::not_enough_room");
  98         error(msg, pstate, backtrace);
  99       }
 100       catch (utf8::invalid_utf8) {
 101         std::string msg("utf8::invalid_utf8");
 102         error(msg, pstate, backtrace);
 103       }
 104       catch (...) { throw; }
 105     }
 106
 107     template <typename T>
 108     T* get_arg(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace)
 109     {
 110       // Minimal error handling -- the expectation is that built-ins will be written correctly!
 111       T* val = Cast<T>(env[argname]);
 112       if (!val) {
 113         std::string msg("argument `");
 114         msg += argname;
 115         msg += "` of `";
 116         msg += sig;
 117         msg += "` must be a ";
 118         msg += T::type_name();
 119         error(msg, pstate, backtrace);
 120       }
 121       return val;
 122     }
 123
 124     Map_Ptr get_arg_m(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx)
 125     {
 126       // Minimal error handling -- the expectation is that built-ins will be written correctly!
 127       Map_Ptr val = Cast<Map>(env[argname]);
 128       if (val) return val;
 129
 130       List_Ptr lval = Cast<List>(env[argname]);
 131       if (lval && lval->length() == 0) return SASS_MEMORY_NEW(Map, pstate, 0);
 132
 133       // fallback on get_arg for error handling
 134       val = get_arg<Map>(argname, env, sig, pstate, backtrace);
 135       return val;
 136     }
 137
 138     Number_Ptr get_arg_r(const std::string& argname, Env& env, Signature sig, ParserState pstate, double lo, double hi, Backtrace* backtrace)
 139     {
 140       // Minimal error handling -- the expectation is that built-ins will be written correctly!
 141       Number_Ptr val = get_arg<Number>(argname, env, sig, pstate, backtrace);
 142       double v = val->value();
 143       if (!(lo <= v && v <= hi)) {
 144         std::stringstream msg;
 145         msg << "argument `" << argname << "` of `" << sig << "` must be between ";
 146         msg << lo << " and " << hi;
 147         error(msg.str(), pstate, backtrace);
 148       }
 149       return val;
 150     }
 151
 152     #define ARGSEL(argname, seltype, contextualize) get_arg_sel<seltype>(argname, env, sig, pstate, backtrace, ctx)
 153
 154     template <typename T>
 155     T get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx);
 156
 157     template <>
 158     Selector_List_Obj get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
 159       Expression_Obj exp = ARG(argname, Expression);
 160       if (exp->concrete_type() == Expression::NULL_VAL) {
 161         std::stringstream msg;
 162         msg << argname << ": null is not a valid selector: it must be a string,\n";
 163         msg << "a list of strings, or a list of lists of strings for `" << function_name(sig) << "'";
 164         error(msg.str(), pstate);
 165       }
 166       if (String_Constant_Ptr str = Cast<String_Constant>(exp)) {
 167         str->quote_mark(0);
 168       }
 169       std::string exp_src = exp->to_string(ctx.c_options);
 170       return Parser::parse_selector(exp_src.c_str(), ctx);
 171     }
 172
 173     template <>
 174     Compound_Selector_Obj get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
 175       Expression_Obj exp = ARG(argname, Expression);
 176       if (exp->concrete_type() == Expression::NULL_VAL) {
 177         std::stringstream msg;
 178         msg << argname << ": null is not a string for `" << function_name(sig) << "'";
 179         error(msg.str(), pstate);
 180       }
 181       if (String_Constant_Ptr str = Cast<String_Constant>(exp)) {
 182         str->quote_mark(0);
 183       }
 184       std::string exp_src = exp->to_string(ctx.c_options);
 185       Selector_List_Obj sel_list = Parser::parse_selector(exp_src.c_str(), ctx);
 186       if (sel_list->length() == 0) return NULL;
 187       return sel_list->first()->tail()->head();
 188     }
 189
 190     #ifdef __MINGW32__
 191     uint64_t GetSeed()
 192     {
 193       HCRYPTPROV hp = 0;
 194       BYTE rb[8];
 195       CryptAcquireContext(&hp, 0, 0, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
 196       CryptGenRandom(hp, sizeof(rb), rb);
 197       CryptReleaseContext(hp, 0);
 198
 199       uint64_t seed;
 200       memcpy(&seed, &rb[0], sizeof(seed));
 201
 202       return seed;
 203     }
 204     #else
 205     uint64_t GetSeed()
 206     {
 207       std::random_device rd;
 208       return rd();
 209     }
 210     #endif
 211
 212     // note: the performance of many  implementations of
 213     // random_device degrades sharply once the entropy pool
 214     // is exhausted. For practical use, random_device is
 215     // generally only used to seed a PRNG such as mt19937.
 216     static std::mt19937 rand(static_cast<unsigned int>(GetSeed()));
 217
 218     // features
 219     static std::set<std::string> features {
 220       "global-variable-shadowing",
 221       "extend-selector-pseudoclass",
 222       "at-error",
 223       "units-level-3"
 224     };
 225
 226     ////////////////
 227     // RGB FUNCTIONS
 228     ////////////////
 229
 230     inline double color_num(Number_Ptr n) {
 231       if (n->unit() == "%") {
 232         return std::min(std::max(n->value() * 255 / 100.0, 0.0), 255.0);
 233       } else {
 234         return std::min(std::max(n->value(), 0.0), 255.0);
 235       }
 236     }
 237
 238     inline double alpha_num(Number_Ptr n) {
 239       if (n->unit() == "%") {
 240         return std::min(std::max(n->value(), 0.0), 100.0);
 241       } else {
 242         return std::min(std::max(n->value(), 0.0), 1.0);
 243       }
 244     }
 245
 246     Signature rgb_sig = "rgb($red, $green, $blue)";
 247     BUILT_IN(rgb)
 248     {
 249       return SASS_MEMORY_NEW(Color,
 250                              pstate,
 251                              color_num(ARG("$red",   Number)),
 252                              color_num(ARG("$green", Number)),
 253                              color_num(ARG("$blue",  Number)));
 254     }
 255
 256     Signature rgba_4_sig = "rgba($red, $green, $blue, $alpha)";
 257     BUILT_IN(rgba_4)
 258     {
 259       return SASS_MEMORY_NEW(Color,
 260                              pstate,
 261                              color_num(ARG("$red",   Number)),
 262                              color_num(ARG("$green", Number)),
 263                              color_num(ARG("$blue",  Number)),
 264                              alpha_num(ARG("$alpha", Number)));
 265     }
 266
 267     Signature rgba_2_sig = "rgba($color, $alpha)";
 268     BUILT_IN(rgba_2)
 269     {
 270       Color_Ptr c_arg = ARG("$color", Color);
 271       Color_Ptr new_c = SASS_MEMORY_COPY(c_arg);
 272       new_c->a(alpha_num(ARG("$alpha", Number)));
 273       new_c->disp("");
 274       return new_c;
 275     }
 276
 277     Signature red_sig = "red($color)";
 278     BUILT_IN(red)
 279     { return SASS_MEMORY_NEW(Number, pstate, ARG("$color", Color)->r()); }
 280
 281     Signature green_sig = "green($color)";
 282     BUILT_IN(green)
 283     { return SASS_MEMORY_NEW(Number, pstate, ARG("$color", Color)->g()); }
 284
 285     Signature blue_sig = "blue($color)";
 286     BUILT_IN(blue)
 287     { return SASS_MEMORY_NEW(Number, pstate, ARG("$color", Color)->b()); }
 288
 289     Color* colormix(Context& ctx, ParserState& pstate, Color* color1, Color* color2, Number* weight) {
 290       double p = weight->value()/100;
 291       double w = 2*p - 1;
 292       double a = color1->a() - color2->a();
 293
 294       double w1 = (((w * a == -1) ? w : (w + a)/(1 + w*a)) + 1)/2.0;
 295       double w2 = 1 - w1;
 296
 297       return SASS_MEMORY_NEW(Color,
 298                              pstate,
 299                              Sass::round(w1*color1->r() + w2*color2->r(), ctx.c_options.precision),
 300                              Sass::round(w1*color1->g() + w2*color2->g(), ctx.c_options.precision),
 301                              Sass::round(w1*color1->b() + w2*color2->b(), ctx.c_options.precision),
 302                              color1->a()*p + color2->a()*(1-p));
 303     }
 304
 305     Signature mix_sig = "mix($color-1, $color-2, $weight: 50%)";
 306     BUILT_IN(mix)
 307     {
 308       Color_Obj  color1 = ARG("$color-1", Color);
 309       Color_Obj  color2 = ARG("$color-2", Color);
 310       Number_Obj weight = ARGR("$weight", Number, 0, 100);
 311       return colormix(ctx, pstate, color1, color2, weight);
 312
 313     }
 314
 315     ////////////////
 316     // HSL FUNCTIONS
 317     ////////////////
 318
 319     // RGB to HSL helper function
 320     struct HSL { double h; double s; double l; };
 321     HSL rgb_to_hsl(double r, double g, double b)
 322     {
 323
 324       // Algorithm from http://en.wikipedia.org/wiki/wHSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV
 325       r /= 255.0; g /= 255.0; b /= 255.0;
 326
 327       double max = std::max(r, std::max(g, b));
 328       double min = std::min(r, std::min(g, b));
 329       double delta = max - min;
 330
 331       double h = 0, s = 0, l = (max + min) / 2.0;
 332
 333       if (max == min) {
 334         h = s = 0; // achromatic
 335       }
 336       else {
 337         if (l < 0.5) s = delta / (max + min);
 338         else         s = delta / (2.0 - max - min);
 339
 340         if      (r == max) h = (g - b) / delta + (g < b ? 6 : 0);
 341         else if (g == max) h = (b - r) / delta + 2;
 342         else if (b == max) h = (r - g) / delta + 4;
 343       }
 344
 345       HSL hsl_struct;
 346       hsl_struct.h = h / 6 * 360;
 347       hsl_struct.s = s * 100;
 348       hsl_struct.l = l * 100;
 349
 350       return hsl_struct;
 351     }
 352
 353     // hue to RGB helper function
 354     double h_to_rgb(double m1, double m2, double h) {
 355       while (h < 0) h += 1;
 356       while (h > 1) h -= 1;
 357       if (h*6.0 < 1) return m1 + (m2 - m1)*h*6;
 358       if (h*2.0 < 1) return m2;
 359       if (h*3.0 < 2) return m1 + (m2 - m1) * (2.0/3.0 - h)*6;
 360       return m1;
 361     }
 362
 363     Color_Ptr hsla_impl(double h, double s, double l, double a, Context& ctx, ParserState pstate)
 364     {
 365       h /= 360.0;
 366       s /= 100.0;
 367       l /= 100.0;
 368
 369       if (l < 0) l = 0;
 370       if (s < 0) s = 0;
 371       if (l > 1) l = 1;
 372       if (s > 1) s = 1;
 373       while (h < 0) h += 1;
 374       while (h > 1) h -= 1;
 375
 376       // if saturation is exacly zero, we loose
 377       // information for hue, since it will evaluate
 378       // to zero if converted back from rgb. Setting
 379       // saturation to a very tiny number solves this.
 380       if (s == 0) s = 1e-10;
 381
 382       // Algorithm from the CSS3 spec: http://www.w3.org/TR/css3-color/#hsl-color.
 383       double m2;
 384       if (l <= 0.5) m2 = l*(s+1.0);
 385       else m2 = (l+s)-(l*s);
 386       double m1 = (l*2.0)-m2;
 387       // round the results -- consider moving this into the Color constructor
 388       double r = (h_to_rgb(m1, m2, h + 1.0/3.0) * 255.0);
 389       double g = (h_to_rgb(m1, m2, h) * 255.0);
 390       double b = (h_to_rgb(m1, m2, h - 1.0/3.0) * 255.0);
 391
 392       return SASS_MEMORY_NEW(Color, pstate, r, g, b, a);
 393     }
 394
 395     Signature hsl_sig = "hsl($hue, $saturation, $lightness)";
 396     BUILT_IN(hsl)
 397     {
 398       return hsla_impl(ARG("$hue", Number)->value(),
 399                        ARG("$saturation", Number)->value(),
 400                        ARG("$lightness",  Number)->value(),
 401                        1.0,
 402                        ctx,
 403                        pstate);
 404     }
 405
 406     Signature hsla_sig = "hsla($hue, $saturation, $lightness, $alpha)";
 407     BUILT_IN(hsla)
 408     {
 409       return hsla_impl(ARG("$hue", Number)->value(),
 410                        ARG("$saturation", Number)->value(),
 411                        ARG("$lightness",  Number)->value(),
 412                        ARG("$alpha",  Number)->value(),
 413                        ctx,
 414                        pstate);
 415     }
 416
 417     Signature hue_sig = "hue($color)";
 418     BUILT_IN(hue)
 419     {
 420       Color_Ptr rgb_color = ARG("$color", Color);
 421       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
 422                                  rgb_color->g(),
 423                                  rgb_color->b());
 424       return SASS_MEMORY_NEW(Number, pstate, hsl_color.h, "deg");
 425     }
 426
 427     Signature saturation_sig = "saturation($color)";
 428     BUILT_IN(saturation)
 429     {
 430       Color_Ptr rgb_color = ARG("$color", Color);
 431       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
 432                                  rgb_color->g(),
 433                                  rgb_color->b());
 434       return SASS_MEMORY_NEW(Number, pstate, hsl_color.s, "%");
 435     }
 436
 437     Signature lightness_sig = "lightness($color)";
 438     BUILT_IN(lightness)
 439     {
 440       Color_Ptr rgb_color = ARG("$color", Color);
 441       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
 442                                  rgb_color->g(),
 443                                  rgb_color->b());
 444       return SASS_MEMORY_NEW(Number, pstate, hsl_color.l, "%");
 445     }
 446
 447     Signature adjust_hue_sig = "adjust-hue($color, $degrees)";
 448     BUILT_IN(adjust_hue)
 449     {
 450       Color_Ptr rgb_color = ARG("$color", Color);
 451       Number_Ptr degrees = ARG("$degrees", Number);
 452       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
 453                                  rgb_color->g(),
 454                                  rgb_color->b());
 455       return hsla_impl(hsl_color.h + degrees->value(),
 456                        hsl_color.s,
 457                        hsl_color.l,
 458                        rgb_color->a(),
 459                        ctx,
 460                        pstate);
 461     }
 462
 463     Signature lighten_sig = "lighten($color, $amount)";
 464     BUILT_IN(lighten)
 465     {
 466       Color_Ptr rgb_color = ARG("$color", Color);
 467       Number_Ptr amount = ARGR("$amount", Number, 0, 100);
 468       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
 469                                  rgb_color->g(),
 470                                  rgb_color->b());
 471       //Check lightness is not negative before lighten it
 472       double hslcolorL = hsl_color.l;
 473       if (hslcolorL < 0) {
 474         hslcolorL = 0;
 475       }
 476
 477       return hsla_impl(hsl_color.h,
 478                        hsl_color.s,
 479                        hslcolorL + amount->value(),
 480                        rgb_color->a(),
 481                        ctx,
 482                        pstate);
 483     }
 484
 485     Signature darken_sig = "darken($color, $amount)";
 486     BUILT_IN(darken)
 487     {
 488       Color_Ptr rgb_color = ARG("$color", Color);
 489       Number_Ptr amount = ARGR("$amount", Number, 0, 100);
 490       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
 491                                  rgb_color->g(),
 492                                  rgb_color->b());
 493
 494       //Check lightness if not over 100, before darken it
 495       double hslcolorL = hsl_color.l;
 496       if (hslcolorL > 100) {
 497         hslcolorL = 100;
 498       }
 499
 500       return hsla_impl(hsl_color.h,
 501                        hsl_color.s,
 502                        hslcolorL - amount->value(),
 503                        rgb_color->a(),
 504                        ctx,
 505                        pstate);
 506     }
 507
 508     Signature saturate_sig = "saturate($color, $amount: false)";
 509     BUILT_IN(saturate)
 510     {
 511       // CSS3 filter function overload: pass literal through directly
 512       Number_Ptr amount = Cast<Number>(env["$amount"]);
 513       if (!amount) {
 514         return SASS_MEMORY_NEW(String_Quoted, pstate, "saturate(" + env["$color"]->to_string(ctx.c_options) + ")");
 515       }
 516
 517       ARGR("$amount", Number, 0, 100);
 518       Color_Ptr rgb_color = ARG("$color", Color);
 519       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
 520                                  rgb_color->g(),
 521                                  rgb_color->b());
 522
 523       double hslcolorS = hsl_color.s + amount->value();
 524
 525       // Saturation cannot be below 0 or above 100
 526       if (hslcolorS < 0) {
 527         hslcolorS = 0;
 528       }
 529       if (hslcolorS > 100) {
 530         hslcolorS = 100;
 531       }
 532
 533       return hsla_impl(hsl_color.h,
 534                        hslcolorS,
 535                        hsl_color.l,
 536                        rgb_color->a(),
 537                        ctx,
 538                        pstate);
 539     }
 540
 541     Signature desaturate_sig = "desaturate($color, $amount)";
 542     BUILT_IN(desaturate)
 543     {
 544       Color_Ptr rgb_color = ARG("$color", Color);
 545       Number_Ptr amount = ARGR("$amount", Number, 0, 100);
 546       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
 547                                  rgb_color->g(),
 548                                  rgb_color->b());
 549
 550       double hslcolorS = hsl_color.s - amount->value();
 551
 552       // Saturation cannot be below 0 or above 100
 553       if (hslcolorS <= 0) {
 554         hslcolorS = 0;
 555       }
 556       if (hslcolorS > 100) {
 557         hslcolorS = 100;
 558       }
 559
 560       return hsla_impl(hsl_color.h,
 561                        hslcolorS,
 562                        hsl_color.l,
 563                        rgb_color->a(),
 564                        ctx,
 565                        pstate);
 566     }
 567
 568     Signature grayscale_sig = "grayscale($color)";
 569     BUILT_IN(grayscale)
 570     {
 571       // CSS3 filter function overload: pass literal through directly
 572       Number_Ptr amount = Cast<Number>(env["$color"]);
 573       if (amount) {
 574         return SASS_MEMORY_NEW(String_Quoted, pstate, "grayscale(" + amount->to_string(ctx.c_options) + ")");
 575       }
 576
 577       Color_Ptr rgb_color = ARG("$color", Color);
 578       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
 579                                  rgb_color->g(),
 580                                  rgb_color->b());
 581       return hsla_impl(hsl_color.h,
 582                        0.0,
 583                        hsl_color.l,
 584                        rgb_color->a(),
 585                        ctx,
 586                        pstate);
 587     }
 588
 589     Signature complement_sig = "complement($color)";
 590     BUILT_IN(complement)
 591     {
 592       Color_Ptr rgb_color = ARG("$color", Color);
 593       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
 594                                  rgb_color->g(),
 595                                  rgb_color->b());
 596       return hsla_impl(hsl_color.h - 180.0,
 597                        hsl_color.s,
 598                        hsl_color.l,
 599                        rgb_color->a(),
 600                        ctx,
 601                        pstate);
 602     }
 603
 604     Signature invert_sig = "invert($color, $weight: 100%)";
 605     BUILT_IN(invert)
 606     {
 607       // CSS3 filter function overload: pass literal through directly
 608       Number_Ptr amount = Cast<Number>(env["$color"]);
 609       if (amount) {
 610         return SASS_MEMORY_NEW(String_Quoted, pstate, "invert(" + amount->to_string(ctx.c_options) + ")");
 611       }
 612
 613       Number_Obj weight = ARGR("$weight", Number, 0, 100);
 614       Color_Ptr rgb_color = ARG("$color", Color);
 615       Color_Obj inv = SASS_MEMORY_NEW(Color,
 616                              pstate,
 617                              255 - rgb_color->r(),
 618                              255 - rgb_color->g(),
 619                              255 - rgb_color->b(),
 620                              rgb_color->a());
 621       return colormix(ctx, pstate, inv, rgb_color, weight);
 622     }
 623
 624     ////////////////////
 625     // OPACITY FUNCTIONS
 626     ////////////////////
 627     Signature alpha_sig = "alpha($color)";
 628     Signature opacity_sig = "opacity($color)";
 629     BUILT_IN(alpha)
 630     {
 631       String_Constant_Ptr ie_kwd = Cast<String_Constant>(env["$color"]);
 632       if (ie_kwd) {
 633         return SASS_MEMORY_NEW(String_Quoted, pstate, "alpha(" + ie_kwd->value() + ")");
 634       }
 635
 636       // CSS3 filter function overload: pass literal through directly
 637       Number_Ptr amount = Cast<Number>(env["$color"]);
 638       if (amount) {
 639         return SASS_MEMORY_NEW(String_Quoted, pstate, "opacity(" + amount->to_string(ctx.c_options) + ")");
 640       }
 641
 642       return SASS_MEMORY_NEW(Number, pstate, ARG("$color", Color)->a());
 643     }
 644
 645     Signature opacify_sig = "opacify($color, $amount)";
 646     Signature fade_in_sig = "fade-in($color, $amount)";
 647     BUILT_IN(opacify)
 648     {
 649       Color_Ptr color = ARG("$color", Color);
 650       double amount = ARGR("$amount", Number, 0, 1)->value();
 651       double alpha = std::min(color->a() + amount, 1.0);
 652       return SASS_MEMORY_NEW(Color,
 653                              pstate,
 654                              color->r(),
 655                              color->g(),
 656                              color->b(),
 657                              alpha);
 658     }
 659
 660     Signature transparentize_sig = "transparentize($color, $amount)";
 661     Signature fade_out_sig = "fade-out($color, $amount)";
 662     BUILT_IN(transparentize)
 663     {
 664       Color_Ptr color = ARG("$color", Color);
 665       double amount = ARGR("$amount", Number, 0, 1)->value();
 666       double alpha = std::max(color->a() - amount, 0.0);
 667       return SASS_MEMORY_NEW(Color,
 668                              pstate,
 669                              color->r(),
 670                              color->g(),
 671                              color->b(),
 672                              alpha);
 673     }
 674
 675     ////////////////////////
 676     // OTHER COLOR FUNCTIONS
 677     ////////////////////////
 678
 679     Signature adjust_color_sig = "adjust-color($color, $red: false, $green: false, $blue: false, $hue: false, $saturation: false, $lightness: false, $alpha: false)";
 680     BUILT_IN(adjust_color)
 681     {
 682       Color_Ptr color = ARG("$color", Color);
 683       Number_Ptr r = Cast<Number>(env["$red"]);
 684       Number_Ptr g = Cast<Number>(env["$green"]);
 685       Number_Ptr b = Cast<Number>(env["$blue"]);
 686       Number_Ptr h = Cast<Number>(env["$hue"]);
 687       Number_Ptr s = Cast<Number>(env["$saturation"]);
 688       Number_Ptr l = Cast<Number>(env["$lightness"]);
 689       Number_Ptr a = Cast<Number>(env["$alpha"]);
 690
 691       bool rgb = r || g || b;
 692       bool hsl = h || s || l;
 693
 694       if (rgb && hsl) {
 695         error("Cannot specify HSL and RGB values for a color at the same time for `adjust-color'", pstate);
 696       }
 697       if (rgb) {
 698         double rr = r ? ARGR("$red",   Number, -255, 255)->value() : 0;
 699         double gg = g ? ARGR("$green", Number, -255, 255)->value() : 0;
 700         double bb = b ? ARGR("$blue",  Number, -255, 255)->value() : 0;
 701         double aa = a ? ARGR("$alpha", Number, -1, 1)->value() : 0;
 702         return SASS_MEMORY_NEW(Color,
 703                                pstate,
 704                                color->r() + rr,
 705                                color->g() + gg,
 706                                color->b() + bb,
 707                                color->a() + aa);
 708       }
 709       if (hsl) {
 710         HSL hsl_struct = rgb_to_hsl(color->r(), color->g(), color->b());
 711         double ss = s ? ARGR("$saturation", Number, -100, 100)->value() : 0;
 712         double ll = l ? ARGR("$lightness",  Number, -100, 100)->value() : 0;
 713         double aa = a ? ARGR("$alpha",      Number, -1, 1)->value() : 0;
 714         return hsla_impl(hsl_struct.h + (h ? h->value() : 0),
 715                          hsl_struct.s + ss,
 716                          hsl_struct.l + ll,
 717                          color->a() + aa,
 718                          ctx,
 719                          pstate);
 720       }
 721       if (a) {
 722         return SASS_MEMORY_NEW(Color,
 723                                pstate,
 724                                color->r(),
 725                                color->g(),
 726                                color->b(),
 727                                color->a() + (a ? a->value() : 0));
 728       }
 729       error("not enough arguments for `adjust-color'", pstate);
 730       // unreachable
 731       return color;
 732     }
 733
 734     Signature scale_color_sig = "scale-color($color, $red: false, $green: false, $blue: false, $hue: false, $saturation: false, $lightness: false, $alpha: false)";
 735     BUILT_IN(scale_color)
 736     {
 737       Color_Ptr color = ARG("$color", Color);
 738       Number_Ptr r = Cast<Number>(env["$red"]);
 739       Number_Ptr g = Cast<Number>(env["$green"]);
 740       Number_Ptr b = Cast<Number>(env["$blue"]);
 741       Number_Ptr h = Cast<Number>(env["$hue"]);
 742       Number_Ptr s = Cast<Number>(env["$saturation"]);
 743       Number_Ptr l = Cast<Number>(env["$lightness"]);
 744       Number_Ptr a = Cast<Number>(env["$alpha"]);
 745
 746       bool rgb = r || g || b;
 747       bool hsl = h || s || l;
 748
 749       if (rgb && hsl) {
 750         error("Cannot specify HSL and RGB values for a color at the same time for `scale-color'", pstate);
 751       }
 752       if (rgb) {
 753         double rscale = (r ? ARGR("$red",   Number, -100.0, 100.0)->value() : 0.0) / 100.0;
 754         double gscale = (g ? ARGR("$green", Number, -100.0, 100.0)->value() : 0.0) / 100.0;
 755         double bscale = (b ? ARGR("$blue",  Number, -100.0, 100.0)->value() : 0.0) / 100.0;
 756         double ascale = (a ? ARGR("$alpha", Number, -100.0, 100.0)->value() : 0.0) / 100.0;
 757         return SASS_MEMORY_NEW(Color,
 758                                pstate,
 759                                color->r() + rscale * (rscale > 0.0 ? 255 - color->r() : color->r()),
 760                                color->g() + gscale * (gscale > 0.0 ? 255 - color->g() : color->g()),
 761                                color->b() + bscale * (bscale > 0.0 ? 255 - color->b() : color->b()),
 762                                color->a() + ascale * (ascale > 0.0 ? 1.0 - color->a() : color->a()));
 763       }
 764       if (hsl) {
 765         double hscale = (h ? ARGR("$hue",        Number, -100.0, 100.0)->value() : 0.0) / 100.0;
 766         double sscale = (s ? ARGR("$saturation", Number, -100.0, 100.0)->value() : 0.0) / 100.0;
 767         double lscale = (l ? ARGR("$lightness",  Number, -100.0, 100.0)->value() : 0.0) / 100.0;
 768         double ascale = (a ? ARGR("$alpha",      Number, -100.0, 100.0)->value() : 0.0) / 100.0;
 769         HSL hsl_struct = rgb_to_hsl(color->r(), color->g(), color->b());
 770         hsl_struct.h += hscale * (hscale > 0.0 ? 360.0 - hsl_struct.h : hsl_struct.h);
 771         hsl_struct.s += sscale * (sscale > 0.0 ? 100.0 - hsl_struct.s : hsl_struct.s);
 772         hsl_struct.l += lscale * (lscale > 0.0 ? 100.0 - hsl_struct.l : hsl_struct.l);
 773         double alpha = color->a() + ascale * (ascale > 0.0 ? 1.0 - color->a() : color->a());
 774         return hsla_impl(hsl_struct.h, hsl_struct.s, hsl_struct.l, alpha, ctx, pstate);
 775       }
 776       if (a) {
 777         double ascale = (a ? ARGR("$alpha", Number, -100.0, 100.0)->value() : 0.0) / 100.0;
 778         return SASS_MEMORY_NEW(Color,
 779                                pstate,
 780                                color->r(),
 781                                color->g(),
 782                                color->b(),
 783                                color->a() + ascale * (ascale > 0.0 ? 1.0 - color->a() : color->a()));
 784       }
 785       error("not enough arguments for `scale-color'", pstate);
 786       // unreachable
 787       return color;
 788     }
 789
 790     Signature change_color_sig = "change-color($color, $red: false, $green: false, $blue: false, $hue: false, $saturation: false, $lightness: false, $alpha: false)";
 791     BUILT_IN(change_color)
 792     {
 793       Color_Ptr color = ARG("$color", Color);
 794       Number_Ptr r = Cast<Number>(env["$red"]);
 795       Number_Ptr g = Cast<Number>(env["$green"]);
 796       Number_Ptr b = Cast<Number>(env["$blue"]);
 797       Number_Ptr h = Cast<Number>(env["$hue"]);
 798       Number_Ptr s = Cast<Number>(env["$saturation"]);
 799       Number_Ptr l = Cast<Number>(env["$lightness"]);
 800       Number_Ptr a = Cast<Number>(env["$alpha"]);
 801
 802       bool rgb = r || g || b;
 803       bool hsl = h || s || l;
 804
 805       if (rgb && hsl) {
 806         error("Cannot specify HSL and RGB values for a color at the same time for `change-color'", pstate);
 807       }
 808       if (rgb) {
 809         return SASS_MEMORY_NEW(Color,
 810                                pstate,
 811                                r ? ARGR("$red",   Number, 0, 255)->value() : color->r(),
 812                                g ? ARGR("$green", Number, 0, 255)->value() : color->g(),
 813                                b ? ARGR("$blue",  Number, 0, 255)->value() : color->b(),
 814                                a ? ARGR("$alpha", Number, 0, 255)->value() : color->a());
 815       }
 816       if (hsl) {
 817         HSL hsl_struct = rgb_to_hsl(color->r(), color->g(), color->b());
 818         if (h) hsl_struct.h = std::fmod(h->value(), 360.0);
 819         if (s) hsl_struct.s = ARGR("$saturation", Number, 0, 100)->value();
 820         if (l) hsl_struct.l = ARGR("$lightness",  Number, 0, 100)->value();
 821         double alpha = a ? ARGR("$alpha", Number, 0, 1.0)->value() : color->a();
 822         return hsla_impl(hsl_struct.h, hsl_struct.s, hsl_struct.l, alpha, ctx, pstate);
 823       }
 824       if (a) {
 825         double alpha = a ? ARGR("$alpha", Number, 0, 1.0)->value() : color->a();
 826         return SASS_MEMORY_NEW(Color,
 827                                pstate,
 828                                color->r(),
 829                                color->g(),
 830                                color->b(),
 831                                alpha);
 832       }
 833       error("not enough arguments for `change-color'", pstate);
 834       // unreachable
 835       return color;
 836     }
 837
 838     template <size_t range>
 839     static double cap_channel(double c) {
 840       if      (c > range) return range;
 841       else if (c < 0)     return 0;
 842       else                return c;
 843     }
 844
 845     Signature ie_hex_str_sig = "ie-hex-str($color)";
 846     BUILT_IN(ie_hex_str)
 847     {
 848       Color_Ptr c = ARG("$color", Color);
 849       double r = cap_channel<0xff>(c->r());
 850       double g = cap_channel<0xff>(c->g());
 851       double b = cap_channel<0xff>(c->b());
 852       double a = cap_channel<1>   (c->a()) * 255;
 853
 854       std::stringstream ss;
 855       ss << '#' << std::setw(2) << std::setfill('0');
 856       ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(a, ctx.c_options.precision));
 857       ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(r, ctx.c_options.precision));
 858       ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(g, ctx.c_options.precision));
 859       ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(b, ctx.c_options.precision));
 860
 861       std::string result(ss.str());
 862       for (size_t i = 0, L = result.length(); i < L; ++i) {
 863         result[i] = std::toupper(result[i]);
 864       }
 865       return SASS_MEMORY_NEW(String_Quoted, pstate, result);
 866     }
 867
 868     ///////////////////
 869     // STRING FUNCTIONS
 870     ///////////////////
 871
 872     Signature unquote_sig = "unquote($string)";
 873     BUILT_IN(sass_unquote)
 874     {
 875       AST_Node_Obj arg = env["$string"];
 876       if (String_Quoted_Ptr string_quoted = Cast<String_Quoted>(arg)) {
 877         String_Constant_Ptr result = SASS_MEMORY_NEW(String_Constant, pstate, string_quoted->value());
 878         // remember if the string was quoted (color tokens)
 879         result->is_delayed(true); // delay colors
 880         return result;
 881       }
 882       else if (String_Constant_Ptr str = Cast<String_Constant>(arg)) {
 883         return str;
 884       }
 885       else if (Expression_Ptr ex = Cast<Expression>(arg)) {
 886         Sass_Output_Style oldstyle = ctx.c_options.output_style;
 887         ctx.c_options.output_style = SASS_STYLE_NESTED;
 888         std::string val(arg->to_string(ctx.c_options));
 889         val = Cast<Null>(arg) ? "null" : val;
 890         ctx.c_options.output_style = oldstyle;
 891
 892         deprecated_function("Passing " + val + ", a non-string value, to unquote()", pstate);
 893         return ex;
 894       }
 895       throw std::runtime_error("Invalid Data Type for unquote");
 896     }
 897
 898     Signature quote_sig = "quote($string)";
 899     BUILT_IN(sass_quote)
 900     {
 901       AST_Node_Obj arg = env["$string"];
 902       // only set quote mark to true if already a string
 903       if (String_Quoted_Ptr qstr = Cast<String_Quoted>(arg)) {
 904         qstr->quote_mark('*');
 905         return qstr;
 906       }
 907       // all other nodes must be converted to a string node
 908       std::string str(quote(arg->to_string(ctx.c_options), String_Constant::double_quote()));
 909       String_Quoted_Ptr result = SASS_MEMORY_NEW(String_Quoted, pstate, str);
 910       result->quote_mark('*');
 911       return result;
 912     }
 913
 914
 915     Signature str_length_sig = "str-length($string)";
 916     BUILT_IN(str_length)
 917     {
 918       size_t len = std::string::npos;
 919       try {
 920         String_Constant_Ptr s = ARG("$string", String_Constant);
 921         len = UTF_8::code_point_count(s->value(), 0, s->value().size());
 922
 923       }
 924       // handle any invalid utf8 errors
 925       // other errors will be re-thrown
 926       catch (...) { handle_utf8_error(pstate, backtrace); }
 927       // return something even if we had an error (-1)
 928       return SASS_MEMORY_NEW(Number, pstate, (double)len);
 929     }
 930
 931     Signature str_insert_sig = "str-insert($string, $insert, $index)";
 932     BUILT_IN(str_insert)
 933     {
 934       std::string str;
 935       try {
 936         String_Constant_Ptr s = ARG("$string", String_Constant);
 937         str = s->value();
 938         str = unquote(str);
 939         String_Constant_Ptr i = ARG("$insert", String_Constant);
 940         std::string ins = i->value();
 941         ins = unquote(ins);
 942         Number_Ptr ind = ARG("$index", Number);
 943         double index = ind->value();
 944         size_t len = UTF_8::code_point_count(str, 0, str.size());
 945
 946         if (index > 0 && index <= len) {
 947           // positive and within string length
 948           str.insert(UTF_8::offset_at_position(str, static_cast<size_t>(index) - 1), ins);
 949         }
 950         else if (index > len) {
 951           // positive and past string length
 952           str += ins;
 953         }
 954         else if (index == 0) {
 955           str = ins + str;
 956         }
 957         else if (std::abs(index) <= len) {
 958           // negative and within string length
 959           index += len + 1;
 960           str.insert(UTF_8::offset_at_position(str, static_cast<size_t>(index)), ins);
 961         }
 962         else {
 963           // negative and past string length
 964           str = ins + str;
 965         }
 966
 967         if (String_Quoted_Ptr ss = Cast<String_Quoted>(s)) {
 968           if (ss->quote_mark()) str = quote(str);
 969         }
 970       }
 971       // handle any invalid utf8 errors
 972       // other errors will be re-thrown
 973       catch (...) { handle_utf8_error(pstate, backtrace); }
 974       return SASS_MEMORY_NEW(String_Quoted, pstate, str);
 975     }
 976
 977     Signature str_index_sig = "str-index($string, $substring)";
 978     BUILT_IN(str_index)
 979     {
 980       size_t index = std::string::npos;
 981       try {
 982         String_Constant_Ptr s = ARG("$string", String_Constant);
 983         String_Constant_Ptr t = ARG("$substring", String_Constant);
 984         std::string str = s->value();
 985         str = unquote(str);
 986         std::string substr = t->value();
 987         substr = unquote(substr);
 988
 989         size_t c_index = str.find(substr);
 990         if(c_index == std::string::npos) {
 991           return SASS_MEMORY_NEW(Null, pstate);
 992         }
 993         index = UTF_8::code_point_count(str, 0, c_index) + 1;
 994       }
 995       // handle any invalid utf8 errors
 996       // other errors will be re-thrown
 997       catch (...) { handle_utf8_error(pstate, backtrace); }
 998       // return something even if we had an error (-1)
 999       return SASS_MEMORY_NEW(Number, pstate, (double)index);
1000     }
1001
1002     Signature str_slice_sig = "str-slice($string, $start-at, $end-at:-1)";
1003     BUILT_IN(str_slice)
1004     {
1005       std::string newstr;
1006       try {
1007         String_Constant_Ptr s = ARG("$string", String_Constant);
1008         double start_at = ARG("$start-at", Number)->value();
1009         double end_at = ARG("$end-at", Number)->value();
1010         String_Quoted_Ptr ss = Cast<String_Quoted>(s);
1011
1012         std::string str = unquote(s->value());
1013
1014         size_t size = utf8::distance(str.begin(), str.end());
1015
1016         if (!Cast<Number>(env["$end-at"])) {
1017           end_at = -1;
1018         }
1019
1020         if (end_at == 0 || (end_at + size) < 0) {
1021           if (ss && ss->quote_mark()) newstr = quote("");
1022           return SASS_MEMORY_NEW(String_Quoted, pstate, newstr);
1023         }
1024
1025         if (end_at < 0) {
1026           end_at += size + 1;
1027           if (end_at == 0) end_at = 1;
1028         }
1029         if (end_at > size) { end_at = (double)size; }
1030         if (start_at < 0) {
1031           start_at += size + 1;
1032           if (start_at < 0)  start_at = 0;
1033         }
1034         else if (start_at == 0) { ++ start_at; }
1035
1036         if (start_at <= end_at)
1037         {
1038           std::string::iterator start = str.begin();
1039           utf8::advance(start, start_at - 1, str.end());
1040           std::string::iterator end = start;
1041           utf8::advance(end, end_at - start_at + 1, str.end());
1042           newstr = std::string(start, end);
1043         }
1044         if (ss) {
1045           if(ss->quote_mark()) newstr = quote(newstr);
1046         }
1047       }
1048       // handle any invalid utf8 errors
1049       // other errors will be re-thrown
1050       catch (...) { handle_utf8_error(pstate, backtrace); }
1051       return SASS_MEMORY_NEW(String_Quoted, pstate, newstr);
1052     }
1053
1054     Signature to_upper_case_sig = "to-upper-case($string)";
1055     BUILT_IN(to_upper_case)
1056     {
1057       String_Constant_Ptr s = ARG("$string", String_Constant);
1058       std::string str = s->value();
1059
1060       for (size_t i = 0, L = str.length(); i < L; ++i) {
1061         if (Sass::Util::isAscii(str[i])) {
1062           str[i] = std::toupper(str[i]);
1063         }
1064       }
1065
1066       if (String_Quoted_Ptr ss = Cast<String_Quoted>(s)) {
1067         String_Quoted_Ptr cpy = SASS_MEMORY_COPY(ss);
1068         cpy->value(str);
1069         return cpy;
1070       } else {
1071         return SASS_MEMORY_NEW(String_Quoted, pstate, str);
1072       }
1073     }
1074
1075     Signature to_lower_case_sig = "to-lower-case($string)";
1076     BUILT_IN(to_lower_case)
1077     {
1078       String_Constant_Ptr s = ARG("$string", String_Constant);
1079       std::string str = s->value();
1080
1081       for (size_t i = 0, L = str.length(); i < L; ++i) {
1082         if (Sass::Util::isAscii(str[i])) {
1083           str[i] = std::tolower(str[i]);
1084         }
1085       }
1086
1087       if (String_Quoted_Ptr ss = Cast<String_Quoted>(s)) {
1088         String_Quoted_Ptr cpy = SASS_MEMORY_COPY(ss);
1089         cpy->value(str);
1090         return cpy;
1091       } else {
1092         return SASS_MEMORY_NEW(String_Quoted, pstate, str);
1093       }
1094     }
1095
1096     ///////////////////
1097     // NUMBER FUNCTIONS
1098     ///////////////////
1099
1100     Signature percentage_sig = "percentage($number)";
1101     BUILT_IN(percentage)
1102     {
1103       Number_Ptr n = ARG("$number", Number);
1104       if (!n->is_unitless()) error("argument $number of `" + std::string(sig) + "` must be unitless", pstate);
1105       return SASS_MEMORY_NEW(Number, pstate, n->value() * 100, "%");
1106     }
1107
1108     Signature round_sig = "round($number)";
1109     BUILT_IN(round)
1110     {
1111       Number_Ptr n = ARG("$number", Number);
1112       Number_Ptr r = SASS_MEMORY_COPY(n);
1113       r->pstate(pstate);
1114       r->value(Sass::round(r->value(), ctx.c_options.precision));
1115       return r;
1116     }
1117
1118     Signature ceil_sig = "ceil($number)";
1119     BUILT_IN(ceil)
1120     {
1121       Number_Ptr n = ARG("$number", Number);
1122       Number_Ptr r = SASS_MEMORY_COPY(n);
1123       r->pstate(pstate);
1124       r->value(std::ceil(r->value()));
1125       return r;
1126     }
1127
1128     Signature floor_sig = "floor($number)";
1129     BUILT_IN(floor)
1130     {
1131       Number_Ptr n = ARG("$number", Number);
1132       Number_Ptr r = SASS_MEMORY_COPY(n);
1133       r->pstate(pstate);
1134       r->value(std::floor(r->value()));
1135       return r;
1136     }
1137
1138     Signature abs_sig = "abs($number)";
1139     BUILT_IN(abs)
1140     {
1141       Number_Ptr n = ARG("$number", Number);
1142       Number_Ptr r = SASS_MEMORY_COPY(n);
1143       r->pstate(pstate);
1144       r->value(std::abs(r->value()));
1145       return r;
1146     }
1147
1148     Signature min_sig = "min($numbers...)";
1149     BUILT_IN(min)
1150     {
1151       List_Ptr arglist = ARG("$numbers", List);
1152       Number_Obj least = NULL;
1153       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
1154         Expression_Obj val = arglist->value_at_index(i);
1155         Number_Obj xi = Cast<Number>(val);
1156         if (!xi) {
1157           error("\"" + val->to_string(ctx.c_options) + "\" is not a number for `min'", pstate);
1158         }
1159         if (least) {
1160           if (*xi < *least) least = xi;
1161         } else least = xi;
1162       }
1163       return least.detach();
1164     }
1165
1166     Signature max_sig = "max($numbers...)";
1167     BUILT_IN(max)
1168     {
1169       List_Ptr arglist = ARG("$numbers", List);
1170       Number_Obj greatest = NULL;
1171       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
1172         Expression_Obj val = arglist->value_at_index(i);
1173         Number_Obj xi = Cast<Number>(val);
1174         if (!xi) {
1175           error("\"" + val->to_string(ctx.c_options) + "\" is not a number for `max'", pstate);
1176         }
1177         if (greatest) {
1178           if (*greatest < *xi) greatest = xi;
1179         } else greatest = xi;
1180       }
1181       return greatest.detach();
1182     }
1183
1184     Signature random_sig = "random($limit:false)";
1185     BUILT_IN(random)
1186     {
1187       AST_Node_Obj arg = env["$limit"];
1188       Value_Ptr v = Cast<Value>(arg);
1189       Number_Ptr l = Cast<Number>(arg);
1190       Boolean_Ptr b = Cast<Boolean>(arg);
1191       if (l) {
1192         double v = l->value();
1193         if (v < 1) {
1194           stringstream err;
1195           err << "$limit " << v << " must be greater than or equal to 1 for `random'";
1196           error(err.str(), pstate);
1197         }
1198         bool eq_int = std::fabs(trunc(v) - v) < NUMBER_EPSILON;
1199         if (!eq_int) {
1200           stringstream err;
1201           err << "Expected $limit to be an integer but got " << v << " for `random'";
1202           error(err.str(), pstate);
1203         }
1204         std::uniform_real_distribution<> distributor(1, v + 1);
1205         uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
1206         return SASS_MEMORY_NEW(Number, pstate, (double)distributed);
1207       }
1208       else if (b) {
1209         std::uniform_real_distribution<> distributor(0, 1);
1210         double distributed = static_cast<double>(distributor(rand));
1211         return SASS_MEMORY_NEW(Number, pstate, distributed);
1212       } else if (v) {
1213         throw Exception::InvalidArgumentType(pstate, "random", "$limit", "number", v);
1214       } else {
1215         throw Exception::InvalidArgumentType(pstate, "random", "$limit", "number");
1216       }
1217       return 0;
1218     }
1219
1220     /////////////////
1221     // LIST FUNCTIONS
1222     /////////////////
1223
1224     Signature length_sig = "length($list)";
1225     BUILT_IN(length)
1226     {
1227       if (Selector_List_Ptr sl = Cast<Selector_List>(env["$list"])) {
1228         return SASS_MEMORY_NEW(Number, pstate, (double)sl->length());
1229       }
1230       Expression_Ptr v = ARG("$list", Expression);
1231       if (v->concrete_type() == Expression::MAP) {
1232         Map_Ptr map = Cast<Map>(env["$list"]);
1233         return SASS_MEMORY_NEW(Number, pstate, (double)(map ? map->length() : 1));
1234       }
1235       if (v->concrete_type() == Expression::SELECTOR) {
1236         if (Compound_Selector_Ptr h = Cast<Compound_Selector>(v)) {
1237           return SASS_MEMORY_NEW(Number, pstate, (double)h->length());
1238         } else if (Selector_List_Ptr ls = Cast<Selector_List>(v)) {
1239           return SASS_MEMORY_NEW(Number, pstate, (double)ls->length());
1240         } else {
1241           return SASS_MEMORY_NEW(Number, pstate, 1);
1242         }
1243       }
1244
1245       List_Ptr list = Cast<List>(env["$list"]);
1246       return SASS_MEMORY_NEW(Number,
1247                              pstate,
1248                              (double)(list ? list->size() : 1));
1249     }
1250
1251     Signature nth_sig = "nth($list, $n)";
1252     BUILT_IN(nth)
1253     {
1254       Number_Ptr n = ARG("$n", Number);
1255       Map_Ptr m = Cast<Map>(env["$list"]);
1256       if (Selector_List_Ptr sl = Cast<Selector_List>(env["$list"])) {
1257         size_t len = m ? m->length() : sl->length();
1258         bool empty = m ? m->empty() : sl->empty();
1259         if (empty) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate);
1260         double index = std::floor(n->value() < 0 ? len + n->value() : n->value() - 1);
1261         if (index < 0 || index > len - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate);
1262         // return (*sl)[static_cast<int>(index)];
1263         Listize listize;
1264         return (*sl)[static_cast<int>(index)]->perform(&listize);
1265       }
1266       List_Obj l = Cast<List>(env["$list"]);
1267       if (n->value() == 0) error("argument `$n` of `" + std::string(sig) + "` must be non-zero", pstate);
1268       // if the argument isn't a list, then wrap it in a singleton list
1269       if (!m && !l) {
1270         l = SASS_MEMORY_NEW(List, pstate, 1);
1271         l->append(ARG("$list", Expression));
1272       }
1273       size_t len = m ? m->length() : l->length();
1274       bool empty = m ? m->empty() : l->empty();
1275       if (empty) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate);
1276       double index = std::floor(n->value() < 0 ? len + n->value() : n->value() - 1);
1277       if (index < 0 || index > len - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate);
1278
1279       if (m) {
1280         l = SASS_MEMORY_NEW(List, pstate, 1);
1281         l->append(m->keys()[static_cast<unsigned int>(index)]);
1282         l->append(m->at(m->keys()[static_cast<unsigned int>(index)]));
1283         return l.detach();
1284       }
1285       else {
1286         Expression_Obj rv = l->value_at_index(static_cast<int>(index));
1287         rv->set_delayed(false);
1288         return rv.detach();
1289       }
1290     }
1291
1292     Signature set_nth_sig = "set-nth($list, $n, $value)";
1293     BUILT_IN(set_nth)
1294     {
1295       Map_Obj m = Cast<Map>(env["$list"]);
1296       List_Obj l = Cast<List>(env["$list"]);
1297       Number_Obj n = ARG("$n", Number);
1298       Expression_Obj v = ARG("$value", Expression);
1299       if (!l) {
1300         l = SASS_MEMORY_NEW(List, pstate, 1);
1301         l->append(ARG("$list", Expression));
1302       }
1303       if (m) {
1304         l = m->to_list(ctx, pstate);
1305       }
1306       if (l->empty()) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate);
1307       double index = std::floor(n->value() < 0 ? l->length() + n->value() : n->value() - 1);
1308       if (index < 0 || index > l->length() - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate);
1309       List_Ptr result = SASS_MEMORY_NEW(List, pstate, l->length(), l->separator(), false, l->is_bracketed());
1310       for (size_t i = 0, L = l->length(); i < L; ++i) {
1311         result->append(((i == index) ? v : (*l)[i]));
1312       }
1313       return result;
1314     }
1315
1316     Signature index_sig = "index($list, $value)";
1317     BUILT_IN(index)
1318     {
1319       Map_Obj m = Cast<Map>(env["$list"]);
1320       List_Obj l = Cast<List>(env["$list"]);
1321       Expression_Obj v = ARG("$value", Expression);
1322       if (!l) {
1323         l = SASS_MEMORY_NEW(List, pstate, 1);
1324         l->append(ARG("$list", Expression));
1325       }
1326       if (m) {
1327         l = m->to_list(ctx, pstate);
1328       }
1329       for (size_t i = 0, L = l->length(); i < L; ++i) {
1330         if (Eval::eq(l->value_at_index(i), v)) return SASS_MEMORY_NEW(Number, pstate, (double)(i+1));
1331       }
1332       return SASS_MEMORY_NEW(Null, pstate);
1333     }
1334
1335     Signature join_sig = "join($list1, $list2, $separator: auto, $bracketed: auto)";
1336     BUILT_IN(join)
1337     {
1338       Map_Obj m1 = Cast<Map>(env["$list1"]);
1339       Map_Obj m2 = Cast<Map>(env["$list2"]);
1340       List_Obj l1 = Cast<List>(env["$list1"]);
1341       List_Obj l2 = Cast<List>(env["$list2"]);
1342       String_Constant_Obj sep = ARG("$separator", String_Constant);
1343       enum Sass_Separator sep_val = (l1 ? l1->separator() : SASS_SPACE);
1344       Value* bracketed = ARG("$bracketed", Value);
1345       bool is_bracketed = (l1 ? l1->is_bracketed() : false);
1346       if (!l1) {
1347         l1 = SASS_MEMORY_NEW(List, pstate, 1);
1348         l1->append(ARG("$list1", Expression));
1349         sep_val = (l2 ? l2->separator() : SASS_SPACE);
1350         is_bracketed = (l2 ? l2->is_bracketed() : false);
1351       }
1352       if (!l2) {
1353         l2 = SASS_MEMORY_NEW(List, pstate, 1);
1354         l2->append(ARG("$list2", Expression));
1355       }
1356       if (m1) {
1357         l1 = m1->to_list(ctx, pstate);
1358         sep_val = SASS_COMMA;
1359       }
1360       if (m2) {
1361         l2 = m2->to_list(ctx, pstate);
1362       }
1363       size_t len = l1->length() + l2->length();
1364       std::string sep_str = unquote(sep->value());
1365       if (sep_str == "space") sep_val = SASS_SPACE;
1366       else if (sep_str == "comma") sep_val = SASS_COMMA;
1367       else if (sep_str != "auto") error("argument `$separator` of `" + std::string(sig) + "` must be `space`, `comma`, or `auto`", pstate);
1368       String_Constant_Obj bracketed_as_str = Cast<String_Constant>(bracketed);
1369       bool bracketed_is_auto = bracketed_as_str && unquote(bracketed_as_str->value()) == "auto";
1370       if (!bracketed_is_auto) {
1371         is_bracketed = !bracketed->is_false();
1372       }
1373       List_Obj result = SASS_MEMORY_NEW(List, pstate, len, sep_val, false, is_bracketed);
1374       result->concat(l1);
1375       result->concat(l2);
1376       return result.detach();
1377     }
1378
1379     Signature append_sig = "append($list, $val, $separator: auto)";
1380     BUILT_IN(append)
1381     {
1382       Map_Obj m = Cast<Map>(env["$list"]);
1383       List_Obj l = Cast<List>(env["$list"]);
1384       Expression_Obj v = ARG("$val", Expression);
1385       if (Selector_List_Ptr sl = Cast<Selector_List>(env["$list"])) {
1386         Listize listize;
1387         l = Cast<List>(sl->perform(&listize));
1388       }
1389       String_Constant_Obj sep = ARG("$separator", String_Constant);
1390       if (!l) {
1391         l = SASS_MEMORY_NEW(List, pstate, 1);
1392         l->append(ARG("$list", Expression));
1393       }
1394       if (m) {
1395         l = m->to_list(ctx, pstate);
1396       }
1397       List_Ptr result = SASS_MEMORY_COPY(l);
1398       std::string sep_str(unquote(sep->value()));
1399       if (sep_str != "auto") { // check default first
1400         if (sep_str == "space") result->separator(SASS_SPACE);
1401         else if (sep_str == "comma") result->separator(SASS_COMMA);
1402         else error("argument `$separator` of `" + std::string(sig) + "` must be `space`, `comma`, or `auto`", pstate);
1403       }
1404       if (l->is_arglist()) {
1405         result->append(SASS_MEMORY_NEW(Argument,
1406                                        v->pstate(),
1407                                        v,
1408                                        "",
1409                                        false,
1410                                        false));
1411
1412       } else {
1413         result->append(v);
1414       }
1415       return result;
1416     }
1417
1418     Signature zip_sig = "zip($lists...)";
1419     BUILT_IN(zip)
1420     {
1421       List_Obj arglist = SASS_MEMORY_COPY(ARG("$lists", List));
1422       size_t shortest = 0;
1423       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
1424         List_Obj ith = Cast<List>(arglist->value_at_index(i));
1425         Map_Obj mith = Cast<Map>(arglist->value_at_index(i));
1426         if (!ith) {
1427           if (mith) {
1428             ith = mith->to_list(ctx, pstate);
1429           } else {
1430             ith = SASS_MEMORY_NEW(List, pstate, 1);
1431             ith->append(arglist->value_at_index(i));
1432           }
1433           if (arglist->is_arglist()) {
1434             Argument_Obj arg = (Argument_Ptr)(arglist->at(i).ptr()); // XXX
1435             arg->value(ith);
1436           } else {
1437             (*arglist)[i] = ith;
1438           }
1439         }
1440         shortest = (i ? std::min(shortest, ith->length()) : ith->length());
1441       }
1442       List_Ptr zippers = SASS_MEMORY_NEW(List, pstate, shortest, SASS_COMMA);
1443       size_t L = arglist->length();
1444       for (size_t i = 0; i < shortest; ++i) {
1445         List_Ptr zipper = SASS_MEMORY_NEW(List, pstate, L);
1446         for (size_t j = 0; j < L; ++j) {
1447           zipper->append(Cast<List>(arglist->value_at_index(j))->at(i));
1448         }
1449         zippers->append(zipper);
1450       }
1451       return zippers;
1452     }
1453
1454     Signature list_separator_sig = "list_separator($list)";
1455     BUILT_IN(list_separator)
1456     {
1457       List_Obj l = Cast<List>(env["$list"]);
1458       if (!l) {
1459         l = SASS_MEMORY_NEW(List, pstate, 1);
1460         l->append(ARG("$list", Expression));
1461       }
1462       return SASS_MEMORY_NEW(String_Quoted,
1463                                pstate,
1464                                l->separator() == SASS_COMMA ? "comma" : "space");
1465     }
1466
1467     /////////////////
1468     // MAP FUNCTIONS
1469     /////////////////
1470
1471     Signature map_get_sig = "map-get($map, $key)";
1472     BUILT_IN(map_get)
1473     {
1474       // leaks for "map-get((), foo)" if not Obj
1475       // investigate why this is (unexpected)
1476       Map_Obj m = ARGM("$map", Map, ctx);
1477       Expression_Obj v = ARG("$key", Expression);
1478       try {
1479         Expression_Obj val = m->at(v);
1480         return val ? val.detach() : SASS_MEMORY_NEW(Null, pstate);
1481       } catch (const std::out_of_range&) {
1482         return SASS_MEMORY_NEW(Null, pstate);
1483       }
1484       catch (...) { throw; }
1485     }
1486
1487     Signature map_has_key_sig = "map-has-key($map, $key)";
1488     BUILT_IN(map_has_key)
1489     {
1490       Map_Obj m = ARGM("$map", Map, ctx);
1491       Expression_Obj v = ARG("$key", Expression);
1492       return SASS_MEMORY_NEW(Boolean, pstate, m->has(v));
1493     }
1494
1495     Signature map_keys_sig = "map-keys($map)";
1496     BUILT_IN(map_keys)
1497     {
1498       Map_Obj m = ARGM("$map", Map, ctx);
1499       List_Ptr result = SASS_MEMORY_NEW(List, pstate, m->length(), SASS_COMMA);
1500       for ( auto key : m->keys()) {
1501         result->append(key);
1502       }
1503       return result;
1504     }
1505
1506     Signature map_values_sig = "map-values($map)";
1507     BUILT_IN(map_values)
1508     {
1509       Map_Obj m = ARGM("$map", Map, ctx);
1510       List_Ptr result = SASS_MEMORY_NEW(List, pstate, m->length(), SASS_COMMA);
1511       for ( auto key : m->keys()) {
1512         result->append(m->at(key));
1513       }
1514       return result;
1515     }
1516
1517     Signature map_merge_sig = "map-merge($map1, $map2)";
1518     BUILT_IN(map_merge)
1519     {
1520       Map_Obj m1 = ARGM("$map1", Map, ctx);
1521       Map_Obj m2 = ARGM("$map2", Map, ctx);
1522
1523       size_t len = m1->length() + m2->length();
1524       Map_Ptr result = SASS_MEMORY_NEW(Map, pstate, len);
1525       // concat not implemented for maps
1526       *result += m1;
1527       *result += m2;
1528       return result;
1529     }
1530
1531     Signature map_remove_sig = "map-remove($map, $keys...)";
1532     BUILT_IN(map_remove)
1533     {
1534       bool remove;
1535       Map_Obj m = ARGM("$map", Map, ctx);
1536       List_Obj arglist = ARG("$keys", List);
1537       Map_Ptr result = SASS_MEMORY_NEW(Map, pstate, 1);
1538       for (auto key : m->keys()) {
1539         remove = false;
1540         for (size_t j = 0, K = arglist->length(); j < K && !remove; ++j) {
1541           remove = Eval::eq(key, arglist->value_at_index(j));
1542         }
1543         if (!remove) *result << std::make_pair(key, m->at(key));
1544       }
1545       return result;
1546     }
1547
1548     Signature keywords_sig = "keywords($args)";
1549     BUILT_IN(keywords)
1550     {
1551       List_Obj arglist = SASS_MEMORY_COPY(ARG("$args", List)); // copy
1552       Map_Obj result = SASS_MEMORY_NEW(Map, pstate, 1);
1553       for (size_t i = arglist->size(), L = arglist->length(); i < L; ++i) {
1554         Expression_Obj obj = arglist->at(i);
1555         Argument_Obj arg = (Argument_Ptr) obj.ptr(); // XXX
1556         std::string name = std::string(arg->name());
1557         name = name.erase(0, 1); // sanitize name (remove dollar sign)
1558         *result << std::make_pair(SASS_MEMORY_NEW(String_Quoted,
1559                  pstate, name),
1560                  arg->value());
1561       }
1562       return result.detach();
1563     }
1564
1565     //////////////////////////
1566     // INTROSPECTION FUNCTIONS
1567     //////////////////////////
1568
1569     Signature type_of_sig = "type-of($value)";
1570     BUILT_IN(type_of)
1571     {
1572       Expression_Ptr v = ARG("$value", Expression);
1573       return SASS_MEMORY_NEW(String_Quoted, pstate, v->type());
1574     }
1575
1576     Signature unit_sig = "unit($number)";
1577     BUILT_IN(unit)
1578     { return SASS_MEMORY_NEW(String_Quoted, pstate, quote(ARG("$number", Number)->unit(), '"')); }
1579
1580     Signature unitless_sig = "unitless($number)";
1581     BUILT_IN(unitless)
1582     { return SASS_MEMORY_NEW(Boolean, pstate, ARG("$number", Number)->is_unitless()); }
1583
1584     Signature comparable_sig = "comparable($number-1, $number-2)";
1585     BUILT_IN(comparable)
1586     {
1587       Number_Ptr n1 = ARG("$number-1", Number);
1588       Number_Ptr n2 = ARG("$number-2", Number);
1589       if (n1->is_unitless() || n2->is_unitless()) {
1590         return SASS_MEMORY_NEW(Boolean, pstate, true);
1591       }
1592       Number tmp_n2(n2); // copy
1593       tmp_n2.normalize(n1->find_convertible_unit());
1594       return SASS_MEMORY_NEW(Boolean, pstate, n1->unit() == tmp_n2.unit());
1595     }
1596
1597     Signature variable_exists_sig = "variable-exists($name)";
1598     BUILT_IN(variable_exists)
1599     {
1600       std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
1601
1602       if(d_env.has("$"+s)) {
1603         return SASS_MEMORY_NEW(Boolean, pstate, true);
1604       }
1605       else {
1606         return SASS_MEMORY_NEW(Boolean, pstate, false);
1607       }
1608     }
1609
1610     Signature global_variable_exists_sig = "global-variable-exists($name)";
1611     BUILT_IN(global_variable_exists)
1612     {
1613       std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
1614
1615       if(d_env.has_global("$"+s)) {
1616         return SASS_MEMORY_NEW(Boolean, pstate, true);
1617       }
1618       else {
1619         return SASS_MEMORY_NEW(Boolean, pstate, false);
1620       }
1621     }
1622
1623     Signature function_exists_sig = "function-exists($name)";
1624     BUILT_IN(function_exists)
1625     {
1626       std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
1627
1628       if(d_env.has_global(s+"[f]")) {
1629         return SASS_MEMORY_NEW(Boolean, pstate, true);
1630       }
1631       else {
1632         return SASS_MEMORY_NEW(Boolean, pstate, false);
1633       }
1634     }
1635
1636     Signature mixin_exists_sig = "mixin-exists($name)";
1637     BUILT_IN(mixin_exists)
1638     {
1639       std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
1640
1641       if(d_env.has_global(s+"[m]")) {
1642         return SASS_MEMORY_NEW(Boolean, pstate, true);
1643       }
1644       else {
1645         return SASS_MEMORY_NEW(Boolean, pstate, false);
1646       }
1647     }
1648
1649     Signature feature_exists_sig = "feature-exists($name)";
1650     BUILT_IN(feature_exists)
1651     {
1652       std::string s = unquote(ARG("$name", String_Constant)->value());
1653
1654       if(features.find(s) == features.end()) {
1655         return SASS_MEMORY_NEW(Boolean, pstate, false);
1656       }
1657       else {
1658         return SASS_MEMORY_NEW(Boolean, pstate, true);
1659       }
1660     }
1661
1662     Signature call_sig = "call($name, $args...)";
1663     BUILT_IN(call)
1664     {
1665       std::string name = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
1666       List_Obj arglist = SASS_MEMORY_COPY(ARG("$args", List));
1667
1668       Arguments_Obj args = SASS_MEMORY_NEW(Arguments, pstate);
1669       // std::string full_name(name + "[f]");
1670       // Definition_Ptr def = d_env.has(full_name) ? Cast<Definition>((d_env)[full_name]) : 0;
1671       // Parameters_Ptr params = def ? def->parameters() : 0;
1672       // size_t param_size = params ? params->length() : 0;
1673       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
1674         Expression_Obj expr = arglist->value_at_index(i);
1675         // if (params && params->has_rest_parameter()) {
1676         //   Parameter_Obj p = param_size > i ? (*params)[i] : 0;
1677         //   List_Ptr list = Cast<List>(expr);
1678         //   if (list && p && !p->is_rest_parameter()) expr = (*list)[0];
1679         // }
1680         if (arglist->is_arglist()) {
1681           Expression_Obj obj = arglist->at(i);
1682           Argument_Obj arg = (Argument_Ptr) obj.ptr(); // XXX
1683           args->append(SASS_MEMORY_NEW(Argument,
1684                                        pstate,
1685                                        expr,
1686                                        arg ? arg->name() : "",
1687                                        arg ? arg->is_rest_argument() : false,
1688                                        arg ? arg->is_keyword_argument() : false));
1689         } else {
1690           args->append(SASS_MEMORY_NEW(Argument, pstate, expr));
1691         }
1692       }
1693       Function_Call_Obj func = SASS_MEMORY_NEW(Function_Call, pstate, name, args);
1694       Expand expand(ctx, &d_env, backtrace, &selector_stack);
1695       func->via_call(true); // calc invoke is allowed
1696       return func->perform(&expand.eval);
1697
1698     }
1699
1700     ////////////////////
1701     // BOOLEAN FUNCTIONS
1702     ////////////////////
1703
1704     Signature not_sig = "not($value)";
1705     BUILT_IN(sass_not)
1706     {
1707       return SASS_MEMORY_NEW(Boolean, pstate, ARG("$value", Expression)->is_false());
1708     }
1709
1710     Signature if_sig = "if($condition, $if-true, $if-false)";
1711     // BUILT_IN(sass_if)
1712     // { return ARG("$condition", Expression)->is_false() ? ARG("$if-false", Expression) : ARG("$if-true", Expression); }
1713     BUILT_IN(sass_if)
1714     {
1715       Expand expand(ctx, &d_env, backtrace, &selector_stack);
1716       Expression_Obj cond = ARG("$condition", Expression)->perform(&expand.eval);
1717       bool is_true = !cond->is_false();
1718       Expression_Ptr res = ARG(is_true ? "$if-true" : "$if-false", Expression);
1719       res = res->perform(&expand.eval);
1720       res->set_delayed(false); // clone?
1721       return res;
1722     }
1723
1724     //////////////////////////
1725     // MISCELLANEOUS FUNCTIONS
1726     //////////////////////////
1727
1728     // value.check_deprecated_interp if value.is_a?(Sass::Script::Value::String)
1729     // unquoted_string(value.to_sass)
1730
1731     Signature inspect_sig = "inspect($value)";
1732     BUILT_IN(inspect)
1733     {
1734       Expression_Ptr v = ARG("$value", Expression);
1735       if (v->concrete_type() == Expression::NULL_VAL) {
1736         return SASS_MEMORY_NEW(String_Quoted, pstate, "null");
1737       } else if (v->concrete_type() == Expression::BOOLEAN && v->is_false()) {
1738         return SASS_MEMORY_NEW(String_Quoted, pstate, "false");
1739       } else if (v->concrete_type() == Expression::STRING) {
1740         return v;
1741       } else {
1742         // ToDo: fix to_sass for nested parentheses
1743         Sass_Output_Style old_style;
1744         old_style = ctx.c_options.output_style;
1745         ctx.c_options.output_style = TO_SASS;
1746         Emitter emitter(ctx.c_options);
1747         Inspect i(emitter);
1748         i.in_declaration = false;
1749         v->perform(&i);
1750         ctx.c_options.output_style = old_style;
1751         return SASS_MEMORY_NEW(String_Quoted, pstate, i.get_buffer());
1752       }
1753       // return v;
1754     }
1755     Signature selector_nest_sig = "selector-nest($selectors...)";
1756     BUILT_IN(selector_nest)
1757     {
1758       List_Ptr arglist = ARG("$selectors", List);
1759
1760       // Not enough parameters
1761       if( arglist->length() == 0 )
1762         error("$selectors: At least one selector must be passed for `selector-nest'", pstate);
1763
1764       // Parse args into vector of selectors
1765       std::vector<Selector_List_Obj> parsedSelectors;
1766       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
1767         Expression_Obj exp = Cast<Expression>(arglist->value_at_index(i));
1768         if (exp->concrete_type() == Expression::NULL_VAL) {
1769           std::stringstream msg;
1770           msg << "$selectors: null is not a valid selector: it must be a string,\n";
1771           msg << "a list of strings, or a list of lists of strings for 'selector-nest'";
1772           error(msg.str(), pstate);
1773         }
1774         if (String_Constant_Obj str = Cast<String_Constant>(exp)) {
1775           str->quote_mark(0);
1776         }
1777         std::string exp_src = exp->to_string(ctx.c_options);
1778         Selector_List_Obj sel = Parser::parse_selector(exp_src.c_str(), ctx);
1779         parsedSelectors.push_back(sel);
1780       }
1781
1782       // Nothing to do
1783       if( parsedSelectors.empty() ) {
1784         return SASS_MEMORY_NEW(Null, pstate);
1785       }
1786
1787       // Set the first element as the `result`, keep appending to as we go down the parsedSelector vector.
1788       std::vector<Selector_List_Obj>::iterator itr = parsedSelectors.begin();
1789       Selector_List_Obj result = *itr;
1790       ++itr;
1791
1792       for(;itr != parsedSelectors.end(); ++itr) {
1793         Selector_List_Obj child = *itr;
1794         std::vector<Complex_Selector_Obj> exploded;
1795         selector_stack.push_back(result);
1796         Selector_List_Obj rv = child->resolve_parent_refs(ctx, selector_stack);
1797         selector_stack.pop_back();
1798         for (size_t m = 0, mLen = rv->length(); m < mLen; ++m) {
1799           exploded.push_back((*rv)[m]);
1800         }
1801         result->elements(exploded);
1802       }
1803
1804       Listize listize;
1805       return result->perform(&listize);
1806     }
1807
1808     Signature selector_append_sig = "selector-append($selectors...)";
1809     BUILT_IN(selector_append)
1810     {
1811       List_Ptr arglist = ARG("$selectors", List);
1812
1813       // Not enough parameters
1814       if( arglist->length() == 0 )
1815         error("$selectors: At least one selector must be passed for `selector-append'", pstate);
1816
1817       // Parse args into vector of selectors
1818       std::vector<Selector_List_Obj> parsedSelectors;
1819       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
1820         Expression_Obj exp = Cast<Expression>(arglist->value_at_index(i));
1821         if (exp->concrete_type() == Expression::NULL_VAL) {
1822           std::stringstream msg;
1823           msg << "$selectors: null is not a valid selector: it must be a string,\n";
1824           msg << "a list of strings, or a list of lists of strings for 'selector-append'";
1825           error(msg.str(), pstate);
1826         }
1827         if (String_Constant_Ptr str = Cast<String_Constant>(exp)) {
1828           str->quote_mark(0);
1829         }
1830         std::string exp_src = exp->to_string();
1831         Selector_List_Obj sel = Parser::parse_selector(exp_src.c_str(), ctx);
1832         parsedSelectors.push_back(sel);
1833       }
1834
1835       // Nothing to do
1836       if( parsedSelectors.empty() ) {
1837         return SASS_MEMORY_NEW(Null, pstate);
1838       }
1839
1840       // Set the first element as the `result`, keep appending to as we go down the parsedSelector vector.
1841       std::vector<Selector_List_Obj>::iterator itr = parsedSelectors.begin();
1842       Selector_List_Obj result = *itr;
1843       ++itr;
1844
1845       for(;itr != parsedSelectors.end(); ++itr) {
1846         Selector_List_Obj child = *itr;
1847         std::vector<Complex_Selector_Obj> newElements;
1848
1849         // For every COMPLEX_SELECTOR in `result`
1850         // For every COMPLEX_SELECTOR in `child`
1851           // let parentSeqClone equal a copy of result->elements[i]
1852           // let childSeq equal child->elements[j]
1853           // Append all of childSeq head elements into parentSeqClone
1854           // Set the innermost tail of parentSeqClone, to childSeq's tail
1855         // Replace result->elements with newElements
1856         for (size_t i = 0, resultLen = result->length(); i < resultLen; ++i) {
1857           for (size_t j = 0, childLen = child->length(); j < childLen; ++j) {
1858             Complex_Selector_Obj parentSeqClone = SASS_MEMORY_CLONE((*result)[i]);
1859             Complex_Selector_Obj childSeq = (*child)[j];
1860             Complex_Selector_Obj base = childSeq->tail();
1861
1862             // Must be a simple sequence
1863             if( childSeq->combinator() != Complex_Selector::Combinator::ANCESTOR_OF ) {
1864               std::string msg("Can't append \"");
1865               msg += childSeq->to_string();
1866               msg += "\" to \"";
1867               msg += parentSeqClone->to_string();
1868               msg += "\" for `selector-append'";
1869               error(msg, pstate, backtrace);
1870             }
1871
1872             // Cannot be a Universal selector
1873             Element_Selector_Obj pType = Cast<Element_Selector>(childSeq->head()->first());
1874             if(pType && pType->name() == "*") {
1875               std::string msg("Can't append \"");
1876               msg += childSeq->to_string();
1877               msg += "\" to \"";
1878               msg += parentSeqClone->to_string();
1879               msg += "\" for `selector-append'";
1880               error(msg, pstate, backtrace);
1881             }
1882
1883             // TODO: Add check for namespace stuff
1884
1885             // append any selectors in childSeq's head
1886             parentSeqClone->innermost()->head()->concat(base->head());
1887
1888             // Set parentSeqClone new tail
1889             parentSeqClone->innermost()->tail( base->tail() );
1890
1891             newElements.push_back(parentSeqClone);
1892           }
1893         }
1894
1895         result->elements(newElements);
1896       }
1897
1898       Listize listize;
1899       return result->perform(&listize);
1900     }
1901
1902     Signature selector_unify_sig = "selector-unify($selector1, $selector2)";
1903     BUILT_IN(selector_unify)
1904     {
1905       Selector_List_Obj selector1 = ARGSEL("$selector1", Selector_List_Obj, p_contextualize);
1906       Selector_List_Obj selector2 = ARGSEL("$selector2", Selector_List_Obj, p_contextualize);
1907
1908       Selector_List_Obj result = selector1->unify_with(selector2, ctx);
1909       Listize listize;
1910       return result->perform(&listize);
1911     }
1912
1913     Signature simple_selectors_sig = "simple-selectors($selector)";
1914     BUILT_IN(simple_selectors)
1915     {
1916       Compound_Selector_Obj sel = ARGSEL("$selector", Compound_Selector_Obj, p_contextualize);
1917
1918       List_Ptr l = SASS_MEMORY_NEW(List, sel->pstate(), sel->length(), SASS_COMMA);
1919
1920       for (size_t i = 0, L = sel->length(); i < L; ++i) {
1921         Simple_Selector_Obj ss = (*sel)[i];
1922         std::string ss_string = ss->to_string() ;
1923
1924         l->append(SASS_MEMORY_NEW(String_Quoted, ss->pstate(), ss_string));
1925       }
1926
1927       return l;
1928     }
1929
1930     Signature selector_extend_sig = "selector-extend($selector, $extendee, $extender)";
1931     BUILT_IN(selector_extend)
1932     {
1933       Selector_List_Obj  selector = ARGSEL("$selector", Selector_List_Obj, p_contextualize);
1934       Selector_List_Obj  extendee = ARGSEL("$extendee", Selector_List_Obj, p_contextualize);
1935       Selector_List_Obj  extender = ARGSEL("$extender", Selector_List_Obj, p_contextualize);
1936
1937       Subset_Map subset_map;
1938       extender->populate_extends(extendee, ctx, subset_map);
1939
1940       Selector_List_Obj result = Extend::extendSelectorList(selector, ctx, subset_map, false);
1941
1942       Listize listize;
1943       return result->perform(&listize);
1944     }
1945
1946     Signature selector_replace_sig = "selector-replace($selector, $original, $replacement)";
1947     BUILT_IN(selector_replace)
1948     {
1949       Selector_List_Obj selector = ARGSEL("$selector", Selector_List_Obj, p_contextualize);
1950       Selector_List_Obj original = ARGSEL("$original", Selector_List_Obj, p_contextualize);
1951       Selector_List_Obj replacement = ARGSEL("$replacement", Selector_List_Obj, p_contextualize);
1952       Subset_Map subset_map;
1953       replacement->populate_extends(original, ctx, subset_map);
1954
1955       Selector_List_Obj result = Extend::extendSelectorList(selector, ctx, subset_map, true);
1956
1957       Listize listize;
1958       return result->perform(&listize);
1959     }
1960
1961     Signature selector_parse_sig = "selector-parse($selector)";
1962     BUILT_IN(selector_parse)
1963     {
1964       Selector_List_Obj sel = ARGSEL("$selector", Selector_List_Obj, p_contextualize);
1965
1966       Listize listize;
1967       return sel->perform(&listize);
1968     }
1969
1970     Signature is_superselector_sig = "is-superselector($super, $sub)";
1971     BUILT_IN(is_superselector)
1972     {
1973       Selector_List_Obj  sel_sup = ARGSEL("$super", Selector_List_Obj, p_contextualize);
1974       Selector_List_Obj  sel_sub = ARGSEL("$sub", Selector_List_Obj, p_contextualize);
1975       bool result = sel_sup->is_superselector_of(sel_sub);
1976       return SASS_MEMORY_NEW(Boolean, pstate, result);
1977     }
1978
1979     Signature unique_id_sig = "unique-id()";
1980     BUILT_IN(unique_id)
1981     {
1982       std::stringstream ss;
1983       std::uniform_real_distribution<> distributor(0, 4294967296); // 16^8
1984       uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
1985       ss << "u" << std::setfill('0') << std::setw(8) << std::hex << distributed;
1986       return SASS_MEMORY_NEW(String_Quoted, pstate, ss.str());
1987     }
1988
1989     Signature is_bracketed_sig = "is-bracketed($list)";
1990     BUILT_IN(is_bracketed)
1991     {
1992       Value_Obj value = ARG("$list", Value);
1993       List_Obj list = Cast<List>(value);
1994       return SASS_MEMORY_NEW(Boolean, pstate, list && list->is_bracketed());
1995     }
1996   }
1997 }