sassc4 2.4.0

data/ext/libsass/src/backtrace.hpp

@@ -0,0 +1,29 @@
+#ifndef SASS_BACKTRACE_H
+#define SASS_BACKTRACE_H
+
+#include <vector>
+#include <sstream>
+#include "file.hpp"
+#include "position.hpp"
+
+namespace Sass {
+
+  struct Backtrace {
+
+    SourceSpan pstate;
+    sass::string caller;
+
+    Backtrace(SourceSpan pstate, sass::string c = "")
+    : pstate(pstate),
+      caller(c)
+    { }
+
+  };
+
+  typedef sass::vector<Backtrace> Backtraces;
+
+  const sass::string traces_to_string(Backtraces traces, sass::string indent = "\t");
+
+}
+
+#endif

data/ext/libsass/src/base64vlq.cpp

@@ -0,0 +1,47 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "base64vlq.hpp"
+
+namespace Sass {
+
+  sass::string Base64VLQ::encode(const int number) const
+  {
+    sass::string encoded = "";
+
+    int vlq = to_vlq_signed(number);
+
+    do {
+      int digit = vlq & VLQ_BASE_MASK;
+      vlq >>= VLQ_BASE_SHIFT;
+      if (vlq > 0) {
+        digit |= VLQ_CONTINUATION_BIT;
+      }
+      encoded += base64_encode(digit);
+    } while (vlq > 0);
+
+    return encoded;
+  }
+
+  char Base64VLQ::base64_encode(const int number) const
+  {
+    int index = number;
+    if (index < 0) index = 0;
+    if (index > 63) index = 63;
+    return CHARACTERS[index];
+  }
+
+  int Base64VLQ::to_vlq_signed(const int number) const
+  {
+    return (number < 0) ? ((-number) << 1) + 1 : (number << 1) + 0;
+  }
+
+  const char* Base64VLQ::CHARACTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+  const int Base64VLQ::VLQ_BASE_SHIFT = 5;
+  const int Base64VLQ::VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+  const int Base64VLQ::VLQ_BASE_MASK = VLQ_BASE - 1;
+  const int Base64VLQ::VLQ_CONTINUATION_BIT = VLQ_BASE;
+
+}

data/ext/libsass/src/base64vlq.hpp

@@ -0,0 +1,30 @@
+#ifndef SASS_BASE64VLQ_H
+#define SASS_BASE64VLQ_H
+
+#include <string>
+
+namespace Sass {
+
+  class Base64VLQ {
+
+  public:
+
+    sass::string encode(const int number) const;
+
+  private:
+
+    char base64_encode(const int number) const;
+
+    int to_vlq_signed(const int number) const;
+
+    static const char* CHARACTERS;
+
+    static const int VLQ_BASE_SHIFT;
+    static const int VLQ_BASE;
+    static const int VLQ_BASE_MASK;
+    static const int VLQ_CONTINUATION_BIT;
+  };
+
+}
+
+#endif

data/ext/libsass/src/bind.cpp

@@ -0,0 +1,312 @@
+#include "sass.hpp"
+#include "bind.hpp"
+#include "ast.hpp"
+#include "backtrace.hpp"
+#include "context.hpp"
+#include "expand.hpp"
+#include "eval.hpp"
+#include <map>
+#include <iostream>
+#include <sstream>
+
+namespace Sass {
+
+  void bind(sass::string type, sass::string name, Parameters_Obj ps, Arguments_Obj as, Env* env, Eval* eval, Backtraces& traces)
+  {
+    sass::string callee(type + " " + name);
+
+    std::map<sass::string, Parameter_Obj> param_map;
+    List_Obj varargs = SASS_MEMORY_NEW(List, as->pstate());
+    varargs->is_arglist(true); // enable keyword size handling
+
+    for (size_t i = 0, L = as->length(); i < L; ++i) {
+      if (auto str = Cast<String_Quoted>((*as)[i]->value())) {
+        // force optional quotes (only if needed)
+        if (str->quote_mark()) {
+          str->quote_mark('*');
+        }
+      }
+    }
+
+    // Set up a map to ensure named arguments refer to actual parameters. Also
+    // eval each default value left-to-right, wrt env, populating env as we go.
+    for (size_t i = 0, L = ps->length(); i < L; ++i) {
+      Parameter_Obj  p = ps->at(i);
+      param_map[p->name()] = p;
+      // if (p->default_value()) {
+      //   env->local_frame()[p->name()] = p->default_value()->perform(eval->with(env));
+      // }
+    }
+
+    // plug in all args; if we have leftover params, deal with it later
+    size_t ip = 0, LP = ps->length();
+    size_t ia = 0, LA = as->length();
+    while (ia < LA) {
+      Argument_Obj a = as->at(ia);
+      if (ip >= LP) {
+        // skip empty rest arguments
+        if (a->is_rest_argument()) {
+          if (List_Obj l = Cast<List>(a->value())) {
+            if (l->length() == 0) {
+              ++ ia; continue;
+            }
+          }
+        }
+        sass::ostream msg;
+        msg << "wrong number of arguments (" << LA << " for " << LP << ")";
+        msg << " for `" << name << "'";
+        return error(msg.str(), as->pstate(), traces);
+      }
+      Parameter_Obj p = ps->at(ip);
+
+      // If the current parameter is the rest parameter, process and break the loop
+      if (p->is_rest_parameter()) {
+        // The next argument by coincidence provides a rest argument
+        if (a->is_rest_argument()) {
+
+          // We should always get a list for rest arguments
+          if (List_Obj rest = Cast<List>(a->value())) {
+              // create a new list object for wrapped items
+              List* arglist = SASS_MEMORY_NEW(List,
+                                              p->pstate(),
+                                              0,
+                                              rest->separator(),
+                                              true);
+              // wrap each item from list as an argument
+              for (ExpressionObj item : rest->elements()) {
+                if (Argument_Obj arg = Cast<Argument>(item)) {
+                  arglist->append(SASS_MEMORY_COPY(arg)); // copy
+                } else {
+                  arglist->append(SASS_MEMORY_NEW(Argument,
+                                                  item->pstate(),
+                                                  item,
+                                                  "",
+                                                  false,
+                                                  false));
+                }
+              }
+              // assign new arglist to environment
+              env->local_frame()[p->name()] = arglist;
+            }
+          // invalid state
+          else {
+            throw std::runtime_error("invalid state");
+          }
+        } else if (a->is_keyword_argument()) {
+
+          // expand keyword arguments into their parameters
+          List* arglist = SASS_MEMORY_NEW(List, p->pstate(), 0, SASS_COMMA, true);
+          env->local_frame()[p->name()] = arglist;
+          Map_Obj argmap = Cast<Map>(a->value());
+          for (auto key : argmap->keys()) {
+            if (String_Constant_Obj str = Cast<String_Constant>(key)) {
+              sass::string param = unquote(str->value());
+              arglist->append(SASS_MEMORY_NEW(Argument,
+                                              key->pstate(),
+                                              argmap->at(key),
+                                              "$" + param,
+                                              false,
+                                              false));
+            } else {
+              traces.push_back(Backtrace(key->pstate()));
+              throw Exception::InvalidVarKwdType(key->pstate(), traces, key->inspect(), a);
+            }
+          }
+
+        } else {
+
+          // create a new list object for wrapped items
+          List_Obj arglist = SASS_MEMORY_NEW(List,
+                                          p->pstate(),
+                                          0,
+                                          SASS_COMMA,
+                                          true);
+          // consume the next args
+          while (ia < LA) {
+            // get and post inc
+            a = (*as)[ia++];
+            // maybe we have another list as argument
+            List_Obj ls = Cast<List>(a->value());
+            // skip any list completely if empty
+            if (ls && ls->empty() && a->is_rest_argument()) continue;
+
+            ExpressionObj value = a->value();
+            if (Argument_Obj arg = Cast<Argument>(value)) {
+              arglist->append(arg);
+            }
+            // check if we have rest argument
+            else if (a->is_rest_argument()) {
+              // preserve the list separator from rest args
+              if (List_Obj rest = Cast<List>(a->value())) {
+                arglist->separator(rest->separator());
+
+                for (size_t i = 0, L = rest->length(); i < L; ++i) {
+                  ExpressionObj obj = rest->value_at_index(i);
+                  arglist->append(SASS_MEMORY_NEW(Argument,
+                                                obj->pstate(),
+                                                obj,
+                                                "",
+                                                false,
+                                                false));
+                }
+              }
+              // no more arguments
+              break;
+            }
+            // wrap all other value types into Argument
+            else {
+              arglist->append(SASS_MEMORY_NEW(Argument,
+                                            a->pstate(),
+                                            a->value(),
+                                            a->name(),
+                                            false,
+                                            false));
+            }
+          }
+          // assign new arglist to environment
+          env->local_frame()[p->name()] = arglist;
+        }
+        // consumed parameter
+        ++ip;
+        // no more parameters
+        break;
+      }
+
+      // If the current argument is the rest argument, extract a value for processing
+      else if (a->is_rest_argument()) {
+        // normal param and rest arg
+        List_Obj arglist = Cast<List>(a->value());
+        if (!arglist) {
+          if (ExpressionObj arg = Cast<Expression>(a->value())) {
+            arglist = SASS_MEMORY_NEW(List, a->pstate(), 1);
+            arglist->append(arg);
+          }
+        }
+
+        // empty rest arg - treat all args as default values
+        if (!arglist || !arglist->length()) {
+          break;
+        } else {
+          if (arglist->length() > LP - ip && !ps->has_rest_parameter()) {
+            size_t arg_count = (arglist->length() + LA - 1);
+            sass::ostream msg;
+            msg << callee << " takes " << LP;
+            msg << (LP == 1 ? " argument" : " arguments");
+            msg << " but " << arg_count;
+            msg << (arg_count == 1 ? " was passed" : " were passed.");
+            deprecated_bind(msg.str(), as->pstate());
+
+            while (arglist->length() > LP - ip) {
+              arglist->elements().erase(arglist->elements().end() - 1);
+            }
+          }
+        }
+        // otherwise move one of the rest args into the param, converting to argument if necessary
+        ExpressionObj obj = arglist->at(0);
+        if (!(a = Cast<Argument>(obj))) {
+          Expression* a_to_convert = obj;
+          a = SASS_MEMORY_NEW(Argument,
+                              a_to_convert->pstate(),
+                              a_to_convert,
+                              "",
+                              false,
+                              false);
+        }
+        arglist->elements().erase(arglist->elements().begin());
+        if (!arglist->length() || (!arglist->is_arglist() && ip + 1 == LP)) {
+          ++ia;
+        }
+
+      } else if (a->is_keyword_argument()) {
+        Map_Obj argmap = Cast<Map>(a->value());
+
+        for (auto key : argmap->keys()) {
+          String_Constant* val = Cast<String_Constant>(key);
+          if (val == NULL) {
+            traces.push_back(Backtrace(key->pstate()));
+            throw Exception::InvalidVarKwdType(key->pstate(), traces, key->inspect(), a);
+          }
+          sass::string param = "$" + unquote(val->value());
+
+          if (!param_map.count(param)) {
+            sass::ostream msg;
+            msg << callee << " has no parameter named " << param;
+            error(msg.str(), a->pstate(), traces);
+          }
+          env->local_frame()[param] = argmap->at(key);
+        }
+        ++ia;
+        continue;
+      } else {
+        ++ia;
+      }
+
+      if (a->name().empty()) {
+        if (env->has_local(p->name())) {
+          sass::ostream msg;
+          msg << "parameter " << p->name()
+          << " provided more than once in call to " << callee;
+          error(msg.str(), a->pstate(), traces);
+        }
+        // ordinal arg -- bind it to the next param
+        env->local_frame()[p->name()] = a->value();
+        ++ip;
+      }
+      else {
+        // named arg -- bind it to the appropriately named param
+        if (!param_map.count(a->name())) {
+          if (ps->has_rest_parameter()) {
+            varargs->append(a);
+          } else {
+            sass::ostream msg;
+            msg << callee << " has no parameter named " << a->name();
+            error(msg.str(), a->pstate(), traces);
+          }
+        }
+        if (param_map[a->name()]) {
+          if (param_map[a->name()]->is_rest_parameter()) {
+            sass::ostream msg;
+            msg << "argument " << a->name() << " of " << callee
+                << "cannot be used as named argument";
+            error(msg.str(), a->pstate(), traces);
+          }
+        }
+        if (env->has_local(a->name())) {
+          sass::ostream msg;
+          msg << "parameter " << p->name()
+              << "provided more than once in call to " << callee;
+          error(msg.str(), a->pstate(), traces);
+        }
+        env->local_frame()[a->name()] = a->value();
+      }
+    }
+    // EO while ia
+
+    // If we make it here, we're out of args but may have leftover params.
+    // That's only okay if they have default values, or were already bound by
+    // named arguments, or if it's a single rest-param.
+    for (size_t i = ip; i < LP; ++i) {
+      Parameter_Obj leftover = ps->at(i);
+      // cerr << "env for default params:" << endl;
+      // env->print();
+      // cerr << "********" << endl;
+      if (!env->has_local(leftover->name())) {
+        if (leftover->is_rest_parameter()) {
+          env->local_frame()[leftover->name()] = varargs;
+        }
+        else if (leftover->default_value()) {
+          Expression* dv = leftover->default_value()->perform(eval);
+          env->local_frame()[leftover->name()] = dv;
+        }
+        else {
+          // param is unbound and has no default value -- error
+          throw Exception::MissingArgument(as->pstate(), traces, name, leftover->name(), type);
+        }
+      }
+    }
+
+    return;
+  }
+
+
+}

data/ext/libsass/src/bind.hpp

@@ -0,0 +1,15 @@
+#ifndef SASS_BIND_H
+#define SASS_BIND_H
+
+#include <string>
+#include "backtrace.hpp"
+#include "environment.hpp"
+#include "ast_fwd_decl.hpp"
+
+namespace Sass {
+
+  void bind(sass::string type, sass::string name, Parameters_Obj, Arguments_Obj, Env*, Eval*, Backtraces& traces);
+
+}
+
+#endif

data/ext/libsass/src/c2ast.cpp

@@ -0,0 +1,64 @@
+#include "ast.hpp"
+#include "units.hpp"
+#include "position.hpp"
+#include "backtrace.hpp"
+#include "sass/values.h"
+#include "ast_fwd_decl.hpp"
+#include "error_handling.hpp"
+
+namespace Sass {
+
+  Value* c2ast(union Sass_Value* v, Backtraces traces, SourceSpan pstate)
+  {
+    using std::strlen;
+    using std::strcpy;
+    Value* e = NULL;
+    switch (sass_value_get_tag(v)) {
+      case SASS_BOOLEAN: {
+        e = SASS_MEMORY_NEW(Boolean, pstate, !!sass_boolean_get_value(v));
+      } break;
+      case SASS_NUMBER: {
+        e = SASS_MEMORY_NEW(Number, pstate, sass_number_get_value(v), sass_number_get_unit(v));
+      } break;
+      case SASS_COLOR: {
+        e = SASS_MEMORY_NEW(Color_RGBA, pstate, sass_color_get_r(v), sass_color_get_g(v), sass_color_get_b(v), sass_color_get_a(v));
+      } break;
+      case SASS_STRING: {
+        if (sass_string_is_quoted(v))
+          e = SASS_MEMORY_NEW(String_Quoted, pstate, sass_string_get_value(v));
+        else {
+          e = SASS_MEMORY_NEW(String_Constant, pstate, sass_string_get_value(v));
+        }
+      } break;
+      case SASS_LIST: {
+        List* l = SASS_MEMORY_NEW(List, pstate, sass_list_get_length(v), sass_list_get_separator(v));
+        for (size_t i = 0, L = sass_list_get_length(v); i < L; ++i) {
+          l->append(c2ast(sass_list_get_value(v, i), traces, pstate));
+        }
+        l->is_bracketed(sass_list_get_is_bracketed(v));
+        e = l;
+      } break;
+      case SASS_MAP: {
+        Map* m = SASS_MEMORY_NEW(Map, pstate);
+        for (size_t i = 0, L = sass_map_get_length(v); i < L; ++i) {
+          *m << std::make_pair(
+            c2ast(sass_map_get_key(v, i), traces, pstate),
+            c2ast(sass_map_get_value(v, i), traces, pstate));
+        }
+        e = m;
+      } break;
+      case SASS_NULL: {
+        e = SASS_MEMORY_NEW(Null, pstate);
+      } break;
+      case SASS_ERROR: {
+        error("Error in C function: " + sass::string(sass_error_get_message(v)), pstate, traces);
+      } break;
+      case SASS_WARNING: {
+        error("Warning in C function: " + sass::string(sass_warning_get_message(v)), pstate, traces);
+      } break;
+      default: break;
+    }
+    return e;
+  }
+
+}

data/ext/libsass/src/c2ast.hpp

@@ -0,0 +1,14 @@
+#ifndef SASS_C2AST_H
+#define SASS_C2AST_H
+
+#include "position.hpp"
+#include "backtrace.hpp"
+#include "ast_fwd_decl.hpp"
+
+namespace Sass {
+
+  Value* c2ast(union Sass_Value* v, Backtraces traces, SourceSpan pstate);
+
+}
+
+#endif

data/ext/libsass/src/c99func.c

@@ -0,0 +1,54 @@
+/*
+  Copyright (C) 2011 Joseph A. Adams (joeyadams3.14159@gmail.com)
+  All rights reserved.
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#if defined(_MSC_VER) && _MSC_VER < 1900
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+static int c99_vsnprintf(char* str, size_t size, const char* format, va_list ap)
+{
+    int count = -1;
+
+    if (size != 0)
+        count = _vsnprintf_s(str, size, _TRUNCATE, format, ap);
+    if (count == -1)
+        count = _vscprintf(format, ap);
+
+    return count;
+}
+
+int snprintf(char* str, size_t size, const char* format, ...)
+{
+    int count;
+    va_list ap;
+
+    va_start(ap, format);
+    count = c99_vsnprintf(str, size, format, ap);
+    va_end(ap);
+
+    return count;
+}
+
+#endif

data/ext/libsass/src/cencode.c

@@ -0,0 +1,106 @@
+/*
+cencoder.c - c source to a base64 encoding algorithm implementation
+
+This is part of the libb64 project, and has been placed in the public domain.
+For details, see http://sourceforge.net/projects/libb64
+*/
+
+#include "b64/cencode.h"
+
+void base64_init_encodestate(base64_encodestate* state_in)
+{
+	state_in->step = step_A;
+	state_in->result = 0;
+	state_in->stepcount = 0;
+}
+
+char base64_encode_value(char value_in)
+{
+	static const char* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	if (value_in > 63) return '=';
+	return encoding[(int)value_in];
+}
+
+int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in)
+{
+	const char* plainchar = plaintext_in;
+	const char* const plaintextend = plaintext_in + length_in;
+	char* codechar = code_out;
+	char result;
+	char fragment;
+
+	result = state_in->result;
+
+	switch (state_in->step)
+	{
+		while (1)
+		{
+	case step_A:
+			if (plainchar == plaintextend)
+			{
+				state_in->result = result;
+				state_in->step = step_A;
+				return (int)(codechar - code_out);
+			}
+			fragment = *plainchar++;
+			result = (fragment & 0x0fc) >> 2;
+			*codechar++ = base64_encode_value(result);
+			result = (fragment & 0x003) << 4;
+			/* fall through */
+
+	case step_B:
+			if (plainchar == plaintextend)
+			{
+				state_in->result = result;
+				state_in->step = step_B;
+				return (int)(codechar - code_out);
+			}
+			fragment = *plainchar++;
+			result |= (fragment & 0x0f0) >> 4;
+			*codechar++ = base64_encode_value(result);
+			result = (fragment & 0x00f) << 2;
+			/* fall through */
+
+	case step_C:
+			if (plainchar == plaintextend)
+			{
+				state_in->result = result;
+				state_in->step = step_C;
+				return (int)(codechar - code_out);
+			}
+			fragment = *plainchar++;
+			result |= (fragment & 0x0c0) >> 6;
+			*codechar++ = base64_encode_value(result);
+			result  = (fragment & 0x03f) >> 0;
+			*codechar++ = base64_encode_value(result);
+
+			++(state_in->stepcount);
+		}
+	}
+	/* control should not reach here */
+	return (int)(codechar - code_out);
+}
+
+int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
+{
+	char* codechar = code_out;
+
+	switch (state_in->step)
+	{
+	case step_B:
+		*codechar++ = base64_encode_value(state_in->result);
+		*codechar++ = '=';
+		*codechar++ = '=';
+		break;
+	case step_C:
+		*codechar++ = base64_encode_value(state_in->result);
+		*codechar++ = '=';
+		break;
+	case step_A:
+		break;
+	}
+	*codechar++ = '\n';
+
+	return (int)(codechar - code_out);
+}
+