sassc 0.0.1

data/ext/libsass/context.hpp

@@ -0,0 +1,150 @@
+#define SASS_CONTEXT
+
+#include <string>
+#include <vector>
+#include <map>
+#include "kwd_arg_macros.hpp"
+
+#ifndef SASS_MEMORY_MANAGER
+#include "memory_manager.hpp"
+#endif
+
+#ifndef SASS_ENVIRONMENT
+#include "environment.hpp"
+#endif
+
+#ifndef SASS_SOURCE_MAP
+#include "source_map.hpp"
+#endif
+
+#ifndef SASS_SUBSET_MAP
+#include "subset_map.hpp"
+#endif
+
+#define BUFFERSIZE 255
+#include "b64/encode.h"
+
+#include "sass_functions.h"
+
+struct Sass_C_Function_Descriptor;
+
+namespace Sass {
+  using namespace std;
+  class AST_Node;
+  class Block;
+  class Expression;
+  class Color;
+  struct Backtrace;
+  // typedef const char* Signature;
+  // struct Context;
+  // typedef Environment<AST_Node*> Env;
+  // typedef Expression* (*Native_Function)(Env&, Context&, Signature, string, size_t);
+
+  enum Output_Style { NESTED, EXPANDED, COMPACT, COMPRESSED, FORMATTED };
+
+  struct Sass_Queued {
+    string abs_path;
+    string load_path;
+    const char* source;
+  public:
+    Sass_Queued(const string& load_path, const string& abs_path, const char* source);
+  };
+
+  struct Context {
+    Memory_Manager<AST_Node> mem;
+
+    const char* source_c_str;
+
+    // c-strs containing Sass file contents
+    // we will overtake ownership of memory
+    vector<const char*> sources;
+    // absolute paths to includes
+    vector<string> included_files;
+    // relative links to includes
+    vector<string> include_links;
+    // vectors above have same size
+
+    vector<string> include_paths; // lookup paths for includes
+    vector<Sass_Queued> queue; // queue of files to be parsed
+    map<string, Block*> style_sheets; // map of paths to ASTs
+    SourceMap source_map;
+    vector<Sass_C_Function_Callback> c_functions;
+
+    string       image_path; // for the image-url Sass function
+    string       input_path; // for relative paths in src-map
+    string       output_path; // for relative paths to the output
+    bool         source_comments; // for inline debug comments in css output
+    Output_Style output_style; // output style for the generated css code
+    string       source_map_file; // path to source map file (enables feature)
+    bool         source_map_embed; // embed in sourceMappingUrl (as data-url)
+    bool         source_map_contents; // insert included contents into source map
+    bool         omit_source_map_url; // disable source map comment in css output
+    bool         is_indented_syntax_src; // treat source string as sass
+
+    // overload import calls
+    Sass_C_Import_Callback importer;
+    vector<struct Sass_Import*> import_stack;
+
+    map<string, Color*> names_to_colors;
+    map<int, string>    colors_to_names;
+
+    size_t precision; // precision for outputting fractional numbers
+    bool _skip_source_map_update; // status flag to skip source map updates
+
+    KWD_ARG_SET(Data) {
+      KWD_ARG(Data, const char*,     source_c_str);
+      KWD_ARG(Data, string,          entry_point);
+      KWD_ARG(Data, string,          input_path);
+      KWD_ARG(Data, string,          output_path);
+      KWD_ARG(Data, string,          image_path);
+      KWD_ARG(Data, const char*,     include_paths_c_str);
+      KWD_ARG(Data, const char**,    include_paths_array);
+      KWD_ARG(Data, vector<string>,  include_paths);
+      KWD_ARG(Data, bool,            source_comments);
+      KWD_ARG(Data, Output_Style,    output_style);
+      KWD_ARG(Data, string,          source_map_file);
+      KWD_ARG(Data, bool,            omit_source_map_url);
+      KWD_ARG(Data, bool,            is_indented_syntax_src);
+      KWD_ARG(Data, size_t,          precision);
+      KWD_ARG(Data, bool,            _skip_source_map_update);
+      KWD_ARG(Data, bool,            source_map_embed);
+      KWD_ARG(Data, bool,            source_map_contents);
+      KWD_ARG(Data, Sass_C_Import_Callback, importer);
+    };
+
+    Context(Data);
+    ~Context();
+    static string get_cwd();
+    void setup_color_map();
+    string add_file(string);
+    Block* parse_file();
+    string add_file(string, string);
+    Block* parse_string();
+    void add_source(string, string, const char*);
+    // allow to optionally overwrite the input path
+    // default argument for input_path is string("stdin")
+    // usefull to influence the source-map generating etc.
+    char* compile_file();
+    char* compile_string();
+    char* compile_block(Block* root);
+    char* generate_source_map();
+
+    vector<string> get_included_files(size_t skip = 0);
+
+  private:
+    void collect_include_paths(const char* paths_str);
+    void collect_include_paths(const char** paths_array);
+    string format_source_mapping_url(const string& file);
+
+    string cwd;
+
+    // void register_built_in_functions(Env* env);
+    // void register_function(Signature sig, Native_Function f, Env* env);
+    // void register_function(Signature sig, Native_Function f, size_t arity, Env* env);
+    // void register_overload_stub(string name, Env* env);
+
+  public:
+    Subset_Map<string, pair<Complex_Selector*, Compound_Selector*> > subset_map;
+  };
+
+}

data/ext/libsass/contextualize.cpp

@@ -0,0 +1,157 @@
+#include "contextualize.hpp"
+#include "ast.hpp"
+#include "eval.hpp"
+#include "backtrace.hpp"
+#include "to_string.hpp"
+#include "parser.hpp"
+
+namespace Sass {
+
+  Contextualize::Contextualize(Context& ctx, Eval* eval, Env* env, Backtrace* bt, Selector* placeholder, Selector* extender)
+  : ctx(ctx), eval(eval), env(env), parent(0), backtrace(bt), placeholder(placeholder), extender(extender)
+  { }
+
+  Contextualize::~Contextualize() { }
+
+  Selector* Contextualize::fallback_impl(AST_Node* n)
+  { return parent; }
+
+  Contextualize* Contextualize::with(Selector* s, Env* e, Backtrace* bt, Selector* p, Selector* ex)
+  {
+    parent = s;
+    env = e;
+    backtrace = bt;
+    placeholder = p;
+    extender = ex;
+    return this;
+  }
+
+  Selector* Contextualize::operator()(Selector_Schema* s)
+  {
+    To_String to_string;
+    string result_str(s->contents()->perform(eval->with(env, backtrace))->perform(&to_string));
+    result_str += '{'; // the parser looks for a brace to end the selector
+    Selector* result_sel = Parser::from_c_str(result_str.c_str(), ctx, s->path(), s->position()).parse_selector_group();
+    return result_sel->perform(this);
+  }
+
+  Selector* Contextualize::operator()(Selector_List* s)
+  {
+    Selector_List* p = static_cast<Selector_List*>(parent);
+    Selector_List* ss = 0;
+    if (p) {
+      ss = new (ctx.mem) Selector_List(s->path(), s->position(), p->length() * s->length());
+      for (size_t i = 0, L = p->length(); i < L; ++i) {
+        for (size_t j = 0, L = s->length(); j < L; ++j) {
+          parent = (*p)[i];
+          Complex_Selector* comb = static_cast<Complex_Selector*>((*s)[j]->perform(this));
+          if (comb) *ss << comb;
+        }
+      }
+    }
+    else {
+      ss = new (ctx.mem) Selector_List(s->path(), s->position(), s->length());
+      for (size_t j = 0, L = s->length(); j < L; ++j) {
+        Complex_Selector* comb = static_cast<Complex_Selector*>((*s)[j]->perform(this));
+        if (comb) *ss << comb;
+      }
+    }
+    return ss->length() ? ss : 0;
+  }
+
+  Selector* Contextualize::operator()(Complex_Selector* s)
+  {
+    To_String to_string;
+    Complex_Selector* ss = new (ctx.mem) Complex_Selector(*s);
+    Compound_Selector* new_head = 0;
+    Complex_Selector* new_tail = 0;
+    if (ss->head()) {
+      new_head = static_cast<Compound_Selector*>(s->head()->perform(this));
+      ss->head(new_head);
+    }
+    if (ss->tail()) {
+      new_tail = static_cast<Complex_Selector*>(s->tail()->perform(this));
+      ss->tail(new_tail);
+    }
+    if ((new_head && new_head->has_placeholder()) || (new_tail && new_tail->has_placeholder())) {
+      ss->has_placeholder(true);
+    }
+    else {
+      ss->has_placeholder(false);
+    }
+    if (!ss->head() && ss->combinator() == Complex_Selector::ANCESTOR_OF) {
+      return ss->tail();
+    }
+    else {
+      return ss;
+    }
+  }
+
+  Selector* Contextualize::operator()(Compound_Selector* s)
+  {
+    To_String to_string;
+    if (placeholder && extender && s->perform(&to_string) == placeholder->perform(&to_string)) {
+      return extender;
+    }
+    Compound_Selector* ss = new (ctx.mem) Compound_Selector(s->path(), s->position(), s->length());
+    for (size_t i = 0, L = s->length(); i < L; ++i) {
+      Simple_Selector* simp = static_cast<Simple_Selector*>((*s)[i]->perform(this));
+      if (simp) *ss << simp;
+    }
+    return ss->length() ? ss : 0;
+  }
+
+  Selector* Contextualize::operator()(Wrapped_Selector* s)
+  {
+    Selector* old_parent = parent;
+    parent = 0;
+    Wrapped_Selector* neg = new (ctx.mem) Wrapped_Selector(s->path(),
+                                                           s->position(),
+                                                           s->name(),
+                                                           s->selector()->perform(this));
+    parent = old_parent;
+    return neg;
+  }
+
+  Selector* Contextualize::operator()(Pseudo_Selector* s)
+  { return s; }
+
+  Selector* Contextualize::operator()(Attribute_Selector* s)
+  {
+    // the value might be interpolated; evaluate it
+    String* v = s->value();
+    if (v && eval) {
+      v = static_cast<String*>(v->perform(eval->with(env, backtrace)));
+    }
+    Attribute_Selector* ss = new (ctx.mem) Attribute_Selector(*s);
+    ss->value(v);
+    return ss;
+  }
+
+  Selector* Contextualize::operator()(Selector_Qualifier* s)
+  { return s; }
+
+  Selector* Contextualize::operator()(Type_Selector* s)
+  { return s; }
+
+  Selector* Contextualize::operator()(Selector_Placeholder* p)
+  {
+    To_String to_string;
+    if (placeholder && extender && p->perform(&to_string) == placeholder->perform(&to_string)) {
+      return extender;
+    }
+    else {
+      return p;
+    }
+  }
+
+  Selector* Contextualize::operator()(Selector_Reference* s)
+  {
+    if (!parent) return 0;
+    Selector_Reference* ss = new (ctx.mem) Selector_Reference(*s);
+    ss->selector(parent);
+    return ss;
+  }
+
+
+}

data/ext/libsass/contextualize.hpp

@@ -0,0 +1,65 @@
+#define SASS_CONTEXTUALIZE
+
+#ifndef SASS_ENVIRONMENT
+#include "environment.hpp"
+#endif
+
+#ifndef SASS_OPERATION
+#include "operation.hpp"
+#endif
+
+namespace Sass {
+  class AST_Node;
+  class Selector;
+  class Selector_Schema;
+  class Selector_List;
+  class Complex_Selector;
+  class Compound_Selector;
+  class Wrapped_Selector;
+  class Pseudo_Selector;
+  class Attribute_Selector;
+  class Selector_Qualifier;
+  class Type_Selector;
+  class Selector_Placeholder;
+  class Selector_Reference;
+  class Simple_Selector;
+  struct Context;
+  class Eval;
+  struct Backtrace;
+
+  typedef Environment<AST_Node*> Env;
+
+  class Contextualize : public Operation_CRTP<Selector*, Contextualize> {
+
+    Context&   ctx;
+    Eval*      eval;
+    Env*       env;
+    Selector*  parent;
+    Backtrace* backtrace;
+
+    Selector* fallback_impl(AST_Node* n);
+
+  public:
+    Selector* placeholder;
+    Selector* extender;
+    Contextualize(Context&, Eval*, Env*, Backtrace*, Selector* placeholder = 0, Selector* extender = 0);
+    virtual ~Contextualize();
+    Contextualize* with(Selector*, Env*, Backtrace*, Selector* placeholder = 0, Selector* extender = 0);
+    using Operation<Selector*>::operator();
+
+    Selector* operator()(Selector_Schema*);
+    Selector* operator()(Selector_List*);
+    Selector* operator()(Complex_Selector*);
+    Selector* operator()(Compound_Selector*);
+    Selector* operator()(Wrapped_Selector*);
+    Selector* operator()(Pseudo_Selector*);
+    Selector* operator()(Attribute_Selector*);
+    Selector* operator()(Selector_Qualifier*);
+    Selector* operator()(Type_Selector*);
+    Selector* operator()(Selector_Placeholder*);
+    Selector* operator()(Selector_Reference*);
+
+    template <typename U>
+    Selector* fallback(U x) { return fallback_impl(x); }
+  };
+}

data/ext/libsass/copy_c_str.cpp

@@ -0,0 +1,13 @@
+#include <cstdlib>
+#include <cstring>
+
+namespace Sass {
+  using namespace std;
+
+  char* copy_c_str(const char* orig)
+  {
+    char* copy = (char*) malloc(sizeof(char) * strlen(orig) + 1);
+    strcpy(copy, orig);
+    return copy;
+  }
+}

data/ext/libsass/copy_c_str.hpp

@@ -0,0 +1,5 @@
+namespace Sass {
+
+  char* copy_c_str(const char*);
+
+}

data/ext/libsass/debug.hpp

@@ -0,0 +1,39 @@
+#ifndef DEBUG_H
+#define DEBUG_H
+
+#include <stdint.h>
+
+enum dbg_lvl_t : uint32_t {
+	NONE = 0,
+	TRIM = 1,
+	CHUNKS = 2,
+	SUBWEAVE = 4,
+	WEAVE = 8,
+	EXTEND_COMPOUND = 16,
+	EXTEND_COMPLEX = 32,
+	LCS = 64,
+  EXTEND_OBJECT = 128,
+	ALL = UINT32_MAX
+};
+
+#ifdef DEBUG
+
+#ifndef DEBUG_LVL
+const uint32_t debug_lvl = UINT32_MAX;
+#else
+const uint32_t debug_lvl = (DEBUG_LVL);
+#endif // DEBUG_LVL
+
+#define DEBUG_PRINT(lvl, x) if((lvl) & debug_lvl) { std::cerr << x; }
+#define DEBUG_PRINTLN(lvl, x) if((lvl) & debug_lvl) { std::cerr << x << std::endl; }
+#define DEBUG_EXEC(lvl, x) if((lvl) & debug_lvl) { x; }
+
+#else // DEBUG
+
+#define DEBUG_PRINT(lvl, x)
+#define DEBUG_PRINTLN(lvl, x)
+#define DEBUG_EXEC(lvl, x)
+
+#endif // DEBUG
+
+#endif // DEBUG_H

data/ext/libsass/environment.hpp

@@ -0,0 +1,75 @@
+#define SASS_ENVIRONMENT
+
+#include <string>
+#include <map>
+#include "ast_def_macros.hpp"
+#include <iostream>
+
+namespace Sass {
+  using std::string;
+  using std::map;
+  using std::cerr;
+  using std::endl;
+
+  template <typename T>
+  class Environment {
+    // TODO: test with unordered_map
+    map<string, T> current_frame_;
+    ADD_PROPERTY(Environment*, parent);
+
+  public:
+    Environment() : current_frame_(map<string, T>()), parent_(0) { }
+
+    map<string, T>& current_frame() { return current_frame_; }
+
+    void link(Environment& env) { parent_ = &env; }
+    void link(Environment* env) { parent_ = env; }
+
+    bool has(const string key) const
+    {
+      if (current_frame_.count(key))  return true;
+      else if (parent_)               return parent_->has(key);
+      else                            return false;
+    }
+
+    bool current_frame_has(const string key) const
+    { return !!current_frame_.count(key); }
+
+    Environment* grandparent() const
+    {
+      if(parent_ && parent_->parent_) return parent_->parent_;
+      else return 0;
+    }
+
+    bool global_frame_has(const string key) const
+    {
+      if(parent_ && !grandparent()) {
+        return has(key);
+      }
+      else if(parent_) {
+        return parent_->global_frame_has(key);
+      }
+      else {
+        return false;
+      }
+    }
+
+    T& operator[](const string key)
+    {
+      if (current_frame_.count(key))  return current_frame_[key];
+      else if (parent_)               return (*parent_)[key];
+      else                            return current_frame_[key];
+    }
+
+    void print()
+    {
+      for (typename map<string, T>::iterator i = current_frame_.begin(); i != current_frame_.end(); ++i) {
+        cerr << i->first << endl;
+      }
+      if (parent_) {
+        cerr << "---" << endl;
+        parent_->print();
+      }
+    }
+  };
+}