sassc4 2.4.0

data/ext/libsass/src/source_map.cpp

@@ -0,0 +1,202 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <iomanip>
+
+#include "ast.hpp"
+#include "json.hpp"
+#include "context.hpp"
+#include "position.hpp"
+#include "source_map.hpp"
+
+namespace Sass {
+  SourceMap::SourceMap() : current_position(0, 0, 0), file("stdin") { }
+  SourceMap::SourceMap(const sass::string& file) : current_position(0, 0, 0), file(file) { }
+
+  sass::string SourceMap::render_srcmap(Context &ctx) {
+
+    const bool include_sources = ctx.c_options.source_map_contents;
+    const sass::vector<sass::string> links = ctx.srcmap_links;
+    const sass::vector<Resource>& sources(ctx.resources);
+
+    JsonNode* json_srcmap = json_mkobject();
+
+    json_append_member(json_srcmap, "version", json_mknumber(3));
+
+    const char *file_name = file.c_str();
+    JsonNode *json_file_name = json_mkstring(file_name);
+    json_append_member(json_srcmap, "file", json_file_name);
+
+    // pass-through sourceRoot option
+    if (!ctx.source_map_root.empty()) {
+      JsonNode* root = json_mkstring(ctx.source_map_root.c_str());
+      json_append_member(json_srcmap, "sourceRoot", root);
+    }
+
+    JsonNode *json_sources = json_mkarray();
+    for (size_t i = 0; i < source_index.size(); ++i) {
+      sass::string source(links[source_index[i]]);
+      if (ctx.c_options.source_map_file_urls) {
+        source = File::rel2abs(source);
+        // check for windows abs path
+        if (source[0] == '/') {
+          // ends up with three slashes
+          source = "file://" + source;
+        } else {
+          // needs an additional slash
+          source = "file:///" + source;
+        }
+      }
+      const char* source_name = source.c_str();
+      JsonNode *json_source_name = json_mkstring(source_name);
+      json_append_element(json_sources, json_source_name);
+    }
+    json_append_member(json_srcmap, "sources", json_sources);
+
+    if (include_sources && source_index.size()) {
+      JsonNode *json_contents = json_mkarray();
+      for (size_t i = 0; i < source_index.size(); ++i) {
+        const Resource& resource(sources[source_index[i]]);
+        JsonNode *json_content = json_mkstring(resource.contents);
+        json_append_element(json_contents, json_content);
+      }
+      json_append_member(json_srcmap, "sourcesContent", json_contents);
+    }
+
+    JsonNode *json_names = json_mkarray();
+    // so far we have no implementation for names
+    // no problem as we do not alter any identifiers
+    json_append_member(json_srcmap, "names", json_names);
+
+    sass::string mappings = serialize_mappings();
+    JsonNode *json_mappings = json_mkstring(mappings.c_str());
+    json_append_member(json_srcmap, "mappings", json_mappings);
+
+    char *str = json_stringify(json_srcmap, "\t");
+    sass::string result = sass::string(str);
+    free(str);
+    json_delete(json_srcmap);
+    return result;
+  }
+
+  sass::string SourceMap::serialize_mappings() {
+    sass::string result = "";
+
+    size_t previous_generated_line = 0;
+    size_t previous_generated_column = 0;
+    size_t previous_original_line = 0;
+    size_t previous_original_column = 0;
+    size_t previous_original_file = 0;
+    for (size_t i = 0; i < mappings.size(); ++i) {
+      const size_t generated_line = mappings[i].generated_position.line;
+      const size_t generated_column = mappings[i].generated_position.column;
+      const size_t original_line = mappings[i].original_position.line;
+      const size_t original_column = mappings[i].original_position.column;
+      const size_t original_file = mappings[i].original_position.file;
+
+      if (generated_line != previous_generated_line) {
+        previous_generated_column = 0;
+        if (generated_line > previous_generated_line) {
+          result += sass::string(generated_line - previous_generated_line, ';');
+          previous_generated_line = generated_line;
+        }
+      }
+      else if (i > 0) {
+        result += ",";
+      }
+
+      // generated column
+      result += base64vlq.encode(static_cast<int>(generated_column) - static_cast<int>(previous_generated_column));
+      previous_generated_column = generated_column;
+      // file
+      result += base64vlq.encode(static_cast<int>(original_file) - static_cast<int>(previous_original_file));
+      previous_original_file = original_file;
+      // source line
+      result += base64vlq.encode(static_cast<int>(original_line) - static_cast<int>(previous_original_line));
+      previous_original_line = original_line;
+      // source column
+      result += base64vlq.encode(static_cast<int>(original_column) - static_cast<int>(previous_original_column));
+      previous_original_column = original_column;
+    }
+
+    return result;
+  }
+
+  void SourceMap::prepend(const OutputBuffer& out)
+  {
+    Offset size(out.smap.current_position);
+    for (Mapping mapping : out.smap.mappings) {
+      if (mapping.generated_position.line > size.line) {
+        throw(std::runtime_error("prepend sourcemap has illegal line"));
+      }
+      if (mapping.generated_position.line == size.line) {
+        if (mapping.generated_position.column > size.column) {
+          throw(std::runtime_error("prepend sourcemap has illegal column"));
+        }
+      }
+    }
+    // adjust the buffer offset
+    prepend(Offset(out.buffer));
+    // now add the new mappings
+    VECTOR_UNSHIFT(mappings, out.smap.mappings);
+  }
+
+  void SourceMap::append(const OutputBuffer& out)
+  {
+    append(Offset(out.buffer));
+  }
+
+  void SourceMap::prepend(const Offset& offset)
+  {
+    if (offset.line != 0 || offset.column != 0) {
+      for (Mapping& mapping : mappings) {
+        // move stuff on the first old line
+        if (mapping.generated_position.line == 0) {
+          mapping.generated_position.column += offset.column;
+        }
+        // make place for the new lines
+        mapping.generated_position.line += offset.line;
+      }
+    }
+    if (current_position.line == 0) {
+      current_position.column += offset.column;
+    }
+    current_position.line += offset.line;
+  }
+
+  void SourceMap::append(const Offset& offset)
+  {
+    current_position += offset;
+  }
+
+  void SourceMap::add_open_mapping(const AST_Node* node)
+  {
+    const SourceSpan& span(node->pstate());
+    Position from(span.getSrcId(), span.position);
+    mappings.push_back(Mapping(from, current_position));
+  }
+
+  void SourceMap::add_close_mapping(const AST_Node* node)
+  {
+    const SourceSpan& span(node->pstate());
+    Position to(span.getSrcId(), span.position + span.offset);
+    mappings.push_back(Mapping(to, current_position));
+  }
+
+  SourceSpan SourceMap::remap(const SourceSpan& pstate) {
+    for (size_t i = 0; i < mappings.size(); ++i) {
+      if (
+        mappings[i].generated_position.file == pstate.getSrcId() &&
+        mappings[i].generated_position.line == pstate.position.line &&
+        mappings[i].generated_position.column == pstate.position.column
+      ) return SourceSpan(pstate.source, mappings[i].original_position, pstate.offset);
+    }
+    return SourceSpan(pstate.source, Position(-1, -1, -1), Offset(0, 0));
+
+  }
+
+}

data/ext/libsass/src/source_map.hpp

@@ -0,0 +1,65 @@
+#ifndef SASS_SOURCE_MAP_H
+#define SASS_SOURCE_MAP_H
+
+#include <string>
+#include <vector>
+
+#include "ast_fwd_decl.hpp"
+#include "base64vlq.hpp"
+#include "position.hpp"
+#include "mapping.hpp"
+
+#include "backtrace.hpp"
+#include "memory.hpp"
+
+#define VECTOR_PUSH(vec, ins) vec.insert(vec.end(), ins.begin(), ins.end())
+#define VECTOR_UNSHIFT(vec, ins) vec.insert(vec.begin(), ins.begin(), ins.end())
+
+namespace Sass {
+
+  class Context;
+  class OutputBuffer;
+
+  class SourceMap {
+
+  public:
+    sass::vector<size_t> source_index;
+    SourceMap();
+    SourceMap(const sass::string& file);
+
+    void append(const Offset& offset);
+    void prepend(const Offset& offset);
+    void append(const OutputBuffer& out);
+    void prepend(const OutputBuffer& out);
+    void add_open_mapping(const AST_Node* node);
+    void add_close_mapping(const AST_Node* node);
+
+    sass::string render_srcmap(Context &ctx);
+    SourceSpan remap(const SourceSpan& pstate);
+
+  private:
+
+    sass::string serialize_mappings();
+
+    sass::vector<Mapping> mappings;
+    Position current_position;
+public:
+    sass::string file;
+private:
+    Base64VLQ base64vlq;
+  };
+
+  class OutputBuffer {
+    public:
+      OutputBuffer(void)
+      : buffer(),
+        smap()
+      { }
+    public:
+      sass::string buffer;
+      SourceMap smap;
+  };
+
+}
+
+#endif

data/ext/libsass/src/stylesheet.cpp

@@ -0,0 +1,22 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "stylesheet.hpp"
+
+namespace Sass {
+
+  // Constructor
+  Sass::StyleSheet::StyleSheet(const Resource& res, Block_Obj root) :
+    Resource(res),
+    root(root)
+  {
+  }
+
+  StyleSheet::StyleSheet(const StyleSheet& sheet) :
+    Resource(sheet),
+    root(sheet.root)
+  {
+  }
+
+}

data/ext/libsass/src/stylesheet.hpp

@@ -0,0 +1,57 @@
+#ifndef SASS_STYLESHEET_H
+#define SASS_STYLESHEET_H
+
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "ast_fwd_decl.hpp"
+#include "extender.hpp"
+#include "file.hpp"
+
+namespace Sass {
+
+  // parsed stylesheet from loaded resource
+  // this should be a `Module` for sass 4.0
+  class StyleSheet : public Resource {
+    public:
+
+      // The canonical URL for this module's source file. This may be `null`
+      // if the module was loaded from a string without a URL provided.
+      // Uri get url;
+
+      // Modules that this module uses.
+      // List<Module> get upstream;
+
+      // The module's variables.
+      // Map<String, Value> get variables;
+
+      // The module's functions. Implementations must ensure
+      // that each [Callable] is stored under its own name.
+      // Map<String, Callable> get functions;
+
+      // The module's mixins. Implementations must ensure that
+      // each [Callable] is stored under its own name.
+      // Map<String, Callable> get mixins;
+
+      // The extensions defined in this module, which is also able to update
+      // [css]'s style rules in-place based on downstream extensions.
+      // Extender extender;
+
+      // The module's CSS tree.
+      Block_Obj root;
+
+    public:
+
+      // default argument constructor
+      StyleSheet(const Resource& res, Block_Obj root);
+
+      // Copy constructor
+      StyleSheet(const StyleSheet& res);
+
+  };
+
+
+}
+
+#endif

data/ext/libsass/src/to_value.cpp

@@ -0,0 +1,114 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "ast.hpp"
+#include "to_value.hpp"
+
+namespace Sass {
+
+  // Custom_Error is a valid value
+  Value* To_Value::operator()(Custom_Error* e)
+  {
+    return e;
+  }
+
+  // Custom_Warning is a valid value
+  Value* To_Value::operator()(Custom_Warning* w)
+  {
+    return w;
+  }
+
+  // Boolean is a valid value
+  Value* To_Value::operator()(Boolean* b)
+  {
+    return b;
+  }
+
+  // Number is a valid value
+  Value* To_Value::operator()(Number* n)
+  {
+    return n;
+  }
+
+  // Color is a valid value
+  Value* To_Value::operator()(Color_RGBA* c)
+  {
+    return c;
+  }
+
+  // Color is a valid value
+  Value* To_Value::operator()(Color_HSLA* c)
+  {
+    return c;
+  }
+
+  // String_Constant is a valid value
+  Value* To_Value::operator()(String_Constant* s)
+  {
+    return s;
+  }
+
+  // String_Quoted is a valid value
+  Value* To_Value::operator()(String_Quoted* s)
+  {
+    return s;
+  }
+
+  // List is a valid value
+  Value* To_Value::operator()(List* l)
+  {
+    List_Obj ll = SASS_MEMORY_NEW(List,
+                               l->pstate(),
+                               l->length(),
+                               l->separator(),
+                               l->is_arglist(),
+                               l->is_bracketed());
+    for (size_t i = 0, L = l->length(); i < L; ++i) {
+      ll->append((*l)[i]->perform(this));
+    }
+    return ll.detach();
+  }
+
+  // Map is a valid value
+  Value* To_Value::operator()(Map* m)
+  {
+    return m;
+  }
+
+  // Null is a valid value
+  Value* To_Value::operator()(Null* n)
+  {
+    return n;
+  }
+
+  // Function is a valid value
+  Value* To_Value::operator()(Function* n)
+  {
+    return n;
+  }
+
+  // Argument returns its value
+  Value* To_Value::operator()(Argument* arg)
+  {
+    if (!arg->name().empty()) return 0;
+    return arg->value()->perform(this);
+  }
+
+  // SelectorList is converted to a string
+  Value* To_Value::operator()(SelectorList* s)
+  {
+    return SASS_MEMORY_NEW(String_Quoted,
+                           s->pstate(),
+                           s->to_string(ctx.c_options));
+  }
+
+  // Binary_Expression is converted to a string
+  Value* To_Value::operator()(Binary_Expression* s)
+  {
+    return SASS_MEMORY_NEW(String_Quoted,
+                           s->pstate(),
+                           s->to_string(ctx.c_options));
+  }
+
+};

data/ext/libsass/src/to_value.hpp

@@ -0,0 +1,46 @@
+#ifndef SASS_TO_VALUE_H
+#define SASS_TO_VALUE_H
+
+#include "operation.hpp"
+#include "sass/values.h"
+#include "ast_fwd_decl.hpp"
+
+namespace Sass {
+
+  class To_Value : public Operation_CRTP<Value*, To_Value> {
+
+  private:
+
+    Context& ctx;
+
+  public:
+
+    To_Value(Context& ctx)
+    : ctx(ctx)
+    { }
+    ~To_Value() { }
+    using Operation<Value*>::operator();
+
+    Value* operator()(Argument*);
+    Value* operator()(Boolean*);
+    Value* operator()(Number*);
+    Value* operator()(Color_RGBA*);
+    Value* operator()(Color_HSLA*);
+    Value* operator()(String_Constant*);
+    Value* operator()(String_Quoted*);
+    Value* operator()(Custom_Warning*);
+    Value* operator()(Custom_Error*);
+    Value* operator()(List*);
+    Value* operator()(Map*);
+    Value* operator()(Null*);
+    Value* operator()(Function*);
+
+    // convert to string via `To_String`
+    Value* operator()(SelectorList*);
+    Value* operator()(Binary_Expression*);
+
+  };
+
+}
+
+#endif