sassc 0.0.1

data/ext/libsass/ast_def_macros.hpp

@@ -0,0 +1,16 @@
+#define ATTACH_OPERATIONS()\
+virtual void perform(Operation<void>* op) { (*op)(this); }\
+virtual AST_Node* perform(Operation<AST_Node*>* op) { return (*op)(this); }\
+virtual Statement* perform(Operation<Statement*>* op) { return (*op)(this); }\
+virtual Expression* perform(Operation<Expression*>* op) { return (*op)(this); }\
+virtual Selector* perform(Operation<Selector*>* op) { return (*op)(this); }\
+virtual string perform(Operation<string>* op) { return (*op)(this); }\
+virtual Sass_Value* perform(Operation<Sass_Value*>* op) { return (*op)(this); }
+
+#define ADD_PROPERTY(type, name)\
+protected:\
+  type name##_;\
+public:\
+  type name() const        { return name##_; }\
+  type name(type name##__) { return name##_ = name##__; }\
+private:

data/ext/libsass/ast_factory.hpp

@@ -0,0 +1,87 @@
+#define SASS_AST_FACTORY
+
+#include <vector>
+
+#ifndef SASS_AST
+#include "ast.hpp"
+#endif
+
+namespace Sass {
+  using namespace std;
+
+  class AST_Factory {
+    vector<AST_Node*> nodes;
+  public:
+    // statements
+    Block* new_Block(string p, size_t l, size_t s = 0, bool r = false);
+    Ruleset* new_Ruleset(string p, size_t l, Selector* s, Block* b);
+    Propset* new_Propset(string p, size_t l, String* pf, Block* b);
+    Feature_Query* new_Feature_Query(string p, size_t l, Feature_Query* f, Block* b);
+    Media_Query* new_Media_Query(string p, size_t l, List* q, Block* b);
+    At_Rule* new_At_Rule(string p, size_t l, string kwd, Selector* sel, Block* b);
+    Declaration* new_Declaration(string p, size_t l, String* prop, List* vals);
+    Assignment* new_Assignment(string p, size_t l, string var, Expression* val, bool guarded = false);
+    Import<Function_Call*>* new_CSS_Import(string p, size_t l, Function_Call* loc);
+    Import<String*>* new_SASS_Import(string p, size_t l, String* loc);
+    Warning* new_Warning(string p, size_t l, Expression* msg);
+    Error* new_Error(string p, size_t l, Expression* msg);
+    Debug* new_Debug(string p, size_t l, Expression* val);
+    Comment* new_Comment(string p, size_t l, String* txt);
+    If* new_If(string p, size_t l, Expression* pred, Block* con, Block* alt = 0);
+    For* new_For(string p, size_t l, string var, Expression* lo, Expression* hi, Block* b, bool inc);
+    Each* new_Each(string p, size_t l, vector<string> vars, Expression* lst, Block* b);
+    While* new_While(string p, size_t l, Expression* pred, Block* b);
+    Extension* new_Extension(string p, size_t l, Selector* s);
+    Definition<MIXIN>* new_Mixin_Definition(string p, size_t l, string n, Parameters* params, Block* b);
+    Definition<FUNCTION>* new_Function_Definition(string p, size_t l, string n, Parameters* params, Block* b);
+    Mixin_Call* new_Mixin_Call(string p, size_t l, string n, Arguments* args, Block* b = 0);
+    // expressions
+    List* new_List(string p, size_t l, size_t size = 0, List::Separator sep = List::space, bool argl = false);
+    Map* new_Map(string p, size_t l, size_t size = 0);
+    Binary_Expression<AND>* new_And(string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<OR>* new_Or(string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<EQ>* new_Eq(string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<NEQ>* new_Neq(string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<GT>* new_Gt(string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<GTE>* new_Gte(string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<LT>* new_Lt(string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<LTE>* new_Lte(string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<ADD>* new_Add(string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<SUB>* new_Sub(string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<MUL>* new_Mul(string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<DIV>* new_Div(string p, size_t l, Expression* lhs, Expression* rhs);
+    Negation* new_Negation(string p, size_t l, Expression* o);
+    Function_Call* new_Function_Call(string p, size_t l, String* n, Arguments* args);
+    Variable* new_Variable(string p, size_t l, string n);
+    Textual<NUMBER>* new_Textual_Number(string p, size_t l, string val);
+    Textual<PERCENTAGE>* new_Textual_Percentage(string p, size_t l, string val);
+    Textual<DIMENSION>* new_Textual_Dimension(string p, size_t l, string val);
+    Textual<HEX>* new_Textual_Hex(string p, size_t l, string val);
+    Number* new_Number(string p, size_t l, double val);
+    Percentage* new_Percentage(string p, size_t l, double val);
+    Dimension* new_Dimension(string p, size_t l, double val, string unit);
+    Color* new_Color(string p, size_t l, double r, double g, double b, double a = 1, string disp = "");
+    Boolean* new_Boolean(string p, size_t l, bool val);
+    String_Schema* new_String_Schema(string p, size_t l, size_t size = 0);
+    String_Constant* new_String_Constant(string p, size_t l, string val);
+    String_Constant* new_String_Constant(string p, size_t l, const char* beg);
+    String_Constant* new_String_Constant(string p, size_t l, const char* beg, const char* end);
+    Feature_Query_Condition* new_Feature_Query_Condition(string p, size_t l, String* f, Expression* v);
+    Media_Expression* new_Media_Expression(string p, size_t l, String* f, Expression* v);
+    // parameters and arguments
+    Parameter* new_Parameter(string p, size_t l, string n, Expression* def = 0, bool rest = false);
+    Parameters* new_Parameters(string p, size_t l);
+    Argument* new_Argument(string p, size_t l, Expression* val, string n = "", bool rest = false);
+    Arguments* new_Arguments(string p, size_t l);
+    // selectors
+    Selector_Schema* new_Selector_Schema(string p, size_t l, String* c);
+    Simple_Selector* new_Simple_Selector(string p, size_t l, string c);
+    Reference_Selector* new_Reference_Selector(string p, size_t l);
+    Placeholder_Selector* new_Placeholder_Selector(string p, size_t l, string n);
+    Pseudo_Selector* new_Pseudo_Selector(string p, size_t l, string n, Expression* expr = 0);
+    Wrapped_Selector* new_Wrapped_Selector(string p, size_t l, string n, Simple_Base* sel);
+    Compound_Selector* new_Compound_Selector(string p, size_t l, size_t s = 0);
+    Complex_Selector* new_Complex_Selector(string p, size_t l, Complex_Selector::Combinator c, Complex_Selector* ctx, Compound_Selector* sel);
+    Selector_List* new_Selector_List(string p, size_t l, size_t s = 0);
+  };
+}

data/ext/libsass/ast_fwd_decl.hpp

@@ -0,0 +1,72 @@
+/////////////////////////////////////////////
+// Forward declarations for the AST visitors.
+/////////////////////////////////////////////
+namespace Sass {
+
+  class AST_Node;
+  // statements
+  class Statement;
+  class Block;
+  class Ruleset;
+  class Propset;
+  class Media_Block;
+  class Feature_Block;
+  class At_Rule;
+  class Declaration;
+  class Assignment;
+  class Import;
+  class Import_Stub;
+  class Warning;
+  class Error;
+  class Debug;
+  class Comment;
+  class If;
+  class For;
+  class Each;
+  class While;
+  class Return;
+  class Content;
+  class Extension;
+  class Definition;
+  class Mixin_Call;
+  // expressions
+  class Expression;
+  class List;
+  class Map;
+  class Binary_Expression;
+  class Unary_Expression;
+  class Function_Call;
+  class Function_Call_Schema;
+  class Variable;
+  class Textual;
+  class Number;
+  class Color;
+  class Boolean;
+  class String_Schema;
+  class String;
+  class String_Constant;
+  class Media_Query;
+  class Media_Query_Expression;
+  class Feature_Query;
+  class Feature_Query_Condition;
+  class Null;
+  // parameters and arguments
+  class Parameter;
+  class Parameters;
+  class Argument;
+  class Arguments;
+  // selectors
+  class Selector;
+  class Selector_Schema;
+  class Selector_Reference;
+  class Selector_Placeholder;
+  class Type_Selector;
+  class Selector_Qualifier;
+  class Attribute_Selector;
+  class Pseudo_Selector;
+  class Wrapped_Selector;
+  class Compound_Selector;
+  class Complex_Selector;
+  class Selector_List;
+
+}

data/ext/libsass/b64/cencode.h

@@ -0,0 +1,32 @@
+/*
+cencode.h - c header for a base64 encoding algorithm
+
+This is part of the libb64 project, and has been placed in the public domain.
+For details, see http://sourceforge.net/projects/libb64
+*/
+
+#ifndef BASE64_CENCODE_H
+#define BASE64_CENCODE_H
+
+typedef enum
+{
+	step_A, step_B, step_C
+} base64_encodestep;
+
+typedef struct
+{
+	base64_encodestep step;
+	char result;
+	int stepcount;
+} base64_encodestate;
+
+void base64_init_encodestate(base64_encodestate* state_in);
+
+char base64_encode_value(char value_in);
+
+int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in);
+
+int base64_encode_blockend(char* code_out, base64_encodestate* state_in);
+
+#endif /* BASE64_CENCODE_H */
+

data/ext/libsass/b64/encode.h

@@ -0,0 +1,77 @@
+// :mode=c++:
+/*
+encode.h - c++ wrapper for a base64 encoding algorithm
+
+This is part of the libb64 project, and has been placed in the public domain.
+For details, see http://sourceforge.net/projects/libb64
+*/
+#ifndef BASE64_ENCODE_H
+#define BASE64_ENCODE_H
+
+#include <iostream>
+
+namespace base64
+{
+	extern "C" 
+	{
+		#include "cencode.h"
+	}
+
+	struct encoder
+	{
+		base64_encodestate _state;
+		int _buffersize;
+
+		encoder(int buffersize_in = BUFFERSIZE)
+		: _buffersize(buffersize_in)
+		{}
+
+		int encode(char value_in)
+		{
+			return base64_encode_value(value_in);
+		}
+
+		int encode(const char* code_in, const int length_in, char* plaintext_out)
+		{
+			return base64_encode_block(code_in, length_in, plaintext_out, &_state);
+		}
+
+		int encode_end(char* plaintext_out)
+		{
+			return base64_encode_blockend(plaintext_out, &_state);
+		}
+
+		void encode(std::istream& istream_in, std::ostream& ostream_in)
+		{
+			base64_init_encodestate(&_state);
+			//
+			const int N = _buffersize;
+			char* plaintext = new char[N];
+			char* code = new char[2*N];
+			int plainlength;
+			int codelength;
+
+			do
+			{
+				istream_in.read(plaintext, N);
+				plainlength = istream_in.gcount();
+				//
+				codelength = encode(plaintext, plainlength, code);
+				ostream_in.write(code, codelength);
+			}
+			while (istream_in.good() && plainlength > 0);
+
+			codelength = encode_end(code);
+			ostream_in.write(code, codelength);
+			//
+			base64_init_encodestate(&_state);
+
+			delete [] code;
+			delete [] plaintext;
+		}
+	};
+
+} // namespace base64
+
+#endif // BASE64_ENCODE_H
+

data/ext/libsass/backtrace.hpp

@@ -0,0 +1,81 @@
+#define SASS_BACKTRACE
+
+#include <sstream>
+
+#ifndef SASS_POSITION
+#include "position.hpp"
+#endif
+
+#ifndef SASS_FILE
+#include "file.hpp"
+#endif
+
+namespace Sass {
+
+  using namespace std;
+
+  struct Backtrace {
+
+    Backtrace* parent;
+    string     path;
+    Position   position;
+    string     caller;
+
+    Backtrace(Backtrace* prn, string pth, Position position, string c)
+    : parent(prn),
+      path(pth),
+      position(position),
+      caller(c)
+    { }
+
+    string to_string(bool warning = false)
+    {
+      size_t i = -1;
+      stringstream ss;
+      string cwd(Sass::File::get_cwd());
+      Backtrace* this_point = this;
+
+      if (!warning) ss << endl << "Backtrace:";
+      // the first tracepoint (which is parent-less) is an empty placeholder
+      while (this_point->parent) {
+
+        // make path relative to the current directory
+        string rel_path(Sass::File::resolve_relative_path(this_point->path, cwd, cwd));
+
+        if (warning) {
+          ss << endl
+             << "\t"
+             << (++i == 0 ? "on" : "from")
+             << " line "
+             << this_point->position.line
+             << " of "
+             << rel_path;
+        } else {
+          ss << endl
+             << "\t"
+             << rel_path
+             << ":"
+             << this_point->position.line
+             << this_point->parent->caller;
+        }
+
+        this_point = this_point->parent;
+      }
+
+      return ss.str();
+    }
+
+    size_t depth()
+    {
+      size_t d = 0;
+      Backtrace* p = parent;
+      while (p) {
+        ++d;
+        p = p->parent;
+      }
+      return d-1;
+    }
+
+  };
+
+}

data/ext/libsass/base64vlq.cpp

@@ -0,0 +1,43 @@
+#include "base64vlq.hpp"
+
+namespace Sass {
+
+  string Base64VLQ::encode(const int number) const
+  {
+    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/base64vlq.hpp

@@ -0,0 +1,28 @@
+#define SASS_BASE64VLQ
+
+#include <string>
+
+namespace Sass {
+  using std::string;
+
+  class Base64VLQ {
+
+  public:
+
+    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;
+  };
+
+}

data/ext/libsass/bind.cpp

@@ -0,0 +1,187 @@
+#include "bind.hpp"
+#include "ast.hpp"
+#include "context.hpp"
+#include "eval.hpp"
+#include <map>
+#include <iostream>
+#include <sstream>
+#include "to_string.hpp"
+
+namespace Sass {
+  using namespace std;
+
+  void bind(string callee, Parameters* ps, Arguments* as, Context& ctx, Env* env, Eval* eval)
+  {
+    map<string, Parameter*> param_map;
+
+    // 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*  p = (*ps)[i];
+      param_map[p->name()] = p;
+      // if (p->default_value()) {
+      //   env->current_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) {
+      if (ip >= LP) {
+        stringstream msg;
+        msg << callee << " only takes " << LP << " arguments; "
+            << "given " << LA;
+        error(msg.str(), as->path(), as->position());
+      }
+      Parameter* p = (*ps)[ip];
+      Argument*  a = (*as)[ia];
+
+      // If the current parameter is the rest parameter, process and break the loop
+      if (p->is_rest_parameter()) {
+        if (a->is_rest_argument()) {
+          // rest param and rest arg -- just add one to the other
+          if (env->current_frame_has(p->name())) {
+            *static_cast<List*>(env->current_frame()[p->name()])
+            += static_cast<List*>(a->value());
+          }
+          else {
+            env->current_frame()[p->name()] = a->value();
+          }
+        } else {
+
+          // copy all remaining arguments into the rest parameter, preserving names
+          List* arglist = new (ctx.mem) List(p->path(),
+                                             p->position(),
+                                             0,
+                                             List::COMMA,
+                                             true);
+          env->current_frame()[p->name()] = arglist;
+          while (ia < LA) {
+            a = (*as)[ia];
+            (*arglist) << new (ctx.mem) Argument(a->path(),
+                                                 a->position(),
+                                                 a->value(),
+                                                 a->name(),
+                                                 false);
+            ++ia;
+          }
+        }
+        ++ip;
+        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* arglist = static_cast<List*>(a->value());
+        // empty rest arg - treat all args as default values
+        if (!arglist->length()) {
+          break;
+        }
+        // otherwise move one of the rest args into the param, converting to argument if necessary
+        if (arglist->is_arglist()) {
+          a = static_cast<Argument*>((*arglist)[0]);
+        } else {
+          Expression* a_to_convert = (*arglist)[0];
+          a = new (ctx.mem) Argument(a_to_convert->path(), a_to_convert->position(), a_to_convert, "", false);
+        }
+        arglist->elements().erase(arglist->elements().begin());
+        if (!arglist->length() || (!arglist->is_arglist() && ip + 1 == LP)) {
+          ++ia;
+        }
+      } else if (a->is_keyword_argument()) {
+        Map* argmap = static_cast<Map*>(a->value());
+
+        for (auto key : argmap->keys()) {
+          string name = "$" + unquote(static_cast<String_Constant*>(key)->value());
+
+          if (!param_map.count(name)) {
+            stringstream msg;
+            msg << callee << " has no parameter named " << name;
+            error(msg.str(), a->path(), a->position());
+          }
+          env->current_frame()[name] = argmap->at(key);
+        }
+        ++ia;
+        continue;
+      } else {
+        ++ia;
+      }
+
+      if (a->name().empty()) {
+        if (env->current_frame_has(p->name())) {
+          stringstream msg;
+          msg << "parameter " << p->name()
+          << " provided more than once in call to " << callee;
+          error(msg.str(), a->path(), a->position());
+        }
+        // ordinal arg -- bind it to the next param
+        env->current_frame()[p->name()] = a->value();
+        ++ip;
+      }
+      else {
+        // named arg -- bind it to the appropriately named param
+        if (!param_map.count(a->name())) {
+          stringstream msg;
+          msg << callee << " has no parameter named " << a->name();
+          error(msg.str(), a->path(), a->position());
+        }
+        if (param_map[a->name()]->is_rest_parameter()) {
+          stringstream msg;
+          msg << "argument " << a->name() << " of " << callee
+              << "cannot be used as named argument";
+          error(msg.str(), a->path(), a->position());
+        }
+        if (env->current_frame_has(a->name())) {
+          stringstream msg;
+          msg << "parameter " << p->name()
+              << "provided more than once in call to " << callee;
+          error(msg.str(), a->path(), a->position());
+        }
+        env->current_frame()[a->name()] = a->value();
+      }
+    }
+
+    // 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) {
+      To_String to_string;
+      Parameter* leftover = (*ps)[i];
+      // cerr << "env for default params:" << endl;
+      // env->print();
+      // cerr << "********" << endl;
+      if (!env->current_frame_has(leftover->name())) {
+        if (leftover->is_rest_parameter()) {
+          env->current_frame()[leftover->name()] = new (ctx.mem) List(leftover->path(),
+                                                                      leftover->position(),
+                                                                      0,
+                                                                      List::COMMA,
+                                                                      true);
+        }
+        else if (leftover->default_value()) {
+          // make sure to eval the default value in the env that we've been populating
+          Env* old_env = eval->env;
+          Backtrace* old_bt = eval->backtrace;
+          Expression* dv = leftover->default_value()->perform(eval->with(env, eval->backtrace));
+          eval->env = old_env;
+          eval->backtrace = old_bt;
+          // dv->perform(&to_string);
+          env->current_frame()[leftover->name()] = dv;
+        }
+        else {
+          // param is unbound and has no default value -- error
+          stringstream msg;
+          msg << "required parameter " << leftover->name()
+              << " is missing in call to " << callee;
+          error(msg.str(), as->path(), as->position());
+        }
+      }
+    }
+
+    return;
+  }
+
+
+}