Implement custom headers (experimental)

Custom headers are very similar to importers, but are run
once at the start of each compile. This way a plugin can
define custom mixins or insert css-code at the top of each
output. Custom headers are excluded from `included_files`.

Author: mgreter

context.cpp

@@ -51,10 +51,11 @@ namespace Sass {
   }
 
   inline bool sort_importers (const Sass_Importer_Entry& i, const Sass_Importer_Entry& j)
-  { return sass_importer_get_priority(i) < sass_importer_get_priority(j); }
+  { return sass_importer_get_priority(i) > sass_importer_get_priority(j); }
 
   Context::Context(Context::Data initializers)
   : // Output(this),
+    head_imports(0),
     mem(Memory_Manager<AST_Node>()),
     c_options               (initializers.c_options()),
     c_compiler              (initializers.c_compiler()),
@@ -65,8 +66,9 @@ namespace Sass {
     queue                   (vector<Sass_Queued>()),
     style_sheets            (map<string, Block*>()),
     emitter (this),
-    c_functions             (vector<Sass_Function_Entry>()),
+    c_headers               (vector<Sass_Importer_Entry>()),
     c_importers             (vector<Sass_Importer_Entry>()),
+    c_functions             (vector<Sass_Function_Entry>()),
     indent                  (initializers.indent()),
     linefeed                (initializers.linefeed()),
     input_path              (make_canonical_path(initializers.input_path())),
@@ -108,10 +110,14 @@ namespace Sass {
     for(auto fn : plugins.get_functions()) {
       c_functions.push_back(fn);
     }
+    for(auto fn : plugins.get_headers()) {
+      c_headers.push_back(fn);
+    }
     for(auto fn : plugins.get_importers()) {
       c_importers.push_back(fn);
     }
 
+    sort (c_headers.begin(), c_headers.end(), sort_importers);
     sort (c_importers.begin(), c_importers.end(), sort_importers);
     string entry_point = initializers.entry_point();
     if (!entry_point.empty()) {
@@ -129,6 +135,12 @@ namespace Sass {
   {
     c_functions.push_back(function);
   }
+  void Context::add_c_header(Sass_Importer_Entry header)
+  {
+    c_headers.push_back(header);
+    // need to sort the array afterwards (no big deal)
+    sort (c_headers.begin(), c_headers.end(), sort_importers);
+  }
   void Context::add_c_importer(Sass_Importer_Entry importer)
   {
     c_importers.push_back(importer);
@@ -394,7 +406,9 @@ namespace Sass {
   std::vector<std::string> Context::get_included_files(size_t skip)
   {
       vector<string> includes = included_files;
+      if (includes.size() == 0) return includes;
       std::sort( includes.begin() + skip, includes.end() );
+      includes.erase( includes.begin(), includes.begin() + skip );
       includes.erase( std::unique( includes.begin(), includes.end() ), includes.end() );
       // the skip solution seems more robust, as we may have real files named stdin
       // includes.erase( std::remove( includes.begin(), includes.end(), "stdin" ), includes.end() );

context.hpp

@@ -32,6 +32,7 @@ namespace Sass {
 
   class Context {
   public:
+    size_t head_imports;
     Memory_Manager<AST_Node> mem;
 
     struct Sass_Options* c_options;
@@ -54,11 +55,13 @@ namespace Sass {
     // SourceMap source_map;
     Output emitter;
 
-    vector<Sass_Function_Entry> c_functions;
+    vector<Sass_Importer_Entry> c_headers;
     vector<Sass_Importer_Entry> c_importers;
+    vector<Sass_Function_Entry> c_functions;
 
-    void add_c_function(Sass_Function_Entry function);
+    void add_c_header(Sass_Importer_Entry header);
     void add_c_importer(Sass_Importer_Entry importer);
+    void add_c_function(Sass_Function_Entry function);
 
     string       indent; // String to be used for indentation
     string       linefeed; // String to be used for line feeds

parser.cpp

@@ -63,6 +63,20 @@ namespace Sass {
     block_stack.push_back(root);
     root->is_root(true);
     read_bom();
+
+    if (ctx.queue.size() == 1) {
+      Import* pre = new (ctx.mem) Import(pstate);
+      string load_path(ctx.queue[0].load_path);
+      do_import(load_path, pre, ctx.c_headers, false);
+      ctx.head_imports = ctx.queue.size() - 1;
+      if (!pre->urls().empty()) (*root) << pre;
+      if (!pre->files().empty()) {
+        for (size_t i = 0, S = pre->files().size(); i < S; ++i) {
+          (*root) << new (ctx.mem) Import_Stub(pstate, pre->files()[i]);
+        }
+      }
+    }
+
     lex< optional_spaces >();
     Selector_Lookahead lookahead_result;
     while (position < end) {
@@ -193,6 +207,52 @@ namespace Sass {
 
   }
 
+  bool Parser::do_import(const string& import_path, Import* imp, vector<Sass_Importer_Entry> importers, bool only_one)
+  {
+    bool has_import = false;
+    string load_path = unquote(import_path);
+    for (auto importer : importers) {
+      // int priority = sass_importer_get_priority(importer);
+      Sass_Importer_Fn fn = sass_importer_get_function(importer);
+      if (Sass_Import_List includes =
+          fn(load_path.c_str(), importer, ctx.c_compiler)
+      ) {
+        Sass_Import_List list = includes;
+        while (*includes) {
+          Sass_Import_Entry include = *includes;
+          const char *file = sass_import_get_path(include);
+          char* source = sass_import_take_source(include);
+          size_t line = sass_import_get_error_line(include);
+          size_t column = sass_import_get_error_column(include);
+          const char* message = sass_import_get_error_message(include);
+          if (message) {
+            if (line == string::npos && column == string::npos) error(message, pstate);
+            else error(message, ParserState(message, source, Position(line, column)));
+          } else if (source) {
+            if (file) {
+              ctx.add_source(file, load_path, source);
+              imp->files().push_back(file);
+            } else {
+              ctx.add_source(load_path, load_path, source);
+              imp->files().push_back(load_path);
+            }
+          } else if(file) {
+            import_single_file(imp, file);
+          }
+          ++includes;
+        }
+        // deallocate returned memory
+        sass_delete_import_list(list);
+        // set success flag
+        has_import = true;
+        // break import chain
+        if (only_one) return true;
+      }
+    }
+    // return result
+    return has_import;
+  }
+
   Import* Parser::parse_import()
   {
     lex< kwd_import >();
@@ -201,52 +261,11 @@ namespace Sass {
     do {
       while (lex< block_comment >());
       if (lex< quoted_string >()) {
-        string import_path(lexed);
-        bool has_custom_import = false;
-        string load_path = unquote(import_path);
-        for (auto importer : ctx.c_importers) {
-          if (has_custom_import) break;
-          Sass_Importer_Fn fn = sass_importer_get_function(importer);
-          // int priority = sass_importer_get_priority(importer);
-          if (Sass_Import_List includes =
-              fn(load_path.c_str(), importer, ctx.c_compiler)
-          ) {
-            Sass_Import_List list = includes;
-            while (*includes) {
-              Sass_Import_Entry include = *includes;
-              const char *file = sass_import_get_path(include);
-              char* source = sass_import_take_source(include);
-              size_t line = sass_import_get_error_line(include);
-              size_t column = sass_import_get_error_column(include);
-              const char* message = sass_import_get_error_message(include);
-              if (message) {
-                if (line == string::npos && column == string::npos) error(message, pstate);
-                else error(message, ParserState(message, source, Position(line, column)));
-              } else if (source) {
-                if (file) {
-                  ctx.add_source(file, load_path, source);
-                  imp->files().push_back(file);
-                } else {
-                  ctx.add_source(load_path, load_path, source);
-                  imp->files().push_back(load_path);
-                }
-              } else if(file) {
-                import_single_file(imp, file);
-              }
-              ++includes;
-            }
-            // deallocate returned memory
-            sass_delete_import_list(list);
-            // break import chain
-            has_custom_import = true;
-          }
-        }
-
-        if (!has_custom_import) {
+        if (!do_import(lexed, imp, ctx.c_importers, true))
+        {
           // push single file import
-          import_single_file(imp, import_path);
+          import_single_file(imp, lexed);
         }
-
       }
       else if (peek< uri_prefix >()) {
         imp->urls().push_back(parse_value());

parser.hpp

@@ -30,6 +30,7 @@ namespace Sass {
     class AST_Node;
 
     enum Syntactic_Context { nothing, mixin_def, function_def };
+    bool do_import(const string& import_path, Import* imp, vector<Sass_Importer_Entry> importers, bool only_one = true);
 
     Context& ctx;
     vector<Block*> block_stack;

plugins.cpp

@@ -67,6 +67,12 @@ namespace Sass {
           Sass_Importer_List imps = plugin_load_importers();
           while (imps && *imps) { importers.push_back(*imps); ++ imps; }
         }
+        // try to get import address for "libsass_load_headers"
+        if (LOAD_LIB_FN(__plugin_load_imps__, plugin_load_headers, "libsass_load_headers"))
+        {
+          Sass_Importer_List imps = plugin_load_headers();
+          while (imps && *imps) { headers.push_back(*imps); ++ imps; }
+        }
         // success
         return true;
       }

plugins.hpp

@@ -42,10 +42,12 @@ namespace Sass {
       size_t load_plugins(const string& path);
 
     public: // public accessors
+      const vector<Sass_Importer_Entry> get_headers(void) { return headers; };
       const vector<Sass_Importer_Entry> get_importers(void) { return importers; };
       const vector<Sass_Function_Entry> get_functions(void) { return functions; };
 
     private: // private vars
+      vector<Sass_Importer_Entry> headers;
       vector<Sass_Importer_Entry> importers;
       vector<Sass_Function_Entry> functions;
 

sass_context.cpp

@@ -102,9 +102,12 @@ extern "C" {
     // Custom functions that can be called from sccs code
     Sass_Function_List c_functions;
 
-    // Callback to overload imports
+    // List of custom importers
     Sass_Importer_List c_importers;
 
+    // List of custom headers
+    Sass_Importer_List c_headers;
+
   };
 
   // base for all contexts
@@ -185,19 +188,19 @@ extern "C" {
     return str == NULL ? "" : str;
   }
 
-  static void copy_strings(const std::vector<std::string>& strings, char*** array, int skip = 0) throw() {
+  static void copy_strings(const std::vector<std::string>& strings, char*** array) throw() {
     int num = static_cast<int>(strings.size());
     char** arr = (char**) malloc(sizeof(char*) * (num + 1));
     if (arr == 0) throw(bad_alloc());
 
-    for(int i = skip; i < num; i++) {
-      arr[i-skip] = (char*) malloc(sizeof(char) * (strings[i].size() + 1));
-      if (arr[i-skip] == 0) throw(bad_alloc());
-      std::copy(strings[i].begin(), strings[i].end(), arr[i-skip]);
-      arr[i-skip][strings[i].size()] = '\0';
+    for(int i = 0; i < num; i++) {
+      arr[i] = (char*) malloc(sizeof(char) * (strings[i].size() + 1));
+      if (arr[i] == 0) throw(bad_alloc());
+      std::copy(strings[i].begin(), strings[i].end(), arr[i]);
+      arr[i][strings[i].size()] = '\0';
     }
 
-    arr[num-skip] = 0;
+    arr[num] = 0;
     *array = arr;
   }
 
@@ -420,6 +423,15 @@ extern "C" {
         }
       }
 
+      // register our custom headers
+      if (c_ctx->c_headers) {
+        auto this_head_data = c_ctx->c_headers;
+        while (this_head_data && *this_head_data) {
+          cpp_ctx->add_c_header(*this_head_data);
+          ++this_head_data;
+        }
+      }
+
       // register our custom importers
       if (c_ctx->c_importers) {
         auto this_imp_data = c_ctx->c_importers;
@@ -475,8 +487,11 @@ extern "C" {
         skip = 1; // skip first entry of includes
       }
 
+      // skip all prefixed files?
+      skip += cpp_ctx->head_imports;
+
       // copy the included files on to the context (dont forget to free)
-      if (root) copy_strings(cpp_ctx->get_included_files(skip), &c_ctx->included_files, skip);
+      if (root) copy_strings(cpp_ctx->get_included_files(skip), &c_ctx->included_files);
 
       // return parsed block
       return root;
@@ -674,15 +689,23 @@ extern "C" {
     if (options == 0) return;
     // Deallocate custom functions
     if (options->c_functions) {
-      struct Sass_Function** this_func_data = options->c_functions;
+      Sass_Function_List this_func_data = options->c_functions;
       while (this_func_data && *this_func_data) {
         free(*this_func_data);
         ++this_func_data;
       }
     }
+    // Deallocate custom headers
+    if (options->c_headers) {
+      Sass_Importer_List this_head_data = options->c_headers;
+      while (this_head_data && *this_head_data) {
+        free(*this_head_data);
+        ++this_head_data;
+      }
+    }
     // Deallocate custom importers
     if (options->c_importers) {
-      struct Sass_Importer** this_imp_data = options->c_importers;
+      Sass_Importer_List this_imp_data = options->c_importers;
       while (this_imp_data && *this_imp_data) {
         free(*this_imp_data);
         ++this_imp_data;
@@ -716,9 +739,11 @@ extern "C" {
     free(options->c_functions);
     // Free custom importers
     free(options->c_importers);
+    free(options->c_headers);
     // Reset our pointers
     options->c_functions = 0;
     options->c_importers = 0;
+    options->c_headers = 0;
     options->plugin_paths = 0;
     options->include_paths = 0;
   }
@@ -800,6 +825,7 @@ extern "C" {
   IMPLEMENT_SASS_OPTION_ACCESSOR(bool, is_indented_syntax_src);
   IMPLEMENT_SASS_OPTION_ACCESSOR(Sass_Function_List, c_functions);
   IMPLEMENT_SASS_OPTION_ACCESSOR(Sass_Importer_List, c_importers);
+  IMPLEMENT_SASS_OPTION_ACCESSOR(Sass_Importer_List, c_headers);
   IMPLEMENT_SASS_OPTION_ACCESSOR(const char*, indent);
   IMPLEMENT_SASS_OPTION_ACCESSOR(const char*, linefeed);
   IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, input_path);

sass_context.h

@@ -81,8 +81,9 @@ ADDAPI const char* ADDCALL sass_option_get_plugin_path (struct Sass_Options* opt
 ADDAPI const char* ADDCALL sass_option_get_include_path (struct Sass_Options* options);
 ADDAPI const char* ADDCALL sass_option_get_source_map_file (struct Sass_Options* options);
 ADDAPI const char* ADDCALL sass_option_get_source_map_root (struct Sass_Options* options);
-ADDAPI Sass_Function_List ADDCALL sass_option_get_c_functions (struct Sass_Options* options);
+ADDAPI Sass_Importer_List ADDCALL sass_option_get_c_headers (struct Sass_Options* options);
 ADDAPI Sass_Importer_List ADDCALL sass_option_get_c_importers (struct Sass_Options* options);
+ADDAPI Sass_Function_List ADDCALL sass_option_get_c_functions (struct Sass_Options* options);
 
 // Setters for Context_Option values
 ADDAPI void ADDCALL sass_option_set_precision (struct Sass_Options* options, int precision);
@@ -100,8 +101,9 @@ ADDAPI void ADDCALL sass_option_set_plugin_path (struct Sass_Options* options, c
 ADDAPI void ADDCALL sass_option_set_include_path (struct Sass_Options* options, const char* include_path);
 ADDAPI void ADDCALL sass_option_set_source_map_file (struct Sass_Options* options, const char* source_map_file);
 ADDAPI void ADDCALL sass_option_set_source_map_root (struct Sass_Options* options, const char* source_map_root);
-ADDAPI void ADDCALL sass_option_set_c_functions (struct Sass_Options* options, Sass_Function_List c_functions);
+ADDAPI void ADDCALL sass_option_set_c_headers (struct Sass_Options* options, Sass_Importer_List c_headers);
 ADDAPI void ADDCALL sass_option_set_c_importers (struct Sass_Options* options, Sass_Importer_List c_importers);
+ADDAPI void ADDCALL sass_option_set_c_functions (struct Sass_Options* options, Sass_Function_List c_functions);
 
 
 // Getters for Sass_Context values

sass_functions.h

@@ -31,7 +31,7 @@ typedef Sass_Import_List (*Sass_Importer_Fn)
 typedef struct Sass_Function (*Sass_Function_Entry);
 typedef struct Sass_Function* (*Sass_Function_List);
 // Typedef defining function signature and return type
-typedef union Sass_Value*(*Sass_Function_Fn)
+typedef union Sass_Value* (*Sass_Function_Fn)
   (const union Sass_Value*, Sass_Function_Entry cb, struct Sass_Options* options);